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 ***************************************************************************/
32 #include "minidriver.h"
33 #include "interface.h"
40 /// The number of JTAG queue flushes (for profiling and debugging purposes).
41 static int jtag_flush_queue_count
;
43 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
44 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
);
46 /* note that this is not marked as static as it must be available from outside jtag.c for those
47 that implement the jtag_xxx() minidriver layer
49 int jtag_error
=ERROR_OK
;
51 char* jtag_event_strings
[] =
53 "JTAG controller reset (RESET or TRST)"
56 const Jim_Nvp nvp_jtag_tap_event
[] = {
57 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
58 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
60 { .name
= NULL
, .value
= -1 }
67 * List all TAPs that have been created.
69 static jtag_tap_t
*__jtag_all_taps
= NULL
;
71 * The number of TAPs in the __jtag_all_taps list, used to track the
72 * assigned chain position to new TAPs
74 static int jtag_num_taps
= 0;
76 enum reset_types jtag_reset_config
= RESET_NONE
;
77 tap_state_t cmd_queue_end_state
= TAP_RESET
;
78 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
80 int jtag_verify_capture_ir
= 1;
83 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
84 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
85 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
87 /* callbacks to inform high-level handlers about JTAG state changes */
88 jtag_event_callback_t
*jtag_event_callbacks
;
91 static int speed_khz
= 0;
92 /* flag if the kHz speed was defined */
93 static bool hasKHz
= false;
95 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
98 #if BUILD_ECOSBOARD == 1
99 extern jtag_interface_t zy1000_interface
;
100 #elif defined(BUILD_MINIDRIVER_DUMMY)
101 extern jtag_interface_t minidummy_interface
;
102 #else // standard drivers
103 #if BUILD_PARPORT == 1
104 extern jtag_interface_t parport_interface
;
108 extern jtag_interface_t dummy_interface
;
111 #if BUILD_FT2232_FTD2XX == 1
112 extern jtag_interface_t ft2232_interface
;
115 #if BUILD_FT2232_LIBFTDI == 1
116 extern jtag_interface_t ft2232_interface
;
119 #if BUILD_AMTJTAGACCEL == 1
120 extern jtag_interface_t amt_jtagaccel_interface
;
123 #if BUILD_EP93XX == 1
124 extern jtag_interface_t ep93xx_interface
;
127 #if BUILD_AT91RM9200 == 1
128 extern jtag_interface_t at91rm9200_interface
;
131 #if BUILD_GW16012 == 1
132 extern jtag_interface_t gw16012_interface
;
135 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
136 extern jtag_interface_t presto_interface
;
139 #if BUILD_USBPROG == 1
140 extern jtag_interface_t usbprog_interface
;
144 extern jtag_interface_t jlink_interface
;
147 #if BUILD_VSLLINK == 1
148 extern jtag_interface_t vsllink_interface
;
152 extern jtag_interface_t rlink_interface
;
155 #if BUILD_ARMJTAGEW == 1
156 extern jtag_interface_t armjtagew_interface
;
158 #endif // standard drivers
161 * The list of built-in JTAG interfaces, containing entries for those
162 * drivers that were enabled by the @c configure script.
164 * The list should be defined to contain either one minidriver interface
165 * or some number of standard driver interfaces, never both.
167 jtag_interface_t
*jtag_interfaces
[] = {
168 #if BUILD_ECOSBOARD == 1
170 #elif defined(BUILD_MINIDRIVER_DUMMY)
171 &minidummy_interface
,
172 #else // standard drivers
173 #if BUILD_PARPORT == 1
179 #if BUILD_FT2232_FTD2XX == 1
182 #if BUILD_FT2232_LIBFTDI == 1
185 #if BUILD_AMTJTAGACCEL == 1
186 &amt_jtagaccel_interface
,
188 #if BUILD_EP93XX == 1
191 #if BUILD_AT91RM9200 == 1
192 &at91rm9200_interface
,
194 #if BUILD_GW16012 == 1
197 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
200 #if BUILD_USBPROG == 1
206 #if BUILD_VSLLINK == 1
212 #if BUILD_ARMJTAGEW == 1
213 &armjtagew_interface
,
215 #endif // standard drivers
219 struct jtag_interface_s
*jtag
= NULL
;
222 static jtag_interface_t
*jtag_interface
= NULL
;
226 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
227 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
228 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
229 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
230 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
231 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
232 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
234 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
236 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
237 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
238 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
239 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
240 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
242 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
243 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
244 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
246 jtag_tap_t
*jtag_all_taps(void)
248 return __jtag_all_taps
;
251 int jtag_tap_count(void)
253 return jtag_num_taps
;
256 unsigned jtag_tap_count_enabled(void)
272 /// Append a new TAP to the chain of all taps.
273 static void jtag_tap_add(struct jtag_tap_s
*t
)
275 t
->abs_chain_position
= jtag_num_taps
++;
277 jtag_tap_t
**tap
= &__jtag_all_taps
;
279 tap
= &(*tap
)->next_tap
;
283 jtag_tap_t
*jtag_tap_by_string( const char *s
)
291 if( 0 == strcmp( t
->dotted_name
, s
) ){
297 /* backup plan is by number */
299 /* ok - is "s" a number? */
301 n
= strtol( s
, &cp
, 0 );
302 if( (s
!= cp
) && (*cp
== 0) ){
304 t
= jtag_tap_by_abs_position(n
);
310 jtag_tap_t
* jtag_tap_by_jim_obj( Jim_Interp
*interp
, Jim_Obj
*o
)
315 cp
= Jim_GetString( o
, NULL
);
320 t
= jtag_tap_by_string( cp
);
323 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
328 /* returns a pointer to the n-th device in the scan chain */
329 jtag_tap_t
* jtag_tap_by_abs_position( int n
)
337 while( t
&& (n
> 0)) {
344 const char *jtag_tap_name(const jtag_tap_t
*tap
)
346 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
350 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
352 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
354 if (callback
== NULL
)
356 return ERROR_INVALID_ARGUMENTS
;
361 while ((*callbacks_p
)->next
)
362 callbacks_p
= &((*callbacks_p
)->next
);
363 callbacks_p
= &((*callbacks_p
)->next
);
366 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
367 (*callbacks_p
)->callback
= callback
;
368 (*callbacks_p
)->priv
= priv
;
369 (*callbacks_p
)->next
= NULL
;
374 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
376 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
378 if (callback
== NULL
)
380 return ERROR_INVALID_ARGUMENTS
;
385 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
386 if ((*callbacks_p
)->callback
== callback
)
389 *callbacks_p
= *next
;
397 int jtag_call_event_callbacks(enum jtag_event event
)
399 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
401 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
405 callback
->callback(event
, callback
->priv
);
406 callback
= callback
->next
;
412 static void jtag_checks(void)
414 assert(jtag_trst
== 0);
417 static void jtag_prelude(tap_state_t state
)
421 assert(state
!=TAP_INVALID
);
423 cmd_queue_cur_state
= state
;
426 void jtag_alloc_in_value32(scan_field_t
*field
)
428 interface_jtag_alloc_in_value32(field
);
431 void jtag_add_ir_scan_noverify(int in_count
, const scan_field_t
*in_fields
,
436 int retval
= interface_jtag_add_ir_scan(in_count
, in_fields
, state
);
437 jtag_set_error(retval
);
442 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
444 * If the input field list contains an instruction value for a TAP then that is used
445 * otherwise the TAP is set to bypass.
447 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
450 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
452 if (jtag_verify
&&jtag_verify_capture_ir
)
454 /* 8 x 32 bit id's is enough for all invocations */
456 for (int j
= 0; j
< in_num_fields
; j
++)
458 /* if we are to run a verification of the ir scan, we need to get the input back.
459 * We may have to allocate space if the caller didn't ask for the input back.
461 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
462 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
464 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
467 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
472 * Duplicate the scan fields passed into the function into an IR SCAN command
474 * This function assumes that the caller handles extra fields for bypassed TAPs
477 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
,
482 int retval
= interface_jtag_add_plain_ir_scan(
483 in_num_fields
, in_fields
, state
);
484 jtag_set_error(retval
);
487 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
489 interface_jtag_add_callback(f
, in
);
492 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
493 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
494 jtag_callback_data_t data3
)
496 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
499 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
501 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
503 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
506 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
507 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
509 for (int i
= 0; i
< in_num_fields
; i
++)
511 struct scan_field_s
*field
= &in_fields
[i
];
512 field
->allocated
= 0;
514 if (field
->check_value
|| field
->in_value
)
516 interface_jtag_add_scan_check_alloc(field
);
520 jtag_add_scan(in_num_fields
, in_fields
, state
);
522 for (int i
= 0; i
< in_num_fields
; i
++)
524 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
526 /* this is synchronous for a minidriver */
527 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
528 (jtag_callback_data_t
)in_fields
[i
].check_value
,
529 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
530 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
532 if (in_fields
[i
].allocated
)
534 free(in_fields
[i
].in_value
);
536 if (in_fields
[i
].modified
)
538 in_fields
[i
].in_value
= NULL
;
543 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
547 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
550 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
556 * Generate a DR SCAN using the fields passed to the function.
557 * For connected TAPs, the function checks in_fields and uses fields
558 * specified there. For bypassed TAPs, the function generates a dummy
559 * 1-bit field. The bypass status of TAPs is set by jtag_add_ir_scan().
561 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
567 retval
= interface_jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
568 jtag_set_error(retval
);
572 * Duplicate the scan fields passed into the function into a DR SCAN
573 * command. Unlike jtag_add_dr_scan(), this function assumes that the
574 * caller handles extra fields for bypassed TAPs.
576 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
,
582 retval
= interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, state
);
583 jtag_set_error(retval
);
586 void jtag_add_dr_out(jtag_tap_t
* tap
,
587 int num_fields
, const int* num_bits
, const u32
* value
,
588 tap_state_t end_state
)
590 assert(end_state
!= TAP_INVALID
);
592 cmd_queue_cur_state
= end_state
;
594 interface_jtag_add_dr_out(tap
,
595 num_fields
, num_bits
, value
,
599 void jtag_add_tlr(void)
601 jtag_prelude(TAP_RESET
);
602 jtag_set_error(interface_jtag_add_tlr());
603 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
606 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
608 tap_state_t cur_state
= cmd_queue_cur_state
;
612 /* the last state has to be a stable state */
613 if (!tap_is_state_stable(path
[num_states
- 1]))
615 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
619 for (i
=0; i
<num_states
; i
++)
621 if (path
[i
] == TAP_RESET
)
623 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
627 if ( tap_state_transition(cur_state
, true) != path
[i
]
628 && tap_state_transition(cur_state
, false) != path
[i
])
630 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[i
]));
638 retval
= interface_jtag_add_pathmove(num_states
, path
);
639 cmd_queue_cur_state
= path
[num_states
- 1];
640 if (retval
!=ERROR_OK
)
644 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
650 /* executed by sw or hw fifo */
651 retval
=interface_jtag_add_runtest(num_cycles
, state
);
652 if (retval
!=ERROR_OK
)
657 void jtag_add_clocks( int num_cycles
)
661 if( !tap_is_state_stable(cmd_queue_cur_state
) )
663 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
664 tap_state_name(cmd_queue_cur_state
) );
665 jtag_error
= ERROR_JTAG_NOT_STABLE_STATE
;
673 retval
= interface_jtag_add_clocks(num_cycles
);
674 if (retval
!= ERROR_OK
)
679 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
681 int trst_with_tlr
= 0;
684 /* FIX!!! there are *many* different cases here. A better
685 * approach is needed for legal combinations of transitions...
687 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
688 (jtag_reset_config
& RESET_HAS_TRST
)&&
689 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
691 if (((req_tlr_or_trst
&&!jtag_trst
)||
692 (!req_tlr_or_trst
&&jtag_trst
))&&
693 ((req_srst
&&!jtag_srst
)||
694 (!req_srst
&&jtag_srst
)))
696 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
697 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
701 /* Make sure that jtag_reset_config allows the requested reset */
702 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
703 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
705 LOG_ERROR("BUG: requested reset would assert trst");
706 jtag_error
=ERROR_FAIL
;
710 /* if TRST pulls SRST, we reset with TAP T-L-R */
711 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
716 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
718 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
719 jtag_error
=ERROR_FAIL
;
725 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
737 jtag_srst
= req_srst
;
739 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
740 if (retval
!=ERROR_OK
)
745 jtag_execute_queue();
749 LOG_DEBUG("SRST line asserted");
753 LOG_DEBUG("SRST line released");
754 if (jtag_nsrst_delay
)
755 jtag_add_sleep(jtag_nsrst_delay
* 1000);
760 LOG_DEBUG("JTAG reset with RESET instead of TRST");
761 jtag_set_end_state(TAP_RESET
);
768 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
769 * and inform possible listeners about this
771 LOG_DEBUG("TRST line asserted");
772 tap_set_state(TAP_RESET
);
773 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
777 if (jtag_ntrst_delay
)
778 jtag_add_sleep(jtag_ntrst_delay
* 1000);
782 tap_state_t
jtag_set_end_state(tap_state_t state
)
784 if ((state
== TAP_DRSHIFT
)||(state
== TAP_IRSHIFT
))
786 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
789 if (state
!=TAP_INVALID
)
790 cmd_queue_end_state
= state
;
791 return cmd_queue_end_state
;
794 tap_state_t
jtag_get_end_state(void)
796 return cmd_queue_end_state
;
799 void jtag_add_sleep(u32 us
)
801 keep_alive(); /* we might be running on a very slow JTAG clk */
802 int retval
=interface_jtag_add_sleep(us
);
803 if (retval
!=ERROR_OK
)
808 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
810 int retval
= ERROR_OK
;
812 int compare_failed
= 0;
815 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
817 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
820 /* An error handler could have caught the failing check
821 * only report a problem when there wasn't a handler, or if the handler
822 * acknowledged the error
825 LOG_WARNING("TAP %s:",
826 jtag_tap_name(field->tap));
830 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
831 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
835 char *in_check_mask_char
;
836 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
837 LOG_WARNING("value captured during scan didn't pass the requested check:");
838 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
839 captured_char
, in_check_value_char
, in_check_mask_char
);
840 free(in_check_mask_char
);
844 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
);
848 free(in_check_value_char
);
850 retval
= ERROR_JTAG_QUEUE_FAILED
;
857 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
859 assert(field
->in_value
!= NULL
);
863 /* no checking to do */
867 jtag_execute_queue_noclear();
869 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
870 jtag_set_error(retval
);
875 int default_interface_jtag_execute_queue(void)
879 LOG_ERROR("No JTAG interface configured yet. "
880 "Issue 'init' command in startup scripts "
881 "before communicating with targets.");
885 return jtag
->execute_queue();
888 void jtag_execute_queue_noclear(void)
890 jtag_flush_queue_count
++;
891 jtag_set_error(interface_jtag_execute_queue());
894 int jtag_get_flush_queue_count(void)
896 return jtag_flush_queue_count
;
899 int jtag_execute_queue(void)
901 jtag_execute_queue_noclear();
902 return jtag_error_clear();
905 static int jtag_reset_callback(enum jtag_event event
, void *priv
)
907 jtag_tap_t
*tap
= priv
;
911 if (event
== JTAG_TRST_ASSERTED
)
913 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
920 void jtag_sleep(u32 us
)
922 alive_sleep(us
/1000);
925 /// maximum number of JTAG devices expected in the chain
926 #define JTAG_MAX_CHAIN_SIZE 20
928 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
929 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
930 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
932 static int jtag_examine_chain_execute(u8
*idcode_buffer
, unsigned num_idcode
)
934 scan_field_t field
= {
936 .num_bits
= num_idcode
* 32,
937 .out_value
= idcode_buffer
,
938 .in_value
= idcode_buffer
,
941 // initialize to the end of chain ID value
942 for (unsigned i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
943 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
945 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
946 return jtag_execute_queue();
949 static bool jtag_examine_chain_check(u8
*idcodes
, unsigned count
)
954 for (unsigned i
= 0; i
< count
* 4; i
++)
956 zero_check
|= idcodes
[i
];
957 one_check
&= idcodes
[i
];
960 /* if there wasn't a single non-zero bit or if all bits were one,
961 * the scan is not valid */
962 if (zero_check
== 0x00 || one_check
== 0xff)
964 LOG_ERROR("JTAG communication failure: check connection, "
965 "JTAG interface, target power etc.");
971 static void jtag_examine_chain_display(enum log_levels level
, const char *msg
,
972 const char *name
, u32 idcode
)
974 log_printf_lf(level
, __FILE__
, __LINE__
, __FUNCTION__
,
975 "JTAG tap: %s %16.16s: 0x%08x "
976 "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
978 EXTRACT_MFG(idcode
), EXTRACT_PART(idcode
), EXTRACT_VER(idcode
) );
981 static bool jtag_idcode_is_final(u32 idcode
)
983 return idcode
== 0x000000FF || idcode
== 0xFFFFFFFF;
987 * This helper checks that remaining bits in the examined chain data are
988 * all as expected, but a single JTAG device requires only 64 bits to be
989 * read back correctly. This can help identify and diagnose problems
990 * with the JTAG chain earlier, gives more helpful/explicit error messages.
992 static void jtag_examine_chain_end(u8
*idcodes
, unsigned count
, unsigned max
)
994 bool triggered
= false;
995 for ( ; count
< max
- 31; count
+= 32)
997 u32 idcode
= buf_get_u32(idcodes
, count
, 32);
998 // do not trigger the warning if the data looks good
999 if (!triggered
&& jtag_idcode_is_final(idcode
))
1001 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
1007 static bool jtag_examine_chain_match_tap(const struct jtag_tap_s
*tap
)
1009 if (0 == tap
->expected_ids_cnt
)
1011 /// @todo Enable LOG_INFO to ask for reports about unknown TAP IDs.
1013 LOG_INFO("Uknown JTAG TAP ID: 0x%08x", tap
->idcode
)
1014 LOG_INFO("Please report the chip name and reported ID code to the openocd project");
1019 /* Loop over the expected identification codes and test for a match */
1021 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
1023 if (tap
->idcode
== tap
->expected_ids
[ii
])
1027 /* If none of the expected ids matched, log an error */
1028 if (ii
!= tap
->expected_ids_cnt
)
1030 LOG_INFO("JTAG Tap/device matched");
1033 jtag_examine_chain_display(LOG_LVL_ERROR
, "got",
1034 tap
->dotted_name
, tap
->idcode
);
1035 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++)
1038 snprintf(msg
, sizeof(msg
), "expected %hhu of %hhu",
1039 ii
+ 1, tap
->expected_ids_cnt
);
1040 jtag_examine_chain_display(LOG_LVL_ERROR
, msg
,
1041 tap
->dotted_name
, tap
->expected_ids
[ii
]);
1046 /* Try to examine chain layout according to IEEE 1149.1 §12
1048 static int jtag_examine_chain(void)
1050 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1051 unsigned device_count
= 0;
1053 jtag_examine_chain_execute(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
);
1055 if (!jtag_examine_chain_check(idcode_buffer
, JTAG_MAX_CHAIN_SIZE
))
1056 return ERROR_JTAG_INIT_FAILED
;
1058 /* point at the 1st tap */
1059 jtag_tap_t
*tap
= jtag_tap_next_enabled(NULL
);
1062 LOG_ERROR("JTAG: No taps enabled?");
1063 return ERROR_JTAG_INIT_FAILED
;
1066 for (unsigned bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1068 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1069 if ((idcode
& 1) == 0)
1071 /* LSB must not be 0, this indicates a device in bypass */
1072 LOG_WARNING("Tap/Device does not have IDCODE");
1080 * End of chain (invalid manufacturer ID) some devices, such
1081 * as AVR will output all 1's instead of TDI input value at
1084 if (jtag_idcode_is_final(idcode
))
1086 jtag_examine_chain_end(idcode_buffer
,
1087 bit_count
+ 32, JTAG_MAX_CHAIN_SIZE
* 32);
1091 jtag_examine_chain_display(LOG_LVL_INFO
, "tap/device found",
1092 tap
? tap
->dotted_name
: "(not-named)",
1101 tap
->idcode
= idcode
;
1103 // ensure the TAP ID does matches what was expected
1104 if (!jtag_examine_chain_match_tap(tap
))
1105 return ERROR_JTAG_INIT_FAILED
;
1107 tap
= jtag_tap_next_enabled(tap
);
1110 /* see if number of discovered devices matches configuration */
1111 if (device_count
!= jtag_tap_count_enabled())
1113 LOG_ERROR("number of discovered devices in JTAG chain (%i) "
1114 "does not match (enabled) configuration (%i), total taps: %d",
1115 device_count
, jtag_tap_count_enabled(), jtag_tap_count());
1116 LOG_ERROR("check the config file and ensure proper JTAG communication"
1117 " (connections, speed, ...)");
1118 return ERROR_JTAG_INIT_FAILED
;
1124 static int jtag_validate_chain(void)
1127 int total_ir_length
= 0;
1133 total_ir_length
= 0;
1135 tap
= jtag_tap_next_enabled(tap
);
1139 total_ir_length
+= tap
->ir_length
;
1142 total_ir_length
+= 2;
1143 ir_test
= malloc(CEIL(total_ir_length
, 8));
1144 buf_set_ones(ir_test
, total_ir_length
);
1147 field
.num_bits
= total_ir_length
;
1148 field
.out_value
= ir_test
;
1149 field
.in_value
= ir_test
;
1152 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1153 jtag_execute_queue();
1159 tap
= jtag_tap_next_enabled(tap
);
1164 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1167 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1168 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
);
1171 return ERROR_JTAG_INIT_FAILED
;
1173 chain_pos
+= tap
->ir_length
;
1176 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1179 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1180 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
);
1183 return ERROR_JTAG_INIT_FAILED
;
1191 enum jtag_tap_cfg_param
{
1195 static Jim_Nvp nvp_config_opts
[] = {
1196 { .name
= "-event", .value
= JCFG_EVENT
},
1198 { .name
= NULL
, .value
= -1 }
1201 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1207 /* parse config or cget options */
1208 while (goi
->argc
> 0) {
1209 Jim_SetEmptyResult (goi
->interp
);
1211 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1213 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1219 if (goi
->argc
== 0) {
1220 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1224 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1226 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1230 if (goi
->isconfigure
) {
1231 if (goi
->argc
!= 1) {
1232 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1236 if (goi
->argc
!= 0) {
1237 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1243 jtag_tap_event_action_t
*jteap
;
1245 jteap
= tap
->event_action
;
1246 /* replace existing? */
1248 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1251 jteap
= jteap
->next
;
1254 if (goi
->isconfigure
) {
1255 if (jteap
== NULL
) {
1257 jteap
= calloc(1, sizeof (*jteap
));
1259 jteap
->event
= n
->value
;
1260 Jim_GetOpt_Obj( goi
, &o
);
1262 Jim_DecrRefCount(interp
, jteap
->body
);
1264 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1265 Jim_IncrRefCount(jteap
->body
);
1267 /* add to head of event list */
1268 jteap
->next
= tap
->event_action
;
1269 tap
->event_action
= jteap
;
1270 Jim_SetEmptyResult(goi
->interp
);
1273 if (jteap
== NULL
) {
1274 Jim_SetEmptyResult(goi
->interp
);
1276 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1283 } /* while (goi->argc) */
1289 static void jtag_tap_init(jtag_tap_t
*tap
)
1291 assert(0 != tap
->ir_length
);
1293 tap
->expected
= malloc(tap
->ir_length
);
1294 tap
->expected_mask
= malloc(tap
->ir_length
);
1295 tap
->cur_instr
= malloc(tap
->ir_length
);
1297 buf_set_u32(tap
->expected
, 0, tap
->ir_length
, tap
->ir_capture_value
);
1298 buf_set_u32(tap
->expected_mask
, 0, tap
->ir_length
, tap
->ir_capture_mask
);
1299 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1301 // place TAP in bypass mode
1303 // register the reset callback for the TAP
1304 jtag_register_event_callback(&jtag_reset_callback
, tap
);
1306 LOG_DEBUG("Created Tap: %s @ abs position %d, "
1307 "irlen %d, capture: 0x%x mask: 0x%x", tap
->dotted_name
,
1308 tap
->abs_chain_position
, tap
->ir_length
,
1309 tap
->ir_capture_value
, tap
->ir_capture_mask
);
1313 static void jtag_tap_free(jtag_tap_t
*tap
)
1315 /// @todo is anything missing? no memory leaks please
1316 free((void *)tap
->expected_ids
);
1317 free((void *)tap
->chip
);
1318 free((void *)tap
->tapname
);
1319 free((void *)tap
->dotted_name
);
1323 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1332 const Jim_Nvp opts
[] = {
1333 #define NTAP_OPT_IRLEN 0
1334 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1335 #define NTAP_OPT_IRMASK 1
1336 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
1337 #define NTAP_OPT_IRCAPTURE 2
1338 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
1339 #define NTAP_OPT_ENABLED 3
1340 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
1341 #define NTAP_OPT_DISABLED 4
1342 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
1343 #define NTAP_OPT_EXPECTED_ID 5
1344 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
1345 { .name
= NULL
, .value
= -1 },
1348 pTap
= malloc( sizeof(jtag_tap_t
) );
1349 memset( pTap
, 0, sizeof(*pTap
) );
1351 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1355 * we expect CHIP + TAP + OPTIONS
1357 if( goi
->argc
< 3 ){
1358 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
1361 Jim_GetOpt_String( goi
, &cp
, NULL
);
1362 pTap
->chip
= strdup(cp
);
1364 Jim_GetOpt_String( goi
, &cp
, NULL
);
1365 pTap
->tapname
= strdup(cp
);
1367 /* name + dot + name + null */
1368 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
1370 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
1371 pTap
->dotted_name
= cp
;
1373 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1374 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
1376 /* default is enabled */
1379 /* deal with options */
1380 #define NTREQ_IRLEN 1
1381 #define NTREQ_IRCAPTURE 2
1382 #define NTREQ_IRMASK 4
1384 /* clear them as we find them */
1385 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
1388 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
1390 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
1393 LOG_DEBUG("Processing option: %s", n
->name
);
1395 case NTAP_OPT_ENABLED
:
1398 case NTAP_OPT_DISABLED
:
1401 case NTAP_OPT_EXPECTED_ID
:
1403 u32
*new_expected_ids
;
1405 e
= Jim_GetOpt_Wide( goi
, &w
);
1407 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
1411 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
1412 if (new_expected_ids
== NULL
) {
1413 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1417 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
1419 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
1421 free(pTap
->expected_ids
);
1422 pTap
->expected_ids
= new_expected_ids
;
1423 pTap
->expected_ids_cnt
++;
1426 case NTAP_OPT_IRLEN
:
1427 case NTAP_OPT_IRMASK
:
1428 case NTAP_OPT_IRCAPTURE
:
1429 e
= Jim_GetOpt_Wide( goi
, &w
);
1431 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
1434 if( (w
< 0) || (w
> 0xffff) ){
1436 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
1437 n
->name
, (int)(w
), (int)(w
));
1441 case NTAP_OPT_IRLEN
:
1442 pTap
->ir_length
= w
;
1443 reqbits
&= (~(NTREQ_IRLEN
));
1445 case NTAP_OPT_IRMASK
:
1446 pTap
->ir_capture_mask
= w
;
1447 reqbits
&= (~(NTREQ_IRMASK
));
1449 case NTAP_OPT_IRCAPTURE
:
1450 pTap
->ir_capture_value
= w
;
1451 reqbits
&= (~(NTREQ_IRCAPTURE
));
1454 } /* switch(n->value) */
1455 } /* while( goi->argc ) */
1457 /* Did all the required option bits get cleared? */
1460 jtag_tap_init(pTap
);
1464 Jim_SetResult_sprintf(goi
->interp
,
1465 "newtap: %s missing required parameters",
1467 jtag_tap_free(pTap
);
1471 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1477 struct command_context_s
*context
;
1481 JTAG_CMD_INIT_RESET
,
1484 JTAG_CMD_TAPDISABLE
,
1485 JTAG_CMD_TAPISENABLED
,
1490 const Jim_Nvp jtag_cmds
[] = {
1491 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
1492 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
1493 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
1494 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
1495 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
1496 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
1497 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
1498 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
1500 { .name
= NULL
, .value
= -1 },
1503 context
= Jim_GetAssocData(interp
, "context");
1504 /* go past the command */
1505 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
1507 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
1509 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
1512 Jim_SetEmptyResult( goi
.interp
);
1514 case JTAG_CMD_INTERFACE
:
1515 /* return the name of the interface */
1516 /* TCL code might need to know the exact type... */
1517 /* FUTURE: we allow this as a means to "set" the interface. */
1518 if( goi
.argc
!= 0 ){
1519 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1522 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
1524 case JTAG_CMD_INIT_RESET
:
1525 if( goi
.argc
!= 0 ){
1526 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1529 e
= jtag_init_reset(context
);
1530 if( e
!= ERROR_OK
){
1531 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
1535 case JTAG_CMD_NEWTAP
:
1536 return jim_newtap_cmd( &goi
);
1538 case JTAG_CMD_TAPISENABLED
:
1539 case JTAG_CMD_TAPENABLE
:
1540 case JTAG_CMD_TAPDISABLE
:
1541 if( goi
.argc
!= 1 ){
1542 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
1548 t
= jtag_tap_by_jim_obj( goi
.interp
, goi
.argv
[0] );
1553 case JTAG_CMD_TAPISENABLED
:
1556 case JTAG_CMD_TAPENABLE
:
1557 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
1561 case JTAG_CMD_TAPDISABLE
:
1562 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
1567 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
1574 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
1581 Jim_GetOpt_Obj(&goi
, &o
);
1582 t
= jtag_tap_by_jim_obj( goi
.interp
, o
);
1587 goi
.isconfigure
= 0;
1588 return jtag_tap_configure_cmd( &goi
, t
);
1592 case JTAG_CMD_CONFIGURE
:
1594 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
1601 Jim_GetOpt_Obj(&goi
, &o
);
1602 t
= jtag_tap_by_jim_obj( goi
.interp
, o
);
1607 goi
.isconfigure
= 1;
1608 return jtag_tap_configure_cmd( &goi
, t
);
1615 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1617 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
1619 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1620 COMMAND_CONFIG
, "try to configure interface");
1621 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1622 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
1623 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1624 COMMAND_ANY
, "set maximum jtag speed (if supported); "
1625 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1626 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1627 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1628 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1630 "[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]");
1631 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1632 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1633 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1634 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1636 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1637 COMMAND_EXEC
, "print current scan chain configuration");
1639 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1640 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1641 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1642 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1643 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1644 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1645 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1646 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
1648 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1649 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1650 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
1651 COMMAND_ANY
, "verify value capture <enable|disable>");
1652 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
1653 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
1657 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1662 if (!jtag_interface
)
1664 /* nothing was previously specified by "interface" command */
1665 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1666 return ERROR_JTAG_INVALID_INTERFACE
;
1670 jtag_interface
->khz(jtag_get_speed_khz(), &jtag_speed
);
1674 if (jtag_interface
->init() != ERROR_OK
)
1675 return ERROR_JTAG_INIT_FAILED
;
1677 jtag
= jtag_interface
;
1681 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1686 LOG_DEBUG("Init JTAG chain");
1688 tap
= jtag_tap_next_enabled(NULL
);
1690 LOG_ERROR("There are no enabled taps?");
1691 return ERROR_JTAG_INIT_FAILED
;
1695 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1698 /* examine chain first, as this could discover the real chain layout */
1699 if (jtag_examine_chain() != ERROR_OK
)
1701 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1704 if (jtag_validate_chain() != ERROR_OK
)
1706 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1712 int jtag_interface_quit(void)
1714 if (!jtag
|| !jtag
->quit
)
1717 // close the JTAG interface
1718 int result
= jtag
->quit();
1719 if (ERROR_OK
!= result
)
1720 LOG_ERROR("failed: %d", result
);
1726 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1730 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1733 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1735 /* Reset can happen after a power cycle.
1737 * Ideally we would only assert TRST or run RESET before the target reset.
1739 * However w/srst_pulls_trst, trst is asserted together with the target
1740 * reset whether we want it or not.
1742 * NB! Some targets have JTAG circuitry disabled until a
1743 * trst & srst has been asserted.
1745 * NB! here we assume nsrst/ntrst delay are sufficient!
1747 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1750 jtag_add_reset(1, 0); /* RESET or TRST */
1751 if (jtag_reset_config
& RESET_HAS_SRST
)
1753 jtag_add_reset(1, 1);
1754 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1755 jtag_add_reset(0, 1);
1757 jtag_add_reset(0, 0);
1758 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1761 /* Check that we can communication on the JTAG chain + eventually we want to
1762 * be able to perform enumeration only after OpenOCD has started
1763 * telnet and GDB server
1765 * That would allow users to more easily perform any magic they need to before
1768 return jtag_init_inner(cmd_ctx
);
1771 int jtag_init(struct command_context_s
*cmd_ctx
)
1774 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1776 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1780 return jtag_init_reset(cmd_ctx
);
1783 void jtag_set_speed_khz(unsigned khz
)
1787 unsigned jtag_get_speed_khz(void)
1792 static int default_khz(int khz
, int *jtag_speed
)
1794 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1798 static int default_speed_div(int speed
, int *khz
)
1800 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1804 static int default_power_dropout(int *dropout
)
1806 *dropout
=0; /* by default we can't detect power dropout */
1810 static int default_srst_asserted(int *srst_asserted
)
1812 *srst_asserted
=0; /* by default we can't detect srst asserted */
1816 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1821 /* check whether the interface is already configured */
1824 LOG_WARNING("Interface already configured, ignoring");
1828 /* interface name is a mandatory argument */
1829 if (argc
< 1 || args
[0][0] == '\0')
1831 return ERROR_COMMAND_SYNTAX_ERROR
;
1834 for (i
=0; jtag_interfaces
[i
]; i
++)
1836 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1838 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
1843 jtag_interface
= jtag_interfaces
[i
];
1845 if (jtag_interface
->khz
== NULL
)
1847 jtag_interface
->khz
= default_khz
;
1849 if (jtag_interface
->speed_div
== NULL
)
1851 jtag_interface
->speed_div
= default_speed_div
;
1853 if (jtag_interface
->power_dropout
== NULL
)
1855 jtag_interface
->power_dropout
= default_power_dropout
;
1857 if (jtag_interface
->srst_asserted
== NULL
)
1859 jtag_interface
->srst_asserted
= default_srst_asserted
;
1866 /* no valid interface was found (i.e. the configuration option,
1867 * didn't match one of the compiled-in interfaces
1869 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
1870 LOG_ERROR("compiled-in jtag interfaces:");
1871 for (i
= 0; jtag_interfaces
[i
]; i
++)
1873 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1876 return ERROR_JTAG_INVALID_INTERFACE
;
1879 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1883 Jim_Obj
*newargs
[ 10 ];
1886 * argv[-1] = command
1887 * argv[ 0] = ir length
1888 * argv[ 1] = ir capture
1889 * argv[ 2] = ir mask
1890 * argv[ 3] = not actually used by anything but in the docs
1894 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
1897 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
1898 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
1902 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
1903 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
1904 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
1905 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
1907 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
1908 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
1909 sprintf( buf
, "chip%d", jtag_tap_count() );
1910 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
1911 sprintf( buf
, "tap%d", jtag_tap_count() );
1912 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
1913 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
1914 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
1915 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
1916 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
1917 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
1918 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
1920 command_print( cmd_ctx
, "NEW COMMAND:");
1921 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
1922 Jim_GetString( newargs
[0], NULL
),
1923 Jim_GetString( newargs
[1], NULL
),
1924 Jim_GetString( newargs
[2], NULL
),
1925 Jim_GetString( newargs
[3], NULL
),
1926 Jim_GetString( newargs
[4], NULL
),
1927 Jim_GetString( newargs
[5], NULL
),
1928 Jim_GetString( newargs
[6], NULL
),
1929 Jim_GetString( newargs
[7], NULL
),
1930 Jim_GetString( newargs
[8], NULL
),
1931 Jim_GetString( newargs
[9], NULL
) );
1933 e
= jim_jtag_command( interp
, 10, newargs
);
1935 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
1940 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1944 tap
= jtag_all_taps();
1945 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
1946 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
1949 u32 expected
, expected_mask
, cur_instr
, ii
;
1950 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
1951 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
1952 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
1954 command_print(cmd_ctx
,
1955 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
1956 tap
->abs_chain_position
,
1958 tap
->enabled
? 'Y' : 'n',
1960 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
1966 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
1967 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
1968 tap
->expected_ids
[ii
]);
1971 tap
= tap
->next_tap
;
1977 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1983 return ERROR_COMMAND_SYNTAX_ERROR
;
1985 /* Original versions cared about the order of these tokens:
1986 * reset_config signals [combination [trst_type [srst_type]]]
1987 * They also clobbered the previous configuration even on error.
1989 * Here we don't care about the order, and only change values
1990 * which have been explicitly specified.
1992 for (; argc
; argc
--, args
++) {
1997 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
1998 if (strcmp(*args
, "none") == 0)
2000 else if (strcmp(*args
, "trst_only") == 0)
2001 tmp
= RESET_HAS_TRST
;
2002 else if (strcmp(*args
, "srst_only") == 0)
2003 tmp
= RESET_HAS_SRST
;
2004 else if (strcmp(*args
, "trst_and_srst") == 0)
2005 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
2009 LOG_ERROR("extra reset_config %s spec (%s)",
2011 return ERROR_INVALID_ARGUMENTS
;
2016 /* combination (options for broken wiring) */
2017 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2018 if (strcmp(*args
, "separate") == 0)
2019 /* separate reset lines - default */;
2020 else if (strcmp(*args
, "srst_pulls_trst") == 0)
2021 tmp
|= RESET_SRST_PULLS_TRST
;
2022 else if (strcmp(*args
, "trst_pulls_srst") == 0)
2023 tmp
|= RESET_TRST_PULLS_SRST
;
2024 else if (strcmp(*args
, "combined") == 0)
2025 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2029 LOG_ERROR("extra reset_config %s spec (%s)",
2030 "combination", *args
);
2031 return ERROR_INVALID_ARGUMENTS
;
2036 /* trst_type (NOP without HAS_TRST) */
2037 m
= RESET_TRST_OPEN_DRAIN
;
2038 if (strcmp(*args
, "trst_open_drain") == 0)
2039 tmp
|= RESET_TRST_OPEN_DRAIN
;
2040 else if (strcmp(*args
, "trst_push_pull") == 0)
2041 /* push/pull from adapter - default */;
2045 LOG_ERROR("extra reset_config %s spec (%s)",
2046 "trst_type", *args
);
2047 return ERROR_INVALID_ARGUMENTS
;
2052 /* srst_type (NOP without HAS_SRST) */
2053 m
|= RESET_SRST_PUSH_PULL
;
2054 if (strcmp(*args
, "srst_push_pull") == 0)
2055 tmp
|= RESET_SRST_PUSH_PULL
;
2056 else if (strcmp(*args
, "srst_open_drain") == 0)
2057 /* open drain from adapter - default */;
2061 LOG_ERROR("extra reset_config %s spec (%s)",
2062 "srst_type", *args
);
2063 return ERROR_INVALID_ARGUMENTS
;
2068 /* caller provided nonsense; fail */
2069 LOG_ERROR("unknown reset_config flag (%s)", *args
);
2070 return ERROR_INVALID_ARGUMENTS
;
2073 /* Remember the bits which were specified (mask)
2074 * and their new values (new_cfg).
2080 /* clear previous values of those bits, save new values */
2081 jtag_reset_config
&= ~mask
;
2082 jtag_reset_config
|= new_cfg
;
2087 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
,
2088 char *cmd
, char **args
, int argc
)
2091 return ERROR_COMMAND_SYNTAX_ERROR
;
2093 jtag_set_nsrst_delay(strtoul(args
[0], NULL
, 0));
2094 command_print(cmd_ctx
, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
2098 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
,
2099 char *cmd
, char **args
, int argc
)
2102 return ERROR_COMMAND_SYNTAX_ERROR
;
2104 jtag_set_ntrst_delay(strtoul(args
[0], NULL
, 0));
2105 command_print(cmd_ctx
, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
2109 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2111 int retval
= ERROR_OK
;
2114 return ERROR_COMMAND_SYNTAX_ERROR
;
2117 LOG_DEBUG("handle jtag speed");
2120 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2122 /* this command can be called during CONFIG,
2123 * in which case jtag isn't initialized */
2125 retval
= jtag
->speed(cur_speed
);
2127 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2132 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2135 return ERROR_COMMAND_SYNTAX_ERROR
;
2137 int retval
= ERROR_OK
;
2141 LOG_DEBUG("handle jtag khz");
2143 jtag_set_speed_khz(strtoul(args
[0], NULL
, 0));
2146 LOG_DEBUG("have interface set up");
2148 retval
= jtag
->khz(jtag_get_speed_khz(), &speed_div1
);
2149 if (ERROR_OK
!= retval
)
2151 jtag_set_speed_khz(0);
2154 cur_speed
= jtag_speed
= speed_div1
;
2156 retval
= jtag
->speed(cur_speed
);
2162 cur_speed
= jtag_get_speed_khz();
2165 retval
= jtag
->speed_div(jtag_speed
, &cur_speed
);
2166 if (ERROR_OK
!= retval
)
2171 command_print(cmd_ctx
, "%d kHz", cur_speed
);
2173 command_print(cmd_ctx
, "RCLK - adaptive");
2178 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
,
2179 char *cmd
, char **args
, int argc
)
2182 return ERROR_COMMAND_SYNTAX_ERROR
;
2185 if (args
[0][0] == '1')
2187 else if (args
[0][0] == '0')
2190 return ERROR_COMMAND_SYNTAX_ERROR
;
2193 if (args
[1][0] == '1')
2195 else if (args
[1][0] == '0')
2198 return ERROR_COMMAND_SYNTAX_ERROR
;
2200 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2201 return ERROR_JTAG_INIT_FAILED
;
2203 jtag_add_reset(trst
, srst
);
2204 jtag_execute_queue();
2209 static int handle_runtest_command(struct command_context_s
*cmd_ctx
,
2210 char *cmd
, char **args
, int argc
)
2213 return ERROR_COMMAND_SYNTAX_ERROR
;
2215 jtag_add_runtest(strtol(args
[0], NULL
, 0), jtag_get_end_state());
2216 jtag_execute_queue();
2222 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2223 * should be stable ... and *NOT* a shift state, otherwise free-running
2224 * jtag clocks could change the values latched by the update state.
2226 static bool scan_is_safe(tap_state_t state
)
2241 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2244 scan_field_t
*fields
;
2246 tap_state_t endstate
;
2248 if ((argc
< 2) || (argc
% 2))
2250 return ERROR_COMMAND_SYNTAX_ERROR
;
2253 /* optional "-endstate" "statename" at the end of the arguments,
2254 * so that e.g. IRPAUSE can let us load the data register before
2255 * entering RUN/IDLE to execute the instruction we load here.
2257 endstate
= TAP_IDLE
;
2260 /* have at least one pair of numbers. */
2261 /* is last pair the magic text? */
2262 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
2265 cpA
= args
[ argc
-1 ];
2266 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
2267 cpS
= tap_state_name( endstate
);
2268 if( 0 == strcmp( cpA
, cpS
) ){
2272 if( endstate
>= TAP_NUM_STATES
){
2273 return ERROR_COMMAND_SYNTAX_ERROR
;
2275 if (!scan_is_safe(endstate
))
2276 LOG_WARNING("irscan with unsafe "
2277 "endstate \"%s\"", cpA
);
2278 /* found - remove the last 2 args */
2284 int num_fields
= argc
/ 2;
2286 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2288 for (i
= 0; i
< num_fields
; i
++)
2290 tap
= jtag_tap_by_string( args
[i
*2] );
2293 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2296 int field_size
= tap
->ir_length
;
2297 fields
[i
].tap
= tap
;
2298 fields
[i
].num_bits
= field_size
;
2299 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2300 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2301 fields
[i
].in_value
= NULL
;
2304 /* did we have an endstate? */
2305 jtag_add_ir_scan(num_fields
, fields
, endstate
);
2307 int retval
=jtag_execute_queue();
2309 for (i
= 0; i
< num_fields
; i
++)
2310 free(fields
[i
].out_value
);
2317 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2320 scan_field_t
*fields
;
2322 int field_count
= 0;
2325 tap_state_t endstate
;
2328 * args[2] = num_bits
2329 * args[3] = hex string
2330 * ... repeat num bits and hex string ...
2333 * args[N-2] = "-endstate"
2334 * args[N-1] = statename
2336 if ((argc
< 4) || ((argc
% 2)!=0))
2338 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2342 endstate
= TAP_IDLE
;
2344 /* validate arguments as numbers */
2346 for (i
= 2; i
< argc
; i
+=2)
2351 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2352 /* If valid - try next arg */
2357 /* Not valid.. are we at the end? */
2358 if ( ((i
+2) != argc
) ){
2359 /* nope, then error */
2363 /* it could be: "-endstate FOO"
2364 * e.g. DRPAUSE so we can issue more instructions
2365 * before entering RUN/IDLE and executing them.
2368 /* get arg as a string. */
2369 cp
= Jim_GetString( args
[i
], NULL
);
2370 /* is it the magic? */
2371 if( 0 == strcmp( "-endstate", cp
) ){
2372 /* is the statename valid? */
2373 cp
= Jim_GetString( args
[i
+1], NULL
);
2375 /* see if it is a valid state name */
2376 endstate
= tap_state_by_name(cp
);
2378 /* update the error message */
2379 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
2381 if (!scan_is_safe(endstate
))
2382 LOG_WARNING("drscan with unsafe "
2383 "endstate \"%s\"", cp
);
2385 /* valid - so clear the error */
2387 /* and remove the last 2 args */
2392 /* Still an error? */
2394 return e
; /* too bad */
2396 } /* validate args */
2398 tap
= jtag_tap_by_jim_obj( interp
, args
[1] );
2403 num_fields
=(argc
-2)/2;
2404 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2405 for (i
= 2; i
< argc
; i
+=2)
2411 Jim_GetLong(interp
, args
[i
], &bits
);
2412 str
= Jim_GetString(args
[i
+1], &len
);
2414 fields
[field_count
].tap
= tap
;
2415 fields
[field_count
].num_bits
= bits
;
2416 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2417 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2418 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2422 jtag_add_dr_scan(num_fields
, fields
, endstate
);
2424 retval
= jtag_execute_queue();
2425 if (retval
!= ERROR_OK
)
2427 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
2432 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2433 for (i
= 2; i
< argc
; i
+=2)
2438 Jim_GetLong(interp
, args
[i
], &bits
);
2439 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2440 free(fields
[field_count
].out_value
);
2442 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2447 Jim_SetResult(interp
, list
);
2455 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2457 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_get_flush_queue_count()));
2463 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2467 if (strcmp(args
[0], "enable") == 0)
2469 jtag_verify_capture_ir
= 1;
2471 else if (strcmp(args
[0], "disable") == 0)
2473 jtag_verify_capture_ir
= 0;
2476 return ERROR_COMMAND_SYNTAX_ERROR
;
2478 } else if (argc
!= 0)
2480 return ERROR_COMMAND_SYNTAX_ERROR
;
2483 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2488 void jtag_set_verify(bool enable
)
2490 jtag_verify
= enable
;
2493 bool jtag_will_verify()
2498 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2501 return ERROR_COMMAND_SYNTAX_ERROR
;
2505 if (strcmp(args
[0], "enable") == 0)
2506 jtag_set_verify(true);
2507 else if (strcmp(args
[0], "disable") == 0)
2508 jtag_set_verify(false);
2510 return ERROR_COMMAND_SYNTAX_ERROR
;
2513 const char *status
= jtag_will_verify() ? "enabled": "disabled";
2514 command_print(cmd_ctx
, "verify jtag capture is %s", status
);
2520 int jtag_power_dropout(int *dropout
)
2522 return jtag
->power_dropout(dropout
);
2525 int jtag_srst_asserted(int *srst_asserted
)
2527 return jtag
->srst_asserted(srst_asserted
);
2530 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
2532 jtag_tap_event_action_t
* jteap
;
2535 jteap
= tap
->event_action
;
2539 if (jteap
->event
== e
) {
2541 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2544 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
2545 Jim_GetString(jteap
->body
, NULL
) );
2546 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
2547 Jim_PrintErrorMessage(interp
);
2551 jteap
= jteap
->next
;
2555 LOG_DEBUG( "event %d %s - no action",
2557 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
2561 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2564 return ERROR_COMMAND_SYNTAX_ERROR
;
2569 if (strcmp(args
[0], "short") == 0)
2570 use_new_table
= true;
2571 else if (strcmp(args
[0], "long") == 0)
2572 use_new_table
= false;
2574 return ERROR_COMMAND_SYNTAX_ERROR
;
2576 tap_use_new_tms_table(use_new_table
);
2579 command_print(cmd_ctx
, "tms sequence is %s",
2580 tap_uses_new_tms_table() ? "short": "long");
2586 * Function jtag_add_statemove
2587 * moves from the current state to the goal \a state. This needs
2588 * to be handled according to the xsvf spec, see the XSTATE command
2591 int jtag_add_statemove(tap_state_t goal_state
)
2593 int retval
= ERROR_OK
;
2595 tap_state_t moves
[8];
2596 tap_state_t cur_state
= cmd_queue_cur_state
;
2601 LOG_DEBUG( "cur_state=%s goal_state=%s",
2602 tap_state_name(cur_state
),
2603 tap_state_name(goal_state
) );
2606 /* From the XSVF spec, pertaining to XSTATE:
2608 For special states known as stable states (Test-Logic-Reset,
2609 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2610 predefined TAP state paths when the starting state is a stable state and
2611 when the XSTATE specifies a new stable state (see the STATE command in
2612 the [Ref 5] for the TAP state paths between stable states). For
2613 non-stable states, XSTATE should specify a state that is only one TAP
2614 state transition distance from the current TAP state to avoid undefined
2615 TAP state paths. A sequence of multiple XSTATE commands can be issued to
2616 transition the TAP through a specific state path.
2619 if (goal_state
==cur_state
)
2620 ; /* nothing to do */
2622 else if( goal_state
==TAP_RESET
)
2627 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
2629 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
2630 spec, then this code is not fully conformant to the xsvf spec. This
2631 puts a burden on tap_get_tms_path() function from the xsvf spec.
2632 If in doubt, you should confirm that that burden is being met.
2635 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
2636 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
2638 assert( (unsigned) tms_count
< DIM(moves
) );
2640 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
2642 bool bit
= tms_bits
& 1;
2644 cur_state
= tap_state_transition(cur_state
, bit
);
2645 moves
[i
] = cur_state
;
2648 jtag_add_pathmove(tms_count
, moves
);
2651 /* else state must be immediately reachable in one clock cycle, and does not
2652 need to be a stable state.
2654 else if( tap_state_transition(cur_state
, true) == goal_state
2655 || tap_state_transition(cur_state
, false) == goal_state
)
2657 /* move a single state */
2658 moves
[0] = goal_state
;
2659 jtag_add_pathmove( 1, moves
);
2664 retval
= ERROR_FAIL
;
2670 void jtag_set_nsrst_delay(unsigned delay
)
2672 jtag_nsrst_delay
= delay
;
2674 unsigned jtag_get_nsrst_delay(void)
2676 return jtag_nsrst_delay
;
2678 void jtag_set_ntrst_delay(unsigned delay
)
2680 jtag_ntrst_delay
= delay
;
2682 unsigned jtag_get_ntrst_delay(void)
2684 return jtag_ntrst_delay
;