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 ***************************************************************************/
38 int jtag_flush_queue_count
; /* count # of flushes for profiling / debugging purposes */
40 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
41 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
);
43 /* note that this is not marked as static as it must be available from outside jtag.c for those
44 that implement the jtag_xxx() minidriver layer
46 int jtag_error
=ERROR_OK
;
48 typedef struct cmd_queue_page_s
52 struct cmd_queue_page_s
*next
;
55 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
56 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
58 char* jtag_event_strings
[] =
60 "JTAG controller reset (RESET or TRST)"
63 const Jim_Nvp nvp_jtag_tap_event
[] = {
64 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
65 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
67 { .name
= NULL
, .value
= -1 }
73 #ifndef HAVE_JTAG_MINIDRIVER_H
74 struct jtag_callback_entry
76 struct jtag_callback_entry
*next
;
78 jtag_callback_t callback
;
80 jtag_callback_data_t data1
;
81 jtag_callback_data_t data2
;
82 jtag_callback_data_t data3
;
86 static struct jtag_callback_entry
*jtag_callback_queue_head
= NULL
;
87 static struct jtag_callback_entry
*jtag_callback_queue_tail
= NULL
;
91 jtag_command_t
*jtag_command_queue
= NULL
;
92 jtag_command_t
**last_command_pointer
= &jtag_command_queue
;
93 static jtag_tap_t
*jtag_all_taps
= NULL
;
95 enum reset_types jtag_reset_config
= RESET_NONE
;
96 tap_state_t cmd_queue_end_state
= TAP_RESET
;
97 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
99 int jtag_verify_capture_ir
= 1;
102 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
103 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
104 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
106 /* maximum number of JTAG devices expected in the chain
108 #define JTAG_MAX_CHAIN_SIZE 20
110 /* callbacks to inform high-level handlers about JTAG state changes */
111 jtag_event_callback_t
*jtag_event_callbacks
;
114 static int speed_khz
= 0;
115 /* flag if the kHz speed was defined */
116 static int hasKHz
= 0;
118 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
121 #if BUILD_ECOSBOARD == 1
122 extern jtag_interface_t zy1000_interface
;
125 #if BUILD_PARPORT == 1
126 extern jtag_interface_t parport_interface
;
130 extern jtag_interface_t dummy_interface
;
133 #if BUILD_FT2232_FTD2XX == 1
134 extern jtag_interface_t ft2232_interface
;
137 #if BUILD_FT2232_LIBFTDI == 1
138 extern jtag_interface_t ft2232_interface
;
141 #if BUILD_AMTJTAGACCEL == 1
142 extern jtag_interface_t amt_jtagaccel_interface
;
145 #if BUILD_EP93XX == 1
146 extern jtag_interface_t ep93xx_interface
;
149 #if BUILD_AT91RM9200 == 1
150 extern jtag_interface_t at91rm9200_interface
;
153 #if BUILD_GW16012 == 1
154 extern jtag_interface_t gw16012_interface
;
157 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
158 extern jtag_interface_t presto_interface
;
161 #if BUILD_USBPROG == 1
162 extern jtag_interface_t usbprog_interface
;
166 extern jtag_interface_t jlink_interface
;
169 #if BUILD_VSLLINK == 1
170 extern jtag_interface_t vsllink_interface
;
174 extern jtag_interface_t rlink_interface
;
177 #if BUILD_ARMJTAGEW == 1
178 extern jtag_interface_t armjtagew_interface
;
181 jtag_interface_t
*jtag_interfaces
[] = {
182 #if BUILD_ECOSBOARD == 1
185 #if BUILD_PARPORT == 1
191 #if BUILD_FT2232_FTD2XX == 1
194 #if BUILD_FT2232_LIBFTDI == 1
197 #if BUILD_AMTJTAGACCEL == 1
198 &amt_jtagaccel_interface
,
200 #if BUILD_EP93XX == 1
203 #if BUILD_AT91RM9200 == 1
204 &at91rm9200_interface
,
206 #if BUILD_GW16012 == 1
209 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
212 #if BUILD_USBPROG == 1
218 #if BUILD_VSLLINK == 1
224 #if BUILD_ARMJTAGEW == 1
225 &armjtagew_interface
,
230 jtag_interface_t
*jtag
= NULL
;
233 static jtag_interface_t
*jtag_interface
= NULL
;
236 /* forward declarations */
237 //void jtag_add_pathmove(int num_states, tap_state_t *path);
238 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
239 //void jtag_add_end_state(tap_state_t endstate);
240 //void jtag_add_sleep(u32 us);
241 //int jtag_execute_queue(void);
242 static tap_state_t
tap_state_by_name(const char *name
);
245 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
246 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
247 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
248 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
249 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
250 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
251 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
253 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
255 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
256 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
257 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
258 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
259 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
260 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
262 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
263 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
264 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
266 jtag_tap_t
*jtag_AllTaps(void)
268 return jtag_all_taps
;
271 int jtag_NumTotalTaps(void)
285 int jtag_NumEnabledTaps(void)
301 jtag_tap_t
*jtag_TapByString( const char *s
)
309 if( 0 == strcmp( t
->dotted_name
, s
) ){
315 /* backup plan is by number */
317 /* ok - is "s" a number? */
319 n
= strtol( s
, &cp
, 0 );
320 if( (s
!= cp
) && (*cp
== 0) ){
322 t
= jtag_TapByAbsPosition(n
);
328 jtag_tap_t
* jtag_TapByJimObj( Jim_Interp
*interp
, Jim_Obj
*o
)
333 cp
= Jim_GetString( o
, NULL
);
338 t
= jtag_TapByString( cp
);
341 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
346 /* returns a pointer to the n-th device in the scan chain */
347 jtag_tap_t
* jtag_TapByAbsPosition( int n
)
355 while( t
&& (n
> 0)) {
362 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
364 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
366 if (callback
== NULL
)
368 return ERROR_INVALID_ARGUMENTS
;
373 while ((*callbacks_p
)->next
)
374 callbacks_p
= &((*callbacks_p
)->next
);
375 callbacks_p
= &((*callbacks_p
)->next
);
378 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
379 (*callbacks_p
)->callback
= callback
;
380 (*callbacks_p
)->priv
= priv
;
381 (*callbacks_p
)->next
= NULL
;
386 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
388 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
390 if (callback
== NULL
)
392 return ERROR_INVALID_ARGUMENTS
;
397 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
398 if ((*callbacks_p
)->callback
== callback
)
401 *callbacks_p
= *next
;
409 int jtag_call_event_callbacks(enum jtag_event event
)
411 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
413 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
417 callback
->callback(event
, callback
->priv
);
418 callback
= callback
->next
;
424 /* returns a pointer to the pointer of the last command in queue
425 * this may be a pointer to the root pointer (jtag_command_queue)
426 * or to the next member of the last but one command
428 jtag_command_t
** jtag_get_last_command_p(void)
430 /* jtag_command_t *cmd = jtag_command_queue;
436 return &jtag_command_queue;
440 return last_command_pointer
;
444 void jtag_queue_command(jtag_command_t
* cmd
)
446 jtag_command_t
**last_cmd
;
448 last_cmd
= jtag_get_last_command_p();
452 (*last_cmd
)->next
= NULL
;
454 last_command_pointer
= &((*last_cmd
)->next
);
458 void* cmd_queue_alloc(size_t size
)
460 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
466 * We align/round the *SIZE* per below
467 * so that all pointers returned by
468 * this function are reasonably well
471 * If we did not, then an "odd-length" request would cause the
472 * *next* allocation to be at an *odd* address, and because
473 * this function has the same type of api as malloc() - we
474 * must also return pointers that have the same type of
477 * What I do not/have is a reasonable portable means
480 * The solution here, is based on these suggestions.
481 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
484 union worse_case_align
{
490 #define ALIGN_SIZE (sizeof(union worse_case_align))
492 /* The alignment process. */
493 size
= (size
+ ALIGN_SIZE
-1) & (~(ALIGN_SIZE
-1));
498 while ((*p_page
)->next
)
499 p_page
= &((*p_page
)->next
);
500 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
501 p_page
= &((*p_page
)->next
);
506 *p_page
= malloc(sizeof(cmd_queue_page_t
));
508 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
509 (*p_page
)->next
= NULL
;
512 offset
= (*p_page
)->used
;
513 (*p_page
)->used
+= size
;
515 t
=(u8
*)((*p_page
)->address
);
519 void cmd_queue_free(void)
521 cmd_queue_page_t
*page
= cmd_queue_pages
;
525 cmd_queue_page_t
*last
= page
;
531 cmd_queue_pages
= NULL
;
534 static void jtag_prelude1(void)
538 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
539 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
543 if (cmd_queue_end_state
== TAP_RESET
)
544 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
547 static void jtag_prelude(tap_state_t state
)
551 if (state
!= TAP_INVALID
)
552 jtag_add_end_state(state
);
554 cmd_queue_cur_state
= cmd_queue_end_state
;
557 void jtag_add_ir_scan_noverify(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
562 retval
=interface_jtag_add_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
563 if (retval
!=ERROR_OK
)
570 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
572 * If the input field list contains an instruction value for a TAP then that is used
573 * otherwise the TAP is set to bypass.
575 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
578 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
580 if (jtag_verify
&&jtag_verify_capture_ir
)
582 /* 8 x 32 bit id's is enough for all invoations */
584 for (int j
= 0; j
< in_num_fields
; j
++)
586 in_fields
[j
].check_value
=NULL
;
587 in_fields
[j
].check_mask
=NULL
;
588 /* if we are to run a verification of the ir scan, we need to get the input back.
589 * We may have to allocate space if the caller didn't ask for the input back.
591 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
592 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
594 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
597 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
602 * see jtag_add_ir_scan()
605 int MINIDRIVER(interface_jtag_add_ir_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
609 int num_taps
= jtag_NumEnabledTaps();
611 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
612 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
613 scan_field_t
* out_fields
= cmd_queue_alloc(num_taps
* sizeof(scan_field_t
));
615 jtag_queue_command(cmd
);
617 cmd
->type
= JTAG_SCAN
;
618 cmd
->cmd
.scan
= scan
;
620 scan
->ir_scan
= true;
621 scan
->num_fields
= num_taps
; /* one field per device */
622 scan
->fields
= out_fields
;
623 scan
->end_state
= state
;
627 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
633 assert(nth_tap
< num_taps
);
635 size_t scan_size
= tap
->ir_length
;
636 scan
->fields
[nth_tap
].tap
= tap
;
637 scan
->fields
[nth_tap
].num_bits
= scan_size
;
638 scan
->fields
[nth_tap
].in_value
= NULL
; /* do not collect input for tap's in bypass */
640 /* search the list */
641 for (int j
= 0; j
< in_num_fields
; j
++)
643 if (tap
== in_fields
[j
].tap
)
646 scan
->fields
[nth_tap
].in_value
= in_fields
[j
].in_value
;
647 scan
->fields
[nth_tap
].out_value
= buf_cpy(in_fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
656 /* if a tap isn't listed, set it to BYPASS */
657 scan
->fields
[nth_tap
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
661 /* update device information */
662 buf_cpy(scan
->fields
[nth_tap
].out_value
, tap
->cur_instr
, scan_size
);
665 assert(nth_tap
== (num_taps
- 1));
671 * Duplicate the scan fields passed into the function into an IR SCAN command
673 * This function assumes that the caller handles extra fields for bypassed TAPs
676 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
682 retval
=interface_jtag_add_plain_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
683 if (retval
!=ERROR_OK
)
689 * see jtag_add_plain_ir_scan()
692 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
695 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
696 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
697 scan_field_t
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(scan_field_t
));
699 jtag_queue_command(cmd
);
701 cmd
->type
= JTAG_SCAN
;
702 cmd
->cmd
.scan
= scan
;
704 scan
->ir_scan
= true;
705 scan
->num_fields
= in_num_fields
;
706 scan
->fields
= out_fields
;
707 scan
->end_state
= state
;
709 for (int i
= 0; i
< in_num_fields
; i
++)
711 int num_bits
= in_fields
[i
].num_bits
;
712 int num_bytes
= CEIL(in_fields
[i
].num_bits
, 8);
713 scan
->fields
[i
].tap
= in_fields
[i
].tap
;
714 scan
->fields
[i
].num_bits
= num_bits
;
715 scan
->fields
[i
].out_value
= buf_cpy(in_fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
716 scan
->fields
[i
].in_value
= in_fields
[i
].in_value
;
724 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
726 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
728 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
731 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
732 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
734 for (int i
= 0; i
< in_num_fields
; i
++)
736 in_fields
[i
].allocated
= 0;
737 in_fields
[i
].modified
= 0;
738 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
== NULL
))
740 in_fields
[i
].modified
= 1;
741 /* we need storage space... */
742 #ifdef HAVE_JTAG_MINIDRIVER_H
743 if (in_fields
[i
].num_bits
<= 32)
745 /* This is enough space and we're executing this synchronously */
746 in_fields
[i
].in_value
= in_fields
[i
].intmp
;
749 in_fields
[i
].in_value
= (u8
*)malloc(CEIL(in_fields
[i
].num_bits
, 8));
750 in_fields
[i
].allocated
= 1;
753 in_fields
[i
].in_value
= (u8
*)cmd_queue_alloc(CEIL(in_fields
[i
].num_bits
, 8));
758 jtag_add_scan(in_num_fields
, in_fields
, state
);
760 for (int i
= 0; i
< in_num_fields
; i
++)
762 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
764 /* this is synchronous for a minidriver */
765 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
766 (jtag_callback_data_t
)in_fields
[i
].check_value
,
767 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
768 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
770 if (in_fields
[i
].allocated
)
772 free(in_fields
[i
].in_value
);
774 if (in_fields
[i
].modified
)
776 in_fields
[i
].in_value
= NULL
;
781 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
785 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
788 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
794 * Generate a DR SCAN using the fields passed to the function
796 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
797 * For bypassed TAPs the function generates a dummy 1bit field.
799 * The bypass status of TAPs is set by jtag_add_ir_scan().
802 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
808 retval
=interface_jtag_add_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
809 if (retval
!=ERROR_OK
)
815 * see jtag_add_dr_scan()
818 int MINIDRIVER(interface_jtag_add_dr_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
824 /* count devices in bypass */
826 size_t bypass_devices
= 0;
828 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
834 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
835 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
836 scan_field_t
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
838 jtag_queue_command(cmd
);
840 cmd
->type
= JTAG_SCAN
;
841 cmd
->cmd
.scan
= scan
;
843 scan
->ir_scan
= false;
844 scan
->num_fields
= in_num_fields
+ bypass_devices
;
845 scan
->fields
= out_fields
;
846 scan
->end_state
= state
;
850 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
855 scan
->fields
[field_count
].tap
= tap
;
857 for (j
= 0; j
< in_num_fields
; j
++)
859 if (tap
== in_fields
[j
].tap
)
862 size_t scan_size
= in_fields
[j
].num_bits
;
863 scan
->fields
[field_count
].num_bits
= scan_size
;
864 scan
->fields
[field_count
].out_value
= buf_cpy(in_fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
865 scan
->fields
[field_count
].in_value
= in_fields
[j
].in_value
;
871 #ifdef _DEBUG_JTAG_IO_
872 /* if a device isn't listed, the BYPASS register should be selected */
875 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
879 /* program the scan field to 1 bit length, and ignore it's value */
880 scan
->fields
[field_count
].num_bits
= 1;
881 scan
->fields
[field_count
].out_value
= NULL
;
882 scan
->fields
[field_count
].in_value
= NULL
;
887 #ifdef _DEBUG_JTAG_IO_
888 /* if a device is listed, the BYPASS register must not be selected */
891 LOG_ERROR("BUG: scan data for a device in BYPASS");
898 /* field_count represents the true number of fields setup*/
899 scan
->num_fields
= field_count
;
906 * Generate a DR SCAN using the array of output values passed to the function
908 * This function assumes that the parameter target_tap specifies the one TAP
909 * that is not bypassed. All other TAPs must be bypassed and the function will
910 * generate a dummy 1bit field for them.
912 * For the target_tap a sequence of output-only fields will be generated where
913 * each field has the size num_bits and the field's values are taken from
916 * The bypass status of TAPs is set by jtag_add_ir_scan().
919 void MINIDRIVER(interface_jtag_add_dr_out
)(jtag_tap_t
*target_tap
,
923 tap_state_t end_state
)
928 /* count devices in bypass */
930 size_t bypass_devices
= 0;
932 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
939 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
940 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
941 scan_field_t
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
943 jtag_queue_command(cmd
);
945 cmd
->type
= JTAG_SCAN
;
946 cmd
->cmd
.scan
= scan
;
948 scan
->ir_scan
= false;
949 scan
->num_fields
= in_num_fields
+ bypass_devices
;
950 scan
->fields
= out_fields
;
951 scan
->end_state
= end_state
;
955 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
958 scan
->fields
[field_count
].tap
= tap
;
960 if (tap
== target_tap
)
962 #ifdef _DEBUG_JTAG_IO_
963 /* if a device is listed, the BYPASS register must not be selected */
966 LOG_ERROR("BUG: scan data for a device in BYPASS");
970 for (int j
= 0; j
< in_num_fields
; j
++)
973 size_t scan_size
= num_bits
[j
];
974 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
975 scan
->fields
[field_count
].num_bits
= scan_size
;
976 scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
977 scan
->fields
[field_count
].in_value
= NULL
;
982 #ifdef _DEBUG_JTAG_IO_
983 /* if a device isn't listed, the BYPASS register should be selected */
986 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
990 /* program the scan field to 1 bit length, and ignore it's value */
991 scan
->fields
[field_count
].num_bits
= 1;
992 scan
->fields
[field_count
].out_value
= NULL
;
993 scan
->fields
[field_count
].in_value
= NULL
;
1001 * Duplicate the scan fields passed into the function into a DR SCAN command
1003 * This function assumes that the caller handles extra fields for bypassed TAPs
1006 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
1010 jtag_prelude(state
);
1012 retval
=interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
1013 if (retval
!=ERROR_OK
)
1019 * see jtag_add_plain_dr_scan()
1022 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
1024 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1025 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
1026 scan_field_t
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(scan_field_t
));
1028 jtag_queue_command(cmd
);
1030 cmd
->type
= JTAG_SCAN
;
1031 cmd
->cmd
.scan
= scan
;
1033 scan
->ir_scan
= false;
1034 scan
->num_fields
= in_num_fields
;
1035 scan
->fields
= out_fields
;
1036 scan
->end_state
= state
;
1038 for (int i
= 0; i
< in_num_fields
; i
++)
1040 int num_bits
= in_fields
[i
].num_bits
;
1041 int num_bytes
= CEIL(in_fields
[i
].num_bits
, 8);
1042 scan
->fields
[i
].tap
= in_fields
[i
].tap
;
1043 scan
->fields
[i
].num_bits
= num_bits
;
1044 scan
->fields
[i
].out_value
= buf_cpy(in_fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
1045 scan
->fields
[i
].in_value
= in_fields
[i
].in_value
;
1052 void jtag_add_tlr(void)
1054 jtag_prelude(TAP_RESET
);
1057 retval
=interface_jtag_add_tlr();
1058 if (retval
!=ERROR_OK
)
1062 int MINIDRIVER(interface_jtag_add_tlr
)(void)
1064 tap_state_t state
= TAP_RESET
;
1066 /* allocate memory for a new list member */
1067 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1069 jtag_queue_command(cmd
);
1071 cmd
->type
= JTAG_STATEMOVE
;
1073 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1074 cmd
->cmd
.statemove
->end_state
= state
;
1079 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
1081 tap_state_t cur_state
= cmd_queue_cur_state
;
1085 /* the last state has to be a stable state */
1086 if (!tap_is_state_stable(path
[num_states
- 1]))
1088 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
1092 for (i
=0; i
<num_states
; i
++)
1094 if (path
[i
] == TAP_RESET
)
1096 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1100 if ( tap_state_transition(cur_state
, true) != path
[i
]
1101 && tap_state_transition(cur_state
, false) != path
[i
])
1103 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[i
]));
1106 cur_state
= path
[i
];
1111 retval
= interface_jtag_add_pathmove(num_states
, path
);
1112 cmd_queue_cur_state
= path
[num_states
- 1];
1113 if (retval
!=ERROR_OK
)
1117 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, const tap_state_t
*path
)
1119 /* allocate memory for a new list member */
1120 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1122 jtag_queue_command(cmd
);
1124 cmd
->type
= JTAG_PATHMOVE
;
1126 cmd
->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
1127 cmd
->cmd
.pathmove
->num_states
= num_states
;
1128 cmd
->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(tap_state_t
) * num_states
);
1130 for (int i
= 0; i
< num_states
; i
++)
1131 cmd
->cmd
.pathmove
->path
[i
] = path
[i
];
1136 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, tap_state_t state
)
1138 /* allocate memory for a new list member */
1139 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1141 jtag_queue_command(cmd
);
1143 cmd
->type
= JTAG_RUNTEST
;
1145 cmd
->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
1146 cmd
->cmd
.runtest
->num_cycles
= num_cycles
;
1147 cmd
->cmd
.runtest
->end_state
= state
;
1152 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
1156 jtag_prelude(state
);
1158 /* executed by sw or hw fifo */
1159 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
1160 if (retval
!=ERROR_OK
)
1165 int MINIDRIVER(interface_jtag_add_clocks
)( int num_cycles
)
1167 /* allocate memory for a new list member */
1168 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1170 jtag_queue_command(cmd
);
1172 cmd
->type
= JTAG_STABLECLOCKS
;
1174 cmd
->cmd
.stableclocks
= cmd_queue_alloc(sizeof(stableclocks_command_t
));
1175 cmd
->cmd
.stableclocks
->num_cycles
= num_cycles
;
1180 void jtag_add_clocks( int num_cycles
)
1184 if( !tap_is_state_stable(cmd_queue_cur_state
) )
1186 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1187 tap_state_name(cmd_queue_cur_state
) );
1188 jtag_error
= ERROR_JTAG_NOT_STABLE_STATE
;
1192 if( num_cycles
> 0 )
1196 retval
= interface_jtag_add_clocks(num_cycles
);
1197 if (retval
!= ERROR_OK
)
1202 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
1204 int trst_with_tlr
= 0;
1207 /* FIX!!! there are *many* different cases here. A better
1208 * approach is needed for legal combinations of transitions...
1210 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
1211 (jtag_reset_config
& RESET_HAS_TRST
)&&
1212 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
1214 if (((req_tlr_or_trst
&&!jtag_trst
)||
1215 (!req_tlr_or_trst
&&jtag_trst
))&&
1216 ((req_srst
&&!jtag_srst
)||
1217 (!req_srst
&&jtag_srst
)))
1219 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1220 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1224 /* Make sure that jtag_reset_config allows the requested reset */
1225 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1226 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
1228 LOG_ERROR("BUG: requested reset would assert trst");
1229 jtag_error
=ERROR_FAIL
;
1233 /* if TRST pulls SRST, we reset with TAP T-L-R */
1234 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
1239 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
1241 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1242 jtag_error
=ERROR_FAIL
;
1246 if (req_tlr_or_trst
)
1248 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
1260 jtag_srst
= req_srst
;
1262 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
1263 if (retval
!=ERROR_OK
)
1271 LOG_DEBUG("SRST line asserted");
1275 LOG_DEBUG("SRST line released");
1276 if (jtag_nsrst_delay
)
1277 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1282 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1283 jtag_add_end_state(TAP_RESET
);
1285 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1291 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1292 * and inform possible listeners about this
1294 LOG_DEBUG("TRST line asserted");
1295 cmd_queue_cur_state
= TAP_RESET
;
1296 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1300 if (jtag_ntrst_delay
)
1301 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1305 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1307 /* allocate memory for a new list member */
1308 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1310 jtag_queue_command(cmd
);
1312 cmd
->type
= JTAG_RESET
;
1314 cmd
->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1315 cmd
->cmd
.reset
->trst
= req_trst
;
1316 cmd
->cmd
.reset
->srst
= req_srst
;
1321 void jtag_add_end_state(tap_state_t state
)
1323 cmd_queue_end_state
= state
;
1324 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
1326 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1330 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1332 /* allocate memory for a new list member */
1333 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1335 jtag_queue_command(cmd
);
1337 cmd
->type
= JTAG_SLEEP
;
1339 cmd
->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1340 cmd
->cmd
.sleep
->us
= us
;
1345 void jtag_add_sleep(u32 us
)
1347 keep_alive(); /* we might be running on a very slow JTAG clk */
1348 int retval
=interface_jtag_add_sleep(us
);
1349 if (retval
!=ERROR_OK
)
1354 int jtag_scan_size(const scan_command_t
*cmd
)
1359 /* count bits in scan command */
1360 for (i
= 0; i
< cmd
->num_fields
; i
++)
1362 bit_count
+= cmd
->fields
[i
].num_bits
;
1368 int jtag_build_buffer(const scan_command_t
*cmd
, u8
**buffer
)
1373 bit_count
= jtag_scan_size(cmd
);
1374 *buffer
= calloc(1,CEIL(bit_count
, 8));
1378 #ifdef _DEBUG_JTAG_IO_
1379 LOG_DEBUG("%s num_fields: %i", cmd
->ir_scan
? "IRSCAN" : "DRSCAN", cmd
->num_fields
);
1382 for (i
= 0; i
< cmd
->num_fields
; i
++)
1384 if (cmd
->fields
[i
].out_value
)
1386 #ifdef _DEBUG_JTAG_IO_
1387 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: cmd
->fields
[i
].num_bits
, 16);
1389 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1390 #ifdef _DEBUG_JTAG_IO_
1391 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i
, cmd
->fields
[i
].num_bits
, char_buf
);
1397 #ifdef _DEBUG_JTAG_IO_
1398 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i
, cmd
->fields
[i
].num_bits
);
1402 bit_count
+= cmd
->fields
[i
].num_bits
;
1405 #ifdef _DEBUG_JTAG_IO_
1406 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1412 int jtag_read_buffer(u8
*buffer
, const scan_command_t
*cmd
)
1418 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1421 for (i
= 0; i
< cmd
->num_fields
; i
++)
1423 /* if neither in_value nor in_handler
1424 * are specified we don't have to examine this field
1426 if (cmd
->fields
[i
].in_value
)
1428 int num_bits
= cmd
->fields
[i
].num_bits
;
1429 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1431 #ifdef _DEBUG_JTAG_IO_
1432 char *char_buf
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1433 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i
, num_bits
, char_buf
);
1437 if (cmd
->fields
[i
].in_value
)
1439 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1444 bit_count
+= cmd
->fields
[i
].num_bits
;
1450 static const char *jtag_tap_name(const jtag_tap_t
*tap
)
1452 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
1455 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
1457 int retval
= ERROR_OK
;
1459 int compare_failed
= 0;
1462 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
1464 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
1466 if (compare_failed
){
1467 /* An error handler could have caught the failing check
1468 * only report a problem when there wasn't a handler, or if the handler
1469 * acknowledged the error
1472 LOG_WARNING("TAP %s:",
1473 jtag_tap_name(field->tap));
1477 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1478 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1482 char *in_check_mask_char
;
1483 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1484 LOG_WARNING("value captured during scan didn't pass the requested check:");
1485 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1486 captured_char
, in_check_value_char
, in_check_mask_char
);
1487 free(in_check_mask_char
);
1491 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
);
1494 free(captured_char
);
1495 free(in_check_value_char
);
1497 retval
= ERROR_JTAG_QUEUE_FAILED
;
1504 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
1506 assert(field
->in_value
!= NULL
);
1510 /* no checking to do */
1514 jtag_execute_queue_noclear();
1516 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
1517 jtag_set_error(retval
);
1522 enum scan_type
jtag_scan_type(const scan_command_t
*cmd
)
1527 for (i
= 0; i
< cmd
->num_fields
; i
++)
1529 if (cmd
->fields
[i
].in_value
)
1531 if (cmd
->fields
[i
].out_value
)
1539 #ifndef HAVE_JTAG_MINIDRIVER_H
1540 /* add callback to end of queue */
1541 void jtag_add_callback4(jtag_callback_t callback
, u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
1543 struct jtag_callback_entry
*entry
=cmd_queue_alloc(sizeof(struct jtag_callback_entry
));
1546 entry
->callback
=callback
;
1552 if (jtag_callback_queue_head
==NULL
)
1554 jtag_callback_queue_head
=entry
;
1555 jtag_callback_queue_tail
=entry
;
1558 jtag_callback_queue_tail
->next
=entry
;
1559 jtag_callback_queue_tail
=entry
;
1564 static int jtag_convert_to_callback4(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
1566 ((jtag_callback1_t
)data1
)(in
);
1570 void jtag_add_callback(jtag_callback1_t callback
, u8
*in
)
1572 jtag_add_callback4(jtag_convert_to_callback4
, in
, (jtag_callback_data_t
)callback
, 0, 0);
1576 #ifndef HAVE_JTAG_MINIDRIVER_H
1578 int interface_jtag_execute_queue(void)
1584 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1588 retval
= jtag
->execute_queue();
1590 if (retval
== ERROR_OK
)
1592 struct jtag_callback_entry
*entry
;
1593 for (entry
=jtag_callback_queue_head
; entry
!=NULL
; entry
=entry
->next
)
1595 retval
=entry
->callback(entry
->in
, entry
->data1
, entry
->data2
, entry
->data3
);
1596 if (retval
!=ERROR_OK
)
1603 jtag_callback_queue_head
= NULL
;
1604 jtag_callback_queue_tail
= NULL
;
1606 jtag_command_queue
= NULL
;
1607 last_command_pointer
= &jtag_command_queue
;
1613 void jtag_execute_queue_noclear(void)
1615 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1616 * E.g. a JTAG over TCP/IP or USB....
1618 jtag_flush_queue_count
++;
1620 int retval
=interface_jtag_execute_queue();
1621 /* we keep the first error */
1622 if ((jtag_error
==ERROR_OK
)&&(retval
!=ERROR_OK
))
1628 int jtag_execute_queue(void)
1631 jtag_execute_queue_noclear();
1633 jtag_error
=ERROR_OK
;
1637 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1639 jtag_tap_t
*tap
= priv
;
1643 if (event
== JTAG_TRST_ASSERTED
)
1645 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1652 void jtag_sleep(u32 us
)
1654 alive_sleep(us
/1000);
1657 /* Try to examine chain layout according to IEEE 1149.1 §12
1659 int jtag_examine_chain(void)
1663 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1666 int device_count
= 0;
1667 u8 zero_check
= 0x0;
1668 u8 one_check
= 0xff;
1671 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1672 field
.out_value
= idcode_buffer
;
1674 field
.in_value
= idcode_buffer
;
1679 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1681 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1684 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
1685 jtag_execute_queue();
1687 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1689 zero_check
|= idcode_buffer
[i
];
1690 one_check
&= idcode_buffer
[i
];
1693 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1694 if ((zero_check
== 0x00) || (one_check
== 0xff))
1696 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1697 return ERROR_JTAG_INIT_FAILED
;
1700 /* point at the 1st tap */
1701 tap
= jtag_NextEnabledTap(NULL
);
1703 LOG_ERROR("JTAG: No taps enabled?");
1704 return ERROR_JTAG_INIT_FAILED
;
1707 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1709 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1710 if ((idcode
& 1) == 0)
1712 /* LSB must not be 0, this indicates a device in bypass */
1713 LOG_WARNING("Tap/Device does not have IDCODE");
1724 /* some devices, such as AVR will output all 1's instead of TDI
1725 input value at end of chain. */
1726 if ((idcode
== 0x000000FF)||(idcode
== 0xFFFFFFFF))
1729 /* End of chain (invalid manufacturer ID)
1731 * The JTAG examine is the very first thing that happens
1733 * A single JTAG device requires only 64 bits to be read back correctly.
1735 * The code below adds a check that the rest of the data scanned (640 bits)
1736 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1738 * earlier and gives more helpful/explicit error messages.
1740 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1742 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1743 if (unexpected
||((idcode
!= 0x000000FF)&&(idcode
!= 0xFFFFFFFF)))
1745 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1753 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1754 manufacturer
= EXTRACT_MFG(idcode
);
1755 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1756 part
= EXTRACT_PART(idcode
);
1757 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1758 version
= EXTRACT_VER(idcode
);
1760 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1761 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1762 idcode
, manufacturer
, part
, version
);
1768 tap
->idcode
= idcode
;
1770 if (tap
->expected_ids_cnt
> 0) {
1771 /* Loop over the expected identification codes and test for a match */
1773 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1774 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1779 /* If none of the expected ids matched, log an error */
1780 if (ii
== tap
->expected_ids_cnt
) {
1781 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1784 EXTRACT_MFG( tap
->idcode
),
1785 EXTRACT_PART( tap
->idcode
),
1786 EXTRACT_VER( tap
->idcode
) );
1787 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1788 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1791 tap
->expected_ids_cnt
,
1792 tap
->expected_ids
[ii
],
1793 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1794 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1795 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1798 return ERROR_JTAG_INIT_FAILED
;
1800 LOG_INFO("JTAG Tap/device matched");
1804 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1808 tap
= jtag_NextEnabledTap(tap
);
1813 /* see if number of discovered devices matches configuration */
1814 if (device_count
!= jtag_NumEnabledTaps())
1816 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1817 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1818 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1819 return ERROR_JTAG_INIT_FAILED
;
1825 int jtag_validate_chain(void)
1828 int total_ir_length
= 0;
1834 total_ir_length
= 0;
1836 tap
= jtag_NextEnabledTap(tap
);
1840 total_ir_length
+= tap
->ir_length
;
1843 total_ir_length
+= 2;
1844 ir_test
= malloc(CEIL(total_ir_length
, 8));
1845 buf_set_ones(ir_test
, total_ir_length
);
1848 field
.num_bits
= total_ir_length
;
1849 field
.out_value
= ir_test
;
1850 field
.in_value
= ir_test
;
1853 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1854 jtag_execute_queue();
1860 tap
= jtag_NextEnabledTap(tap
);
1865 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1868 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1869 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
);
1872 return ERROR_JTAG_INIT_FAILED
;
1874 chain_pos
+= tap
->ir_length
;
1877 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1880 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1881 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
);
1884 return ERROR_JTAG_INIT_FAILED
;
1892 enum jtag_tap_cfg_param
{
1896 static Jim_Nvp nvp_config_opts
[] = {
1897 { .name
= "-event", .value
= JCFG_EVENT
},
1899 { .name
= NULL
, .value
= -1 }
1902 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1908 /* parse config or cget options */
1909 while (goi
->argc
> 0) {
1910 Jim_SetEmptyResult (goi
->interp
);
1912 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1914 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1920 if (goi
->argc
== 0) {
1921 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1925 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1927 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1931 if (goi
->isconfigure
) {
1932 if (goi
->argc
!= 1) {
1933 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1937 if (goi
->argc
!= 0) {
1938 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1944 jtag_tap_event_action_t
*jteap
;
1946 jteap
= tap
->event_action
;
1947 /* replace existing? */
1949 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1952 jteap
= jteap
->next
;
1955 if (goi
->isconfigure
) {
1956 if (jteap
== NULL
) {
1958 jteap
= calloc(1, sizeof (*jteap
));
1960 jteap
->event
= n
->value
;
1961 Jim_GetOpt_Obj( goi
, &o
);
1963 Jim_DecrRefCount(interp
, jteap
->body
);
1965 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1966 Jim_IncrRefCount(jteap
->body
);
1968 /* add to head of event list */
1969 jteap
->next
= tap
->event_action
;
1970 tap
->event_action
= jteap
;
1971 Jim_SetEmptyResult(goi
->interp
);
1974 if (jteap
== NULL
) {
1975 Jim_SetEmptyResult(goi
->interp
);
1977 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1984 } /* while (goi->argc) */
1989 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1999 const Jim_Nvp opts
[] = {
2000 #define NTAP_OPT_IRLEN 0
2001 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
2002 #define NTAP_OPT_IRMASK 1
2003 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
2004 #define NTAP_OPT_IRCAPTURE 2
2005 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
2006 #define NTAP_OPT_ENABLED 3
2007 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
2008 #define NTAP_OPT_DISABLED 4
2009 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
2010 #define NTAP_OPT_EXPECTED_ID 5
2011 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
2012 { .name
= NULL
, .value
= -1 },
2015 pTap
= malloc( sizeof(jtag_tap_t
) );
2016 memset( pTap
, 0, sizeof(*pTap
) );
2018 Jim_SetResult_sprintf( goi
->interp
, "no memory");
2022 * we expect CHIP + TAP + OPTIONS
2024 if( goi
->argc
< 3 ){
2025 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
2028 Jim_GetOpt_String( goi
, &cp
, NULL
);
2029 pTap
->chip
= strdup(cp
);
2031 Jim_GetOpt_String( goi
, &cp
, NULL
);
2032 pTap
->tapname
= strdup(cp
);
2034 /* name + dot + name + null */
2035 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
2037 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
2038 pTap
->dotted_name
= cp
;
2040 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
2041 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
2043 /* default is enabled */
2046 /* deal with options */
2047 #define NTREQ_IRLEN 1
2048 #define NTREQ_IRCAPTURE 2
2049 #define NTREQ_IRMASK 4
2051 /* clear them as we find them */
2052 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
2055 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
2057 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
2060 LOG_DEBUG("Processing option: %s", n
->name
);
2062 case NTAP_OPT_ENABLED
:
2065 case NTAP_OPT_DISABLED
:
2068 case NTAP_OPT_EXPECTED_ID
:
2070 u32
*new_expected_ids
;
2072 e
= Jim_GetOpt_Wide( goi
, &w
);
2074 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
2078 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
2079 if (new_expected_ids
== NULL
) {
2080 Jim_SetResult_sprintf( goi
->interp
, "no memory");
2084 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
2086 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
2088 free(pTap
->expected_ids
);
2089 pTap
->expected_ids
= new_expected_ids
;
2090 pTap
->expected_ids_cnt
++;
2093 case NTAP_OPT_IRLEN
:
2094 case NTAP_OPT_IRMASK
:
2095 case NTAP_OPT_IRCAPTURE
:
2096 e
= Jim_GetOpt_Wide( goi
, &w
);
2098 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
2101 if( (w
< 0) || (w
> 0xffff) ){
2103 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
2104 n
->name
, (int)(w
), (int)(w
));
2108 case NTAP_OPT_IRLEN
:
2109 pTap
->ir_length
= w
;
2110 reqbits
&= (~(NTREQ_IRLEN
));
2112 case NTAP_OPT_IRMASK
:
2113 pTap
->ir_capture_mask
= w
;
2114 reqbits
&= (~(NTREQ_IRMASK
));
2116 case NTAP_OPT_IRCAPTURE
:
2117 pTap
->ir_capture_value
= w
;
2118 reqbits
&= (~(NTREQ_IRCAPTURE
));
2121 } /* switch(n->value) */
2122 } /* while( goi->argc ) */
2124 /* Did we get all the options? */
2127 Jim_SetResult_sprintf( goi
->interp
,
2128 "newtap: %s missing required parameters",
2130 /* TODO: Tell user what is missing :-( */
2131 /* no memory leaks pelase */
2132 free(((void *)(pTap
->expected_ids
)));
2133 free(((void *)(pTap
->chip
)));
2134 free(((void *)(pTap
->tapname
)));
2135 free(((void *)(pTap
->dotted_name
)));
2136 free(((void *)(pTap
)));
2140 pTap
->expected
= malloc( pTap
->ir_length
);
2141 pTap
->expected_mask
= malloc( pTap
->ir_length
);
2142 pTap
->cur_instr
= malloc( pTap
->ir_length
);
2144 buf_set_u32( pTap
->expected
,
2147 pTap
->ir_capture_value
);
2148 buf_set_u32( pTap
->expected_mask
,
2151 pTap
->ir_capture_mask
);
2152 buf_set_ones( pTap
->cur_instr
,
2157 jtag_register_event_callback(jtag_reset_callback
, pTap
);
2159 ppTap
= &(jtag_all_taps
);
2160 while( (*ppTap
) != NULL
){
2161 ppTap
= &((*ppTap
)->next_tap
);
2165 static int n_taps
= 0;
2166 pTap
->abs_chain_position
= n_taps
++;
2168 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2169 (*ppTap
)->dotted_name
,
2170 (*ppTap
)->abs_chain_position
,
2171 (*ppTap
)->ir_length
,
2172 (*ppTap
)->ir_capture_value
,
2173 (*ppTap
)->ir_capture_mask
);
2178 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2184 struct command_context_s
*context
;
2188 JTAG_CMD_INIT_RESET
,
2191 JTAG_CMD_TAPDISABLE
,
2192 JTAG_CMD_TAPISENABLED
,
2197 const Jim_Nvp jtag_cmds
[] = {
2198 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
2199 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
2200 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
2201 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
2202 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
2203 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
2204 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
2205 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
2207 { .name
= NULL
, .value
= -1 },
2210 context
= Jim_GetAssocData(interp
, "context");
2211 /* go past the command */
2212 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
2214 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
2216 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
2219 Jim_SetEmptyResult( goi
.interp
);
2221 case JTAG_CMD_INTERFACE
:
2222 /* return the name of the interface */
2223 /* TCL code might need to know the exact type... */
2224 /* FUTURE: we allow this as a means to "set" the interface. */
2225 if( goi
.argc
!= 0 ){
2226 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2229 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
2231 case JTAG_CMD_INIT_RESET
:
2232 if( goi
.argc
!= 0 ){
2233 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2236 e
= jtag_init_reset(context
);
2237 if( e
!= ERROR_OK
){
2238 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
2242 case JTAG_CMD_NEWTAP
:
2243 return jim_newtap_cmd( &goi
);
2245 case JTAG_CMD_TAPISENABLED
:
2246 case JTAG_CMD_TAPENABLE
:
2247 case JTAG_CMD_TAPDISABLE
:
2248 if( goi
.argc
!= 1 ){
2249 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
2255 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
2260 case JTAG_CMD_TAPISENABLED
:
2263 case JTAG_CMD_TAPENABLE
:
2264 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
2268 case JTAG_CMD_TAPDISABLE
:
2269 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
2274 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
2281 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
2288 Jim_GetOpt_Obj(&goi
, &o
);
2289 t
= jtag_TapByJimObj( goi
.interp
, o
);
2294 goi
.isconfigure
= 0;
2295 return jtag_tap_configure_cmd( &goi
, t
);
2299 case JTAG_CMD_CONFIGURE
:
2301 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
2308 Jim_GetOpt_Obj(&goi
, &o
);
2309 t
= jtag_TapByJimObj( goi
.interp
, o
);
2314 goi
.isconfigure
= 1;
2315 return jtag_tap_configure_cmd( &goi
, t
);
2322 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
2324 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
2326 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
2327 COMMAND_CONFIG
, "try to configure interface");
2328 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
2329 COMMAND_ANY
, "set jtag speed (if supported)");
2330 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
2331 COMMAND_ANY
, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2332 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
2333 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2334 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
2336 "[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]");
2337 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
2338 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2339 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
2340 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2342 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
2343 COMMAND_EXEC
, "print current scan chain configuration");
2345 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
2346 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
2347 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
2348 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
2349 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
2350 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
2351 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
2352 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2353 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2354 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
2356 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
2357 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
2358 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
2359 COMMAND_ANY
, "verify value capture <enable|disable>");
2360 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
2361 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
2365 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
2370 if (!jtag_interface
)
2372 /* nothing was previously specified by "interface" command */
2373 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2374 return ERROR_JTAG_INVALID_INTERFACE
;
2378 jtag_interface
->khz(speed_khz
, &jtag_speed
);
2382 if (jtag_interface
->init() != ERROR_OK
)
2383 return ERROR_JTAG_INIT_FAILED
;
2385 jtag
= jtag_interface
;
2389 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
2394 LOG_DEBUG("Init JTAG chain");
2396 tap
= jtag_NextEnabledTap(NULL
);
2398 LOG_ERROR("There are no enabled taps?");
2399 return ERROR_JTAG_INIT_FAILED
;
2403 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
2406 /* examine chain first, as this could discover the real chain layout */
2407 if (jtag_examine_chain() != ERROR_OK
)
2409 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2412 if (jtag_validate_chain() != ERROR_OK
)
2414 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2420 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
2424 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2427 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2429 /* Reset can happen after a power cycle.
2431 * Ideally we would only assert TRST or run RESET before the target reset.
2433 * However w/srst_pulls_trst, trst is asserted together with the target
2434 * reset whether we want it or not.
2436 * NB! Some targets have JTAG circuitry disabled until a
2437 * trst & srst has been asserted.
2439 * NB! here we assume nsrst/ntrst delay are sufficient!
2441 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2444 jtag_add_reset(1, 0); /* RESET or TRST */
2445 if (jtag_reset_config
& RESET_HAS_SRST
)
2447 jtag_add_reset(1, 1);
2448 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
2449 jtag_add_reset(0, 1);
2451 jtag_add_reset(0, 0);
2452 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2455 /* Check that we can communication on the JTAG chain + eventually we want to
2456 * be able to perform enumeration only after OpenOCD has started
2457 * telnet and GDB server
2459 * That would allow users to more easily perform any magic they need to before
2462 return jtag_init_inner(cmd_ctx
);
2465 int jtag_init(struct command_context_s
*cmd_ctx
)
2468 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2470 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
2474 return jtag_init_reset(cmd_ctx
);
2477 static int default_khz(int khz
, int *jtag_speed
)
2479 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2483 static int default_speed_div(int speed
, int *khz
)
2485 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2489 static int default_power_dropout(int *dropout
)
2491 *dropout
=0; /* by default we can't detect power dropout */
2495 static int default_srst_asserted(int *srst_asserted
)
2497 *srst_asserted
=0; /* by default we can't detect srst asserted */
2501 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2506 /* check whether the interface is already configured */
2509 LOG_WARNING("Interface already configured, ignoring");
2513 /* interface name is a mandatory argument */
2514 if (argc
< 1 || args
[0][0] == '\0')
2516 return ERROR_COMMAND_SYNTAX_ERROR
;
2519 for (i
=0; jtag_interfaces
[i
]; i
++)
2521 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
2523 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
2528 jtag_interface
= jtag_interfaces
[i
];
2530 if (jtag_interface
->khz
== NULL
)
2532 jtag_interface
->khz
= default_khz
;
2534 if (jtag_interface
->speed_div
== NULL
)
2536 jtag_interface
->speed_div
= default_speed_div
;
2538 if (jtag_interface
->power_dropout
== NULL
)
2540 jtag_interface
->power_dropout
= default_power_dropout
;
2542 if (jtag_interface
->srst_asserted
== NULL
)
2544 jtag_interface
->srst_asserted
= default_srst_asserted
;
2551 /* no valid interface was found (i.e. the configuration option,
2552 * didn't match one of the compiled-in interfaces
2554 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
2555 LOG_ERROR("compiled-in jtag interfaces:");
2556 for (i
= 0; jtag_interfaces
[i
]; i
++)
2558 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
2561 return ERROR_JTAG_INVALID_INTERFACE
;
2564 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2568 Jim_Obj
*newargs
[ 10 ];
2571 * argv[-1] = command
2572 * argv[ 0] = ir length
2573 * argv[ 1] = ir capture
2574 * argv[ 2] = ir mask
2575 * argv[ 3] = not actually used by anything but in the docs
2579 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2582 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2583 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2587 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2588 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2589 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2590 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
2592 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
2593 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
2594 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
2595 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
2596 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
2597 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
2598 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
2599 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
2600 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
2601 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
2602 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
2603 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
2605 command_print( cmd_ctx
, "NEW COMMAND:");
2606 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
2607 Jim_GetString( newargs
[0], NULL
),
2608 Jim_GetString( newargs
[1], NULL
),
2609 Jim_GetString( newargs
[2], NULL
),
2610 Jim_GetString( newargs
[3], NULL
),
2611 Jim_GetString( newargs
[4], NULL
),
2612 Jim_GetString( newargs
[5], NULL
),
2613 Jim_GetString( newargs
[6], NULL
),
2614 Jim_GetString( newargs
[7], NULL
),
2615 Jim_GetString( newargs
[8], NULL
),
2616 Jim_GetString( newargs
[9], NULL
) );
2618 e
= jim_jtag_command( interp
, 10, newargs
);
2620 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
2625 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2629 tap
= jtag_all_taps
;
2630 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2631 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
2634 u32 expected
, expected_mask
, cur_instr
, ii
;
2635 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
2636 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
2637 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
2639 command_print(cmd_ctx
,
2640 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2641 tap
->abs_chain_position
,
2643 tap
->enabled
? 'Y' : 'n',
2645 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
2651 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
2652 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
2653 tap
->expected_ids
[ii
]);
2656 tap
= tap
->next_tap
;
2662 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2665 return ERROR_COMMAND_SYNTAX_ERROR
;
2669 if (strcmp(args
[0], "none") == 0)
2670 jtag_reset_config
= RESET_NONE
;
2671 else if (strcmp(args
[0], "trst_only") == 0)
2672 jtag_reset_config
= RESET_HAS_TRST
;
2673 else if (strcmp(args
[0], "srst_only") == 0)
2674 jtag_reset_config
= RESET_HAS_SRST
;
2675 else if (strcmp(args
[0], "trst_and_srst") == 0)
2676 jtag_reset_config
= RESET_TRST_AND_SRST
;
2679 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args
[0]);
2680 jtag_reset_config
= RESET_NONE
;
2681 return ERROR_INVALID_ARGUMENTS
;
2687 if (strcmp(args
[1], "separate") == 0)
2689 /* seperate reset lines - default */
2692 if (strcmp(args
[1], "srst_pulls_trst") == 0)
2693 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
2694 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
2695 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
2696 else if (strcmp(args
[1], "combined") == 0)
2697 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2700 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args
[1]);
2701 jtag_reset_config
= RESET_NONE
;
2702 return ERROR_INVALID_ARGUMENTS
;
2709 if (strcmp(args
[2], "trst_open_drain") == 0)
2710 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
2711 else if (strcmp(args
[2], "trst_push_pull") == 0)
2712 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
2715 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args
[2] );
2716 jtag_reset_config
= RESET_NONE
;
2717 return ERROR_INVALID_ARGUMENTS
;
2723 if (strcmp(args
[3], "srst_push_pull") == 0)
2724 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
2725 else if (strcmp(args
[3], "srst_open_drain") == 0)
2726 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
2729 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args
[3]);
2730 jtag_reset_config
= RESET_NONE
;
2731 return ERROR_INVALID_ARGUMENTS
;
2738 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2742 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2747 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2753 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2757 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2762 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2768 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2770 int retval
=ERROR_OK
;
2774 LOG_DEBUG("handle jtag speed");
2777 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2779 /* this command can be called during CONFIG,
2780 * in which case jtag isn't initialized */
2783 retval
=jtag
->speed(cur_speed
);
2785 } else if (argc
== 0)
2789 return ERROR_COMMAND_SYNTAX_ERROR
;
2791 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2796 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2798 int retval
=ERROR_OK
;
2799 LOG_DEBUG("handle jtag khz");
2803 speed_khz
= strtoul(args
[0], NULL
, 0);
2807 LOG_DEBUG("have interface set up");
2809 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2815 cur_speed
= jtag_speed
= speed_div1
;
2817 retval
=jtag
->speed(cur_speed
);
2826 return ERROR_COMMAND_SYNTAX_ERROR
;
2831 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2837 command_print(cmd_ctx
, "RCLK - adaptive");
2840 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2846 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2852 return ERROR_COMMAND_SYNTAX_ERROR
;
2856 state
= tap_state_by_name( args
[0] );
2858 command_print( cmd_ctx
, "Invalid state name: %s\n", args
[0] );
2859 return ERROR_COMMAND_SYNTAX_ERROR
;
2861 jtag_add_end_state(state
);
2862 jtag_execute_queue();
2864 command_print(cmd_ctx
, "current endstate: %s", tap_state_name(cmd_queue_end_state
));
2869 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2876 return ERROR_COMMAND_SYNTAX_ERROR
;
2879 if (args
[0][0] == '1')
2881 else if (args
[0][0] == '0')
2885 return ERROR_COMMAND_SYNTAX_ERROR
;
2888 if (args
[1][0] == '1')
2890 else if (args
[1][0] == '0')
2894 return ERROR_COMMAND_SYNTAX_ERROR
;
2897 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2898 return ERROR_JTAG_INIT_FAILED
;
2900 jtag_add_reset(trst
, srst
);
2901 jtag_execute_queue();
2906 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2910 return ERROR_COMMAND_SYNTAX_ERROR
;
2913 jtag_add_runtest(strtol(args
[0], NULL
, 0), TAP_INVALID
);
2914 jtag_execute_queue();
2920 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2923 scan_field_t
*fields
;
2925 tap_state_t endstate
;
2927 if ((argc
< 2) || (argc
% 2))
2929 return ERROR_COMMAND_SYNTAX_ERROR
;
2932 /* optional "-endstate" */
2934 /* at the end of the arguments. */
2936 endstate
= cmd_queue_end_state
;
2938 /* have at least one pair of numbers. */
2939 /* is last pair the magic text? */
2940 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
2943 cpA
= args
[ argc
-1 ];
2944 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
2945 cpS
= tap_state_name( endstate
);
2946 if( 0 == strcmp( cpA
, cpS
) ){
2950 if( endstate
>= TAP_NUM_STATES
){
2951 return ERROR_COMMAND_SYNTAX_ERROR
;
2953 /* found - remove the last 2 args */
2959 int num_fields
= argc
/ 2;
2961 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2963 for (i
= 0; i
< num_fields
; i
++)
2965 tap
= jtag_TapByString( args
[i
*2] );
2968 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2971 int field_size
= tap
->ir_length
;
2972 fields
[i
].tap
= tap
;
2973 fields
[i
].num_bits
= field_size
;
2974 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2975 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2976 fields
[i
].in_value
= NULL
;
2979 /* did we have an endstate? */
2980 jtag_add_ir_scan(num_fields
, fields
, endstate
);
2982 int retval
=jtag_execute_queue();
2984 for (i
= 0; i
< num_fields
; i
++)
2985 free(fields
[i
].out_value
);
2992 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2995 scan_field_t
*fields
;
2997 int field_count
= 0;
3000 tap_state_t endstate
;
3003 * args[2] = num_bits
3004 * args[3] = hex string
3005 * ... repeat num bits and hex string ...
3008 * args[N-2] = "-endstate"
3009 * args[N-1] = statename
3011 if ((argc
< 4) || ((argc
% 2)!=0))
3013 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
3017 /* assume no endstate */
3018 endstate
= cmd_queue_end_state
;
3019 /* validate arguments as numbers */
3021 for (i
= 2; i
< argc
; i
+=2)
3026 e
= Jim_GetLong(interp
, args
[i
], &bits
);
3027 /* If valid - try next arg */
3032 /* Not valid.. are we at the end? */
3033 if ( ((i
+2) != argc
) ){
3034 /* nope, then error */
3038 /* it could be: "-endstate FOO" */
3040 /* get arg as a string. */
3041 cp
= Jim_GetString( args
[i
], NULL
);
3042 /* is it the magic? */
3043 if( 0 == strcmp( "-endstate", cp
) ){
3044 /* is the statename valid? */
3045 cp
= Jim_GetString( args
[i
+1], NULL
);
3047 /* see if it is a valid state name */
3048 endstate
= tap_state_by_name(cp
);
3050 /* update the error message */
3051 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
3053 /* valid - so clear the error */
3055 /* and remove the last 2 args */
3060 /* Still an error? */
3062 return e
; /* too bad */
3064 } /* validate args */
3066 tap
= jtag_TapByJimObj( interp
, args
[1] );
3071 num_fields
=(argc
-2)/2;
3072 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
3073 for (i
= 2; i
< argc
; i
+=2)
3079 Jim_GetLong(interp
, args
[i
], &bits
);
3080 str
= Jim_GetString(args
[i
+1], &len
);
3082 fields
[field_count
].tap
= tap
;
3083 fields
[field_count
].num_bits
= bits
;
3084 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
3085 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
3086 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
3090 jtag_add_dr_scan(num_fields
, fields
, endstate
);
3092 retval
= jtag_execute_queue();
3093 if (retval
!= ERROR_OK
)
3095 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
3100 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
3101 for (i
= 2; i
< argc
; i
+=2)
3106 Jim_GetLong(interp
, args
[i
], &bits
);
3107 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
3108 free(fields
[field_count
].out_value
);
3110 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
3115 Jim_SetResult(interp
, list
);
3123 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
3125 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_flush_queue_count
));
3131 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3135 if (strcmp(args
[0], "enable") == 0)
3137 jtag_verify_capture_ir
= 1;
3139 else if (strcmp(args
[0], "disable") == 0)
3141 jtag_verify_capture_ir
= 0;
3144 return ERROR_COMMAND_SYNTAX_ERROR
;
3146 } else if (argc
!= 0)
3148 return ERROR_COMMAND_SYNTAX_ERROR
;
3151 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
3156 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3160 if (strcmp(args
[0], "enable") == 0)
3164 else if (strcmp(args
[0], "disable") == 0)
3169 return ERROR_COMMAND_SYNTAX_ERROR
;
3171 } else if (argc
!= 0)
3173 return ERROR_COMMAND_SYNTAX_ERROR
;
3176 command_print(cmd_ctx
, "verify jtag capture is %s", (jtag_verify
) ? "enabled": "disabled");
3182 int jtag_power_dropout(int *dropout
)
3184 return jtag
->power_dropout(dropout
);
3187 int jtag_srst_asserted(int *srst_asserted
)
3189 return jtag
->srst_asserted(srst_asserted
);
3192 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
3194 jtag_tap_event_action_t
* jteap
;
3197 jteap
= tap
->event_action
;
3201 if (jteap
->event
== e
) {
3203 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3206 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
3207 Jim_GetString(jteap
->body
, NULL
) );
3208 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
3209 Jim_PrintErrorMessage(interp
);
3213 jteap
= jteap
->next
;
3217 LOG_DEBUG( "event %d %s - no action",
3219 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
3223 /*-----<Cable Helper API>---------------------------------------*/
3225 /* these Cable Helper API functions are all documented in the jtag.h header file,
3226 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3227 is setup to prefer its docs in the header file, no documentation is here, for
3228 if it were, it would have to be doubly maintained.
3232 * @see tap_set_state() and tap_get_state() accessors.
3233 * Actual name is not important since accessors hide it.
3235 static tap_state_t state_follower
= TAP_RESET
;
3237 void tap_set_state_impl( tap_state_t new_state
)
3239 /* this is the state we think the TAPs are in now, was cur_state */
3240 state_follower
= new_state
;
3243 tap_state_t
tap_get_state()
3245 return state_follower
;
3249 * @see tap_set_end_state() and tap_get_end_state() accessors.
3250 * Actual name is not important because accessors hide it.
3252 static tap_state_t end_state_follower
= TAP_RESET
;
3254 void tap_set_end_state( tap_state_t new_end_state
)
3256 /* this is the state we think the TAPs will be in at completion of the
3257 current TAP operation, was end_state
3259 end_state_follower
= new_end_state
;
3262 tap_state_t
tap_get_end_state()
3264 return end_state_follower
;
3268 int tap_move_ndx( tap_state_t astate
)
3270 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3276 case TAP_RESET
: ndx
= 0; break;
3277 case TAP_DRSHIFT
: ndx
= 2; break;
3278 case TAP_DRPAUSE
: ndx
= 3; break;
3279 case TAP_IDLE
: ndx
= 1; break;
3280 case TAP_IRSHIFT
: ndx
= 4; break;
3281 case TAP_IRPAUSE
: ndx
= 5; break;
3283 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate
) );
3291 /* tap_move[i][j]: tap movement command to go from state i to state j
3292 * 0: Test-Logic-Reset
3299 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3301 struct tms_sequences
3309 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3310 * Read the bits from LSBit first to MSBit last (right-to-left).
3312 #define HEX__(n) 0x##n##LU
3315 (((x) & 0x0000000FLU)?(1<<0):0) \
3316 +(((x) & 0x000000F0LU)?(1<<1):0) \
3317 +(((x) & 0x00000F00LU)?(1<<2):0) \
3318 +(((x) & 0x0000F000LU)?(1<<3):0) \
3319 +(((x) & 0x000F0000LU)?(1<<4):0) \
3320 +(((x) & 0x00F00000LU)?(1<<5):0) \
3321 +(((x) & 0x0F000000LU)?(1<<6):0) \
3322 +(((x) & 0xF0000000LU)?(1<<7):0)
3324 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3326 static const struct tms_sequences old_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
3328 /* value clocked to TMS to move from one of six stable states to another.
3329 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3330 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3331 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3332 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3338 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3339 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3340 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3341 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3342 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3343 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3344 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* IRPAUSE */
3349 static const struct tms_sequences short_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
3351 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3353 OK, I added Peter's version of the state table, and it works OK for
3354 me on MC1322x. I've recreated the jlink portion of patch with this
3355 new state table. His changes to my state table are pretty minor in
3356 terms of total transitions, but Peter feels that his version fixes
3357 some long-standing problems.
3360 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3363 state specific comments:
3364 ------------------------
3365 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3366 work better on ARM9 with ft2232 driver. (Dick)
3368 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3369 needed on ARM9 with ft2232 driver. (Dick)
3371 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3372 needed on ARM9 with ft2232 driver. (Dick)
3376 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3377 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3378 { B8(1111111,7), B8(0000000,7), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3379 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3380 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3381 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3382 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3386 typedef const struct tms_sequences tms_table
[6][6];
3388 static tms_table
*tms_seqs
=&short_tms_seqs
;
3390 int tap_get_tms_path( tap_state_t from
, tap_state_t to
)
3392 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bits
;
3396 int tap_get_tms_path_len( tap_state_t from
, tap_state_t to
)
3398 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bit_count
;
3402 bool tap_is_state_stable(tap_state_t astate
)
3406 /* A switch() is used because it is symbol dependent
3407 (not value dependent like an array), and can also check bounds.
3426 tap_state_t
tap_state_transition(tap_state_t cur_state
, bool tms
)
3428 tap_state_t new_state
;
3430 /* A switch is used because it is symbol dependent and not value dependent
3431 like an array. Also it can check for out of range conditions.
3439 new_state
= cur_state
;
3444 new_state
= TAP_DRSELECT
;
3447 new_state
= TAP_IRSELECT
;
3451 new_state
= TAP_DREXIT1
;
3455 new_state
= TAP_DRUPDATE
;
3458 new_state
= TAP_DREXIT2
;
3461 new_state
= TAP_RESET
;
3465 new_state
= TAP_IREXIT1
;
3469 new_state
= TAP_IRUPDATE
;
3472 new_state
= TAP_IREXIT2
;
3475 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3488 new_state
= TAP_IDLE
;
3491 new_state
= TAP_DRCAPTURE
;
3496 new_state
= TAP_DRSHIFT
;
3500 new_state
= TAP_DRPAUSE
;
3503 new_state
= TAP_IRCAPTURE
;
3508 new_state
= TAP_IRSHIFT
;
3512 new_state
= TAP_IRPAUSE
;
3515 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3524 const char* tap_state_name(tap_state_t state
)
3530 case TAP_RESET
: ret
= "RESET"; break;
3531 case TAP_IDLE
: ret
= "RUN/IDLE"; break;
3532 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
3533 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
3534 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
3535 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
3536 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
3537 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
3538 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
3539 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
3540 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
3541 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
3542 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
3543 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
3544 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
3545 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
3546 default: ret
= "???";
3552 static tap_state_t
tap_state_by_name( const char *name
)
3556 for( x
= 0 ; x
< TAP_NUM_STATES
; x
++ ){
3557 /* be nice to the human */
3558 if( 0 == strcasecmp( name
, tap_state_name(x
) ) ){
3566 #ifdef _DEBUG_JTAG_IO_
3568 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3569 do { buf[len] = bit ? '1' : '0'; } while(0)
3570 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3571 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3572 tap_state_name(a), tap_state_name(b), astr, bstr)
3574 tap_state_t
jtag_debug_state_machine(const void *tms_buf
, const void *tdi_buf
,
3575 unsigned tap_bits
, tap_state_t next_state
)
3577 const u8
*tms_buffer
;
3578 const u8
*tdi_buffer
;
3583 unsigned tap_out_bits
;
3587 tap_state_t last_state
;
3589 // set startstate (and possibly last, if tap_bits == 0)
3590 last_state
= next_state
;
3591 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state
));
3593 tms_buffer
= (const u8
*)tms_buf
;
3594 tdi_buffer
= (const u8
*)tdi_buf
;
3596 tap_bytes
= TAP_SCAN_BYTES(tap_bits
);
3597 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits
, tap_bytes
);
3600 for(cur_byte
= 0; cur_byte
< tap_bytes
; cur_byte
++)
3602 for(cur_bit
= 0; cur_bit
< 8; cur_bit
++)
3604 // make sure we do not run off the end of the buffers
3605 unsigned tap_bit
= cur_byte
* 8 + cur_bit
;
3606 if (tap_bit
== tap_bits
)
3609 // check and save TMS bit
3610 tap_bit
= !!(tms_buffer
[cur_byte
] & (1 << cur_bit
));
3611 JTAG_DEBUG_STATE_APPEND(tms_str
, tap_out_bits
, tap_bit
);
3613 // use TMS bit to find the next TAP state
3614 next_state
= tap_state_transition(last_state
, tap_bit
);
3616 // check and store TDI bit
3617 tap_bit
= !!(tdi_buffer
[cur_byte
] & (1 << cur_bit
));
3618 JTAG_DEBUG_STATE_APPEND(tdi_str
, tap_out_bits
, tap_bit
);
3620 // increment TAP bits
3623 // Only show TDO bits on state transitions, or
3624 // after some number of bits in the same state.
3625 if ((next_state
== last_state
) && (tap_out_bits
< 32))
3628 // terminate strings and display state transition
3629 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3630 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3633 last_state
= next_state
;
3640 // terminate strings and display state transition
3641 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3642 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3645 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state
));
3649 #endif // _DEBUG_JTAG_IO_
3651 #ifndef HAVE_JTAG_MINIDRIVER_H
3652 void jtag_alloc_in_value32(scan_field_t
*field
)
3654 field
->in_value
=(u8
*)cmd_queue_alloc(4);
3658 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3662 if (strcmp(args
[0], "short") == 0)
3664 tms_seqs
=&short_tms_seqs
;
3666 else if (strcmp(args
[0], "long") == 0)
3668 tms_seqs
=&old_tms_seqs
;
3671 return ERROR_COMMAND_SYNTAX_ERROR
;
3673 } else if (argc
!= 0)
3675 return ERROR_COMMAND_SYNTAX_ERROR
;
3678 command_print(cmd_ctx
, "tms sequence is %s", (tms_seqs
==&short_tms_seqs
) ? "short": "long");
3683 /*-----</Cable Helper API>--------------------------------------*/