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 jtag_interface_t
*jtag_interfaces
[] = {
166 #if BUILD_PARPORT == 1
169 #if BUILD_FT2232_FTD2XX == 1
172 #if BUILD_FT2232_LIBFTDI == 1
175 #if BUILD_AMTJTAGACCEL == 1
176 &amt_jtagaccel_interface
,
178 #if BUILD_EP93XX == 1
181 #if BUILD_AT91RM9200 == 1
182 &at91rm9200_interface
,
184 #if BUILD_GW16012 == 1
190 jtag_interface_t
*jtag
= NULL
;
193 char* jtag_interface
= NULL
;
197 /* forward declarations */
198 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
199 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
200 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
201 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
202 int jtag_add_statemove(enum tap_state endstate
);
203 int jtag_add_pathmove(int num_states
, enum tap_state
*path
);
204 int jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
205 int jtag_add_reset(int trst
, int srst
);
206 int jtag_add_end_state(enum tap_state endstate
);
207 int jtag_add_sleep(u32 us
);
208 int jtag_execute_queue(void);
209 int jtag_cancel_queue(void);
212 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
213 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
214 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
215 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
216 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
217 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
219 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
221 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
222 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
223 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
224 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
225 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
226 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
228 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
230 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
232 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
234 if (callback
== NULL
)
236 return ERROR_INVALID_ARGUMENTS
;
241 while ((*callbacks_p
)->next
)
242 callbacks_p
= &((*callbacks_p
)->next
);
243 callbacks_p
= &((*callbacks_p
)->next
);
246 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
247 (*callbacks_p
)->callback
= callback
;
248 (*callbacks_p
)->priv
= priv
;
249 (*callbacks_p
)->next
= NULL
;
254 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
256 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
258 if (callback
== NULL
)
260 return ERROR_INVALID_ARGUMENTS
;
265 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
266 if ((*callbacks_p
)->callback
== callback
)
269 *callbacks_p
= *next
;
277 int jtag_call_event_callbacks(enum jtag_event event
)
279 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
281 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
285 callback
->callback(event
, callback
->priv
);
286 callback
= callback
->next
;
292 /* returns a pointer to the pointer of the last command in queue
293 * this may be a pointer to the root pointer (jtag_command_queue)
294 * or to the next member of the last but one command
296 jtag_command_t
** jtag_get_last_command_p(void)
298 /* jtag_command_t *cmd = jtag_command_queue;
304 return &jtag_command_queue;
308 return last_comand_pointer
;
311 /* returns a pointer to the n-th device in the scan chain */
312 jtag_device_t
* jtag_get_device(int num
)
314 jtag_device_t
*device
= jtag_devices
;
321 device
= device
->next
;
328 void* cmd_queue_alloc(size_t size
)
330 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
335 while ((*p_page
)->next
)
336 p_page
= &((*p_page
)->next
);
337 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
338 p_page
= &((*p_page
)->next
);
343 *p_page
= malloc(sizeof(cmd_queue_page_t
));
345 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
346 (*p_page
)->next
= NULL
;
349 offset
= (*p_page
)->used
;
350 (*p_page
)->used
+= size
;
352 return ((*p_page
)->address
) + offset
;
355 void cmd_queue_free()
357 cmd_queue_page_t
*page
= cmd_queue_pages
;
361 cmd_queue_page_t
*last
= page
;
367 cmd_queue_pages
= NULL
;
370 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
372 jtag_command_t
**last_cmd
;
373 jtag_device_t
*device
;
379 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
380 return ERROR_JTAG_TRST_ASSERTED
;
383 last_cmd
= jtag_get_last_command_p();
385 /* allocate memory for a new list member */
386 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
387 (*last_cmd
)->next
= NULL
;
388 last_comand_pointer
= &((*last_cmd
)->next
);
389 (*last_cmd
)->type
= JTAG_SCAN
;
391 /* allocate memory for ir scan command */
392 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
393 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
394 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
395 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
396 (*last_cmd
)->cmd
.scan
->end_state
= state
;
399 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
400 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
404 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
408 cmd_queue_end_state
= state
;
410 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
411 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
413 if (cmd_queue_end_state
== TAP_TLR
)
414 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
416 cmd_queue_cur_state
= cmd_queue_end_state
;
418 for (i
=0; i
< jtag_num_devices
; i
++)
421 device
= jtag_get_device(i
);
422 scan_size
= device
->ir_length
;
423 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
424 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
425 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
426 if (jtag_verify_capture_ir
)
428 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
429 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
433 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
434 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
436 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
437 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
439 /* search the list */
440 for (j
=0; j
< num_fields
; j
++)
442 if (i
== fields
[j
].device
)
445 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
446 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
455 /* if a device isn't listed, set it to BYPASS */
456 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
457 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
462 /* update device information */
463 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
469 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
471 jtag_command_t
**last_cmd
;
476 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
477 return ERROR_JTAG_TRST_ASSERTED
;
480 last_cmd
= jtag_get_last_command_p();
482 /* allocate memory for a new list member */
483 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
484 (*last_cmd
)->next
= NULL
;
485 last_comand_pointer
= &((*last_cmd
)->next
);
486 (*last_cmd
)->type
= JTAG_SCAN
;
488 /* allocate memory for ir scan command */
489 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
490 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
491 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
492 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
493 (*last_cmd
)->cmd
.scan
->end_state
= state
;
496 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
497 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
501 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
505 cmd_queue_end_state
= state
;
507 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
508 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
510 if (cmd_queue_end_state
== TAP_TLR
)
511 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
513 cmd_queue_cur_state
= cmd_queue_end_state
;
515 for (i
= 0; i
< num_fields
; i
++)
517 int num_bits
= fields
[i
].num_bits
;
518 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
519 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
520 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
521 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
522 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
523 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
524 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
525 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
526 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
527 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
532 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
535 int bypass_devices
= 0;
537 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
538 jtag_device_t
*device
= jtag_devices
;
543 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
544 return ERROR_JTAG_TRST_ASSERTED
;
547 /* count devices in bypass */
552 device
= device
->next
;
555 /* allocate memory for a new list member */
556 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
557 last_comand_pointer
= &((*last_cmd
)->next
);
558 (*last_cmd
)->next
= NULL
;
559 (*last_cmd
)->type
= JTAG_SCAN
;
561 /* allocate memory for dr scan command */
562 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
563 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
564 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
565 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
566 (*last_cmd
)->cmd
.scan
->end_state
= state
;
569 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
570 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
574 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
578 cmd_queue_end_state
= state
;
580 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
581 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
583 if (cmd_queue_end_state
== TAP_TLR
)
584 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
586 cmd_queue_cur_state
= cmd_queue_end_state
;
588 for (i
=0; i
< jtag_num_devices
; i
++)
591 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
593 for (j
=0; j
< num_fields
; j
++)
595 if (i
== fields
[j
].device
)
598 scan_size
= fields
[j
].num_bits
;
599 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
600 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
601 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
602 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
603 (*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
);
604 (*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
);
605 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
606 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
611 /* if a device isn't listed, the BYPASS register should be selected */
612 if (!jtag_get_device(i
)->bypass
)
614 ERROR("BUG: no scan data for a device not in BYPASS");
618 /* program the scan field to 1 bit length, and ignore it's value */
619 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
620 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
621 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
622 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
623 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
624 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
625 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
626 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
630 /* if a device is listed, the BYPASS register must not be selected */
631 if (jtag_get_device(i
)->bypass
)
633 WARNING("scan data for a device in BYPASS");
640 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
643 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
647 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
648 return ERROR_JTAG_TRST_ASSERTED
;
651 /* allocate memory for a new list member */
652 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
653 last_comand_pointer
= &((*last_cmd
)->next
);
654 (*last_cmd
)->next
= NULL
;
655 (*last_cmd
)->type
= JTAG_SCAN
;
657 /* allocate memory for scan command */
658 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
659 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
660 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
661 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
662 (*last_cmd
)->cmd
.scan
->end_state
= state
;
665 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
666 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
670 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
674 cmd_queue_end_state
= state
;
676 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
677 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
679 if (cmd_queue_end_state
== TAP_TLR
)
680 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
682 cmd_queue_cur_state
= cmd_queue_end_state
;
684 for (i
= 0; i
< num_fields
; i
++)
686 int num_bits
= fields
[i
].num_bits
;
687 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
688 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
689 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
690 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
691 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
692 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
693 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
694 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
695 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
696 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
701 int jtag_add_statemove(enum tap_state state
)
703 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
707 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
708 return ERROR_JTAG_TRST_ASSERTED
;
711 /* allocate memory for a new list member */
712 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
713 last_comand_pointer
= &((*last_cmd
)->next
);
714 (*last_cmd
)->next
= NULL
;
715 (*last_cmd
)->type
= JTAG_STATEMOVE
;
717 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
718 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
721 cmd_queue_end_state
= state
;
723 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
724 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
726 if (cmd_queue_end_state
== TAP_TLR
)
727 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
729 cmd_queue_cur_state
= cmd_queue_end_state
;
734 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
736 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
741 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
742 return ERROR_JTAG_TRST_ASSERTED
;
745 /* the last state has to be a stable state */
746 if (tap_move_map
[path
[num_states
- 1]] == -1)
748 ERROR("TAP path doesn't finish in a stable state");
749 return ERROR_JTAG_NOT_IMPLEMENTED
;
752 if (jtag
->support_pathmove
)
754 /* allocate memory for a new list member */
755 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
756 last_comand_pointer
= &((*last_cmd
)->next
);
757 (*last_cmd
)->next
= NULL
;
758 (*last_cmd
)->type
= JTAG_PATHMOVE
;
760 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
761 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
762 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
764 for (i
= 0; i
< num_states
; i
++)
765 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
769 /* validate the desired path, and see if it fits a default path */
774 for (i
= 0; i
< num_states
; i
++)
776 for (j
= i
; j
< num_states
; j
++)
778 if (tap_move_map
[path
[j
]] != -1)
785 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
787 jtag_add_statemove(path
[end
]);
791 ERROR("encountered a TAP path that can't be fulfilled by default paths");
792 return ERROR_JTAG_NOT_IMPLEMENTED
;
799 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
800 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
802 if (cmd_queue_end_state
== TAP_TLR
)
803 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
805 cmd_queue_cur_state
= path
[num_states
- 1];
810 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
812 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
816 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
817 return ERROR_JTAG_TRST_ASSERTED
;
820 /* allocate memory for a new list member */
821 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
822 (*last_cmd
)->next
= NULL
;
823 last_comand_pointer
= &((*last_cmd
)->next
);
824 (*last_cmd
)->type
= JTAG_RUNTEST
;
826 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
827 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
828 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
831 cmd_queue_end_state
= state
;
833 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
834 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
836 if (cmd_queue_end_state
== TAP_TLR
)
837 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
839 cmd_queue_cur_state
= cmd_queue_end_state
;
844 int jtag_add_reset(int req_trst
, int req_srst
)
846 int trst_with_tms
= 0;
848 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
851 req_trst
= jtag_trst
;
854 req_srst
= jtag_srst
;
856 /* Make sure that jtag_reset_config allows the requested reset */
857 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
858 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
859 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
861 /* if TRST pulls SRST, we reset with TAP T-L-R */
862 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
868 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
870 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
871 return ERROR_JTAG_RESET_CANT_SRST
;
874 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
880 /* allocate memory for a new list member */
881 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
882 (*last_cmd
)->next
= NULL
;
883 last_comand_pointer
= &((*last_cmd
)->next
);
884 (*last_cmd
)->type
= JTAG_RESET
;
886 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
887 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
888 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
890 jtag_trst
= req_trst
;
891 jtag_srst
= req_srst
;
895 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
899 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
900 if (jtag_nsrst_delay
)
901 jtag_add_sleep(jtag_nsrst_delay
* 1000);
906 last_cmd
= &((*last_cmd
)->next
);
908 /* allocate memory for a new list member */
909 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
910 (*last_cmd
)->next
= NULL
;
911 last_comand_pointer
= &((*last_cmd
)->next
);
912 (*last_cmd
)->type
= JTAG_STATEMOVE
;
914 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
915 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
917 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
918 cmd_queue_cur_state
= TAP_TLR
;
919 cmd_queue_end_state
= TAP_TLR
;
927 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
928 * and inform possible listeners about this
930 cmd_queue_cur_state
= TAP_TLR
;
931 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
935 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
936 * but we might want to add a delay to give the TAP time to settle
938 if (jtag_ntrst_delay
)
939 jtag_add_sleep(jtag_ntrst_delay
* 1000);
946 int jtag_add_end_state(enum tap_state state
)
948 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
950 /* allocate memory for a new list member */
951 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
952 (*last_cmd
)->next
= NULL
;
953 last_comand_pointer
= &((*last_cmd
)->next
);
954 (*last_cmd
)->type
= JTAG_END_STATE
;
956 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
957 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
960 cmd_queue_end_state
= state
;
965 int jtag_add_sleep(u32 us
)
967 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
969 /* allocate memory for a new list member */
970 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
971 (*last_cmd
)->next
= NULL
;
972 last_comand_pointer
= &((*last_cmd
)->next
);
973 (*last_cmd
)->type
= JTAG_SLEEP
;
975 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
976 (*last_cmd
)->cmd
.sleep
->us
= us
;
981 int jtag_scan_size(scan_command_t
*cmd
)
986 /* count bits in scan command */
987 for (i
=0; i
<cmd
->num_fields
; i
++)
989 bit_count
+= cmd
->fields
[i
].num_bits
;
995 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1000 bit_count
= jtag_scan_size(cmd
);
1001 *buffer
= malloc(CEIL(bit_count
, 8));
1005 for (i
= 0; i
< cmd
->num_fields
; i
++)
1007 if (cmd
->fields
[i
].out_value
)
1009 #ifdef _DEBUG_JTAG_IO_
1010 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1012 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1013 #ifdef _DEBUG_JTAG_IO_
1014 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1019 bit_count
+= cmd
->fields
[i
].num_bits
;
1026 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1032 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1035 for (i
=0; i
< cmd
->num_fields
; i
++)
1037 /* if neither in_value, in_check_value nor in_handler
1038 * are specified we don't have to examine this field
1040 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_handler
)
1042 int num_bits
= cmd
->fields
[i
].num_bits
;
1043 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1045 #ifdef _DEBUG_JTAG_IO_
1048 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1049 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1053 if (cmd
->fields
[i
].in_value
)
1055 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1057 if (cmd
->fields
[i
].in_handler
)
1059 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1061 WARNING("in_handler reported a failed check");
1062 retval
= ERROR_JTAG_QUEUE_FAILED
;
1067 /* no in_value specified, but a handler takes care of the scanned data */
1068 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1070 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1072 /* We're going to call the error:handler later, but if the in_handler
1073 * reported an error we report this failure upstream
1075 WARNING("in_handler reported a failed check");
1076 retval
= ERROR_JTAG_QUEUE_FAILED
;
1080 if (cmd
->fields
[i
].in_check_value
)
1082 int compare_failed
= 0;
1084 if (cmd
->fields
[i
].in_check_mask
)
1085 compare_failed
= buf_cmp_mask(captured
, cmd
->fields
[i
].in_check_value
, cmd
->fields
[i
].in_check_mask
, num_bits
);
1087 compare_failed
= buf_cmp(captured
, cmd
->fields
[i
].in_check_value
, num_bits
);
1091 if (cmd
->error_handler
)
1093 /* ask the error handler if once has been specified if this is a real problem */
1094 if (cmd
->error_handler
->error_handler(captured
, cmd
->error_handler
->error_handler_priv
) != ERROR_OK
)
1095 retval
= ERROR_JTAG_QUEUE_FAILED
;
1101 /* if there wasn't a handler specified, we report a failure */
1102 retval
= ERROR_JTAG_QUEUE_FAILED
;
1105 /* An error handler could have caught the failing check
1106 * only report a problem when there wasn't a handler, or if the handler
1107 * acknowledged the error
1111 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1112 char *in_check_value_char
= buf_to_str(cmd
->fields
[i
].in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1114 if (cmd
->fields
[i
].in_check_mask
)
1116 char *in_check_mask_char
;
1117 in_check_mask_char
= buf_to_str(cmd
->fields
[i
].in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1118 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
);
1119 free(in_check_mask_char
);
1123 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1126 free(captured_char
);
1127 free(in_check_value_char
);
1134 bit_count
+= cmd
->fields
[i
].num_bits
;
1140 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1145 for (i
=0; i
< cmd
->num_fields
; i
++)
1147 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1149 if (cmd
->fields
[i
].out_value
)
1156 int jtag_execute_queue(void)
1160 retval
= jtag
->execute_queue();
1164 jtag_command_queue
= NULL
;
1165 last_comand_pointer
= &jtag_command_queue
;
1170 int jtag_cancel_queue(void)
1173 jtag_command_queue
= NULL
;
1174 last_comand_pointer
= &jtag_command_queue
;
1179 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1181 jtag_device_t
*device
= priv
;
1185 if (event
== JTAG_TRST_ASSERTED
)
1187 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1194 void jtag_sleep(u32 us
)
1199 /* Try to examine chain layout according to IEEE 1149.1 §12
1201 int jtag_examine_chain()
1203 jtag_device_t
*device
= jtag_devices
;
1205 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1208 int device_count
= 0;
1209 u8 zero_check
= 0x0;
1210 u8 one_check
= 0xff;
1213 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1214 field
.out_value
= idcode_buffer
;
1215 field
.out_mask
= NULL
;
1216 field
.in_value
= idcode_buffer
;
1217 field
.in_check_value
= NULL
;
1218 field
.in_check_mask
= NULL
;
1219 field
.in_handler
= NULL
;
1220 field
.in_handler_priv
= NULL
;
1222 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1224 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1227 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
, NULL
);
1228 jtag_execute_queue();
1230 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1232 zero_check
|= idcode_buffer
[i
];
1233 one_check
&= idcode_buffer
[i
];
1236 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1237 if ((zero_check
== 0x00) || (one_check
== 0xff))
1239 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1243 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1245 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1246 if ((idcode
& 1) == 0)
1248 /* LSB must not be 0, this indicates a device in bypass */
1259 if (idcode
== 0x000000FF)
1261 /* End of chain (invalid manufacturer ID) */
1267 device
->idcode
= idcode
;
1268 device
= device
->next
;
1272 manufacturer
= (idcode
& 0xffe) >> 1;
1273 part
= (idcode
& 0xffff000) >> 12;
1274 version
= (idcode
& 0xf0000000) >> 28;
1276 DEBUG("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x",
1277 idcode
, manufacturer
, part
, version
);
1283 /* see if number of discovered devices matches configuration */
1284 if (device_count
!= jtag_num_devices
)
1286 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1287 device_count
, jtag_num_devices
);
1288 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1295 int jtag_validate_chain()
1297 jtag_device_t
*device
= jtag_devices
;
1298 int total_ir_length
= 0;
1305 total_ir_length
+= device
->ir_length
;
1306 device
= device
->next
;
1309 total_ir_length
+= 2;
1310 ir_test
= malloc(CEIL(total_ir_length
, 8));
1311 buf_set_ones(ir_test
, total_ir_length
);
1314 field
.num_bits
= total_ir_length
;
1315 field
.out_value
= ir_test
;
1316 field
.out_mask
= NULL
;
1317 field
.in_value
= ir_test
;
1318 field
.in_check_value
= NULL
;
1319 field
.in_check_mask
= NULL
;
1320 field
.in_handler
= NULL
;
1321 field
.in_handler_priv
= NULL
;
1323 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
, NULL
);
1324 jtag_execute_queue();
1326 device
= jtag_devices
;
1329 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1331 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1332 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1336 chain_pos
+= device
->ir_length
;
1337 device
= device
->next
;
1340 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1342 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1343 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1353 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1355 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1356 COMMAND_CONFIG
, NULL
);
1357 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1358 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1359 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1360 COMMAND_CONFIG
, NULL
);
1361 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1362 COMMAND_CONFIG
, NULL
);
1363 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1364 COMMAND_CONFIG
, NULL
);
1365 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1366 COMMAND_CONFIG
, NULL
);
1368 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1369 COMMAND_EXEC
, "print current scan chain configuration");
1371 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1372 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1373 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1374 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1375 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1376 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1377 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1378 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1379 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1380 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1381 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1382 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1384 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1385 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1389 int jtag_init(struct command_context_s
*cmd_ctx
)
1395 if (jtag_speed
== -1)
1398 if (jtag_interface
&& (jtag_interface
[0] != 0))
1399 /* configuration var 'jtag_interface' is set, and not empty */
1400 for (i
= 0; jtag_interfaces
[i
]; i
++)
1402 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1404 jtag_device_t
*device
;
1405 device
= jtag_devices
;
1407 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1408 return ERROR_JTAG_INIT_FAILED
;
1409 jtag
= jtag_interfaces
[i
];
1411 jtag_ir_scan_size
= 0;
1412 jtag_num_devices
= 0;
1413 while (device
!= NULL
)
1415 jtag_ir_scan_size
+= device
->ir_length
;
1417 device
= device
->next
;
1420 jtag_add_statemove(TAP_TLR
);
1421 jtag_execute_queue();
1423 jtag_examine_chain();
1425 jtag_validate_chain();
1431 /* no valid interface was found (i.e. the configuration option,
1432 * didn't match one of the compiled-in interfaces
1434 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1435 ERROR("compiled-in jtag interfaces:");
1436 for (i
= 0; jtag_interfaces
[i
]; i
++)
1438 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1442 return ERROR_JTAG_INVALID_INTERFACE
;
1445 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1449 /* only if the configuration var isn't overwritten from cmdline */
1450 if (!jtag_interface
)
1452 if (args
[0] && (args
[0][0] != 0))
1454 for (i
=0; jtag_interfaces
[i
]; i
++)
1456 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1458 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1461 jtag_interface
= jtag_interfaces
[i
]->name
;
1468 /* remember the requested interface name, so we can complain about it later */
1469 jtag_interface
= strdup(args
[0]);
1470 DEBUG("'interface' command didn't specify a valid interface");
1476 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1478 jtag_device_t
**last_device_p
= &jtag_devices
;
1482 while ((*last_device_p
)->next
)
1483 last_device_p
= &((*last_device_p
)->next
);
1484 last_device_p
= &((*last_device_p
)->next
);
1490 *last_device_p
= malloc(sizeof(jtag_device_t
));
1491 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1493 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1494 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1495 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1496 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1498 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1499 (*last_device_p
)->bypass
= 1;
1500 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1502 (*last_device_p
)->next
= NULL
;
1504 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1511 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1513 jtag_device_t
*device
= jtag_devices
;
1514 int device_count
= 0;
1518 u32 expected
, expected_mask
, cur_instr
;
1519 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1520 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1521 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1522 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
);
1523 device
= device
->next
;
1530 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1534 if (strcmp(args
[0], "none") == 0)
1535 jtag_reset_config
= RESET_NONE
;
1536 else if (strcmp(args
[0], "trst_only") == 0)
1537 jtag_reset_config
= RESET_HAS_TRST
;
1538 else if (strcmp(args
[0], "srst_only") == 0)
1539 jtag_reset_config
= RESET_HAS_SRST
;
1540 else if (strcmp(args
[0], "trst_and_srst") == 0)
1541 jtag_reset_config
= RESET_TRST_AND_SRST
;
1544 ERROR("invalid reset_config argument");
1551 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1552 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1553 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1554 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1555 else if (strcmp(args
[1], "combined") == 0)
1556 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1557 else if (strcmp(args
[1], "separate") == 0)
1558 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1561 ERROR("invalid reset_config argument");
1568 if (strcmp(args
[2], "trst_open_drain") == 0)
1569 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1570 else if (strcmp(args
[2], "trst_push_pull") == 0)
1571 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1574 ERROR("invalid reset_config argument");
1581 if (strcmp(args
[3], "srst_push_pull") == 0)
1582 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1583 else if (strcmp(args
[3], "srst_open_drain") == 0)
1584 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1587 ERROR("invalid reset_config argument");
1595 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1599 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1604 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1610 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1614 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1619 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1625 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1628 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1632 /* this command can be called during CONFIG,
1633 * in which case jtag isn't initialized */
1635 jtag
->speed(strtoul(args
[0], NULL
, 0));
1637 jtag_speed
= strtoul(args
[0], NULL
, 0);
1643 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1645 enum tap_state state
;
1649 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1653 for (state
= 0; state
< 16; state
++)
1655 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1657 jtag_add_end_state(state
);
1658 jtag_execute_queue();
1662 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1667 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1671 char *usage
= "usage: jtag_reset <trst> <srst>";
1676 command_print(cmd_ctx
, usage
);
1680 if (args
[0][0] == '1')
1682 else if (args
[0][0] == '0')
1686 command_print(cmd_ctx
, usage
);
1690 if (args
[1][0] == '1')
1692 else if (args
[1][0] == '0')
1696 command_print(cmd_ctx
, usage
);
1700 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1704 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1705 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1707 case ERROR_JTAG_RESET_CANT_SRST
:
1708 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1711 command_print(cmd_ctx
, "unknown error");
1714 jtag_execute_queue();
1719 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1723 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1727 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1728 jtag_execute_queue();
1734 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1736 enum tap_state state
;
1741 for (state
= 0; state
< 16; state
++)
1743 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1750 jtag_add_statemove(state
);
1751 jtag_execute_queue();
1757 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1760 scan_field_t
*fields
;
1762 if ((argc
< 2) || (argc
% 2))
1764 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1768 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1770 for (i
= 0; i
< argc
/ 2; i
++)
1772 int device
= strtoul(args
[i
*2], NULL
, 0);
1773 int field_size
= jtag_get_device(device
)->ir_length
;
1774 fields
[i
].device
= device
;
1775 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1776 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1777 fields
[i
].out_mask
= NULL
;
1778 fields
[i
].in_value
= NULL
;
1779 fields
[i
].in_check_mask
= NULL
;
1780 fields
[i
].in_handler
= NULL
;
1781 fields
[i
].in_handler_priv
= NULL
;
1784 jtag_add_ir_scan(argc
/ 2, fields
, -1, NULL
);
1785 jtag_execute_queue();
1787 for (i
= 0; i
< argc
/ 2; i
++)
1788 free(fields
[i
].out_value
);
1795 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1797 scan_field_t
*fields
;
1799 int field_count
= 0;
1803 if ((argc
< 2) || (argc
% 2))
1805 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1809 for (i
= 0; i
< argc
; i
+=2)
1811 var
= get_var_by_namenum(args
[i
+1]);
1814 num_fields
+= var
->num_fields
;
1818 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1823 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1825 for (i
= 0; i
< argc
; i
+=2)
1827 var
= get_var_by_namenum(args
[i
+1]);
1829 for (j
= 0; j
< var
->num_fields
; j
++)
1831 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1832 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1833 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1834 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1835 fields
[field_count
].out_mask
= NULL
;
1836 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1837 fields
[field_count
].in_check_mask
= NULL
;
1838 fields
[field_count
].in_check_value
= NULL
;
1839 fields
[field_count
].in_handler
= field_le_to_host
;
1840 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1844 jtag_add_dr_scan(num_fields
, fields
, -1, NULL
);
1845 jtag_execute_queue();
1847 for (i
= 0; i
< argc
/ 2; i
++)
1848 free(fields
[i
].out_value
);
1855 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1859 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1863 if (strcmp(args
[0], "enable") == 0)
1865 jtag_verify_capture_ir
= 1;
1867 else if (strcmp(args
[0], "disable") == 0)
1869 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)