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
;
44 char* tap_state_strings
[16] =
47 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
49 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
52 typedef struct cmd_queue_page_s
56 struct cmd_queue_page_s
*next
;
59 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
60 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
62 /* tap_move[i][j]: tap movement command to go from state i to state j
70 * SD->SD and SI->SI have to be caught in interface specific code
74 /* TLR RTI SD PD SI PI */
75 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
76 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
77 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
78 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
79 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
80 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
83 int tap_move_map
[16] = {
84 0, -1, -1, 2, -1, 3, -1, -1,
85 1, -1, -1, 4, -1, 5, -1, -1
88 tap_transition_t tap_transitions
[16] =
90 {TAP_TLR
, TAP_RTI
}, /* TLR */
91 {TAP_SIS
, TAP_CD
}, /* SDS */
92 {TAP_E1D
, TAP_SD
}, /* CD */
93 {TAP_E1D
, TAP_SD
}, /* SD */
94 {TAP_UD
, TAP_PD
}, /* E1D */
95 {TAP_E2D
, TAP_PD
}, /* PD */
96 {TAP_UD
, TAP_SD
}, /* E2D */
97 {TAP_SDS
, TAP_RTI
}, /* UD */
98 {TAP_SDS
, TAP_RTI
}, /* RTI */
99 {TAP_TLR
, TAP_CI
}, /* SIS */
100 {TAP_E1I
, TAP_SI
}, /* CI */
101 {TAP_E1I
, TAP_SI
}, /* SI */
102 {TAP_UI
, TAP_PI
}, /* E1I */
103 {TAP_E2I
, TAP_PI
}, /* PI */
104 {TAP_UI
, TAP_SI
}, /* E2I */
105 {TAP_SDS
, TAP_RTI
} /* UI */
108 char* jtag_event_strings
[] =
110 "JTAG controller reset (TLR or TRST)"
113 /* kludge!!!! these are just global variables that the
114 * interface use internally. They really belong
115 * inside the drivers, but we don't want to break
116 * linking the drivers!!!!
118 enum tap_state end_state
= TAP_TLR
;
119 enum tap_state cur_state
= TAP_TLR
;
123 jtag_command_t
*jtag_command_queue
= NULL
;
124 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
125 jtag_device_t
*jtag_devices
= NULL
;
126 int jtag_num_devices
= 0;
127 int jtag_ir_scan_size
= 0;
128 enum reset_types jtag_reset_config
= RESET_NONE
;
129 enum tap_state cmd_queue_end_state
= TAP_TLR
;
130 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
132 int jtag_verify_capture_ir
= 1;
134 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
135 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
136 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
138 /* maximum number of JTAG devices expected in the chain
140 #define JTAG_MAX_CHAIN_SIZE 20
142 /* callbacks to inform high-level handlers about JTAG state changes */
143 jtag_event_callback_t
*jtag_event_callbacks
;
146 static int speed_khz
= 0;
147 /* flag if the kHz speed was defined */
148 static int hasKHz
= 0;
150 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
153 #if BUILD_ECOSBOARD == 1
154 extern jtag_interface_t zy1000_interface
;
157 #if BUILD_PARPORT == 1
158 extern jtag_interface_t parport_interface
;
162 extern jtag_interface_t dummy_interface
;
165 #if BUILD_FT2232_FTD2XX == 1
166 extern jtag_interface_t ft2232_interface
;
169 #if BUILD_FT2232_LIBFTDI == 1
170 extern jtag_interface_t ft2232_interface
;
173 #if BUILD_AMTJTAGACCEL == 1
174 extern jtag_interface_t amt_jtagaccel_interface
;
177 #if BUILD_EP93XX == 1
178 extern jtag_interface_t ep93xx_interface
;
181 #if BUILD_AT91RM9200 == 1
182 extern jtag_interface_t at91rm9200_interface
;
185 #if BUILD_GW16012 == 1
186 extern jtag_interface_t gw16012_interface
;
189 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
190 extern jtag_interface_t presto_interface
;
193 #if BUILD_USBPROG == 1
194 extern jtag_interface_t usbprog_interface
;
198 extern jtag_interface_t jlink_interface
;
201 jtag_interface_t
*jtag_interfaces
[] = {
202 #if BUILD_ECOSBOARD == 1
205 #if BUILD_PARPORT == 1
211 #if BUILD_FT2232_FTD2XX == 1
214 #if BUILD_FT2232_LIBFTDI == 1
217 #if BUILD_AMTJTAGACCEL == 1
218 &amt_jtagaccel_interface
,
220 #if BUILD_EP93XX == 1
223 #if BUILD_AT91RM9200 == 1
224 &at91rm9200_interface
,
226 #if BUILD_GW16012 == 1
229 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
232 #if BUILD_USBPROG == 1
241 jtag_interface_t
*jtag
= NULL
;
244 jtag_interface_t
*jtag_interface
= NULL
;
249 /* forward declarations */
250 void jtag_add_pathmove(int num_states
, enum tap_state
*path
);
251 void jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
252 void jtag_add_end_state(enum tap_state endstate
);
253 void jtag_add_sleep(u32 us
);
254 int jtag_execute_queue(void);
258 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
259 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
260 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
261 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
262 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
263 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
264 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
266 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
268 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
269 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
270 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
271 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
272 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
274 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
276 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
278 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
280 if (callback
== NULL
)
282 return ERROR_INVALID_ARGUMENTS
;
287 while ((*callbacks_p
)->next
)
288 callbacks_p
= &((*callbacks_p
)->next
);
289 callbacks_p
= &((*callbacks_p
)->next
);
292 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
293 (*callbacks_p
)->callback
= callback
;
294 (*callbacks_p
)->priv
= priv
;
295 (*callbacks_p
)->next
= NULL
;
300 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
302 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
304 if (callback
== NULL
)
306 return ERROR_INVALID_ARGUMENTS
;
311 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
312 if ((*callbacks_p
)->callback
== callback
)
315 *callbacks_p
= *next
;
323 int jtag_call_event_callbacks(enum jtag_event event
)
325 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
327 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
331 callback
->callback(event
, callback
->priv
);
332 callback
= callback
->next
;
338 /* returns a pointer to the pointer of the last command in queue
339 * this may be a pointer to the root pointer (jtag_command_queue)
340 * or to the next member of the last but one command
342 jtag_command_t
** jtag_get_last_command_p(void)
344 /* jtag_command_t *cmd = jtag_command_queue;
350 return &jtag_command_queue;
354 return last_comand_pointer
;
357 /* returns a pointer to the n-th device in the scan chain */
358 jtag_device_t
* jtag_get_device(int num
)
360 jtag_device_t
*device
= jtag_devices
;
367 device
= device
->next
;
371 LOG_ERROR("jtag device number %d not defined", num
);
375 void* cmd_queue_alloc(size_t size
)
377 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
383 while ((*p_page
)->next
)
384 p_page
= &((*p_page
)->next
);
385 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
386 p_page
= &((*p_page
)->next
);
391 *p_page
= malloc(sizeof(cmd_queue_page_t
));
393 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
394 (*p_page
)->next
= NULL
;
397 offset
= (*p_page
)->used
;
398 (*p_page
)->used
+= size
;
400 t
=(u8
*)((*p_page
)->address
);
404 void cmd_queue_free(void)
406 cmd_queue_page_t
*page
= cmd_queue_pages
;
410 cmd_queue_page_t
*last
= page
;
416 cmd_queue_pages
= NULL
;
419 static void jtag_prelude1(void)
423 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
424 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
428 if (cmd_queue_end_state
== TAP_TLR
)
429 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
432 static void jtag_prelude(enum tap_state state
)
437 jtag_add_end_state(state
);
439 cmd_queue_cur_state
= cmd_queue_end_state
;
442 void jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
448 retval
=interface_jtag_add_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
449 if (retval
!=ERROR_OK
)
453 int MINIDRIVER(interface_jtag_add_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
455 jtag_command_t
**last_cmd
;
456 jtag_device_t
*device
;
461 last_cmd
= jtag_get_last_command_p();
463 /* allocate memory for a new list member */
464 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
465 (*last_cmd
)->next
= NULL
;
466 last_comand_pointer
= &((*last_cmd
)->next
);
467 (*last_cmd
)->type
= JTAG_SCAN
;
469 /* allocate memory for ir scan command */
470 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
471 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
472 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
473 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
474 (*last_cmd
)->cmd
.scan
->end_state
= state
;
476 for (i
= 0; i
< jtag_num_devices
; i
++)
479 device
= jtag_get_device(i
);
484 scan_size
= device
->ir_length
;
485 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
486 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
487 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
488 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
; /* disable verification by default */
490 /* search the list */
491 for (j
= 0; j
< num_fields
; j
++)
493 if (i
== fields
[j
].device
)
496 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
497 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
499 if (jtag_verify_capture_ir
)
501 if (fields
[j
].in_handler
==NULL
)
503 jtag_set_check_value((*last_cmd
)->cmd
.scan
->fields
+i
, device
->expected
, device
->expected_mask
, NULL
);
506 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[j
].in_handler
;
507 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[j
].in_handler_priv
;
508 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= device
->expected
;
509 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= device
->expected_mask
;
520 /* if a device isn't listed, set it to BYPASS */
521 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
522 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
527 /* update device information */
528 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
534 void jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
540 retval
=interface_jtag_add_plain_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
541 if (retval
!=ERROR_OK
)
545 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
548 jtag_command_t
**last_cmd
;
550 last_cmd
= jtag_get_last_command_p();
552 /* allocate memory for a new list member */
553 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
554 (*last_cmd
)->next
= NULL
;
555 last_comand_pointer
= &((*last_cmd
)->next
);
556 (*last_cmd
)->type
= JTAG_SCAN
;
558 /* allocate memory for ir scan command */
559 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
560 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
561 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
562 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
563 (*last_cmd
)->cmd
.scan
->end_state
= state
;
565 for (i
= 0; i
< num_fields
; i
++)
567 int num_bits
= fields
[i
].num_bits
;
568 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
569 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
570 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
571 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
572 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
573 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
574 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
575 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
576 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
577 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
582 void jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
588 retval
=interface_jtag_add_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
589 if (retval
!=ERROR_OK
)
593 int MINIDRIVER(interface_jtag_add_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
596 int bypass_devices
= 0;
600 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
601 jtag_device_t
*device
= jtag_devices
;
603 /* count devices in bypass */
608 device
= device
->next
;
610 if (bypass_devices
>= jtag_num_devices
)
612 LOG_ERROR("all devices in bypass");
613 return ERROR_JTAG_DEVICE_ERROR
;
616 /* allocate memory for a new list member */
617 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
618 last_comand_pointer
= &((*last_cmd
)->next
);
619 (*last_cmd
)->next
= NULL
;
620 (*last_cmd
)->type
= JTAG_SCAN
;
622 /* allocate memory for dr scan command */
623 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
624 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
625 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
626 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
627 (*last_cmd
)->cmd
.scan
->end_state
= state
;
629 for (i
= 0; i
< jtag_num_devices
; i
++)
632 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
634 for (j
= 0; j
< num_fields
; j
++)
636 if (i
== fields
[j
].device
)
639 scan_size
= fields
[j
].num_bits
;
640 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
641 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
642 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
643 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
644 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= fields
[j
].in_check_value
;
645 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= fields
[j
].in_check_mask
;
646 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
647 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
652 #ifdef _DEBUG_JTAG_IO_
653 /* if a device isn't listed, the BYPASS register should be selected */
654 if (!jtag_get_device(i
)->bypass
)
656 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
660 /* program the scan field to 1 bit length, and ignore it's value */
661 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
662 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
663 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
664 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
665 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
666 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
667 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
668 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
672 #ifdef _DEBUG_JTAG_IO_
673 /* if a device is listed, the BYPASS register must not be selected */
674 if (jtag_get_device(i
)->bypass
)
676 LOG_ERROR("BUG: scan data for a device in BYPASS");
685 void MINIDRIVER(interface_jtag_add_dr_out
)(int device_num
,
689 enum tap_state end_state
)
694 int bypass_devices
= 0;
696 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
697 jtag_device_t
*device
= jtag_devices
;
698 /* count devices in bypass */
703 device
= device
->next
;
706 /* allocate memory for a new list member */
707 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
708 last_comand_pointer
= &((*last_cmd
)->next
);
709 (*last_cmd
)->next
= NULL
;
710 (*last_cmd
)->type
= JTAG_SCAN
;
712 /* allocate memory for dr scan command */
713 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
714 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
715 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
716 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
717 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
719 for (i
= 0; i
< jtag_num_devices
; i
++)
721 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
726 #ifdef _DEBUG_JTAG_IO_
727 /* if a device is listed, the BYPASS register must not be selected */
728 if (jtag_get_device(i
)->bypass
)
730 LOG_ERROR("BUG: scan data for a device in BYPASS");
734 for (j
= 0; j
< num_fields
; j
++)
737 scan_size
= num_bits
[j
];
738 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
739 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
740 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
741 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
742 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
743 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
744 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
745 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
746 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
750 #ifdef _DEBUG_JTAG_IO_
751 /* if a device isn't listed, the BYPASS register should be selected */
752 if (!jtag_get_device(i
)->bypass
)
754 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
758 /* program the scan field to 1 bit length, and ignore it's value */
759 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
760 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
761 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
762 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
763 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
764 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
765 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
766 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
771 void jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
777 retval
=interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
778 if (retval
!=ERROR_OK
)
782 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
785 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
787 /* allocate memory for a new list member */
788 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
789 last_comand_pointer
= &((*last_cmd
)->next
);
790 (*last_cmd
)->next
= NULL
;
791 (*last_cmd
)->type
= JTAG_SCAN
;
793 /* allocate memory for scan command */
794 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
795 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
796 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
797 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
798 (*last_cmd
)->cmd
.scan
->end_state
= state
;
800 for (i
= 0; i
< num_fields
; i
++)
802 int num_bits
= fields
[i
].num_bits
;
803 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
804 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
805 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
806 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
807 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
808 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
809 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
810 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
811 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
812 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
818 void jtag_add_tlr(void)
820 jtag_prelude(TAP_TLR
);
823 retval
=interface_jtag_add_tlr();
824 if (retval
!=ERROR_OK
)
828 int MINIDRIVER(interface_jtag_add_tlr
)()
830 enum tap_state state
= TAP_TLR
;
831 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
833 /* allocate memory for a new list member */
834 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
835 last_comand_pointer
= &((*last_cmd
)->next
);
836 (*last_cmd
)->next
= NULL
;
837 (*last_cmd
)->type
= JTAG_STATEMOVE
;
839 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
840 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
846 void jtag_add_pathmove(int num_states
, enum tap_state
*path
)
848 enum tap_state cur_state
=cmd_queue_cur_state
;
852 /* the last state has to be a stable state */
853 if (tap_move_map
[path
[num_states
- 1]] == -1)
855 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
859 for (i
=0; i
<num_states
; i
++)
861 if (path
[i
] == TAP_TLR
)
863 LOG_ERROR("BUG: TAP_TLR is not a valid state for pathmove sequences");
866 if ((tap_transitions
[cur_state
].low
!= path
[i
])&&
867 (tap_transitions
[cur_state
].high
!= path
[i
]))
869 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[i
]]);
878 retval
=interface_jtag_add_pathmove(num_states
, path
);
879 cmd_queue_cur_state
= path
[num_states
- 1];
880 if (retval
!=ERROR_OK
)
884 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
886 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
889 /* allocate memory for a new list member */
890 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
891 last_comand_pointer
= &((*last_cmd
)->next
);
892 (*last_cmd
)->next
= NULL
;
893 (*last_cmd
)->type
= JTAG_PATHMOVE
;
895 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
896 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
897 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
899 for (i
= 0; i
< num_states
; i
++)
900 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
905 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
907 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
909 /* allocate memory for a new list member */
910 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
911 (*last_cmd
)->next
= NULL
;
912 last_comand_pointer
= &((*last_cmd
)->next
);
913 (*last_cmd
)->type
= JTAG_RUNTEST
;
915 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
916 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
917 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
922 void jtag_add_runtest(int num_cycles
, enum tap_state state
)
928 /* executed by sw or hw fifo */
929 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
930 if (retval
!=ERROR_OK
)
934 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
936 int trst_with_tlr
= 0;
939 /* FIX!!! there are *many* different cases here. A better
940 * approach is needed for legal combinations of transitions...
942 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
943 (jtag_reset_config
& RESET_HAS_TRST
)&&
944 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
946 if (((req_tlr_or_trst
&&!jtag_trst
)||
947 (!req_tlr_or_trst
&&jtag_trst
))&&
948 ((req_srst
&&!jtag_srst
)||
949 (!req_srst
&&jtag_srst
)))
951 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
952 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
956 /* Make sure that jtag_reset_config allows the requested reset */
957 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
958 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
960 LOG_ERROR("BUG: requested reset would assert trst");
961 jtag_error
=ERROR_FAIL
;
965 /* if TRST pulls SRST, we reset with TAP T-L-R */
966 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
971 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
973 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
974 jtag_error
=ERROR_FAIL
;
980 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
992 jtag_srst
= req_srst
;
994 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
995 if (retval
!=ERROR_OK
)
1003 LOG_DEBUG("SRST line asserted");
1007 LOG_DEBUG("SRST line released");
1008 if (jtag_nsrst_delay
)
1009 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1014 LOG_DEBUG("JTAG reset with TLR instead of TRST");
1015 jtag_add_end_state(TAP_TLR
);
1017 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1023 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1024 * and inform possible listeners about this
1026 LOG_DEBUG("TRST line asserted");
1027 cmd_queue_cur_state
= TAP_TLR
;
1028 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1032 if (jtag_ntrst_delay
)
1033 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1037 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1039 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1041 /* allocate memory for a new list member */
1042 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1043 (*last_cmd
)->next
= NULL
;
1044 last_comand_pointer
= &((*last_cmd
)->next
);
1045 (*last_cmd
)->type
= JTAG_RESET
;
1047 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1048 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1049 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1054 void jtag_add_end_state(enum tap_state state
)
1056 cmd_queue_end_state
= state
;
1057 if ((cmd_queue_end_state
== TAP_SD
)||(cmd_queue_end_state
== TAP_SI
))
1059 LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field");
1063 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1065 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1067 /* allocate memory for a new list member */
1068 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1069 (*last_cmd
)->next
= NULL
;
1070 last_comand_pointer
= &((*last_cmd
)->next
);
1071 (*last_cmd
)->type
= JTAG_SLEEP
;
1073 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1074 (*last_cmd
)->cmd
.sleep
->us
= us
;
1079 void jtag_add_sleep(u32 us
)
1081 keep_alive(); /* we might be running on a very slow JTAG clk */
1082 int retval
=interface_jtag_add_sleep(us
);
1083 if (retval
!=ERROR_OK
)
1088 int jtag_scan_size(scan_command_t
*cmd
)
1093 /* count bits in scan command */
1094 for (i
= 0; i
< cmd
->num_fields
; i
++)
1096 bit_count
+= cmd
->fields
[i
].num_bits
;
1102 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1107 bit_count
= jtag_scan_size(cmd
);
1108 *buffer
= malloc(CEIL(bit_count
, 8));
1112 for (i
= 0; i
< cmd
->num_fields
; i
++)
1114 if (cmd
->fields
[i
].out_value
)
1116 #ifdef _DEBUG_JTAG_IO_
1117 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1119 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1120 #ifdef _DEBUG_JTAG_IO_
1121 LOG_DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1126 bit_count
+= cmd
->fields
[i
].num_bits
;
1132 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1138 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1141 for (i
= 0; i
< cmd
->num_fields
; i
++)
1143 /* if neither in_value nor in_handler
1144 * are specified we don't have to examine this field
1146 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1148 int num_bits
= cmd
->fields
[i
].num_bits
;
1149 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1151 #ifdef _DEBUG_JTAG_IO_
1154 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1155 LOG_DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1159 if (cmd
->fields
[i
].in_value
)
1161 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1163 if (cmd
->fields
[i
].in_handler
)
1165 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1167 LOG_WARNING("in_handler reported a failed check");
1168 retval
= ERROR_JTAG_QUEUE_FAILED
;
1173 /* no in_value specified, but a handler takes care of the scanned data */
1174 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1176 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1178 /* We're going to call the error:handler later, but if the in_handler
1179 * reported an error we report this failure upstream
1181 LOG_WARNING("in_handler reported a failed check");
1182 retval
= ERROR_JTAG_QUEUE_FAILED
;
1188 bit_count
+= cmd
->fields
[i
].num_bits
;
1194 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1196 int retval
= ERROR_OK
;
1197 int num_bits
= field
->num_bits
;
1199 int compare_failed
= 0;
1201 if (field
->in_check_mask
)
1202 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1204 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1208 /* An error handler could have caught the failing check
1209 * only report a problem when there wasn't a handler, or if the handler
1210 * acknowledged the error
1214 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1215 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1217 if (field
->in_check_mask
)
1219 char *in_check_mask_char
;
1220 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1221 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char
, in_check_value_char
, in_check_mask_char
);
1222 free(in_check_mask_char
);
1226 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
);
1229 free(captured_char
);
1230 free(in_check_value_char
);
1232 retval
= ERROR_JTAG_QUEUE_FAILED
;
1240 set up checking of this field using the in_handler. The values passed in must be valid until
1241 after jtag_execute() has completed.
1243 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1246 field
->in_handler
= jtag_check_value
;
1248 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1249 field
->in_handler_priv
= NULL
;
1250 field
->in_check_value
= value
;
1251 field
->in_check_mask
= mask
;
1254 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1259 for (i
= 0; i
< cmd
->num_fields
; i
++)
1261 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1263 if (cmd
->fields
[i
].out_value
)
1270 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1276 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1280 retval
= jtag
->execute_queue();
1284 jtag_command_queue
= NULL
;
1285 last_comand_pointer
= &jtag_command_queue
;
1290 int jtag_execute_queue(void)
1292 int retval
=interface_jtag_execute_queue();
1293 if (retval
==ERROR_OK
)
1297 jtag_error
=ERROR_OK
;
1301 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1303 jtag_device_t
*device
= priv
;
1307 if (event
== JTAG_TRST_ASSERTED
)
1309 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1316 void jtag_sleep(u32 us
)
1318 alive_sleep(us
/1000);
1321 /* Try to examine chain layout according to IEEE 1149.1 §12
1323 int jtag_examine_chain(void)
1325 jtag_device_t
*device
= jtag_devices
;
1327 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1330 int device_count
= 0;
1331 u8 zero_check
= 0x0;
1332 u8 one_check
= 0xff;
1335 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1336 field
.out_value
= idcode_buffer
;
1337 field
.out_mask
= NULL
;
1338 field
.in_value
= idcode_buffer
;
1339 field
.in_check_value
= NULL
;
1340 field
.in_check_mask
= NULL
;
1341 field
.in_handler
= NULL
;
1342 field
.in_handler_priv
= NULL
;
1344 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1346 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1349 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1350 jtag_execute_queue();
1352 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1354 zero_check
|= idcode_buffer
[i
];
1355 one_check
&= idcode_buffer
[i
];
1358 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1359 if ((zero_check
== 0x00) || (one_check
== 0xff))
1361 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1362 return ERROR_JTAG_INIT_FAILED
;
1365 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1367 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1368 if ((idcode
& 1) == 0)
1370 /* LSB must not be 0, this indicates a device in bypass */
1371 LOG_WARNING("Device does not have IDCODE");
1382 if (idcode
== 0x000000FF)
1385 /* End of chain (invalid manufacturer ID)
1387 * The JTAG examine is the very first thing that happens
1389 * A single JTAG device requires only 64 bits to be read back correctly.
1391 * The code below adds a check that the rest of the data scanned (640 bits)
1392 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1394 * earlier and gives more helpful/explicit error messages.
1396 for (bit_count
+= 32; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;bit_count
+= 32)
1398 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1399 if (unexpected
||(idcode
!= 0x000000FF))
1401 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count
, idcode
);
1409 manufacturer
= (idcode
& 0xffe) >> 1;
1410 part
= (idcode
& 0xffff000) >> 12;
1411 version
= (idcode
& 0xf0000000) >> 28;
1413 LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1414 idcode
, manufacturer
, part
, version
);
1420 device
->idcode
= idcode
;
1421 device
= device
->next
;
1426 /* see if number of discovered devices matches configuration */
1427 if (device_count
!= jtag_num_devices
)
1429 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1430 device_count
, jtag_num_devices
);
1431 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1432 return ERROR_JTAG_INIT_FAILED
;
1438 int jtag_validate_chain(void)
1440 jtag_device_t
*device
= jtag_devices
;
1441 int total_ir_length
= 0;
1448 total_ir_length
+= device
->ir_length
;
1449 device
= device
->next
;
1452 total_ir_length
+= 2;
1453 ir_test
= malloc(CEIL(total_ir_length
, 8));
1454 buf_set_ones(ir_test
, total_ir_length
);
1457 field
.num_bits
= total_ir_length
;
1458 field
.out_value
= ir_test
;
1459 field
.out_mask
= NULL
;
1460 field
.in_value
= ir_test
;
1461 field
.in_check_value
= NULL
;
1462 field
.in_check_mask
= NULL
;
1463 field
.in_handler
= NULL
;
1464 field
.in_handler_priv
= NULL
;
1466 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1467 jtag_execute_queue();
1469 device
= jtag_devices
;
1472 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1474 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1475 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1478 return ERROR_JTAG_INIT_FAILED
;
1480 chain_pos
+= device
->ir_length
;
1481 device
= device
->next
;
1484 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1486 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1487 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1490 return ERROR_JTAG_INIT_FAILED
;
1500 jim_jtag_command( Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
1505 struct command_context_s
*context
;
1509 JTAG_CMD_INIT_RESET
,
1512 const Jim_Nvp jtag_cmds
[] = {
1513 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
1514 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
1516 { .name
= NULL
, .value
= -1 },
1519 context
= Jim_GetAssocData(interp
, "context");
1520 // go past the command
1521 Jim_GetOpt_Setup( &goi
, interp
, argc
-1, argv
+1 );
1523 e
= Jim_GetOpt_Nvp( &goi
, jtag_cmds
, &n
);
1525 Jim_GetOpt_NvpUnknown( &goi
, jtag_cmds
, 0 );
1528 Jim_SetEmptyResult( goi
.interp
);
1530 case JTAG_CMD_INTERFACE
:
1531 // return the name of the interface
1532 // TCL code might need to know the exact type...
1533 // FUTURE: we allow this as a means to "set" the interface.
1534 if( goi
.argc
!= 0 ){
1535 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1538 Jim_SetResultString( goi
.interp
, jtag_interface
->name
, -1 );
1540 case JTAG_CMD_INIT_RESET
:
1541 if( goi
.argc
!= 0 ){
1542 Jim_WrongNumArgs( goi
.interp
, 1, goi
.argv
-1, "(no params)");
1545 e
= jtag_init_reset(context
);
1546 if( e
!= ERROR_OK
){
1547 Jim_SetResult_sprintf( goi
.interp
, "error: %d", e
);
1557 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1559 register_jim( cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
1561 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1562 COMMAND_CONFIG
, "try to configure interface");
1563 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1564 COMMAND_ANY
, "set jtag speed (if supported)");
1565 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1566 COMMAND_ANY
, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1567 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1568 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1569 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1570 COMMAND_CONFIG
, NULL
);
1571 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1572 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1573 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1574 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1576 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1577 COMMAND_EXEC
, "print current scan chain configuration");
1579 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1580 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1581 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1582 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1583 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1584 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1585 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1586 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1587 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1589 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1590 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1594 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1599 if (!jtag_interface
)
1601 /* nothing was previously specified by "interface" command */
1602 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1603 return ERROR_JTAG_INVALID_INTERFACE
;
1607 jtag_interface
->khz(speed_khz
, &jtag_speed
);
1611 if (jtag_interface
->init() != ERROR_OK
)
1612 return ERROR_JTAG_INIT_FAILED
;
1616 jtag
= jtag_interface
;
1620 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1622 jtag_device_t
*device
;
1625 LOG_DEBUG("Init JTAG chain");
1627 device
= jtag_devices
;
1628 jtag_ir_scan_size
= 0;
1629 jtag_num_devices
= 0;
1630 while (device
!= NULL
)
1632 jtag_ir_scan_size
+= device
->ir_length
;
1634 device
= device
->next
;
1638 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1641 /* examine chain first, as this could discover the real chain layout */
1642 if (jtag_examine_chain() != ERROR_OK
)
1644 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1647 if (jtag_validate_chain() != ERROR_OK
)
1649 LOG_ERROR("Could not validate JTAG chain, continuing anyway...");
1655 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1659 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1662 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR");
1664 /* Reset can happen after a power cycle.
1666 * Ideally we would only assert TRST or run TLR before the target reset.
1668 * However w/srst_pulls_trst, trst is asserted together with the target
1669 * reset whether we want it or not.
1671 * NB! Some targets have JTAG circuitry disabled until a
1672 * trst & srst has been asserted.
1674 * NB! here we assume nsrst/ntrst delay are sufficient!
1676 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1679 jtag_add_reset(1, 0); /* TLR or TRST */
1680 if (jtag_reset_config
& RESET_HAS_SRST
)
1682 jtag_add_reset(1, 1);
1683 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1684 jtag_add_reset(0, 1);
1686 jtag_add_reset(0, 0);
1687 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1690 /* Check that we can communication on the JTAG chain + eventually we want to
1691 * be able to perform enumeration only after OpenOCD has started
1692 * telnet and GDB server
1694 * That would allow users to more easily perform any magic they need to before
1697 return jtag_init_inner(cmd_ctx
);
1700 int jtag_init(struct command_context_s
*cmd_ctx
)
1703 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1705 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1709 return jtag_init_reset(cmd_ctx
);
1712 static int default_khz(int khz
, int *jtag_speed
)
1714 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1718 static int default_speed_div(int speed
, int *khz
)
1720 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1724 static int default_power_dropout(int *dropout
)
1726 *dropout
=0; /* by default we can't detect power dropout */
1730 static int default_srst_asserted(int *srst_asserted
)
1732 *srst_asserted
=0; /* by default we can't detect srst asserted */
1736 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1741 /* check whether the interface is already configured */
1744 LOG_WARNING("Interface already configured, ignoring");
1748 /* interface name is a mandatory argument */
1749 if (argc
< 1 || args
[0][0] == '\0')
1751 return ERROR_COMMAND_SYNTAX_ERROR
;
1754 for (i
=0; jtag_interfaces
[i
]; i
++)
1756 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1758 if ((retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
)) != ERROR_OK
)
1763 jtag_interface
= jtag_interfaces
[i
];
1765 if (jtag_interface
->khz
== NULL
)
1767 jtag_interface
->khz
= default_khz
;
1769 if (jtag_interface
->speed_div
== NULL
)
1771 jtag_interface
->speed_div
= default_speed_div
;
1773 if (jtag_interface
->power_dropout
== NULL
)
1775 jtag_interface
->power_dropout
= default_power_dropout
;
1777 if (jtag_interface
->srst_asserted
== NULL
)
1779 jtag_interface
->srst_asserted
= default_srst_asserted
;
1786 /* no valid interface was found (i.e. the configuration option,
1787 * didn't match one of the compiled-in interfaces
1789 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
1790 LOG_ERROR("compiled-in jtag interfaces:");
1791 for (i
= 0; jtag_interfaces
[i
]; i
++)
1793 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1796 return ERROR_JTAG_INVALID_INTERFACE
;
1799 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1801 jtag_device_t
**last_device_p
= &jtag_devices
;
1805 while ((*last_device_p
)->next
)
1806 last_device_p
= &((*last_device_p
)->next
);
1807 last_device_p
= &((*last_device_p
)->next
);
1813 *last_device_p
= malloc(sizeof(jtag_device_t
));
1814 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1816 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1817 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1818 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1819 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1821 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1822 (*last_device_p
)->bypass
= 1;
1823 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1825 (*last_device_p
)->next
= NULL
;
1827 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1834 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1836 jtag_device_t
*device
= jtag_devices
;
1837 int device_count
= 0;
1841 u32 expected
, expected_mask
, cur_instr
;
1842 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1843 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1844 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1845 command_print(cmd_ctx
, "%i: idcode: 0x%8.8x ir length %i, ir capture 0x%x, ir mask 0x%x, current instruction 0x%x", device_count
, device
->idcode
, device
->ir_length
, expected
, expected_mask
, cur_instr
);
1846 device
= device
->next
;
1853 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1856 return ERROR_COMMAND_SYNTAX_ERROR
;
1860 if (strcmp(args
[0], "none") == 0)
1861 jtag_reset_config
= RESET_NONE
;
1862 else if (strcmp(args
[0], "trst_only") == 0)
1863 jtag_reset_config
= RESET_HAS_TRST
;
1864 else if (strcmp(args
[0], "srst_only") == 0)
1865 jtag_reset_config
= RESET_HAS_SRST
;
1866 else if (strcmp(args
[0], "trst_and_srst") == 0)
1867 jtag_reset_config
= RESET_TRST_AND_SRST
;
1870 LOG_ERROR("invalid reset_config argument, defaulting to none");
1871 jtag_reset_config
= RESET_NONE
;
1872 return ERROR_INVALID_ARGUMENTS
;
1878 if (strcmp(args
[1], "separate") == 0)
1880 /* seperate reset lines - default */
1883 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1884 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1885 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1886 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1887 else if (strcmp(args
[1], "combined") == 0)
1888 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1891 LOG_ERROR("invalid reset_config argument, defaulting to none");
1892 jtag_reset_config
= RESET_NONE
;
1893 return ERROR_INVALID_ARGUMENTS
;
1900 if (strcmp(args
[2], "trst_open_drain") == 0)
1901 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1902 else if (strcmp(args
[2], "trst_push_pull") == 0)
1903 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1906 LOG_ERROR("invalid reset_config argument, defaulting to none");
1907 jtag_reset_config
= RESET_NONE
;
1908 return ERROR_INVALID_ARGUMENTS
;
1914 if (strcmp(args
[3], "srst_push_pull") == 0)
1915 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1916 else if (strcmp(args
[3], "srst_open_drain") == 0)
1917 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1920 LOG_ERROR("invalid reset_config argument, defaulting to none");
1921 jtag_reset_config
= RESET_NONE
;
1922 return ERROR_INVALID_ARGUMENTS
;
1929 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1933 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1938 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1944 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1948 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1953 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1959 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1961 int retval
=ERROR_OK
;
1965 LOG_DEBUG("handle jtag speed");
1968 cur_speed
= jtag_speed
= strtoul(args
[0], NULL
, 0);
1970 /* this command can be called during CONFIG,
1971 * in which case jtag isn't initialized */
1974 retval
=jtag
->speed(cur_speed
);
1976 } else if (argc
== 0)
1980 return ERROR_COMMAND_SYNTAX_ERROR
;
1982 command_print(cmd_ctx
, "jtag_speed: %d", jtag_speed
);
1987 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1989 int retval
=ERROR_OK
;
1990 LOG_DEBUG("handle jtag khz");
1994 speed_khz
= strtoul(args
[0], NULL
, 0);
1998 LOG_DEBUG("have interface set up");
2000 if ((retval
=jtag
->khz(speed_khz
, &speed_div1
))!=ERROR_OK
)
2006 cur_speed
= jtag_speed
= speed_div1
;
2008 retval
=jtag
->speed(cur_speed
);
2017 return ERROR_COMMAND_SYNTAX_ERROR
;
2022 if ((retval
=jtag
->speed_div(jtag_speed
, &speed_khz
))!=ERROR_OK
)
2028 command_print(cmd_ctx
, "RCLK - adaptive");
2031 command_print(cmd_ctx
, "%d kHz", speed_khz
);
2037 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2039 enum tap_state state
;
2043 return ERROR_COMMAND_SYNTAX_ERROR
;
2047 for (state
= 0; state
< 16; state
++)
2049 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
2051 jtag_add_end_state(state
);
2052 jtag_execute_queue();
2056 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[cmd_queue_end_state
]);
2061 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2068 return ERROR_COMMAND_SYNTAX_ERROR
;
2071 if (args
[0][0] == '1')
2073 else if (args
[0][0] == '0')
2077 return ERROR_COMMAND_SYNTAX_ERROR
;
2080 if (args
[1][0] == '1')
2082 else if (args
[1][0] == '0')
2086 return ERROR_COMMAND_SYNTAX_ERROR
;
2089 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
2090 return ERROR_JTAG_INIT_FAILED
;
2092 jtag_add_reset(trst
, srst
);
2093 jtag_execute_queue();
2098 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2102 return ERROR_COMMAND_SYNTAX_ERROR
;
2105 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
2106 jtag_execute_queue();
2112 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2115 scan_field_t
*fields
;
2117 if ((argc
< 2) || (argc
% 2))
2119 return ERROR_COMMAND_SYNTAX_ERROR
;
2122 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
2124 for (i
= 0; i
< argc
/ 2; i
++)
2126 int device
= strtoul(args
[i
*2], NULL
, 0);
2127 jtag_device_t
*device_ptr
=jtag_get_device(device
);
2128 if (device_ptr
==NULL
)
2132 int field_size
= device_ptr
->ir_length
;
2133 fields
[i
].device
= device
;
2134 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2135 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2136 fields
[i
].out_mask
= NULL
;
2137 fields
[i
].in_value
= NULL
;
2138 fields
[i
].in_check_mask
= NULL
;
2139 fields
[i
].in_handler
= NULL
;
2140 fields
[i
].in_handler_priv
= NULL
;
2143 jtag_add_ir_scan(argc
/ 2, fields
, -1);
2144 jtag_execute_queue();
2146 for (i
= 0; i
< argc
/ 2; i
++)
2147 free(fields
[i
].out_value
);
2154 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2157 scan_field_t
*fields
;
2159 int field_count
= 0;
2164 * args[2] = num_bits
2165 * args[3] = hex string
2166 * ... repeat num bits and hex string ...
2168 if ((argc
< 4) || ((argc
% 2)!=0))
2170 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
2174 for (i
= 2; i
< argc
; i
+=2)
2178 e
= Jim_GetLong(interp
, args
[i
], &bits
);
2183 e
= Jim_GetLong(interp
, args
[1], &device
);
2187 num_fields
=(argc
-2)/2;
2188 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2189 for (i
= 2; i
< argc
; i
+=2)
2195 Jim_GetLong(interp
, args
[i
], &bits
);
2196 str
= Jim_GetString(args
[i
+1], &len
);
2198 fields
[field_count
].device
= device
;
2199 fields
[field_count
].num_bits
= bits
;
2200 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2201 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
2202 fields
[field_count
].out_mask
= NULL
;
2203 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2204 fields
[field_count
].in_check_mask
= NULL
;
2205 fields
[field_count
].in_check_value
= NULL
;
2206 fields
[field_count
].in_handler
= NULL
;
2207 fields
[field_count
++].in_handler_priv
= NULL
;
2210 jtag_add_dr_scan(num_fields
, fields
, -1);
2211 retval
= jtag_execute_queue();
2212 if (retval
!= ERROR_OK
)
2214 Jim_SetResult(interp
, Jim_NewEmptyStringObj(interp
));
2215 Jim_AppendStrings(interp
, Jim_GetResult(interp
), "drscan: jtag execute failed", NULL
);
2220 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
2221 for (i
= 2; i
< argc
; i
+=2)
2226 Jim_GetLong(interp
, args
[i
], &bits
);
2227 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
2228 free(fields
[field_count
].out_value
);
2230 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
2235 Jim_SetResult(interp
, list
);
2242 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2246 if (strcmp(args
[0], "enable") == 0)
2248 jtag_verify_capture_ir
= 1;
2250 else if (strcmp(args
[0], "disable") == 0)
2252 jtag_verify_capture_ir
= 0;
2255 return ERROR_COMMAND_SYNTAX_ERROR
;
2257 } else if (argc
!= 0)
2259 return ERROR_COMMAND_SYNTAX_ERROR
;
2262 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
2268 int jtag_power_dropout(int *dropout
)
2270 return jtag
->power_dropout(dropout
);
2273 int jtag_srst_asserted(int *srst_asserted
)
2275 return jtag
->srst_asserted(srst_asserted
);