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 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include "replacements.h"
38 /* note that this is not marked as static as it must be available from outside jtag.c for those
39 that implement the jtag_xxx() minidriver layer
41 int jtag_error
=ERROR_OK
;
43 typedef struct cmd_queue_page_s
47 struct cmd_queue_page_s
*next
;
50 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
51 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
53 /* tap_move[i][j]: tap movement command to go from state i to state j
61 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
65 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
66 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* RESET */
67 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* IDLE */
68 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* DRSHIFT */
69 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* DRPAUSE */
70 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* IRSHIFT */
71 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* IRPAUSE */
74 int tap_move_map
[16] = {
75 0, -1, -1, 2, -1, 3, -1, -1,
76 1, -1, -1, 4, -1, 5, -1, -1
79 tap_transition_t tap_transitions
[16] =
81 {TAP_RESET
, TAP_IDLE
}, /* RESET */
82 {TAP_IRSELECT
, TAP_DRCAPTURE
}, /* DRSELECT */
83 {TAP_DREXIT1
, TAP_DRSHIFT
}, /* DRCAPTURE */
84 {TAP_DREXIT1
, TAP_DRSHIFT
}, /* DRSHIFT */
85 {TAP_DRUPDATE
, TAP_DRPAUSE
}, /* DREXIT1 */
86 {TAP_DREXIT2
, TAP_DRPAUSE
}, /* DRPAUSE */
87 {TAP_DRUPDATE
, TAP_DRSHIFT
}, /* DREXIT2 */
88 {TAP_DRSELECT
, TAP_IDLE
}, /* DRUPDATE */
89 {TAP_DRSELECT
, TAP_IDLE
}, /* IDLE */
90 {TAP_RESET
, TAP_IRCAPTURE
}, /* IRSELECT */
91 {TAP_IREXIT1
, TAP_IRSHIFT
}, /* IRCAPTURE */
92 {TAP_IREXIT1
, TAP_IRSHIFT
}, /* IRSHIFT */
93 {TAP_IRUPDATE
, TAP_IRPAUSE
}, /* IREXIT1 */
94 {TAP_IREXIT2
, TAP_IRPAUSE
}, /* IRPAUSE */
95 {TAP_IRUPDATE
, TAP_IRSHIFT
}, /* IREXIT2 */
96 {TAP_DRSELECT
, TAP_IDLE
} /* IRUPDATE */
99 char* jtag_event_strings
[] =
101 "JTAG controller reset (RESET or TRST)"
104 const Jim_Nvp nvp_jtag_tap_event
[] = {
105 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
106 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
108 { .name
= NULL
, .value
= -1 }
111 /* kludge!!!! these are just global variables that the
112 * interface use internally. They really belong
113 * inside the drivers, but we don't want to break
114 * linking the drivers!!!!
116 enum tap_state end_state
= TAP_RESET
;
117 enum tap_state cur_state
= TAP_RESET
;
121 jtag_command_t
*jtag_command_queue
= NULL
;
122 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
123 static jtag_tap_t
*jtag_all_taps
= NULL
;
125 enum reset_types jtag_reset_config
= RESET_NONE
;
126 enum tap_state cmd_queue_end_state
= TAP_RESET
;
127 enum tap_state cmd_queue_cur_state
= TAP_RESET
;
129 int jtag_verify_capture_ir
= 1;
131 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
132 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
133 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
135 /* maximum number of JTAG devices expected in the chain
137 #define JTAG_MAX_CHAIN_SIZE 20
139 /* callbacks to inform high-level handlers about JTAG state changes */
140 jtag_event_callback_t
*jtag_event_callbacks
;
143 static int speed_khz
= 0;
144 /* flag if the kHz speed was defined */
145 static int hasKHz
= 0;
147 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
150 #if BUILD_ECOSBOARD == 1
151 extern jtag_interface_t zy1000_interface
;
154 #if BUILD_PARPORT == 1
155 extern jtag_interface_t parport_interface
;
159 extern jtag_interface_t dummy_interface
;
162 #if BUILD_FT2232_FTD2XX == 1
163 extern jtag_interface_t ft2232_interface
;
166 #if BUILD_FT2232_LIBFTDI == 1
167 extern jtag_interface_t ft2232_interface
;
170 #if BUILD_AMTJTAGACCEL == 1
171 extern jtag_interface_t amt_jtagaccel_interface
;
174 #if BUILD_EP93XX == 1
175 extern jtag_interface_t ep93xx_interface
;
178 #if BUILD_AT91RM9200 == 1
179 extern jtag_interface_t at91rm9200_interface
;
182 #if BUILD_GW16012 == 1
183 extern jtag_interface_t gw16012_interface
;
186 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
187 extern jtag_interface_t presto_interface
;
190 #if BUILD_USBPROG == 1
191 extern jtag_interface_t usbprog_interface
;
195 extern jtag_interface_t jlink_interface
;
198 #if BUILD_VSLLINK == 1
199 extern jtag_interface_t vsllink_interface
;
203 extern jtag_interface_t rlink_interface
;
206 jtag_interface_t
*jtag_interfaces
[] = {
207 #if BUILD_ECOSBOARD == 1
210 #if BUILD_PARPORT == 1
216 #if BUILD_FT2232_FTD2XX == 1
219 #if BUILD_FT2232_LIBFTDI == 1
222 #if BUILD_AMTJTAGACCEL == 1
223 &amt_jtagaccel_interface
,
225 #if BUILD_EP93XX == 1
228 #if BUILD_AT91RM9200 == 1
229 &at91rm9200_interface
,
231 #if BUILD_GW16012 == 1
234 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
237 #if BUILD_USBPROG == 1
243 #if BUILD_VSLLINK == 1
252 jtag_interface_t
*jtag
= NULL
;
255 jtag_interface_t
*jtag_interface
= NULL
;
258 /* forward declarations */
259 void jtag_add_pathmove(int num_states
, enum tap_state
*path
);
260 void jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
261 void jtag_add_end_state(enum tap_state endstate
);
262 void jtag_add_sleep(u32 us
);
263 int jtag_execute_queue(void);
267 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
268 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
269 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
270 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
271 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
272 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
273 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
275 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
277 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
278 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
279 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
280 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
281 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
283 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
285 jtag_tap_t
*jtag_AllTaps(void)
287 return jtag_all_taps
;
290 int jtag_NumTotalTaps(void)
304 int jtag_NumEnabledTaps(void)
321 jtag_tap_t
*jtag_TapByString( const char *s
)
329 if( 0 == strcmp( t
->dotted_name
, s
) ){
335 // backup plan is by number
337 /* ok - is "s" a number? */
339 n
= strtol( s
, &cp
, 0 );
340 if( (s
!= cp
) && (*cp
== 0) ){
342 t
= jtag_TapByAbsPosition(n
);
348 jtag_tap_t
* jtag_TapByJimObj( Jim_Interp
*interp
, Jim_Obj
*o
)
353 cp
= Jim_GetString( o
, NULL
);
358 t
= jtag_TapByString( cp
);
361 Jim_SetResult_sprintf(interp
,"Tap: %s is unknown", cp
);
366 /* returns a pointer to the n-th device in the scan chain */
367 jtag_tap_t
* jtag_TapByAbsPosition( int n
)
375 while( t
&& (n
> 0)) {
382 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
384 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
386 if (callback
== NULL
)
388 return ERROR_INVALID_ARGUMENTS
;
393 while ((*callbacks_p
)->next
)
394 callbacks_p
= &((*callbacks_p
)->next
);
395 callbacks_p
= &((*callbacks_p
)->next
);
398 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
399 (*callbacks_p
)->callback
= callback
;
400 (*callbacks_p
)->priv
= priv
;
401 (*callbacks_p
)->next
= NULL
;
406 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
408 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
410 if (callback
== NULL
)
412 return ERROR_INVALID_ARGUMENTS
;
417 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
418 if ((*callbacks_p
)->callback
== callback
)
421 *callbacks_p
= *next
;
429 int jtag_call_event_callbacks(enum jtag_event event
)
431 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
433 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
437 callback
->callback(event
, callback
->priv
);
438 callback
= callback
->next
;
444 /* returns a pointer to the pointer of the last command in queue
445 * this may be a pointer to the root pointer (jtag_command_queue)
446 * or to the next member of the last but one command
448 jtag_command_t
** jtag_get_last_command_p(void)
450 /* jtag_command_t *cmd = jtag_command_queue;
456 return &jtag_command_queue;
460 return last_comand_pointer
;
463 void* cmd_queue_alloc(size_t size
)
465 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
471 * We align/round the *SIZE* per below
472 * so that all pointers returned by
473 * this function are reasonably well
476 * If we did not, then an "odd-length" request would cause the
477 * *next* allocation to be at an *odd* address, and because
478 * this function has the same type of api as malloc() - we
479 * must also return pointers that have the same type of
482 * What I do not/have is a reasonable portable means
485 * The solution here, is based on these suggestions.
486 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
489 union worse_case_align
{
495 #define ALIGN_SIZE (sizeof(union worse_case_align))
497 /* The alignment process. */
498 size
= (size
+ ALIGN_SIZE
-1) & (~(ALIGN_SIZE
-1));
503 while ((*p_page
)->next
)
504 p_page
= &((*p_page
)->next
);
505 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
506 p_page
= &((*p_page
)->next
);
511 *p_page
= malloc(sizeof(cmd_queue_page_t
));
513 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
514 (*p_page
)->next
= NULL
;
517 offset
= (*p_page
)->used
;
518 (*p_page
)->used
+= size
;
520 t
=(u8
*)((*p_page
)->address
);
524 void cmd_queue_free(void)
526 cmd_queue_page_t
*page
= cmd_queue_pages
;
530 cmd_queue_page_t
*last
= page
;
536 cmd_queue_pages
= NULL
;
539 static void jtag_prelude1(void)
543 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
544 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
548 if (cmd_queue_end_state
== TAP_RESET
)
549 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
552 static void jtag_prelude(enum tap_state state
)
557 jtag_add_end_state(state
);
559 cmd_queue_cur_state
= cmd_queue_end_state
;
562 void jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
568 retval
=interface_jtag_add_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
569 if (retval
!=ERROR_OK
)
573 int MINIDRIVER(interface_jtag_add_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
575 jtag_command_t
**last_cmd
;
583 last_cmd
= jtag_get_last_command_p();
585 /* allocate memory for a new list member */
586 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
587 (*last_cmd
)->next
= NULL
;
588 last_comand_pointer
= &((*last_cmd
)->next
);
589 (*last_cmd
)->type
= JTAG_SCAN
;
591 /* allocate memory for ir scan command */
592 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
593 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
594 x
= jtag_NumEnabledTaps();
595 (*last_cmd
)->cmd
.scan
->num_fields
= x
; /* one field per device */
596 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(x
* sizeof(scan_field_t
));
597 (*last_cmd
)->cmd
.scan
->end_state
= state
;
604 // do this here so it is not forgotten
605 tap
= jtag_NextEnabledTap(tap
);
610 scan_size
= tap
->ir_length
;
611 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].tap
= tap
;
612 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].num_bits
= scan_size
;
613 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_value
= NULL
;
614 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_handler
= NULL
; /* disable verification by default */
616 /* search the list */
617 for (j
= 0; j
< num_fields
; j
++)
619 if (tap
== fields
[j
].tap
)
622 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
623 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
625 if (jtag_verify_capture_ir
)
627 if (fields
[j
].in_handler
==NULL
)
629 jtag_set_check_value((*last_cmd
)->cmd
.scan
->fields
+nth_tap
, tap
->expected
, tap
->expected_mask
, NULL
);
632 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_handler
= fields
[j
].in_handler
;
633 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_handler_priv
= fields
[j
].in_handler_priv
;
634 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_check_value
= tap
->expected
;
635 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].in_check_mask
= tap
->expected_mask
;
646 /* if a tap isn't listed, set it to BYPASS */
647 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
648 (*last_cmd
)->cmd
.scan
->fields
[nth_tap
].out_mask
= NULL
;
652 /* update device information */
653 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[nth_tap
].out_value
, tap
->cur_instr
, scan_size
);
659 void jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
665 retval
=interface_jtag_add_plain_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
666 if (retval
!=ERROR_OK
)
670 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
673 jtag_command_t
**last_cmd
;
675 last_cmd
= jtag_get_last_command_p();
677 /* allocate memory for a new list member */
678 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
679 (*last_cmd
)->next
= NULL
;
680 last_comand_pointer
= &((*last_cmd
)->next
);
681 (*last_cmd
)->type
= JTAG_SCAN
;
683 /* allocate memory for ir scan command */
684 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
685 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
686 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
687 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
688 (*last_cmd
)->cmd
.scan
->end_state
= state
;
690 for( i
= 0 ; i
< num_fields
; i
++ ){
691 int num_bits
= fields
[i
].num_bits
;
692 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
693 (*last_cmd
)->cmd
.scan
->fields
[i
].tap
= fields
[i
].tap
;
694 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
695 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
696 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
697 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
698 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
699 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
700 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
701 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
706 void jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
712 retval
=interface_jtag_add_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
713 if (retval
!=ERROR_OK
)
717 int MINIDRIVER(interface_jtag_add_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
721 int bypass_devices
= 0;
725 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
728 /* count devices in bypass */
732 tap
= jtag_NextEnabledTap(tap
);
741 /* allocate memory for a new list member */
742 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
743 last_comand_pointer
= &((*last_cmd
)->next
);
744 (*last_cmd
)->next
= NULL
;
745 (*last_cmd
)->type
= JTAG_SCAN
;
747 /* allocate memory for dr scan command */
748 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
749 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
750 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
751 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
752 (*last_cmd
)->cmd
.scan
->end_state
= state
;
758 tap
= jtag_NextEnabledTap(tap
);
763 (*last_cmd
)->cmd
.scan
->fields
[field_count
].tap
= tap
;
765 for (j
= 0; j
< num_fields
; j
++)
767 if (tap
== fields
[j
].tap
)
770 scan_size
= fields
[j
].num_bits
;
771 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
772 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
773 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
774 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
775 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= fields
[j
].in_check_value
;
776 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= fields
[j
].in_check_mask
;
777 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
778 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
783 #ifdef _DEBUG_JTAG_IO_
784 /* if a device isn't listed, the BYPASS register should be selected */
787 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
791 /* program the scan field to 1 bit length, and ignore it's value */
792 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
793 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
794 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
795 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
796 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
797 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
798 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
799 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
803 #ifdef _DEBUG_JTAG_IO_
804 /* if a device is listed, the BYPASS register must not be selected */
807 LOG_ERROR("BUG: scan data for a device in BYPASS");
816 void MINIDRIVER(interface_jtag_add_dr_out
)(jtag_tap_t
*target_tap
,
820 enum tap_state end_state
)
825 int bypass_devices
= 0;
827 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
830 /* count devices in bypass */
834 tap
= jtag_NextEnabledTap(tap
);
843 /* allocate memory for a new list member */
844 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
845 last_comand_pointer
= &((*last_cmd
)->next
);
846 (*last_cmd
)->next
= NULL
;
847 (*last_cmd
)->type
= JTAG_SCAN
;
849 /* allocate memory for dr scan command */
850 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
851 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
852 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
853 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
854 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
859 tap
= jtag_NextEnabledTap(tap
);
864 (*last_cmd
)->cmd
.scan
->fields
[field_count
].tap
= tap
;
866 if (tap
== target_tap
)
869 #ifdef _DEBUG_JTAG_IO_
870 /* if a device is listed, the BYPASS register must not be selected */
873 LOG_ERROR("BUG: scan data for a device in BYPASS");
877 for (j
= 0; j
< num_fields
; j
++)
880 scan_size
= num_bits
[j
];
881 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
882 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
883 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
884 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
885 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
886 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
887 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
888 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
889 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
893 #ifdef _DEBUG_JTAG_IO_
894 /* if a device isn't listed, the BYPASS register should be selected */
897 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
901 /* program the scan field to 1 bit length, and ignore it's value */
902 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
903 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
904 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
905 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
906 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
907 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
908 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
909 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
914 void jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
920 retval
=interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
921 if (retval
!=ERROR_OK
)
925 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
928 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
930 /* allocate memory for a new list member */
931 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
932 last_comand_pointer
= &((*last_cmd
)->next
);
933 (*last_cmd
)->next
= NULL
;
934 (*last_cmd
)->type
= JTAG_SCAN
;
936 /* allocate memory for scan command */
937 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
938 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
939 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
940 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
941 (*last_cmd
)->cmd
.scan
->end_state
= state
;
943 for (i
= 0; i
< num_fields
; i
++)
945 int num_bits
= fields
[i
].num_bits
;
946 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
947 (*last_cmd
)->cmd
.scan
->fields
[i
].tap
= fields
[i
].tap
;
948 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
949 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
950 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
951 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
952 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
953 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
954 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
955 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
961 void jtag_add_tlr(void)
963 jtag_prelude(TAP_RESET
);
966 retval
=interface_jtag_add_tlr();
967 if (retval
!=ERROR_OK
)
971 int MINIDRIVER(interface_jtag_add_tlr
)(void)
973 enum tap_state state
= TAP_RESET
;
974 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
976 /* allocate memory for a new list member */
977 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
978 last_comand_pointer
= &((*last_cmd
)->next
);
979 (*last_cmd
)->next
= NULL
;
980 (*last_cmd
)->type
= JTAG_STATEMOVE
;
982 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
983 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
988 void jtag_add_pathmove(int num_states
, enum tap_state
*path
)
990 enum tap_state cur_state
=cmd_queue_cur_state
;
994 /* the last state has to be a stable state */
995 if (tap_move_map
[path
[num_states
- 1]] == -1)
997 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
1001 for (i
=0; i
<num_states
; i
++)
1003 if (path
[i
] == TAP_RESET
)
1005 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1008 if ((tap_transitions
[cur_state
].low
!= path
[i
])&&
1009 (tap_transitions
[cur_state
].high
!= path
[i
]))
1011 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state
), jtag_state_name(path
[i
]));
1014 cur_state
= path
[i
];
1019 retval
=interface_jtag_add_pathmove(num_states
, path
);
1020 cmd_queue_cur_state
= path
[num_states
- 1];
1021 if (retval
!=ERROR_OK
)
1025 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
1027 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1030 /* allocate memory for a new list member */
1031 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1032 last_comand_pointer
= &((*last_cmd
)->next
);
1033 (*last_cmd
)->next
= NULL
;
1034 (*last_cmd
)->type
= JTAG_PATHMOVE
;
1036 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
1037 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
1038 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
1040 for (i
= 0; i
< num_states
; i
++)
1041 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
1046 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
1048 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1050 /* allocate memory for a new list member */
1051 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1052 (*last_cmd
)->next
= NULL
;
1053 last_comand_pointer
= &((*last_cmd
)->next
);
1054 (*last_cmd
)->type
= JTAG_RUNTEST
;
1056 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
1057 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
1058 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
1063 void jtag_add_runtest(int num_cycles
, enum tap_state state
)
1067 jtag_prelude(state
);
1069 /* executed by sw or hw fifo */
1070 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
1071 if (retval
!=ERROR_OK
)
1076 int MINIDRIVER(interface_jtag_add_clocks
)( int num_cycles
)
1078 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1080 /* allocate memory for a new list member */
1081 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1082 (*last_cmd
)->next
= NULL
;
1083 last_comand_pointer
= &((*last_cmd
)->next
);
1084 (*last_cmd
)->type
= JTAG_STABLECLOCKS
;
1086 (*last_cmd
)->cmd
.stableclocks
= cmd_queue_alloc(sizeof(stableclocks_command_t
));
1087 (*last_cmd
)->cmd
.stableclocks
->num_cycles
= num_cycles
;
1091 void jtag_add_clocks( int num_cycles
)
1097 retval
=interface_jtag_add_clocks(num_cycles
);
1098 if (retval
!=ERROR_OK
)
1102 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
1104 int trst_with_tlr
= 0;
1107 /* FIX!!! there are *many* different cases here. A better
1108 * approach is needed for legal combinations of transitions...
1110 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
1111 (jtag_reset_config
& RESET_HAS_TRST
)&&
1112 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
1114 if (((req_tlr_or_trst
&&!jtag_trst
)||
1115 (!req_tlr_or_trst
&&jtag_trst
))&&
1116 ((req_srst
&&!jtag_srst
)||
1117 (!req_srst
&&jtag_srst
)))
1119 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1120 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1124 /* Make sure that jtag_reset_config allows the requested reset */
1125 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1126 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
1128 LOG_ERROR("BUG: requested reset would assert trst");
1129 jtag_error
=ERROR_FAIL
;
1133 /* if TRST pulls SRST, we reset with TAP T-L-R */
1134 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
1139 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
1141 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1142 jtag_error
=ERROR_FAIL
;
1146 if (req_tlr_or_trst
)
1148 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
1160 jtag_srst
= req_srst
;
1162 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
1163 if (retval
!=ERROR_OK
)
1171 LOG_DEBUG("SRST line asserted");
1175 LOG_DEBUG("SRST line released");
1176 if (jtag_nsrst_delay
)
1177 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1182 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1183 jtag_add_end_state(TAP_RESET
);
1185 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1191 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1192 * and inform possible listeners about this
1194 LOG_DEBUG("TRST line asserted");
1195 cmd_queue_cur_state
= TAP_RESET
;
1196 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1200 if (jtag_ntrst_delay
)
1201 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1205 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1207 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1209 /* allocate memory for a new list member */
1210 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1211 (*last_cmd
)->next
= NULL
;
1212 last_comand_pointer
= &((*last_cmd
)->next
);
1213 (*last_cmd
)->type
= JTAG_RESET
;
1215 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1216 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1217 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1222 void jtag_add_end_state(enum tap_state state
)
1224 cmd_queue_end_state
= state
;
1225 if ((cmd_queue_end_state
== TAP_DRSHIFT
)||(cmd_queue_end_state
== TAP_IRSHIFT
))
1227 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1231 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1233 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1235 /* allocate memory for a new list member */
1236 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1237 (*last_cmd
)->next
= NULL
;
1238 last_comand_pointer
= &((*last_cmd
)->next
);
1239 (*last_cmd
)->type
= JTAG_SLEEP
;
1241 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1242 (*last_cmd
)->cmd
.sleep
->us
= us
;
1247 void jtag_add_sleep(u32 us
)
1249 keep_alive(); /* we might be running on a very slow JTAG clk */
1250 int retval
=interface_jtag_add_sleep(us
);
1251 if (retval
!=ERROR_OK
)
1256 int jtag_scan_size(scan_command_t
*cmd
)
1261 /* count bits in scan command */
1262 for (i
= 0; i
< cmd
->num_fields
; i
++)
1264 bit_count
+= cmd
->fields
[i
].num_bits
;
1270 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1275 bit_count
= jtag_scan_size(cmd
);
1276 *buffer
= malloc(CEIL(bit_count
, 8));
1280 #ifdef _DEBUG_JTAG_IO_
1281 LOG_DEBUG("num_fields: %i",cmd
->num_fields
);
1284 for (i
= 0; i
< cmd
->num_fields
; i
++)
1286 if (cmd
->fields
[i
].out_value
)
1288 #ifdef _DEBUG_JTAG_IO_
1289 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1291 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1292 #ifdef _DEBUG_JTAG_IO_
1293 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i
, cmd
->fields
[i
].num_bits
, char_buf
);
1298 bit_count
+= cmd
->fields
[i
].num_bits
;
1299 #ifdef _DEBUG_JTAG_IO_
1300 LOG_DEBUG("bit_count totalling: %i", bit_count
);
1307 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1313 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1316 for (i
= 0; i
< cmd
->num_fields
; i
++)
1318 /* if neither in_value nor in_handler
1319 * are specified we don't have to examine this field
1321 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1323 int num_bits
= cmd
->fields
[i
].num_bits
;
1324 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1326 #ifdef _DEBUG_JTAG_IO_
1327 char *char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1328 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i
, num_bits
, char_buf
);
1332 if (cmd
->fields
[i
].in_value
)
1334 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1336 if (cmd
->fields
[i
].in_handler
)
1338 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1340 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd
->ir_scan
? "SIR" : "SDR" );
1341 retval
= ERROR_JTAG_QUEUE_FAILED
;
1346 /* no in_value specified, but a handler takes care of the scanned data */
1347 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1349 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1351 /* We're going to call the error:handler later, but if the in_handler
1352 * reported an error we report this failure upstream
1354 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd
->ir_scan
? "SIR" : "SDR" );
1355 retval
= ERROR_JTAG_QUEUE_FAILED
;
1361 bit_count
+= cmd
->fields
[i
].num_bits
;
1367 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1369 int retval
= ERROR_OK
;
1370 int num_bits
= field
->num_bits
;
1372 int compare_failed
= 0;
1374 if (field
->in_check_mask
)
1375 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1377 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1379 if (compare_failed
){
1380 /* An error handler could have caught the failing check
1381 * only report a problem when there wasn't a handler, or if the handler
1382 * acknowledged the error
1384 LOG_WARNING("TAP %s:",
1385 (field
->tap
== NULL
) ? "(unknown)" : field
->tap
->dotted_name
);
1388 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1389 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1391 if (field
->in_check_mask
)
1393 char *in_check_mask_char
;
1394 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1395 LOG_WARNING("value captured during scan didn't pass the requested check:");
1396 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1397 captured_char
, in_check_value_char
, in_check_mask_char
);
1398 free(in_check_mask_char
);
1402 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
);
1405 free(captured_char
);
1406 free(in_check_value_char
);
1408 retval
= ERROR_JTAG_QUEUE_FAILED
;
1416 set up checking of this field using the in_handler. The values passed in must be valid until
1417 after jtag_execute() has completed.
1419 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1422 field
->in_handler
= jtag_check_value
;
1424 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1425 field
->in_handler_priv
= NULL
;
1426 field
->in_check_value
= value
;
1427 field
->in_check_mask
= mask
;
1430 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1435 for (i
= 0; i
< cmd
->num_fields
; i
++)
1437 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1439 if (cmd
->fields
[i
].out_value
)
1446 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1452 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1456 retval
= jtag
->execute_queue();
1460 jtag_command_queue
= NULL
;
1461 last_comand_pointer
= &jtag_command_queue
;
1466 int jtag_execute_queue(void)
1468 int retval
=interface_jtag_execute_queue();
1469 if (retval
==ERROR_OK
)
1473 jtag_error
=ERROR_OK
;
1477 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1479 jtag_tap_t
*tap
= priv
;
1483 if (event
== JTAG_TRST_ASSERTED
)
1485 buf_set_ones(tap
->cur_instr
, tap
->ir_length
);
1492 void jtag_sleep(u32 us
)
1494 alive_sleep(us
/1000);
1497 /* Try to examine chain layout according to IEEE 1149.1 §12
1499 int jtag_examine_chain(void)
1503 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1506 int device_count
= 0;
1507 u8 zero_check
= 0x0;
1508 u8 one_check
= 0xff;
1511 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1512 field
.out_value
= idcode_buffer
;
1513 field
.out_mask
= NULL
;
1514 field
.in_value
= idcode_buffer
;
1515 field
.in_check_value
= NULL
;
1516 field
.in_check_mask
= NULL
;
1517 field
.in_handler
= NULL
;
1518 field
.in_handler_priv
= NULL
;
1520 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1522 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1525 jtag_add_plain_dr_scan(1, &field
, TAP_RESET
);
1526 jtag_execute_queue();
1528 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1530 zero_check
|= idcode_buffer
[i
];
1531 one_check
&= idcode_buffer
[i
];
1534 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1535 if ((zero_check
== 0x00) || (one_check
== 0xff))
1537 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1538 return ERROR_JTAG_INIT_FAILED
;
1541 // point at the 1st tap
1542 tap
= jtag_NextEnabledTap(NULL
);
1544 LOG_ERROR("JTAG: No taps enabled?");
1545 return ERROR_JTAG_INIT_FAILED
;
1548 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1550 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1551 if ((idcode
& 1) == 0)
1553 /* LSB must not be 0, this indicates a device in bypass */
1554 LOG_WARNING("Tap/Device does not have IDCODE");
1565 if (idcode
== 0x000000FF)
1568 /* End of chain (invalid manufacturer ID)
1570 * The JTAG examine is the very first thing that happens
1572 * A single JTAG device requires only 64 bits to be read back correctly.
1574 * The code below adds a check that the rest of the data scanned (640 bits)
1575 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1577 * earlier and gives more helpful/explicit error messages.
1579 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1581 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1582 if (unexpected
||(idcode
!= 0x000000FF))
1584 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1592 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1593 manufacturer
= EXTRACT_MFG(idcode
);
1594 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1595 part
= EXTRACT_PART(idcode
);
1596 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1597 version
= EXTRACT_VER(idcode
);
1599 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1600 ((tap
!= NULL
) ? (tap
->dotted_name
) : "(not-named)"),
1601 idcode
, manufacturer
, part
, version
);
1607 tap
->idcode
= idcode
;
1609 if (tap
->expected_ids_cnt
> 0) {
1610 /* Loop over the expected identification codes and test for a match */
1612 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1613 if( tap
->idcode
== tap
->expected_ids
[ii
] ){
1618 /* If none of the expected ids matched, log an error */
1619 if (ii
== tap
->expected_ids_cnt
) {
1620 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1623 EXTRACT_MFG( tap
->idcode
),
1624 EXTRACT_PART( tap
->idcode
),
1625 EXTRACT_VER( tap
->idcode
) );
1626 for (ii
= 0; ii
< tap
->expected_ids_cnt
; ii
++) {
1627 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1630 tap
->expected_ids_cnt
,
1631 tap
->expected_ids
[ii
],
1632 EXTRACT_MFG( tap
->expected_ids
[ii
] ),
1633 EXTRACT_PART( tap
->expected_ids
[ii
] ),
1634 EXTRACT_VER( tap
->expected_ids
[ii
] ) );
1637 return ERROR_JTAG_INIT_FAILED
;
1639 LOG_INFO("JTAG Tap/device matched");
1643 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1647 tap
= jtag_NextEnabledTap(tap
);
1652 /* see if number of discovered devices matches configuration */
1653 if (device_count
!= jtag_NumEnabledTaps())
1655 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1656 device_count
, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1657 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1658 return ERROR_JTAG_INIT_FAILED
;
1664 int jtag_validate_chain(void)
1667 int total_ir_length
= 0;
1673 total_ir_length
= 0;
1675 tap
= jtag_NextEnabledTap(tap
);
1679 total_ir_length
+= tap
->ir_length
;
1682 total_ir_length
+= 2;
1683 ir_test
= malloc(CEIL(total_ir_length
, 8));
1684 buf_set_ones(ir_test
, total_ir_length
);
1687 field
.num_bits
= total_ir_length
;
1688 field
.out_value
= ir_test
;
1689 field
.out_mask
= NULL
;
1690 field
.in_value
= ir_test
;
1691 field
.in_check_value
= NULL
;
1692 field
.in_check_mask
= NULL
;
1693 field
.in_handler
= NULL
;
1694 field
.in_handler_priv
= NULL
;
1696 jtag_add_plain_ir_scan(1, &field
, TAP_RESET
);
1697 jtag_execute_queue();
1702 tap
= jtag_NextEnabledTap(tap
);
1708 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1710 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1711 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1714 return ERROR_JTAG_INIT_FAILED
;
1716 chain_pos
+= tap
->ir_length
;
1719 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1721 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1722 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1725 return ERROR_JTAG_INIT_FAILED
;
1733 enum jtag_tap_cfg_param
{
1737 static Jim_Nvp nvp_config_opts
[] = {
1738 { .name
= "-event", .value
= JCFG_EVENT
},
1740 { .name
= NULL
, .value
= -1 }
1744 jtag_tap_configure_cmd( Jim_GetOptInfo
*goi
,
1751 /* parse config or cget options */
1752 while (goi
->argc
> 0) {
1753 Jim_SetEmptyResult (goi
->interp
);
1755 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
1757 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
1763 if (goi
->argc
== 0) {
1764 Jim_WrongNumArgs( goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ..." );
1768 e
= Jim_GetOpt_Nvp( goi
, nvp_jtag_tap_event
, &n
);
1770 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
1774 if (goi
->isconfigure
) {
1775 if (goi
->argc
!= 1) {
1776 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
1780 if (goi
->argc
!= 0) {
1781 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
1787 jtag_tap_event_action_t
*jteap
;
1789 jteap
= tap
->event_action
;
1790 /* replace existing? */
1792 if (jteap
->event
== n
->value
) {
1795 jteap
= jteap
->next
;
1798 if (goi
->isconfigure
) {
1799 if (jteap
== NULL
) {
1801 jteap
= calloc(1, sizeof (*jteap
));
1803 jteap
->event
= n
->value
;
1804 Jim_GetOpt_Obj( goi
, &o
);
1806 Jim_DecrRefCount(interp
, jteap
->body
);
1808 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
1809 Jim_IncrRefCount(jteap
->body
);
1811 /* add to head of event list */
1812 jteap
->next
= tap
->event_action
;
1813 tap
->event_action
= jteap
;
1814 Jim_SetEmptyResult(goi
->interp
);
1817 if (jteap
== NULL
) {
1818 Jim_SetEmptyResult(goi
->interp
);
1820 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
1827 } /* while (goi->argc) */
1832 static int jim_newtap_cmd( Jim_GetOptInfo
*goi
)
1842 const Jim_Nvp opts
[] = {
1843 #define NTAP_OPT_IRLEN 0
1844 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
1845 #define NTAP_OPT_IRMASK 1
1846 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
1847 #define NTAP_OPT_IRCAPTURE 2
1848 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
1849 #define NTAP_OPT_ENABLED 3
1850 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
1851 #define NTAP_OPT_DISABLED 4
1852 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
1853 #define NTAP_OPT_EXPECTED_ID 5
1854 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
1855 { .name
= NULL
, .value
= -1 },
1858 pTap
= malloc( sizeof(jtag_tap_t
) );
1859 memset( pTap
, 0, sizeof(*pTap
) );
1861 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1865 * we expect CHIP + TAP + OPTIONS
1867 if( goi
->argc
< 3 ){
1868 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
1871 Jim_GetOpt_String( goi
, &cp
, NULL
);
1872 pTap
->chip
= strdup(cp
);
1874 Jim_GetOpt_String( goi
, &cp
, NULL
);
1875 pTap
->tapname
= strdup(cp
);
1877 /* name + dot + name + null */
1878 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
1880 sprintf( cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
1881 pTap
->dotted_name
= cp
;
1883 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1884 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
1886 /* default is enabled */
1889 /* deal with options */
1890 #define NTREQ_IRLEN 1
1891 #define NTREQ_IRCAPTURE 2
1892 #define NTREQ_IRMASK 4
1894 /* clear them as we find them */
1895 reqbits
= (NTREQ_IRLEN
| NTREQ_IRCAPTURE
| NTREQ_IRMASK
);
1898 e
= Jim_GetOpt_Nvp( goi
, opts
, &n
);
1900 Jim_GetOpt_NvpUnknown( goi
, opts
, 0 );
1903 LOG_DEBUG("Processing option: %s", n
->name
);
1905 case NTAP_OPT_ENABLED
:
1908 case NTAP_OPT_DISABLED
:
1911 case NTAP_OPT_EXPECTED_ID
:
1913 u32
*new_expected_ids
;
1915 e
= Jim_GetOpt_Wide( goi
, &w
);
1917 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
1921 new_expected_ids
= malloc(sizeof(u32
) * (pTap
->expected_ids_cnt
+ 1));
1922 if (new_expected_ids
== NULL
) {
1923 Jim_SetResult_sprintf( goi
->interp
, "no memory");
1927 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(u32
) * pTap
->expected_ids_cnt
);
1929 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
1931 free(pTap
->expected_ids
);
1932 pTap
->expected_ids
= new_expected_ids
;
1933 pTap
->expected_ids_cnt
++;
1936 case NTAP_OPT_IRLEN
:
1937 case NTAP_OPT_IRMASK
:
1938 case NTAP_OPT_IRCAPTURE
:
1939 e
= Jim_GetOpt_Wide( goi
, &w
);
1941 Jim_SetResult_sprintf( goi
->interp
, "option: %s bad parameter", n
->name
);
1944 if( (w
< 0) || (w
> 0xffff) ){
1946 Jim_SetResult_sprintf( goi
->interp
, "option: %s - wacky value: %d (0x%x)",
1947 n
->name
, (int)(w
), (int)(w
));
1951 case NTAP_OPT_IRLEN
:
1952 pTap
->ir_length
= w
;
1953 reqbits
&= (~(NTREQ_IRLEN
));
1955 case NTAP_OPT_IRMASK
:
1956 pTap
->ir_capture_mask
= w
;
1957 reqbits
&= (~(NTREQ_IRMASK
));
1959 case NTAP_OPT_IRCAPTURE
:
1960 pTap
->ir_capture_value
= w
;
1961 reqbits
&= (~(NTREQ_IRCAPTURE
));
1964 } /* switch(n->value) */
1965 } /* while( goi->argc ) */
1967 /* Did we get all the options? */
1970 Jim_SetResult_sprintf( goi
->interp
,
1971 "newtap: %s missing required parameters",
1973 /* TODO: Tell user what is missing :-( */
1974 /* no memory leaks pelase */
1975 free(((void *)(pTap
->expected_ids
)));
1976 free(((void *)(pTap
->chip
)));
1977 free(((void *)(pTap
->tapname
)));
1978 free(((void *)(pTap
->dotted_name
)));
1979 free(((void *)(pTap
)));
1983 pTap
->expected
= malloc( pTap
->ir_length
);
1984 pTap
->expected_mask
= malloc( pTap
->ir_length
);
1985 pTap
->cur_instr
= malloc( pTap
->ir_length
);
1987 buf_set_u32( pTap
->expected
,
1990 pTap
->ir_capture_value
);
1991 buf_set_u32( pTap
->expected_mask
,
1994 pTap
->ir_capture_mask
);
1995 buf_set_ones( pTap
->cur_instr
,
2000 jtag_register_event_callback(jtag_reset_callback
, pTap
);
2002 ppTap
= &(jtag_all_taps
);
2003 while( (*ppTap
) != NULL
){
2004 ppTap
= &((*ppTap
)->next_tap
);
2008 static int n_taps
= 0;
2009 pTap
->abs_chain_position
= n_taps
++;
2011 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2012 (*ppTap
)->dotted_name
,
2013 (*ppTap
)->abs_chain_position
,
2014 (*ppTap
)->ir_length
,
2015 (*ppTap
)->ir_capture_value
,
2016 (*ppTap
)->ir_capture_mask
);
2021 static int jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
2027 struct command_context_s
*context
;
2031 JTAG_CMD_INIT_RESET
,
2034 JTAG_CMD_TAPDISABLE
,
2035 JTAG_CMD_TAPISENABLED
,
2040 const Jim_Nvp jtag_cmds
[] = {
2041 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
2042 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
2043 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
2044 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
2045 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
2046 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
2047 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
2048 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
2050 { .name
= NULL
, .value
= -1 },
2053 context
= Jim_GetAssocData(interp
, "context");
2054 /* go past the command */
2055 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
2057 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
2059 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
2062 Jim_SetEmptyResult( goi
.interp
);
2064 case JTAG_CMD_INTERFACE
:
2065 /* return the name of the interface */
2066 /* TCL code might need to know the exact type... */
2067 /* FUTURE: we allow this as a means to "set" the interface. */
2068 if( goi
.argc
!= 0 ){
2069 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2072 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
2074 case JTAG_CMD_INIT_RESET
:
2075 if( goi
.argc
!= 0 ){
2076 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
2079 e
= jtag_init_reset(context
);
2080 if( e
!= ERROR_OK
){
2081 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
2085 case JTAG_CMD_NEWTAP
:
2086 return jim_newtap_cmd( &goi
);
2088 case JTAG_CMD_TAPISENABLED
:
2089 case JTAG_CMD_TAPENABLE
:
2090 case JTAG_CMD_TAPDISABLE
:
2091 if( goi
.argc
!= 1 ){
2092 Jim_SetResultString( goi
.interp
, "Too many parameters",-1 );
2098 t
= jtag_TapByJimObj( goi
.interp
, goi
.argv
[0] );
2103 case JTAG_CMD_TAPISENABLED
:
2106 case JTAG_CMD_TAPENABLE
:
2107 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_ENABLE
);
2111 case JTAG_CMD_TAPDISABLE
:
2112 jtag_tap_handle_event( t
, JTAG_TAP_EVENT_DISABLE
);
2117 Jim_SetResult( goi
.interp
, Jim_NewIntObj( goi
.interp
, e
) );
2124 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ...");
2131 Jim_GetOpt_Obj(&goi
, &o
);
2132 t
= jtag_TapByJimObj( goi
.interp
, o
);
2137 goi
.isconfigure
= 0;
2138 return jtag_tap_configure_cmd( &goi
, t
);
2142 case JTAG_CMD_CONFIGURE
:
2144 Jim_WrongNumArgs( goi
.interp
, 0, NULL
, "?tap-name? -option ?VALUE? ...");
2151 Jim_GetOpt_Obj(&goi
, &o
);
2152 t
= jtag_TapByJimObj( goi
.interp
, o
);
2157 goi
.isconfigure
= 1;
2158 return jtag_tap_configure_cmd( &goi
, t
);
2165 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
2167 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
2169 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
2170 COMMAND_CONFIG
, "try to configure interface");
2171 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
2172 COMMAND_ANY
, "set jtag speed (if supported)");
2173 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
2174 COMMAND_ANY
, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2175 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
2176 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2177 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
2179 "[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]");
2180 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
2181 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2182 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
2183 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2185 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
2186 COMMAND_EXEC
, "print current scan chain configuration");
2188 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
2189 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
2190 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
2191 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
2192 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
2193 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
2194 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
2195 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2196 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2198 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
2199 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
2203 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
2208 if (!jtag_interface
)
2210 /* nothing was previously specified by "interface" command */
2211 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2212 return ERROR_JTAG_INVALID_INTERFACE
;
2216 jtag_interface
->khz(speed_khz
, &jtag_speed
);
2220 if (jtag_interface
->init() != ERROR_OK
)
2221 return ERROR_JTAG_INIT_FAILED
;
2223 jtag
= jtag_interface
;
2227 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
2232 LOG_DEBUG("Init JTAG chain");
2234 tap
= jtag_NextEnabledTap(NULL
);
2236 LOG_ERROR("There are no enabled taps?");
2237 return ERROR_JTAG_INIT_FAILED
;
2241 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
2244 /* examine chain first, as this could discover the real chain layout */
2245 if (jtag_examine_chain() != ERROR_OK
)
2247 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2250 if (jtag_validate_chain() != ERROR_OK
)
2252 LOG_ERROR("Could not validate JTAG chain, continuing anyway...");
2258 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
2262 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2265 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2267 /* Reset can happen after a power cycle.
2269 * Ideally we would only assert TRST or run RESET before the target reset.
2271 * However w/srst_pulls_trst, trst is asserted together with the target
2272 * reset whether we want it or not.
2274 * NB! Some targets have JTAG circuitry disabled until a
2275 * trst & srst has been asserted.
2277 * NB! here we assume nsrst/ntrst delay are sufficient!
2279 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2282 jtag_add_reset(1, 0); /* RESET or TRST */
2283 if (jtag_reset_config
& RESET_HAS_SRST
)
2285 jtag_add_reset(1, 1);
2286 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
2287 jtag_add_reset(0, 1);
2289 jtag_add_reset(0, 0);
2290 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
2293 /* Check that we can communication on the JTAG chain + eventually we want to
2294 * be able to perform enumeration only after OpenOCD has started
2295 * telnet and GDB server
2297 * That would allow users to more easily perform any magic they need to before
2300 return jtag_init_inner(cmd_ctx
);
2303 int jtag_init(struct command_context_s
*cmd_ctx
)
2306 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
2308 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
2312 return jtag_init_reset(cmd_ctx
);
2315 static int default_khz(int khz
, int *jtag_speed
)
2317 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2321 static int default_speed_div(int speed
, int *khz
)
2323 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2327 static int default_power_dropout(int *dropout
)
2329 *dropout
=0; /* by default we can't detect power dropout */
2333 static int default_srst_asserted(int *srst_asserted
)
2335 *srst_asserted
=0; /* by default we can't detect srst asserted */
2339 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2344 /* check whether the interface is already configured */
2347 LOG_WARNING("Interface already configured, ignoring");
2351 /* interface name is a mandatory argument */
2352 if (argc
< 1 || args
[0][0] == '\0')
2354 return ERROR_COMMAND_SYNTAX_ERROR
;
2357 for (i
=0; jtag_interfaces
[i
]; i
++)
2359 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
2361 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
2366 jtag_interface
= jtag_interfaces
[i
];
2368 if (jtag_interface
->khz
== NULL
)
2370 jtag_interface
->khz
= default_khz
;
2372 if (jtag_interface
->speed_div
== NULL
)
2374 jtag_interface
->speed_div
= default_speed_div
;
2376 if (jtag_interface
->power_dropout
== NULL
)
2378 jtag_interface
->power_dropout
= default_power_dropout
;
2380 if (jtag_interface
->srst_asserted
== NULL
)
2382 jtag_interface
->srst_asserted
= default_srst_asserted
;
2389 /* no valid interface was found (i.e. the configuration option,
2390 * didn't match one of the compiled-in interfaces
2392 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
2393 LOG_ERROR("compiled-in jtag interfaces:");
2394 for (i
= 0; jtag_interfaces
[i
]; i
++)
2396 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
2399 return ERROR_JTAG_INVALID_INTERFACE
;
2402 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2406 Jim_Obj
*newargs
[ 10 ];
2409 * argv[-1] = command
2410 * argv[ 0] = ir length
2411 * argv[ 1] = ir capture
2412 * argv[ 2] = ir mask
2413 * argv[ 3] = not actually used by anything but in the docs
2417 command_print( cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2420 command_print( cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2421 command_print( cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2425 command_print( cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundryscan(len5)");
2426 command_print( cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2427 command_print( cmd_ctx
, "jtag newtap stm32 boundry ....., and the tap: \"stm32.boundery\"");
2428 command_print( cmd_ctx
, "And then refer to the taps by the dotted name.");
2430 newargs
[0] = Jim_NewStringObj( interp
, "jtag", -1 );
2431 newargs
[1] = Jim_NewStringObj( interp
, "newtap", -1 );
2432 sprintf( buf
, "chip%d", jtag_NumTotalTaps() );
2433 newargs
[2] = Jim_NewStringObj( interp
, buf
, -1 );
2434 sprintf( buf
, "tap%d", jtag_NumTotalTaps() );
2435 newargs
[3] = Jim_NewStringObj( interp
, buf
, -1 );
2436 newargs
[4] = Jim_NewStringObj( interp
, "-irlen", -1 );
2437 newargs
[5] = Jim_NewStringObj( interp
, args
[0], -1 );
2438 newargs
[6] = Jim_NewStringObj( interp
, "-ircapture", -1 );
2439 newargs
[7] = Jim_NewStringObj( interp
, args
[1], -1 );
2440 newargs
[8] = Jim_NewStringObj( interp
, "-irmask", -1 );
2441 newargs
[9] = Jim_NewStringObj( interp
, args
[2], -1 );
2443 command_print( cmd_ctx
, "NEW COMMAND:");
2444 sprintf( buf
, "%s %s %s %s %s %s %s %s %s %s",
2445 Jim_GetString( newargs
[0], NULL
),
2446 Jim_GetString( newargs
[1], NULL
),
2447 Jim_GetString( newargs
[2], NULL
),
2448 Jim_GetString( newargs
[3], NULL
),
2449 Jim_GetString( newargs
[4], NULL
),
2450 Jim_GetString( newargs
[5], NULL
),
2451 Jim_GetString( newargs
[6], NULL
),
2452 Jim_GetString( newargs
[7], NULL
),
2453 Jim_GetString( newargs
[8], NULL
),
2454 Jim_GetString( newargs
[9], NULL
) );
2456 e
= jim_jtag_command( interp
, 10, newargs
);
2458 command_print( cmd_ctx
, "%s", Jim_GetString( Jim_GetResult(interp
), NULL
) );
2463 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2467 tap
= jtag_all_taps
;
2468 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2469 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
2472 u32 expected
, expected_mask
, cur_instr
, ii
;
2473 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
2474 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
2475 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
2477 command_print(cmd_ctx
,
2478 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2479 tap
->abs_chain_position
,
2481 tap
->enabled
? 'Y' : 'n',
2483 (tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
2489 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
2490 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
2491 tap
->expected_ids
[ii
]);
2494 tap
= tap
->next_tap
;
2500 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2503 return ERROR_COMMAND_SYNTAX_ERROR
;
2507 if (strcmp(args
[0], "none") == 0)
2508 jtag_reset_config
= RESET_NONE
;
2509 else if (strcmp(args
[0], "trst_only") == 0)
2510 jtag_reset_config
= RESET_HAS_TRST
;
2511 else if (strcmp(args
[0], "srst_only") == 0)
2512 jtag_reset_config
= RESET_HAS_SRST
;
2513 else if (strcmp(args
[0], "trst_and_srst") == 0)
2514 jtag_reset_config
= RESET_TRST_AND_SRST
;
2517 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args
[0]);
2518 jtag_reset_config
= RESET_NONE
;
2519 return ERROR_INVALID_ARGUMENTS
;
2525 if (strcmp(args
[1], "separate") == 0)
2527 /* seperate reset lines - default */
2530 if (strcmp(args
[1], "srst_pulls_trst") == 0)
2531 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
2532 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
2533 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
2534 else if (strcmp(args
[1], "combined") == 0)
2535 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
2538 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args
[1]);
2539 jtag_reset_config
= RESET_NONE
;
2540 return ERROR_INVALID_ARGUMENTS
;
2547 if (strcmp(args
[2], "trst_open_drain") == 0)
2548 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
2549 else if (strcmp(args
[2], "trst_push_pull") == 0)
2550 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
2553 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args
[2] );
2554 jtag_reset_config
= RESET_NONE
;
2555 return ERROR_INVALID_ARGUMENTS
;
2561 if (strcmp(args
[3], "srst_push_pull") == 0)
2562 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
2563 else if (strcmp(args
[3], "srst_open_drain") == 0)
2564 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
2567 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args
[3]);
2568 jtag_reset_config
= RESET_NONE
;
2569 return ERROR_INVALID_ARGUMENTS
;
2576 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2580 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2585 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
2591 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2595 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2600 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
2606 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2608 int retval
=ERROR_OK
;
2612 LOG_DEBUG("handle jtag speed");
2615 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
2617 /* this command can be called during CONFIG,
2618 * in which case jtag isn't initialized */
2621 retval
=jtag
->speed(cur_speed
);
2623 } else if (argc
== 0)
2627 return ERROR_COMMAND_SYNTAX_ERROR
;
2629 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
2634 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2636 int retval
=ERROR_OK
;
2637 LOG_DEBUG("handle jtag khz");
2641 speed_khz
= strtoul(args
[0], NULL
, 0);
2645 LOG_DEBUG("have interface set up");
2647 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2653 cur_speed
= jtag_speed
= speed_div1
;
2655 retval
=jtag
->speed(cur_speed
);
2664 return ERROR_COMMAND_SYNTAX_ERROR
;
2669 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2675 command_print(cmd_ctx
, "RCLK - adaptive");
2678 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2684 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2686 enum tap_state state
;
2690 return ERROR_COMMAND_SYNTAX_ERROR
;
2694 for (state
= 0; state
< 16; state
++)
2696 if (strcmp(args
[0], jtag_state_name(state
)) == 0)
2698 jtag_add_end_state(state
);
2699 jtag_execute_queue();
2703 command_print(cmd_ctx
, "current endstate: %s", jtag_state_name(cmd_queue_end_state
));
2708 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2715 return ERROR_COMMAND_SYNTAX_ERROR
;
2718 if (args
[0][0] == '1')
2720 else if (args
[0][0] == '0')
2724 return ERROR_COMMAND_SYNTAX_ERROR
;
2727 if (args
[1][0] == '1')
2729 else if (args
[1][0] == '0')
2733 return ERROR_COMMAND_SYNTAX_ERROR
;
2736 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2737 return ERROR_JTAG_INIT_FAILED
;
2739 jtag_add_reset(trst
, srst
);
2740 jtag_execute_queue();
2745 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2749 return ERROR_COMMAND_SYNTAX_ERROR
;
2752 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
2753 jtag_execute_queue();
2759 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2762 scan_field_t
*fields
;
2765 if ((argc
< 2) || (argc
% 2))
2767 return ERROR_COMMAND_SYNTAX_ERROR
;
2770 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
2772 for (i
= 0; i
< argc
/ 2; i
++)
2774 tap
= jtag_TapByString( args
[i
*2] );
2777 command_print( cmd_ctx
, "Tap: %s unknown", args
[i
*2] );
2780 int field_size
= tap
->ir_length
;
2781 fields
[i
].tap
= tap
;
2782 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2783 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2784 fields
[i
].out_mask
= NULL
;
2785 fields
[i
].in_value
= NULL
;
2786 fields
[i
].in_check_mask
= NULL
;
2787 fields
[i
].in_handler
= NULL
;
2788 fields
[i
].in_handler_priv
= NULL
;
2791 jtag_add_ir_scan(argc
/ 2, fields
, -1);
2792 jtag_execute_queue();
2794 for (i
= 0; i
< argc
/ 2; i
++)
2795 free(fields
[i
].out_value
);
2802 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2805 scan_field_t
*fields
;
2807 int field_count
= 0;
2812 * args[2] = num_bits
2813 * args[3] = hex string
2814 * ... repeat num bits and hex string ...
2816 if ((argc
< 4) || ((argc
% 2)!=0))
2818 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2822 for (i
= 2; i
< argc
; i
+=2)
2826 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2831 tap
= jtag_TapByJimObj( interp
, args
[1] );
2836 num_fields
=(argc
-2)/2;
2837 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2838 for (i
= 2; i
< argc
; i
+=2)
2844 Jim_GetLong(interp
, args
[i
], &bits
);
2845 str
= Jim_GetString(args
[i
+1], &len
);
2847 fields
[field_count
].tap
= tap
;
2848 fields
[field_count
].num_bits
= bits
;
2849 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2850 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2851 fields
[field_count
].out_mask
= NULL
;
2852 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2853 fields
[field_count
].in_check_mask
= NULL
;
2854 fields
[field_count
].in_check_value
= NULL
;
2855 fields
[field_count
].in_handler
= NULL
;
2856 fields
[field_count
++].in_handler_priv
= NULL
;
2859 jtag_add_dr_scan(num_fields
, fields
, -1);
2860 retval
= jtag_execute_queue();
2861 if (retval
!= ERROR_OK
)
2863 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
2868 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2869 for (i
= 2; i
< argc
; i
+=2)
2874 Jim_GetLong(interp
, args
[i
], &bits
);
2875 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2876 free(fields
[field_count
].out_value
);
2878 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2883 Jim_SetResult(interp
, list
);
2890 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2894 if (strcmp(args
[0], "enable") == 0)
2896 jtag_verify_capture_ir
= 1;
2898 else if (strcmp(args
[0], "disable") == 0)
2900 jtag_verify_capture_ir
= 0;
2903 return ERROR_COMMAND_SYNTAX_ERROR
;
2905 } else if (argc
!= 0)
2907 return ERROR_COMMAND_SYNTAX_ERROR
;
2910 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2915 int jtag_power_dropout(int *dropout
)
2917 return jtag
->power_dropout(dropout
);
2920 int jtag_srst_asserted(int *srst_asserted
)
2922 return jtag
->srst_asserted(srst_asserted
);
2925 void jtag_tap_handle_event( jtag_tap_t
* tap
, enum jtag_tap_event e
)
2927 jtag_tap_event_action_t
* jteap
;
2930 jteap
= tap
->event_action
;
2934 if (jteap
->event
== e
) {
2936 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2939 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
2940 Jim_GetString(jteap
->body
, NULL
) );
2941 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
2942 Jim_PrintErrorMessage(interp
);
2946 jteap
= jteap
->next
;
2950 LOG_DEBUG( "event %d %s - no action",
2952 Jim_Nvp_value2name_simple( nvp_jtag_tap_event
, e
)->name
);
2956 /* map state number to SVF state string */
2957 const char* jtag_state_name(enum tap_state state
)
2963 case TAP_RESET
: ret
= "RESET"; break;
2964 case TAP_IDLE
: ret
= "IDLE"; break;
2965 case TAP_DRSELECT
: ret
= "DRSELECT"; break;
2966 case TAP_DRCAPTURE
: ret
= "DRCAPTURE"; break;
2967 case TAP_DRSHIFT
: ret
= "DRSHIFT"; break;
2968 case TAP_DREXIT1
: ret
= "DREXIT1"; break;
2969 case TAP_DRPAUSE
: ret
= "DRPAUSE"; break;
2970 case TAP_DREXIT2
: ret
= "DREXIT2"; break;
2971 case TAP_DRUPDATE
: ret
= "DRUPDATE"; break;
2972 case TAP_IRSELECT
: ret
= "IRSELECT"; break;
2973 case TAP_IRCAPTURE
: ret
= "IRCAPTURE"; break;
2974 case TAP_IRSHIFT
: ret
= "IRSHIFT"; break;
2975 case TAP_IREXIT1
: ret
= "IREXIT1"; break;
2976 case TAP_IRPAUSE
: ret
= "IRPAUSE"; break;
2977 case TAP_IREXIT2
: ret
= "IREXIT2"; break;
2978 case TAP_IRUPDATE
: ret
= "IRUPDATE"; break;
2979 default: ret
= "???";
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)