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
64 /* TLR RTI SD PD SI PI */
65 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
66 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
67 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
68 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
69 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
70 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
73 int tap_move_map
[16] = {
74 0, -1, -1, 2, -1, 3, -1, -1,
75 1, -1, -1, 4, -1, 5, -1, -1
78 tap_transition_t tap_transitions
[16] =
80 {TAP_TLR
, TAP_RTI
}, /* TLR */
81 {TAP_SIS
, TAP_CD
}, /* SDS */
82 {TAP_E1D
, TAP_SD
}, /* CD */
83 {TAP_E1D
, TAP_SD
}, /* SD */
84 {TAP_UD
, TAP_PD
}, /* E1D */
85 {TAP_E2D
, TAP_PD
}, /* PD */
86 {TAP_UD
, TAP_SD
}, /* E2D */
87 {TAP_SDS
, TAP_RTI
}, /* UD */
88 {TAP_SDS
, TAP_RTI
}, /* RTI */
89 {TAP_TLR
, TAP_CI
}, /* SIS */
90 {TAP_E1I
, TAP_SI
}, /* CI */
91 {TAP_E1I
, TAP_SI
}, /* SI */
92 {TAP_UI
, TAP_PI
}, /* E1I */
93 {TAP_E2I
, TAP_PI
}, /* PI */
94 {TAP_UI
, TAP_SI
}, /* E2I */
95 {TAP_SDS
, TAP_RTI
} /* UI */
98 char* jtag_event_strings
[] =
106 enum tap_state end_state
= TAP_TLR
;
107 enum tap_state cur_state
= TAP_TLR
;
111 jtag_command_t
*jtag_command_queue
= NULL
;
112 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
113 jtag_device_t
*jtag_devices
= NULL
;
114 int jtag_num_devices
= 0;
115 int jtag_ir_scan_size
= 0;
116 enum reset_types jtag_reset_config
= RESET_NONE
;
117 enum tap_state cmd_queue_end_state
= TAP_TLR
;
118 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
120 int jtag_verify_capture_ir
= 1;
122 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
123 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
124 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
126 /* maximum number of JTAG devices expected in the chain
128 #define JTAG_MAX_CHAIN_SIZE 20
130 /* callbacks to inform high-level handlers about JTAG state changes */
131 jtag_event_callback_t
*jtag_event_callbacks
;
133 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
135 #if BUILD_PARPORT == 1
136 extern jtag_interface_t parport_interface
;
139 #if BUILD_FT2232_FTD2XX == 1
140 extern jtag_interface_t ft2232_interface
;
143 #if BUILD_FT2232_LIBFTDI == 1
144 extern jtag_interface_t ft2232_interface
;
147 #if BUILD_AMTJTAGACCEL == 1
148 extern jtag_interface_t amt_jtagaccel_interface
;
151 #if BUILD_EP93XX == 1
152 extern jtag_interface_t ep93xx_interface
;
155 #if BUILD_AT91RM9200 == 1
156 extern jtag_interface_t at91rm9200_interface
;
159 #if BUILD_GW16012 == 1
160 extern jtag_interface_t gw16012_interface
;
163 jtag_interface_t
*jtag_interfaces
[] = {
164 #if BUILD_PARPORT == 1
167 #if BUILD_FT2232_FTD2XX == 1
170 #if BUILD_FT2232_LIBFTDI == 1
173 #if BUILD_AMTJTAGACCEL == 1
174 &amt_jtagaccel_interface
,
176 #if BUILD_EP93XX == 1
179 #if BUILD_AT91RM9200 == 1
180 &at91rm9200_interface
,
182 #if BUILD_GW16012 == 1
188 jtag_interface_t
*jtag
= NULL
;
191 char* jtag_interface
= NULL
;
195 /* forward declarations */
196 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
197 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
198 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
199 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
, error_handler_t
*error_handler
);
200 int jtag_add_statemove(enum tap_state endstate
);
201 int jtag_add_pathmove(int num_states
, enum tap_state
*path
);
202 int jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
203 int jtag_add_reset(int trst
, int srst
);
204 int jtag_add_end_state(enum tap_state endstate
);
205 int jtag_add_sleep(u32 us
);
206 int jtag_execute_queue(void);
207 int jtag_cancel_queue(void);
210 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
211 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
212 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
213 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
214 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
215 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
217 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
219 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
220 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
221 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
222 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
223 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
224 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
226 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
228 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
230 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
232 if (callback
== NULL
)
234 return ERROR_INVALID_ARGUMENTS
;
239 while ((*callbacks_p
)->next
)
240 callbacks_p
= &((*callbacks_p
)->next
);
241 callbacks_p
= &((*callbacks_p
)->next
);
244 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
245 (*callbacks_p
)->callback
= callback
;
246 (*callbacks_p
)->priv
= priv
;
247 (*callbacks_p
)->next
= NULL
;
252 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
254 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
256 if (callback
== NULL
)
258 return ERROR_INVALID_ARGUMENTS
;
263 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
264 if ((*callbacks_p
)->callback
== callback
)
267 *callbacks_p
= *next
;
275 int jtag_call_event_callbacks(enum jtag_event event
)
277 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
279 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
283 callback
->callback(event
, callback
->priv
);
284 callback
= callback
->next
;
290 /* returns a pointer to the pointer of the last command in queue
291 * this may be a pointer to the root pointer (jtag_command_queue)
292 * or to the next member of the last but one command
294 jtag_command_t
** jtag_get_last_command_p(void)
296 /* jtag_command_t *cmd = jtag_command_queue;
302 return &jtag_command_queue;
306 return last_comand_pointer
;
309 /* returns a pointer to the n-th device in the scan chain */
310 jtag_device_t
* jtag_get_device(int num
)
312 jtag_device_t
*device
= jtag_devices
;
319 device
= device
->next
;
326 void* cmd_queue_alloc(size_t size
)
328 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
333 while ((*p_page
)->next
)
334 p_page
= &((*p_page
)->next
);
335 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
336 p_page
= &((*p_page
)->next
);
341 *p_page
= malloc(sizeof(cmd_queue_page_t
));
343 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
344 (*p_page
)->next
= NULL
;
347 offset
= (*p_page
)->used
;
348 (*p_page
)->used
+= size
;
350 return ((*p_page
)->address
) + offset
;
353 void cmd_queue_free()
355 cmd_queue_page_t
*page
= cmd_queue_pages
;
359 cmd_queue_page_t
*last
= page
;
365 cmd_queue_pages
= NULL
;
368 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
370 jtag_command_t
**last_cmd
;
371 jtag_device_t
*device
;
377 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
378 return ERROR_JTAG_TRST_ASSERTED
;
381 last_cmd
= jtag_get_last_command_p();
383 /* allocate memory for a new list member */
384 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
385 (*last_cmd
)->next
= NULL
;
386 last_comand_pointer
= &((*last_cmd
)->next
);
387 (*last_cmd
)->type
= JTAG_SCAN
;
389 /* allocate memory for ir scan command */
390 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
391 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
392 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
393 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
394 (*last_cmd
)->cmd
.scan
->end_state
= state
;
397 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
398 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
402 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
406 cmd_queue_end_state
= state
;
408 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
409 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
411 if (cmd_queue_end_state
== TAP_TLR
)
412 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
414 cmd_queue_cur_state
= cmd_queue_end_state
;
416 for (i
=0; i
< jtag_num_devices
; i
++)
419 device
= jtag_get_device(i
);
420 scan_size
= device
->ir_length
;
421 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
422 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
423 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
424 if (jtag_verify_capture_ir
)
426 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
427 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
431 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
432 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
434 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
435 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
437 /* search the list */
438 for (j
=0; j
< num_fields
; j
++)
440 if (i
== fields
[j
].device
)
443 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
444 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
453 /* if a device isn't listed, set it to BYPASS */
454 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
455 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
460 /* update device information */
461 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
467 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
469 jtag_command_t
**last_cmd
;
474 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
475 return ERROR_JTAG_TRST_ASSERTED
;
478 last_cmd
= jtag_get_last_command_p();
480 /* allocate memory for a new list member */
481 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
482 (*last_cmd
)->next
= NULL
;
483 last_comand_pointer
= &((*last_cmd
)->next
);
484 (*last_cmd
)->type
= JTAG_SCAN
;
486 /* allocate memory for ir scan command */
487 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
488 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
489 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
490 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
491 (*last_cmd
)->cmd
.scan
->end_state
= state
;
494 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
495 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
499 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
503 cmd_queue_end_state
= state
;
505 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
506 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
508 if (cmd_queue_end_state
== TAP_TLR
)
509 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
511 cmd_queue_cur_state
= cmd_queue_end_state
;
513 for (i
= 0; i
< num_fields
; i
++)
515 int num_bits
= fields
[i
].num_bits
;
516 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
517 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
518 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
519 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
520 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
521 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
522 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
523 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
524 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
525 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
530 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
533 int bypass_devices
= 0;
535 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
536 jtag_device_t
*device
= jtag_devices
;
541 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
542 return ERROR_JTAG_TRST_ASSERTED
;
545 /* count devices in bypass */
550 device
= device
->next
;
553 /* allocate memory for a new list member */
554 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
555 last_comand_pointer
= &((*last_cmd
)->next
);
556 (*last_cmd
)->next
= NULL
;
557 (*last_cmd
)->type
= JTAG_SCAN
;
559 /* allocate memory for dr scan command */
560 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
561 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
562 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
563 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
564 (*last_cmd
)->cmd
.scan
->end_state
= state
;
567 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
568 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
572 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
576 cmd_queue_end_state
= state
;
578 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
579 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
581 if (cmd_queue_end_state
== TAP_TLR
)
582 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
584 cmd_queue_cur_state
= cmd_queue_end_state
;
586 for (i
=0; i
< jtag_num_devices
; i
++)
589 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
591 for (j
=0; j
< num_fields
; j
++)
593 if (i
== fields
[j
].device
)
596 scan_size
= fields
[j
].num_bits
;
597 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
598 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
599 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
600 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
601 (*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
);
602 (*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
);
603 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
604 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
609 /* if a device isn't listed, the BYPASS register should be selected */
610 if (!jtag_get_device(i
)->bypass
)
612 ERROR("BUG: no scan data for a device not in BYPASS");
616 /* program the scan field to 1 bit length, and ignore it's value */
617 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
618 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
619 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
620 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
621 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
622 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
623 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
624 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
628 /* if a device is listed, the BYPASS register must not be selected */
629 if (jtag_get_device(i
)->bypass
)
631 WARNING("scan data for a device in BYPASS");
638 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
, error_handler_t
*error_handler
)
641 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
645 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
646 return ERROR_JTAG_TRST_ASSERTED
;
649 /* allocate memory for a new list member */
650 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
651 last_comand_pointer
= &((*last_cmd
)->next
);
652 (*last_cmd
)->next
= NULL
;
653 (*last_cmd
)->type
= JTAG_SCAN
;
655 /* allocate memory for scan command */
656 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
657 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
658 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
659 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
660 (*last_cmd
)->cmd
.scan
->end_state
= state
;
663 (*last_cmd
)->cmd
.scan
->error_handler
= cmd_queue_alloc(sizeof(error_handler_t
));
664 *(*last_cmd
)->cmd
.scan
->error_handler
= *error_handler
;
668 (*last_cmd
)->cmd
.scan
->error_handler
= NULL
;
672 cmd_queue_end_state
= state
;
674 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
675 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
677 if (cmd_queue_end_state
== TAP_TLR
)
678 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
680 cmd_queue_cur_state
= cmd_queue_end_state
;
682 for (i
= 0; i
< num_fields
; i
++)
684 int num_bits
= fields
[i
].num_bits
;
685 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
686 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
687 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
688 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
689 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
690 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
691 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
692 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
693 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
694 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
699 int jtag_add_statemove(enum tap_state state
)
701 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
705 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
706 return ERROR_JTAG_TRST_ASSERTED
;
709 /* allocate memory for a new list member */
710 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
711 last_comand_pointer
= &((*last_cmd
)->next
);
712 (*last_cmd
)->next
= NULL
;
713 (*last_cmd
)->type
= JTAG_STATEMOVE
;
715 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
716 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
719 cmd_queue_end_state
= state
;
721 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
722 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
724 if (cmd_queue_end_state
== TAP_TLR
)
725 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
727 cmd_queue_cur_state
= cmd_queue_end_state
;
732 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
734 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
739 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
740 return ERROR_JTAG_TRST_ASSERTED
;
743 /* the last state has to be a stable state */
744 if (tap_move_map
[path
[num_states
- 1]] == -1)
746 ERROR("TAP path doesn't finish in a stable state");
747 return ERROR_JTAG_NOT_IMPLEMENTED
;
750 if (jtag
->support_pathmove
)
752 /* allocate memory for a new list member */
753 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
754 last_comand_pointer
= &((*last_cmd
)->next
);
755 (*last_cmd
)->next
= NULL
;
756 (*last_cmd
)->type
= JTAG_PATHMOVE
;
758 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
759 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
760 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
762 for (i
= 0; i
< num_states
; i
++)
763 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
767 /* validate the desired path, and see if it fits a default path */
772 for (i
= 0; i
< num_states
; i
++)
774 for (j
= i
; j
< num_states
; j
++)
776 if (tap_move_map
[path
[j
]] != -1)
783 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
785 jtag_add_statemove(path
[end
]);
789 ERROR("encountered a TAP path that can't be fulfilled by default paths");
790 return ERROR_JTAG_NOT_IMPLEMENTED
;
797 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
798 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
800 if (cmd_queue_end_state
== TAP_TLR
)
801 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
803 cmd_queue_cur_state
= path
[num_states
- 1];
808 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
810 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
814 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
815 return ERROR_JTAG_TRST_ASSERTED
;
818 /* allocate memory for a new list member */
819 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
820 (*last_cmd
)->next
= NULL
;
821 last_comand_pointer
= &((*last_cmd
)->next
);
822 (*last_cmd
)->type
= JTAG_RUNTEST
;
824 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
825 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
826 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
829 cmd_queue_end_state
= state
;
831 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
832 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
834 if (cmd_queue_end_state
== TAP_TLR
)
835 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
837 cmd_queue_cur_state
= cmd_queue_end_state
;
842 int jtag_add_reset(int req_trst
, int req_srst
)
844 int trst_with_tms
= 0;
846 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
849 req_trst
= jtag_trst
;
852 req_srst
= jtag_srst
;
854 /* Make sure that jtag_reset_config allows the requested reset */
855 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
856 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
857 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
859 /* if TRST pulls SRST, we reset with TAP T-L-R */
860 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
866 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
868 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
869 return ERROR_JTAG_RESET_CANT_SRST
;
872 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
878 /* allocate memory for a new list member */
879 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
880 (*last_cmd
)->next
= NULL
;
881 last_comand_pointer
= &((*last_cmd
)->next
);
882 (*last_cmd
)->type
= JTAG_RESET
;
884 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
885 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
886 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
888 jtag_trst
= req_trst
;
889 jtag_srst
= req_srst
;
893 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
897 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
898 if (jtag_nsrst_delay
)
899 jtag_add_sleep(jtag_nsrst_delay
* 1000);
904 last_cmd
= &((*last_cmd
)->next
);
906 /* allocate memory for a new list member */
907 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
908 (*last_cmd
)->next
= NULL
;
909 last_comand_pointer
= &((*last_cmd
)->next
);
910 (*last_cmd
)->type
= JTAG_STATEMOVE
;
912 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
913 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
915 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
916 cmd_queue_cur_state
= TAP_TLR
;
917 cmd_queue_end_state
= TAP_TLR
;
925 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
926 * and inform possible listeners about this
928 cmd_queue_cur_state
= TAP_TLR
;
929 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
933 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
934 * but we might want to add a delay to give the TAP time to settle
936 if (jtag_ntrst_delay
)
937 jtag_add_sleep(jtag_ntrst_delay
* 1000);
944 int jtag_add_end_state(enum tap_state state
)
946 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
948 /* allocate memory for a new list member */
949 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
950 (*last_cmd
)->next
= NULL
;
951 last_comand_pointer
= &((*last_cmd
)->next
);
952 (*last_cmd
)->type
= JTAG_END_STATE
;
954 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
955 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
958 cmd_queue_end_state
= state
;
963 int jtag_add_sleep(u32 us
)
965 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
967 /* allocate memory for a new list member */
968 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
969 (*last_cmd
)->next
= NULL
;
970 last_comand_pointer
= &((*last_cmd
)->next
);
971 (*last_cmd
)->type
= JTAG_SLEEP
;
973 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
974 (*last_cmd
)->cmd
.sleep
->us
= us
;
979 int jtag_scan_size(scan_command_t
*cmd
)
984 /* count bits in scan command */
985 for (i
=0; i
<cmd
->num_fields
; i
++)
987 bit_count
+= cmd
->fields
[i
].num_bits
;
993 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
998 bit_count
= jtag_scan_size(cmd
);
999 *buffer
= malloc(CEIL(bit_count
, 8));
1003 for (i
= 0; i
< cmd
->num_fields
; i
++)
1005 if (cmd
->fields
[i
].out_value
)
1007 #ifdef _DEBUG_JTAG_IO_
1008 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1010 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1011 #ifdef _DEBUG_JTAG_IO_
1012 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1017 bit_count
+= cmd
->fields
[i
].num_bits
;
1024 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1030 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1033 for (i
=0; i
< cmd
->num_fields
; i
++)
1035 /* if neither in_value, in_check_value nor in_handler
1036 * are specified we don't have to examine this field
1038 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_handler
)
1040 int num_bits
= cmd
->fields
[i
].num_bits
;
1041 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1043 #ifdef _DEBUG_JTAG_IO_
1046 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1047 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1051 if (cmd
->fields
[i
].in_value
)
1053 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1055 if (cmd
->fields
[i
].in_handler
)
1057 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1059 WARNING("in_handler reported a failed check");
1060 retval
= ERROR_JTAG_QUEUE_FAILED
;
1065 /* no in_value specified, but a handler takes care of the scanned data */
1066 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1068 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1070 /* We're going to call the error:handler later, but if the in_handler
1071 * reported an error we report this failure upstream
1073 WARNING("in_handler reported a failed check");
1074 retval
= ERROR_JTAG_QUEUE_FAILED
;
1078 if (cmd
->fields
[i
].in_check_value
)
1080 int compare_failed
= 0;
1082 if (cmd
->fields
[i
].in_check_mask
)
1083 compare_failed
= buf_cmp_mask(captured
, cmd
->fields
[i
].in_check_value
, cmd
->fields
[i
].in_check_mask
, num_bits
);
1085 compare_failed
= buf_cmp(captured
, cmd
->fields
[i
].in_check_value
, num_bits
);
1089 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1090 char *in_check_value_char
= buf_to_str(cmd
->fields
[i
].in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1092 if (cmd
->error_handler
)
1094 /* ask the error handler if once has been specified if this is a real problem */
1095 if (cmd
->error_handler
->error_handler(captured
, cmd
->error_handler
->error_handler_priv
) != ERROR_OK
)
1096 retval
= ERROR_JTAG_QUEUE_FAILED
;
1102 /* if there wasn't a handler specified, we report a failure */
1103 retval
= ERROR_JTAG_QUEUE_FAILED
;
1106 /* An error handler could have caught the failing check
1107 * only report a problem when there wasn't a handler, or if the handler
1108 * acknowledged the error
1112 if (cmd
->fields
[i
].in_check_mask
)
1114 char *in_check_mask_char
;
1115 in_check_mask_char
= buf_to_str(cmd
->fields
[i
].in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1116 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
);
1117 free(in_check_mask_char
);
1121 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1125 free(captured_char
);
1126 free(in_check_value_char
);
1131 bit_count
+= cmd
->fields
[i
].num_bits
;
1137 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1142 for (i
=0; i
< cmd
->num_fields
; i
++)
1144 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1146 if (cmd
->fields
[i
].out_value
)
1153 int jtag_execute_queue(void)
1157 retval
= jtag
->execute_queue();
1161 jtag_command_queue
= NULL
;
1162 last_comand_pointer
= &jtag_command_queue
;
1167 int jtag_cancel_queue(void)
1170 jtag_command_queue
= NULL
;
1171 last_comand_pointer
= &jtag_command_queue
;
1176 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1178 jtag_device_t
*device
= priv
;
1182 if (event
== JTAG_TRST_ASSERTED
)
1184 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1191 void jtag_sleep(u32 us
)
1196 /* Try to examine chain layout according to IEEE 1149.1 §12
1198 int jtag_examine_chain()
1200 jtag_device_t
*device
= jtag_devices
;
1202 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1205 int device_count
= 0;
1206 u8 zero_check
= 0x0;
1207 u8 one_check
= 0xff;
1210 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1211 field
.out_value
= idcode_buffer
;
1212 field
.out_mask
= NULL
;
1213 field
.in_value
= idcode_buffer
;
1214 field
.in_check_value
= NULL
;
1215 field
.in_check_mask
= NULL
;
1216 field
.in_handler
= NULL
;
1217 field
.in_handler_priv
= NULL
;
1219 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1221 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1224 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
, NULL
);
1225 jtag_execute_queue();
1227 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1229 zero_check
|= idcode_buffer
[i
];
1230 one_check
&= idcode_buffer
[i
];
1233 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1234 if ((zero_check
== 0x00) || (one_check
== 0xff))
1236 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1240 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1242 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1243 if ((idcode
& 1) == 0)
1245 /* LSB must not be 0, this indicates a device in bypass */
1256 if (idcode
== 0x000000FF)
1258 /* End of chain (invalid manufacturer ID) */
1264 device
->idcode
= idcode
;
1265 device
= device
->next
;
1269 manufacturer
= (idcode
& 0xffe) >> 1;
1270 part
= (idcode
& 0xffff000) >> 12;
1271 version
= (idcode
& 0xf0000000) >> 28;
1273 DEBUG("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x",
1274 idcode
, manufacturer
, part
, version
);
1280 /* see if number of discovered devices matches configuration */
1281 if (device_count
!= jtag_num_devices
)
1283 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1284 device_count
, jtag_num_devices
);
1291 int jtag_validate_chain()
1293 jtag_device_t
*device
= jtag_devices
;
1294 int total_ir_length
= 0;
1301 total_ir_length
+= device
->ir_length
;
1302 device
= device
->next
;
1305 total_ir_length
+= 2;
1306 ir_test
= malloc(CEIL(total_ir_length
, 8));
1307 buf_set_ones(ir_test
, total_ir_length
);
1310 field
.num_bits
= total_ir_length
;
1311 field
.out_value
= ir_test
;
1312 field
.out_mask
= NULL
;
1313 field
.in_value
= ir_test
;
1314 field
.in_check_value
= NULL
;
1315 field
.in_check_mask
= NULL
;
1316 field
.in_handler
= NULL
;
1317 field
.in_handler_priv
= NULL
;
1319 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
, NULL
);
1320 jtag_execute_queue();
1322 device
= jtag_devices
;
1325 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1327 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1328 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1332 chain_pos
+= device
->ir_length
;
1333 device
= device
->next
;
1336 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1338 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1339 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1349 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1351 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1352 COMMAND_CONFIG
, NULL
);
1353 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1354 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1355 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1356 COMMAND_CONFIG
, NULL
);
1357 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1358 COMMAND_CONFIG
, NULL
);
1359 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1360 COMMAND_CONFIG
, NULL
);
1361 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1362 COMMAND_CONFIG
, NULL
);
1364 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1365 COMMAND_EXEC
, "print current scan chain configuration");
1367 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1368 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1369 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1370 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1371 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1372 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1373 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1374 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1375 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1376 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1377 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1378 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1380 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1381 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1385 int jtag_init(struct command_context_s
*cmd_ctx
)
1391 if (jtag_speed
== -1)
1394 if (jtag_interface
&& (jtag_interface
[0] != 0))
1395 /* configuration var 'jtag_interface' is set, and not empty */
1396 for (i
= 0; jtag_interfaces
[i
]; i
++)
1398 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1400 jtag_device_t
*device
;
1401 device
= jtag_devices
;
1403 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1404 return ERROR_JTAG_INIT_FAILED
;
1405 jtag
= jtag_interfaces
[i
];
1407 jtag_ir_scan_size
= 0;
1408 jtag_num_devices
= 0;
1409 while (device
!= NULL
)
1411 jtag_ir_scan_size
+= device
->ir_length
;
1413 device
= device
->next
;
1416 jtag_add_statemove(TAP_TLR
);
1417 jtag_execute_queue();
1419 jtag_examine_chain();
1421 jtag_validate_chain();
1427 /* no valid interface was found (i.e. the configuration option,
1428 * didn't match one of the compiled-in interfaces
1430 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1431 ERROR("compiled-in jtag interfaces:");
1432 for (i
= 0; jtag_interfaces
[i
]; i
++)
1434 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1438 return ERROR_JTAG_INVALID_INTERFACE
;
1441 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1445 /* only if the configuration var isn't overwritten from cmdline */
1446 if (!jtag_interface
)
1448 if (args
[0] && (args
[0][0] != 0))
1450 for (i
=0; jtag_interfaces
[i
]; i
++)
1452 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1454 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1457 jtag_interface
= jtag_interfaces
[i
]->name
;
1464 /* remember the requested interface name, so we can complain about it later */
1465 jtag_interface
= strdup(args
[0]);
1466 DEBUG("'interface' command didn't specify a valid interface");
1472 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1474 jtag_device_t
**last_device_p
= &jtag_devices
;
1478 while ((*last_device_p
)->next
)
1479 last_device_p
= &((*last_device_p
)->next
);
1480 last_device_p
= &((*last_device_p
)->next
);
1486 *last_device_p
= malloc(sizeof(jtag_device_t
));
1487 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1489 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1490 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1491 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1492 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1494 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1495 (*last_device_p
)->bypass
= 1;
1496 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1498 (*last_device_p
)->next
= NULL
;
1500 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1507 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1509 jtag_device_t
*device
= jtag_devices
;
1510 int device_count
= 0;
1514 u32 expected
, expected_mask
, cur_instr
;
1515 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1516 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1517 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1518 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
);
1519 device
= device
->next
;
1526 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1530 if (strcmp(args
[0], "none") == 0)
1531 jtag_reset_config
= RESET_NONE
;
1532 else if (strcmp(args
[0], "trst_only") == 0)
1533 jtag_reset_config
= RESET_HAS_TRST
;
1534 else if (strcmp(args
[0], "srst_only") == 0)
1535 jtag_reset_config
= RESET_HAS_SRST
;
1536 else if (strcmp(args
[0], "trst_and_srst") == 0)
1537 jtag_reset_config
= RESET_TRST_AND_SRST
;
1540 ERROR("invalid reset_config argument");
1547 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1548 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1549 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1550 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1551 else if (strcmp(args
[1], "combined") == 0)
1552 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1553 else if (strcmp(args
[1], "separate") == 0)
1554 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1557 ERROR("invalid reset_config argument");
1564 if (strcmp(args
[2], "trst_open_drain") == 0)
1565 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1566 else if (strcmp(args
[2], "trst_push_pull") == 0)
1567 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1570 ERROR("invalid reset_config argument");
1577 if (strcmp(args
[3], "srst_push_pull") == 0)
1578 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1579 else if (strcmp(args
[3], "srst_open_drain") == 0)
1580 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1583 ERROR("invalid reset_config argument");
1591 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1595 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1600 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1606 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1610 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1615 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1621 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1624 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1628 /* this command can be called during CONFIG,
1629 * in which case jtag isn't initialized */
1631 jtag
->speed(strtoul(args
[0], NULL
, 0));
1633 jtag_speed
= strtoul(args
[0], NULL
, 0);
1639 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1641 enum tap_state state
;
1645 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1649 for (state
= 0; state
< 16; state
++)
1651 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1653 jtag_add_end_state(state
);
1654 jtag_execute_queue();
1658 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1663 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1667 char *usage
= "usage: jtag_reset <trst> <srst>";
1672 command_print(cmd_ctx
, usage
);
1676 if (args
[0][0] == '1')
1678 else if (args
[0][0] == '0')
1682 command_print(cmd_ctx
, usage
);
1686 if (args
[1][0] == '1')
1688 else if (args
[1][0] == '0')
1692 command_print(cmd_ctx
, usage
);
1696 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1700 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1701 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1703 case ERROR_JTAG_RESET_CANT_SRST
:
1704 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1707 command_print(cmd_ctx
, "unknown error");
1710 jtag_execute_queue();
1715 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1719 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1723 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1724 jtag_execute_queue();
1730 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1732 enum tap_state state
;
1737 for (state
= 0; state
< 16; state
++)
1739 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1746 jtag_add_statemove(state
);
1747 jtag_execute_queue();
1753 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1756 scan_field_t
*fields
;
1758 if ((argc
< 2) || (argc
% 2))
1760 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1764 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1766 for (i
= 0; i
< argc
/ 2; i
++)
1768 int device
= strtoul(args
[i
*2], NULL
, 0);
1769 int field_size
= jtag_get_device(device
)->ir_length
;
1770 fields
[i
].device
= device
;
1771 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1772 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1773 fields
[i
].out_mask
= NULL
;
1774 fields
[i
].in_value
= NULL
;
1775 fields
[i
].in_check_mask
= NULL
;
1776 fields
[i
].in_handler
= NULL
;
1777 fields
[i
].in_handler_priv
= NULL
;
1780 jtag_add_ir_scan(argc
/ 2, fields
, -1, NULL
);
1781 jtag_execute_queue();
1783 for (i
= 0; i
< argc
/ 2; i
++)
1784 free(fields
[i
].out_value
);
1791 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1793 scan_field_t
*fields
;
1795 int field_count
= 0;
1799 if ((argc
< 2) || (argc
% 2))
1801 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1805 for (i
= 0; i
< argc
; i
+=2)
1807 var
= get_var_by_namenum(args
[i
+1]);
1810 num_fields
+= var
->num_fields
;
1814 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1819 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1821 for (i
= 0; i
< argc
; i
+=2)
1823 var
= get_var_by_namenum(args
[i
+1]);
1825 for (j
= 0; j
< var
->num_fields
; j
++)
1827 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1828 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1829 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1830 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1831 fields
[field_count
].out_mask
= NULL
;
1832 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1833 fields
[field_count
].in_check_mask
= NULL
;
1834 fields
[field_count
].in_check_value
= NULL
;
1835 fields
[field_count
].in_handler
= field_le_to_host
;
1836 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1840 jtag_add_dr_scan(num_fields
, fields
, -1, NULL
);
1841 jtag_execute_queue();
1843 for (i
= 0; i
< argc
/ 2; i
++)
1844 free(fields
[i
].out_value
);
1851 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1855 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1859 if (strcmp(args
[0], "enable") == 0)
1861 jtag_verify_capture_ir
= 1;
1863 else if (strcmp(args
[0], "disable") == 0)
1865 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)