1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
30 #include "interpreter.h"
36 char* tap_state_strings
[16] =
39 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
41 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
44 typedef struct cmd_queue_page_s
48 struct cmd_queue_page_s
*next
;
51 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
52 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
54 /* tap_move[i][j]: tap movement command to go from state i to state j
62 * SD->SD and SI->SI have to be caught in interface specific code
66 /* TLR RTI SD PD SI PI */
67 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
68 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
69 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
70 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
71 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
72 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
75 int tap_move_map
[16] = {
76 0, -1, -1, 2, -1, 3, -1, -1,
77 1, -1, -1, 4, -1, 5, -1, -1
80 tap_transition_t tap_transitions
[16] =
82 {TAP_TLR
, TAP_RTI
}, /* TLR */
83 {TAP_SIS
, TAP_CD
}, /* SDS */
84 {TAP_E1D
, TAP_SD
}, /* CD */
85 {TAP_E1D
, TAP_SD
}, /* SD */
86 {TAP_UD
, TAP_PD
}, /* E1D */
87 {TAP_E2D
, TAP_PD
}, /* PD */
88 {TAP_UD
, TAP_SD
}, /* E2D */
89 {TAP_SDS
, TAP_RTI
}, /* UD */
90 {TAP_SDS
, TAP_RTI
}, /* RTI */
91 {TAP_TLR
, TAP_CI
}, /* SIS */
92 {TAP_E1I
, TAP_SI
}, /* CI */
93 {TAP_E1I
, TAP_SI
}, /* SI */
94 {TAP_UI
, TAP_PI
}, /* E1I */
95 {TAP_E2I
, TAP_PI
}, /* PI */
96 {TAP_UI
, TAP_SI
}, /* E2I */
97 {TAP_SDS
, TAP_RTI
} /* UI */
100 char* jtag_event_strings
[] =
108 enum tap_state end_state
= TAP_TLR
;
109 enum tap_state cur_state
= TAP_TLR
;
113 jtag_command_t
*jtag_command_queue
= NULL
;
114 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
115 jtag_device_t
*jtag_devices
= NULL
;
116 int jtag_num_devices
= 0;
117 int jtag_ir_scan_size
= 0;
118 enum reset_types jtag_reset_config
= RESET_NONE
;
119 enum tap_state cmd_queue_end_state
= TAP_TLR
;
120 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
122 int jtag_verify_capture_ir
= 1;
124 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
125 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
126 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
128 /* maximum number of JTAG devices expected in the chain
130 #define JTAG_MAX_CHAIN_SIZE 20
132 /* callbacks to inform high-level handlers about JTAG state changes */
133 jtag_event_callback_t
*jtag_event_callbacks
;
135 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
137 #if BUILD_PARPORT == 1
138 extern jtag_interface_t parport_interface
;
141 #if BUILD_FT2232_FTD2XX == 1
142 extern jtag_interface_t ft2232_interface
;
145 #if BUILD_FT2232_LIBFTDI == 1
146 extern jtag_interface_t ft2232_interface
;
149 #if BUILD_AMTJTAGACCEL == 1
150 extern jtag_interface_t amt_jtagaccel_interface
;
153 #if BUILD_EP93XX == 1
154 extern jtag_interface_t ep93xx_interface
;
157 #if BUILD_AT91RM9200 == 1
158 extern jtag_interface_t at91rm9200_interface
;
161 #if BUILD_GW16012 == 1
162 extern jtag_interface_t gw16012_interface
;
165 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
166 extern jtag_interface_t presto_interface
;
169 #if BUILD_USBPROG == 1
170 extern jtag_interface_t usbprog_interface
;
173 jtag_interface_t
*jtag_interfaces
[] = {
174 #if BUILD_PARPORT == 1
177 #if BUILD_FT2232_FTD2XX == 1
180 #if BUILD_FT2232_LIBFTDI == 1
183 #if BUILD_AMTJTAGACCEL == 1
184 &amt_jtagaccel_interface
,
186 #if BUILD_EP93XX == 1
189 #if BUILD_AT91RM9200 == 1
190 &at91rm9200_interface
,
192 #if BUILD_GW16012 == 1
195 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
198 #if BUILD_USBPROG == 1
204 jtag_interface_t
*jtag
= NULL
;
207 char* jtag_interface
= NULL
;
211 /* forward declarations */
212 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
213 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
214 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
215 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
216 int jtag_add_statemove(enum tap_state endstate
);
217 int jtag_add_pathmove(int num_states
, enum tap_state
*path
);
218 int jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
219 int jtag_add_reset(int trst
, int srst
);
220 int jtag_add_end_state(enum tap_state endstate
);
221 int jtag_add_sleep(u32 us
);
222 int jtag_execute_queue(void);
223 int jtag_cancel_queue(void);
226 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
227 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
228 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
229 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
230 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
231 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
233 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
235 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
236 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
237 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
238 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
239 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
240 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
242 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
244 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
246 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
248 if (callback
== NULL
)
250 return ERROR_INVALID_ARGUMENTS
;
255 while ((*callbacks_p
)->next
)
256 callbacks_p
= &((*callbacks_p
)->next
);
257 callbacks_p
= &((*callbacks_p
)->next
);
260 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
261 (*callbacks_p
)->callback
= callback
;
262 (*callbacks_p
)->priv
= priv
;
263 (*callbacks_p
)->next
= NULL
;
268 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
270 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
272 if (callback
== NULL
)
274 return ERROR_INVALID_ARGUMENTS
;
279 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
280 if ((*callbacks_p
)->callback
== callback
)
283 *callbacks_p
= *next
;
291 int jtag_call_event_callbacks(enum jtag_event event
)
293 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
295 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
299 callback
->callback(event
, callback
->priv
);
300 callback
= callback
->next
;
306 /* returns a pointer to the pointer of the last command in queue
307 * this may be a pointer to the root pointer (jtag_command_queue)
308 * or to the next member of the last but one command
310 jtag_command_t
** jtag_get_last_command_p(void)
312 /* jtag_command_t *cmd = jtag_command_queue;
318 return &jtag_command_queue;
322 return last_comand_pointer
;
325 /* returns a pointer to the n-th device in the scan chain */
326 jtag_device_t
* jtag_get_device(int num
)
328 jtag_device_t
*device
= jtag_devices
;
335 device
= device
->next
;
342 void* cmd_queue_alloc(size_t size
)
344 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
349 while ((*p_page
)->next
)
350 p_page
= &((*p_page
)->next
);
351 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
352 p_page
= &((*p_page
)->next
);
357 *p_page
= malloc(sizeof(cmd_queue_page_t
));
359 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
360 (*p_page
)->next
= NULL
;
363 offset
= (*p_page
)->used
;
364 (*p_page
)->used
+= size
;
366 return ((*p_page
)->address
) + offset
;
369 void cmd_queue_free()
371 cmd_queue_page_t
*page
= cmd_queue_pages
;
375 cmd_queue_page_t
*last
= page
;
381 cmd_queue_pages
= NULL
;
384 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
386 jtag_command_t
**last_cmd
;
387 jtag_device_t
*device
;
393 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
394 return ERROR_JTAG_TRST_ASSERTED
;
397 last_cmd
= jtag_get_last_command_p();
399 /* allocate memory for a new list member */
400 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
401 (*last_cmd
)->next
= NULL
;
402 last_comand_pointer
= &((*last_cmd
)->next
);
403 (*last_cmd
)->type
= JTAG_SCAN
;
405 /* allocate memory for ir scan command */
406 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
407 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
408 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
409 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
410 (*last_cmd
)->cmd
.scan
->end_state
= state
;
413 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
414 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
418 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
422 cmd_queue_end_state
= state
;
424 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
425 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
427 if (cmd_queue_end_state
== TAP_TLR
)
428 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
430 cmd_queue_cur_state
= cmd_queue_end_state
;
432 for (i
=0; i
< jtag_num_devices
; i
++)
435 device
= jtag_get_device(i
);
436 scan_size
= device
->ir_length
;
437 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
438 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
439 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
440 if (jtag_verify_capture_ir
)
442 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
443 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
447 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
448 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
450 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
451 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
453 /* search the list */
454 for (j
=0; j
< num_fields
; j
++)
456 if (i
== fields
[j
].device
)
459 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
460 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
469 /* if a device isn't listed, set it to BYPASS */
470 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
471 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
476 /* update device information */
477 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
483 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
485 jtag_command_t
**last_cmd
;
490 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
491 return ERROR_JTAG_TRST_ASSERTED
;
494 last_cmd
= jtag_get_last_command_p();
496 /* allocate memory for a new list member */
497 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
498 (*last_cmd
)->next
= NULL
;
499 last_comand_pointer
= &((*last_cmd
)->next
);
500 (*last_cmd
)->type
= JTAG_SCAN
;
502 /* allocate memory for ir scan command */
503 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
504 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
505 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
506 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
507 (*last_cmd
)->cmd
.scan
->end_state
= state
;
510 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
511 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
515 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
519 cmd_queue_end_state
= state
;
521 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
522 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
524 if (cmd_queue_end_state
== TAP_TLR
)
525 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
527 cmd_queue_cur_state
= cmd_queue_end_state
;
529 for (i
= 0; i
< num_fields
; i
++)
531 int num_bits
= fields
[i
].num_bits
;
532 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
533 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
534 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
535 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
536 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
537 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
538 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
539 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
540 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
541 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
546 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
549 int bypass_devices
= 0;
551 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
552 jtag_device_t
*device
= jtag_devices
;
557 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
558 return ERROR_JTAG_TRST_ASSERTED
;
561 /* count devices in bypass */
566 device
= device
->next
;
569 /* allocate memory for a new list member */
570 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
571 last_comand_pointer
= &((*last_cmd
)->next
);
572 (*last_cmd
)->next
= NULL
;
573 (*last_cmd
)->type
= JTAG_SCAN
;
575 /* allocate memory for dr scan command */
576 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
577 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
578 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
579 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
580 (*last_cmd
)->cmd
.scan
->end_state
= state
;
583 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
584 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
588 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
592 cmd_queue_end_state
= state
;
594 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
595 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
597 if (cmd_queue_end_state
== TAP_TLR
)
598 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
600 cmd_queue_cur_state
= cmd_queue_end_state
;
602 for (i
=0; i
< jtag_num_devices
; i
++)
605 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
607 for (j
=0; j
< num_fields
; j
++)
609 if (i
== fields
[j
].device
)
612 scan_size
= fields
[j
].num_bits
;
613 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
614 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
615 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
616 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
617 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= buf_cpy(fields
[j
].in_check_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
618 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= buf_cpy(fields
[j
].in_check_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
619 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
620 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
625 /* if a device isn't listed, the BYPASS register should be selected */
626 if (!jtag_get_device(i
)->bypass
)
628 ERROR("BUG: no scan data for a device not in BYPASS");
632 /* program the scan field to 1 bit length, and ignore it's value */
633 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
634 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
635 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
636 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
637 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
638 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
639 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
640 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
644 /* if a device is listed, the BYPASS register must not be selected */
645 if (jtag_get_device(i
)->bypass
)
647 WARNING("scan data for a device in BYPASS");
654 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
657 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
661 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
662 return ERROR_JTAG_TRST_ASSERTED
;
665 /* allocate memory for a new list member */
666 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
667 last_comand_pointer
= &((*last_cmd
)->next
);
668 (*last_cmd
)->next
= NULL
;
669 (*last_cmd
)->type
= JTAG_SCAN
;
671 /* allocate memory for scan command */
672 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
673 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
674 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
675 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
676 (*last_cmd
)->cmd
.scan
->end_state
= state
;
679 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
680 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
684 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
688 cmd_queue_end_state
= state
;
690 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
691 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
693 if (cmd_queue_end_state
== TAP_TLR
)
694 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
696 cmd_queue_cur_state
= cmd_queue_end_state
;
698 for (i
= 0; i
< num_fields
; i
++)
700 int num_bits
= fields
[i
].num_bits
;
701 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
702 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
703 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
704 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
705 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
706 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
707 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
708 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
709 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
710 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
715 int jtag_add_statemove(enum tap_state state
)
717 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
721 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
722 return ERROR_JTAG_TRST_ASSERTED
;
725 /* allocate memory for a new list member */
726 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
727 last_comand_pointer
= &((*last_cmd
)->next
);
728 (*last_cmd
)->next
= NULL
;
729 (*last_cmd
)->type
= JTAG_STATEMOVE
;
731 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
732 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
735 cmd_queue_end_state
= state
;
737 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
738 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
740 if (cmd_queue_end_state
== TAP_TLR
)
741 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
743 cmd_queue_cur_state
= cmd_queue_end_state
;
748 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
750 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
755 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
756 return ERROR_JTAG_TRST_ASSERTED
;
759 /* the last state has to be a stable state */
760 if (tap_move_map
[path
[num_states
- 1]] == -1)
762 ERROR("TAP path doesn't finish in a stable state");
763 return ERROR_JTAG_NOT_IMPLEMENTED
;
766 if (jtag
->support_pathmove
)
768 /* allocate memory for a new list member */
769 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
770 last_comand_pointer
= &((*last_cmd
)->next
);
771 (*last_cmd
)->next
= NULL
;
772 (*last_cmd
)->type
= JTAG_PATHMOVE
;
774 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
775 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
776 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
778 for (i
= 0; i
< num_states
; i
++)
779 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
783 /* validate the desired path, and see if it fits a default path */
788 for (i
= 0; i
< num_states
; i
++)
790 for (j
= i
; j
< num_states
; j
++)
792 if (tap_move_map
[path
[j
]] != -1)
799 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
801 jtag_add_statemove(path
[end
]);
805 ERROR("encountered a TAP path that can't be fulfilled by default paths");
806 return ERROR_JTAG_NOT_IMPLEMENTED
;
813 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
814 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
816 if (cmd_queue_end_state
== TAP_TLR
)
817 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
819 cmd_queue_cur_state
= path
[num_states
- 1];
824 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
826 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
830 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
831 return ERROR_JTAG_TRST_ASSERTED
;
834 /* allocate memory for a new list member */
835 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
836 (*last_cmd
)->next
= NULL
;
837 last_comand_pointer
= &((*last_cmd
)->next
);
838 (*last_cmd
)->type
= JTAG_RUNTEST
;
840 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
841 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
842 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
845 cmd_queue_end_state
= state
;
847 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
848 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
850 if (cmd_queue_end_state
== TAP_TLR
)
851 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
853 cmd_queue_cur_state
= cmd_queue_end_state
;
858 int jtag_add_reset(int req_trst
, int req_srst
)
860 int trst_with_tms
= 0;
862 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
865 req_trst
= jtag_trst
;
868 req_srst
= jtag_srst
;
870 /* Make sure that jtag_reset_config allows the requested reset */
871 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
872 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
873 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
875 /* if TRST pulls SRST, we reset with TAP T-L-R */
876 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
882 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
884 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
885 return ERROR_JTAG_RESET_CANT_SRST
;
888 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
894 /* allocate memory for a new list member */
895 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
896 (*last_cmd
)->next
= NULL
;
897 last_comand_pointer
= &((*last_cmd
)->next
);
898 (*last_cmd
)->type
= JTAG_RESET
;
900 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
901 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
902 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
904 jtag_trst
= req_trst
;
905 jtag_srst
= req_srst
;
909 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
913 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
914 if (jtag_nsrst_delay
)
915 jtag_add_sleep(jtag_nsrst_delay
* 1000);
920 last_cmd
= &((*last_cmd
)->next
);
922 /* allocate memory for a new list member */
923 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
924 (*last_cmd
)->next
= NULL
;
925 last_comand_pointer
= &((*last_cmd
)->next
);
926 (*last_cmd
)->type
= JTAG_STATEMOVE
;
928 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
929 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
931 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
932 cmd_queue_cur_state
= TAP_TLR
;
933 cmd_queue_end_state
= TAP_TLR
;
941 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
942 * and inform possible listeners about this
944 cmd_queue_cur_state
= TAP_TLR
;
945 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
949 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
950 * but we might want to add a delay to give the TAP time to settle
952 if (jtag_ntrst_delay
)
953 jtag_add_sleep(jtag_ntrst_delay
* 1000);
960 int jtag_add_end_state(enum tap_state state
)
962 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
964 /* allocate memory for a new list member */
965 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
966 (*last_cmd
)->next
= NULL
;
967 last_comand_pointer
= &((*last_cmd
)->next
);
968 (*last_cmd
)->type
= JTAG_END_STATE
;
970 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
971 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
974 cmd_queue_end_state
= state
;
979 int jtag_add_sleep(u32 us
)
981 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
983 /* allocate memory for a new list member */
984 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
985 (*last_cmd
)->next
= NULL
;
986 last_comand_pointer
= &((*last_cmd
)->next
);
987 (*last_cmd
)->type
= JTAG_SLEEP
;
989 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
990 (*last_cmd
)->cmd
.sleep
->us
= us
;
995 int jtag_scan_size(scan_command_t
*cmd
)
1000 /* count bits in scan command */
1001 for (i
=0; i
<cmd
->num_fields
; i
++)
1003 bit_count
+= cmd
->fields
[i
].num_bits
;
1009 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1014 bit_count
= jtag_scan_size(cmd
);
1015 *buffer
= malloc(CEIL(bit_count
, 8));
1019 for (i
= 0; i
< cmd
->num_fields
; i
++)
1021 if (cmd
->fields
[i
].out_value
)
1023 #ifdef _DEBUG_JTAG_IO_
1024 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1026 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1027 #ifdef _DEBUG_JTAG_IO_
1028 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1033 bit_count
+= cmd
->fields
[i
].num_bits
;
1040 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1046 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1049 for (i
=0; i
< cmd
->num_fields
; i
++)
1051 /* if neither in_value, in_check_value nor in_handler
1052 * are specified we don't have to examine this field
1054 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_handler
)
1056 int num_bits
= cmd
->fields
[i
].num_bits
;
1057 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1059 #ifdef _DEBUG_JTAG_IO_
1062 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1063 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1067 if (cmd
->fields
[i
].in_value
)
1069 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1071 if (cmd
->fields
[i
].in_handler
)
1073 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1075 WARNING("in_handler reported a failed check");
1076 retval
= ERROR_JTAG_QUEUE_FAILED
;
1081 /* no in_value specified, but a handler takes care of the scanned data */
1082 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1084 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1086 /* We're going to call the error:handler later, but if the in_handler
1087 * reported an error we report this failure upstream
1089 WARNING("in_handler reported a failed check");
1090 retval
= ERROR_JTAG_QUEUE_FAILED
;
1094 if (cmd
->fields
[i
].in_check_value
)
1096 int compare_failed
= 0;
1098 if (cmd
->fields
[i
].in_check_mask
)
1099 compare_failed
= buf_cmp_mask(captured
, cmd
->fields
[i
].in_check_value
, cmd
->fields
[i
].in_check_mask
, num_bits
);
1101 compare_failed
= buf_cmp(captured
, cmd
->fields
[i
].in_check_value
, num_bits
);
1105 if (cmd
->error_handler
)
1107 /* ask the error handler if once has been specified if this is a real problem */
1108 if (cmd
->error_handler
->error_handler(captured
, cmd
->error_handler
->error_handler_priv
) != ERROR_OK
)
1109 retval
= ERROR_JTAG_QUEUE_FAILED
;
1115 /* if there wasn't a handler specified, we report a failure */
1116 retval
= ERROR_JTAG_QUEUE_FAILED
;
1119 /* An error handler could have caught the failing check
1120 * only report a problem when there wasn't a handler, or if the handler
1121 * acknowledged the error
1125 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1126 char *in_check_value_char
= buf_to_str(cmd
->fields
[i
].in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1128 if (cmd
->fields
[i
].in_check_mask
)
1130 char *in_check_mask_char
;
1131 in_check_mask_char
= buf_to_str(cmd
->fields
[i
].in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1132 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
);
1133 free(in_check_mask_char
);
1137 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1140 free(captured_char
);
1141 free(in_check_value_char
);
1148 bit_count
+= cmd
->fields
[i
].num_bits
;
1154 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1159 for (i
=0; i
< cmd
->num_fields
; i
++)
1161 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1163 if (cmd
->fields
[i
].out_value
)
1170 int jtag_execute_queue(void)
1174 retval
= jtag
->execute_queue();
1178 jtag_command_queue
= NULL
;
1179 last_comand_pointer
= &jtag_command_queue
;
1184 int jtag_cancel_queue(void)
1187 jtag_command_queue
= NULL
;
1188 last_comand_pointer
= &jtag_command_queue
;
1193 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1195 jtag_device_t
*device
= priv
;
1199 if (event
== JTAG_TRST_ASSERTED
)
1201 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1208 void jtag_sleep(u32 us
)
1213 /* Try to examine chain layout according to IEEE 1149.1 §12
1215 int jtag_examine_chain()
1217 jtag_device_t
*device
= jtag_devices
;
1219 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1222 int device_count
= 0;
1223 u8 zero_check
= 0x0;
1224 u8 one_check
= 0xff;
1227 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1228 field
.out_value
= idcode_buffer
;
1229 field
.out_mask
= NULL
;
1230 field
.in_value
= idcode_buffer
;
1231 field
.in_check_value
= NULL
;
1232 field
.in_check_mask
= NULL
;
1233 field
.in_handler
= NULL
;
1234 field
.in_handler_priv
= NULL
;
1236 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1238 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1241 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
, NULL
);
1242 jtag_execute_queue();
1244 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1246 zero_check
|= idcode_buffer
[i
];
1247 one_check
&= idcode_buffer
[i
];
1250 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1251 if ((zero_check
== 0x00) || (one_check
== 0xff))
1253 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1254 return ERROR_JTAG_INIT_FAILED
;
1257 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1259 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1260 if ((idcode
& 1) == 0)
1262 /* LSB must not be 0, this indicates a device in bypass */
1273 if (idcode
== 0x000000FF)
1275 /* End of chain (invalid manufacturer ID) */
1281 device
->idcode
= idcode
;
1282 device
= device
->next
;
1286 manufacturer
= (idcode
& 0xffe) >> 1;
1287 part
= (idcode
& 0xffff000) >> 12;
1288 version
= (idcode
& 0xf0000000) >> 28;
1290 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1291 idcode
, manufacturer
, part
, version
);
1297 /* see if number of discovered devices matches configuration */
1298 if (device_count
!= jtag_num_devices
)
1300 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1301 device_count
, jtag_num_devices
);
1302 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1303 return ERROR_JTAG_INIT_FAILED
;
1309 int jtag_validate_chain()
1311 jtag_device_t
*device
= jtag_devices
;
1312 int total_ir_length
= 0;
1319 total_ir_length
+= device
->ir_length
;
1320 device
= device
->next
;
1323 total_ir_length
+= 2;
1324 ir_test
= malloc(CEIL(total_ir_length
, 8));
1325 buf_set_ones(ir_test
, total_ir_length
);
1328 field
.num_bits
= total_ir_length
;
1329 field
.out_value
= ir_test
;
1330 field
.out_mask
= NULL
;
1331 field
.in_value
= ir_test
;
1332 field
.in_check_value
= NULL
;
1333 field
.in_check_mask
= NULL
;
1334 field
.in_handler
= NULL
;
1335 field
.in_handler_priv
= NULL
;
1337 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
, NULL
);
1338 jtag_execute_queue();
1340 device
= jtag_devices
;
1343 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1345 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1346 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1349 return ERROR_JTAG_INIT_FAILED
;
1351 chain_pos
+= device
->ir_length
;
1352 device
= device
->next
;
1355 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1357 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1358 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1361 return ERROR_JTAG_INIT_FAILED
;
1369 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1371 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1372 COMMAND_CONFIG
, NULL
);
1373 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1374 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1375 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1376 COMMAND_CONFIG
, NULL
);
1377 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1378 COMMAND_CONFIG
, NULL
);
1379 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1380 COMMAND_CONFIG
, NULL
);
1381 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1382 COMMAND_CONFIG
, NULL
);
1384 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1385 COMMAND_EXEC
, "print current scan chain configuration");
1387 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1388 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1389 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1390 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1391 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1392 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1393 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1394 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1395 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1396 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1397 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1398 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1400 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1401 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1405 int jtag_init(struct command_context_s
*cmd_ctx
)
1407 int i
, validate_tries
= 0;
1411 if (jtag_speed
== -1)
1414 if (jtag_interface
&& (jtag_interface
[0] != 0))
1415 /* configuration var 'jtag_interface' is set, and not empty */
1416 for (i
= 0; jtag_interfaces
[i
]; i
++)
1418 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1420 jtag_device_t
*device
;
1421 device
= jtag_devices
;
1423 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1424 return ERROR_JTAG_INIT_FAILED
;
1425 jtag
= jtag_interfaces
[i
];
1427 jtag_ir_scan_size
= 0;
1428 jtag_num_devices
= 0;
1429 while (device
!= NULL
)
1431 jtag_ir_scan_size
+= device
->ir_length
;
1433 device
= device
->next
;
1436 jtag_add_statemove(TAP_TLR
);
1437 jtag_execute_queue();
1439 /* examine chain first, as this could discover the real chain layout */
1440 if (jtag_examine_chain() != ERROR_OK
)
1442 ERROR("trying to validate configured JTAG chain anyway...");
1445 while (jtag_validate_chain() != ERROR_OK
)
1448 if (validate_tries
> 5)
1450 ERROR("Could not validate JTAG chain, exit");
1452 return ERROR_JTAG_INVALID_INTERFACE
;
1461 /* no valid interface was found (i.e. the configuration option,
1462 * didn't match one of the compiled-in interfaces
1464 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1465 ERROR("compiled-in jtag interfaces:");
1466 for (i
= 0; jtag_interfaces
[i
]; i
++)
1468 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1472 return ERROR_JTAG_INVALID_INTERFACE
;
1475 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1479 /* only if the configuration var isn't overwritten from cmdline */
1480 if (!jtag_interface
)
1482 if (args
[0] && (args
[0][0] != 0))
1484 for (i
=0; jtag_interfaces
[i
]; i
++)
1486 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1488 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1491 jtag_interface
= jtag_interfaces
[i
]->name
;
1498 /* remember the requested interface name, so we can complain about it later */
1499 jtag_interface
= strdup(args
[0]);
1500 DEBUG("'interface' command didn't specify a valid interface");
1506 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1508 jtag_device_t
**last_device_p
= &jtag_devices
;
1512 while ((*last_device_p
)->next
)
1513 last_device_p
= &((*last_device_p
)->next
);
1514 last_device_p
= &((*last_device_p
)->next
);
1520 *last_device_p
= malloc(sizeof(jtag_device_t
));
1521 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1523 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1524 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1525 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1526 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1528 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1529 (*last_device_p
)->bypass
= 1;
1530 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1532 (*last_device_p
)->next
= NULL
;
1534 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1541 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1543 jtag_device_t
*device
= jtag_devices
;
1544 int device_count
= 0;
1548 u32 expected
, expected_mask
, cur_instr
;
1549 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1550 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1551 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1552 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
);
1553 device
= device
->next
;
1560 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1564 if (strcmp(args
[0], "none") == 0)
1565 jtag_reset_config
= RESET_NONE
;
1566 else if (strcmp(args
[0], "trst_only") == 0)
1567 jtag_reset_config
= RESET_HAS_TRST
;
1568 else if (strcmp(args
[0], "srst_only") == 0)
1569 jtag_reset_config
= RESET_HAS_SRST
;
1570 else if (strcmp(args
[0], "trst_and_srst") == 0)
1571 jtag_reset_config
= RESET_TRST_AND_SRST
;
1574 ERROR("invalid reset_config argument, defaulting to none");
1575 jtag_reset_config
= RESET_NONE
;
1576 return ERROR_INVALID_ARGUMENTS
;
1582 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1583 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1584 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1585 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1586 else if (strcmp(args
[1], "combined") == 0)
1587 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1588 else if (strcmp(args
[1], "separate") == 0)
1589 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1592 ERROR("invalid reset_config argument, defaulting to none");
1593 jtag_reset_config
= RESET_NONE
;
1594 return ERROR_INVALID_ARGUMENTS
;
1600 if (strcmp(args
[2], "trst_open_drain") == 0)
1601 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1602 else if (strcmp(args
[2], "trst_push_pull") == 0)
1603 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1606 ERROR("invalid reset_config argument, defaulting to none");
1607 jtag_reset_config
= RESET_NONE
;
1608 return ERROR_INVALID_ARGUMENTS
;
1614 if (strcmp(args
[3], "srst_push_pull") == 0)
1615 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1616 else if (strcmp(args
[3], "srst_open_drain") == 0)
1617 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1620 ERROR("invalid reset_config argument, defaulting to none");
1621 jtag_reset_config
= RESET_NONE
;
1622 return ERROR_INVALID_ARGUMENTS
;
1629 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1633 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1638 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1644 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1648 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1653 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1659 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1662 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1666 /* this command can be called during CONFIG,
1667 * in which case jtag isn't initialized */
1669 jtag
->speed(strtoul(args
[0], NULL
, 0));
1671 jtag_speed
= strtoul(args
[0], NULL
, 0);
1677 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1679 enum tap_state state
;
1683 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1687 for (state
= 0; state
< 16; state
++)
1689 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1691 jtag_add_end_state(state
);
1692 jtag_execute_queue();
1696 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1701 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1705 char *usage
= "usage: jtag_reset <trst> <srst>";
1710 command_print(cmd_ctx
, usage
);
1714 if (args
[0][0] == '1')
1716 else if (args
[0][0] == '0')
1720 command_print(cmd_ctx
, usage
);
1724 if (args
[1][0] == '1')
1726 else if (args
[1][0] == '0')
1730 command_print(cmd_ctx
, usage
);
1734 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1738 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1739 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1741 case ERROR_JTAG_RESET_CANT_SRST
:
1742 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1745 command_print(cmd_ctx
, "unknown error");
1748 jtag_execute_queue();
1753 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1757 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1761 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1762 jtag_execute_queue();
1768 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1770 enum tap_state state
;
1775 for (state
= 0; state
< 16; state
++)
1777 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1784 jtag_add_statemove(state
);
1785 jtag_execute_queue();
1791 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1794 scan_field_t
*fields
;
1796 if ((argc
< 2) || (argc
% 2))
1798 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1802 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1804 for (i
= 0; i
< argc
/ 2; i
++)
1806 int device
= strtoul(args
[i
*2], NULL
, 0);
1807 int field_size
= jtag_get_device(device
)->ir_length
;
1808 fields
[i
].device
= device
;
1809 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1810 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1811 fields
[i
].out_mask
= NULL
;
1812 fields
[i
].in_value
= NULL
;
1813 fields
[i
].in_check_mask
= NULL
;
1814 fields
[i
].in_handler
= NULL
;
1815 fields
[i
].in_handler_priv
= NULL
;
1818 jtag_add_ir_scan(argc
/ 2, fields
, -1, NULL
);
1819 jtag_execute_queue();
1821 for (i
= 0; i
< argc
/ 2; i
++)
1822 free(fields
[i
].out_value
);
1829 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1831 scan_field_t
*fields
;
1833 int field_count
= 0;
1837 if ((argc
< 2) || (argc
% 2))
1839 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1843 for (i
= 0; i
< argc
; i
+=2)
1845 var
= get_var_by_namenum(args
[i
+1]);
1848 num_fields
+= var
->num_fields
;
1852 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1857 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1859 for (i
= 0; i
< argc
; i
+=2)
1861 var
= get_var_by_namenum(args
[i
+1]);
1863 for (j
= 0; j
< var
->num_fields
; j
++)
1865 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1866 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1867 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1868 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1869 fields
[field_count
].out_mask
= NULL
;
1870 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1871 fields
[field_count
].in_check_mask
= NULL
;
1872 fields
[field_count
].in_check_value
= NULL
;
1873 fields
[field_count
].in_handler
= field_le_to_host
;
1874 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1878 jtag_add_dr_scan(num_fields
, fields
, -1, NULL
);
1879 jtag_execute_queue();
1881 for (i
= 0; i
< argc
/ 2; i
++)
1882 free(fields
[i
].out_value
);
1889 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1893 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1897 if (strcmp(args
[0], "enable") == 0)
1899 jtag_verify_capture_ir
= 1;
1901 else if (strcmp(args
[0], "disable") == 0)
1903 jtag_verify_capture_ir
= 0;
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)