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 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 char* jtag_event_strings
[] =
52 "JTAG controller reset (RESET or TRST)"
55 const Jim_Nvp nvp_jtag_tap_event
[] = {
56 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
57 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
59 { .name
= NULL
, .value
= -1 }
65 static jtag_tap_t
*jtag_all_taps
= NULL
;
67 enum reset_types jtag_reset_config
= RESET_NONE
;
68 tap_state_t cmd_queue_end_state
= TAP_RESET
;
69 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
71 int jtag_verify_capture_ir
= 1;
74 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
75 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
76 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
78 /* maximum number of JTAG devices expected in the chain
80 #define JTAG_MAX_CHAIN_SIZE 20
82 /* callbacks to inform high-level handlers about JTAG state changes */
83 jtag_event_callback_t
*jtag_event_callbacks
;
86 static int speed_khz
= 0;
87 /* flag if the kHz speed was defined */
88 static int hasKHz
= 0;
90 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
93 #if BUILD_ECOSBOARD == 1
94 extern jtag_interface_t zy1000_interface
;
97 #if BUILD_PARPORT == 1
98 extern jtag_interface_t parport_interface
;
102 extern jtag_interface_t dummy_interface
;
105 #if BUILD_FT2232_FTD2XX == 1
106 extern jtag_interface_t ft2232_interface
;
109 #if BUILD_FT2232_LIBFTDI == 1
110 extern jtag_interface_t ft2232_interface
;
113 #if BUILD_AMTJTAGACCEL == 1
114 extern jtag_interface_t amt_jtagaccel_interface
;
117 #if BUILD_EP93XX == 1
118 extern jtag_interface_t ep93xx_interface
;
121 #if BUILD_AT91RM9200 == 1
122 extern jtag_interface_t at91rm9200_interface
;
125 #if BUILD_GW16012 == 1
126 extern jtag_interface_t gw16012_interface
;
129 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
130 extern jtag_interface_t presto_interface
;
133 #if BUILD_USBPROG == 1
134 extern jtag_interface_t usbprog_interface
;
138 extern jtag_interface_t jlink_interface
;
141 #if BUILD_VSLLINK == 1
142 extern jtag_interface_t vsllink_interface
;
146 extern jtag_interface_t rlink_interface
;
149 #if BUILD_ARMJTAGEW == 1
150 extern jtag_interface_t armjtagew_interface
;
153 jtag_interface_t
*jtag_interfaces
[] = {
154 #if BUILD_ECOSBOARD == 1
157 #if BUILD_PARPORT == 1
163 #if BUILD_FT2232_FTD2XX == 1
166 #if BUILD_FT2232_LIBFTDI == 1
169 #if BUILD_AMTJTAGACCEL == 1
170 &amt_jtagaccel_interface
,
172 #if BUILD_EP93XX == 1
175 #if BUILD_AT91RM9200 == 1
176 &at91rm9200_interface
,
178 #if BUILD_GW16012 == 1
181 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
184 #if BUILD_USBPROG == 1
190 #if BUILD_VSLLINK == 1
196 #if BUILD_ARMJTAGEW == 1
197 &armjtagew_interface
,
202 struct jtag_interface_s
*jtag
= NULL
;
205 static jtag_interface_t
*jtag_interface
= NULL
;
209 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
210 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
211 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
212 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
213 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
214 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
215 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
217 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
219 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
220 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
221 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
222 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
223 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
224 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
226 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
227 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
228 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
230 jtag_tap_t
*jtag_AllTaps(void)
232 return jtag_all_taps
;
235 int jtag_NumTotalTaps(void)
249 int jtag_NumEnabledTaps(void)
265 jtag_tap_t
*jtag_TapByString( const char *s
)
273 if( 0 == strcmp( t
->dotted_name
, s
) ){
279 /* backup plan is by number */
281 /* ok - is "s" a number? */
283 n
= strtol( s
, &cp
, 0 );
284 if( (s
!= cp
) && (*cp
== 0) ){
286 t
= jtag_TapByAbsPosition(n
);
292 jtag_tap_t
* jtag_TapByJimObj( Jim_Interp
*interp
, Jim_Obj
*o
)
297 cp
= Jim_GetString( o
, NULL
);
302 t
= jtag_TapByString( cp
);
305 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
310 /* returns a pointer to the n-th device in the scan chain */
311 jtag_tap_t
* jtag_TapByAbsPosition( int n
)
319 while( t
&& (n
> 0)) {
326 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
328 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
330 if (callback
== NULL
)
332 return ERROR_INVALID_ARGUMENTS
;
337 while ((*callbacks_p
)->next
)
338 callbacks_p
= &((*callbacks_p
)->next
);
339 callbacks_p
= &((*callbacks_p
)->next
);
342 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
343 (*callbacks_p
)->callback
= callback
;
344 (*callbacks_p
)->priv
= priv
;
345 (*callbacks_p
)->next
= NULL
;
350 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
352 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
354 if (callback
== NULL
)
356 return ERROR_INVALID_ARGUMENTS
;
361 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
362 if ((*callbacks_p
)->callback
== callback
)
365 *callbacks_p
= *next
;
373 int jtag_call_event_callbacks(enum jtag_event event
)
375 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
377 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
381 callback
->callback(event
, callback
->priv
);
382 callback
= callback
->next
;
388 static void jtag_prelude1(void)
392 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
393 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
397 if (cmd_queue_end_state
== TAP_RESET
)
398 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
401 static void jtag_prelude(tap_state_t state
)
405 if (state
!= TAP_INVALID
)
406 jtag_add_end_state(state
);
408 cmd_queue_cur_state
= cmd_queue_end_state
;
411 void jtag_alloc_in_value32(scan_field_t
*field
)
413 interface_jtag_alloc_in_value32(field
);
416 void jtag_add_ir_scan_noverify(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
421 retval
=interface_jtag_add_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
422 if (retval
!=ERROR_OK
)
429 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
431 * If the input field list contains an instruction value for a TAP then that is used
432 * otherwise the TAP is set to bypass.
434 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
437 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
439 if (jtag_verify
&&jtag_verify_capture_ir
)
441 /* 8 x 32 bit id's is enough for all invocations */
443 for (int j
= 0; j
< in_num_fields
; j
++)
445 /* if we are to run a verification of the ir scan, we need to get the input back.
446 * We may have to allocate space if the caller didn't ask for the input back.
448 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
449 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
451 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
454 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
459 * Duplicate the scan fields passed into the function into an IR SCAN command
461 * This function assumes that the caller handles extra fields for bypassed TAPs
464 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
470 retval
=interface_jtag_add_plain_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
471 if (retval
!=ERROR_OK
)
475 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
477 interface_jtag_add_callback(f
, in
);
480 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
481 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
482 jtag_callback_data_t data3
)
484 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
487 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
489 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
491 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
494 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
495 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
497 for (int i
= 0; i
< in_num_fields
; i
++)
499 struct scan_field_s
*field
= &in_fields
[i
];
500 field
->allocated
= 0;
502 if (field
->check_value
|| field
->in_value
)
504 interface_jtag_add_scan_check_alloc(field
);
508 jtag_add_scan(in_num_fields
, in_fields
, state
);
510 for (int i
= 0; i
< in_num_fields
; i
++)
512 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
514 /* this is synchronous for a minidriver */
515 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
516 (jtag_callback_data_t
)in_fields
[i
].check_value
,
517 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
518 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
520 if (in_fields
[i
].allocated
)
522 free(in_fields
[i
].in_value
);
524 if (in_fields
[i
].modified
)
526 in_fields
[i
].in_value
= NULL
;
531 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
535 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
538 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
544 * Generate a DR SCAN using the fields passed to the function
546 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
547 * For bypassed TAPs the function generates a dummy 1bit field.
549 * The bypass status of TAPs is set by jtag_add_ir_scan().
552 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
558 retval
=interface_jtag_add_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
559 if (retval
!=ERROR_OK
)
566 * Duplicate the scan fields passed into the function into a DR SCAN command
568 * This function assumes that the caller handles extra fields for bypassed TAPs
571 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
577 retval
=interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
578 if (retval
!=ERROR_OK
)
582 void jtag_add_dr_out(jtag_tap_t
* tap
,
583 int num_fields
, const int* num_bits
, const u32
* value
,
584 tap_state_t end_state
)
586 if (end_state
!= TAP_INVALID
)
587 cmd_queue_end_state
= end_state
;
589 cmd_queue_cur_state
= cmd_queue_end_state
;
591 interface_jtag_add_dr_out(tap
,
592 num_fields
, num_bits
, value
,
593 cmd_queue_end_state
);
596 void jtag_add_tlr(void)
598 jtag_prelude(TAP_RESET
);
601 retval
=interface_jtag_add_tlr();
602 if (retval
!=ERROR_OK
)
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
, cmd_queue_end_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_add_end_state(TAP_RESET
);
763 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
769 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
770 * and inform possible listeners about this
772 LOG_DEBUG("TRST line asserted");
773 tap_set_state(TAP_RESET
);
774 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
778 if (jtag_ntrst_delay
)
779 jtag_add_sleep(jtag_ntrst_delay
* 1000);
783 void jtag_add_end_state(tap_state_t state
)
785 cmd_queue_end_state
= state
;
786 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
788 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
792 void jtag_add_sleep(u32 us
)
794 keep_alive(); /* we might be running on a very slow JTAG clk */
795 int retval
=interface_jtag_add_sleep(us
);
796 if (retval
!=ERROR_OK
)
801 static const char *jtag_tap_name(const jtag_tap_t
*tap
)
803 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
806 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
808 int retval
= ERROR_OK
;
810 int compare_failed
= 0;
813 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
815 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
818 /* An error handler could have caught the failing check
819 * only report a problem when there wasn't a handler, or if the handler
820 * acknowledged the error
823 LOG_WARNING("TAP %s:",
824 jtag_tap_name(field->tap));
828 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
829 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
833 char *in_check_mask_char
;
834 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
835 LOG_WARNING("value captured during scan didn't pass the requested check:");
836 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
837 captured_char
, in_check_value_char
, in_check_mask_char
);
838 free(in_check_mask_char
);
842 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
);
846 free(in_check_value_char
);
848 retval
= ERROR_JTAG_QUEUE_FAILED
;
855 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
857 assert(field
->in_value
!= NULL
);
861 /* no checking to do */
865 jtag_execute_queue_noclear();
867 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
868 jtag_set_error(retval
);
873 int default_interface_jtag_execute_queue(void)
877 LOG_ERROR("No JTAG interface configured yet. "
878 "Issue 'init' command in startup scripts "
879 "before communicating with targets.");
883 return jtag
->execute_queue();
886 void jtag_execute_queue_noclear(void)
888 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
889 * E.g. a JTAG over TCP/IP or USB....
891 jtag_flush_queue_count
++;
893 int retval
=interface_jtag_execute_queue();
894 /* we keep the first error */
895 if ((jtag_error
==ERROR_OK
)&&(retval
!=ERROR_OK
))
901 int jtag_execute_queue(void)
904 jtag_execute_queue_noclear();
910 int jtag_reset_callback(enum jtag_event event
, void *priv
)
912 jtag_tap_t
*tap
= priv
;
916 if (event
== JTAG_TRST_ASSERTED
)
918 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
925 void jtag_sleep(u32 us
)
927 alive_sleep(us
/1000);
930 /* Try to examine chain layout according to IEEE 1149.1 §12
932 int jtag_examine_chain(void)
936 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
939 int device_count
= 0;
944 field
.num_bits
= sizeof(idcode_buffer
) * 8;
945 field
.out_value
= idcode_buffer
;
947 field
.in_value
= idcode_buffer
;
952 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
954 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
957 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
958 jtag_execute_queue();
960 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
962 zero_check
|= idcode_buffer
[i
];
963 one_check
&= idcode_buffer
[i
];
966 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
967 if ((zero_check
== 0x00) || (one_check
== 0xff))
969 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
970 return ERROR_JTAG_INIT_FAILED
;
973 /* point at the 1st tap */
974 tap
= jtag_NextEnabledTap(NULL
);
976 LOG_ERROR("JTAG: No taps enabled?");
977 return ERROR_JTAG_INIT_FAILED
;
980 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
982 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
983 if ((idcode
& 1) == 0)
985 /* LSB must not be 0, this indicates a device in bypass */
986 LOG_WARNING("Tap/Device does not have IDCODE");
997 /* some devices, such as AVR will output all 1's instead of TDI
998 input value at end of chain. */
999 if ((idcode
== 0x000000FF)||(idcode
== 0xFFFFFFFF))
1002 /* End of chain (invalid manufacturer ID)
1004 * The JTAG examine is the very first thing that happens
1006 * A single JTAG device requires only 64 bits to be read back correctly.
1008 * The code below adds a check that the rest of the data scanned (640 bits)
1009 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1011 * earlier and gives more helpful/explicit error messages.
1013 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1015 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1016 if (unexpected
||((idcode
!= 0x000000FF)&&(idcode
!= 0xFFFFFFFF)))
1018 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1026 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1027 manufacturer
= EXTRACT_MFG(idcode
);
1028 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1029 part
= EXTRACT_PART(idcode
);
1030 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1031 version
= EXTRACT_VER(idcode
);
1033 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1034 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1035 idcode
, manufacturer
, part
, version
);
1041 tap
->idcode
= idcode
;
1043 if (tap
->expected_ids_cnt
> 0) {
1044 /* Loop over the expected identification codes and test for a match */
1046 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1047 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1052 /* If none of the expected ids matched, log an error */
1053 if (ii
== tap
->expected_ids_cnt
) {
1054 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1057 EXTRACT_MFG( tap
->idcode
),
1058 EXTRACT_PART( tap
->idcode
),
1059 EXTRACT_VER( tap
->idcode
) );
1060 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1061 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1064 tap
->expected_ids_cnt
,
1065 tap
->expected_ids
[ii
],
1066 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1067 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1068 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1071 return ERROR_JTAG_INIT_FAILED
;
1073 LOG_INFO("JTAG Tap/device matched");
1077 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1081 tap
= jtag_NextEnabledTap(tap
);
1086 /* see if number of discovered devices matches configuration */
1087 if (device_count
!= jtag_NumEnabledTaps())
1089 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1090 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1091 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1092 return ERROR_JTAG_INIT_FAILED
;
1098 int jtag_validate_chain(void)
1101 int total_ir_length
= 0;
1107 total_ir_length
= 0;
1109 tap
= jtag_NextEnabledTap(tap
);
1113 total_ir_length
+= tap
->ir_length
;
1116 total_ir_length
+= 2;
1117 ir_test
= malloc(CEIL(total_ir_length
, 8));
1118 buf_set_ones(ir_test
, total_ir_length
);
1121 field
.num_bits
= total_ir_length
;
1122 field
.out_value
= ir_test
;
1123 field
.in_value
= ir_test
;
1126 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1127 jtag_execute_queue();
1133 tap
= jtag_NextEnabledTap(tap
);
1138 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1141 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1142 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
);
1145 return ERROR_JTAG_INIT_FAILED
;
1147 chain_pos
+= tap
->ir_length
;
1150 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1153 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1154 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
);
1157 return ERROR_JTAG_INIT_FAILED
;
1165 enum jtag_tap_cfg_param
{
1169 static Jim_Nvp nvp_config_opts
[] = {
1170 { .name
= "-event", .value
= JCFG_EVENT
},
1172 { .name
= NULL
, .value
= -1 }
1175 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1181 /* parse config or cget options */
1182 while (goi
->argc
> 0) {
1183 Jim_SetEmptyResult (goi
->interp
);
1185 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1187 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1193 if (goi
->argc
== 0) {
1194 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1198 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1200 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1204 if (goi
->isconfigure
) {
1205 if (goi
->argc
!= 1) {
1206 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1210 if (goi
->argc
!= 0) {
1211 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1217 jtag_tap_event_action_t
*jteap
;
1219 jteap
= tap
->event_action
;
1220 /* replace existing? */
1222 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1225 jteap
= jteap
->next
;
1228 if (goi
->isconfigure
) {
1229 if (jteap
== NULL
) {
1231 jteap
= calloc(1, sizeof (*jteap
));
1233 jteap
->event
= n
->value
;
1234 Jim_GetOpt_Obj( goi
, &o
);
1236 Jim_DecrRefCount(interp
, jteap
->body
);
1238 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1239 Jim_IncrRefCount(jteap
->body
);
1241 /* add to head of event list */
1242 jteap
->next
= tap
->event_action
;
1243 tap
->event_action
= jteap
;
1244 Jim_SetEmptyResult(goi
->interp
);
1247 if (jteap
== NULL
) {
1248 Jim_SetEmptyResult(goi
->interp
);
1250 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1257 } /* while (goi->argc) */
1262 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1272 const Jim_Nvp opts
[] = {
1273 #define NTAP_OPT_IRLEN 0
1274 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1275 #define NTAP_OPT_IRMASK 1
1276 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
1277 #define NTAP_OPT_IRCAPTURE 2
1278 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
1279 #define NTAP_OPT_ENABLED 3
1280 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
1281 #define NTAP_OPT_DISABLED 4
1282 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
1283 #define NTAP_OPT_EXPECTED_ID 5
1284 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
1285 { .name
= NULL
, .value
= -1 },
1288 pTap
= malloc( sizeof(jtag_tap_t
) );
1289 memset( pTap
, 0, sizeof(*pTap
) );
1291 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1295 * we expect CHIP + TAP + OPTIONS
1297 if( goi
->argc
< 3 ){
1298 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
1301 Jim_GetOpt_String( goi
, &cp
, NULL
);
1302 pTap
->chip
= strdup(cp
);
1304 Jim_GetOpt_String( goi
, &cp
, NULL
);
1305 pTap
->tapname
= strdup(cp
);
1307 /* name + dot + name + null */
1308 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
1310 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
1311 pTap
->dotted_name
= cp
;
1313 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1314 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
1316 /* default is enabled */
1319 /* deal with options */
1320 #define NTREQ_IRLEN 1
1321 #define NTREQ_IRCAPTURE 2
1322 #define NTREQ_IRMASK 4
1324 /* clear them as we find them */
1325 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
1328 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
1330 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
1333 LOG_DEBUG("Processing option: %s", n
->name
);
1335 case NTAP_OPT_ENABLED
:
1338 case NTAP_OPT_DISABLED
:
1341 case NTAP_OPT_EXPECTED_ID
:
1343 u32
*new_expected_ids
;
1345 e
= Jim_GetOpt_Wide( goi
, &w
);
1347 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
1351 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
1352 if (new_expected_ids
== NULL
) {
1353 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1357 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
1359 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
1361 free(pTap
->expected_ids
);
1362 pTap
->expected_ids
= new_expected_ids
;
1363 pTap
->expected_ids_cnt
++;
1366 case NTAP_OPT_IRLEN
:
1367 case NTAP_OPT_IRMASK
:
1368 case NTAP_OPT_IRCAPTURE
:
1369 e
= Jim_GetOpt_Wide( goi
, &w
);
1371 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
1374 if( (w
< 0) || (w
> 0xffff) ){
1376 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
1377 n
->name
, (int)(w
), (int)(w
));
1381 case NTAP_OPT_IRLEN
:
1382 pTap
->ir_length
= w
;
1383 reqbits
&= (~(NTREQ_IRLEN
));
1385 case NTAP_OPT_IRMASK
:
1386 pTap
->ir_capture_mask
= w
;
1387 reqbits
&= (~(NTREQ_IRMASK
));
1389 case NTAP_OPT_IRCAPTURE
:
1390 pTap
->ir_capture_value
= w
;
1391 reqbits
&= (~(NTREQ_IRCAPTURE
));
1394 } /* switch(n->value) */
1395 } /* while( goi->argc ) */
1397 /* Did we get all the options? */
1400 Jim_SetResult_sprintf( goi
->interp
,
1401 "newtap: %s missing required parameters",
1403 /* TODO: Tell user what is missing :-( */
1404 /* no memory leaks pelase */
1405 free(((void *)(pTap
->expected_ids
)));
1406 free(((void *)(pTap
->chip
)));
1407 free(((void *)(pTap
->tapname
)));
1408 free(((void *)(pTap
->dotted_name
)));
1409 free(((void *)(pTap
)));
1413 pTap
->expected
= malloc( pTap
->ir_length
);
1414 pTap
->expected_mask
= malloc( pTap
->ir_length
);
1415 pTap
->cur_instr
= malloc( pTap
->ir_length
);
1417 buf_set_u32( pTap
->expected
,
1420 pTap
->ir_capture_value
);
1421 buf_set_u32( pTap
->expected_mask
,
1424 pTap
->ir_capture_mask
);
1425 buf_set_ones( pTap
->cur_instr
,
1430 jtag_register_event_callback(jtag_reset_callback
, pTap
);
1432 ppTap
= &(jtag_all_taps
);
1433 while( (*ppTap
) != NULL
){
1434 ppTap
= &((*ppTap
)->next_tap
);
1438 static int n_taps
= 0;
1439 pTap
->abs_chain_position
= n_taps
++;
1441 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1442 (*ppTap
)->dotted_name
,
1443 (*ppTap
)->abs_chain_position
,
1444 (*ppTap
)->ir_length
,
1445 (*ppTap
)->ir_capture_value
,
1446 (*ppTap
)->ir_capture_mask
);
1451 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1457 struct command_context_s
*context
;
1461 JTAG_CMD_INIT_RESET
,
1464 JTAG_CMD_TAPDISABLE
,
1465 JTAG_CMD_TAPISENABLED
,
1470 const Jim_Nvp jtag_cmds
[] = {
1471 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
1472 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
1473 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
1474 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
1475 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
1476 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
1477 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
1478 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
1480 { .name
= NULL
, .value
= -1 },
1483 context
= Jim_GetAssocData(interp
, "context");
1484 /* go past the command */
1485 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
1487 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
1489 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
1492 Jim_SetEmptyResult( goi
.interp
);
1494 case JTAG_CMD_INTERFACE
:
1495 /* return the name of the interface */
1496 /* TCL code might need to know the exact type... */
1497 /* FUTURE: we allow this as a means to "set" the interface. */
1498 if( goi
.argc
!= 0 ){
1499 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1502 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
1504 case JTAG_CMD_INIT_RESET
:
1505 if( goi
.argc
!= 0 ){
1506 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1509 e
= jtag_init_reset(context
);
1510 if( e
!= ERROR_OK
){
1511 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
1515 case JTAG_CMD_NEWTAP
:
1516 return jim_newtap_cmd( &goi
);
1518 case JTAG_CMD_TAPISENABLED
:
1519 case JTAG_CMD_TAPENABLE
:
1520 case JTAG_CMD_TAPDISABLE
:
1521 if( goi
.argc
!= 1 ){
1522 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
1528 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
1533 case JTAG_CMD_TAPISENABLED
:
1536 case JTAG_CMD_TAPENABLE
:
1537 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
1541 case JTAG_CMD_TAPDISABLE
:
1542 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
1547 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
1554 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
1561 Jim_GetOpt_Obj(&goi
, &o
);
1562 t
= jtag_TapByJimObj( goi
.interp
, o
);
1567 goi
.isconfigure
= 0;
1568 return jtag_tap_configure_cmd( &goi
, t
);
1572 case JTAG_CMD_CONFIGURE
:
1574 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
1581 Jim_GetOpt_Obj(&goi
, &o
);
1582 t
= jtag_TapByJimObj( goi
.interp
, o
);
1587 goi
.isconfigure
= 1;
1588 return jtag_tap_configure_cmd( &goi
, t
);
1595 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1597 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
1599 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1600 COMMAND_CONFIG
, "try to configure interface");
1601 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1602 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
1603 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1604 COMMAND_ANY
, "set maximum jtag speed (if supported); "
1605 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1606 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1607 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1608 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1610 "[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]");
1611 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1612 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1613 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1614 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1616 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1617 COMMAND_EXEC
, "print current scan chain configuration");
1619 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1620 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1621 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1622 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1623 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1624 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1625 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1626 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1627 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1628 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
1630 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1631 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1632 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
1633 COMMAND_ANY
, "verify value capture <enable|disable>");
1634 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
1635 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
1639 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1644 if (!jtag_interface
)
1646 /* nothing was previously specified by "interface" command */
1647 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1648 return ERROR_JTAG_INVALID_INTERFACE
;
1652 jtag_interface
->khz(speed_khz
, &jtag_speed
);
1656 if (jtag_interface
->init() != ERROR_OK
)
1657 return ERROR_JTAG_INIT_FAILED
;
1659 jtag
= jtag_interface
;
1663 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1668 LOG_DEBUG("Init JTAG chain");
1670 tap
= jtag_NextEnabledTap(NULL
);
1672 LOG_ERROR("There are no enabled taps?");
1673 return ERROR_JTAG_INIT_FAILED
;
1677 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1680 /* examine chain first, as this could discover the real chain layout */
1681 if (jtag_examine_chain() != ERROR_OK
)
1683 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1686 if (jtag_validate_chain() != ERROR_OK
)
1688 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1694 int jtag_interface_quit(void)
1696 if (!jtag
|| !jtag
->quit
)
1699 // close the JTAG interface
1700 int result
= jtag
->quit();
1701 if (ERROR_OK
!= result
)
1702 LOG_ERROR("failed: %d", result
);
1708 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1712 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1715 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1717 /* Reset can happen after a power cycle.
1719 * Ideally we would only assert TRST or run RESET before the target reset.
1721 * However w/srst_pulls_trst, trst is asserted together with the target
1722 * reset whether we want it or not.
1724 * NB! Some targets have JTAG circuitry disabled until a
1725 * trst & srst has been asserted.
1727 * NB! here we assume nsrst/ntrst delay are sufficient!
1729 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1732 jtag_add_reset(1, 0); /* RESET or TRST */
1733 if (jtag_reset_config
& RESET_HAS_SRST
)
1735 jtag_add_reset(1, 1);
1736 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1737 jtag_add_reset(0, 1);
1739 jtag_add_reset(0, 0);
1740 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1743 /* Check that we can communication on the JTAG chain + eventually we want to
1744 * be able to perform enumeration only after OpenOCD has started
1745 * telnet and GDB server
1747 * That would allow users to more easily perform any magic they need to before
1750 return jtag_init_inner(cmd_ctx
);
1753 int jtag_init(struct command_context_s
*cmd_ctx
)
1756 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1758 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1762 return jtag_init_reset(cmd_ctx
);
1765 static int default_khz(int khz
, int *jtag_speed
)
1767 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1771 static int default_speed_div(int speed
, int *khz
)
1773 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1777 static int default_power_dropout(int *dropout
)
1779 *dropout
=0; /* by default we can't detect power dropout */
1783 static int default_srst_asserted(int *srst_asserted
)
1785 *srst_asserted
=0; /* by default we can't detect srst asserted */
1789 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1794 /* check whether the interface is already configured */
1797 LOG_WARNING("Interface already configured, ignoring");
1801 /* interface name is a mandatory argument */
1802 if (argc
< 1 || args
[0][0] == '\0')
1804 return ERROR_COMMAND_SYNTAX_ERROR
;
1807 for (i
=0; jtag_interfaces
[i
]; i
++)
1809 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1811 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
1816 jtag_interface
= jtag_interfaces
[i
];
1818 if (jtag_interface
->khz
== NULL
)
1820 jtag_interface
->khz
= default_khz
;
1822 if (jtag_interface
->speed_div
== NULL
)
1824 jtag_interface
->speed_div
= default_speed_div
;
1826 if (jtag_interface
->power_dropout
== NULL
)
1828 jtag_interface
->power_dropout
= default_power_dropout
;
1830 if (jtag_interface
->srst_asserted
== NULL
)
1832 jtag_interface
->srst_asserted
= default_srst_asserted
;
1839 /* no valid interface was found (i.e. the configuration option,
1840 * didn't match one of the compiled-in interfaces
1842 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
1843 LOG_ERROR("compiled-in jtag interfaces:");
1844 for (i
= 0; jtag_interfaces
[i
]; i
++)
1846 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1849 return ERROR_JTAG_INVALID_INTERFACE
;
1852 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1856 Jim_Obj
*newargs
[ 10 ];
1859 * argv[-1] = command
1860 * argv[ 0] = ir length
1861 * argv[ 1] = ir capture
1862 * argv[ 2] = ir mask
1863 * argv[ 3] = not actually used by anything but in the docs
1867 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
1870 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
1871 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
1875 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
1876 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
1877 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
1878 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
1880 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
1881 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
1882 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
1883 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
1884 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
1885 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
1886 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
1887 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
1888 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
1889 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
1890 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
1891 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
1893 command_print( cmd_ctx
, "NEW COMMAND:");
1894 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
1895 Jim_GetString( newargs
[0], NULL
),
1896 Jim_GetString( newargs
[1], NULL
),
1897 Jim_GetString( newargs
[2], NULL
),
1898 Jim_GetString( newargs
[3], NULL
),
1899 Jim_GetString( newargs
[4], NULL
),
1900 Jim_GetString( newargs
[5], NULL
),
1901 Jim_GetString( newargs
[6], NULL
),
1902 Jim_GetString( newargs
[7], NULL
),
1903 Jim_GetString( newargs
[8], NULL
),
1904 Jim_GetString( newargs
[9], NULL
) );
1906 e
= jim_jtag_command( interp
, 10, newargs
);
1908 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
1913 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1917 tap
= jtag_all_taps
;
1918 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
1919 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
1922 u32 expected
, expected_mask
, cur_instr
, ii
;
1923 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
1924 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
1925 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
1927 command_print(cmd_ctx
,
1928 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
1929 tap
->abs_chain_position
,
1931 tap
->enabled
? 'Y' : 'n',
1933 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
1939 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
1940 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
1941 tap
->expected_ids
[ii
]);
1944 tap
= tap
->next_tap
;
1950 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1956 return ERROR_COMMAND_SYNTAX_ERROR
;
1958 /* Original versions cared about the order of these tokens:
1959 * reset_config signals [combination [trst_type [srst_type]]]
1960 * They also clobbered the previous configuration even on error.
1962 * Here we don't care about the order, and only change values
1963 * which have been explicitly specified.
1965 for (; argc
; argc
--, args
++) {
1970 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
1971 if (strcmp(*args
, "none") == 0)
1973 else if (strcmp(*args
, "trst_only") == 0)
1974 tmp
= RESET_HAS_TRST
;
1975 else if (strcmp(*args
, "srst_only") == 0)
1976 tmp
= RESET_HAS_SRST
;
1977 else if (strcmp(*args
, "trst_and_srst") == 0)
1978 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
1982 LOG_ERROR("extra reset_config %s spec (%s)",
1984 return ERROR_INVALID_ARGUMENTS
;
1989 /* combination (options for broken wiring) */
1990 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1991 if (strcmp(*args
, "separate") == 0)
1992 /* separate reset lines - default */;
1993 else if (strcmp(*args
, "srst_pulls_trst") == 0)
1994 tmp
|= RESET_SRST_PULLS_TRST
;
1995 else if (strcmp(*args
, "trst_pulls_srst") == 0)
1996 tmp
|= RESET_TRST_PULLS_SRST
;
1997 else if (strcmp(*args
, "combined") == 0)
1998 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2002 LOG_ERROR("extra reset_config %s spec (%s)",
2003 "combination", *args
);
2004 return ERROR_INVALID_ARGUMENTS
;
2009 /* trst_type (NOP without HAS_TRST) */
2010 m
= RESET_TRST_OPEN_DRAIN
;
2011 if (strcmp(*args
, "trst_open_drain") == 0)
2012 tmp
|= RESET_TRST_OPEN_DRAIN
;
2013 else if (strcmp(*args
, "trst_push_pull") == 0)
2014 /* push/pull from adapter - default */;
2018 LOG_ERROR("extra reset_config %s spec (%s)",
2019 "trst_type", *args
);
2020 return ERROR_INVALID_ARGUMENTS
;
2025 /* srst_type (NOP without HAS_SRST) */
2026 m
|= RESET_SRST_PUSH_PULL
;
2027 if (strcmp(*args
, "srst_push_pull") == 0)
2028 tmp
|= RESET_SRST_PUSH_PULL
;
2029 else if (strcmp(*args
, "srst_open_drain") == 0)
2030 /* open drain from adapter - default */;
2034 LOG_ERROR("extra reset_config %s spec (%s)",
2035 "srst_type", *args
);
2036 return ERROR_INVALID_ARGUMENTS
;
2041 /* caller provided nonsense; fail */
2042 LOG_ERROR("unknown reset_config flag (%s)", *args
);
2043 return ERROR_INVALID_ARGUMENTS
;
2046 /* Remember the bits which were specified (mask)
2047 * and their new values (new_cfg).
2053 /* clear previous values of those bits, save new values */
2054 jtag_reset_config
&= ~mask
;
2055 jtag_reset_config
|= new_cfg
;
2060 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2064 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2069 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2075 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2079 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2084 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2090 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2092 int retval
=ERROR_OK
;
2096 LOG_DEBUG("handle jtag speed");
2099 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2101 /* this command can be called during CONFIG,
2102 * in which case jtag isn't initialized */
2105 retval
=jtag
->speed(cur_speed
);
2107 } else if (argc
== 0)
2111 return ERROR_COMMAND_SYNTAX_ERROR
;
2113 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2118 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2120 int retval
=ERROR_OK
;
2121 LOG_DEBUG("handle jtag khz");
2125 speed_khz
= strtoul(args
[0], NULL
, 0);
2129 LOG_DEBUG("have interface set up");
2131 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2137 cur_speed
= jtag_speed
= speed_div1
;
2139 retval
=jtag
->speed(cur_speed
);
2148 return ERROR_COMMAND_SYNTAX_ERROR
;
2153 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2159 command_print(cmd_ctx
, "RCLK - adaptive");
2162 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2168 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2174 return ERROR_COMMAND_SYNTAX_ERROR
;
2178 state
= tap_state_by_name( args
[0] );
2180 command_print( cmd_ctx
, "Invalid state name: %s\n", args
[0] );
2181 return ERROR_COMMAND_SYNTAX_ERROR
;
2183 jtag_add_end_state(state
);
2184 jtag_execute_queue();
2186 command_print(cmd_ctx
, "current endstate: %s", tap_state_name(cmd_queue_end_state
));
2191 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2198 return ERROR_COMMAND_SYNTAX_ERROR
;
2201 if (args
[0][0] == '1')
2203 else if (args
[0][0] == '0')
2207 return ERROR_COMMAND_SYNTAX_ERROR
;
2210 if (args
[1][0] == '1')
2212 else if (args
[1][0] == '0')
2216 return ERROR_COMMAND_SYNTAX_ERROR
;
2219 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2220 return ERROR_JTAG_INIT_FAILED
;
2222 jtag_add_reset(trst
, srst
);
2223 jtag_execute_queue();
2228 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2232 return ERROR_COMMAND_SYNTAX_ERROR
;
2235 jtag_add_runtest(strtol(args
[0], NULL
, 0), TAP_INVALID
);
2236 jtag_execute_queue();
2243 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2244 * should be stable ... and *NOT* a shift state, otherwise free-running
2245 * jtag clocks could change the values latched by the update state.
2247 static bool scan_is_safe(tap_state_t state
)
2262 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2265 scan_field_t
*fields
;
2267 tap_state_t endstate
;
2269 if ((argc
< 2) || (argc
% 2))
2271 return ERROR_COMMAND_SYNTAX_ERROR
;
2274 /* optional "-endstate" "statename" at the end of the arguments,
2275 * so that e.g. IRPAUSE can let us load the data register before
2276 * entering RUN/IDLE to execute the instruction we load here.
2278 endstate
= TAP_IDLE
;
2281 /* have at least one pair of numbers. */
2282 /* is last pair the magic text? */
2283 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
2286 cpA
= args
[ argc
-1 ];
2287 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
2288 cpS
= tap_state_name( endstate
);
2289 if( 0 == strcmp( cpA
, cpS
) ){
2293 if( endstate
>= TAP_NUM_STATES
){
2294 return ERROR_COMMAND_SYNTAX_ERROR
;
2296 if (!scan_is_safe(endstate
))
2297 LOG_WARNING("irscan with unsafe "
2298 "endstate \"%s\"", cpA
);
2299 /* found - remove the last 2 args */
2305 int num_fields
= argc
/ 2;
2307 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2309 for (i
= 0; i
< num_fields
; i
++)
2311 tap
= jtag_TapByString( args
[i
*2] );
2314 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2317 int field_size
= tap
->ir_length
;
2318 fields
[i
].tap
= tap
;
2319 fields
[i
].num_bits
= field_size
;
2320 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2321 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2322 fields
[i
].in_value
= NULL
;
2325 /* did we have an endstate? */
2326 jtag_add_ir_scan(num_fields
, fields
, endstate
);
2328 int retval
=jtag_execute_queue();
2330 for (i
= 0; i
< num_fields
; i
++)
2331 free(fields
[i
].out_value
);
2338 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2341 scan_field_t
*fields
;
2343 int field_count
= 0;
2346 tap_state_t endstate
;
2349 * args[2] = num_bits
2350 * args[3] = hex string
2351 * ... repeat num bits and hex string ...
2354 * args[N-2] = "-endstate"
2355 * args[N-1] = statename
2357 if ((argc
< 4) || ((argc
% 2)!=0))
2359 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2363 endstate
= TAP_IDLE
;
2365 /* validate arguments as numbers */
2367 for (i
= 2; i
< argc
; i
+=2)
2372 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2373 /* If valid - try next arg */
2378 /* Not valid.. are we at the end? */
2379 if ( ((i
+2) != argc
) ){
2380 /* nope, then error */
2384 /* it could be: "-endstate FOO"
2385 * e.g. DRPAUSE so we can issue more instructions
2386 * before entering RUN/IDLE and executing them.
2389 /* get arg as a string. */
2390 cp
= Jim_GetString( args
[i
], NULL
);
2391 /* is it the magic? */
2392 if( 0 == strcmp( "-endstate", cp
) ){
2393 /* is the statename valid? */
2394 cp
= Jim_GetString( args
[i
+1], NULL
);
2396 /* see if it is a valid state name */
2397 endstate
= tap_state_by_name(cp
);
2399 /* update the error message */
2400 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
2402 if (!scan_is_safe(endstate
))
2403 LOG_WARNING("drscan with unsafe "
2404 "endstate \"%s\"", cp
);
2406 /* valid - so clear the error */
2408 /* and remove the last 2 args */
2413 /* Still an error? */
2415 return e
; /* too bad */
2417 } /* validate args */
2419 tap
= jtag_TapByJimObj( interp
, args
[1] );
2424 num_fields
=(argc
-2)/2;
2425 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2426 for (i
= 2; i
< argc
; i
+=2)
2432 Jim_GetLong(interp
, args
[i
], &bits
);
2433 str
= Jim_GetString(args
[i
+1], &len
);
2435 fields
[field_count
].tap
= tap
;
2436 fields
[field_count
].num_bits
= bits
;
2437 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2438 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2439 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2443 jtag_add_dr_scan(num_fields
, fields
, endstate
);
2445 retval
= jtag_execute_queue();
2446 if (retval
!= ERROR_OK
)
2448 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
2453 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2454 for (i
= 2; i
< argc
; i
+=2)
2459 Jim_GetLong(interp
, args
[i
], &bits
);
2460 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2461 free(fields
[field_count
].out_value
);
2463 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2468 Jim_SetResult(interp
, list
);
2476 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2478 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_flush_queue_count
));
2484 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2488 if (strcmp(args
[0], "enable") == 0)
2490 jtag_verify_capture_ir
= 1;
2492 else if (strcmp(args
[0], "disable") == 0)
2494 jtag_verify_capture_ir
= 0;
2497 return ERROR_COMMAND_SYNTAX_ERROR
;
2499 } else if (argc
!= 0)
2501 return ERROR_COMMAND_SYNTAX_ERROR
;
2504 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2509 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2513 if (strcmp(args
[0], "enable") == 0)
2517 else if (strcmp(args
[0], "disable") == 0)
2522 return ERROR_COMMAND_SYNTAX_ERROR
;
2524 } else if (argc
!= 0)
2526 return ERROR_COMMAND_SYNTAX_ERROR
;
2529 command_print(cmd_ctx
, "verify jtag capture is %s", (jtag_verify
) ? "enabled": "disabled");
2535 int jtag_power_dropout(int *dropout
)
2537 return jtag
->power_dropout(dropout
);
2540 int jtag_srst_asserted(int *srst_asserted
)
2542 return jtag
->srst_asserted(srst_asserted
);
2545 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
2547 jtag_tap_event_action_t
* jteap
;
2550 jteap
= tap
->event_action
;
2554 if (jteap
->event
== e
) {
2556 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2559 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
2560 Jim_GetString(jteap
->body
, NULL
) );
2561 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
2562 Jim_PrintErrorMessage(interp
);
2566 jteap
= jteap
->next
;
2570 LOG_DEBUG( "event %d %s - no action",
2572 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
2576 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2579 return ERROR_COMMAND_SYNTAX_ERROR
;
2584 if (strcmp(args
[0], "short") == 0)
2585 use_new_table
= true;
2586 else if (strcmp(args
[0], "long") == 0)
2587 use_new_table
= false;
2589 return ERROR_COMMAND_SYNTAX_ERROR
;
2591 tap_use_new_tms_table(use_new_table
);
2594 command_print(cmd_ctx
, "tms sequence is %s",
2595 tap_uses_new_tms_table() ? "short": "long");
2601 * Function jtag_add_statemove
2602 * moves from the current state to the goal \a state. This needs
2603 * to be handled according to the xsvf spec, see the XSTATE command
2606 int jtag_add_statemove(tap_state_t goal_state
)
2608 int retval
= ERROR_OK
;
2610 tap_state_t moves
[8];
2611 tap_state_t cur_state
= cmd_queue_cur_state
;
2616 LOG_DEBUG( "cur_state=%s goal_state=%s",
2617 tap_state_name(cur_state
),
2618 tap_state_name(goal_state
) );
2621 /* From the XSVF spec, pertaining to XSTATE:
2623 For special states known as stable states (Test-Logic-Reset,
2624 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2625 predefined TAP state paths when the starting state is a stable state and
2626 when the XSTATE specifies a new stable state (see the STATE command in
2627 the [Ref 5] for the TAP state paths between stable states). For
2628 non-stable states, XSTATE should specify a state that is only one TAP
2629 state transition distance from the current TAP state to avoid undefined
2630 TAP state paths. A sequence of multiple XSTATE commands can be issued to
2631 transition the TAP through a specific state path.
2634 if (goal_state
==cur_state
)
2635 ; /* nothing to do */
2637 else if( goal_state
==TAP_RESET
)
2642 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
2644 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
2645 spec, then this code is not fully conformant to the xsvf spec. This
2646 puts a burden on tap_get_tms_path() function from the xsvf spec.
2647 If in doubt, you should confirm that that burden is being met.
2650 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
2651 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
2653 assert( (unsigned) tms_count
< DIM(moves
) );
2655 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
2657 bool bit
= tms_bits
& 1;
2659 cur_state
= tap_state_transition(cur_state
, bit
);
2660 moves
[i
] = cur_state
;
2663 jtag_add_pathmove(tms_count
, moves
);
2666 /* else state must be immediately reachable in one clock cycle, and does not
2667 need to be a stable state.
2669 else if( tap_state_transition(cur_state
, true) == goal_state
2670 || tap_state_transition(cur_state
, false) == goal_state
)
2672 /* move a single state */
2673 moves
[0] = goal_state
;
2674 jtag_add_pathmove( 1, moves
);
2679 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)