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
;
194 /* forward declarations */
195 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
);
196 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
);
197 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
);
198 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state endstate
);
199 int jtag_add_statemove(enum tap_state endstate
);
200 int jtag_add_pathmove(int num_states
, enum tap_state
*path
);
201 int jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
202 int jtag_add_reset(int trst
, int srst
);
203 int jtag_add_end_state(enum tap_state endstate
);
204 int jtag_add_sleep(u32 us
);
205 int jtag_execute_queue(void);
206 int jtag_cancel_queue(void);
209 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
210 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
211 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
212 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
213 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
214 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
216 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
218 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
219 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
220 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
221 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
222 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
223 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
225 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
227 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
229 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
231 if (callback
== NULL
)
233 return ERROR_INVALID_ARGUMENTS
;
238 while ((*callbacks_p
)->next
)
239 callbacks_p
= &((*callbacks_p
)->next
);
240 callbacks_p
= &((*callbacks_p
)->next
);
243 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
244 (*callbacks_p
)->callback
= callback
;
245 (*callbacks_p
)->priv
= priv
;
246 (*callbacks_p
)->next
= NULL
;
251 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
253 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
255 if (callback
== NULL
)
257 return ERROR_INVALID_ARGUMENTS
;
262 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
263 if ((*callbacks_p
)->callback
== callback
)
266 *callbacks_p
= *next
;
274 int jtag_call_event_callbacks(enum jtag_event event
)
276 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
278 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
282 callback
->callback(event
, callback
->priv
);
283 callback
= callback
->next
;
289 /* returns a pointer to the pointer of the last command in queue
290 * this may be a pointer to the root pointer (jtag_command_queue)
291 * or to the next member of the last but one command
293 jtag_command_t
** jtag_get_last_command_p(void)
295 /* jtag_command_t *cmd = jtag_command_queue;
301 return &jtag_command_queue;
305 return last_comand_pointer
;
308 /* returns a pointer to the n-th device in the scan chain */
309 jtag_device_t
* jtag_get_device(int num
)
311 jtag_device_t
*device
= jtag_devices
;
318 device
= device
->next
;
325 void* cmd_queue_alloc(size_t size
)
327 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
332 while ((*p_page
)->next
)
333 p_page
= &((*p_page
)->next
);
334 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
335 p_page
= &((*p_page
)->next
);
340 *p_page
= malloc(sizeof(cmd_queue_page_t
));
342 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
343 (*p_page
)->next
= NULL
;
346 offset
= (*p_page
)->used
;
347 (*p_page
)->used
+= size
;
349 return ((*p_page
)->address
) + offset
;
352 void cmd_queue_free()
354 cmd_queue_page_t
*page
= cmd_queue_pages
;
358 cmd_queue_page_t
*last
= page
;
364 cmd_queue_pages
= NULL
;
367 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
369 jtag_command_t
**last_cmd
;
370 jtag_device_t
*device
;
373 /* int changed = 0; */
377 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
378 return ERROR_JTAG_TRST_ASSERTED
;
382 for (i=0; i<num_fields; i++)
384 device = jtag_get_device(fields[i].device);
387 if (buf_cmp(device->cur_instr, fields[i].out_value, device->ir_length))
392 ERROR("inexistant device specified for ir scan");
393 return ERROR_INVALID_ARGUMENTS;
401 last_cmd
= jtag_get_last_command_p();
403 /* allocate memory for a new list member */
404 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
405 (*last_cmd
)->next
= NULL
;
406 last_comand_pointer
= &((*last_cmd
)->next
);
407 (*last_cmd
)->type
= JTAG_SCAN
;
409 /* allocate memory for ir scan command */
410 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
411 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
412 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
413 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
414 (*last_cmd
)->cmd
.scan
->end_state
= state
;
417 cmd_queue_end_state
= state
;
419 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
420 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
422 if (cmd_queue_end_state
== TAP_TLR
)
423 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
425 cmd_queue_cur_state
= cmd_queue_end_state
;
427 for (i
=0; i
< jtag_num_devices
; i
++)
430 device
= jtag_get_device(i
);
431 scan_size
= device
->ir_length
;
432 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
433 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
434 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
435 if (jtag_verify_capture_ir
)
437 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
438 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
442 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
443 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
445 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
446 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
448 /* search the list */
449 for (j
=0; j
< num_fields
; j
++)
451 if (i
== fields
[j
].device
)
454 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
455 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
464 /* if a device isn't listed, set it to BYPASS */
465 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
466 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
471 /* update device information */
472 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
478 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
480 jtag_command_t
**last_cmd
;
485 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
486 return ERROR_JTAG_TRST_ASSERTED
;
489 last_cmd
= jtag_get_last_command_p();
491 /* allocate memory for a new list member */
492 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
493 (*last_cmd
)->next
= NULL
;
494 last_comand_pointer
= &((*last_cmd
)->next
);
495 (*last_cmd
)->type
= JTAG_SCAN
;
497 /* allocate memory for ir scan command */
498 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
499 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
500 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
501 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
502 (*last_cmd
)->cmd
.scan
->end_state
= state
;
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
)
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 cmd_queue_end_state
= state
;
571 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
572 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
574 if (cmd_queue_end_state
== TAP_TLR
)
575 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
577 cmd_queue_cur_state
= cmd_queue_end_state
;
579 for (i
=0; i
< jtag_num_devices
; i
++)
582 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
584 for (j
=0; j
< num_fields
; j
++)
586 if (i
== fields
[j
].device
)
589 scan_size
= fields
[j
].num_bits
;
590 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
591 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
592 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
593 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
594 (*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
);
595 (*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
);
596 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
597 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
602 /* if a device isn't listed, the BYPASS register should be selected */
603 if (!jtag_get_device(i
)->bypass
)
605 ERROR("BUG: no scan data for a device not in BYPASS");
609 /* program the scan field to 1 bit length, and ignore it's value */
610 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
611 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
612 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
613 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
614 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
615 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
616 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
617 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
621 /* if a device is listed, the BYPASS register must not be selected */
622 if (jtag_get_device(i
)->bypass
)
624 WARNING("scan data for a device in BYPASS");
631 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
634 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
638 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
639 return ERROR_JTAG_TRST_ASSERTED
;
642 /* allocate memory for a new list member */
643 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
644 last_comand_pointer
= &((*last_cmd
)->next
);
645 (*last_cmd
)->next
= NULL
;
646 (*last_cmd
)->type
= JTAG_SCAN
;
648 /* allocate memory for scan command */
649 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
650 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
651 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
652 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
653 (*last_cmd
)->cmd
.scan
->end_state
= state
;
656 cmd_queue_end_state
= state
;
658 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
659 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
661 if (cmd_queue_end_state
== TAP_TLR
)
662 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
664 cmd_queue_cur_state
= cmd_queue_end_state
;
666 for (i
= 0; i
< num_fields
; i
++)
668 int num_bits
= fields
[i
].num_bits
;
669 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
670 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
671 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
672 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
673 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
674 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
675 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
676 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
677 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
678 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
683 int jtag_add_statemove(enum tap_state state
)
685 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
689 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
690 return ERROR_JTAG_TRST_ASSERTED
;
693 /* allocate memory for a new list member */
694 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
695 last_comand_pointer
= &((*last_cmd
)->next
);
696 (*last_cmd
)->next
= NULL
;
697 (*last_cmd
)->type
= JTAG_STATEMOVE
;
699 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
700 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
703 cmd_queue_end_state
= state
;
705 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
706 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
708 if (cmd_queue_end_state
== TAP_TLR
)
709 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
711 cmd_queue_cur_state
= cmd_queue_end_state
;
716 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
718 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
723 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
724 return ERROR_JTAG_TRST_ASSERTED
;
727 /* the last state has to be a stable state */
728 if (tap_move_map
[path
[num_states
- 1]] == -1)
730 ERROR("TAP path doesn't finish in a stable state");
731 return ERROR_JTAG_NOT_IMPLEMENTED
;
734 if (jtag
->support_pathmove
)
736 /* allocate memory for a new list member */
737 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
738 last_comand_pointer
= &((*last_cmd
)->next
);
739 (*last_cmd
)->next
= NULL
;
740 (*last_cmd
)->type
= JTAG_PATHMOVE
;
742 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
743 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
744 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
746 for (i
= 0; i
< num_states
; i
++)
747 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
751 /* validate the desired path, and see if it fits a default path */
756 for (i
= 0; i
< num_states
; i
++)
758 for (j
= i
; j
< num_states
; j
++)
760 if (tap_move_map
[path
[j
]] != -1)
767 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
769 jtag_add_statemove(path
[end
]);
773 ERROR("encountered a TAP path that can't be fulfilled by default paths");
774 return ERROR_JTAG_NOT_IMPLEMENTED
;
781 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
782 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
784 if (cmd_queue_end_state
== TAP_TLR
)
785 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
787 cmd_queue_cur_state
= path
[num_states
- 1];
792 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
794 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
798 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
799 return ERROR_JTAG_TRST_ASSERTED
;
802 /* allocate memory for a new list member */
803 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
804 (*last_cmd
)->next
= NULL
;
805 last_comand_pointer
= &((*last_cmd
)->next
);
806 (*last_cmd
)->type
= JTAG_RUNTEST
;
808 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
809 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
810 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
813 cmd_queue_end_state
= state
;
815 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
816 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
818 if (cmd_queue_end_state
== TAP_TLR
)
819 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
821 cmd_queue_cur_state
= cmd_queue_end_state
;
826 int jtag_add_reset(int req_trst
, int req_srst
)
828 int trst_with_tms
= 0;
830 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
833 req_trst
= jtag_trst
;
836 req_srst
= jtag_srst
;
838 /* Make sure that jtag_reset_config allows the requested reset */
839 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
840 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
841 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
843 /* if TRST pulls SRST, we reset with TAP T-L-R */
844 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
850 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
852 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
853 return ERROR_JTAG_RESET_CANT_SRST
;
856 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
862 /* allocate memory for a new list member */
863 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
864 (*last_cmd
)->next
= NULL
;
865 last_comand_pointer
= &((*last_cmd
)->next
);
866 (*last_cmd
)->type
= JTAG_RESET
;
868 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
869 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
870 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
872 jtag_trst
= req_trst
;
873 jtag_srst
= req_srst
;
877 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
881 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
882 if (jtag_nsrst_delay
)
883 jtag_add_sleep(jtag_nsrst_delay
* 1000);
888 last_cmd
= &((*last_cmd
)->next
);
890 /* allocate memory for a new list member */
891 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
892 (*last_cmd
)->next
= NULL
;
893 last_comand_pointer
= &((*last_cmd
)->next
);
894 (*last_cmd
)->type
= JTAG_STATEMOVE
;
896 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
897 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
899 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
900 cmd_queue_cur_state
= TAP_TLR
;
901 cmd_queue_end_state
= TAP_TLR
;
909 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
910 * and inform possible listeners about this
912 cmd_queue_cur_state
= TAP_TLR
;
913 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
917 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
918 * but we might want to add a delay to give the TAP time to settle
920 if (jtag_ntrst_delay
)
921 jtag_add_sleep(jtag_ntrst_delay
* 1000);
928 int jtag_add_end_state(enum tap_state state
)
930 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
932 /* allocate memory for a new list member */
933 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
934 (*last_cmd
)->next
= NULL
;
935 last_comand_pointer
= &((*last_cmd
)->next
);
936 (*last_cmd
)->type
= JTAG_END_STATE
;
938 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
939 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
942 cmd_queue_end_state
= state
;
947 int jtag_add_sleep(u32 us
)
949 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
951 /* allocate memory for a new list member */
952 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
953 (*last_cmd
)->next
= NULL
;
954 last_comand_pointer
= &((*last_cmd
)->next
);
955 (*last_cmd
)->type
= JTAG_SLEEP
;
957 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
958 (*last_cmd
)->cmd
.sleep
->us
= us
;
963 int jtag_scan_size(scan_command_t
*cmd
)
968 /* count bits in scan command */
969 for (i
=0; i
<cmd
->num_fields
; i
++)
971 bit_count
+= cmd
->fields
[i
].num_bits
;
977 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
982 bit_count
= jtag_scan_size(cmd
);
983 *buffer
= malloc(CEIL(bit_count
, 8));
987 for (i
= 0; i
< cmd
->num_fields
; i
++)
989 if (cmd
->fields
[i
].out_value
)
991 #ifdef _DEBUG_JTAG_IO_
992 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
994 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
995 #ifdef _DEBUG_JTAG_IO_
996 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1001 bit_count
+= cmd
->fields
[i
].num_bits
;
1008 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1012 int retval
= ERROR_OK
;
1014 for (i
=0; i
< cmd
->num_fields
; i
++)
1016 /* if neither in_value, in_check_value nor in_handler
1017 * are specified we don't have to examine this field
1019 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_handler
)
1021 int num_bits
= cmd
->fields
[i
].num_bits
;
1022 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1023 #ifdef _DEBUG_JTAG_IO_
1026 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1027 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1032 if (cmd
->fields
[i
].in_value
)
1034 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1036 if (cmd
->fields
[i
].in_handler
)
1038 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1040 /* TODO: error reporting */
1041 WARNING("in_handler reported a failed check");
1042 retval
= ERROR_JTAG_QUEUE_FAILED
;
1047 /* no in_value specified, but a handler takes care of the scanned data */
1048 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1050 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1052 /* TODO: error reporting */
1053 WARNING("in_handler reported a failed check");
1054 retval
= ERROR_JTAG_QUEUE_FAILED
;
1059 if (cmd
->fields
[i
].in_check_value
)
1061 if ((cmd
->fields
[i
].in_check_mask
&& buf_cmp_mask(captured
, cmd
->fields
[i
].in_check_value
, cmd
->fields
[i
].in_check_mask
, num_bits
))
1062 || (!cmd
->fields
[i
].in_check_mask
&& buf_cmp(captured
, cmd
->fields
[i
].in_check_mask
, num_bits
)))
1064 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1065 char *in_check_value_char
= buf_to_str(cmd
->fields
[i
].in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1066 char *in_check_mask_char
= buf_to_str(cmd
->fields
[i
].in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1067 /* TODO: error reporting */
1068 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
);
1069 retval
= ERROR_JTAG_QUEUE_FAILED
;
1070 free(captured_char
);
1071 free(in_check_value_char
);
1072 free(in_check_mask_char
);
1077 bit_count
+= cmd
->fields
[i
].num_bits
;
1083 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1088 for (i
=0; i
< cmd
->num_fields
; i
++)
1090 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1092 if (cmd
->fields
[i
].out_value
)
1099 int jtag_execute_queue(void)
1103 retval
= jtag
->execute_queue();
1107 jtag_command_queue
= NULL
;
1108 last_comand_pointer
= &jtag_command_queue
;
1113 int jtag_cancel_queue(void)
1116 jtag_command_queue
= NULL
;
1117 last_comand_pointer
= &jtag_command_queue
;
1122 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1124 jtag_device_t
*device
= priv
;
1128 if (event
== JTAG_TRST_ASSERTED
)
1130 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1137 void jtag_sleep(u32 us
)
1142 /* Try to examine chain layout according to IEEE 1149.1 §12
1144 int jtag_examine_chain()
1147 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1150 int device_count
= 0;
1151 u8 zero_check
= 0x0;
1152 u8 one_check
= 0xff;
1155 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1156 field
.out_value
= idcode_buffer
;
1157 field
.out_mask
= NULL
;
1158 field
.in_value
= idcode_buffer
;
1159 field
.in_check_value
= NULL
;
1160 field
.in_check_mask
= NULL
;
1161 field
.in_handler
= NULL
;
1162 field
.in_handler_priv
= NULL
;
1164 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1166 buf_set_u32(idcode_buffer
, 0, 32, 0x000000FF);
1169 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1170 jtag_execute_queue();
1172 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1174 zero_check
|= idcode_buffer
[i
];
1175 one_check
&= idcode_buffer
[i
];
1178 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1179 if ((zero_check
== 0x00) || (one_check
== 0xff))
1181 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1185 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1187 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1188 if ((idcode
& 1) == 0)
1190 /* LSB must not be 0, this indicates a device in bypass */
1201 if (idcode
== 0x000000FF)
1203 /* End of chain (invalid manufacturer ID) */
1209 manufacturer
= (idcode
& 0xffe) >> 1;
1210 part
= (idcode
& 0xffff000) >> 12;
1211 version
= (idcode
& 0xf0000000) >> 28;
1213 DEBUG("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x",
1214 idcode
, manufacturer
, part
, version
);
1220 /* see if number of discovered devices matches configuration */
1221 if (device_count
!= jtag_num_devices
)
1223 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1224 device_count
, jtag_num_devices
);
1231 int jtag_validate_chain()
1233 jtag_device_t
*device
= jtag_devices
;
1234 int total_ir_length
= 0;
1241 total_ir_length
+= device
->ir_length
;
1242 device
= device
->next
;
1245 total_ir_length
+= 2;
1246 ir_test
= malloc(CEIL(total_ir_length
, 8));
1247 buf_set_ones(ir_test
, total_ir_length
);
1250 field
.num_bits
= total_ir_length
;
1251 field
.out_value
= ir_test
;
1252 field
.out_mask
= NULL
;
1253 field
.in_value
= ir_test
;
1254 field
.in_check_value
= NULL
;
1255 field
.in_check_mask
= NULL
;
1256 field
.in_handler
= NULL
;
1257 field
.in_handler_priv
= NULL
;
1259 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1260 jtag_execute_queue();
1262 device
= jtag_devices
;
1265 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1267 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1268 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1272 chain_pos
+= device
->ir_length
;
1273 device
= device
->next
;
1276 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1278 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1279 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1289 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1291 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1292 COMMAND_CONFIG
, NULL
);
1293 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1294 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1295 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1296 COMMAND_CONFIG
, NULL
);
1297 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1298 COMMAND_CONFIG
, NULL
);
1299 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1300 COMMAND_CONFIG
, NULL
);
1301 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1302 COMMAND_CONFIG
, NULL
);
1304 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1305 COMMAND_EXEC
, "print current scan chain configuration");
1307 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1308 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1309 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1310 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1311 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1312 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1313 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1314 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1315 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1316 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1317 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1318 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1320 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1321 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1325 int jtag_init(struct command_context_s
*cmd_ctx
)
1331 if (jtag_speed
== -1)
1334 if (jtag_interface
&& (jtag_interface
[0] != 0))
1335 /* configuration var 'jtag_interface' is set, and not empty */
1336 for (i
= 0; jtag_interfaces
[i
]; i
++)
1338 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1340 jtag_device_t
*device
;
1341 device
= jtag_devices
;
1343 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1344 return ERROR_JTAG_INIT_FAILED
;
1345 jtag
= jtag_interfaces
[i
];
1347 jtag_ir_scan_size
= 0;
1348 jtag_num_devices
= 0;
1349 while (device
!= NULL
)
1351 jtag_ir_scan_size
+= device
->ir_length
;
1353 device
= device
->next
;
1356 jtag_add_statemove(TAP_TLR
);
1357 jtag_execute_queue();
1359 jtag_examine_chain();
1361 jtag_validate_chain();
1367 /* no valid interface was found (i.e. the configuration option,
1368 * didn't match one of the compiled-in interfaces
1370 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1371 ERROR("compiled-in jtag interfaces:");
1372 for (i
= 0; jtag_interfaces
[i
]; i
++)
1374 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1378 return ERROR_JTAG_INVALID_INTERFACE
;
1381 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1385 /* only if the configuration var isn't overwritten from cmdline */
1386 if (!jtag_interface
)
1388 if (args
[0] && (args
[0][0] != 0))
1390 for (i
=0; jtag_interfaces
[i
]; i
++)
1392 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1394 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1397 jtag_interface
= jtag_interfaces
[i
]->name
;
1404 /* remember the requested interface name, so we can complain about it later */
1405 jtag_interface
= strdup(args
[0]);
1406 DEBUG("'interface' command didn't specify a valid interface");
1412 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1414 jtag_device_t
**last_device_p
= &jtag_devices
;
1418 while ((*last_device_p
)->next
)
1419 last_device_p
= &((*last_device_p
)->next
);
1420 last_device_p
= &((*last_device_p
)->next
);
1426 *last_device_p
= malloc(sizeof(jtag_device_t
));
1427 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1429 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1430 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1431 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1432 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1434 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1435 (*last_device_p
)->bypass
= 1;
1436 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1438 (*last_device_p
)->next
= NULL
;
1440 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1447 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1449 jtag_device_t
*device
= jtag_devices
;
1450 int device_count
= 0;
1454 u32 expected
, expected_mask
, cur_instr
;
1455 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1456 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1457 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1458 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
);
1459 device
= device
->next
;
1466 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1470 if (strcmp(args
[0], "none") == 0)
1471 jtag_reset_config
= RESET_NONE
;
1472 else if (strcmp(args
[0], "trst_only") == 0)
1473 jtag_reset_config
= RESET_HAS_TRST
;
1474 else if (strcmp(args
[0], "srst_only") == 0)
1475 jtag_reset_config
= RESET_HAS_SRST
;
1476 else if (strcmp(args
[0], "trst_and_srst") == 0)
1477 jtag_reset_config
= RESET_TRST_AND_SRST
;
1480 ERROR("invalid reset_config argument");
1487 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1488 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1489 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1490 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1491 else if (strcmp(args
[1], "combined") == 0)
1492 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1493 else if (strcmp(args
[1], "separate") == 0)
1494 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1497 ERROR("invalid reset_config argument");
1504 if (strcmp(args
[2], "trst_open_drain") == 0)
1505 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1506 else if (strcmp(args
[2], "trst_push_pull") == 0)
1507 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1510 ERROR("invalid reset_config argument");
1517 if (strcmp(args
[3], "srst_push_pull") == 0)
1518 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1519 else if (strcmp(args
[3], "srst_open_drain") == 0)
1520 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1523 ERROR("invalid reset_config argument");
1531 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1535 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1540 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1546 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1550 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1555 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1561 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1564 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1568 /* this command can be called during CONFIG,
1569 * in which case jtag isn't initialized */
1571 jtag
->speed(strtoul(args
[0], NULL
, 0));
1573 jtag_speed
= strtoul(args
[0], NULL
, 0);
1579 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1581 enum tap_state state
;
1585 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1589 for (state
= 0; state
< 16; state
++)
1591 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1593 jtag_add_end_state(state
);
1594 jtag_execute_queue();
1601 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1605 char *usage
= "usage: jtag_reset <trst> <srst>";
1610 command_print(cmd_ctx
, usage
);
1614 if (args
[0][0] == '1')
1616 else if (args
[0][0] == '0')
1620 command_print(cmd_ctx
, usage
);
1624 if (args
[1][0] == '1')
1626 else if (args
[1][0] == '0')
1630 command_print(cmd_ctx
, usage
);
1634 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1638 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1639 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1641 case ERROR_JTAG_RESET_CANT_SRST
:
1642 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1645 command_print(cmd_ctx
, "unknown error");
1648 jtag_execute_queue();
1653 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1657 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1661 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1662 jtag_execute_queue();
1668 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1670 enum tap_state state
;
1675 for (state
= 0; state
< 16; state
++)
1677 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1684 jtag_add_statemove(state
);
1685 jtag_execute_queue();
1691 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1694 scan_field_t
*fields
;
1696 if ((argc
< 2) || (argc
% 2))
1698 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1702 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1704 for (i
= 0; i
< argc
/ 2; i
++)
1706 int device
= strtoul(args
[i
*2], NULL
, 0);
1707 int field_size
= jtag_get_device(device
)->ir_length
;
1708 fields
[i
].device
= device
;
1709 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1710 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1711 fields
[i
].out_mask
= NULL
;
1712 fields
[i
].in_value
= NULL
;
1713 fields
[i
].in_check_mask
= NULL
;
1714 fields
[i
].in_handler
= NULL
;
1715 fields
[i
].in_handler_priv
= NULL
;
1718 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1719 jtag_execute_queue();
1721 for (i
= 0; i
< argc
/ 2; i
++)
1722 free(fields
[i
].out_value
);
1729 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1731 scan_field_t
*fields
;
1733 int field_count
= 0;
1737 if ((argc
< 2) || (argc
% 2))
1739 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1743 for (i
= 0; i
< argc
; i
+=2)
1745 var
= get_var_by_namenum(args
[i
+1]);
1748 num_fields
+= var
->num_fields
;
1752 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1757 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1759 for (i
= 0; i
< argc
; i
+=2)
1761 var
= get_var_by_namenum(args
[i
+1]);
1763 for (j
= 0; j
< var
->num_fields
; j
++)
1765 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1766 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1767 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1768 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1769 fields
[field_count
].out_mask
= NULL
;
1770 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1771 fields
[field_count
].in_check_mask
= NULL
;
1772 fields
[field_count
].in_check_value
= NULL
;
1773 fields
[field_count
].in_handler
= field_le_to_host
;
1774 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1778 jtag_add_dr_scan(num_fields
, fields
, -1);
1779 jtag_execute_queue();
1781 for (i
= 0; i
< argc
/ 2; i
++)
1782 free(fields
[i
].out_value
);
1789 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1793 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1797 if (strcmp(args
[0], "enable") == 0)
1799 jtag_verify_capture_ir
= 1;
1801 else if (strcmp(args
[0], "disable") == 0)
1803 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)