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 #if BUILD_AT91RM9200 == 1
144 extern jtag_interface_t at91rm9200_interface
;
147 jtag_interface_t
*jtag_interfaces
[] = {
148 #if BUILD_PARPORT == 1
151 #if BUILD_FT2232_FTD2XX == 1
154 #if BUILD_FT2232_LIBFTDI == 1
157 #if BUILD_AMTJTAGACCEL == 1
158 &amt_jtagaccel_interface
,
160 #if BUILD_EP93XX == 1
163 #if BUILD_AT91RM9200 == 1
164 &at91rm9200_interface
,
169 jtag_interface_t
*jtag
= NULL
;
172 char* jtag_interface
= NULL
;
175 /* forward declarations */
178 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
179 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
180 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
181 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
182 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
183 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
185 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
187 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
188 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
189 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
190 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
191 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
192 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
194 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
196 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
198 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
200 if (callback
== NULL
)
202 return ERROR_INVALID_ARGUMENTS
;
207 while ((*callbacks_p
)->next
)
208 callbacks_p
= &((*callbacks_p
)->next
);
209 callbacks_p
= &((*callbacks_p
)->next
);
212 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
213 (*callbacks_p
)->callback
= callback
;
214 (*callbacks_p
)->priv
= priv
;
215 (*callbacks_p
)->next
= NULL
;
220 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
222 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
224 if (callback
== NULL
)
226 return ERROR_INVALID_ARGUMENTS
;
231 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
232 if ((*callbacks_p
)->callback
== callback
)
235 *callbacks_p
= *next
;
243 int jtag_call_event_callbacks(enum jtag_event event
)
245 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
247 DEBUG("jtag event: %i", event
);
251 callback
->callback(event
, callback
->priv
);
252 callback
= callback
->next
;
258 /* returns a pointer to the pointer of the last command in queue
259 * this may be a pointer to the root pointer (jtag_command_queue)
260 * or to the next member of the last but one command
262 jtag_command_t
** jtag_get_last_command_p(void)
264 /* jtag_command_t *cmd = jtag_command_queue;
270 return &jtag_command_queue;
274 return last_comand_pointer
;
277 /* returns a pointer to the n-th device in the scan chain */
278 jtag_device_t
* jtag_get_device(int num
)
280 jtag_device_t
*device
= jtag_devices
;
287 device
= device
->next
;
294 void* cmd_queue_alloc(size_t size
)
296 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
301 while ((*p_page
)->next
)
302 p_page
= &((*p_page
)->next
);
303 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
304 p_page
= &((*p_page
)->next
);
309 *p_page
= malloc(sizeof(cmd_queue_page_t
));
311 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
312 (*p_page
)->next
= NULL
;
315 offset
= (*p_page
)->used
;
316 (*p_page
)->used
+= size
;
318 return ((*p_page
)->address
) + offset
;
321 void cmd_queue_free()
323 cmd_queue_page_t
*page
= cmd_queue_pages
;
327 cmd_queue_page_t
*last
= page
;
333 cmd_queue_pages
= NULL
;
336 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
338 jtag_command_t
**last_cmd
;
339 jtag_device_t
*device
;
342 /* int changed = 0; */
346 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
347 return ERROR_JTAG_TRST_ASSERTED
;
351 for (i=0; i<num_fields; i++)
353 device = jtag_get_device(fields[i].device);
356 if (buf_cmp(device->cur_instr, fields[i].out_value, device->ir_length))
361 ERROR("inexistant device specified for ir scan");
362 return ERROR_INVALID_ARGUMENTS;
370 last_cmd
= jtag_get_last_command_p();
372 /* allocate memory for a new list member */
373 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
374 (*last_cmd
)->next
= NULL
;
375 last_comand_pointer
= &((*last_cmd
)->next
);
376 (*last_cmd
)->type
= JTAG_SCAN
;
378 /* allocate memory for ir scan command */
379 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
380 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
381 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
382 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
383 (*last_cmd
)->cmd
.scan
->end_state
= state
;
386 cmd_queue_end_state
= state
;
388 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
389 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
391 if (cmd_queue_end_state
== TAP_TLR
)
392 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
394 cmd_queue_cur_state
= cmd_queue_end_state
;
396 for (i
=0; i
< jtag_num_devices
; i
++)
399 device
= jtag_get_device(i
);
400 scan_size
= device
->ir_length
;
401 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
402 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
403 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
404 if (jtag_verify_capture_ir
)
406 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(device
->expected
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
407 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(device
->expected_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
411 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= NULL
;
412 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= NULL
;
414 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
415 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
417 /* search the list */
418 for (j
=0; j
< num_fields
; j
++)
420 if (i
== fields
[j
].device
)
423 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
424 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
433 /* if a device isn't listed, set it to BYPASS */
434 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
435 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
440 /* update device information */
441 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
447 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
449 jtag_command_t
**last_cmd
;
454 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
455 return ERROR_JTAG_TRST_ASSERTED
;
458 last_cmd
= jtag_get_last_command_p();
460 /* allocate memory for a new list member */
461 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
462 (*last_cmd
)->next
= NULL
;
463 last_comand_pointer
= &((*last_cmd
)->next
);
464 (*last_cmd
)->type
= JTAG_SCAN
;
466 /* allocate memory for ir scan command */
467 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
468 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
469 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
470 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
471 (*last_cmd
)->cmd
.scan
->end_state
= state
;
474 cmd_queue_end_state
= state
;
476 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
477 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
479 if (cmd_queue_end_state
== TAP_TLR
)
480 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
482 cmd_queue_cur_state
= cmd_queue_end_state
;
484 for (i
= 0; i
< num_fields
; i
++)
486 int num_bits
= fields
[i
].num_bits
;
487 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
488 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
489 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
490 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
491 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
492 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
493 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
494 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
495 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
496 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
501 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
504 int bypass_devices
= 0;
506 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
507 jtag_device_t
*device
= jtag_devices
;
512 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
513 return ERROR_JTAG_TRST_ASSERTED
;
516 /* count devices in bypass */
521 device
= device
->next
;
524 /* allocate memory for a new list member */
525 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
526 last_comand_pointer
= &((*last_cmd
)->next
);
527 (*last_cmd
)->next
= NULL
;
528 (*last_cmd
)->type
= JTAG_SCAN
;
530 /* allocate memory for dr scan command */
531 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
532 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
533 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
534 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
535 (*last_cmd
)->cmd
.scan
->end_state
= state
;
538 cmd_queue_end_state
= state
;
540 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
541 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
543 if (cmd_queue_end_state
== TAP_TLR
)
544 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
546 cmd_queue_cur_state
= cmd_queue_end_state
;
548 for (i
=0; i
< jtag_num_devices
; i
++)
551 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
553 for (j
=0; j
< num_fields
; j
++)
555 if (i
== fields
[j
].device
)
558 scan_size
= fields
[j
].num_bits
;
559 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
560 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
561 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
562 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
563 (*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
);
564 (*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
);
565 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
566 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
571 /* if a device isn't listed, the BYPASS register should be selected */
572 if (!jtag_get_device(i
)->bypass
)
574 ERROR("BUG: no scan data for a device not in BYPASS");
578 /* program the scan field to 1 bit length, and ignore it's value */
579 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
580 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
581 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
582 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
583 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
584 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
585 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
586 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
590 /* if a device is listed, the BYPASS register must not be selected */
591 if (jtag_get_device(i
)->bypass
)
593 ERROR("BUG: scan data for a device in BYPASS");
601 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
604 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
608 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
609 return ERROR_JTAG_TRST_ASSERTED
;
612 /* allocate memory for a new list member */
613 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
614 last_comand_pointer
= &((*last_cmd
)->next
);
615 (*last_cmd
)->next
= NULL
;
616 (*last_cmd
)->type
= JTAG_SCAN
;
618 /* allocate memory for scan command */
619 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
620 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
621 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
622 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
623 (*last_cmd
)->cmd
.scan
->end_state
= state
;
626 cmd_queue_end_state
= state
;
628 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
629 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
631 if (cmd_queue_end_state
== TAP_TLR
)
632 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
634 cmd_queue_cur_state
= cmd_queue_end_state
;
636 for (i
= 0; i
< num_fields
; i
++)
638 int num_bits
= fields
[i
].num_bits
;
639 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
640 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
641 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
642 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
643 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
644 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
645 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= buf_cpy(fields
[i
].in_check_value
, cmd_queue_alloc(num_bytes
), num_bits
);
646 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= buf_cpy(fields
[i
].in_check_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
647 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
648 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
653 int jtag_add_statemove(enum tap_state state
)
655 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
659 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
660 return ERROR_JTAG_TRST_ASSERTED
;
663 /* allocate memory for a new list member */
664 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
665 last_comand_pointer
= &((*last_cmd
)->next
);
666 (*last_cmd
)->next
= NULL
;
667 (*last_cmd
)->type
= JTAG_STATEMOVE
;
669 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
670 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
673 cmd_queue_end_state
= state
;
675 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
676 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
678 if (cmd_queue_end_state
== TAP_TLR
)
679 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
681 cmd_queue_cur_state
= cmd_queue_end_state
;
686 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
688 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
693 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
694 return ERROR_JTAG_TRST_ASSERTED
;
697 /* the last state has to be a stable state */
698 if (tap_move_map
[path
[num_states
- 1]] == -1)
700 ERROR("TAP path doesn't finish in a stable state");
701 return ERROR_JTAG_NOT_IMPLEMENTED
;
704 if (jtag
->support_pathmove
)
706 /* allocate memory for a new list member */
707 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
708 last_comand_pointer
= &((*last_cmd
)->next
);
709 (*last_cmd
)->next
= NULL
;
710 (*last_cmd
)->type
= JTAG_RUNTEST
;
712 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
713 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
714 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
716 for (i
= 0; i
< num_states
; i
++)
717 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
721 /* validate the desired path, and see if it fits a default path */
726 for (i
= 0; i
< num_states
; i
++)
728 for (j
= i
; j
< num_states
; j
++)
730 if (tap_move_map
[path
[j
]] != -1)
737 if (begin
- end
<= 7) /* a default path spans no more than 7 states */
739 jtag_add_statemove(path
[end
]);
743 ERROR("encountered a TAP path that can't be fulfilled by default paths");
744 return ERROR_JTAG_NOT_IMPLEMENTED
;
751 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
752 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
754 if (cmd_queue_end_state
== TAP_TLR
)
755 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
757 cmd_queue_cur_state
= path
[num_states
- 1];
762 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
764 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
768 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
769 return ERROR_JTAG_TRST_ASSERTED
;
772 /* allocate memory for a new list member */
773 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
774 (*last_cmd
)->next
= NULL
;
775 last_comand_pointer
= &((*last_cmd
)->next
);
776 (*last_cmd
)->type
= JTAG_RUNTEST
;
778 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
779 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
780 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
783 cmd_queue_end_state
= state
;
785 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
786 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
788 if (cmd_queue_end_state
== TAP_TLR
)
789 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
791 cmd_queue_cur_state
= cmd_queue_end_state
;
796 int jtag_add_reset(int req_trst
, int req_srst
)
798 int trst_with_tms
= 0;
800 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
803 req_trst
= jtag_trst
;
806 req_srst
= jtag_srst
;
808 /* Make sure that jtag_reset_config allows the requested reset */
809 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
810 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
811 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
813 /* if TRST pulls SRST, we reset with TAP T-L-R */
814 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
820 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
822 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
823 return ERROR_JTAG_RESET_CANT_SRST
;
826 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
832 /* allocate memory for a new list member */
833 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
834 (*last_cmd
)->next
= NULL
;
835 last_comand_pointer
= &((*last_cmd
)->next
);
836 (*last_cmd
)->type
= JTAG_RESET
;
838 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
839 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
840 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
842 jtag_trst
= req_trst
;
843 jtag_srst
= req_srst
;
847 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
851 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
852 if (jtag_nsrst_delay
)
853 jtag_add_sleep(jtag_nsrst_delay
* 1000);
858 last_cmd
= &((*last_cmd
)->next
);
860 /* allocate memory for a new list member */
861 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
862 (*last_cmd
)->next
= NULL
;
863 last_comand_pointer
= &((*last_cmd
)->next
);
864 (*last_cmd
)->type
= JTAG_STATEMOVE
;
866 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
867 (*last_cmd
)->cmd
.statemove
->end_state
= TAP_TLR
;
869 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
870 cmd_queue_cur_state
= TAP_TLR
;
871 cmd_queue_end_state
= TAP_TLR
;
879 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
880 * and inform possible listeners about this
882 cmd_queue_cur_state
= TAP_TLR
;
883 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
887 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
888 * but we might want to add a delay to give the TAP time to settle
890 if (jtag_ntrst_delay
)
891 jtag_add_sleep(jtag_ntrst_delay
* 1000);
898 int jtag_add_end_state(enum tap_state state
)
900 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
902 /* allocate memory for a new list member */
903 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
904 (*last_cmd
)->next
= NULL
;
905 last_comand_pointer
= &((*last_cmd
)->next
);
906 (*last_cmd
)->type
= JTAG_END_STATE
;
908 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
909 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
912 cmd_queue_end_state
= state
;
917 int jtag_add_sleep(u32 us
)
919 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
921 /* allocate memory for a new list member */
922 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
923 (*last_cmd
)->next
= NULL
;
924 last_comand_pointer
= &((*last_cmd
)->next
);
925 (*last_cmd
)->type
= JTAG_SLEEP
;
927 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
928 (*last_cmd
)->cmd
.sleep
->us
= us
;
933 int jtag_scan_size(scan_command_t
*cmd
)
938 /* count bits in scan command */
939 for (i
=0; i
<cmd
->num_fields
; i
++)
941 bit_count
+= cmd
->fields
[i
].num_bits
;
947 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
952 bit_count
= jtag_scan_size(cmd
);
953 *buffer
= malloc(CEIL(bit_count
, 8));
957 for (i
= 0; i
< cmd
->num_fields
; i
++)
959 if (cmd
->fields
[i
].out_value
)
961 #ifdef _DEBUG_JTAG_IO_
962 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, cmd
->fields
[i
].num_bits
, 16);
964 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
965 #ifdef _DEBUG_JTAG_IO_
966 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
971 bit_count
+= cmd
->fields
[i
].num_bits
;
978 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
982 int retval
= ERROR_OK
;
984 for (i
=0; i
< cmd
->num_fields
; i
++)
986 /* if neither in_value, in_check_value nor in_handler
987 * are specified we don't have to examine this field
989 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_handler
)
991 int num_bits
= cmd
->fields
[i
].num_bits
;
992 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
993 #ifdef _DEBUG_JTAG_IO_
996 char_buf
= buf_to_str(captured
, num_bits
, 16);
997 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1002 if (cmd
->fields
[i
].in_value
)
1004 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1006 if (cmd
->fields
[i
].in_handler
)
1008 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1010 /* TODO: error reporting */
1011 WARNING("in_handler reported a failed check");
1012 retval
= ERROR_JTAG_QUEUE_FAILED
;
1017 /* no in_value specified, but a handler takes care of the scanned data */
1018 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1020 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
) != ERROR_OK
)
1022 /* TODO: error reporting */
1023 WARNING("in_handler reported a failed check");
1024 retval
= ERROR_JTAG_QUEUE_FAILED
;
1029 if (cmd
->fields
[i
].in_check_value
)
1031 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
))
1032 || (!cmd
->fields
[i
].in_check_mask
&& buf_cmp(captured
, cmd
->fields
[i
].in_check_mask
, num_bits
)))
1034 char *captured_char
= buf_to_str(captured
, num_bits
, 16);
1035 char *in_check_value_char
= buf_to_str(cmd
->fields
[i
].in_check_value
, num_bits
, 16);
1036 char *in_check_mask_char
= buf_to_str(cmd
->fields
[i
].in_check_mask
, num_bits
, 16);
1037 /* TODO: error reporting */
1038 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
);
1039 retval
= ERROR_JTAG_QUEUE_FAILED
;
1040 free(captured_char
);
1041 free(in_check_value_char
);
1042 free(in_check_mask_char
);
1047 bit_count
+= cmd
->fields
[i
].num_bits
;
1053 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1058 for (i
=0; i
< cmd
->num_fields
; i
++)
1060 if (cmd
->fields
[i
].in_check_value
|| cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1062 if (cmd
->fields
[i
].out_value
)
1069 int jtag_execute_queue(void)
1073 retval
= jtag
->execute_queue();
1077 jtag_command_queue
= NULL
;
1078 last_comand_pointer
= &jtag_command_queue
;
1083 int jtag_cancel_queue(void)
1086 jtag_command_queue
= NULL
;
1087 last_comand_pointer
= &jtag_command_queue
;
1092 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1094 jtag_device_t
*device
= priv
;
1098 if (event
== JTAG_TRST_ASSERTED
)
1100 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1107 void jtag_sleep(u32 us
)
1112 int jtag_validate_chain()
1114 jtag_device_t
*device
= jtag_devices
;
1115 int total_ir_length
= 0;
1122 total_ir_length
+= device
->ir_length
;
1123 device
= device
->next
;
1126 total_ir_length
+= 2;
1127 ir_test
= malloc(CEIL(total_ir_length
, 8));
1128 buf_set_ones(ir_test
, total_ir_length
);
1131 field
.num_bits
= total_ir_length
;
1132 field
.out_value
= ir_test
;
1133 field
.out_mask
= NULL
;
1134 field
.in_value
= ir_test
;
1135 field
.in_check_value
= NULL
;
1136 field
.in_check_mask
= NULL
;
1137 field
.in_handler
= NULL
;
1138 field
.in_handler_priv
= NULL
;
1140 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1141 jtag_execute_queue();
1143 device
= jtag_devices
;
1146 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1148 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1149 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1153 chain_pos
+= device
->ir_length
;
1154 device
= device
->next
;
1157 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1159 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1160 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1170 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1172 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1173 COMMAND_CONFIG
, NULL
);
1174 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1175 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1176 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1177 COMMAND_CONFIG
, NULL
);
1178 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1179 COMMAND_CONFIG
, NULL
);
1180 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1181 COMMAND_CONFIG
, NULL
);
1182 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1183 COMMAND_CONFIG
, NULL
);
1185 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1186 COMMAND_EXEC
, "print current scan chain configuration");
1188 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1189 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1190 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1191 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1192 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1193 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1194 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1195 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1196 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1197 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1198 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1199 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1201 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1202 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1206 int jtag_init(struct command_context_s
*cmd_ctx
)
1212 if (jtag_speed
== -1)
1215 if (jtag_interface
&& (jtag_interface
[0] != 0))
1216 /* configuration var 'jtag_interface' is set, and not empty */
1217 for (i
= 0; jtag_interfaces
[i
]; i
++)
1219 if (strcmp(jtag_interface
, jtag_interfaces
[i
]->name
) == 0)
1221 jtag_device_t
*device
;
1222 device
= jtag_devices
;
1224 if (jtag_interfaces
[i
]->init() != ERROR_OK
)
1225 return ERROR_JTAG_INIT_FAILED
;
1226 jtag
= jtag_interfaces
[i
];
1228 jtag_ir_scan_size
= 0;
1229 jtag_num_devices
= 0;
1230 while (device
!= NULL
)
1232 jtag_ir_scan_size
+= device
->ir_length
;
1234 device
= device
->next
;
1237 jtag_add_statemove(TAP_TLR
);
1238 jtag_execute_queue();
1240 jtag_validate_chain();
1246 /* no valid interface was found (i.e. the configuration option,
1247 * didn't match one of the compiled-in interfaces
1249 ERROR("No valid jtag interface found (%s)", jtag_interface
);
1250 ERROR("compiled-in jtag interfaces:");
1251 for (i
= 0; jtag_interfaces
[i
]; i
++)
1253 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1257 return ERROR_JTAG_INVALID_INTERFACE
;
1260 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1264 /* only if the configuration var isn't overwritten from cmdline */
1265 if (!jtag_interface
)
1267 if (args
[0] && (args
[0][0] != 0))
1269 for (i
=0; jtag_interfaces
[i
]; i
++)
1271 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1273 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1276 jtag_interface
= jtag_interfaces
[i
]->name
;
1283 /* remember the requested interface name, so we can complain about it later */
1284 jtag_interface
= strdup(args
[0]);
1285 DEBUG("'interface' command didn't specify a valid interface");
1291 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1293 jtag_device_t
**last_device_p
= &jtag_devices
;
1297 while ((*last_device_p
)->next
)
1298 last_device_p
= &((*last_device_p
)->next
);
1299 last_device_p
= &((*last_device_p
)->next
);
1305 *last_device_p
= malloc(sizeof(jtag_device_t
));
1306 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1308 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1309 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1310 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1311 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1313 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1314 (*last_device_p
)->bypass
= 1;
1315 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1317 (*last_device_p
)->next
= NULL
;
1319 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1326 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1328 jtag_device_t
*device
= jtag_devices
;
1329 int device_count
= 0;
1333 u32 expected
, expected_mask
, cur_instr
;
1334 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1335 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1336 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1337 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
);
1338 device
= device
->next
;
1345 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1349 if (strcmp(args
[0], "none") == 0)
1350 jtag_reset_config
= RESET_NONE
;
1351 else if (strcmp(args
[0], "trst_only") == 0)
1352 jtag_reset_config
= RESET_HAS_TRST
;
1353 else if (strcmp(args
[0], "srst_only") == 0)
1354 jtag_reset_config
= RESET_HAS_SRST
;
1355 else if (strcmp(args
[0], "trst_and_srst") == 0)
1356 jtag_reset_config
= RESET_TRST_AND_SRST
;
1359 ERROR("invalid reset_config argument");
1366 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1367 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1368 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1369 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1370 else if (strcmp(args
[1], "combined") == 0)
1371 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1372 else if (strcmp(args
[1], "separate") == 0)
1373 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1376 ERROR("invalid reset_config argument");
1383 if (strcmp(args
[2], "trst_open_drain") == 0)
1384 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1385 else if (strcmp(args
[2], "trst_push_pull") == 0)
1386 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1389 ERROR("invalid reset_config argument");
1396 if (strcmp(args
[3], "srst_push_pull") == 0)
1397 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1398 else if (strcmp(args
[3], "srst_open_drain") == 0)
1399 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1402 ERROR("invalid reset_config argument");
1410 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1414 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1419 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1425 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1429 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1434 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1440 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1443 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1447 /* this command can be called during CONFIG,
1448 * in which case jtag isn't initialized */
1450 jtag
->speed(strtoul(args
[0], NULL
, 0));
1452 jtag_speed
= strtoul(args
[0], NULL
, 0);
1458 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1460 enum tap_state state
;
1464 command_print(cmd_ctx
, "usage: endstate <tap_state>");
1468 for (state
= 0; state
< 16; state
++)
1470 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1472 jtag_add_end_state(state
);
1473 jtag_execute_queue();
1480 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1484 char *usage
= "usage: jtag_reset <trst> <srst>";
1489 command_print(cmd_ctx
, usage
);
1493 if (args
[0][0] == '1')
1495 else if (args
[0][0] == '0')
1499 command_print(cmd_ctx
, usage
);
1503 if (args
[1][0] == '1')
1505 else if (args
[1][0] == '0')
1509 command_print(cmd_ctx
, usage
);
1513 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1517 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1518 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1520 case ERROR_JTAG_RESET_CANT_SRST
:
1521 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1524 command_print(cmd_ctx
, "unknown error");
1527 jtag_execute_queue();
1532 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1536 command_print(cmd_ctx
, "usage: runtest <num_cycles>");
1540 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1541 jtag_execute_queue();
1547 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1549 enum tap_state state
;
1554 for (state
= 0; state
< 16; state
++)
1556 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1563 jtag_add_statemove(state
);
1564 jtag_execute_queue();
1570 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1573 scan_field_t
*fields
;
1575 if ((argc
< 2) || (argc
% 2))
1577 command_print(cmd_ctx
, "usage: irscan <device> <instr> [dev2] [instr2] ...");
1581 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1583 for (i
= 0; i
< argc
/ 2; i
++)
1585 int device
= strtoul(args
[i
*2], NULL
, 0);
1586 int field_size
= jtag_get_device(device
)->ir_length
;
1587 fields
[i
].device
= device
;
1588 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1589 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1590 fields
[i
].out_mask
= NULL
;
1591 fields
[i
].in_value
= NULL
;
1592 fields
[i
].in_check_mask
= NULL
;
1593 fields
[i
].in_handler
= NULL
;
1594 fields
[i
].in_handler_priv
= NULL
;
1597 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1598 jtag_execute_queue();
1600 for (i
= 0; i
< argc
/ 2; i
++)
1601 free(fields
[i
].out_value
);
1608 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1610 scan_field_t
*fields
;
1612 int field_count
= 0;
1616 if ((argc
< 2) || (argc
% 2))
1618 command_print(cmd_ctx
, "usage: drscan <device> <var> [dev2] [var2]");
1622 for (i
= 0; i
< argc
; i
+=2)
1624 var
= get_var_by_namenum(args
[i
+1]);
1627 num_fields
+= var
->num_fields
;
1631 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1636 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1638 for (i
= 0; i
< argc
; i
+=2)
1640 var
= get_var_by_namenum(args
[i
+1]);
1642 for (j
= 0; j
< var
->num_fields
; j
++)
1644 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1645 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1646 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1647 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1648 fields
[field_count
].out_mask
= NULL
;
1649 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1650 fields
[field_count
].in_check_mask
= NULL
;
1651 fields
[field_count
].in_check_value
= NULL
;
1652 fields
[field_count
].in_handler
= field_le_to_host
;
1653 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1657 jtag_add_dr_scan(num_fields
, fields
, -1);
1658 jtag_execute_queue();
1660 for (i
= 0; i
< argc
/ 2; i
++)
1661 free(fields
[i
].out_value
);
1668 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1672 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
1676 if (strcmp(args
[0], "enable") == 0)
1678 jtag_verify_capture_ir
= 1;
1680 else if (strcmp(args
[0], "disable") == 0)
1682 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)