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 enum tap_state end_state
= TAP_TLR
;
99 enum tap_state cur_state
= TAP_TLR
;
103 jtag_command_t
*jtag_command_queue
= NULL
;
104 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
105 jtag_device_t
*jtag_devices
= NULL
;
106 int jtag_num_devices
= 0;
107 int jtag_ir_scan_size
= 0;
108 enum reset_types jtag_reset_config
= RESET_NONE
;
109 enum tap_state cmd_queue_end_state
= TAP_TLR
;
110 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
112 int jtag_verify_capture_ir
= 1;
114 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
115 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
116 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
118 /* callbacks to inform high-level handlers about JTAG state changes */
119 jtag_event_callback_t
*jtag_event_callbacks
;
121 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
123 #if BUILD_PARPORT == 1
124 extern jtag_interface_t parport_interface
;
127 #if BUILD_FTDI2232 == 1
128 extern jtag_interface_t ftdi2232_interface
;
131 #if BUILD_FTD2XX == 1
132 extern jtag_interface_t ftd2xx_interface
;
135 #if BUILD_AMTJTAGACCEL == 1
136 extern jtag_interface_t amt_jtagaccel_interface
;
139 #if BUILD_EP93XX == 1
140 extern jtag_interface_t ep93xx_interface
;
143 jtag_interface_t
*jtag_interfaces
[] = {
144 #if BUILD_PARPORT == 1
147 #if BUILD_FTDI2232 == 1
150 #if BUILD_FTD2XX == 1
153 #if BUILD_AMTJTAGACCEL == 1
154 &amt_jtagaccel_interface
,
156 #if BUILD_EP93XX == 1
162 jtag_interface_t
*jtag
= NULL
;
165 char* jtag_interface
= NULL
;
168 /* forward declarations */
171 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
172 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
173 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
174 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
175 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
176 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
178 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
180 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
181 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
182 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
183 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
184 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
185 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
187 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
189 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
191 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
193 if (callback
== NULL
)
195 return ERROR_INVALID_ARGUMENTS
;
200 while ((*callbacks_p
)->next
)
201 callbacks_p
= &((*callbacks_p
)->next
);
202 callbacks_p
= &((*callbacks_p
)->next
);
205 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
206 (*callbacks_p
)->callback
= callback
;
207 (*callbacks_p
)->priv
= priv
;
208 (*callbacks_p
)->next
= NULL
;
213 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
215 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
217 if (callback
== NULL
)
219 return ERROR_INVALID_ARGUMENTS
;
224 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
225 if ((*callbacks_p
)->callback
== callback
)
228 *callbacks_p
= *next
;
236 int jtag_call_event_callbacks(enum jtag_event event
)
238 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
240 DEBUG("jtag event: %i", event
);
244 callback
->callback(event
, callback
->priv
);
245 callback
= callback
->next
;
251 /* returns a pointer to the pointer of the last command in queue
252 * this may be a pointer to the root pointer (jtag_command_queue)
253 * or to the next member of the last but one command
255 jtag_command_t
** jtag_get_last_command_p(void)
257 /* jtag_command_t *cmd = jtag_command_queue;
263 return &jtag_command_queue;
267 return last_comand_pointer
;
270 /* returns a pointer to the n-th device in the scan chain */
271 jtag_device_t
* jtag_get_device(int num
)
273 jtag_device_t
*device
= jtag_devices
;
280 device
= device
->next
;
287 void* cmd_queue_alloc(size_t size
)
289 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
294 while ((*p_page
)->next
)
295 p_page
= &((*p_page
)->next
);
296 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
297 p_page
= &((*p_page
)->next
);
302 *p_page
= malloc(sizeof(cmd_queue_page_t
));
304 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
305 (*p_page
)->next
= NULL
;
308 offset
= (*p_page
)->used
;
309 (*p_page
)->used
+= size
;
311 return ((*p_page
)->address
) + offset
;
314 void cmd_queue_free()
316 cmd_queue_page_t
*page
= cmd_queue_pages
;
320 cmd_queue_page_t
*last
= page
;
326 cmd_queue_pages
= NULL
;
329 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
331 jtag_command_t
**last_cmd
;
332 jtag_device_t
*device
;
335 /* int changed = 0; */
339 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
340 return ERROR_JTAG_TRST_ASSERTED
;
344 for (i=0; i<num_fields; i++)
346 device = jtag_get_device(fields[i].device);
349 if (buf_cmp(device->cur_instr, fields[i].out_value, device->ir_length))
354 ERROR("inexistant device specified for ir scan");
355 return ERROR_INVALID_ARGUMENTS;
363 last_cmd
= jtag_get_last_command_p();
365 /* allocate memory for a new list member */
366 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
367 (*last_cmd
)->next
= NULL
;
368 last_comand_pointer
= &((*last_cmd
)->next
);
369 (*last_cmd
)->type
= JTAG_SCAN
;
371 /* allocate memory for ir scan command */
372 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
373 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
374 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
375 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
376 (*last_cmd
)->cmd
.scan
->end_state
= state
;
379 cmd_queue_end_state
= state
;
381 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
382 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
384 if (cmd_queue_end_state
== TAP_TLR
)
385 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
387 cmd_queue_cur_state
= cmd_queue_end_state
;
389 for (i
=0; i
< jtag_num_devices
; i
++)
392 device
= jtag_get_device(i
);
393 scan_size
= device
->ir_length
;
394 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
395 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
396 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
397 if (jtag_verify_capture_ir
)
399 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
400 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
404 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
405 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
407 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
408 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
410 /* search the list */
411 for (j
=0; j
< num_fields
; j
++)
413 if (i
== fields
[j
].device
)
416 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
417 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
426 /* if a device isn't listed, set it to BYPASS */
427 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
428 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
433 /* update device information */
434 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
440 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
442 jtag_command_t
**last_cmd
;
447 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
448 return ERROR_JTAG_TRST_ASSERTED
;
451 last_cmd
= jtag_get_last_command_p();
453 /* allocate memory for a new list member */
454 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
455 (*last_cmd
)->next
= NULL
;
456 last_comand_pointer
= &((*last_cmd
)->next
);
457 (*last_cmd
)->type
= JTAG_SCAN
;
459 /* allocate memory for ir scan command */
460 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
461 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
462 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
463 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
464 (*last_cmd
)->cmd
.scan
->end_state
= state
;
467 cmd_queue_end_state
= state
;
469 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
470 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
472 if (cmd_queue_end_state
== TAP_TLR
)
473 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
475 cmd_queue_cur_state
= cmd_queue_end_state
;
477 for (i
= 0; i
< num_fields
; i
++)
479 int num_bits
= fields
[i
].num_bits
;
480 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
481 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
482 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
483 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
484 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
485 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
486 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
487 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
488 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
489 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
494 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
497 int bypass_devices
= 0;
499 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
500 jtag_device_t
*device
= jtag_devices
;
505 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
506 return ERROR_JTAG_TRST_ASSERTED
;
509 /* count devices in bypass */
514 device
= device
->next
;
517 /* allocate memory for a new list member */
518 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
519 last_comand_pointer
= &((*last_cmd
)->next
);
520 (*last_cmd
)->next
= NULL
;
521 (*last_cmd
)->type
= JTAG_SCAN
;
523 /* allocate memory for dr scan command */
524 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
525 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
526 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
527 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
528 (*last_cmd
)->cmd
.scan
->end_state
= state
;
531 cmd_queue_end_state
= state
;
533 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
534 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
536 if (cmd_queue_end_state
== TAP_TLR
)
537 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
539 cmd_queue_cur_state
= cmd_queue_end_state
;
541 for (i
=0; i
< jtag_num_devices
; i
++)
544 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
546 for (j
=0; j
< num_fields
; j
++)
548 if (i
== fields
[j
].device
)
551 scan_size
= fields
[j
].num_bits
;
552 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
553 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
554 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
555 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
556 (*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
);
557 (*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
);
558 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
559 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
564 /* if a device isn't listed, the BYPASS register should be selected */
565 if (!jtag_get_device(i
)->bypass
)
567 ERROR("BUG: no scan data for a device not in BYPASS");
571 /* program the scan field to 1 bit length, and ignore it's value */
572 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
573 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
574 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
575 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
576 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
577 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
578 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
579 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
583 /* if a device is listed, the BYPASS register must not be selected */
584 if (jtag_get_device(i
)->bypass
)
586 ERROR("BUG: scan data for a device in BYPASS");
594 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
597 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
601 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
602 return ERROR_JTAG_TRST_ASSERTED
;
605 /* allocate memory for a new list member */
606 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
607 last_comand_pointer
= &((*last_cmd
)->next
);
608 (*last_cmd
)->next
= NULL
;
609 (*last_cmd
)->type
= JTAG_SCAN
;
611 /* allocate memory for scan command */
612 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
613 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
614 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
615 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
616 (*last_cmd
)->cmd
.scan
->end_state
= state
;
619 cmd_queue_end_state
= state
;
621 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
622 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
624 if (cmd_queue_end_state
== TAP_TLR
)
625 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
627 cmd_queue_cur_state
= cmd_queue_end_state
;
629 for (i
= 0; i
< num_fields
; i
++)
631 int num_bits
= fields
[i
].num_bits
;
632 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
633 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
634 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
635 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
636 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
637 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
638 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
639 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
640 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
641 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
646 int jtag_add_statemove(enum tap_state state
)
648 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
652 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
653 return ERROR_JTAG_TRST_ASSERTED
;
656 /* allocate memory for a new list member */
657 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
658 last_comand_pointer
= &((*last_cmd
)->next
);
659 (*last_cmd
)->next
= NULL
;
660 (*last_cmd
)->type
= JTAG_STATEMOVE
;
662 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
663 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
666 cmd_queue_end_state
= state
;
668 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
669 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
671 if (cmd_queue_end_state
== TAP_TLR
)
672 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
674 cmd_queue_cur_state
= cmd_queue_end_state
;
679 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
681 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
686 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
687 return ERROR_JTAG_TRST_ASSERTED
;
690 /* the last state has to be a stable state */
691 if (tap_move_map
[path
[num_states
- 1]] == -1)
693 ERROR("TAP path doesn't finish in a stable state");
694 return ERROR_JTAG_NOT_IMPLEMENTED
;
697 if (jtag
->support_statemove
)
699 /* allocate memory for a new list member */
700 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
701 last_comand_pointer
= &((*last_cmd
)->next
);
702 (*last_cmd
)->next
= NULL
;
703 (*last_cmd
)->type
= JTAG_RUNTEST
;
705 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
706 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
707 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
709 for (i
= 0; i
< num_states
; i
++)
710 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
714 /* validate the desired path, and see if it fits a default path */
719 for (i
= 0; i
< num_states
; i
++)
721 for (j
= i
; j
< num_states
; j
++)
723 if (tap_move_map
[path
[j
]] != -1)
730 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
732 jtag_add_statemove(path
[end
]);
736 ERROR("encountered a TAP path that can't be fulfilled by default paths");
737 return ERROR_JTAG_NOT_IMPLEMENTED
;
744 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
745 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
747 if (cmd_queue_end_state
== TAP_TLR
)
748 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
750 cmd_queue_cur_state
= path
[num_states
- 1];
755 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
757 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
761 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
762 return ERROR_JTAG_TRST_ASSERTED
;
765 /* allocate memory for a new list member */
766 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
767 (*last_cmd
)->next
= NULL
;
768 last_comand_pointer
= &((*last_cmd
)->next
);
769 (*last_cmd
)->type
= JTAG_RUNTEST
;
771 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
772 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
773 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
776 cmd_queue_end_state
= state
;
778 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
779 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
781 if (cmd_queue_end_state
== TAP_TLR
)
782 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
784 cmd_queue_cur_state
= cmd_queue_end_state
;
789 int jtag_add_reset(int req_trst
, int req_srst
)
791 int trst_with_tms
= 0;
793 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
796 req_trst
= jtag_trst
;
799 req_srst
= jtag_srst
;
801 /* Make sure that jtag_reset_config allows the requested reset */
802 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
803 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
804 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
806 /* if TRST pulls SRST, we reset with TAP T-L-R */
807 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
813 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
815 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
816 return ERROR_JTAG_RESET_CANT_SRST
;
819 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
825 /* allocate memory for a new list member */
826 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
827 (*last_cmd
)->next
= NULL
;
828 last_comand_pointer
= &((*last_cmd
)->next
);
829 (*last_cmd
)->type
= JTAG_RESET
;
831 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
832 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
833 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
835 jtag_trst
= req_trst
;
836 jtag_srst
= req_srst
;
840 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
844 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
845 if (jtag_nsrst_delay
)
846 jtag_add_sleep(jtag_nsrst_delay
);
851 last_cmd
= &((*last_cmd
)->next
);
853 /* allocate memory for a new list member */
854 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
855 (*last_cmd
)->next
= NULL
;
856 last_comand_pointer
= &((*last_cmd
)->next
);
857 (*last_cmd
)->type
= JTAG_STATEMOVE
;
859 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
860 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
862 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
863 cmd_queue_cur_state
= TAP_TLR
;
864 cmd_queue_end_state
= TAP_TLR
;
872 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
873 * and inform possible listeners about this
875 cmd_queue_cur_state
= TAP_TLR
;
876 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
880 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
881 * but we might want to add a delay to give the TAP time to settle
883 if (jtag_ntrst_delay
)
884 jtag_add_sleep(jtag_ntrst_delay
);
891 int jtag_add_end_state(enum tap_state state
)
893 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
895 /* allocate memory for a new list member */
896 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
897 (*last_cmd
)->next
= NULL
;
898 last_comand_pointer
= &((*last_cmd
)->next
);
899 (*last_cmd
)->type
= JTAG_END_STATE
;
901 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
902 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
905 cmd_queue_end_state
= state
;
910 int jtag_add_sleep(u32 us
)
912 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
914 /* allocate memory for a new list member */
915 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
916 (*last_cmd
)->next
= NULL
;
917 last_comand_pointer
= &((*last_cmd
)->next
);
918 (*last_cmd
)->type
= JTAG_SLEEP
;
920 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
921 (*last_cmd
)->cmd
.sleep
->us
= us
;
926 int jtag_scan_size(scan_command_t
*cmd
)
931 /* count bits in scan command */
932 for (i
=0; i
<cmd
->num_fields
; i
++)
934 bit_count
+= cmd
->fields
[i
].num_bits
;
940 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
945 bit_count
= jtag_scan_size(cmd
);
946 *buffer
= malloc(CEIL(bit_count
, 8));
950 for (i
= 0; i
< cmd
->num_fields
; i
++)
952 if (cmd
->fields
[i
].out_value
)
954 char* char_buf
= buf_to_char(cmd
->fields
[i
].out_value
, cmd
->fields
[i
].num_bits
);
955 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
956 #ifdef _DEBUG_JTAG_IO_
957 DEBUG("fields[%i].out_value: %s", i
, char_buf
);
962 bit_count
+= cmd
->fields
[i
].num_bits
;
969 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
973 int retval
= ERROR_OK
;
975 for (i
=0; i
< cmd
->num_fields
; i
++)
977 /* if neither in_value nor in_check_value are specified we don't have to examine this field */
978 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
)
980 int num_bits
= cmd
->fields
[i
].num_bits
;
982 if (cmd
->fields
[i
].in_value
)
985 buf_set_buf(buffer
, bit_count
, cmd
->fields
[i
].in_value
, 0, num_bits
);
986 char_buf
= buf_to_char(cmd
->fields
[i
].in_value
, num_bits
);
987 #ifdef _DEBUG_JTAG_IO_
988 DEBUG("fields[%i].in_value: %s", i
, char_buf
);
991 if (cmd
->fields
[i
].in_handler
)
993 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
995 /* TODO: error reporting */
996 WARNING("in_handler reported a failed check");
997 retval
= ERROR_JTAG_QUEUE_FAILED
;
1002 if (cmd
->fields
[i
].in_check_value
)
1004 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1005 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
))
1006 || (!cmd
->fields
[i
].in_check_mask
&& buf_cmp(captured
, cmd
->fields
[i
].in_check_mask
, num_bits
)))
1008 char *captured_char
= buf_to_char(captured
, num_bits
);
1009 char *in_check_value_char
= buf_to_char(cmd
->fields
[i
].in_check_value
, num_bits
);
1010 char *in_check_mask_char
= buf_to_char(cmd
->fields
[i
].in_check_mask
, num_bits
);
1011 /* TODO: error reporting */
1012 WARNING("value captured during scan didn't pass the requested check: captured: %s check_value: %s check_mask: %s", captured_char
, in_check_value_char
, in_check_mask_char
);
1013 retval
= ERROR_JTAG_QUEUE_FAILED
;
1014 free(captured_char
);
1015 free(in_check_value_char
);
1016 free(in_check_mask_char
);
1021 bit_count
+= cmd
->fields
[i
].num_bits
;
1027 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1032 for (i
=0; i
< cmd
->num_fields
; i
++)
1034 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
)
1036 if (cmd
->fields
[i
].out_value
)
1043 int jtag_execute_queue(void)
1047 retval
= jtag
->execute_queue();
1051 jtag_command_queue
= NULL
;
1052 last_comand_pointer
= &jtag_command_queue
;
1057 int jtag_cancel_queue(void)
1060 jtag_command_queue
= NULL
;
1061 last_comand_pointer
= &jtag_command_queue
;
1066 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1068 jtag_device_t
*device
= priv
;
1072 if (event
== JTAG_TRST_ASSERTED
)
1074 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1081 void jtag_sleep(u32 us
)
1086 int jtag_validate_chain()
1088 jtag_device_t
*device
= jtag_devices
;
1089 int total_ir_length
= 0;
1096 total_ir_length
+= device
->ir_length
;
1097 device
= device
->next
;
1100 total_ir_length
+= 2;
1101 ir_test
= malloc(CEIL(total_ir_length
, 8));
1102 buf_set_ones(ir_test
, total_ir_length
);
1105 field
.num_bits
= total_ir_length
;
1106 field
.out_value
= ir_test
;
1107 field
.out_mask
= NULL
;
1108 field
.in_value
= ir_test
;
1109 field
.in_check_value
= NULL
;
1110 field
.in_check_mask
= NULL
;
1111 field
.in_handler
= NULL
;
1112 field
.in_handler_priv
= NULL
;
1114 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1115 jtag_execute_queue();
1117 device
= jtag_devices
;
1120 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1122 ERROR("Error validating JTAG scan chain, IR mismatch");
1125 chain_pos
+= device
->ir_length
;
1126 device
= device
->next
;
1129 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1131 ERROR("Error validating JTAG scan chain, IR mismatch");
1140 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1142 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1143 COMMAND_CONFIG
, NULL
);
1144 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1145 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1146 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1147 COMMAND_CONFIG
, NULL
);
1148 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1149 COMMAND_CONFIG
, NULL
);
1150 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1151 COMMAND_CONFIG
, NULL
);
1152 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1153 COMMAND_CONFIG
, NULL
);
1155 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1156 COMMAND_EXEC
, "print current scan chain configuration");
1158 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1159 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1160 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1161 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1162 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1163 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1164 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1165 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1166 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1167 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1168 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1169 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1171 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1172 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1176 int jtag_init(struct command_context_s
*cmd_ctx
)
1182 if (jtag_speed
== -1)
1185 if (jtag_interface
&& (jtag_interface
[0] != 0))
1186 /* configuration var 'jtag_interface' is set, and not empty */
1187 for (i
= 0; jtag_interfaces
[i
]; i
++)
1189 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1191 jtag_device_t
*device
;
1192 device
= jtag_devices
;
1194 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1195 return ERROR_JTAG_INIT_FAILED
;
1196 jtag
= jtag_interfaces
[i
];
1198 jtag_ir_scan_size
= 0;
1199 jtag_num_devices
= 0;
1200 while (device
!= NULL
)
1202 jtag_ir_scan_size
+= device
->ir_length
;
1204 device
= device
->next
;
1207 jtag_add_statemove(TAP_TLR
);
1208 jtag_execute_queue();
1210 jtag_validate_chain();
1216 /* no valid interface was found (i.e. the configuration option,
1217 * didn't match one of the compiled-in interfaces
1219 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1221 return ERROR_JTAG_INVALID_INTERFACE
;
1224 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1228 /* only if the configuration var isn't overwritten from cmdline */
1229 if (!jtag_interface
)
1231 if (args
[0] && (args
[0][0] != 0))
1233 for (i
=0; jtag_interfaces
[i
]; i
++)
1235 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1237 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1240 jtag_interface
= jtag_interfaces
[i
]->name
;
1247 /* remember the requested interface name, so we can complain about it later */
1248 jtag_interface
= strdup(args
[0]);
1249 DEBUG("'interface' command didn't specify a valid interface");
1255 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1257 jtag_device_t
**last_device_p
= &jtag_devices
;
1261 while ((*last_device_p
)->next
)
1262 last_device_p
= &((*last_device_p
)->next
);
1263 last_device_p
= &((*last_device_p
)->next
);
1269 *last_device_p
= malloc(sizeof(jtag_device_t
));
1270 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1272 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1273 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1274 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1275 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1277 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1278 (*last_device_p
)->bypass
= 1;
1279 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1281 (*last_device_p
)->next
= NULL
;
1283 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1290 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1292 jtag_device_t
*device
= jtag_devices
;
1293 int device_count
= 0;
1297 u32 expected
, expected_mask
, cur_instr
;
1298 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1299 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1300 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1301 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
);
1302 device
= device
->next
;
1309 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1313 if (strcmp(args
[0], "none") == 0)
1314 jtag_reset_config
= RESET_NONE
;
1315 else if (strcmp(args
[0], "trst_only") == 0)
1316 jtag_reset_config
= RESET_HAS_TRST
;
1317 else if (strcmp(args
[0], "srst_only") == 0)
1318 jtag_reset_config
= RESET_HAS_SRST
;
1319 else if (strcmp(args
[0], "trst_and_srst") == 0)
1320 jtag_reset_config
= RESET_TRST_AND_SRST
;
1323 ERROR("invalid reset_config argument");
1330 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1331 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1332 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1333 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1334 else if (strcmp(args
[1], "combined") == 0)
1335 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1336 else if (strcmp(args
[1], "separate") == 0)
1337 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1340 ERROR("invalid reset_config argument");
1347 if (strcmp(args
[2], "trst_open_drain") == 0)
1348 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1349 else if (strcmp(args
[2], "trst_push_pull") == 0)
1350 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1353 ERROR("invalid reset_config argument");
1360 if (strcmp(args
[3], "srst_push_pull") == 0)
1361 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1362 else if (strcmp(args
[3], "srst_open_drain") == 0)
1363 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1366 ERROR("invalid reset_config argument");
1374 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1378 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1383 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1389 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1393 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1398 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1404 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1407 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1411 /* this command can be called during CONFIG,
1412 * in which case jtag isn't initialized */
1414 jtag
->speed(strtoul(args
[0], NULL
, 0));
1416 jtag_speed
= strtoul(args
[0], NULL
, 0);
1422 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1424 enum tap_state state
;
1428 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1432 for (state
= 0; state
< 16; state
++)
1434 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1436 jtag_add_end_state(state
);
1437 jtag_execute_queue();
1444 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1448 char *usage
= "usage: jtag_reset <trst> <srst>";
1453 command_print(cmd_ctx
, usage
);
1457 if (args
[0][0] == '1')
1459 else if (args
[0][0] == '0')
1463 command_print(cmd_ctx
, usage
);
1467 if (args
[1][0] == '1')
1469 else if (args
[1][0] == '0')
1473 command_print(cmd_ctx
, usage
);
1477 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1481 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1482 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1484 case ERROR_JTAG_RESET_CANT_SRST
:
1485 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1488 command_print(cmd_ctx
, "unknown error");
1491 jtag_execute_queue();
1496 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1500 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1504 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1505 jtag_execute_queue();
1511 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1513 enum tap_state state
;
1518 for (state
= 0; state
< 16; state
++)
1520 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1527 jtag_add_statemove(state
);
1528 jtag_execute_queue();
1534 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1537 scan_field_t
*fields
;
1539 if ((argc
< 2) || (argc
% 2))
1541 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1545 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1547 for (i
= 0; i
< argc
/ 2; i
++)
1549 int device
= strtoul(args
[i
*2], NULL
, 0);
1550 int field_size
= jtag_get_device(device
)->ir_length
;
1551 fields
[i
].device
= device
;
1552 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1553 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1554 fields
[i
].out_mask
= NULL
;
1555 fields
[i
].in_value
= NULL
;
1556 fields
[i
].in_check_mask
= NULL
;
1557 fields
[i
].in_handler
= NULL
;
1558 fields
[i
].in_handler_priv
= NULL
;
1561 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1562 jtag_execute_queue();
1564 for (i
= 0; i
< argc
/ 2; i
++)
1565 free(fields
[i
].out_value
);
1572 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1574 scan_field_t
*fields
;
1576 int field_count
= 0;
1580 if ((argc
< 2) || (argc
% 2))
1582 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1586 for (i
= 0; i
< argc
; i
+=2)
1588 var
= get_var_by_namenum(args
[i
+1]);
1591 num_fields
+= var
->num_fields
;
1595 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1600 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1602 for (i
= 0; i
< argc
; i
+=2)
1604 var
= get_var_by_namenum(args
[i
+1]);
1606 for (j
= 0; j
< var
->num_fields
; j
++)
1608 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1609 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1610 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1611 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1612 fields
[field_count
].out_mask
= NULL
;
1613 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1614 fields
[field_count
].in_check_mask
= NULL
;
1615 fields
[field_count
].in_check_value
= NULL
;
1616 fields
[field_count
].in_handler
= field_le_to_host
;
1617 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1621 jtag_add_dr_scan(num_fields
, fields
, -1);
1622 jtag_execute_queue();
1624 for (i
= 0; i
< argc
/ 2; i
++)
1625 free(fields
[i
].out_value
);
1632 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1636 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1640 if (strcmp(args
[0], "enable") == 0)
1642 jtag_verify_capture_ir
= 1;
1644 else if (strcmp(args
[0], "disable") == 0)
1646 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)