1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
31 #define INCLUDE_JTAG_INTERFACE_H
33 #include "minidriver.h"
40 int jtag_flush_queue_count
; /* count # of flushes for profiling / debugging purposes */
42 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
43 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
);
45 /* note that this is not marked as static as it must be available from outside jtag.c for those
46 that implement the jtag_xxx() minidriver layer
48 int jtag_error
=ERROR_OK
;
50 typedef struct cmd_queue_page_s
54 struct cmd_queue_page_s
*next
;
57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
58 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
60 char* jtag_event_strings
[] =
62 "JTAG controller reset (RESET or TRST)"
65 const Jim_Nvp nvp_jtag_tap_event
[] = {
66 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
67 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
69 { .name
= NULL
, .value
= -1 }
75 jtag_command_t
*jtag_command_queue
= NULL
;
76 static jtag_command_t
**next_command_pointer
= &jtag_command_queue
;
77 static jtag_tap_t
*jtag_all_taps
= NULL
;
79 enum reset_types jtag_reset_config
= RESET_NONE
;
80 tap_state_t cmd_queue_end_state
= TAP_RESET
;
81 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
83 int jtag_verify_capture_ir
= 1;
86 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
87 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
88 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
90 /* maximum number of JTAG devices expected in the chain
92 #define JTAG_MAX_CHAIN_SIZE 20
94 /* callbacks to inform high-level handlers about JTAG state changes */
95 jtag_event_callback_t
*jtag_event_callbacks
;
98 static int speed_khz
= 0;
99 /* flag if the kHz speed was defined */
100 static int hasKHz
= 0;
102 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
105 #if BUILD_ECOSBOARD == 1
106 extern jtag_interface_t zy1000_interface
;
109 #if BUILD_PARPORT == 1
110 extern jtag_interface_t parport_interface
;
114 extern jtag_interface_t dummy_interface
;
117 #if BUILD_FT2232_FTD2XX == 1
118 extern jtag_interface_t ft2232_interface
;
121 #if BUILD_FT2232_LIBFTDI == 1
122 extern jtag_interface_t ft2232_interface
;
125 #if BUILD_AMTJTAGACCEL == 1
126 extern jtag_interface_t amt_jtagaccel_interface
;
129 #if BUILD_EP93XX == 1
130 extern jtag_interface_t ep93xx_interface
;
133 #if BUILD_AT91RM9200 == 1
134 extern jtag_interface_t at91rm9200_interface
;
137 #if BUILD_GW16012 == 1
138 extern jtag_interface_t gw16012_interface
;
141 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
142 extern jtag_interface_t presto_interface
;
145 #if BUILD_USBPROG == 1
146 extern jtag_interface_t usbprog_interface
;
150 extern jtag_interface_t jlink_interface
;
153 #if BUILD_VSLLINK == 1
154 extern jtag_interface_t vsllink_interface
;
158 extern jtag_interface_t rlink_interface
;
161 #if BUILD_ARMJTAGEW == 1
162 extern jtag_interface_t armjtagew_interface
;
165 jtag_interface_t
*jtag_interfaces
[] = {
166 #if BUILD_ECOSBOARD == 1
169 #if BUILD_PARPORT == 1
175 #if BUILD_FT2232_FTD2XX == 1
178 #if BUILD_FT2232_LIBFTDI == 1
181 #if BUILD_AMTJTAGACCEL == 1
182 &amt_jtagaccel_interface
,
184 #if BUILD_EP93XX == 1
187 #if BUILD_AT91RM9200 == 1
188 &at91rm9200_interface
,
190 #if BUILD_GW16012 == 1
193 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
196 #if BUILD_USBPROG == 1
202 #if BUILD_VSLLINK == 1
208 #if BUILD_ARMJTAGEW == 1
209 &armjtagew_interface
,
214 struct jtag_interface_s
*jtag
= NULL
;
217 static jtag_interface_t
*jtag_interface
= NULL
;
221 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
222 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
223 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
224 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
225 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
226 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
227 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
229 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
231 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
232 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
233 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
234 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
235 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
236 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
238 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
239 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
240 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
242 jtag_tap_t
*jtag_AllTaps(void)
244 return jtag_all_taps
;
247 int jtag_NumTotalTaps(void)
261 int jtag_NumEnabledTaps(void)
277 jtag_tap_t
*jtag_TapByString( const char *s
)
285 if( 0 == strcmp( t
->dotted_name
, s
) ){
291 /* backup plan is by number */
293 /* ok - is "s" a number? */
295 n
= strtol( s
, &cp
, 0 );
296 if( (s
!= cp
) && (*cp
== 0) ){
298 t
= jtag_TapByAbsPosition(n
);
304 jtag_tap_t
* jtag_TapByJimObj( Jim_Interp
*interp
, Jim_Obj
*o
)
309 cp
= Jim_GetString( o
, NULL
);
314 t
= jtag_TapByString( cp
);
317 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
322 /* returns a pointer to the n-th device in the scan chain */
323 jtag_tap_t
* jtag_TapByAbsPosition( int n
)
331 while( t
&& (n
> 0)) {
338 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
340 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
342 if (callback
== NULL
)
344 return ERROR_INVALID_ARGUMENTS
;
349 while ((*callbacks_p
)->next
)
350 callbacks_p
= &((*callbacks_p
)->next
);
351 callbacks_p
= &((*callbacks_p
)->next
);
354 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
355 (*callbacks_p
)->callback
= callback
;
356 (*callbacks_p
)->priv
= priv
;
357 (*callbacks_p
)->next
= NULL
;
362 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
364 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
366 if (callback
== NULL
)
368 return ERROR_INVALID_ARGUMENTS
;
373 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
374 if ((*callbacks_p
)->callback
== callback
)
377 *callbacks_p
= *next
;
385 int jtag_call_event_callbacks(enum jtag_event event
)
387 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
389 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
393 callback
->callback(event
, callback
->priv
);
394 callback
= callback
->next
;
400 void jtag_queue_command(jtag_command_t
* cmd
)
402 // this command goes on the end, so ensure the queue terminates
405 jtag_command_t
**last_cmd
= next_command_pointer
;
406 assert(NULL
!= last_cmd
);
407 assert(NULL
== *last_cmd
);
410 // store location where the next command pointer will be stored
411 next_command_pointer
= &cmd
->next
;
414 void* cmd_queue_alloc(size_t size
)
416 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
422 * We align/round the *SIZE* per below
423 * so that all pointers returned by
424 * this function are reasonably well
427 * If we did not, then an "odd-length" request would cause the
428 * *next* allocation to be at an *odd* address, and because
429 * this function has the same type of api as malloc() - we
430 * must also return pointers that have the same type of
433 * What I do not/have is a reasonable portable means
436 * The solution here, is based on these suggestions.
437 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
440 union worse_case_align
{
446 #define ALIGN_SIZE (sizeof(union worse_case_align))
448 /* The alignment process. */
449 size
= (size
+ ALIGN_SIZE
-1) & (~(ALIGN_SIZE
-1));
454 while ((*p_page
)->next
)
455 p_page
= &((*p_page
)->next
);
456 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
457 p_page
= &((*p_page
)->next
);
462 *p_page
= malloc(sizeof(cmd_queue_page_t
));
464 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
465 (*p_page
)->next
= NULL
;
468 offset
= (*p_page
)->used
;
469 (*p_page
)->used
+= size
;
471 t
=(u8
*)((*p_page
)->address
);
475 void cmd_queue_free(void)
477 cmd_queue_page_t
*page
= cmd_queue_pages
;
481 cmd_queue_page_t
*last
= page
;
487 cmd_queue_pages
= NULL
;
490 void jtag_command_queue_reset(void)
494 jtag_command_queue
= NULL
;
495 next_command_pointer
= &jtag_command_queue
;
498 static void jtag_prelude1(void)
502 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
503 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
507 if (cmd_queue_end_state
== TAP_RESET
)
508 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
511 static void jtag_prelude(tap_state_t state
)
515 if (state
!= TAP_INVALID
)
516 jtag_add_end_state(state
);
518 cmd_queue_cur_state
= cmd_queue_end_state
;
521 void jtag_alloc_in_value32(scan_field_t
*field
)
523 interface_jtag_alloc_in_value32(field
);
526 void jtag_add_ir_scan_noverify(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
531 retval
=interface_jtag_add_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
532 if (retval
!=ERROR_OK
)
539 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
541 * If the input field list contains an instruction value for a TAP then that is used
542 * otherwise the TAP is set to bypass.
544 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
547 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
549 if (jtag_verify
&&jtag_verify_capture_ir
)
551 /* 8 x 32 bit id's is enough for all invocations */
553 for (int j
= 0; j
< in_num_fields
; j
++)
555 /* if we are to run a verification of the ir scan, we need to get the input back.
556 * We may have to allocate space if the caller didn't ask for the input back.
558 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
559 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
561 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
564 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
569 * Duplicate the scan fields passed into the function into an IR SCAN command
571 * This function assumes that the caller handles extra fields for bypassed TAPs
574 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
580 retval
=interface_jtag_add_plain_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
581 if (retval
!=ERROR_OK
)
585 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
587 interface_jtag_add_callback(f
, in
);
590 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
591 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
592 jtag_callback_data_t data3
)
594 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
597 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
599 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
601 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
604 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
605 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
607 for (int i
= 0; i
< in_num_fields
; i
++)
609 struct scan_field_s
*field
= &in_fields
[i
];
610 field
->allocated
= 0;
612 if (field
->check_value
|| field
->in_value
)
614 interface_jtag_add_scan_check_alloc(field
);
618 jtag_add_scan(in_num_fields
, in_fields
, state
);
620 for (int i
= 0; i
< in_num_fields
; i
++)
622 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
624 /* this is synchronous for a minidriver */
625 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
626 (jtag_callback_data_t
)in_fields
[i
].check_value
,
627 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
628 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
630 if (in_fields
[i
].allocated
)
632 free(in_fields
[i
].in_value
);
634 if (in_fields
[i
].modified
)
636 in_fields
[i
].in_value
= NULL
;
641 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
645 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
648 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
654 * Generate a DR SCAN using the fields passed to the function
656 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
657 * For bypassed TAPs the function generates a dummy 1bit field.
659 * The bypass status of TAPs is set by jtag_add_ir_scan().
662 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
668 retval
=interface_jtag_add_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
669 if (retval
!=ERROR_OK
)
676 * Duplicate the scan fields passed into the function into a DR SCAN command
678 * This function assumes that the caller handles extra fields for bypassed TAPs
681 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
687 retval
=interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
688 if (retval
!=ERROR_OK
)
692 void jtag_add_dr_out(jtag_tap_t
* tap
,
693 int num_fields
, const int* num_bits
, const u32
* value
,
694 tap_state_t end_state
)
696 if (end_state
!= TAP_INVALID
)
697 cmd_queue_end_state
= end_state
;
699 cmd_queue_cur_state
= cmd_queue_end_state
;
701 interface_jtag_add_dr_out(tap
,
702 num_fields
, num_bits
, value
,
703 cmd_queue_end_state
);
706 void jtag_add_tlr(void)
708 jtag_prelude(TAP_RESET
);
711 retval
=interface_jtag_add_tlr();
712 if (retval
!=ERROR_OK
)
716 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
718 tap_state_t cur_state
= cmd_queue_cur_state
;
722 /* the last state has to be a stable state */
723 if (!tap_is_state_stable(path
[num_states
- 1]))
725 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
729 for (i
=0; i
<num_states
; i
++)
731 if (path
[i
] == TAP_RESET
)
733 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
737 if ( tap_state_transition(cur_state
, true) != path
[i
]
738 && tap_state_transition(cur_state
, false) != path
[i
])
740 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[i
]));
748 retval
= interface_jtag_add_pathmove(num_states
, path
);
749 cmd_queue_cur_state
= path
[num_states
- 1];
750 if (retval
!=ERROR_OK
)
754 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
760 /* executed by sw or hw fifo */
761 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
762 if (retval
!=ERROR_OK
)
767 void jtag_add_clocks( int num_cycles
)
771 if( !tap_is_state_stable(cmd_queue_cur_state
) )
773 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
774 tap_state_name(cmd_queue_cur_state
) );
775 jtag_error
= ERROR_JTAG_NOT_STABLE_STATE
;
783 retval
= interface_jtag_add_clocks(num_cycles
);
784 if (retval
!= ERROR_OK
)
789 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
791 int trst_with_tlr
= 0;
794 /* FIX!!! there are *many* different cases here. A better
795 * approach is needed for legal combinations of transitions...
797 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
798 (jtag_reset_config
& RESET_HAS_TRST
)&&
799 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
801 if (((req_tlr_or_trst
&&!jtag_trst
)||
802 (!req_tlr_or_trst
&&jtag_trst
))&&
803 ((req_srst
&&!jtag_srst
)||
804 (!req_srst
&&jtag_srst
)))
806 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
807 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
811 /* Make sure that jtag_reset_config allows the requested reset */
812 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
813 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
815 LOG_ERROR("BUG: requested reset would assert trst");
816 jtag_error
=ERROR_FAIL
;
820 /* if TRST pulls SRST, we reset with TAP T-L-R */
821 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
826 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
828 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
829 jtag_error
=ERROR_FAIL
;
835 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
847 jtag_srst
= req_srst
;
849 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
850 if (retval
!=ERROR_OK
)
855 jtag_execute_queue();
859 LOG_DEBUG("SRST line asserted");
863 LOG_DEBUG("SRST line released");
864 if (jtag_nsrst_delay
)
865 jtag_add_sleep(jtag_nsrst_delay
* 1000);
870 LOG_DEBUG("JTAG reset with RESET instead of TRST");
871 jtag_add_end_state(TAP_RESET
);
873 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
879 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
880 * and inform possible listeners about this
882 LOG_DEBUG("TRST line asserted");
883 tap_set_state(TAP_RESET
);
884 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
888 if (jtag_ntrst_delay
)
889 jtag_add_sleep(jtag_ntrst_delay
* 1000);
893 void jtag_add_end_state(tap_state_t state
)
895 cmd_queue_end_state
= state
;
896 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
898 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
902 void jtag_add_sleep(u32 us
)
904 keep_alive(); /* we might be running on a very slow JTAG clk */
905 int retval
=interface_jtag_add_sleep(us
);
906 if (retval
!=ERROR_OK
)
911 int jtag_scan_size(const scan_command_t
*cmd
)
916 /* count bits in scan command */
917 for (i
= 0; i
< cmd
->num_fields
; i
++)
919 bit_count
+= cmd
->fields
[i
].num_bits
;
925 int jtag_build_buffer(const scan_command_t
*cmd
, u8
**buffer
)
930 bit_count
= jtag_scan_size(cmd
);
931 *buffer
= calloc(1,CEIL(bit_count
, 8));
935 #ifdef _DEBUG_JTAG_IO_
936 LOG_DEBUG("%s num_fields: %i", cmd
->ir_scan
? "IRSCAN" : "DRSCAN", cmd
->num_fields
);
939 for (i
= 0; i
< cmd
->num_fields
; i
++)
941 if (cmd
->fields
[i
].out_value
)
943 #ifdef _DEBUG_JTAG_IO_
944 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: cmd
->fields
[i
].num_bits
, 16);
946 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
947 #ifdef _DEBUG_JTAG_IO_
948 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i
, cmd
->fields
[i
].num_bits
, char_buf
);
954 #ifdef _DEBUG_JTAG_IO_
955 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i
, cmd
->fields
[i
].num_bits
);
959 bit_count
+= cmd
->fields
[i
].num_bits
;
962 #ifdef _DEBUG_JTAG_IO_
963 //LOG_DEBUG("bit_count totalling: %i", bit_count );
969 int jtag_read_buffer(u8
*buffer
, const scan_command_t
*cmd
)
975 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
978 for (i
= 0; i
< cmd
->num_fields
; i
++)
980 /* if neither in_value nor in_handler
981 * are specified we don't have to examine this field
983 if (cmd
->fields
[i
].in_value
)
985 int num_bits
= cmd
->fields
[i
].num_bits
;
986 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
988 #ifdef _DEBUG_JTAG_IO_
989 char *char_buf
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
990 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i
, num_bits
, char_buf
);
994 if (cmd
->fields
[i
].in_value
)
996 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1001 bit_count
+= cmd
->fields
[i
].num_bits
;
1007 static const char *jtag_tap_name(const jtag_tap_t
*tap
)
1009 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
1012 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
1014 int retval
= ERROR_OK
;
1016 int compare_failed
= 0;
1019 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
1021 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
1023 if (compare_failed
){
1024 /* An error handler could have caught the failing check
1025 * only report a problem when there wasn't a handler, or if the handler
1026 * acknowledged the error
1029 LOG_WARNING("TAP %s:",
1030 jtag_tap_name(field->tap));
1034 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1035 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1039 char *in_check_mask_char
;
1040 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1041 LOG_WARNING("value captured during scan didn't pass the requested check:");
1042 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1043 captured_char
, in_check_value_char
, in_check_mask_char
);
1044 free(in_check_mask_char
);
1048 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1051 free(captured_char
);
1052 free(in_check_value_char
);
1054 retval
= ERROR_JTAG_QUEUE_FAILED
;
1061 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
1063 assert(field
->in_value
!= NULL
);
1067 /* no checking to do */
1071 jtag_execute_queue_noclear();
1073 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
1074 jtag_set_error(retval
);
1079 enum scan_type
jtag_scan_type(const scan_command_t
*cmd
)
1084 for (i
= 0; i
< cmd
->num_fields
; i
++)
1086 if (cmd
->fields
[i
].in_value
)
1088 if (cmd
->fields
[i
].out_value
)
1095 int default_interface_jtag_execute_queue(void)
1099 LOG_ERROR("No JTAG interface configured yet. "
1100 "Issue 'init' command in startup scripts "
1101 "before communicating with targets.");
1105 return jtag
->execute_queue();
1108 void jtag_execute_queue_noclear(void)
1110 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1111 * E.g. a JTAG over TCP/IP or USB....
1113 jtag_flush_queue_count
++;
1115 int retval
=interface_jtag_execute_queue();
1116 /* we keep the first error */
1117 if ((jtag_error
==ERROR_OK
)&&(retval
!=ERROR_OK
))
1123 int jtag_execute_queue(void)
1126 jtag_execute_queue_noclear();
1128 jtag_error
=ERROR_OK
;
1132 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1134 jtag_tap_t
*tap
= priv
;
1138 if (event
== JTAG_TRST_ASSERTED
)
1140 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1147 void jtag_sleep(u32 us
)
1149 alive_sleep(us
/1000);
1152 /* Try to examine chain layout according to IEEE 1149.1 §12
1154 int jtag_examine_chain(void)
1158 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1161 int device_count
= 0;
1162 u8 zero_check
= 0x0;
1163 u8 one_check
= 0xff;
1166 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1167 field
.out_value
= idcode_buffer
;
1169 field
.in_value
= idcode_buffer
;
1174 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1176 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1179 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
1180 jtag_execute_queue();
1182 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1184 zero_check
|= idcode_buffer
[i
];
1185 one_check
&= idcode_buffer
[i
];
1188 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1189 if ((zero_check
== 0x00) || (one_check
== 0xff))
1191 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1192 return ERROR_JTAG_INIT_FAILED
;
1195 /* point at the 1st tap */
1196 tap
= jtag_NextEnabledTap(NULL
);
1198 LOG_ERROR("JTAG: No taps enabled?");
1199 return ERROR_JTAG_INIT_FAILED
;
1202 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1204 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1205 if ((idcode
& 1) == 0)
1207 /* LSB must not be 0, this indicates a device in bypass */
1208 LOG_WARNING("Tap/Device does not have IDCODE");
1219 /* some devices, such as AVR will output all 1's instead of TDI
1220 input value at end of chain. */
1221 if ((idcode
== 0x000000FF)||(idcode
== 0xFFFFFFFF))
1224 /* End of chain (invalid manufacturer ID)
1226 * The JTAG examine is the very first thing that happens
1228 * A single JTAG device requires only 64 bits to be read back correctly.
1230 * The code below adds a check that the rest of the data scanned (640 bits)
1231 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1233 * earlier and gives more helpful/explicit error messages.
1235 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1237 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1238 if (unexpected
||((idcode
!= 0x000000FF)&&(idcode
!= 0xFFFFFFFF)))
1240 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1248 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1249 manufacturer
= EXTRACT_MFG(idcode
);
1250 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1251 part
= EXTRACT_PART(idcode
);
1252 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1253 version
= EXTRACT_VER(idcode
);
1255 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1256 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1257 idcode
, manufacturer
, part
, version
);
1263 tap
->idcode
= idcode
;
1265 if (tap
->expected_ids_cnt
> 0) {
1266 /* Loop over the expected identification codes and test for a match */
1268 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1269 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1274 /* If none of the expected ids matched, log an error */
1275 if (ii
== tap
->expected_ids_cnt
) {
1276 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1279 EXTRACT_MFG( tap
->idcode
),
1280 EXTRACT_PART( tap
->idcode
),
1281 EXTRACT_VER( tap
->idcode
) );
1282 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1283 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1286 tap
->expected_ids_cnt
,
1287 tap
->expected_ids
[ii
],
1288 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1289 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1290 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1293 return ERROR_JTAG_INIT_FAILED
;
1295 LOG_INFO("JTAG Tap/device matched");
1299 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1303 tap
= jtag_NextEnabledTap(tap
);
1308 /* see if number of discovered devices matches configuration */
1309 if (device_count
!= jtag_NumEnabledTaps())
1311 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1312 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1313 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1314 return ERROR_JTAG_INIT_FAILED
;
1320 int jtag_validate_chain(void)
1323 int total_ir_length
= 0;
1329 total_ir_length
= 0;
1331 tap
= jtag_NextEnabledTap(tap
);
1335 total_ir_length
+= tap
->ir_length
;
1338 total_ir_length
+= 2;
1339 ir_test
= malloc(CEIL(total_ir_length
, 8));
1340 buf_set_ones(ir_test
, total_ir_length
);
1343 field
.num_bits
= total_ir_length
;
1344 field
.out_value
= ir_test
;
1345 field
.in_value
= ir_test
;
1348 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1349 jtag_execute_queue();
1355 tap
= jtag_NextEnabledTap(tap
);
1360 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1363 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1364 LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf
, jtag_tap_name(tap
), chain_pos
, val
);
1367 return ERROR_JTAG_INIT_FAILED
;
1369 chain_pos
+= tap
->ir_length
;
1372 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1375 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1376 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf
, chain_pos
, val
);
1379 return ERROR_JTAG_INIT_FAILED
;
1387 enum jtag_tap_cfg_param
{
1391 static Jim_Nvp nvp_config_opts
[] = {
1392 { .name
= "-event", .value
= JCFG_EVENT
},
1394 { .name
= NULL
, .value
= -1 }
1397 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1403 /* parse config or cget options */
1404 while (goi
->argc
> 0) {
1405 Jim_SetEmptyResult (goi
->interp
);
1407 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1409 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1415 if (goi
->argc
== 0) {
1416 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1420 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1422 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1426 if (goi
->isconfigure
) {
1427 if (goi
->argc
!= 1) {
1428 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1432 if (goi
->argc
!= 0) {
1433 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1439 jtag_tap_event_action_t
*jteap
;
1441 jteap
= tap
->event_action
;
1442 /* replace existing? */
1444 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1447 jteap
= jteap
->next
;
1450 if (goi
->isconfigure
) {
1451 if (jteap
== NULL
) {
1453 jteap
= calloc(1, sizeof (*jteap
));
1455 jteap
->event
= n
->value
;
1456 Jim_GetOpt_Obj( goi
, &o
);
1458 Jim_DecrRefCount(interp
, jteap
->body
);
1460 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1461 Jim_IncrRefCount(jteap
->body
);
1463 /* add to head of event list */
1464 jteap
->next
= tap
->event_action
;
1465 tap
->event_action
= jteap
;
1466 Jim_SetEmptyResult(goi
->interp
);
1469 if (jteap
== NULL
) {
1470 Jim_SetEmptyResult(goi
->interp
);
1472 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1479 } /* while (goi->argc) */
1484 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1494 const Jim_Nvp opts
[] = {
1495 #define NTAP_OPT_IRLEN 0
1496 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1497 #define NTAP_OPT_IRMASK 1
1498 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
1499 #define NTAP_OPT_IRCAPTURE 2
1500 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
1501 #define NTAP_OPT_ENABLED 3
1502 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
1503 #define NTAP_OPT_DISABLED 4
1504 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
1505 #define NTAP_OPT_EXPECTED_ID 5
1506 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
1507 { .name
= NULL
, .value
= -1 },
1510 pTap
= malloc( sizeof(jtag_tap_t
) );
1511 memset( pTap
, 0, sizeof(*pTap
) );
1513 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1517 * we expect CHIP + TAP + OPTIONS
1519 if( goi
->argc
< 3 ){
1520 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
1523 Jim_GetOpt_String( goi
, &cp
, NULL
);
1524 pTap
->chip
= strdup(cp
);
1526 Jim_GetOpt_String( goi
, &cp
, NULL
);
1527 pTap
->tapname
= strdup(cp
);
1529 /* name + dot + name + null */
1530 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
1532 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
1533 pTap
->dotted_name
= cp
;
1535 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1536 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
1538 /* default is enabled */
1541 /* deal with options */
1542 #define NTREQ_IRLEN 1
1543 #define NTREQ_IRCAPTURE 2
1544 #define NTREQ_IRMASK 4
1546 /* clear them as we find them */
1547 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
1550 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
1552 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
1555 LOG_DEBUG("Processing option: %s", n
->name
);
1557 case NTAP_OPT_ENABLED
:
1560 case NTAP_OPT_DISABLED
:
1563 case NTAP_OPT_EXPECTED_ID
:
1565 u32
*new_expected_ids
;
1567 e
= Jim_GetOpt_Wide( goi
, &w
);
1569 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
1573 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
1574 if (new_expected_ids
== NULL
) {
1575 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1579 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
1581 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
1583 free(pTap
->expected_ids
);
1584 pTap
->expected_ids
= new_expected_ids
;
1585 pTap
->expected_ids_cnt
++;
1588 case NTAP_OPT_IRLEN
:
1589 case NTAP_OPT_IRMASK
:
1590 case NTAP_OPT_IRCAPTURE
:
1591 e
= Jim_GetOpt_Wide( goi
, &w
);
1593 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
1596 if( (w
< 0) || (w
> 0xffff) ){
1598 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
1599 n
->name
, (int)(w
), (int)(w
));
1603 case NTAP_OPT_IRLEN
:
1604 pTap
->ir_length
= w
;
1605 reqbits
&= (~(NTREQ_IRLEN
));
1607 case NTAP_OPT_IRMASK
:
1608 pTap
->ir_capture_mask
= w
;
1609 reqbits
&= (~(NTREQ_IRMASK
));
1611 case NTAP_OPT_IRCAPTURE
:
1612 pTap
->ir_capture_value
= w
;
1613 reqbits
&= (~(NTREQ_IRCAPTURE
));
1616 } /* switch(n->value) */
1617 } /* while( goi->argc ) */
1619 /* Did we get all the options? */
1622 Jim_SetResult_sprintf( goi
->interp
,
1623 "newtap: %s missing required parameters",
1625 /* TODO: Tell user what is missing :-( */
1626 /* no memory leaks pelase */
1627 free(((void *)(pTap
->expected_ids
)));
1628 free(((void *)(pTap
->chip
)));
1629 free(((void *)(pTap
->tapname
)));
1630 free(((void *)(pTap
->dotted_name
)));
1631 free(((void *)(pTap
)));
1635 pTap
->expected
= malloc( pTap
->ir_length
);
1636 pTap
->expected_mask
= malloc( pTap
->ir_length
);
1637 pTap
->cur_instr
= malloc( pTap
->ir_length
);
1639 buf_set_u32( pTap
->expected
,
1642 pTap
->ir_capture_value
);
1643 buf_set_u32( pTap
->expected_mask
,
1646 pTap
->ir_capture_mask
);
1647 buf_set_ones( pTap
->cur_instr
,
1652 jtag_register_event_callback(jtag_reset_callback
, pTap
);
1654 ppTap
= &(jtag_all_taps
);
1655 while( (*ppTap
) != NULL
){
1656 ppTap
= &((*ppTap
)->next_tap
);
1660 static int n_taps
= 0;
1661 pTap
->abs_chain_position
= n_taps
++;
1663 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1664 (*ppTap
)->dotted_name
,
1665 (*ppTap
)->abs_chain_position
,
1666 (*ppTap
)->ir_length
,
1667 (*ppTap
)->ir_capture_value
,
1668 (*ppTap
)->ir_capture_mask
);
1673 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1679 struct command_context_s
*context
;
1683 JTAG_CMD_INIT_RESET
,
1686 JTAG_CMD_TAPDISABLE
,
1687 JTAG_CMD_TAPISENABLED
,
1692 const Jim_Nvp jtag_cmds
[] = {
1693 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
1694 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
1695 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
1696 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
1697 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
1698 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
1699 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
1700 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
1702 { .name
= NULL
, .value
= -1 },
1705 context
= Jim_GetAssocData(interp
, "context");
1706 /* go past the command */
1707 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
1709 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
1711 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
1714 Jim_SetEmptyResult( goi
.interp
);
1716 case JTAG_CMD_INTERFACE
:
1717 /* return the name of the interface */
1718 /* TCL code might need to know the exact type... */
1719 /* FUTURE: we allow this as a means to "set" the interface. */
1720 if( goi
.argc
!= 0 ){
1721 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1724 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
1726 case JTAG_CMD_INIT_RESET
:
1727 if( goi
.argc
!= 0 ){
1728 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1731 e
= jtag_init_reset(context
);
1732 if( e
!= ERROR_OK
){
1733 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
1737 case JTAG_CMD_NEWTAP
:
1738 return jim_newtap_cmd( &goi
);
1740 case JTAG_CMD_TAPISENABLED
:
1741 case JTAG_CMD_TAPENABLE
:
1742 case JTAG_CMD_TAPDISABLE
:
1743 if( goi
.argc
!= 1 ){
1744 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
1750 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
1755 case JTAG_CMD_TAPISENABLED
:
1758 case JTAG_CMD_TAPENABLE
:
1759 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
1763 case JTAG_CMD_TAPDISABLE
:
1764 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
1769 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
1776 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
1783 Jim_GetOpt_Obj(&goi
, &o
);
1784 t
= jtag_TapByJimObj( goi
.interp
, o
);
1789 goi
.isconfigure
= 0;
1790 return jtag_tap_configure_cmd( &goi
, t
);
1794 case JTAG_CMD_CONFIGURE
:
1796 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
1803 Jim_GetOpt_Obj(&goi
, &o
);
1804 t
= jtag_TapByJimObj( goi
.interp
, o
);
1809 goi
.isconfigure
= 1;
1810 return jtag_tap_configure_cmd( &goi
, t
);
1817 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1819 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
1821 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1822 COMMAND_CONFIG
, "try to configure interface");
1823 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1824 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
1825 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1826 COMMAND_ANY
, "set maximum jtag speed (if supported); "
1827 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1828 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1829 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1830 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1832 "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]");
1833 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1834 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1835 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1836 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1838 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1839 COMMAND_EXEC
, "print current scan chain configuration");
1841 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1842 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1843 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1844 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1845 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1846 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1847 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1848 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1849 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1850 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
1852 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1853 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1854 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
1855 COMMAND_ANY
, "verify value capture <enable|disable>");
1856 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
1857 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
1861 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1866 if (!jtag_interface
)
1868 /* nothing was previously specified by "interface" command */
1869 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1870 return ERROR_JTAG_INVALID_INTERFACE
;
1874 jtag_interface
->khz(speed_khz
, &jtag_speed
);
1878 if (jtag_interface
->init() != ERROR_OK
)
1879 return ERROR_JTAG_INIT_FAILED
;
1881 jtag
= jtag_interface
;
1885 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1890 LOG_DEBUG("Init JTAG chain");
1892 tap
= jtag_NextEnabledTap(NULL
);
1894 LOG_ERROR("There are no enabled taps?");
1895 return ERROR_JTAG_INIT_FAILED
;
1899 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1902 /* examine chain first, as this could discover the real chain layout */
1903 if (jtag_examine_chain() != ERROR_OK
)
1905 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1908 if (jtag_validate_chain() != ERROR_OK
)
1910 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1916 int jtag_interface_quit(void)
1918 if (!jtag
|| !jtag
->quit
)
1921 // close the JTAG interface
1922 int result
= jtag
->quit();
1923 if (ERROR_OK
!= result
)
1924 LOG_ERROR("failed: %d", result
);
1930 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1934 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1937 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1939 /* Reset can happen after a power cycle.
1941 * Ideally we would only assert TRST or run RESET before the target reset.
1943 * However w/srst_pulls_trst, trst is asserted together with the target
1944 * reset whether we want it or not.
1946 * NB! Some targets have JTAG circuitry disabled until a
1947 * trst & srst has been asserted.
1949 * NB! here we assume nsrst/ntrst delay are sufficient!
1951 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1954 jtag_add_reset(1, 0); /* RESET or TRST */
1955 if (jtag_reset_config
& RESET_HAS_SRST
)
1957 jtag_add_reset(1, 1);
1958 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1959 jtag_add_reset(0, 1);
1961 jtag_add_reset(0, 0);
1962 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1965 /* Check that we can communication on the JTAG chain + eventually we want to
1966 * be able to perform enumeration only after OpenOCD has started
1967 * telnet and GDB server
1969 * That would allow users to more easily perform any magic they need to before
1972 return jtag_init_inner(cmd_ctx
);
1975 int jtag_init(struct command_context_s
*cmd_ctx
)
1978 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1980 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1984 return jtag_init_reset(cmd_ctx
);
1987 static int default_khz(int khz
, int *jtag_speed
)
1989 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1993 static int default_speed_div(int speed
, int *khz
)
1995 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1999 static int default_power_dropout(int *dropout
)
2001 *dropout
=0; /* by default we can't detect power dropout */
2005 static int default_srst_asserted(int *srst_asserted
)
2007 *srst_asserted
=0; /* by default we can't detect srst asserted */
2011 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2016 /* check whether the interface is already configured */
2019 LOG_WARNING("Interface already configured, ignoring");
2023 /* interface name is a mandatory argument */
2024 if (argc
< 1 || args
[0][0] == '\0')
2026 return ERROR_COMMAND_SYNTAX_ERROR
;
2029 for (i
=0; jtag_interfaces
[i
]; i
++)
2031 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
2033 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
2038 jtag_interface
= jtag_interfaces
[i
];
2040 if (jtag_interface
->khz
== NULL
)
2042 jtag_interface
->khz
= default_khz
;
2044 if (jtag_interface
->speed_div
== NULL
)
2046 jtag_interface
->speed_div
= default_speed_div
;
2048 if (jtag_interface
->power_dropout
== NULL
)
2050 jtag_interface
->power_dropout
= default_power_dropout
;
2052 if (jtag_interface
->srst_asserted
== NULL
)
2054 jtag_interface
->srst_asserted
= default_srst_asserted
;
2061 /* no valid interface was found (i.e. the configuration option,
2062 * didn't match one of the compiled-in interfaces
2064 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
2065 LOG_ERROR("compiled-in jtag interfaces:");
2066 for (i
= 0; jtag_interfaces
[i
]; i
++)
2068 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
2071 return ERROR_JTAG_INVALID_INTERFACE
;
2074 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2078 Jim_Obj
*newargs
[ 10 ];
2081 * argv[-1] = command
2082 * argv[ 0] = ir length
2083 * argv[ 1] = ir capture
2084 * argv[ 2] = ir mask
2085 * argv[ 3] = not actually used by anything but in the docs
2089 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2092 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2093 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2097 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2098 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2099 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2100 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
2102 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
2103 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
2104 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
2105 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
2106 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
2107 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
2108 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
2109 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
2110 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
2111 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
2112 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
2113 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
2115 command_print( cmd_ctx
, "NEW COMMAND:");
2116 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
2117 Jim_GetString( newargs
[0], NULL
),
2118 Jim_GetString( newargs
[1], NULL
),
2119 Jim_GetString( newargs
[2], NULL
),
2120 Jim_GetString( newargs
[3], NULL
),
2121 Jim_GetString( newargs
[4], NULL
),
2122 Jim_GetString( newargs
[5], NULL
),
2123 Jim_GetString( newargs
[6], NULL
),
2124 Jim_GetString( newargs
[7], NULL
),
2125 Jim_GetString( newargs
[8], NULL
),
2126 Jim_GetString( newargs
[9], NULL
) );
2128 e
= jim_jtag_command( interp
, 10, newargs
);
2130 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
2135 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2139 tap
= jtag_all_taps
;
2140 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2141 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
2144 u32 expected
, expected_mask
, cur_instr
, ii
;
2145 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
2146 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
2147 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
2149 command_print(cmd_ctx
,
2150 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2151 tap
->abs_chain_position
,
2153 tap
->enabled
? 'Y' : 'n',
2155 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
2161 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
2162 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
2163 tap
->expected_ids
[ii
]);
2166 tap
= tap
->next_tap
;
2172 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2178 return ERROR_COMMAND_SYNTAX_ERROR
;
2180 /* Original versions cared about the order of these tokens:
2181 * reset_config signals [combination [trst_type [srst_type]]]
2182 * They also clobbered the previous configuration even on error.
2184 * Here we don't care about the order, and only change values
2185 * which have been explicitly specified.
2187 for (; argc
; argc
--, args
++) {
2192 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
2193 if (strcmp(*args
, "none") == 0)
2195 else if (strcmp(*args
, "trst_only") == 0)
2196 tmp
= RESET_HAS_TRST
;
2197 else if (strcmp(*args
, "srst_only") == 0)
2198 tmp
= RESET_HAS_SRST
;
2199 else if (strcmp(*args
, "trst_and_srst") == 0)
2200 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
2204 LOG_ERROR("extra reset_config %s spec (%s)",
2206 return ERROR_INVALID_ARGUMENTS
;
2211 /* combination (options for broken wiring) */
2212 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2213 if (strcmp(*args
, "separate") == 0)
2214 /* separate reset lines - default */;
2215 else if (strcmp(*args
, "srst_pulls_trst") == 0)
2216 tmp
|= RESET_SRST_PULLS_TRST
;
2217 else if (strcmp(*args
, "trst_pulls_srst") == 0)
2218 tmp
|= RESET_TRST_PULLS_SRST
;
2219 else if (strcmp(*args
, "combined") == 0)
2220 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2224 LOG_ERROR("extra reset_config %s spec (%s)",
2225 "combination", *args
);
2226 return ERROR_INVALID_ARGUMENTS
;
2231 /* trst_type (NOP without HAS_TRST) */
2232 m
= RESET_TRST_OPEN_DRAIN
;
2233 if (strcmp(*args
, "trst_open_drain") == 0)
2234 tmp
|= RESET_TRST_OPEN_DRAIN
;
2235 else if (strcmp(*args
, "trst_push_pull") == 0)
2236 /* push/pull from adapter - default */;
2240 LOG_ERROR("extra reset_config %s spec (%s)",
2241 "trst_type", *args
);
2242 return ERROR_INVALID_ARGUMENTS
;
2247 /* srst_type (NOP without HAS_SRST) */
2248 m
|= RESET_SRST_PUSH_PULL
;
2249 if (strcmp(*args
, "srst_push_pull") == 0)
2250 tmp
|= RESET_SRST_PUSH_PULL
;
2251 else if (strcmp(*args
, "srst_open_drain") == 0)
2252 /* open drain from adapter - default */;
2256 LOG_ERROR("extra reset_config %s spec (%s)",
2257 "srst_type", *args
);
2258 return ERROR_INVALID_ARGUMENTS
;
2263 /* caller provided nonsense; fail */
2264 LOG_ERROR("unknown reset_config flag (%s)", *args
);
2265 return ERROR_INVALID_ARGUMENTS
;
2268 /* Remember the bits which were specified (mask)
2269 * and their new values (new_cfg).
2275 /* clear previous values of those bits, save new values */
2276 jtag_reset_config
&= ~mask
;
2277 jtag_reset_config
|= new_cfg
;
2282 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2286 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2291 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2297 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2301 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2306 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2312 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2314 int retval
=ERROR_OK
;
2318 LOG_DEBUG("handle jtag speed");
2321 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2323 /* this command can be called during CONFIG,
2324 * in which case jtag isn't initialized */
2327 retval
=jtag
->speed(cur_speed
);
2329 } else if (argc
== 0)
2333 return ERROR_COMMAND_SYNTAX_ERROR
;
2335 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2340 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2342 int retval
=ERROR_OK
;
2343 LOG_DEBUG("handle jtag khz");
2347 speed_khz
= strtoul(args
[0], NULL
, 0);
2351 LOG_DEBUG("have interface set up");
2353 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2359 cur_speed
= jtag_speed
= speed_div1
;
2361 retval
=jtag
->speed(cur_speed
);
2370 return ERROR_COMMAND_SYNTAX_ERROR
;
2375 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2381 command_print(cmd_ctx
, "RCLK - adaptive");
2384 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2390 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2396 return ERROR_COMMAND_SYNTAX_ERROR
;
2400 state
= tap_state_by_name( args
[0] );
2402 command_print( cmd_ctx
, "Invalid state name: %s\n", args
[0] );
2403 return ERROR_COMMAND_SYNTAX_ERROR
;
2405 jtag_add_end_state(state
);
2406 jtag_execute_queue();
2408 command_print(cmd_ctx
, "current endstate: %s", tap_state_name(cmd_queue_end_state
));
2413 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2420 return ERROR_COMMAND_SYNTAX_ERROR
;
2423 if (args
[0][0] == '1')
2425 else if (args
[0][0] == '0')
2429 return ERROR_COMMAND_SYNTAX_ERROR
;
2432 if (args
[1][0] == '1')
2434 else if (args
[1][0] == '0')
2438 return ERROR_COMMAND_SYNTAX_ERROR
;
2441 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2442 return ERROR_JTAG_INIT_FAILED
;
2444 jtag_add_reset(trst
, srst
);
2445 jtag_execute_queue();
2450 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2454 return ERROR_COMMAND_SYNTAX_ERROR
;
2457 jtag_add_runtest(strtol(args
[0], NULL
, 0), TAP_INVALID
);
2458 jtag_execute_queue();
2465 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2466 * should be stable ... and *NOT* a shift state, otherwise free-running
2467 * jtag clocks could change the values latched by the update state.
2469 static bool scan_is_safe(tap_state_t state
)
2484 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2487 scan_field_t
*fields
;
2489 tap_state_t endstate
;
2491 if ((argc
< 2) || (argc
% 2))
2493 return ERROR_COMMAND_SYNTAX_ERROR
;
2496 /* optional "-endstate" "statename" at the end of the arguments,
2497 * so that e.g. IRPAUSE can let us load the data register before
2498 * entering RUN/IDLE to execute the instruction we load here.
2500 endstate
= TAP_IDLE
;
2503 /* have at least one pair of numbers. */
2504 /* is last pair the magic text? */
2505 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
2508 cpA
= args
[ argc
-1 ];
2509 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
2510 cpS
= tap_state_name( endstate
);
2511 if( 0 == strcmp( cpA
, cpS
) ){
2515 if( endstate
>= TAP_NUM_STATES
){
2516 return ERROR_COMMAND_SYNTAX_ERROR
;
2518 if (!scan_is_safe(endstate
))
2519 LOG_WARNING("irscan with unsafe "
2520 "endstate \"%s\"", cpA
);
2521 /* found - remove the last 2 args */
2527 int num_fields
= argc
/ 2;
2529 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2531 for (i
= 0; i
< num_fields
; i
++)
2533 tap
= jtag_TapByString( args
[i
*2] );
2536 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2539 int field_size
= tap
->ir_length
;
2540 fields
[i
].tap
= tap
;
2541 fields
[i
].num_bits
= field_size
;
2542 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2543 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2544 fields
[i
].in_value
= NULL
;
2547 /* did we have an endstate? */
2548 jtag_add_ir_scan(num_fields
, fields
, endstate
);
2550 int retval
=jtag_execute_queue();
2552 for (i
= 0; i
< num_fields
; i
++)
2553 free(fields
[i
].out_value
);
2560 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2563 scan_field_t
*fields
;
2565 int field_count
= 0;
2568 tap_state_t endstate
;
2571 * args[2] = num_bits
2572 * args[3] = hex string
2573 * ... repeat num bits and hex string ...
2576 * args[N-2] = "-endstate"
2577 * args[N-1] = statename
2579 if ((argc
< 4) || ((argc
% 2)!=0))
2581 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2585 endstate
= TAP_IDLE
;
2587 /* validate arguments as numbers */
2589 for (i
= 2; i
< argc
; i
+=2)
2594 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2595 /* If valid - try next arg */
2600 /* Not valid.. are we at the end? */
2601 if ( ((i
+2) != argc
) ){
2602 /* nope, then error */
2606 /* it could be: "-endstate FOO"
2607 * e.g. DRPAUSE so we can issue more instructions
2608 * before entering RUN/IDLE and executing them.
2611 /* get arg as a string. */
2612 cp
= Jim_GetString( args
[i
], NULL
);
2613 /* is it the magic? */
2614 if( 0 == strcmp( "-endstate", cp
) ){
2615 /* is the statename valid? */
2616 cp
= Jim_GetString( args
[i
+1], NULL
);
2618 /* see if it is a valid state name */
2619 endstate
= tap_state_by_name(cp
);
2621 /* update the error message */
2622 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
2624 if (!scan_is_safe(endstate
))
2625 LOG_WARNING("drscan with unsafe "
2626 "endstate \"%s\"", cp
);
2628 /* valid - so clear the error */
2630 /* and remove the last 2 args */
2635 /* Still an error? */
2637 return e
; /* too bad */
2639 } /* validate args */
2641 tap
= jtag_TapByJimObj( interp
, args
[1] );
2646 num_fields
=(argc
-2)/2;
2647 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2648 for (i
= 2; i
< argc
; i
+=2)
2654 Jim_GetLong(interp
, args
[i
], &bits
);
2655 str
= Jim_GetString(args
[i
+1], &len
);
2657 fields
[field_count
].tap
= tap
;
2658 fields
[field_count
].num_bits
= bits
;
2659 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2660 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2661 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2665 jtag_add_dr_scan(num_fields
, fields
, endstate
);
2667 retval
= jtag_execute_queue();
2668 if (retval
!= ERROR_OK
)
2670 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
2675 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2676 for (i
= 2; i
< argc
; i
+=2)
2681 Jim_GetLong(interp
, args
[i
], &bits
);
2682 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2683 free(fields
[field_count
].out_value
);
2685 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2690 Jim_SetResult(interp
, list
);
2698 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2700 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_flush_queue_count
));
2706 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2710 if (strcmp(args
[0], "enable") == 0)
2712 jtag_verify_capture_ir
= 1;
2714 else if (strcmp(args
[0], "disable") == 0)
2716 jtag_verify_capture_ir
= 0;
2719 return ERROR_COMMAND_SYNTAX_ERROR
;
2721 } else if (argc
!= 0)
2723 return ERROR_COMMAND_SYNTAX_ERROR
;
2726 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2731 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2735 if (strcmp(args
[0], "enable") == 0)
2739 else if (strcmp(args
[0], "disable") == 0)
2744 return ERROR_COMMAND_SYNTAX_ERROR
;
2746 } else if (argc
!= 0)
2748 return ERROR_COMMAND_SYNTAX_ERROR
;
2751 command_print(cmd_ctx
, "verify jtag capture is %s", (jtag_verify
) ? "enabled": "disabled");
2757 int jtag_power_dropout(int *dropout
)
2759 return jtag
->power_dropout(dropout
);
2762 int jtag_srst_asserted(int *srst_asserted
)
2764 return jtag
->srst_asserted(srst_asserted
);
2767 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
2769 jtag_tap_event_action_t
* jteap
;
2772 jteap
= tap
->event_action
;
2776 if (jteap
->event
== e
) {
2778 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2781 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
2782 Jim_GetString(jteap
->body
, NULL
) );
2783 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
2784 Jim_PrintErrorMessage(interp
);
2788 jteap
= jteap
->next
;
2792 LOG_DEBUG( "event %d %s - no action",
2794 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
2798 /*-----<Cable Helper API>---------------------------------------*/
2800 /* these Cable Helper API functions are all documented in the jtag.h header file,
2801 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
2802 is setup to prefer its docs in the header file, no documentation is here, for
2803 if it were, it would have to be doubly maintained.
2807 * @see tap_set_state() and tap_get_state() accessors.
2808 * Actual name is not important since accessors hide it.
2810 static tap_state_t state_follower
= TAP_RESET
;
2812 void tap_set_state_impl( tap_state_t new_state
)
2814 /* this is the state we think the TAPs are in now, was cur_state */
2815 state_follower
= new_state
;
2818 tap_state_t
tap_get_state()
2820 return state_follower
;
2824 * @see tap_set_end_state() and tap_get_end_state() accessors.
2825 * Actual name is not important because accessors hide it.
2827 static tap_state_t end_state_follower
= TAP_RESET
;
2829 void tap_set_end_state( tap_state_t new_end_state
)
2831 /* this is the state we think the TAPs will be in at completion of the
2832 current TAP operation, was end_state
2834 end_state_follower
= new_end_state
;
2837 tap_state_t
tap_get_end_state()
2839 return end_state_follower
;
2843 int tap_move_ndx( tap_state_t astate
)
2845 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
2851 case TAP_RESET
: ndx
= 0; break;
2852 case TAP_DRSHIFT
: ndx
= 2; break;
2853 case TAP_DRPAUSE
: ndx
= 3; break;
2854 case TAP_IDLE
: ndx
= 1; break;
2855 case TAP_IRSHIFT
: ndx
= 4; break;
2856 case TAP_IRPAUSE
: ndx
= 5; break;
2858 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate
) );
2866 /* tap_move[i][j]: tap movement command to go from state i to state j
2867 * 0: Test-Logic-Reset
2874 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
2876 struct tms_sequences
2884 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
2885 * Read the bits from LSBit first to MSBit last (right-to-left).
2887 #define HEX__(n) 0x##n##LU
2890 (((x) & 0x0000000FLU)?(1<<0):0) \
2891 +(((x) & 0x000000F0LU)?(1<<1):0) \
2892 +(((x) & 0x00000F00LU)?(1<<2):0) \
2893 +(((x) & 0x0000F000LU)?(1<<3):0) \
2894 +(((x) & 0x000F0000LU)?(1<<4):0) \
2895 +(((x) & 0x00F00000LU)?(1<<5):0) \
2896 +(((x) & 0x0F000000LU)?(1<<6):0) \
2897 +(((x) & 0xF0000000LU)?(1<<7):0)
2899 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
2901 static const struct tms_sequences old_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
2903 /* value clocked to TMS to move from one of six stable states to another.
2904 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
2905 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
2906 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
2907 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
2913 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
2914 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
2915 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
2916 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
2917 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
2918 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
2919 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* IRPAUSE */
2924 static const struct tms_sequences short_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
2926 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
2928 OK, I added Peter's version of the state table, and it works OK for
2929 me on MC1322x. I've recreated the jlink portion of patch with this
2930 new state table. His changes to my state table are pretty minor in
2931 terms of total transitions, but Peter feels that his version fixes
2932 some long-standing problems.
2935 I added the bit count into the table, reduced RESET column to 7 bits from 8.
2938 state specific comments:
2939 ------------------------
2940 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
2941 work better on ARM9 with ft2232 driver. (Dick)
2943 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
2944 needed on ARM9 with ft2232 driver. (Dick)
2946 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
2947 needed on ARM9 with ft2232 driver. (Dick)
2951 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
2952 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
2953 { B8(1111111,7), B8(0000000,7), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
2954 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
2955 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
2956 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
2957 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
2961 typedef const struct tms_sequences tms_table
[6][6];
2963 static tms_table
*tms_seqs
=&short_tms_seqs
;
2965 int tap_get_tms_path( tap_state_t from
, tap_state_t to
)
2967 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bits
;
2971 int tap_get_tms_path_len( tap_state_t from
, tap_state_t to
)
2973 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bit_count
;
2977 bool tap_is_state_stable(tap_state_t astate
)
2981 /* A switch() is used because it is symbol dependent
2982 (not value dependent like an array), and can also check bounds.
3001 tap_state_t
tap_state_transition(tap_state_t cur_state
, bool tms
)
3003 tap_state_t new_state
;
3005 /* A switch is used because it is symbol dependent and not value dependent
3006 like an array. Also it can check for out of range conditions.
3014 new_state
= cur_state
;
3019 new_state
= TAP_DRSELECT
;
3022 new_state
= TAP_IRSELECT
;
3026 new_state
= TAP_DREXIT1
;
3030 new_state
= TAP_DRUPDATE
;
3033 new_state
= TAP_DREXIT2
;
3036 new_state
= TAP_RESET
;
3040 new_state
= TAP_IREXIT1
;
3044 new_state
= TAP_IRUPDATE
;
3047 new_state
= TAP_IREXIT2
;
3050 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3063 new_state
= TAP_IDLE
;
3066 new_state
= TAP_DRCAPTURE
;
3071 new_state
= TAP_DRSHIFT
;
3075 new_state
= TAP_DRPAUSE
;
3078 new_state
= TAP_IRCAPTURE
;
3083 new_state
= TAP_IRSHIFT
;
3087 new_state
= TAP_IRPAUSE
;
3090 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3099 const char* tap_state_name(tap_state_t state
)
3105 case TAP_RESET
: ret
= "RESET"; break;
3106 case TAP_IDLE
: ret
= "RUN/IDLE"; break;
3107 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
3108 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
3109 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
3110 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
3111 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
3112 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
3113 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
3114 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
3115 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
3116 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
3117 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
3118 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
3119 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
3120 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
3121 default: ret
= "???";
3127 tap_state_t
tap_state_by_name(const char *name
)
3131 for( x
= 0 ; x
< TAP_NUM_STATES
; x
++ ){
3132 /* be nice to the human */
3133 if( 0 == strcasecmp( name
, tap_state_name(x
) ) ){
3141 #ifdef _DEBUG_JTAG_IO_
3143 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3144 do { buf[len] = bit ? '1' : '0'; } while(0)
3145 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3146 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3147 tap_state_name(a), tap_state_name(b), astr, bstr)
3149 tap_state_t
jtag_debug_state_machine(const void *tms_buf
, const void *tdi_buf
,
3150 unsigned tap_bits
, tap_state_t next_state
)
3152 const u8
*tms_buffer
;
3153 const u8
*tdi_buffer
;
3158 unsigned tap_out_bits
;
3162 tap_state_t last_state
;
3164 // set startstate (and possibly last, if tap_bits == 0)
3165 last_state
= next_state
;
3166 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state
));
3168 tms_buffer
= (const u8
*)tms_buf
;
3169 tdi_buffer
= (const u8
*)tdi_buf
;
3171 tap_bytes
= TAP_SCAN_BYTES(tap_bits
);
3172 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits
, tap_bytes
);
3175 for(cur_byte
= 0; cur_byte
< tap_bytes
; cur_byte
++)
3177 for(cur_bit
= 0; cur_bit
< 8; cur_bit
++)
3179 // make sure we do not run off the end of the buffers
3180 unsigned tap_bit
= cur_byte
* 8 + cur_bit
;
3181 if (tap_bit
== tap_bits
)
3184 // check and save TMS bit
3185 tap_bit
= !!(tms_buffer
[cur_byte
] & (1 << cur_bit
));
3186 JTAG_DEBUG_STATE_APPEND(tms_str
, tap_out_bits
, tap_bit
);
3188 // use TMS bit to find the next TAP state
3189 next_state
= tap_state_transition(last_state
, tap_bit
);
3191 // check and store TDI bit
3192 tap_bit
= !!(tdi_buffer
[cur_byte
] & (1 << cur_bit
));
3193 JTAG_DEBUG_STATE_APPEND(tdi_str
, tap_out_bits
, tap_bit
);
3195 // increment TAP bits
3198 // Only show TDO bits on state transitions, or
3199 // after some number of bits in the same state.
3200 if ((next_state
== last_state
) && (tap_out_bits
< 32))
3203 // terminate strings and display state transition
3204 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3205 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3208 last_state
= next_state
;
3215 // terminate strings and display state transition
3216 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3217 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3220 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state
));
3224 #endif // _DEBUG_JTAG_IO_
3226 void tap_use_new_tms_table(bool use_new
)
3228 tms_seqs
= use_new
? &short_tms_seqs
: &old_tms_seqs
;
3230 bool tap_uses_new_tms_table(void)
3232 return tms_seqs
== &short_tms_seqs
;
3235 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3238 return ERROR_COMMAND_SYNTAX_ERROR
;
3243 if (strcmp(args
[0], "short") == 0)
3244 use_new_table
= true;
3245 else if (strcmp(args
[0], "long") == 0)
3246 use_new_table
= false;
3248 return ERROR_COMMAND_SYNTAX_ERROR
;
3250 tap_use_new_tms_table(use_new_table
);
3253 command_print(cmd_ctx
, "tms sequence is %s",
3254 tap_uses_new_tms_table() ? "short": "long");
3259 /*-----</Cable Helper API>--------------------------------------*/
3263 * Function jtag_add_statemove
3264 * moves from the current state to the goal \a state. This needs
3265 * to be handled according to the xsvf spec, see the XSTATE command
3268 int jtag_add_statemove(tap_state_t goal_state
)
3270 int retval
= ERROR_OK
;
3272 tap_state_t moves
[8];
3273 tap_state_t cur_state
= cmd_queue_cur_state
;
3278 LOG_DEBUG( "cur_state=%s goal_state=%s",
3279 tap_state_name(cur_state
),
3280 tap_state_name(goal_state
) );
3283 /* From the XSVF spec, pertaining to XSTATE:
3285 For special states known as stable states (Test-Logic-Reset,
3286 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
3287 predefined TAP state paths when the starting state is a stable state and
3288 when the XSTATE specifies a new stable state (see the STATE command in
3289 the [Ref 5] for the TAP state paths between stable states). For
3290 non-stable states, XSTATE should specify a state that is only one TAP
3291 state transition distance from the current TAP state to avoid undefined
3292 TAP state paths. A sequence of multiple XSTATE commands can be issued to
3293 transition the TAP through a specific state path.
3296 if (goal_state
==cur_state
)
3297 ; /* nothing to do */
3299 else if( goal_state
==TAP_RESET
)
3304 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
3306 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
3307 spec, then this code is not fully conformant to the xsvf spec. This
3308 puts a burden on tap_get_tms_path() function from the xsvf spec.
3309 If in doubt, you should confirm that that burden is being met.
3312 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
3313 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
3315 assert( (unsigned) tms_count
< DIM(moves
) );
3317 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
3319 bool bit
= tms_bits
& 1;
3321 cur_state
= tap_state_transition(cur_state
, bit
);
3322 moves
[i
] = cur_state
;
3325 jtag_add_pathmove(tms_count
, moves
);
3328 /* else state must be immediately reachable in one clock cycle, and does not
3329 need to be a stable state.
3331 else if( tap_state_transition(cur_state
, true) == goal_state
3332 || tap_state_transition(cur_state
, false) == goal_state
)
3334 /* move a single state */
3335 moves
[0] = goal_state
;
3336 jtag_add_pathmove( 1, moves
);
3341 retval
= ERROR_FAIL
;
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)