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)
390 assert(jtag_trst
== 0);
392 if (cmd_queue_end_state
== TAP_RESET
)
393 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
396 static void jtag_prelude(tap_state_t state
)
400 if (state
!= TAP_INVALID
)
401 jtag_add_end_state(state
);
403 cmd_queue_cur_state
= cmd_queue_end_state
;
406 void jtag_alloc_in_value32(scan_field_t
*field
)
408 interface_jtag_alloc_in_value32(field
);
411 void jtag_add_ir_scan_noverify(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
416 retval
=interface_jtag_add_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
417 if (retval
!=ERROR_OK
)
424 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
426 * If the input field list contains an instruction value for a TAP then that is used
427 * otherwise the TAP is set to bypass.
429 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
432 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
434 if (jtag_verify
&&jtag_verify_capture_ir
)
436 /* 8 x 32 bit id's is enough for all invocations */
438 for (int j
= 0; j
< in_num_fields
; j
++)
440 /* if we are to run a verification of the ir scan, we need to get the input back.
441 * We may have to allocate space if the caller didn't ask for the input back.
443 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
444 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
446 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
449 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
454 * Duplicate the scan fields passed into the function into an IR SCAN command
456 * This function assumes that the caller handles extra fields for bypassed TAPs
459 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
465 retval
=interface_jtag_add_plain_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
466 if (retval
!=ERROR_OK
)
470 void jtag_add_callback(jtag_callback1_t f
, u8
*in
)
472 interface_jtag_add_callback(f
, in
);
475 void jtag_add_callback4(jtag_callback_t f
, u8
*in
,
476 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
477 jtag_callback_data_t data3
)
479 interface_jtag_add_callback4(f
, in
, data1
, data2
, data3
);
482 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
484 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
486 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
489 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
490 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
492 for (int i
= 0; i
< in_num_fields
; i
++)
494 struct scan_field_s
*field
= &in_fields
[i
];
495 field
->allocated
= 0;
497 if (field
->check_value
|| field
->in_value
)
499 interface_jtag_add_scan_check_alloc(field
);
503 jtag_add_scan(in_num_fields
, in_fields
, state
);
505 for (int i
= 0; i
< in_num_fields
; i
++)
507 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
509 /* this is synchronous for a minidriver */
510 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
511 (jtag_callback_data_t
)in_fields
[i
].check_value
,
512 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
513 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
515 if (in_fields
[i
].allocated
)
517 free(in_fields
[i
].in_value
);
519 if (in_fields
[i
].modified
)
521 in_fields
[i
].in_value
= NULL
;
526 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
530 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
533 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
539 * Generate a DR SCAN using the fields passed to the function
541 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
542 * For bypassed TAPs the function generates a dummy 1bit field.
544 * The bypass status of TAPs is set by jtag_add_ir_scan().
547 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
553 retval
=interface_jtag_add_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
554 if (retval
!=ERROR_OK
)
561 * Duplicate the scan fields passed into the function into a DR SCAN command
563 * This function assumes that the caller handles extra fields for bypassed TAPs
566 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
572 retval
=interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
573 if (retval
!=ERROR_OK
)
577 void jtag_add_dr_out(jtag_tap_t
* tap
,
578 int num_fields
, const int* num_bits
, const u32
* value
,
579 tap_state_t end_state
)
581 if (end_state
!= TAP_INVALID
)
582 cmd_queue_end_state
= end_state
;
584 cmd_queue_cur_state
= cmd_queue_end_state
;
586 interface_jtag_add_dr_out(tap
,
587 num_fields
, num_bits
, value
,
588 cmd_queue_end_state
);
591 void jtag_add_tlr(void)
593 jtag_prelude(TAP_RESET
);
596 retval
=interface_jtag_add_tlr();
597 if (retval
!=ERROR_OK
)
601 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
603 tap_state_t cur_state
= cmd_queue_cur_state
;
607 /* the last state has to be a stable state */
608 if (!tap_is_state_stable(path
[num_states
- 1]))
610 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
614 for (i
=0; i
<num_states
; i
++)
616 if (path
[i
] == TAP_RESET
)
618 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
622 if ( tap_state_transition(cur_state
, true) != path
[i
]
623 && tap_state_transition(cur_state
, false) != path
[i
])
625 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[i
]));
633 retval
= interface_jtag_add_pathmove(num_states
, path
);
634 cmd_queue_cur_state
= path
[num_states
- 1];
635 if (retval
!=ERROR_OK
)
639 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
645 /* executed by sw or hw fifo */
646 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
647 if (retval
!=ERROR_OK
)
652 void jtag_add_clocks( int num_cycles
)
656 if( !tap_is_state_stable(cmd_queue_cur_state
) )
658 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
659 tap_state_name(cmd_queue_cur_state
) );
660 jtag_error
= ERROR_JTAG_NOT_STABLE_STATE
;
668 retval
= interface_jtag_add_clocks(num_cycles
);
669 if (retval
!= ERROR_OK
)
674 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
676 int trst_with_tlr
= 0;
679 /* FIX!!! there are *many* different cases here. A better
680 * approach is needed for legal combinations of transitions...
682 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
683 (jtag_reset_config
& RESET_HAS_TRST
)&&
684 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
686 if (((req_tlr_or_trst
&&!jtag_trst
)||
687 (!req_tlr_or_trst
&&jtag_trst
))&&
688 ((req_srst
&&!jtag_srst
)||
689 (!req_srst
&&jtag_srst
)))
691 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
692 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
696 /* Make sure that jtag_reset_config allows the requested reset */
697 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
698 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
700 LOG_ERROR("BUG: requested reset would assert trst");
701 jtag_error
=ERROR_FAIL
;
705 /* if TRST pulls SRST, we reset with TAP T-L-R */
706 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
711 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
713 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
714 jtag_error
=ERROR_FAIL
;
720 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
732 jtag_srst
= req_srst
;
734 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
735 if (retval
!=ERROR_OK
)
740 jtag_execute_queue();
744 LOG_DEBUG("SRST line asserted");
748 LOG_DEBUG("SRST line released");
749 if (jtag_nsrst_delay
)
750 jtag_add_sleep(jtag_nsrst_delay
* 1000);
755 LOG_DEBUG("JTAG reset with RESET instead of TRST");
756 jtag_add_end_state(TAP_RESET
);
758 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
764 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
765 * and inform possible listeners about this
767 LOG_DEBUG("TRST line asserted");
768 tap_set_state(TAP_RESET
);
769 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
773 if (jtag_ntrst_delay
)
774 jtag_add_sleep(jtag_ntrst_delay
* 1000);
778 void jtag_add_end_state(tap_state_t state
)
780 cmd_queue_end_state
= state
;
781 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
783 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
787 void jtag_add_sleep(u32 us
)
789 keep_alive(); /* we might be running on a very slow JTAG clk */
790 int retval
=interface_jtag_add_sleep(us
);
791 if (retval
!=ERROR_OK
)
796 static const char *jtag_tap_name(const jtag_tap_t
*tap
)
798 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
801 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
803 int retval
= ERROR_OK
;
805 int compare_failed
= 0;
808 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
810 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
813 /* An error handler could have caught the failing check
814 * only report a problem when there wasn't a handler, or if the handler
815 * acknowledged the error
818 LOG_WARNING("TAP %s:",
819 jtag_tap_name(field->tap));
823 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
824 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
828 char *in_check_mask_char
;
829 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
830 LOG_WARNING("value captured during scan didn't pass the requested check:");
831 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
832 captured_char
, in_check_value_char
, in_check_mask_char
);
833 free(in_check_mask_char
);
837 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
);
841 free(in_check_value_char
);
843 retval
= ERROR_JTAG_QUEUE_FAILED
;
850 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
852 assert(field
->in_value
!= NULL
);
856 /* no checking to do */
860 jtag_execute_queue_noclear();
862 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
863 jtag_set_error(retval
);
868 int default_interface_jtag_execute_queue(void)
872 LOG_ERROR("No JTAG interface configured yet. "
873 "Issue 'init' command in startup scripts "
874 "before communicating with targets.");
878 return jtag
->execute_queue();
881 void jtag_execute_queue_noclear(void)
883 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
884 * E.g. a JTAG over TCP/IP or USB....
886 jtag_flush_queue_count
++;
888 int retval
=interface_jtag_execute_queue();
889 /* we keep the first error */
890 if ((jtag_error
==ERROR_OK
)&&(retval
!=ERROR_OK
))
896 int jtag_execute_queue(void)
899 jtag_execute_queue_noclear();
905 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 /* Try to examine chain layout according to IEEE 1149.1 §12
927 int jtag_examine_chain(void)
931 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
934 int device_count
= 0;
939 field
.num_bits
= sizeof(idcode_buffer
) * 8;
940 field
.out_value
= idcode_buffer
;
942 field
.in_value
= idcode_buffer
;
947 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
949 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
952 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
953 jtag_execute_queue();
955 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
957 zero_check
|= idcode_buffer
[i
];
958 one_check
&= idcode_buffer
[i
];
961 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
962 if ((zero_check
== 0x00) || (one_check
== 0xff))
964 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
965 return ERROR_JTAG_INIT_FAILED
;
968 /* point at the 1st tap */
969 tap
= jtag_NextEnabledTap(NULL
);
971 LOG_ERROR("JTAG: No taps enabled?");
972 return ERROR_JTAG_INIT_FAILED
;
975 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
977 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
978 if ((idcode
& 1) == 0)
980 /* LSB must not be 0, this indicates a device in bypass */
981 LOG_WARNING("Tap/Device does not have IDCODE");
992 /* some devices, such as AVR will output all 1's instead of TDI
993 input value at end of chain. */
994 if ((idcode
== 0x000000FF)||(idcode
== 0xFFFFFFFF))
997 /* End of chain (invalid manufacturer ID)
999 * The JTAG examine is the very first thing that happens
1001 * A single JTAG device requires only 64 bits to be read back correctly.
1003 * The code below adds a check that the rest of the data scanned (640 bits)
1004 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1006 * earlier and gives more helpful/explicit error messages.
1008 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1010 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1011 if (unexpected
||((idcode
!= 0x000000FF)&&(idcode
!= 0xFFFFFFFF)))
1013 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1021 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1022 manufacturer
= EXTRACT_MFG(idcode
);
1023 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1024 part
= EXTRACT_PART(idcode
);
1025 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1026 version
= EXTRACT_VER(idcode
);
1028 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1029 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1030 idcode
, manufacturer
, part
, version
);
1036 tap
->idcode
= idcode
;
1038 if (tap
->expected_ids_cnt
> 0) {
1039 /* Loop over the expected identification codes and test for a match */
1041 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1042 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1047 /* If none of the expected ids matched, log an error */
1048 if (ii
== tap
->expected_ids_cnt
) {
1049 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1052 EXTRACT_MFG( tap
->idcode
),
1053 EXTRACT_PART( tap
->idcode
),
1054 EXTRACT_VER( tap
->idcode
) );
1055 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1056 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1059 tap
->expected_ids_cnt
,
1060 tap
->expected_ids
[ii
],
1061 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1062 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1063 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1066 return ERROR_JTAG_INIT_FAILED
;
1068 LOG_INFO("JTAG Tap/device matched");
1072 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1076 tap
= jtag_NextEnabledTap(tap
);
1081 /* see if number of discovered devices matches configuration */
1082 if (device_count
!= jtag_NumEnabledTaps())
1084 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1085 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1086 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1087 return ERROR_JTAG_INIT_FAILED
;
1093 int jtag_validate_chain(void)
1096 int total_ir_length
= 0;
1102 total_ir_length
= 0;
1104 tap
= jtag_NextEnabledTap(tap
);
1108 total_ir_length
+= tap
->ir_length
;
1111 total_ir_length
+= 2;
1112 ir_test
= malloc(CEIL(total_ir_length
, 8));
1113 buf_set_ones(ir_test
, total_ir_length
);
1116 field
.num_bits
= total_ir_length
;
1117 field
.out_value
= ir_test
;
1118 field
.in_value
= ir_test
;
1121 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1122 jtag_execute_queue();
1128 tap
= jtag_NextEnabledTap(tap
);
1133 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1136 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1137 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
);
1140 return ERROR_JTAG_INIT_FAILED
;
1142 chain_pos
+= tap
->ir_length
;
1145 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1148 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1149 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
);
1152 return ERROR_JTAG_INIT_FAILED
;
1160 enum jtag_tap_cfg_param
{
1164 static Jim_Nvp nvp_config_opts
[] = {
1165 { .name
= "-event", .value
= JCFG_EVENT
},
1167 { .name
= NULL
, .value
= -1 }
1170 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1176 /* parse config or cget options */
1177 while (goi
->argc
> 0) {
1178 Jim_SetEmptyResult (goi
->interp
);
1180 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1182 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1188 if (goi
->argc
== 0) {
1189 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1193 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1195 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1199 if (goi
->isconfigure
) {
1200 if (goi
->argc
!= 1) {
1201 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1205 if (goi
->argc
!= 0) {
1206 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1212 jtag_tap_event_action_t
*jteap
;
1214 jteap
= tap
->event_action
;
1215 /* replace existing? */
1217 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1220 jteap
= jteap
->next
;
1223 if (goi
->isconfigure
) {
1224 if (jteap
== NULL
) {
1226 jteap
= calloc(1, sizeof (*jteap
));
1228 jteap
->event
= n
->value
;
1229 Jim_GetOpt_Obj( goi
, &o
);
1231 Jim_DecrRefCount(interp
, jteap
->body
);
1233 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1234 Jim_IncrRefCount(jteap
->body
);
1236 /* add to head of event list */
1237 jteap
->next
= tap
->event_action
;
1238 tap
->event_action
= jteap
;
1239 Jim_SetEmptyResult(goi
->interp
);
1242 if (jteap
== NULL
) {
1243 Jim_SetEmptyResult(goi
->interp
);
1245 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1252 } /* while (goi->argc) */
1257 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1267 const Jim_Nvp opts
[] = {
1268 #define NTAP_OPT_IRLEN 0
1269 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1270 #define NTAP_OPT_IRMASK 1
1271 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
1272 #define NTAP_OPT_IRCAPTURE 2
1273 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
1274 #define NTAP_OPT_ENABLED 3
1275 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
1276 #define NTAP_OPT_DISABLED 4
1277 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
1278 #define NTAP_OPT_EXPECTED_ID 5
1279 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
1280 { .name
= NULL
, .value
= -1 },
1283 pTap
= malloc( sizeof(jtag_tap_t
) );
1284 memset( pTap
, 0, sizeof(*pTap
) );
1286 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1290 * we expect CHIP + TAP + OPTIONS
1292 if( goi
->argc
< 3 ){
1293 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
1296 Jim_GetOpt_String( goi
, &cp
, NULL
);
1297 pTap
->chip
= strdup(cp
);
1299 Jim_GetOpt_String( goi
, &cp
, NULL
);
1300 pTap
->tapname
= strdup(cp
);
1302 /* name + dot + name + null */
1303 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
1305 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
1306 pTap
->dotted_name
= cp
;
1308 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1309 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
1311 /* default is enabled */
1314 /* deal with options */
1315 #define NTREQ_IRLEN 1
1316 #define NTREQ_IRCAPTURE 2
1317 #define NTREQ_IRMASK 4
1319 /* clear them as we find them */
1320 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
1323 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
1325 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
1328 LOG_DEBUG("Processing option: %s", n
->name
);
1330 case NTAP_OPT_ENABLED
:
1333 case NTAP_OPT_DISABLED
:
1336 case NTAP_OPT_EXPECTED_ID
:
1338 u32
*new_expected_ids
;
1340 e
= Jim_GetOpt_Wide( goi
, &w
);
1342 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
1346 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
1347 if (new_expected_ids
== NULL
) {
1348 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1352 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
1354 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
1356 free(pTap
->expected_ids
);
1357 pTap
->expected_ids
= new_expected_ids
;
1358 pTap
->expected_ids_cnt
++;
1361 case NTAP_OPT_IRLEN
:
1362 case NTAP_OPT_IRMASK
:
1363 case NTAP_OPT_IRCAPTURE
:
1364 e
= Jim_GetOpt_Wide( goi
, &w
);
1366 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
1369 if( (w
< 0) || (w
> 0xffff) ){
1371 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
1372 n
->name
, (int)(w
), (int)(w
));
1376 case NTAP_OPT_IRLEN
:
1377 pTap
->ir_length
= w
;
1378 reqbits
&= (~(NTREQ_IRLEN
));
1380 case NTAP_OPT_IRMASK
:
1381 pTap
->ir_capture_mask
= w
;
1382 reqbits
&= (~(NTREQ_IRMASK
));
1384 case NTAP_OPT_IRCAPTURE
:
1385 pTap
->ir_capture_value
= w
;
1386 reqbits
&= (~(NTREQ_IRCAPTURE
));
1389 } /* switch(n->value) */
1390 } /* while( goi->argc ) */
1392 /* Did we get all the options? */
1395 Jim_SetResult_sprintf( goi
->interp
,
1396 "newtap: %s missing required parameters",
1398 /* TODO: Tell user what is missing :-( */
1399 /* no memory leaks pelase */
1400 free(((void *)(pTap
->expected_ids
)));
1401 free(((void *)(pTap
->chip
)));
1402 free(((void *)(pTap
->tapname
)));
1403 free(((void *)(pTap
->dotted_name
)));
1404 free(((void *)(pTap
)));
1408 pTap
->expected
= malloc( pTap
->ir_length
);
1409 pTap
->expected_mask
= malloc( pTap
->ir_length
);
1410 pTap
->cur_instr
= malloc( pTap
->ir_length
);
1412 buf_set_u32( pTap
->expected
,
1415 pTap
->ir_capture_value
);
1416 buf_set_u32( pTap
->expected_mask
,
1419 pTap
->ir_capture_mask
);
1420 buf_set_ones( pTap
->cur_instr
,
1425 jtag_register_event_callback(jtag_reset_callback
, pTap
);
1427 ppTap
= &(jtag_all_taps
);
1428 while( (*ppTap
) != NULL
){
1429 ppTap
= &((*ppTap
)->next_tap
);
1433 static int n_taps
= 0;
1434 pTap
->abs_chain_position
= n_taps
++;
1436 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1437 (*ppTap
)->dotted_name
,
1438 (*ppTap
)->abs_chain_position
,
1439 (*ppTap
)->ir_length
,
1440 (*ppTap
)->ir_capture_value
,
1441 (*ppTap
)->ir_capture_mask
);
1446 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1452 struct command_context_s
*context
;
1456 JTAG_CMD_INIT_RESET
,
1459 JTAG_CMD_TAPDISABLE
,
1460 JTAG_CMD_TAPISENABLED
,
1465 const Jim_Nvp jtag_cmds
[] = {
1466 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
1467 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
1468 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
1469 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
1470 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
1471 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
1472 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
1473 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
1475 { .name
= NULL
, .value
= -1 },
1478 context
= Jim_GetAssocData(interp
, "context");
1479 /* go past the command */
1480 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
1482 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
1484 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
1487 Jim_SetEmptyResult( goi
.interp
);
1489 case JTAG_CMD_INTERFACE
:
1490 /* return the name of the interface */
1491 /* TCL code might need to know the exact type... */
1492 /* FUTURE: we allow this as a means to "set" the interface. */
1493 if( goi
.argc
!= 0 ){
1494 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1497 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
1499 case JTAG_CMD_INIT_RESET
:
1500 if( goi
.argc
!= 0 ){
1501 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1504 e
= jtag_init_reset(context
);
1505 if( e
!= ERROR_OK
){
1506 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
1510 case JTAG_CMD_NEWTAP
:
1511 return jim_newtap_cmd( &goi
);
1513 case JTAG_CMD_TAPISENABLED
:
1514 case JTAG_CMD_TAPENABLE
:
1515 case JTAG_CMD_TAPDISABLE
:
1516 if( goi
.argc
!= 1 ){
1517 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
1523 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
1528 case JTAG_CMD_TAPISENABLED
:
1531 case JTAG_CMD_TAPENABLE
:
1532 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
1536 case JTAG_CMD_TAPDISABLE
:
1537 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
1542 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
1549 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
1556 Jim_GetOpt_Obj(&goi
, &o
);
1557 t
= jtag_TapByJimObj( goi
.interp
, o
);
1562 goi
.isconfigure
= 0;
1563 return jtag_tap_configure_cmd( &goi
, t
);
1567 case JTAG_CMD_CONFIGURE
:
1569 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
1576 Jim_GetOpt_Obj(&goi
, &o
);
1577 t
= jtag_TapByJimObj( goi
.interp
, o
);
1582 goi
.isconfigure
= 1;
1583 return jtag_tap_configure_cmd( &goi
, t
);
1590 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1592 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
1594 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1595 COMMAND_CONFIG
, "try to configure interface");
1596 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1597 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
1598 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1599 COMMAND_ANY
, "set maximum jtag speed (if supported); "
1600 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1601 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1602 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1603 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1605 "[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]");
1606 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1607 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1608 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1609 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1611 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1612 COMMAND_EXEC
, "print current scan chain configuration");
1614 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1615 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1616 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1617 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1618 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1619 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1620 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1621 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1622 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1623 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
1625 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1626 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1627 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
1628 COMMAND_ANY
, "verify value capture <enable|disable>");
1629 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
1630 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
1634 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1639 if (!jtag_interface
)
1641 /* nothing was previously specified by "interface" command */
1642 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1643 return ERROR_JTAG_INVALID_INTERFACE
;
1647 jtag_interface
->khz(speed_khz
, &jtag_speed
);
1651 if (jtag_interface
->init() != ERROR_OK
)
1652 return ERROR_JTAG_INIT_FAILED
;
1654 jtag
= jtag_interface
;
1658 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1663 LOG_DEBUG("Init JTAG chain");
1665 tap
= jtag_NextEnabledTap(NULL
);
1667 LOG_ERROR("There are no enabled taps?");
1668 return ERROR_JTAG_INIT_FAILED
;
1672 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1675 /* examine chain first, as this could discover the real chain layout */
1676 if (jtag_examine_chain() != ERROR_OK
)
1678 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1681 if (jtag_validate_chain() != ERROR_OK
)
1683 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1689 int jtag_interface_quit(void)
1691 if (!jtag
|| !jtag
->quit
)
1694 // close the JTAG interface
1695 int result
= jtag
->quit();
1696 if (ERROR_OK
!= result
)
1697 LOG_ERROR("failed: %d", result
);
1703 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1707 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1710 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1712 /* Reset can happen after a power cycle.
1714 * Ideally we would only assert TRST or run RESET before the target reset.
1716 * However w/srst_pulls_trst, trst is asserted together with the target
1717 * reset whether we want it or not.
1719 * NB! Some targets have JTAG circuitry disabled until a
1720 * trst & srst has been asserted.
1722 * NB! here we assume nsrst/ntrst delay are sufficient!
1724 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1727 jtag_add_reset(1, 0); /* RESET or TRST */
1728 if (jtag_reset_config
& RESET_HAS_SRST
)
1730 jtag_add_reset(1, 1);
1731 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1732 jtag_add_reset(0, 1);
1734 jtag_add_reset(0, 0);
1735 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1738 /* Check that we can communication on the JTAG chain + eventually we want to
1739 * be able to perform enumeration only after OpenOCD has started
1740 * telnet and GDB server
1742 * That would allow users to more easily perform any magic they need to before
1745 return jtag_init_inner(cmd_ctx
);
1748 int jtag_init(struct command_context_s
*cmd_ctx
)
1751 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1753 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1757 return jtag_init_reset(cmd_ctx
);
1760 static int default_khz(int khz
, int *jtag_speed
)
1762 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1766 static int default_speed_div(int speed
, int *khz
)
1768 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1772 static int default_power_dropout(int *dropout
)
1774 *dropout
=0; /* by default we can't detect power dropout */
1778 static int default_srst_asserted(int *srst_asserted
)
1780 *srst_asserted
=0; /* by default we can't detect srst asserted */
1784 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1789 /* check whether the interface is already configured */
1792 LOG_WARNING("Interface already configured, ignoring");
1796 /* interface name is a mandatory argument */
1797 if (argc
< 1 || args
[0][0] == '\0')
1799 return ERROR_COMMAND_SYNTAX_ERROR
;
1802 for (i
=0; jtag_interfaces
[i
]; i
++)
1804 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1806 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
1811 jtag_interface
= jtag_interfaces
[i
];
1813 if (jtag_interface
->khz
== NULL
)
1815 jtag_interface
->khz
= default_khz
;
1817 if (jtag_interface
->speed_div
== NULL
)
1819 jtag_interface
->speed_div
= default_speed_div
;
1821 if (jtag_interface
->power_dropout
== NULL
)
1823 jtag_interface
->power_dropout
= default_power_dropout
;
1825 if (jtag_interface
->srst_asserted
== NULL
)
1827 jtag_interface
->srst_asserted
= default_srst_asserted
;
1834 /* no valid interface was found (i.e. the configuration option,
1835 * didn't match one of the compiled-in interfaces
1837 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
1838 LOG_ERROR("compiled-in jtag interfaces:");
1839 for (i
= 0; jtag_interfaces
[i
]; i
++)
1841 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1844 return ERROR_JTAG_INVALID_INTERFACE
;
1847 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1851 Jim_Obj
*newargs
[ 10 ];
1854 * argv[-1] = command
1855 * argv[ 0] = ir length
1856 * argv[ 1] = ir capture
1857 * argv[ 2] = ir mask
1858 * argv[ 3] = not actually used by anything but in the docs
1862 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
1865 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
1866 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
1870 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
1871 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
1872 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
1873 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
1875 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
1876 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
1877 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
1878 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
1879 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
1880 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
1881 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
1882 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
1883 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
1884 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
1885 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
1886 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
1888 command_print( cmd_ctx
, "NEW COMMAND:");
1889 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
1890 Jim_GetString( newargs
[0], NULL
),
1891 Jim_GetString( newargs
[1], NULL
),
1892 Jim_GetString( newargs
[2], NULL
),
1893 Jim_GetString( newargs
[3], NULL
),
1894 Jim_GetString( newargs
[4], NULL
),
1895 Jim_GetString( newargs
[5], NULL
),
1896 Jim_GetString( newargs
[6], NULL
),
1897 Jim_GetString( newargs
[7], NULL
),
1898 Jim_GetString( newargs
[8], NULL
),
1899 Jim_GetString( newargs
[9], NULL
) );
1901 e
= jim_jtag_command( interp
, 10, newargs
);
1903 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
1908 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1912 tap
= jtag_all_taps
;
1913 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
1914 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
1917 u32 expected
, expected_mask
, cur_instr
, ii
;
1918 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
1919 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
1920 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
1922 command_print(cmd_ctx
,
1923 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
1924 tap
->abs_chain_position
,
1926 tap
->enabled
? 'Y' : 'n',
1928 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
1934 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
1935 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
1936 tap
->expected_ids
[ii
]);
1939 tap
= tap
->next_tap
;
1945 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1951 return ERROR_COMMAND_SYNTAX_ERROR
;
1953 /* Original versions cared about the order of these tokens:
1954 * reset_config signals [combination [trst_type [srst_type]]]
1955 * They also clobbered the previous configuration even on error.
1957 * Here we don't care about the order, and only change values
1958 * which have been explicitly specified.
1960 for (; argc
; argc
--, args
++) {
1965 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
1966 if (strcmp(*args
, "none") == 0)
1968 else if (strcmp(*args
, "trst_only") == 0)
1969 tmp
= RESET_HAS_TRST
;
1970 else if (strcmp(*args
, "srst_only") == 0)
1971 tmp
= RESET_HAS_SRST
;
1972 else if (strcmp(*args
, "trst_and_srst") == 0)
1973 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
1977 LOG_ERROR("extra reset_config %s spec (%s)",
1979 return ERROR_INVALID_ARGUMENTS
;
1984 /* combination (options for broken wiring) */
1985 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1986 if (strcmp(*args
, "separate") == 0)
1987 /* separate reset lines - default */;
1988 else if (strcmp(*args
, "srst_pulls_trst") == 0)
1989 tmp
|= RESET_SRST_PULLS_TRST
;
1990 else if (strcmp(*args
, "trst_pulls_srst") == 0)
1991 tmp
|= RESET_TRST_PULLS_SRST
;
1992 else if (strcmp(*args
, "combined") == 0)
1993 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1997 LOG_ERROR("extra reset_config %s spec (%s)",
1998 "combination", *args
);
1999 return ERROR_INVALID_ARGUMENTS
;
2004 /* trst_type (NOP without HAS_TRST) */
2005 m
= RESET_TRST_OPEN_DRAIN
;
2006 if (strcmp(*args
, "trst_open_drain") == 0)
2007 tmp
|= RESET_TRST_OPEN_DRAIN
;
2008 else if (strcmp(*args
, "trst_push_pull") == 0)
2009 /* push/pull from adapter - default */;
2013 LOG_ERROR("extra reset_config %s spec (%s)",
2014 "trst_type", *args
);
2015 return ERROR_INVALID_ARGUMENTS
;
2020 /* srst_type (NOP without HAS_SRST) */
2021 m
|= RESET_SRST_PUSH_PULL
;
2022 if (strcmp(*args
, "srst_push_pull") == 0)
2023 tmp
|= RESET_SRST_PUSH_PULL
;
2024 else if (strcmp(*args
, "srst_open_drain") == 0)
2025 /* open drain from adapter - default */;
2029 LOG_ERROR("extra reset_config %s spec (%s)",
2030 "srst_type", *args
);
2031 return ERROR_INVALID_ARGUMENTS
;
2036 /* caller provided nonsense; fail */
2037 LOG_ERROR("unknown reset_config flag (%s)", *args
);
2038 return ERROR_INVALID_ARGUMENTS
;
2041 /* Remember the bits which were specified (mask)
2042 * and their new values (new_cfg).
2048 /* clear previous values of those bits, save new values */
2049 jtag_reset_config
&= ~mask
;
2050 jtag_reset_config
|= new_cfg
;
2055 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2059 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2064 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2070 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2074 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2079 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2085 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2087 int retval
=ERROR_OK
;
2091 LOG_DEBUG("handle jtag speed");
2094 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2096 /* this command can be called during CONFIG,
2097 * in which case jtag isn't initialized */
2100 retval
=jtag
->speed(cur_speed
);
2102 } else if (argc
== 0)
2106 return ERROR_COMMAND_SYNTAX_ERROR
;
2108 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2113 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2115 int retval
=ERROR_OK
;
2116 LOG_DEBUG("handle jtag khz");
2120 speed_khz
= strtoul(args
[0], NULL
, 0);
2124 LOG_DEBUG("have interface set up");
2126 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2132 cur_speed
= jtag_speed
= speed_div1
;
2134 retval
=jtag
->speed(cur_speed
);
2143 return ERROR_COMMAND_SYNTAX_ERROR
;
2148 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2154 command_print(cmd_ctx
, "RCLK - adaptive");
2157 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2163 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2169 return ERROR_COMMAND_SYNTAX_ERROR
;
2173 state
= tap_state_by_name( args
[0] );
2175 command_print( cmd_ctx
, "Invalid state name: %s\n", args
[0] );
2176 return ERROR_COMMAND_SYNTAX_ERROR
;
2178 jtag_add_end_state(state
);
2179 jtag_execute_queue();
2181 command_print(cmd_ctx
, "current endstate: %s", tap_state_name(cmd_queue_end_state
));
2186 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2193 return ERROR_COMMAND_SYNTAX_ERROR
;
2196 if (args
[0][0] == '1')
2198 else if (args
[0][0] == '0')
2202 return ERROR_COMMAND_SYNTAX_ERROR
;
2205 if (args
[1][0] == '1')
2207 else if (args
[1][0] == '0')
2211 return ERROR_COMMAND_SYNTAX_ERROR
;
2214 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2215 return ERROR_JTAG_INIT_FAILED
;
2217 jtag_add_reset(trst
, srst
);
2218 jtag_execute_queue();
2223 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2227 return ERROR_COMMAND_SYNTAX_ERROR
;
2230 jtag_add_runtest(strtol(args
[0], NULL
, 0), TAP_INVALID
);
2231 jtag_execute_queue();
2238 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2239 * should be stable ... and *NOT* a shift state, otherwise free-running
2240 * jtag clocks could change the values latched by the update state.
2242 static bool scan_is_safe(tap_state_t state
)
2257 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2260 scan_field_t
*fields
;
2262 tap_state_t endstate
;
2264 if ((argc
< 2) || (argc
% 2))
2266 return ERROR_COMMAND_SYNTAX_ERROR
;
2269 /* optional "-endstate" "statename" at the end of the arguments,
2270 * so that e.g. IRPAUSE can let us load the data register before
2271 * entering RUN/IDLE to execute the instruction we load here.
2273 endstate
= TAP_IDLE
;
2276 /* have at least one pair of numbers. */
2277 /* is last pair the magic text? */
2278 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
2281 cpA
= args
[ argc
-1 ];
2282 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
2283 cpS
= tap_state_name( endstate
);
2284 if( 0 == strcmp( cpA
, cpS
) ){
2288 if( endstate
>= TAP_NUM_STATES
){
2289 return ERROR_COMMAND_SYNTAX_ERROR
;
2291 if (!scan_is_safe(endstate
))
2292 LOG_WARNING("irscan with unsafe "
2293 "endstate \"%s\"", cpA
);
2294 /* found - remove the last 2 args */
2300 int num_fields
= argc
/ 2;
2302 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2304 for (i
= 0; i
< num_fields
; i
++)
2306 tap
= jtag_TapByString( args
[i
*2] );
2309 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2312 int field_size
= tap
->ir_length
;
2313 fields
[i
].tap
= tap
;
2314 fields
[i
].num_bits
= field_size
;
2315 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2316 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2317 fields
[i
].in_value
= NULL
;
2320 /* did we have an endstate? */
2321 jtag_add_ir_scan(num_fields
, fields
, endstate
);
2323 int retval
=jtag_execute_queue();
2325 for (i
= 0; i
< num_fields
; i
++)
2326 free(fields
[i
].out_value
);
2333 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2336 scan_field_t
*fields
;
2338 int field_count
= 0;
2341 tap_state_t endstate
;
2344 * args[2] = num_bits
2345 * args[3] = hex string
2346 * ... repeat num bits and hex string ...
2349 * args[N-2] = "-endstate"
2350 * args[N-1] = statename
2352 if ((argc
< 4) || ((argc
% 2)!=0))
2354 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2358 endstate
= TAP_IDLE
;
2360 /* validate arguments as numbers */
2362 for (i
= 2; i
< argc
; i
+=2)
2367 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2368 /* If valid - try next arg */
2373 /* Not valid.. are we at the end? */
2374 if ( ((i
+2) != argc
) ){
2375 /* nope, then error */
2379 /* it could be: "-endstate FOO"
2380 * e.g. DRPAUSE so we can issue more instructions
2381 * before entering RUN/IDLE and executing them.
2384 /* get arg as a string. */
2385 cp
= Jim_GetString( args
[i
], NULL
);
2386 /* is it the magic? */
2387 if( 0 == strcmp( "-endstate", cp
) ){
2388 /* is the statename valid? */
2389 cp
= Jim_GetString( args
[i
+1], NULL
);
2391 /* see if it is a valid state name */
2392 endstate
= tap_state_by_name(cp
);
2394 /* update the error message */
2395 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
2397 if (!scan_is_safe(endstate
))
2398 LOG_WARNING("drscan with unsafe "
2399 "endstate \"%s\"", cp
);
2401 /* valid - so clear the error */
2403 /* and remove the last 2 args */
2408 /* Still an error? */
2410 return e
; /* too bad */
2412 } /* validate args */
2414 tap
= jtag_TapByJimObj( interp
, args
[1] );
2419 num_fields
=(argc
-2)/2;
2420 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2421 for (i
= 2; i
< argc
; i
+=2)
2427 Jim_GetLong(interp
, args
[i
], &bits
);
2428 str
= Jim_GetString(args
[i
+1], &len
);
2430 fields
[field_count
].tap
= tap
;
2431 fields
[field_count
].num_bits
= bits
;
2432 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2433 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2434 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2438 jtag_add_dr_scan(num_fields
, fields
, endstate
);
2440 retval
= jtag_execute_queue();
2441 if (retval
!= ERROR_OK
)
2443 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
2448 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2449 for (i
= 2; i
< argc
; i
+=2)
2454 Jim_GetLong(interp
, args
[i
], &bits
);
2455 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2456 free(fields
[field_count
].out_value
);
2458 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2463 Jim_SetResult(interp
, list
);
2471 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2473 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_flush_queue_count
));
2479 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2483 if (strcmp(args
[0], "enable") == 0)
2485 jtag_verify_capture_ir
= 1;
2487 else if (strcmp(args
[0], "disable") == 0)
2489 jtag_verify_capture_ir
= 0;
2492 return ERROR_COMMAND_SYNTAX_ERROR
;
2494 } else if (argc
!= 0)
2496 return ERROR_COMMAND_SYNTAX_ERROR
;
2499 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2504 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2508 if (strcmp(args
[0], "enable") == 0)
2512 else if (strcmp(args
[0], "disable") == 0)
2517 return ERROR_COMMAND_SYNTAX_ERROR
;
2519 } else if (argc
!= 0)
2521 return ERROR_COMMAND_SYNTAX_ERROR
;
2524 command_print(cmd_ctx
, "verify jtag capture is %s", (jtag_verify
) ? "enabled": "disabled");
2530 int jtag_power_dropout(int *dropout
)
2532 return jtag
->power_dropout(dropout
);
2535 int jtag_srst_asserted(int *srst_asserted
)
2537 return jtag
->srst_asserted(srst_asserted
);
2540 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
2542 jtag_tap_event_action_t
* jteap
;
2545 jteap
= tap
->event_action
;
2549 if (jteap
->event
== e
) {
2551 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2554 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
2555 Jim_GetString(jteap
->body
, NULL
) );
2556 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
2557 Jim_PrintErrorMessage(interp
);
2561 jteap
= jteap
->next
;
2565 LOG_DEBUG( "event %d %s - no action",
2567 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
2571 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2574 return ERROR_COMMAND_SYNTAX_ERROR
;
2579 if (strcmp(args
[0], "short") == 0)
2580 use_new_table
= true;
2581 else if (strcmp(args
[0], "long") == 0)
2582 use_new_table
= false;
2584 return ERROR_COMMAND_SYNTAX_ERROR
;
2586 tap_use_new_tms_table(use_new_table
);
2589 command_print(cmd_ctx
, "tms sequence is %s",
2590 tap_uses_new_tms_table() ? "short": "long");
2596 * Function jtag_add_statemove
2597 * moves from the current state to the goal \a state. This needs
2598 * to be handled according to the xsvf spec, see the XSTATE command
2601 int jtag_add_statemove(tap_state_t goal_state
)
2603 int retval
= ERROR_OK
;
2605 tap_state_t moves
[8];
2606 tap_state_t cur_state
= cmd_queue_cur_state
;
2611 LOG_DEBUG( "cur_state=%s goal_state=%s",
2612 tap_state_name(cur_state
),
2613 tap_state_name(goal_state
) );
2616 /* From the XSVF spec, pertaining to XSTATE:
2618 For special states known as stable states (Test-Logic-Reset,
2619 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2620 predefined TAP state paths when the starting state is a stable state and
2621 when the XSTATE specifies a new stable state (see the STATE command in
2622 the [Ref 5] for the TAP state paths between stable states). For
2623 non-stable states, XSTATE should specify a state that is only one TAP
2624 state transition distance from the current TAP state to avoid undefined
2625 TAP state paths. A sequence of multiple XSTATE commands can be issued to
2626 transition the TAP through a specific state path.
2629 if (goal_state
==cur_state
)
2630 ; /* nothing to do */
2632 else if( goal_state
==TAP_RESET
)
2637 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
2639 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
2640 spec, then this code is not fully conformant to the xsvf spec. This
2641 puts a burden on tap_get_tms_path() function from the xsvf spec.
2642 If in doubt, you should confirm that that burden is being met.
2645 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
2646 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
2648 assert( (unsigned) tms_count
< DIM(moves
) );
2650 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
2652 bool bit
= tms_bits
& 1;
2654 cur_state
= tap_state_transition(cur_state
, bit
);
2655 moves
[i
] = cur_state
;
2658 jtag_add_pathmove(tms_count
, moves
);
2661 /* else state must be immediately reachable in one clock cycle, and does not
2662 need to be a stable state.
2664 else if( tap_state_transition(cur_state
, true) == goal_state
2665 || tap_state_transition(cur_state
, false) == goal_state
)
2667 /* move a single state */
2668 moves
[0] = goal_state
;
2669 jtag_add_pathmove( 1, moves
);
2674 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)