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_FT2232_FTD2XX == 1
128 extern jtag_interface_t ft2232_interface
;
131 #if BUILD_FT2232_LIBFTDI == 1
132 extern jtag_interface_t ft2232_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_FT2232_FTD2XX == 1
150 #if BUILD_FT2232_LIBFTDI == 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_pathmove
)
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
* 1000);
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
* 1000);
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 char *cbuf
= buf_to_char(ir_test
, total_ir_length
);
1123 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned %s", cbuf
);
1127 chain_pos
+= device
->ir_length
;
1128 device
= device
->next
;
1131 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1133 char *cbuf
= buf_to_char(ir_test
, total_ir_length
);
1134 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned %s", cbuf
);
1144 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1146 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1147 COMMAND_CONFIG
, NULL
);
1148 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1149 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1150 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1151 COMMAND_CONFIG
, NULL
);
1152 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1153 COMMAND_CONFIG
, NULL
);
1154 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1155 COMMAND_CONFIG
, NULL
);
1156 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1157 COMMAND_CONFIG
, NULL
);
1159 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1160 COMMAND_EXEC
, "print current scan chain configuration");
1162 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1163 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1164 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1165 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1166 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1167 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1168 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1169 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1170 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1171 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1172 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1173 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1175 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1176 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1180 int jtag_init(struct command_context_s
*cmd_ctx
)
1186 if (jtag_speed
== -1)
1189 if (jtag_interface
&& (jtag_interface
[0] != 0))
1190 /* configuration var 'jtag_interface' is set, and not empty */
1191 for (i
= 0; jtag_interfaces
[i
]; i
++)
1193 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1195 jtag_device_t
*device
;
1196 device
= jtag_devices
;
1198 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1199 return ERROR_JTAG_INIT_FAILED
;
1200 jtag
= jtag_interfaces
[i
];
1202 jtag_ir_scan_size
= 0;
1203 jtag_num_devices
= 0;
1204 while (device
!= NULL
)
1206 jtag_ir_scan_size
+= device
->ir_length
;
1208 device
= device
->next
;
1211 jtag_add_statemove(TAP_TLR
);
1212 jtag_execute_queue();
1214 jtag_validate_chain();
1220 /* no valid interface was found (i.e. the configuration option,
1221 * didn't match one of the compiled-in interfaces
1223 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1224 ERROR("compiled-in jtag interfaces:");
1225 for (i
= 0; jtag_interfaces
[i
]; i
++)
1227 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1231 return ERROR_JTAG_INVALID_INTERFACE
;
1234 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1238 /* only if the configuration var isn't overwritten from cmdline */
1239 if (!jtag_interface
)
1241 if (args
[0] && (args
[0][0] != 0))
1243 for (i
=0; jtag_interfaces
[i
]; i
++)
1245 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1247 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1250 jtag_interface
= jtag_interfaces
[i
]->name
;
1257 /* remember the requested interface name, so we can complain about it later */
1258 jtag_interface
= strdup(args
[0]);
1259 DEBUG("'interface' command didn't specify a valid interface");
1265 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1267 jtag_device_t
**last_device_p
= &jtag_devices
;
1271 while ((*last_device_p
)->next
)
1272 last_device_p
= &((*last_device_p
)->next
);
1273 last_device_p
= &((*last_device_p
)->next
);
1279 *last_device_p
= malloc(sizeof(jtag_device_t
));
1280 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1282 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1283 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1284 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1285 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1287 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1288 (*last_device_p
)->bypass
= 1;
1289 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1291 (*last_device_p
)->next
= NULL
;
1293 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1300 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1302 jtag_device_t
*device
= jtag_devices
;
1303 int device_count
= 0;
1307 u32 expected
, expected_mask
, cur_instr
;
1308 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1309 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1310 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1311 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
);
1312 device
= device
->next
;
1319 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1323 if (strcmp(args
[0], "none") == 0)
1324 jtag_reset_config
= RESET_NONE
;
1325 else if (strcmp(args
[0], "trst_only") == 0)
1326 jtag_reset_config
= RESET_HAS_TRST
;
1327 else if (strcmp(args
[0], "srst_only") == 0)
1328 jtag_reset_config
= RESET_HAS_SRST
;
1329 else if (strcmp(args
[0], "trst_and_srst") == 0)
1330 jtag_reset_config
= RESET_TRST_AND_SRST
;
1333 ERROR("invalid reset_config argument");
1340 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1341 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1342 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1343 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1344 else if (strcmp(args
[1], "combined") == 0)
1345 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1346 else if (strcmp(args
[1], "separate") == 0)
1347 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1350 ERROR("invalid reset_config argument");
1357 if (strcmp(args
[2], "trst_open_drain") == 0)
1358 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1359 else if (strcmp(args
[2], "trst_push_pull") == 0)
1360 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1363 ERROR("invalid reset_config argument");
1370 if (strcmp(args
[3], "srst_push_pull") == 0)
1371 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1372 else if (strcmp(args
[3], "srst_open_drain") == 0)
1373 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1376 ERROR("invalid reset_config argument");
1384 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1388 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1393 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1399 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1403 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1408 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1414 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1417 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1421 /* this command can be called during CONFIG,
1422 * in which case jtag isn't initialized */
1424 jtag
->speed(strtoul(args
[0], NULL
, 0));
1426 jtag_speed
= strtoul(args
[0], NULL
, 0);
1432 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1434 enum tap_state state
;
1438 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1442 for (state
= 0; state
< 16; state
++)
1444 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1446 jtag_add_end_state(state
);
1447 jtag_execute_queue();
1454 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1458 char *usage
= "usage: jtag_reset <trst> <srst>";
1463 command_print(cmd_ctx
, usage
);
1467 if (args
[0][0] == '1')
1469 else if (args
[0][0] == '0')
1473 command_print(cmd_ctx
, usage
);
1477 if (args
[1][0] == '1')
1479 else if (args
[1][0] == '0')
1483 command_print(cmd_ctx
, usage
);
1487 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1491 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1492 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1494 case ERROR_JTAG_RESET_CANT_SRST
:
1495 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1498 command_print(cmd_ctx
, "unknown error");
1501 jtag_execute_queue();
1506 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1510 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1514 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1515 jtag_execute_queue();
1521 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1523 enum tap_state state
;
1528 for (state
= 0; state
< 16; state
++)
1530 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1537 jtag_add_statemove(state
);
1538 jtag_execute_queue();
1544 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1547 scan_field_t
*fields
;
1549 if ((argc
< 2) || (argc
% 2))
1551 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1555 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1557 for (i
= 0; i
< argc
/ 2; i
++)
1559 int device
= strtoul(args
[i
*2], NULL
, 0);
1560 int field_size
= jtag_get_device(device
)->ir_length
;
1561 fields
[i
].device
= device
;
1562 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1563 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1564 fields
[i
].out_mask
= NULL
;
1565 fields
[i
].in_value
= NULL
;
1566 fields
[i
].in_check_mask
= NULL
;
1567 fields
[i
].in_handler
= NULL
;
1568 fields
[i
].in_handler_priv
= NULL
;
1571 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1572 jtag_execute_queue();
1574 for (i
= 0; i
< argc
/ 2; i
++)
1575 free(fields
[i
].out_value
);
1582 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1584 scan_field_t
*fields
;
1586 int field_count
= 0;
1590 if ((argc
< 2) || (argc
% 2))
1592 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1596 for (i
= 0; i
< argc
; i
+=2)
1598 var
= get_var_by_namenum(args
[i
+1]);
1601 num_fields
+= var
->num_fields
;
1605 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1610 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1612 for (i
= 0; i
< argc
; i
+=2)
1614 var
= get_var_by_namenum(args
[i
+1]);
1616 for (j
= 0; j
< var
->num_fields
; j
++)
1618 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1619 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1620 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1621 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1622 fields
[field_count
].out_mask
= NULL
;
1623 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1624 fields
[field_count
].in_check_mask
= NULL
;
1625 fields
[field_count
].in_check_value
= NULL
;
1626 fields
[field_count
].in_handler
= field_le_to_host
;
1627 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1631 jtag_add_dr_scan(num_fields
, fields
, -1);
1632 jtag_execute_queue();
1634 for (i
= 0; i
< argc
/ 2; i
++)
1635 free(fields
[i
].out_value
);
1642 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1646 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1650 if (strcmp(args
[0], "enable") == 0)
1652 jtag_verify_capture_ir
= 1;
1654 else if (strcmp(args
[0], "disable") == 0)
1656 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)