1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
31 #define INCLUDE_JTAG_MINIDRIVER_H
32 #define INCLUDE_JTAG_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 typedef struct cmd_queue_page_s
54 struct cmd_queue_page_s
*next
;
57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
58 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
60 char* jtag_event_strings
[] =
62 "JTAG controller reset (RESET or TRST)"
65 const Jim_Nvp nvp_jtag_tap_event
[] = {
66 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
67 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
69 { .name
= NULL
, .value
= -1 }
75 #ifndef HAVE_JTAG_MINIDRIVER_H
76 struct jtag_callback_entry
78 struct jtag_callback_entry
*next
;
80 jtag_callback_t callback
;
82 jtag_callback_data_t data1
;
83 jtag_callback_data_t data2
;
84 jtag_callback_data_t data3
;
88 static struct jtag_callback_entry
*jtag_callback_queue_head
= NULL
;
89 static struct jtag_callback_entry
*jtag_callback_queue_tail
= NULL
;
93 jtag_command_t
*jtag_command_queue
= NULL
;
94 jtag_command_t
**last_command_pointer
= &jtag_command_queue
;
95 static jtag_tap_t
*jtag_all_taps
= NULL
;
97 enum reset_types jtag_reset_config
= RESET_NONE
;
98 tap_state_t cmd_queue_end_state
= TAP_RESET
;
99 tap_state_t cmd_queue_cur_state
= TAP_RESET
;
101 int jtag_verify_capture_ir
= 1;
104 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
105 static int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
106 static int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
108 /* maximum number of JTAG devices expected in the chain
110 #define JTAG_MAX_CHAIN_SIZE 20
112 /* callbacks to inform high-level handlers about JTAG state changes */
113 jtag_event_callback_t
*jtag_event_callbacks
;
116 static int speed_khz
= 0;
117 /* flag if the kHz speed was defined */
118 static int hasKHz
= 0;
120 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
123 #if BUILD_ECOSBOARD == 1
124 extern jtag_interface_t zy1000_interface
;
127 #if BUILD_PARPORT == 1
128 extern jtag_interface_t parport_interface
;
132 extern jtag_interface_t dummy_interface
;
135 #if BUILD_FT2232_FTD2XX == 1
136 extern jtag_interface_t ft2232_interface
;
139 #if BUILD_FT2232_LIBFTDI == 1
140 extern jtag_interface_t ft2232_interface
;
143 #if BUILD_AMTJTAGACCEL == 1
144 extern jtag_interface_t amt_jtagaccel_interface
;
147 #if BUILD_EP93XX == 1
148 extern jtag_interface_t ep93xx_interface
;
151 #if BUILD_AT91RM9200 == 1
152 extern jtag_interface_t at91rm9200_interface
;
155 #if BUILD_GW16012 == 1
156 extern jtag_interface_t gw16012_interface
;
159 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
160 extern jtag_interface_t presto_interface
;
163 #if BUILD_USBPROG == 1
164 extern jtag_interface_t usbprog_interface
;
168 extern jtag_interface_t jlink_interface
;
171 #if BUILD_VSLLINK == 1
172 extern jtag_interface_t vsllink_interface
;
176 extern jtag_interface_t rlink_interface
;
179 #if BUILD_ARMJTAGEW == 1
180 extern jtag_interface_t armjtagew_interface
;
183 jtag_interface_t
*jtag_interfaces
[] = {
184 #if BUILD_ECOSBOARD == 1
187 #if BUILD_PARPORT == 1
193 #if BUILD_FT2232_FTD2XX == 1
196 #if BUILD_FT2232_LIBFTDI == 1
199 #if BUILD_AMTJTAGACCEL == 1
200 &amt_jtagaccel_interface
,
202 #if BUILD_EP93XX == 1
205 #if BUILD_AT91RM9200 == 1
206 &at91rm9200_interface
,
208 #if BUILD_GW16012 == 1
211 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
214 #if BUILD_USBPROG == 1
220 #if BUILD_VSLLINK == 1
226 #if BUILD_ARMJTAGEW == 1
227 &armjtagew_interface
,
232 static jtag_interface_t
*jtag
= NULL
;
235 static jtag_interface_t
*jtag_interface
= NULL
;
238 /* forward declarations */
239 //void jtag_add_pathmove(int num_states, tap_state_t *path);
240 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
241 //void jtag_add_end_state(tap_state_t endstate);
242 //void jtag_add_sleep(u32 us);
243 //int jtag_execute_queue(void);
244 static tap_state_t
tap_state_by_name(const char *name
);
247 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
248 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
249 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
250 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
251 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
252 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
253 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
255 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
257 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
258 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
259 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
260 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
261 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
262 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
264 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
265 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
266 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
268 jtag_tap_t
*jtag_AllTaps(void)
270 return jtag_all_taps
;
273 int jtag_NumTotalTaps(void)
287 int jtag_NumEnabledTaps(void)
303 jtag_tap_t
*jtag_TapByString( const char *s
)
311 if( 0 == strcmp( t
->dotted_name
, s
) ){
317 /* backup plan is by number */
319 /* ok - is "s" a number? */
321 n
= strtol( s
, &cp
, 0 );
322 if( (s
!= cp
) && (*cp
== 0) ){
324 t
= jtag_TapByAbsPosition(n
);
330 jtag_tap_t
* jtag_TapByJimObj( Jim_Interp
*interp
, Jim_Obj
*o
)
335 cp
= Jim_GetString( o
, NULL
);
340 t
= jtag_TapByString( cp
);
343 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
348 /* returns a pointer to the n-th device in the scan chain */
349 jtag_tap_t
* jtag_TapByAbsPosition( int n
)
357 while( t
&& (n
> 0)) {
364 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
366 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
368 if (callback
== NULL
)
370 return ERROR_INVALID_ARGUMENTS
;
375 while ((*callbacks_p
)->next
)
376 callbacks_p
= &((*callbacks_p
)->next
);
377 callbacks_p
= &((*callbacks_p
)->next
);
380 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
381 (*callbacks_p
)->callback
= callback
;
382 (*callbacks_p
)->priv
= priv
;
383 (*callbacks_p
)->next
= NULL
;
388 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
390 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
392 if (callback
== NULL
)
394 return ERROR_INVALID_ARGUMENTS
;
399 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
400 if ((*callbacks_p
)->callback
== callback
)
403 *callbacks_p
= *next
;
411 int jtag_call_event_callbacks(enum jtag_event event
)
413 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
415 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
419 callback
->callback(event
, callback
->priv
);
420 callback
= callback
->next
;
426 /* returns a pointer to the pointer of the last command in queue
427 * this may be a pointer to the root pointer (jtag_command_queue)
428 * or to the next member of the last but one command
430 jtag_command_t
** jtag_get_last_command_p(void)
432 /* jtag_command_t *cmd = jtag_command_queue;
438 return &jtag_command_queue;
442 return last_command_pointer
;
446 void jtag_queue_command(jtag_command_t
* cmd
)
448 jtag_command_t
**last_cmd
;
450 last_cmd
= jtag_get_last_command_p();
454 (*last_cmd
)->next
= NULL
;
456 last_command_pointer
= &((*last_cmd
)->next
);
460 void* cmd_queue_alloc(size_t size
)
462 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
468 * We align/round the *SIZE* per below
469 * so that all pointers returned by
470 * this function are reasonably well
473 * If we did not, then an "odd-length" request would cause the
474 * *next* allocation to be at an *odd* address, and because
475 * this function has the same type of api as malloc() - we
476 * must also return pointers that have the same type of
479 * What I do not/have is a reasonable portable means
482 * The solution here, is based on these suggestions.
483 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
486 union worse_case_align
{
492 #define ALIGN_SIZE (sizeof(union worse_case_align))
494 /* The alignment process. */
495 size
= (size
+ ALIGN_SIZE
-1) & (~(ALIGN_SIZE
-1));
500 while ((*p_page
)->next
)
501 p_page
= &((*p_page
)->next
);
502 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
503 p_page
= &((*p_page
)->next
);
508 *p_page
= malloc(sizeof(cmd_queue_page_t
));
510 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
511 (*p_page
)->next
= NULL
;
514 offset
= (*p_page
)->used
;
515 (*p_page
)->used
+= size
;
517 t
=(u8
*)((*p_page
)->address
);
521 void cmd_queue_free(void)
523 cmd_queue_page_t
*page
= cmd_queue_pages
;
527 cmd_queue_page_t
*last
= page
;
533 cmd_queue_pages
= NULL
;
537 * Copy a scan_field_t for insertion into the queue.
539 * This allocates a new copy of out_value using cmd_queue_alloc.
541 static void cmd_queue_scan_field_clone(scan_field_t
* dst
, const scan_field_t
* src
)
544 dst
->num_bits
= src
->num_bits
;
545 dst
->out_value
= buf_cpy(src
->out_value
, cmd_queue_alloc(CEIL(src
->num_bits
, 8)), src
->num_bits
);
546 dst
->in_value
= src
->in_value
;
550 static void jtag_prelude1(void)
554 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
555 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
559 if (cmd_queue_end_state
== TAP_RESET
)
560 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
563 static void jtag_prelude(tap_state_t state
)
567 if (state
!= TAP_INVALID
)
568 jtag_add_end_state(state
);
570 cmd_queue_cur_state
= cmd_queue_end_state
;
573 void jtag_add_ir_scan_noverify(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
578 retval
=interface_jtag_add_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
579 if (retval
!=ERROR_OK
)
586 * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
588 * If the input field list contains an instruction value for a TAP then that is used
589 * otherwise the TAP is set to bypass.
591 * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
594 void jtag_add_ir_scan(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
596 if (jtag_verify
&&jtag_verify_capture_ir
)
598 /* 8 x 32 bit id's is enough for all invocations */
600 for (int j
= 0; j
< in_num_fields
; j
++)
602 /* if we are to run a verification of the ir scan, we need to get the input back.
603 * We may have to allocate space if the caller didn't ask for the input back.
605 in_fields
[j
].check_value
=in_fields
[j
].tap
->expected
;
606 in_fields
[j
].check_mask
=in_fields
[j
].tap
->expected_mask
;
608 jtag_add_scan_check(jtag_add_ir_scan_noverify
, in_num_fields
, in_fields
, state
);
611 jtag_add_ir_scan_noverify(in_num_fields
, in_fields
, state
);
616 * see jtag_add_ir_scan()
619 int MINIDRIVER(interface_jtag_add_ir_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
621 size_t num_taps
= jtag_NumEnabledTaps();
623 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
624 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
625 scan_field_t
* out_fields
= cmd_queue_alloc(num_taps
* sizeof(scan_field_t
));
627 jtag_queue_command(cmd
);
629 cmd
->type
= JTAG_SCAN
;
630 cmd
->cmd
.scan
= scan
;
632 scan
->ir_scan
= true;
633 scan
->num_fields
= num_taps
; /* one field per device */
634 scan
->fields
= out_fields
;
635 scan
->end_state
= state
;
638 scan_field_t
* field
= out_fields
; /* keep track where we insert data */
640 /* loop over all enabled TAPs */
642 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
644 /* search the input field list for fields for the current TAP */
648 for (int j
= 0; j
< in_num_fields
; j
++)
650 if (tap
!= in_fields
[j
].tap
)
653 /* if TAP is listed in input fields, copy the value */
659 assert(in_fields
[j
].num_bits
== tap
->ir_length
); /* input fields must have the same length as the TAP's IR */
661 cmd_queue_scan_field_clone(field
, in_fields
+ j
);
668 /* if a TAP isn't listed in input fields, set it to BYPASS */
673 field
->num_bits
= tap
->ir_length
;
674 field
->out_value
= buf_set_ones(cmd_queue_alloc(CEIL(tap
->ir_length
, 8)), tap
->ir_length
);
675 field
->in_value
= NULL
; /* do not collect input for tap's in bypass */
678 /* update device information */
679 buf_cpy(field
->out_value
, tap
->cur_instr
, tap
->ir_length
);
684 assert(field
== out_fields
+ num_taps
); /* paranoia: jtag_NumEnabledTaps() and jtag_NextEnabledTap() not in sync */
690 * Duplicate the scan fields passed into the function into an IR SCAN command
692 * This function assumes that the caller handles extra fields for bypassed TAPs
695 void jtag_add_plain_ir_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
701 retval
=interface_jtag_add_plain_ir_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
702 if (retval
!=ERROR_OK
)
708 * see jtag_add_plain_ir_scan()
711 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
714 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
715 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
716 scan_field_t
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(scan_field_t
));
718 jtag_queue_command(cmd
);
720 cmd
->type
= JTAG_SCAN
;
721 cmd
->cmd
.scan
= scan
;
723 scan
->ir_scan
= true;
724 scan
->num_fields
= in_num_fields
;
725 scan
->fields
= out_fields
;
726 scan
->end_state
= state
;
728 for (int i
= 0; i
< in_num_fields
; i
++)
729 cmd_queue_scan_field_clone(out_fields
+ i
, in_fields
+ i
);
736 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
);
738 static int jtag_check_value_mask_callback(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
740 return jtag_check_value_inner(in
, (u8
*)data1
, (u8
*)data2
, (int)data3
);
743 #ifdef HAVE_JTAG_MINIDRIVER_H
744 void interface_jtag_add_scan_check_alloc(scan_field_t
*field
)
746 /* We're executing this synchronously, so try to use local storage. */
747 if (field
->num_bits
> 32)
749 unsigned num_bytes
= TAP_SCAN_BYTES(field
->num_bits
);
750 field
->in_value
= (u8
*)malloc(num_bytes
);
751 field
->allocated
= 1;
754 field
->in_value
= field
->intmp
;
757 void interface_jtag_add_scan_check_alloc(scan_field_t
*field
)
759 unsigned num_bytes
= TAP_SCAN_BYTES(field
->num_bits
);
760 field
->in_value
= (u8
*)cmd_queue_alloc(num_bytes
);
764 static void jtag_add_scan_check(void (*jtag_add_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
),
765 int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
767 for (int i
= 0; i
< in_num_fields
; i
++)
769 struct scan_field_s
*field
= &in_fields
[i
];
770 field
->allocated
= 0;
772 if (field
->check_value
|| field
->in_value
)
774 interface_jtag_add_scan_check_alloc(field
);
778 jtag_add_scan(in_num_fields
, in_fields
, state
);
780 for (int i
= 0; i
< in_num_fields
; i
++)
782 if ((in_fields
[i
].check_value
!= NULL
) && (in_fields
[i
].in_value
!= NULL
))
784 /* this is synchronous for a minidriver */
785 jtag_add_callback4(jtag_check_value_mask_callback
, in_fields
[i
].in_value
,
786 (jtag_callback_data_t
)in_fields
[i
].check_value
,
787 (jtag_callback_data_t
)in_fields
[i
].check_mask
,
788 (jtag_callback_data_t
)in_fields
[i
].num_bits
);
790 if (in_fields
[i
].allocated
)
792 free(in_fields
[i
].in_value
);
794 if (in_fields
[i
].modified
)
796 in_fields
[i
].in_value
= NULL
;
801 void jtag_add_dr_scan_check(int in_num_fields
, scan_field_t
*in_fields
, tap_state_t state
)
805 jtag_add_scan_check(jtag_add_dr_scan
, in_num_fields
, in_fields
, state
);
808 jtag_add_dr_scan(in_num_fields
, in_fields
, state
);
814 * Generate a DR SCAN using the fields passed to the function
816 * For not bypassed TAPs the function checks in_fields and uses fields specified there.
817 * For bypassed TAPs the function generates a dummy 1bit field.
819 * The bypass status of TAPs is set by jtag_add_ir_scan().
822 void jtag_add_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
828 retval
=interface_jtag_add_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
829 if (retval
!=ERROR_OK
)
835 * see jtag_add_dr_scan()
838 int MINIDRIVER(interface_jtag_add_dr_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
840 /* count devices in bypass */
842 size_t bypass_devices
= 0;
844 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
850 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
851 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
852 scan_field_t
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
854 jtag_queue_command(cmd
);
856 cmd
->type
= JTAG_SCAN
;
857 cmd
->cmd
.scan
= scan
;
859 scan
->ir_scan
= false;
860 scan
->num_fields
= in_num_fields
+ bypass_devices
;
861 scan
->fields
= out_fields
;
862 scan
->end_state
= state
;
865 scan_field_t
* field
= out_fields
; /* keep track where we insert data */
867 /* loop over all enabled TAPs */
869 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
871 /* if TAP is not bypassed insert matching input fields */
875 scan_field_t
* start_field
= field
; /* keep initial position for assert() */
877 for (int j
= 0; j
< in_num_fields
; j
++)
879 if (tap
!= in_fields
[j
].tap
)
882 cmd_queue_scan_field_clone(field
, in_fields
+ j
);
887 assert(field
> start_field
); /* must have at least one input field per not bypassed TAP */
890 /* if a TAP is bypassed, generated a dummy bit*/
895 field
->out_value
= NULL
;
896 field
->in_value
= NULL
;
902 assert(field
== out_fields
+ scan
->num_fields
); /* no superfluous input fields permitted */
910 * Generate a DR SCAN using the array of output values passed to the function
912 * This function assumes that the parameter target_tap specifies the one TAP
913 * that is not bypassed. All other TAPs must be bypassed and the function will
914 * generate a dummy 1bit field for them.
916 * For the target_tap a sequence of output-only fields will be generated where
917 * each field has the size num_bits and the field's values are taken from
920 * The bypass status of TAPs is set by jtag_add_ir_scan().
923 void MINIDRIVER(interface_jtag_add_dr_out
)(jtag_tap_t
*target_tap
,
927 tap_state_t end_state
)
929 /* count devices in bypass */
931 size_t bypass_devices
= 0;
933 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
940 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
941 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
942 scan_field_t
* out_fields
= cmd_queue_alloc((in_num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
944 jtag_queue_command(cmd
);
946 cmd
->type
= JTAG_SCAN
;
947 cmd
->cmd
.scan
= scan
;
949 scan
->ir_scan
= false;
950 scan
->num_fields
= in_num_fields
+ bypass_devices
;
951 scan
->fields
= out_fields
;
952 scan
->end_state
= end_state
;
955 bool target_tap_match
= false;
957 scan_field_t
* field
= out_fields
; /* keep track where we insert data */
959 /* loop over all enabled TAPs */
961 for (jtag_tap_t
* tap
= jtag_NextEnabledTap(NULL
); tap
!= NULL
; tap
= jtag_NextEnabledTap(tap
))
963 /* if TAP is not bypassed insert matching input fields */
967 assert(tap
== target_tap
); /* target_tap must match the one not bypassed TAP */
969 target_tap_match
= true;
971 for (int j
= 0; j
< in_num_fields
; j
++)
974 size_t scan_size
= num_bits
[j
];
975 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
978 field
->num_bits
= scan_size
;
979 field
->out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
980 field
->in_value
= NULL
;
986 /* if a TAP is bypassed, generated a dummy bit*/
992 field
->out_value
= NULL
;
993 field
->in_value
= NULL
;
999 assert(target_tap_match
); /* target_tap should be enabled and not bypassed */
1004 * Duplicate the scan fields passed into the function into a DR SCAN command
1006 * This function assumes that the caller handles extra fields for bypassed TAPs
1009 void jtag_add_plain_dr_scan(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
1013 jtag_prelude(state
);
1015 retval
=interface_jtag_add_plain_dr_scan(in_num_fields
, in_fields
, cmd_queue_end_state
);
1016 if (retval
!=ERROR_OK
)
1022 * see jtag_add_plain_dr_scan()
1025 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int in_num_fields
, const scan_field_t
*in_fields
, tap_state_t state
)
1027 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1028 scan_command_t
* scan
= cmd_queue_alloc(sizeof(scan_command_t
));
1029 scan_field_t
* out_fields
= cmd_queue_alloc(in_num_fields
* sizeof(scan_field_t
));
1031 jtag_queue_command(cmd
);
1033 cmd
->type
= JTAG_SCAN
;
1034 cmd
->cmd
.scan
= scan
;
1036 scan
->ir_scan
= false;
1037 scan
->num_fields
= in_num_fields
;
1038 scan
->fields
= out_fields
;
1039 scan
->end_state
= state
;
1041 for (int i
= 0; i
< in_num_fields
; i
++)
1042 cmd_queue_scan_field_clone(out_fields
+ i
, in_fields
+ i
);
1048 void jtag_add_tlr(void)
1050 jtag_prelude(TAP_RESET
);
1053 retval
=interface_jtag_add_tlr();
1054 if (retval
!=ERROR_OK
)
1058 int MINIDRIVER(interface_jtag_add_tlr
)(void)
1060 tap_state_t state
= TAP_RESET
;
1062 /* allocate memory for a new list member */
1063 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1065 jtag_queue_command(cmd
);
1067 cmd
->type
= JTAG_STATEMOVE
;
1069 cmd
->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
1070 cmd
->cmd
.statemove
->end_state
= state
;
1075 void jtag_add_pathmove(int num_states
, const tap_state_t
*path
)
1077 tap_state_t cur_state
= cmd_queue_cur_state
;
1081 /* the last state has to be a stable state */
1082 if (!tap_is_state_stable(path
[num_states
- 1]))
1084 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
1088 for (i
=0; i
<num_states
; i
++)
1090 if (path
[i
] == TAP_RESET
)
1092 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1096 if ( tap_state_transition(cur_state
, true) != path
[i
]
1097 && tap_state_transition(cur_state
, false) != path
[i
])
1099 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state
), tap_state_name(path
[i
]));
1102 cur_state
= path
[i
];
1107 retval
= interface_jtag_add_pathmove(num_states
, path
);
1108 cmd_queue_cur_state
= path
[num_states
- 1];
1109 if (retval
!=ERROR_OK
)
1113 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, const tap_state_t
*path
)
1115 /* allocate memory for a new list member */
1116 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1118 jtag_queue_command(cmd
);
1120 cmd
->type
= JTAG_PATHMOVE
;
1122 cmd
->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
1123 cmd
->cmd
.pathmove
->num_states
= num_states
;
1124 cmd
->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(tap_state_t
) * num_states
);
1126 for (int i
= 0; i
< num_states
; i
++)
1127 cmd
->cmd
.pathmove
->path
[i
] = path
[i
];
1132 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, tap_state_t state
)
1134 /* allocate memory for a new list member */
1135 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1137 jtag_queue_command(cmd
);
1139 cmd
->type
= JTAG_RUNTEST
;
1141 cmd
->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
1142 cmd
->cmd
.runtest
->num_cycles
= num_cycles
;
1143 cmd
->cmd
.runtest
->end_state
= state
;
1148 void jtag_add_runtest(int num_cycles
, tap_state_t state
)
1152 jtag_prelude(state
);
1154 /* executed by sw or hw fifo */
1155 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
1156 if (retval
!=ERROR_OK
)
1161 int MINIDRIVER(interface_jtag_add_clocks
)( int num_cycles
)
1163 /* allocate memory for a new list member */
1164 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1166 jtag_queue_command(cmd
);
1168 cmd
->type
= JTAG_STABLECLOCKS
;
1170 cmd
->cmd
.stableclocks
= cmd_queue_alloc(sizeof(stableclocks_command_t
));
1171 cmd
->cmd
.stableclocks
->num_cycles
= num_cycles
;
1176 void jtag_add_clocks( int num_cycles
)
1180 if( !tap_is_state_stable(cmd_queue_cur_state
) )
1182 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1183 tap_state_name(cmd_queue_cur_state
) );
1184 jtag_error
= ERROR_JTAG_NOT_STABLE_STATE
;
1188 if( num_cycles
> 0 )
1192 retval
= interface_jtag_add_clocks(num_cycles
);
1193 if (retval
!= ERROR_OK
)
1198 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
1200 int trst_with_tlr
= 0;
1203 /* FIX!!! there are *many* different cases here. A better
1204 * approach is needed for legal combinations of transitions...
1206 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
1207 (jtag_reset_config
& RESET_HAS_TRST
)&&
1208 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
1210 if (((req_tlr_or_trst
&&!jtag_trst
)||
1211 (!req_tlr_or_trst
&&jtag_trst
))&&
1212 ((req_srst
&&!jtag_srst
)||
1213 (!req_srst
&&jtag_srst
)))
1215 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1216 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1220 /* Make sure that jtag_reset_config allows the requested reset */
1221 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1222 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
1224 LOG_ERROR("BUG: requested reset would assert trst");
1225 jtag_error
=ERROR_FAIL
;
1229 /* if TRST pulls SRST, we reset with TAP T-L-R */
1230 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
1235 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
1237 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1238 jtag_error
=ERROR_FAIL
;
1242 if (req_tlr_or_trst
)
1244 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
1256 jtag_srst
= req_srst
;
1258 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
1259 if (retval
!=ERROR_OK
)
1264 jtag_execute_queue();
1268 LOG_DEBUG("SRST line asserted");
1272 LOG_DEBUG("SRST line released");
1273 if (jtag_nsrst_delay
)
1274 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1279 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1280 jtag_add_end_state(TAP_RESET
);
1282 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1288 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1289 * and inform possible listeners about this
1291 LOG_DEBUG("TRST line asserted");
1292 tap_set_state(TAP_RESET
);
1293 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1297 if (jtag_ntrst_delay
)
1298 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1302 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1304 /* allocate memory for a new list member */
1305 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1307 jtag_queue_command(cmd
);
1309 cmd
->type
= JTAG_RESET
;
1311 cmd
->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1312 cmd
->cmd
.reset
->trst
= req_trst
;
1313 cmd
->cmd
.reset
->srst
= req_srst
;
1318 void jtag_add_end_state(tap_state_t state
)
1320 cmd_queue_end_state
= state
;
1321 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
1323 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1327 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1329 /* allocate memory for a new list member */
1330 jtag_command_t
* cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1332 jtag_queue_command(cmd
);
1334 cmd
->type
= JTAG_SLEEP
;
1336 cmd
->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1337 cmd
->cmd
.sleep
->us
= us
;
1342 void jtag_add_sleep(u32 us
)
1344 keep_alive(); /* we might be running on a very slow JTAG clk */
1345 int retval
=interface_jtag_add_sleep(us
);
1346 if (retval
!=ERROR_OK
)
1351 int jtag_scan_size(const scan_command_t
*cmd
)
1356 /* count bits in scan command */
1357 for (i
= 0; i
< cmd
->num_fields
; i
++)
1359 bit_count
+= cmd
->fields
[i
].num_bits
;
1365 int jtag_build_buffer(const scan_command_t
*cmd
, u8
**buffer
)
1370 bit_count
= jtag_scan_size(cmd
);
1371 *buffer
= calloc(1,CEIL(bit_count
, 8));
1375 #ifdef _DEBUG_JTAG_IO_
1376 LOG_DEBUG("%s num_fields: %i", cmd
->ir_scan
? "IRSCAN" : "DRSCAN", cmd
->num_fields
);
1379 for (i
= 0; i
< cmd
->num_fields
; i
++)
1381 if (cmd
->fields
[i
].out_value
)
1383 #ifdef _DEBUG_JTAG_IO_
1384 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);
1386 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1387 #ifdef _DEBUG_JTAG_IO_
1388 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i
, cmd
->fields
[i
].num_bits
, char_buf
);
1394 #ifdef _DEBUG_JTAG_IO_
1395 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i
, cmd
->fields
[i
].num_bits
);
1399 bit_count
+= cmd
->fields
[i
].num_bits
;
1402 #ifdef _DEBUG_JTAG_IO_
1403 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1409 int jtag_read_buffer(u8
*buffer
, const scan_command_t
*cmd
)
1415 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1418 for (i
= 0; i
< cmd
->num_fields
; i
++)
1420 /* if neither in_value nor in_handler
1421 * are specified we don't have to examine this field
1423 if (cmd
->fields
[i
].in_value
)
1425 int num_bits
= cmd
->fields
[i
].num_bits
;
1426 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1428 #ifdef _DEBUG_JTAG_IO_
1429 char *char_buf
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1430 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i
, num_bits
, char_buf
);
1434 if (cmd
->fields
[i
].in_value
)
1436 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1441 bit_count
+= cmd
->fields
[i
].num_bits
;
1447 static const char *jtag_tap_name(const jtag_tap_t
*tap
)
1449 return (tap
== NULL
) ? "(unknown)" : tap
->dotted_name
;
1452 int jtag_check_value_inner(u8
*captured
, u8
*in_check_value
, u8
*in_check_mask
, int num_bits
)
1454 int retval
= ERROR_OK
;
1456 int compare_failed
= 0;
1459 compare_failed
= buf_cmp_mask(captured
, in_check_value
, in_check_mask
, num_bits
);
1461 compare_failed
= buf_cmp(captured
, in_check_value
, num_bits
);
1463 if (compare_failed
){
1464 /* An error handler could have caught the failing check
1465 * only report a problem when there wasn't a handler, or if the handler
1466 * acknowledged the error
1469 LOG_WARNING("TAP %s:",
1470 jtag_tap_name(field->tap));
1474 char *captured_char
= buf_to_str(captured
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1475 char *in_check_value_char
= buf_to_str(in_check_value
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1479 char *in_check_mask_char
;
1480 in_check_mask_char
= buf_to_str(in_check_mask
, (num_bits
> DEBUG_JTAG_IOZ
) ? DEBUG_JTAG_IOZ
: num_bits
, 16);
1481 LOG_WARNING("value captured during scan didn't pass the requested check:");
1482 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1483 captured_char
, in_check_value_char
, in_check_mask_char
);
1484 free(in_check_mask_char
);
1488 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
);
1491 free(captured_char
);
1492 free(in_check_value_char
);
1494 retval
= ERROR_JTAG_QUEUE_FAILED
;
1501 void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
)
1503 assert(field
->in_value
!= NULL
);
1507 /* no checking to do */
1511 jtag_execute_queue_noclear();
1513 int retval
=jtag_check_value_inner(field
->in_value
, value
, mask
, field
->num_bits
);
1514 jtag_set_error(retval
);
1519 enum scan_type
jtag_scan_type(const scan_command_t
*cmd
)
1524 for (i
= 0; i
< cmd
->num_fields
; i
++)
1526 if (cmd
->fields
[i
].in_value
)
1528 if (cmd
->fields
[i
].out_value
)
1536 #ifndef HAVE_JTAG_MINIDRIVER_H
1537 /* add callback to end of queue */
1538 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
)
1540 struct jtag_callback_entry
*entry
=cmd_queue_alloc(sizeof(struct jtag_callback_entry
));
1543 entry
->callback
=callback
;
1549 if (jtag_callback_queue_head
==NULL
)
1551 jtag_callback_queue_head
=entry
;
1552 jtag_callback_queue_tail
=entry
;
1555 jtag_callback_queue_tail
->next
=entry
;
1556 jtag_callback_queue_tail
=entry
;
1561 static int jtag_convert_to_callback4(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
)
1563 ((jtag_callback1_t
)data1
)(in
);
1567 void jtag_add_callback(jtag_callback1_t callback
, u8
*in
)
1569 jtag_add_callback4(jtag_convert_to_callback4
, in
, (jtag_callback_data_t
)callback
, 0, 0);
1573 #ifndef HAVE_JTAG_MINIDRIVER_H
1575 int interface_jtag_execute_queue(void)
1581 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1585 retval
= jtag
->execute_queue();
1587 if (retval
== ERROR_OK
)
1589 struct jtag_callback_entry
*entry
;
1590 for (entry
=jtag_callback_queue_head
; entry
!=NULL
; entry
=entry
->next
)
1592 retval
=entry
->callback(entry
->in
, entry
->data1
, entry
->data2
, entry
->data3
);
1593 if (retval
!=ERROR_OK
)
1600 jtag_callback_queue_head
= NULL
;
1601 jtag_callback_queue_tail
= NULL
;
1603 jtag_command_queue
= NULL
;
1604 last_command_pointer
= &jtag_command_queue
;
1610 void jtag_execute_queue_noclear(void)
1612 /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1613 * E.g. a JTAG over TCP/IP or USB....
1615 jtag_flush_queue_count
++;
1617 int retval
=interface_jtag_execute_queue();
1618 /* we keep the first error */
1619 if ((jtag_error
==ERROR_OK
)&&(retval
!=ERROR_OK
))
1625 int jtag_execute_queue(void)
1628 jtag_execute_queue_noclear();
1630 jtag_error
=ERROR_OK
;
1634 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1636 jtag_tap_t
*tap
= priv
;
1640 if (event
== JTAG_TRST_ASSERTED
)
1642 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1649 void jtag_sleep(u32 us
)
1651 alive_sleep(us
/1000);
1654 /* Try to examine chain layout according to IEEE 1149.1 §12
1656 int jtag_examine_chain(void)
1660 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1663 int device_count
= 0;
1664 u8 zero_check
= 0x0;
1665 u8 one_check
= 0xff;
1668 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1669 field
.out_value
= idcode_buffer
;
1671 field
.in_value
= idcode_buffer
;
1676 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1678 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1681 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
1682 jtag_execute_queue();
1684 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1686 zero_check
|= idcode_buffer
[i
];
1687 one_check
&= idcode_buffer
[i
];
1690 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1691 if ((zero_check
== 0x00) || (one_check
== 0xff))
1693 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1694 return ERROR_JTAG_INIT_FAILED
;
1697 /* point at the 1st tap */
1698 tap
= jtag_NextEnabledTap(NULL
);
1700 LOG_ERROR("JTAG: No taps enabled?");
1701 return ERROR_JTAG_INIT_FAILED
;
1704 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1706 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1707 if ((idcode
& 1) == 0)
1709 /* LSB must not be 0, this indicates a device in bypass */
1710 LOG_WARNING("Tap/Device does not have IDCODE");
1721 /* some devices, such as AVR will output all 1's instead of TDI
1722 input value at end of chain. */
1723 if ((idcode
== 0x000000FF)||(idcode
== 0xFFFFFFFF))
1726 /* End of chain (invalid manufacturer ID)
1728 * The JTAG examine is the very first thing that happens
1730 * A single JTAG device requires only 64 bits to be read back correctly.
1732 * The code below adds a check that the rest of the data scanned (640 bits)
1733 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1735 * earlier and gives more helpful/explicit error messages.
1737 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1739 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1740 if (unexpected
||((idcode
!= 0x000000FF)&&(idcode
!= 0xFFFFFFFF)))
1742 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1750 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1751 manufacturer
= EXTRACT_MFG(idcode
);
1752 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1753 part
= EXTRACT_PART(idcode
);
1754 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1755 version
= EXTRACT_VER(idcode
);
1757 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1758 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1759 idcode
, manufacturer
, part
, version
);
1765 tap
->idcode
= idcode
;
1767 if (tap
->expected_ids_cnt
> 0) {
1768 /* Loop over the expected identification codes and test for a match */
1770 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1771 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1776 /* If none of the expected ids matched, log an error */
1777 if (ii
== tap
->expected_ids_cnt
) {
1778 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1781 EXTRACT_MFG( tap
->idcode
),
1782 EXTRACT_PART( tap
->idcode
),
1783 EXTRACT_VER( tap
->idcode
) );
1784 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1785 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1788 tap
->expected_ids_cnt
,
1789 tap
->expected_ids
[ii
],
1790 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1791 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1792 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1795 return ERROR_JTAG_INIT_FAILED
;
1797 LOG_INFO("JTAG Tap/device matched");
1801 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1805 tap
= jtag_NextEnabledTap(tap
);
1810 /* see if number of discovered devices matches configuration */
1811 if (device_count
!= jtag_NumEnabledTaps())
1813 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1814 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1815 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1816 return ERROR_JTAG_INIT_FAILED
;
1822 int jtag_validate_chain(void)
1825 int total_ir_length
= 0;
1831 total_ir_length
= 0;
1833 tap
= jtag_NextEnabledTap(tap
);
1837 total_ir_length
+= tap
->ir_length
;
1840 total_ir_length
+= 2;
1841 ir_test
= malloc(CEIL(total_ir_length
, 8));
1842 buf_set_ones(ir_test
, total_ir_length
);
1845 field
.num_bits
= total_ir_length
;
1846 field
.out_value
= ir_test
;
1847 field
.in_value
= ir_test
;
1850 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1851 jtag_execute_queue();
1857 tap
= jtag_NextEnabledTap(tap
);
1862 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1865 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1866 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
);
1869 return ERROR_JTAG_INIT_FAILED
;
1871 chain_pos
+= tap
->ir_length
;
1874 val
= buf_get_u32(ir_test
, chain_pos
, 2);
1877 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1878 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
);
1881 return ERROR_JTAG_INIT_FAILED
;
1889 enum jtag_tap_cfg_param
{
1893 static Jim_Nvp nvp_config_opts
[] = {
1894 { .name
= "-event", .value
= JCFG_EVENT
},
1896 { .name
= NULL
, .value
= -1 }
1899 static int jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
1905 /* parse config or cget options */
1906 while (goi
->argc
> 0) {
1907 Jim_SetEmptyResult (goi
->interp
);
1909 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1911 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1917 if (goi
->argc
== 0) {
1918 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1922 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1924 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1928 if (goi
->isconfigure
) {
1929 if (goi
->argc
!= 1) {
1930 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1934 if (goi
->argc
!= 0) {
1935 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1941 jtag_tap_event_action_t
*jteap
;
1943 jteap
= tap
->event_action
;
1944 /* replace existing? */
1946 if (jteap
->event
== (enum jtag_tap_event
)n
->value
) {
1949 jteap
= jteap
->next
;
1952 if (goi
->isconfigure
) {
1953 if (jteap
== NULL
) {
1955 jteap
= calloc(1, sizeof (*jteap
));
1957 jteap
->event
= n
->value
;
1958 Jim_GetOpt_Obj( goi
, &o
);
1960 Jim_DecrRefCount(interp
, jteap
->body
);
1962 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1963 Jim_IncrRefCount(jteap
->body
);
1965 /* add to head of event list */
1966 jteap
->next
= tap
->event_action
;
1967 tap
->event_action
= jteap
;
1968 Jim_SetEmptyResult(goi
->interp
);
1971 if (jteap
== NULL
) {
1972 Jim_SetEmptyResult(goi
->interp
);
1974 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1981 } /* while (goi->argc) */
1986 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1996 const Jim_Nvp opts
[] = {
1997 #define NTAP_OPT_IRLEN 0
1998 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1999 #define NTAP_OPT_IRMASK 1
2000 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
2001 #define NTAP_OPT_IRCAPTURE 2
2002 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
2003 #define NTAP_OPT_ENABLED 3
2004 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
2005 #define NTAP_OPT_DISABLED 4
2006 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
2007 #define NTAP_OPT_EXPECTED_ID 5
2008 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
2009 { .name
= NULL
, .value
= -1 },
2012 pTap
= malloc( sizeof(jtag_tap_t
) );
2013 memset( pTap
, 0, sizeof(*pTap
) );
2015 Jim_SetResult_sprintf( goi
->interp
, "no memory");
2019 * we expect CHIP + TAP + OPTIONS
2021 if( goi
->argc
< 3 ){
2022 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
2025 Jim_GetOpt_String( goi
, &cp
, NULL
);
2026 pTap
->chip
= strdup(cp
);
2028 Jim_GetOpt_String( goi
, &cp
, NULL
);
2029 pTap
->tapname
= strdup(cp
);
2031 /* name + dot + name + null */
2032 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
2034 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
2035 pTap
->dotted_name
= cp
;
2037 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
2038 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
2040 /* default is enabled */
2043 /* deal with options */
2044 #define NTREQ_IRLEN 1
2045 #define NTREQ_IRCAPTURE 2
2046 #define NTREQ_IRMASK 4
2048 /* clear them as we find them */
2049 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
2052 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
2054 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
2057 LOG_DEBUG("Processing option: %s", n
->name
);
2059 case NTAP_OPT_ENABLED
:
2062 case NTAP_OPT_DISABLED
:
2065 case NTAP_OPT_EXPECTED_ID
:
2067 u32
*new_expected_ids
;
2069 e
= Jim_GetOpt_Wide( goi
, &w
);
2071 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
2075 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
2076 if (new_expected_ids
== NULL
) {
2077 Jim_SetResult_sprintf( goi
->interp
, "no memory");
2081 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
2083 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
2085 free(pTap
->expected_ids
);
2086 pTap
->expected_ids
= new_expected_ids
;
2087 pTap
->expected_ids_cnt
++;
2090 case NTAP_OPT_IRLEN
:
2091 case NTAP_OPT_IRMASK
:
2092 case NTAP_OPT_IRCAPTURE
:
2093 e
= Jim_GetOpt_Wide( goi
, &w
);
2095 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
2098 if( (w
< 0) || (w
> 0xffff) ){
2100 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
2101 n
->name
, (int)(w
), (int)(w
));
2105 case NTAP_OPT_IRLEN
:
2106 pTap
->ir_length
= w
;
2107 reqbits
&= (~(NTREQ_IRLEN
));
2109 case NTAP_OPT_IRMASK
:
2110 pTap
->ir_capture_mask
= w
;
2111 reqbits
&= (~(NTREQ_IRMASK
));
2113 case NTAP_OPT_IRCAPTURE
:
2114 pTap
->ir_capture_value
= w
;
2115 reqbits
&= (~(NTREQ_IRCAPTURE
));
2118 } /* switch(n->value) */
2119 } /* while( goi->argc ) */
2121 /* Did we get all the options? */
2124 Jim_SetResult_sprintf( goi
->interp
,
2125 "newtap: %s missing required parameters",
2127 /* TODO: Tell user what is missing :-( */
2128 /* no memory leaks pelase */
2129 free(((void *)(pTap
->expected_ids
)));
2130 free(((void *)(pTap
->chip
)));
2131 free(((void *)(pTap
->tapname
)));
2132 free(((void *)(pTap
->dotted_name
)));
2133 free(((void *)(pTap
)));
2137 pTap
->expected
= malloc( pTap
->ir_length
);
2138 pTap
->expected_mask
= malloc( pTap
->ir_length
);
2139 pTap
->cur_instr
= malloc( pTap
->ir_length
);
2141 buf_set_u32( pTap
->expected
,
2144 pTap
->ir_capture_value
);
2145 buf_set_u32( pTap
->expected_mask
,
2148 pTap
->ir_capture_mask
);
2149 buf_set_ones( pTap
->cur_instr
,
2154 jtag_register_event_callback(jtag_reset_callback
, pTap
);
2156 ppTap
= &(jtag_all_taps
);
2157 while( (*ppTap
) != NULL
){
2158 ppTap
= &((*ppTap
)->next_tap
);
2162 static int n_taps
= 0;
2163 pTap
->abs_chain_position
= n_taps
++;
2165 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2166 (*ppTap
)->dotted_name
,
2167 (*ppTap
)->abs_chain_position
,
2168 (*ppTap
)->ir_length
,
2169 (*ppTap
)->ir_capture_value
,
2170 (*ppTap
)->ir_capture_mask
);
2175 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2181 struct command_context_s
*context
;
2185 JTAG_CMD_INIT_RESET
,
2188 JTAG_CMD_TAPDISABLE
,
2189 JTAG_CMD_TAPISENABLED
,
2194 const Jim_Nvp jtag_cmds
[] = {
2195 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
2196 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
2197 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
2198 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
2199 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
2200 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
2201 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
2202 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
2204 { .name
= NULL
, .value
= -1 },
2207 context
= Jim_GetAssocData(interp
, "context");
2208 /* go past the command */
2209 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
2211 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
2213 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
2216 Jim_SetEmptyResult( goi
.interp
);
2218 case JTAG_CMD_INTERFACE
:
2219 /* return the name of the interface */
2220 /* TCL code might need to know the exact type... */
2221 /* FUTURE: we allow this as a means to "set" the interface. */
2222 if( goi
.argc
!= 0 ){
2223 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2226 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
2228 case JTAG_CMD_INIT_RESET
:
2229 if( goi
.argc
!= 0 ){
2230 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2233 e
= jtag_init_reset(context
);
2234 if( e
!= ERROR_OK
){
2235 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
2239 case JTAG_CMD_NEWTAP
:
2240 return jim_newtap_cmd( &goi
);
2242 case JTAG_CMD_TAPISENABLED
:
2243 case JTAG_CMD_TAPENABLE
:
2244 case JTAG_CMD_TAPDISABLE
:
2245 if( goi
.argc
!= 1 ){
2246 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
2252 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
2257 case JTAG_CMD_TAPISENABLED
:
2260 case JTAG_CMD_TAPENABLE
:
2261 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
2265 case JTAG_CMD_TAPDISABLE
:
2266 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
2271 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
2278 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
2285 Jim_GetOpt_Obj(&goi
, &o
);
2286 t
= jtag_TapByJimObj( goi
.interp
, o
);
2291 goi
.isconfigure
= 0;
2292 return jtag_tap_configure_cmd( &goi
, t
);
2296 case JTAG_CMD_CONFIGURE
:
2298 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
2305 Jim_GetOpt_Obj(&goi
, &o
);
2306 t
= jtag_TapByJimObj( goi
.interp
, o
);
2311 goi
.isconfigure
= 1;
2312 return jtag_tap_configure_cmd( &goi
, t
);
2319 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
2321 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
2323 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
2324 COMMAND_CONFIG
, "try to configure interface");
2325 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
2326 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
2327 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
2328 COMMAND_ANY
, "set maximum jtag speed (if supported); "
2329 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
2330 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
2331 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
2332 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
2334 "[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]");
2335 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
2336 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2337 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
2338 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2340 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
2341 COMMAND_EXEC
, "print current scan chain configuration");
2343 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
2344 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
2345 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
2346 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
2347 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
2348 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
2349 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
2350 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2351 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2352 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
2354 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
2355 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
2356 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
2357 COMMAND_ANY
, "verify value capture <enable|disable>");
2358 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
2359 COMMAND_ANY
, "choose short(default) or long tms_sequence <short|long>");
2363 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
2368 if (!jtag_interface
)
2370 /* nothing was previously specified by "interface" command */
2371 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2372 return ERROR_JTAG_INVALID_INTERFACE
;
2376 jtag_interface
->khz(speed_khz
, &jtag_speed
);
2380 if (jtag_interface
->init() != ERROR_OK
)
2381 return ERROR_JTAG_INIT_FAILED
;
2383 jtag
= jtag_interface
;
2387 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
2392 LOG_DEBUG("Init JTAG chain");
2394 tap
= jtag_NextEnabledTap(NULL
);
2396 LOG_ERROR("There are no enabled taps?");
2397 return ERROR_JTAG_INIT_FAILED
;
2401 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
2404 /* examine chain first, as this could discover the real chain layout */
2405 if (jtag_examine_chain() != ERROR_OK
)
2407 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2410 if (jtag_validate_chain() != ERROR_OK
)
2412 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2418 int jtag_interface_quit(void)
2420 if (!jtag
|| !jtag
->quit
)
2423 // close the JTAG interface
2424 int result
= jtag
->quit();
2425 if (ERROR_OK
!= result
)
2426 LOG_ERROR("failed: %d", result
);
2432 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
2436 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2439 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2441 /* Reset can happen after a power cycle.
2443 * Ideally we would only assert TRST or run RESET before the target reset.
2445 * However w/srst_pulls_trst, trst is asserted together with the target
2446 * reset whether we want it or not.
2448 * NB! Some targets have JTAG circuitry disabled until a
2449 * trst & srst has been asserted.
2451 * NB! here we assume nsrst/ntrst delay are sufficient!
2453 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2456 jtag_add_reset(1, 0); /* RESET or TRST */
2457 if (jtag_reset_config
& RESET_HAS_SRST
)
2459 jtag_add_reset(1, 1);
2460 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
2461 jtag_add_reset(0, 1);
2463 jtag_add_reset(0, 0);
2464 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2467 /* Check that we can communication on the JTAG chain + eventually we want to
2468 * be able to perform enumeration only after OpenOCD has started
2469 * telnet and GDB server
2471 * That would allow users to more easily perform any magic they need to before
2474 return jtag_init_inner(cmd_ctx
);
2477 int jtag_init(struct command_context_s
*cmd_ctx
)
2480 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2482 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
2486 return jtag_init_reset(cmd_ctx
);
2489 static int default_khz(int khz
, int *jtag_speed
)
2491 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2495 static int default_speed_div(int speed
, int *khz
)
2497 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2501 static int default_power_dropout(int *dropout
)
2503 *dropout
=0; /* by default we can't detect power dropout */
2507 static int default_srst_asserted(int *srst_asserted
)
2509 *srst_asserted
=0; /* by default we can't detect srst asserted */
2513 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2518 /* check whether the interface is already configured */
2521 LOG_WARNING("Interface already configured, ignoring");
2525 /* interface name is a mandatory argument */
2526 if (argc
< 1 || args
[0][0] == '\0')
2528 return ERROR_COMMAND_SYNTAX_ERROR
;
2531 for (i
=0; jtag_interfaces
[i
]; i
++)
2533 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
2535 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
2540 jtag_interface
= jtag_interfaces
[i
];
2542 if (jtag_interface
->khz
== NULL
)
2544 jtag_interface
->khz
= default_khz
;
2546 if (jtag_interface
->speed_div
== NULL
)
2548 jtag_interface
->speed_div
= default_speed_div
;
2550 if (jtag_interface
->power_dropout
== NULL
)
2552 jtag_interface
->power_dropout
= default_power_dropout
;
2554 if (jtag_interface
->srst_asserted
== NULL
)
2556 jtag_interface
->srst_asserted
= default_srst_asserted
;
2563 /* no valid interface was found (i.e. the configuration option,
2564 * didn't match one of the compiled-in interfaces
2566 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
2567 LOG_ERROR("compiled-in jtag interfaces:");
2568 for (i
= 0; jtag_interfaces
[i
]; i
++)
2570 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
2573 return ERROR_JTAG_INVALID_INTERFACE
;
2576 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2580 Jim_Obj
*newargs
[ 10 ];
2583 * argv[-1] = command
2584 * argv[ 0] = ir length
2585 * argv[ 1] = ir capture
2586 * argv[ 2] = ir mask
2587 * argv[ 3] = not actually used by anything but in the docs
2591 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2594 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2595 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2599 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2600 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2601 command_print( cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2602 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
2604 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
2605 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
2606 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
2607 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
2608 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
2609 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
2610 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
2611 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
2612 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
2613 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
2614 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
2615 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
2617 command_print( cmd_ctx
, "NEW COMMAND:");
2618 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
2619 Jim_GetString( newargs
[0], NULL
),
2620 Jim_GetString( newargs
[1], NULL
),
2621 Jim_GetString( newargs
[2], NULL
),
2622 Jim_GetString( newargs
[3], NULL
),
2623 Jim_GetString( newargs
[4], NULL
),
2624 Jim_GetString( newargs
[5], NULL
),
2625 Jim_GetString( newargs
[6], NULL
),
2626 Jim_GetString( newargs
[7], NULL
),
2627 Jim_GetString( newargs
[8], NULL
),
2628 Jim_GetString( newargs
[9], NULL
) );
2630 e
= jim_jtag_command( interp
, 10, newargs
);
2632 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
2637 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2641 tap
= jtag_all_taps
;
2642 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2643 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
2646 u32 expected
, expected_mask
, cur_instr
, ii
;
2647 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
2648 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
2649 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
2651 command_print(cmd_ctx
,
2652 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2653 tap
->abs_chain_position
,
2655 tap
->enabled
? 'Y' : 'n',
2657 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
2663 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
2664 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
2665 tap
->expected_ids
[ii
]);
2668 tap
= tap
->next_tap
;
2674 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2680 return ERROR_COMMAND_SYNTAX_ERROR
;
2682 /* Original versions cared about the order of these tokens:
2683 * reset_config signals [combination [trst_type [srst_type]]]
2684 * They also clobbered the previous configuration even on error.
2686 * Here we don't care about the order, and only change values
2687 * which have been explicitly specified.
2689 for (; argc
; argc
--, args
++) {
2694 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
2695 if (strcmp(*args
, "none") == 0)
2697 else if (strcmp(*args
, "trst_only") == 0)
2698 tmp
= RESET_HAS_TRST
;
2699 else if (strcmp(*args
, "srst_only") == 0)
2700 tmp
= RESET_HAS_SRST
;
2701 else if (strcmp(*args
, "trst_and_srst") == 0)
2702 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
2706 LOG_ERROR("extra reset_config %s spec (%s)",
2708 return ERROR_INVALID_ARGUMENTS
;
2713 /* combination (options for broken wiring) */
2714 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2715 if (strcmp(*args
, "separate") == 0)
2716 /* separate reset lines - default */;
2717 else if (strcmp(*args
, "srst_pulls_trst") == 0)
2718 tmp
|= RESET_SRST_PULLS_TRST
;
2719 else if (strcmp(*args
, "trst_pulls_srst") == 0)
2720 tmp
|= RESET_TRST_PULLS_SRST
;
2721 else if (strcmp(*args
, "combined") == 0)
2722 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2726 LOG_ERROR("extra reset_config %s spec (%s)",
2727 "combination", *args
);
2728 return ERROR_INVALID_ARGUMENTS
;
2733 /* trst_type (NOP without HAS_TRST) */
2734 m
= RESET_TRST_OPEN_DRAIN
;
2735 if (strcmp(*args
, "trst_open_drain") == 0)
2736 tmp
|= RESET_TRST_OPEN_DRAIN
;
2737 else if (strcmp(*args
, "trst_push_pull") == 0)
2738 /* push/pull from adapter - default */;
2742 LOG_ERROR("extra reset_config %s spec (%s)",
2743 "trst_type", *args
);
2744 return ERROR_INVALID_ARGUMENTS
;
2749 /* srst_type (NOP without HAS_SRST) */
2750 m
|= RESET_SRST_PUSH_PULL
;
2751 if (strcmp(*args
, "srst_push_pull") == 0)
2752 tmp
|= RESET_SRST_PUSH_PULL
;
2753 else if (strcmp(*args
, "srst_open_drain") == 0)
2754 /* open drain from adapter - default */;
2758 LOG_ERROR("extra reset_config %s spec (%s)",
2759 "srst_type", *args
);
2760 return ERROR_INVALID_ARGUMENTS
;
2765 /* caller provided nonsense; fail */
2766 LOG_ERROR("unknown reset_config flag (%s)", *args
);
2767 return ERROR_INVALID_ARGUMENTS
;
2770 /* Remember the bits which were specified (mask)
2771 * and their new values (new_cfg).
2777 /* clear previous values of those bits, save new values */
2778 jtag_reset_config
&= ~mask
;
2779 jtag_reset_config
|= new_cfg
;
2784 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2788 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2793 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2799 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2803 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2808 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2814 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2816 int retval
=ERROR_OK
;
2820 LOG_DEBUG("handle jtag speed");
2823 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2825 /* this command can be called during CONFIG,
2826 * in which case jtag isn't initialized */
2829 retval
=jtag
->speed(cur_speed
);
2831 } else if (argc
== 0)
2835 return ERROR_COMMAND_SYNTAX_ERROR
;
2837 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2842 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2844 int retval
=ERROR_OK
;
2845 LOG_DEBUG("handle jtag khz");
2849 speed_khz
= strtoul(args
[0], NULL
, 0);
2853 LOG_DEBUG("have interface set up");
2855 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2861 cur_speed
= jtag_speed
= speed_div1
;
2863 retval
=jtag
->speed(cur_speed
);
2872 return ERROR_COMMAND_SYNTAX_ERROR
;
2877 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2883 command_print(cmd_ctx
, "RCLK - adaptive");
2886 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2892 static int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2898 return ERROR_COMMAND_SYNTAX_ERROR
;
2902 state
= tap_state_by_name( args
[0] );
2904 command_print( cmd_ctx
, "Invalid state name: %s\n", args
[0] );
2905 return ERROR_COMMAND_SYNTAX_ERROR
;
2907 jtag_add_end_state(state
);
2908 jtag_execute_queue();
2910 command_print(cmd_ctx
, "current endstate: %s", tap_state_name(cmd_queue_end_state
));
2915 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2922 return ERROR_COMMAND_SYNTAX_ERROR
;
2925 if (args
[0][0] == '1')
2927 else if (args
[0][0] == '0')
2931 return ERROR_COMMAND_SYNTAX_ERROR
;
2934 if (args
[1][0] == '1')
2936 else if (args
[1][0] == '0')
2940 return ERROR_COMMAND_SYNTAX_ERROR
;
2943 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2944 return ERROR_JTAG_INIT_FAILED
;
2946 jtag_add_reset(trst
, srst
);
2947 jtag_execute_queue();
2952 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2956 return ERROR_COMMAND_SYNTAX_ERROR
;
2959 jtag_add_runtest(strtol(args
[0], NULL
, 0), TAP_INVALID
);
2960 jtag_execute_queue();
2967 * For "irscan" or "drscan" commands, the "end" (really, "next") state
2968 * should be stable ... and *NOT* a shift state, otherwise free-running
2969 * jtag clocks could change the values latched by the update state.
2971 static bool scan_is_safe(tap_state_t state
)
2986 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2989 scan_field_t
*fields
;
2991 tap_state_t endstate
;
2993 if ((argc
< 2) || (argc
% 2))
2995 return ERROR_COMMAND_SYNTAX_ERROR
;
2998 /* optional "-endstate" "statename" at the end of the arguments,
2999 * so that e.g. IRPAUSE can let us load the data register before
3000 * entering RUN/IDLE to execute the instruction we load here.
3002 endstate
= TAP_IDLE
;
3005 /* have at least one pair of numbers. */
3006 /* is last pair the magic text? */
3007 if( 0 == strcmp( "-endstate", args
[ argc
- 2 ] ) ){
3010 cpA
= args
[ argc
-1 ];
3011 for( endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++ ){
3012 cpS
= tap_state_name( endstate
);
3013 if( 0 == strcmp( cpA
, cpS
) ){
3017 if( endstate
>= TAP_NUM_STATES
){
3018 return ERROR_COMMAND_SYNTAX_ERROR
;
3020 if (!scan_is_safe(endstate
))
3021 LOG_WARNING("irscan with unsafe "
3022 "endstate \"%s\"", cpA
);
3023 /* found - remove the last 2 args */
3029 int num_fields
= argc
/ 2;
3031 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
3033 for (i
= 0; i
< num_fields
; i
++)
3035 tap
= jtag_TapByString( args
[i
*2] );
3038 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
3041 int field_size
= tap
->ir_length
;
3042 fields
[i
].tap
= tap
;
3043 fields
[i
].num_bits
= field_size
;
3044 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
3045 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
3046 fields
[i
].in_value
= NULL
;
3049 /* did we have an endstate? */
3050 jtag_add_ir_scan(num_fields
, fields
, endstate
);
3052 int retval
=jtag_execute_queue();
3054 for (i
= 0; i
< num_fields
; i
++)
3055 free(fields
[i
].out_value
);
3062 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
3065 scan_field_t
*fields
;
3067 int field_count
= 0;
3070 tap_state_t endstate
;
3073 * args[2] = num_bits
3074 * args[3] = hex string
3075 * ... repeat num bits and hex string ...
3078 * args[N-2] = "-endstate"
3079 * args[N-1] = statename
3081 if ((argc
< 4) || ((argc
% 2)!=0))
3083 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
3087 endstate
= TAP_IDLE
;
3089 /* validate arguments as numbers */
3091 for (i
= 2; i
< argc
; i
+=2)
3096 e
= Jim_GetLong(interp
, args
[i
], &bits
);
3097 /* If valid - try next arg */
3102 /* Not valid.. are we at the end? */
3103 if ( ((i
+2) != argc
) ){
3104 /* nope, then error */
3108 /* it could be: "-endstate FOO"
3109 * e.g. DRPAUSE so we can issue more instructions
3110 * before entering RUN/IDLE and executing them.
3113 /* get arg as a string. */
3114 cp
= Jim_GetString( args
[i
], NULL
);
3115 /* is it the magic? */
3116 if( 0 == strcmp( "-endstate", cp
) ){
3117 /* is the statename valid? */
3118 cp
= Jim_GetString( args
[i
+1], NULL
);
3120 /* see if it is a valid state name */
3121 endstate
= tap_state_by_name(cp
);
3123 /* update the error message */
3124 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
3126 if (!scan_is_safe(endstate
))
3127 LOG_WARNING("drscan with unsafe "
3128 "endstate \"%s\"", cp
);
3130 /* valid - so clear the error */
3132 /* and remove the last 2 args */
3137 /* Still an error? */
3139 return e
; /* too bad */
3141 } /* validate args */
3143 tap
= jtag_TapByJimObj( interp
, args
[1] );
3148 num_fields
=(argc
-2)/2;
3149 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
3150 for (i
= 2; i
< argc
; i
+=2)
3156 Jim_GetLong(interp
, args
[i
], &bits
);
3157 str
= Jim_GetString(args
[i
+1], &len
);
3159 fields
[field_count
].tap
= tap
;
3160 fields
[field_count
].num_bits
= bits
;
3161 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
3162 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
3163 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
3167 jtag_add_dr_scan(num_fields
, fields
, endstate
);
3169 retval
= jtag_execute_queue();
3170 if (retval
!= ERROR_OK
)
3172 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
3177 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
3178 for (i
= 2; i
< argc
; i
+=2)
3183 Jim_GetLong(interp
, args
[i
], &bits
);
3184 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
3185 free(fields
[field_count
].out_value
);
3187 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
3192 Jim_SetResult(interp
, list
);
3200 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
3202 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_flush_queue_count
));
3208 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3212 if (strcmp(args
[0], "enable") == 0)
3214 jtag_verify_capture_ir
= 1;
3216 else if (strcmp(args
[0], "disable") == 0)
3218 jtag_verify_capture_ir
= 0;
3221 return ERROR_COMMAND_SYNTAX_ERROR
;
3223 } else if (argc
!= 0)
3225 return ERROR_COMMAND_SYNTAX_ERROR
;
3228 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
3233 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3237 if (strcmp(args
[0], "enable") == 0)
3241 else if (strcmp(args
[0], "disable") == 0)
3246 return ERROR_COMMAND_SYNTAX_ERROR
;
3248 } else if (argc
!= 0)
3250 return ERROR_COMMAND_SYNTAX_ERROR
;
3253 command_print(cmd_ctx
, "verify jtag capture is %s", (jtag_verify
) ? "enabled": "disabled");
3259 int jtag_power_dropout(int *dropout
)
3261 return jtag
->power_dropout(dropout
);
3264 int jtag_srst_asserted(int *srst_asserted
)
3266 return jtag
->srst_asserted(srst_asserted
);
3269 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
3271 jtag_tap_event_action_t
* jteap
;
3274 jteap
= tap
->event_action
;
3278 if (jteap
->event
== e
) {
3280 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3283 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
3284 Jim_GetString(jteap
->body
, NULL
) );
3285 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
3286 Jim_PrintErrorMessage(interp
);
3290 jteap
= jteap
->next
;
3294 LOG_DEBUG( "event %d %s - no action",
3296 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
3300 /*-----<Cable Helper API>---------------------------------------*/
3302 /* these Cable Helper API functions are all documented in the jtag.h header file,
3303 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3304 is setup to prefer its docs in the header file, no documentation is here, for
3305 if it were, it would have to be doubly maintained.
3309 * @see tap_set_state() and tap_get_state() accessors.
3310 * Actual name is not important since accessors hide it.
3312 static tap_state_t state_follower
= TAP_RESET
;
3314 void tap_set_state_impl( tap_state_t new_state
)
3316 /* this is the state we think the TAPs are in now, was cur_state */
3317 state_follower
= new_state
;
3320 tap_state_t
tap_get_state()
3322 return state_follower
;
3326 * @see tap_set_end_state() and tap_get_end_state() accessors.
3327 * Actual name is not important because accessors hide it.
3329 static tap_state_t end_state_follower
= TAP_RESET
;
3331 void tap_set_end_state( tap_state_t new_end_state
)
3333 /* this is the state we think the TAPs will be in at completion of the
3334 current TAP operation, was end_state
3336 end_state_follower
= new_end_state
;
3339 tap_state_t
tap_get_end_state()
3341 return end_state_follower
;
3345 int tap_move_ndx( tap_state_t astate
)
3347 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3353 case TAP_RESET
: ndx
= 0; break;
3354 case TAP_DRSHIFT
: ndx
= 2; break;
3355 case TAP_DRPAUSE
: ndx
= 3; break;
3356 case TAP_IDLE
: ndx
= 1; break;
3357 case TAP_IRSHIFT
: ndx
= 4; break;
3358 case TAP_IRPAUSE
: ndx
= 5; break;
3360 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate
) );
3368 /* tap_move[i][j]: tap movement command to go from state i to state j
3369 * 0: Test-Logic-Reset
3376 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3378 struct tms_sequences
3386 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3387 * Read the bits from LSBit first to MSBit last (right-to-left).
3389 #define HEX__(n) 0x##n##LU
3392 (((x) & 0x0000000FLU)?(1<<0):0) \
3393 +(((x) & 0x000000F0LU)?(1<<1):0) \
3394 +(((x) & 0x00000F00LU)?(1<<2):0) \
3395 +(((x) & 0x0000F000LU)?(1<<3):0) \
3396 +(((x) & 0x000F0000LU)?(1<<4):0) \
3397 +(((x) & 0x00F00000LU)?(1<<5):0) \
3398 +(((x) & 0x0F000000LU)?(1<<6):0) \
3399 +(((x) & 0xF0000000LU)?(1<<7):0)
3401 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3403 static const struct tms_sequences old_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
3405 /* value clocked to TMS to move from one of six stable states to another.
3406 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3407 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3408 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3409 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3415 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3416 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3417 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3418 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3419 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3420 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3421 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* IRPAUSE */
3426 static const struct tms_sequences short_tms_seqs
[6][6] = /* [from_state_ndx][to_state_ndx] */
3428 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3430 OK, I added Peter's version of the state table, and it works OK for
3431 me on MC1322x. I've recreated the jlink portion of patch with this
3432 new state table. His changes to my state table are pretty minor in
3433 terms of total transitions, but Peter feels that his version fixes
3434 some long-standing problems.
3437 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3440 state specific comments:
3441 ------------------------
3442 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3443 work better on ARM9 with ft2232 driver. (Dick)
3445 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3446 needed on ARM9 with ft2232 driver. (Dick)
3448 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3449 needed on ARM9 with ft2232 driver. (Dick)
3453 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3454 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3455 { B8(1111111,7), B8(0000000,7), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3456 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3457 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3458 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3459 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3463 typedef const struct tms_sequences tms_table
[6][6];
3465 static tms_table
*tms_seqs
=&short_tms_seqs
;
3467 int tap_get_tms_path( tap_state_t from
, tap_state_t to
)
3469 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bits
;
3473 int tap_get_tms_path_len( tap_state_t from
, tap_state_t to
)
3475 return (*tms_seqs
)[tap_move_ndx(from
)][tap_move_ndx(to
)].bit_count
;
3479 bool tap_is_state_stable(tap_state_t astate
)
3483 /* A switch() is used because it is symbol dependent
3484 (not value dependent like an array), and can also check bounds.
3503 tap_state_t
tap_state_transition(tap_state_t cur_state
, bool tms
)
3505 tap_state_t new_state
;
3507 /* A switch is used because it is symbol dependent and not value dependent
3508 like an array. Also it can check for out of range conditions.
3516 new_state
= cur_state
;
3521 new_state
= TAP_DRSELECT
;
3524 new_state
= TAP_IRSELECT
;
3528 new_state
= TAP_DREXIT1
;
3532 new_state
= TAP_DRUPDATE
;
3535 new_state
= TAP_DREXIT2
;
3538 new_state
= TAP_RESET
;
3542 new_state
= TAP_IREXIT1
;
3546 new_state
= TAP_IRUPDATE
;
3549 new_state
= TAP_IREXIT2
;
3552 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3565 new_state
= TAP_IDLE
;
3568 new_state
= TAP_DRCAPTURE
;
3573 new_state
= TAP_DRSHIFT
;
3577 new_state
= TAP_DRPAUSE
;
3580 new_state
= TAP_IRCAPTURE
;
3585 new_state
= TAP_IRSHIFT
;
3589 new_state
= TAP_IRPAUSE
;
3592 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state
);
3601 const char* tap_state_name(tap_state_t state
)
3607 case TAP_RESET
: ret
= "RESET"; break;
3608 case TAP_IDLE
: ret
= "RUN/IDLE"; break;
3609 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
3610 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
3611 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
3612 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
3613 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
3614 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
3615 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
3616 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
3617 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
3618 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
3619 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
3620 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
3621 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
3622 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
3623 default: ret
= "???";
3629 static tap_state_t
tap_state_by_name( const char *name
)
3633 for( x
= 0 ; x
< TAP_NUM_STATES
; x
++ ){
3634 /* be nice to the human */
3635 if( 0 == strcasecmp( name
, tap_state_name(x
) ) ){
3643 #ifdef _DEBUG_JTAG_IO_
3645 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3646 do { buf[len] = bit ? '1' : '0'; } while(0)
3647 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3648 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3649 tap_state_name(a), tap_state_name(b), astr, bstr)
3651 tap_state_t
jtag_debug_state_machine(const void *tms_buf
, const void *tdi_buf
,
3652 unsigned tap_bits
, tap_state_t next_state
)
3654 const u8
*tms_buffer
;
3655 const u8
*tdi_buffer
;
3660 unsigned tap_out_bits
;
3664 tap_state_t last_state
;
3666 // set startstate (and possibly last, if tap_bits == 0)
3667 last_state
= next_state
;
3668 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state
));
3670 tms_buffer
= (const u8
*)tms_buf
;
3671 tdi_buffer
= (const u8
*)tdi_buf
;
3673 tap_bytes
= TAP_SCAN_BYTES(tap_bits
);
3674 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits
, tap_bytes
);
3677 for(cur_byte
= 0; cur_byte
< tap_bytes
; cur_byte
++)
3679 for(cur_bit
= 0; cur_bit
< 8; cur_bit
++)
3681 // make sure we do not run off the end of the buffers
3682 unsigned tap_bit
= cur_byte
* 8 + cur_bit
;
3683 if (tap_bit
== tap_bits
)
3686 // check and save TMS bit
3687 tap_bit
= !!(tms_buffer
[cur_byte
] & (1 << cur_bit
));
3688 JTAG_DEBUG_STATE_APPEND(tms_str
, tap_out_bits
, tap_bit
);
3690 // use TMS bit to find the next TAP state
3691 next_state
= tap_state_transition(last_state
, tap_bit
);
3693 // check and store TDI bit
3694 tap_bit
= !!(tdi_buffer
[cur_byte
] & (1 << cur_bit
));
3695 JTAG_DEBUG_STATE_APPEND(tdi_str
, tap_out_bits
, tap_bit
);
3697 // increment TAP bits
3700 // Only show TDO bits on state transitions, or
3701 // after some number of bits in the same state.
3702 if ((next_state
== last_state
) && (tap_out_bits
< 32))
3705 // terminate strings and display state transition
3706 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3707 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3710 last_state
= next_state
;
3717 // terminate strings and display state transition
3718 tms_str
[tap_out_bits
] = tdi_str
[tap_out_bits
] = 0;
3719 JTAG_DEBUG_STATE_PRINT(last_state
, next_state
, tms_str
, tdi_str
);
3722 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state
));
3726 #endif // _DEBUG_JTAG_IO_
3728 #ifndef HAVE_JTAG_MINIDRIVER_H
3729 void jtag_alloc_in_value32(scan_field_t
*field
)
3731 field
->in_value
=(u8
*)cmd_queue_alloc(4);
3735 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
3739 if (strcmp(args
[0], "short") == 0)
3741 tms_seqs
=&short_tms_seqs
;
3743 else if (strcmp(args
[0], "long") == 0)
3745 tms_seqs
=&old_tms_seqs
;
3748 return ERROR_COMMAND_SYNTAX_ERROR
;
3750 } else if (argc
!= 0)
3752 return ERROR_COMMAND_SYNTAX_ERROR
;
3755 command_print(cmd_ctx
, "tms sequence is %s", (tms_seqs
==&short_tms_seqs
) ? "short": "long");
3760 /*-----</Cable Helper API>--------------------------------------*/
3764 * Function jtag_add_statemove
3765 * moves from the current state to the goal \a state. This needs
3766 * to be handled according to the xsvf spec, see the XSTATE command
3769 int jtag_add_statemove(tap_state_t goal_state
)
3771 int retval
= ERROR_OK
;
3773 tap_state_t moves
[8];
3774 tap_state_t cur_state
= cmd_queue_cur_state
;
3779 LOG_DEBUG( "cur_state=%s goal_state=%s",
3780 tap_state_name(cur_state
),
3781 tap_state_name(goal_state
) );
3784 /* From the XSVF spec, pertaining to XSTATE:
3786 For special states known as stable states (Test-Logic-Reset,
3787 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
3788 predefined TAP state paths when the starting state is a stable state and
3789 when the XSTATE specifies a new stable state (see the STATE command in
3790 the [Ref 5] for the TAP state paths between stable states). For
3791 non-stable states, XSTATE should specify a state that is only one TAP
3792 state transition distance from the current TAP state to avoid undefined
3793 TAP state paths. A sequence of multiple XSTATE commands can be issued to
3794 transition the TAP through a specific state path.
3797 if (goal_state
==cur_state
)
3798 ; /* nothing to do */
3800 else if( goal_state
==TAP_RESET
)
3805 else if( tap_is_state_stable(cur_state
) && tap_is_state_stable(goal_state
) )
3807 /* note: unless tms_bits holds a path that agrees with [Ref 5] in above
3808 spec, then this code is not fully conformant to the xsvf spec. This
3809 puts a burden on tap_get_tms_path() function from the xsvf spec.
3810 If in doubt, you should confirm that that burden is being met.
3813 tms_bits
= tap_get_tms_path(cur_state
, goal_state
);
3814 tms_count
= tap_get_tms_path_len(cur_state
, goal_state
);
3816 assert( (unsigned) tms_count
< DIM(moves
) );
3818 for (i
=0; i
<tms_count
; i
++, tms_bits
>>=1)
3820 bool bit
= tms_bits
& 1;
3822 cur_state
= tap_state_transition(cur_state
, bit
);
3823 moves
[i
] = cur_state
;
3826 jtag_add_pathmove(tms_count
, moves
);
3829 /* else state must be immediately reachable in one clock cycle, and does not
3830 need to be a stable state.
3832 else if( tap_state_transition(cur_state
, true) == goal_state
3833 || tap_state_transition(cur_state
, false) == goal_state
)
3835 /* move a single state */
3836 moves
[0] = goal_state
;
3837 jtag_add_pathmove( 1, moves
);
3842 retval
= ERROR_FAIL
;