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"
37 /* note that this is not marked as static as it must be available from outside jtag.c for those
38 that implement the jtag_xxx() minidriver layer
40 int jtag_error
=ERROR_OK
;
43 char* tap_state_strings
[16] =
46 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
48 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
51 typedef struct cmd_queue_page_s
55 struct cmd_queue_page_s
*next
;
58 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
59 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
61 /* tap_move[i][j]: tap movement command to go from state i to state j
69 * SD->SD and SI->SI have to be caught in interface specific code
73 /* TLR RTI SD PD SI PI */
74 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
75 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
76 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
77 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
78 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
79 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
82 int tap_move_map
[16] = {
83 0, -1, -1, 2, -1, 3, -1, -1,
84 1, -1, -1, 4, -1, 5, -1, -1
87 tap_transition_t tap_transitions
[16] =
89 {TAP_TLR
, TAP_RTI
}, /* TLR */
90 {TAP_SIS
, TAP_CD
}, /* SDS */
91 {TAP_E1D
, TAP_SD
}, /* CD */
92 {TAP_E1D
, TAP_SD
}, /* SD */
93 {TAP_UD
, TAP_PD
}, /* E1D */
94 {TAP_E2D
, TAP_PD
}, /* PD */
95 {TAP_UD
, TAP_SD
}, /* E2D */
96 {TAP_SDS
, TAP_RTI
}, /* UD */
97 {TAP_SDS
, TAP_RTI
}, /* RTI */
98 {TAP_TLR
, TAP_CI
}, /* SIS */
99 {TAP_E1I
, TAP_SI
}, /* CI */
100 {TAP_E1I
, TAP_SI
}, /* SI */
101 {TAP_UI
, TAP_PI
}, /* E1I */
102 {TAP_E2I
, TAP_PI
}, /* PI */
103 {TAP_UI
, TAP_SI
}, /* E2I */
104 {TAP_SDS
, TAP_RTI
} /* UI */
107 char* jtag_event_strings
[] =
115 enum tap_state end_state
= TAP_TLR
;
116 enum tap_state cur_state
= TAP_TLR
;
120 jtag_command_t
*jtag_command_queue
= NULL
;
121 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
122 jtag_device_t
*jtag_devices
= NULL
;
123 int jtag_num_devices
= 0;
124 int jtag_ir_scan_size
= 0;
125 enum reset_types jtag_reset_config
= RESET_NONE
;
126 enum tap_state cmd_queue_end_state
= TAP_TLR
;
127 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
129 int jtag_verify_capture_ir
= 1;
131 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
132 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
133 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
135 /* maximum number of JTAG devices expected in the chain
137 #define JTAG_MAX_CHAIN_SIZE 20
139 /* callbacks to inform high-level handlers about JTAG state changes */
140 jtag_event_callback_t
*jtag_event_callbacks
;
142 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
145 #if BUILD_ECOSBOARD == 1
146 extern jtag_interface_t eCosBoard_interface
;
149 #if BUILD_PARPORT == 1
150 extern jtag_interface_t parport_interface
;
153 #if BUILD_FT2232_FTD2XX == 1
154 extern jtag_interface_t ft2232_interface
;
157 #if BUILD_FT2232_LIBFTDI == 1
158 extern jtag_interface_t ft2232_interface
;
161 #if BUILD_AMTJTAGACCEL == 1
162 extern jtag_interface_t amt_jtagaccel_interface
;
165 #if BUILD_EP93XX == 1
166 extern jtag_interface_t ep93xx_interface
;
169 #if BUILD_AT91RM9200 == 1
170 extern jtag_interface_t at91rm9200_interface
;
173 #if BUILD_GW16012 == 1
174 extern jtag_interface_t gw16012_interface
;
177 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
178 extern jtag_interface_t presto_interface
;
181 #if BUILD_USBPROG == 1
182 extern jtag_interface_t usbprog_interface
;
185 jtag_interface_t
*jtag_interfaces
[] = {
186 #if BUILD_ECOSBOARD == 1
187 &eCosBoard_interface
,
189 #if BUILD_PARPORT == 1
192 #if BUILD_FT2232_FTD2XX == 1
195 #if BUILD_FT2232_LIBFTDI == 1
198 #if BUILD_AMTJTAGACCEL == 1
199 &amt_jtagaccel_interface
,
201 #if BUILD_EP93XX == 1
204 #if BUILD_AT91RM9200 == 1
205 &at91rm9200_interface
,
207 #if BUILD_GW16012 == 1
210 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
213 #if BUILD_USBPROG == 1
219 jtag_interface_t
*jtag
= NULL
;
222 jtag_interface_t
*jtag_interface
= NULL
;
226 /* forward declarations */
227 void jtag_add_statemove(enum tap_state endstate
);
228 void jtag_add_pathmove(int num_states
, enum tap_state
*path
);
229 void jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
230 int jtag_add_reset(int trst
, int srst
);
231 void jtag_add_end_state(enum tap_state endstate
);
232 void jtag_add_sleep(u32 us
);
233 int jtag_execute_queue(void);
234 int jtag_cancel_queue(void);
237 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
238 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
239 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
240 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
241 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
242 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
244 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
246 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
247 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
248 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
249 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
250 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
251 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
253 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
255 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
257 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
259 if (callback
== NULL
)
261 return ERROR_INVALID_ARGUMENTS
;
266 while ((*callbacks_p
)->next
)
267 callbacks_p
= &((*callbacks_p
)->next
);
268 callbacks_p
= &((*callbacks_p
)->next
);
271 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
272 (*callbacks_p
)->callback
= callback
;
273 (*callbacks_p
)->priv
= priv
;
274 (*callbacks_p
)->next
= NULL
;
279 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
281 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
283 if (callback
== NULL
)
285 return ERROR_INVALID_ARGUMENTS
;
290 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
291 if ((*callbacks_p
)->callback
== callback
)
294 *callbacks_p
= *next
;
302 int jtag_call_event_callbacks(enum jtag_event event
)
304 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
306 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
310 callback
->callback(event
, callback
->priv
);
311 callback
= callback
->next
;
317 /* returns a pointer to the pointer of the last command in queue
318 * this may be a pointer to the root pointer (jtag_command_queue)
319 * or to the next member of the last but one command
321 jtag_command_t
** jtag_get_last_command_p(void)
323 /* jtag_command_t *cmd = jtag_command_queue;
329 return &jtag_command_queue;
333 return last_comand_pointer
;
336 /* returns a pointer to the n-th device in the scan chain */
337 jtag_device_t
* jtag_get_device(int num
)
339 jtag_device_t
*device
= jtag_devices
;
346 device
= device
->next
;
350 ERROR("jtag device number %d not defined", num
);
354 void* cmd_queue_alloc(size_t size
)
356 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
361 while ((*p_page
)->next
)
362 p_page
= &((*p_page
)->next
);
363 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
364 p_page
= &((*p_page
)->next
);
369 *p_page
= malloc(sizeof(cmd_queue_page_t
));
371 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
372 (*p_page
)->next
= NULL
;
375 offset
= (*p_page
)->used
;
376 (*p_page
)->used
+= size
;
378 u8
*t
=(u8
*)((*p_page
)->address
);
382 void cmd_queue_free()
384 cmd_queue_page_t
*page
= cmd_queue_pages
;
388 cmd_queue_page_t
*last
= page
;
394 cmd_queue_pages
= NULL
;
397 void jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
401 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
402 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
407 cmd_queue_end_state
= state
;
409 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
410 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
412 if (cmd_queue_end_state
== TAP_TLR
)
413 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
415 cmd_queue_cur_state
= cmd_queue_end_state
;
417 int retval
=interface_jtag_add_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
418 if (retval
!=ERROR_OK
)
422 int MINIDRIVER(interface_jtag_add_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
424 jtag_command_t
**last_cmd
;
425 jtag_device_t
*device
;
430 last_cmd
= jtag_get_last_command_p();
432 /* allocate memory for a new list member */
433 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
434 (*last_cmd
)->next
= NULL
;
435 last_comand_pointer
= &((*last_cmd
)->next
);
436 (*last_cmd
)->type
= JTAG_SCAN
;
438 /* allocate memory for ir scan command */
439 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
440 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
441 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
442 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
443 (*last_cmd
)->cmd
.scan
->end_state
= state
;
445 for (i
= 0; i
< jtag_num_devices
; i
++)
448 device
= jtag_get_device(i
);
449 scan_size
= device
->ir_length
;
450 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
451 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
452 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
453 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
; /* disable verification by default */
455 /* search the list */
456 for (j
= 0; j
< num_fields
; j
++)
458 if (i
== fields
[j
].device
)
461 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
462 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
464 if (jtag_verify_capture_ir
)
466 if (fields
[j
].in_handler
==NULL
)
468 jtag_set_check_value((*last_cmd
)->cmd
.scan
->fields
+i
, device
->expected
, device
->expected_mask
, NULL
);
471 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[j
].in_handler
;
472 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[j
].in_handler_priv
;
473 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= device
->expected
;
474 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= device
->expected_mask
;
485 /* if a device isn't listed, set it to BYPASS */
486 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
487 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
492 /* update device information */
493 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
499 void jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
503 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
504 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
509 cmd_queue_end_state
= state
;
511 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
512 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
514 if (cmd_queue_end_state
== TAP_TLR
)
515 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
517 cmd_queue_cur_state
= cmd_queue_end_state
;
519 int retval
=interface_jtag_add_plain_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
520 if (retval
!=ERROR_OK
)
524 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
527 jtag_command_t
**last_cmd
;
529 last_cmd
= jtag_get_last_command_p();
531 /* allocate memory for a new list member */
532 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
533 (*last_cmd
)->next
= NULL
;
534 last_comand_pointer
= &((*last_cmd
)->next
);
535 (*last_cmd
)->type
= JTAG_SCAN
;
537 /* allocate memory for ir scan command */
538 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
539 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
540 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
541 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
542 (*last_cmd
)->cmd
.scan
->end_state
= state
;
544 for (i
= 0; i
< num_fields
; i
++)
546 int num_bits
= fields
[i
].num_bits
;
547 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
548 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
549 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
550 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
551 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
552 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
553 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
554 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
555 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
556 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
561 void jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
565 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
566 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
571 cmd_queue_end_state
= state
;
573 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
574 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
576 if (cmd_queue_end_state
== TAP_TLR
)
577 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
579 cmd_queue_cur_state
= cmd_queue_end_state
;
581 int retval
=interface_jtag_add_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
582 if (retval
!=ERROR_OK
)
586 int MINIDRIVER(interface_jtag_add_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
589 int bypass_devices
= 0;
593 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
594 jtag_device_t
*device
= jtag_devices
;
596 /* count devices in bypass */
601 device
= device
->next
;
604 /* allocate memory for a new list member */
605 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
606 last_comand_pointer
= &((*last_cmd
)->next
);
607 (*last_cmd
)->next
= NULL
;
608 (*last_cmd
)->type
= JTAG_SCAN
;
610 /* allocate memory for dr scan command */
611 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
612 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
613 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
614 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
615 (*last_cmd
)->cmd
.scan
->end_state
= state
;
617 for (i
= 0; i
< jtag_num_devices
; i
++)
620 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
622 for (j
= 0; j
< num_fields
; j
++)
624 if (i
== fields
[j
].device
)
627 scan_size
= fields
[j
].num_bits
;
628 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
629 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
630 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
631 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
632 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= fields
[j
].in_check_value
;
633 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= fields
[j
].in_check_mask
;
634 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
635 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
640 #ifdef _DEBUG_JTAG_IO_
641 /* if a device isn't listed, the BYPASS register should be selected */
642 if (!jtag_get_device(i
)->bypass
)
644 ERROR("BUG: no scan data for a device not in BYPASS");
648 /* program the scan field to 1 bit length, and ignore it's value */
649 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
650 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
651 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
652 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
653 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
654 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
655 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
656 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
660 #ifdef _DEBUG_JTAG_IO_
661 /* if a device is listed, the BYPASS register must not be selected */
662 if (jtag_get_device(i
)->bypass
)
664 ERROR("BUG: scan data for a device in BYPASS");
673 void MINIDRIVER(interface_jtag_add_dr_out
)(int device_num
,
677 enum tap_state end_state
)
682 int bypass_devices
= 0;
684 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
685 jtag_device_t
*device
= jtag_devices
;
686 /* count devices in bypass */
691 device
= device
->next
;
694 /* allocate memory for a new list member */
695 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
696 last_comand_pointer
= &((*last_cmd
)->next
);
697 (*last_cmd
)->next
= NULL
;
698 (*last_cmd
)->type
= JTAG_SCAN
;
700 /* allocate memory for dr scan command */
701 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
702 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
703 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
704 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
705 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
707 for (i
= 0; i
< jtag_num_devices
; i
++)
709 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
714 #ifdef _DEBUG_JTAG_IO_
715 /* if a device is listed, the BYPASS register must not be selected */
716 if (jtag_get_device(i
)->bypass
)
718 ERROR("BUG: scan data for a device in BYPASS");
722 for (j
= 0; j
< num_fields
; j
++)
725 scan_size
= num_bits
[j
];
726 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
727 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
728 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
729 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
730 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
731 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
732 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
733 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
734 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
738 #ifdef _DEBUG_JTAG_IO_
739 /* if a device isn't listed, the BYPASS register should be selected */
740 if (!jtag_get_device(i
)->bypass
)
742 ERROR("BUG: no scan data for a device not in BYPASS");
746 /* program the scan field to 1 bit length, and ignore it's value */
747 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
748 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
749 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
750 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
751 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
752 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
753 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
754 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
762 void jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
766 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
767 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
772 cmd_queue_end_state
= state
;
774 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
775 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
777 if (cmd_queue_end_state
== TAP_TLR
)
778 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
780 cmd_queue_cur_state
= cmd_queue_end_state
;
782 int retval
=interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
783 if (retval
!=ERROR_OK
)
787 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
790 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
792 /* allocate memory for a new list member */
793 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
794 last_comand_pointer
= &((*last_cmd
)->next
);
795 (*last_cmd
)->next
= NULL
;
796 (*last_cmd
)->type
= JTAG_SCAN
;
798 /* allocate memory for scan command */
799 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
800 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
801 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
802 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
803 (*last_cmd
)->cmd
.scan
->end_state
= state
;
805 for (i
= 0; i
< num_fields
; i
++)
807 int num_bits
= fields
[i
].num_bits
;
808 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
809 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
810 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
811 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
812 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
813 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
814 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
815 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
816 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
817 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
822 void jtag_add_statemove(enum tap_state state
)
826 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
827 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
832 cmd_queue_end_state
= state
;
834 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
835 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
837 if (cmd_queue_end_state
== TAP_TLR
)
838 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
840 cmd_queue_cur_state
= cmd_queue_end_state
;
843 retval
=interface_jtag_add_statemove(cmd_queue_end_state
);
844 if (retval
!=ERROR_OK
)
848 int MINIDRIVER(interface_jtag_add_statemove
)(enum tap_state state
)
850 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
852 /* allocate memory for a new list member */
853 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
854 last_comand_pointer
= &((*last_cmd
)->next
);
855 (*last_cmd
)->next
= NULL
;
856 (*last_cmd
)->type
= JTAG_STATEMOVE
;
858 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
859 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
865 void jtag_add_pathmove(int num_states
, enum tap_state
*path
)
869 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
870 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
874 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
875 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
877 if (cmd_queue_end_state
== TAP_TLR
)
878 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
880 /* the last state has to be a stable state */
881 if (tap_move_map
[path
[num_states
- 1]] == -1)
883 ERROR("TAP path doesn't finish in a stable state");
884 jtag_error
=ERROR_JTAG_NOT_IMPLEMENTED
;
888 enum tap_state cur_state
=cmd_queue_cur_state
;
890 for (i
=0; i
<num_states
; i
++)
892 if ((tap_transitions
[cur_state
].low
!= path
[i
])&&
893 (tap_transitions
[cur_state
].high
!= path
[i
]))
895 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[i
]]);
901 cmd_queue_cur_state
= path
[num_states
- 1];
903 int retval
=interface_jtag_add_pathmove(num_states
, path
);
904 if (retval
!=ERROR_OK
)
909 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
911 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_comand_pointer
= &((*last_cmd
)->next
);
917 (*last_cmd
)->next
= NULL
;
918 (*last_cmd
)->type
= JTAG_PATHMOVE
;
920 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
921 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
922 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
924 for (i
= 0; i
< num_states
; i
++)
925 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
930 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
932 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
934 /* allocate memory for a new list member */
935 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
936 (*last_cmd
)->next
= NULL
;
937 last_comand_pointer
= &((*last_cmd
)->next
);
938 (*last_cmd
)->type
= JTAG_RUNTEST
;
940 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
941 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
942 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
947 void jtag_add_runtest(int num_cycles
, enum tap_state state
)
951 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
952 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
957 cmd_queue_end_state
= state
;
959 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
960 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
962 if (cmd_queue_end_state
== TAP_TLR
)
963 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
965 cmd_queue_cur_state
= cmd_queue_end_state
;
967 /* executed by sw or hw fifo */
968 int retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
969 if (retval
!=ERROR_OK
)
973 int jtag_add_reset(int req_trst
, int req_srst
)
975 int trst_with_tms
= 0;
979 req_trst
= jtag_trst
;
982 req_srst
= jtag_srst
;
984 /* Make sure that jtag_reset_config allows the requested reset */
985 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
986 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
988 ERROR("requested reset would assert trst");
989 return ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
992 /* if TRST pulls SRST, we reset with TAP T-L-R */
993 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
999 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
1001 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
1002 return ERROR_JTAG_RESET_CANT_SRST
;
1005 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
1011 jtag_trst
= req_trst
;
1012 jtag_srst
= req_srst
;
1014 retval
= interface_jtag_add_reset(req_trst
, req_srst
);
1015 if (retval
!=ERROR_OK
)
1023 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
1027 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
1028 if (jtag_nsrst_delay
)
1029 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1034 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1035 jtag_add_end_state(TAP_TLR
);
1036 jtag_add_statemove(TAP_TLR
);
1042 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1043 * and inform possible listeners about this
1045 cmd_queue_cur_state
= TAP_TLR
;
1046 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1050 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
1051 * but we might want to add a delay to give the TAP time to settle
1053 if (jtag_ntrst_delay
)
1054 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1059 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1061 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1063 /* allocate memory for a new list member */
1064 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1065 (*last_cmd
)->next
= NULL
;
1066 last_comand_pointer
= &((*last_cmd
)->next
);
1067 (*last_cmd
)->type
= JTAG_RESET
;
1069 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1070 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1071 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1077 void jtag_add_end_state(enum tap_state state
)
1079 cmd_queue_end_state
= state
;
1082 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1084 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1086 /* allocate memory for a new list member */
1087 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1088 (*last_cmd
)->next
= NULL
;
1089 last_comand_pointer
= &((*last_cmd
)->next
);
1090 (*last_cmd
)->type
= JTAG_SLEEP
;
1092 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1093 (*last_cmd
)->cmd
.sleep
->us
= us
;
1098 void jtag_add_sleep(u32 us
)
1100 int retval
=interface_jtag_add_sleep(us
);
1101 if (retval
!=ERROR_OK
)
1106 int jtag_scan_size(scan_command_t
*cmd
)
1111 /* count bits in scan command */
1112 for (i
= 0; i
< cmd
->num_fields
; i
++)
1114 bit_count
+= cmd
->fields
[i
].num_bits
;
1120 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1125 bit_count
= jtag_scan_size(cmd
);
1126 *buffer
= malloc(CEIL(bit_count
, 8));
1130 for (i
= 0; i
< cmd
->num_fields
; i
++)
1132 if (cmd
->fields
[i
].out_value
)
1134 #ifdef _DEBUG_JTAG_IO_
1135 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1137 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1138 #ifdef _DEBUG_JTAG_IO_
1139 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1144 bit_count
+= cmd
->fields
[i
].num_bits
;
1151 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1157 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1160 for (i
= 0; i
< cmd
->num_fields
; i
++)
1162 /* if neither in_value nor in_handler
1163 * are specified we don't have to examine this field
1165 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1167 int num_bits
= cmd
->fields
[i
].num_bits
;
1168 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1170 #ifdef _DEBUG_JTAG_IO_
1173 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1174 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1178 if (cmd
->fields
[i
].in_value
)
1180 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1182 if (cmd
->fields
[i
].in_handler
)
1184 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1186 WARNING("in_handler reported a failed check");
1187 retval
= ERROR_JTAG_QUEUE_FAILED
;
1192 /* no in_value specified, but a handler takes care of the scanned data */
1193 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1195 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1197 /* We're going to call the error:handler later, but if the in_handler
1198 * reported an error we report this failure upstream
1200 WARNING("in_handler reported a failed check");
1201 retval
= ERROR_JTAG_QUEUE_FAILED
;
1207 bit_count
+= cmd
->fields
[i
].num_bits
;
1213 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1215 int retval
= ERROR_OK
;
1216 int num_bits
= field
->num_bits
;
1218 int compare_failed
= 0;
1220 if (field
->in_check_mask
)
1221 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1223 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1227 /* An error handler could have caught the failing check
1228 * only report a problem when there wasn't a handler, or if the handler
1229 * acknowledged the error
1233 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1234 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1236 if (field
->in_check_mask
)
1238 char *in_check_mask_char
;
1239 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1240 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
);
1241 free(in_check_mask_char
);
1245 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1248 free(captured_char
);
1249 free(in_check_value_char
);
1251 retval
= ERROR_JTAG_QUEUE_FAILED
;
1259 set up checking of this field using the in_handler. The values passed in must be valid until
1260 after jtag_execute() has completed.
1262 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1265 field
->in_handler
= jtag_check_value
;
1267 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1268 field
->in_handler_priv
= NULL
; /* this will be filled in at the invocation site to point to the field duplicate */
1269 field
->in_check_value
= value
;
1270 field
->in_check_mask
= mask
;
1273 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1278 for (i
= 0; i
< cmd
->num_fields
; i
++)
1280 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1282 if (cmd
->fields
[i
].out_value
)
1289 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1293 retval
= jtag
->execute_queue();
1297 jtag_command_queue
= NULL
;
1298 last_comand_pointer
= &jtag_command_queue
;
1303 int jtag_execute_queue(void)
1305 int retval
=interface_jtag_execute_queue();
1306 if (retval
==ERROR_OK
)
1310 jtag_error
=ERROR_OK
;
1314 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1316 jtag_device_t
*device
= priv
;
1320 if (event
== JTAG_TRST_ASSERTED
)
1322 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1329 void jtag_sleep(u32 us
)
1334 /* Try to examine chain layout according to IEEE 1149.1 §12
1336 int jtag_examine_chain()
1338 jtag_device_t
*device
= jtag_devices
;
1340 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1343 int device_count
= 0;
1344 u8 zero_check
= 0x0;
1345 u8 one_check
= 0xff;
1348 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1349 field
.out_value
= idcode_buffer
;
1350 field
.out_mask
= NULL
;
1351 field
.in_value
= idcode_buffer
;
1352 field
.in_check_value
= NULL
;
1353 field
.in_check_mask
= NULL
;
1354 field
.in_handler
= NULL
;
1355 field
.in_handler_priv
= NULL
;
1357 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1359 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1362 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1363 jtag_execute_queue();
1365 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1367 zero_check
|= idcode_buffer
[i
];
1368 one_check
&= idcode_buffer
[i
];
1371 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1372 if ((zero_check
== 0x00) || (one_check
== 0xff))
1374 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1375 return ERROR_JTAG_INIT_FAILED
;
1378 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1380 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1381 if ((idcode
& 1) == 0)
1383 /* LSB must not be 0, this indicates a device in bypass */
1394 if (idcode
== 0x000000FF)
1396 /* End of chain (invalid manufacturer ID) */
1402 device
->idcode
= idcode
;
1403 device
= device
->next
;
1407 manufacturer
= (idcode
& 0xffe) >> 1;
1408 part
= (idcode
& 0xffff000) >> 12;
1409 version
= (idcode
& 0xf0000000) >> 28;
1411 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1412 idcode
, manufacturer
, part
, version
);
1418 /* see if number of discovered devices matches configuration */
1419 if (device_count
!= jtag_num_devices
)
1421 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1422 device_count
, jtag_num_devices
);
1423 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1424 return ERROR_JTAG_INIT_FAILED
;
1430 int jtag_validate_chain()
1432 jtag_device_t
*device
= jtag_devices
;
1433 int total_ir_length
= 0;
1440 total_ir_length
+= device
->ir_length
;
1441 device
= device
->next
;
1444 total_ir_length
+= 2;
1445 ir_test
= malloc(CEIL(total_ir_length
, 8));
1446 buf_set_ones(ir_test
, total_ir_length
);
1449 field
.num_bits
= total_ir_length
;
1450 field
.out_value
= ir_test
;
1451 field
.out_mask
= NULL
;
1452 field
.in_value
= ir_test
;
1453 field
.in_check_value
= NULL
;
1454 field
.in_check_mask
= NULL
;
1455 field
.in_handler
= NULL
;
1456 field
.in_handler_priv
= NULL
;
1458 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1459 jtag_execute_queue();
1461 device
= jtag_devices
;
1464 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1466 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1467 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1470 return ERROR_JTAG_INIT_FAILED
;
1472 chain_pos
+= device
->ir_length
;
1473 device
= device
->next
;
1476 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1478 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1479 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1482 return ERROR_JTAG_INIT_FAILED
;
1490 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1492 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1493 COMMAND_CONFIG
, NULL
);
1494 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1495 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1496 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1497 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1498 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1499 COMMAND_CONFIG
, NULL
);
1500 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1501 COMMAND_CONFIG
, NULL
);
1502 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1503 COMMAND_CONFIG
, NULL
);
1505 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1506 COMMAND_EXEC
, "print current scan chain configuration");
1508 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1509 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1510 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1511 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1512 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1513 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1514 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1515 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1516 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1517 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1518 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1519 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1521 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1522 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1526 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1528 if (!jtag_interface
)
1530 /* nothing was previously specified by "interface" command */
1531 ERROR("JTAG interface has to be specified, see \"interface\" command");
1532 return ERROR_JTAG_INVALID_INTERFACE
;
1535 if (jtag_interface
->init() != ERROR_OK
)
1536 return ERROR_JTAG_INIT_FAILED
;
1538 jtag
= jtag_interface
;
1542 int jtag_init(struct command_context_s
*cmd_ctx
)
1544 int validate_tries
= 0;
1545 jtag_device_t
*device
;
1549 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1550 return ERROR_JTAG_INIT_FAILED
;
1552 device
= jtag_devices
;
1553 jtag_ir_scan_size
= 0;
1554 jtag_num_devices
= 0;
1555 while (device
!= NULL
)
1557 jtag_ir_scan_size
+= device
->ir_length
;
1559 device
= device
->next
;
1562 jtag_add_statemove(TAP_TLR
);
1563 jtag_execute_queue();
1565 /* examine chain first, as this could discover the real chain layout */
1566 if (jtag_examine_chain() != ERROR_OK
)
1568 ERROR("trying to validate configured JTAG chain anyway...");
1571 while (jtag_validate_chain() != ERROR_OK
)
1574 if (validate_tries
> 5)
1576 ERROR("Could not validate JTAG chain, exit");
1577 return ERROR_JTAG_INVALID_INTERFACE
;
1586 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1590 /* check whether the interface is already configured */
1593 WARNING("Interface already configured, ignoring");
1597 /* interface name is a mandatory argument */
1598 if (argc
< 1 || args
[0][0] == '\0')
1600 return ERROR_COMMAND_SYNTAX_ERROR
;
1603 for (i
=0; jtag_interfaces
[i
]; i
++)
1605 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1607 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1610 jtag_interface
= jtag_interfaces
[i
];
1615 /* no valid interface was found (i.e. the configuration option,
1616 * didn't match one of the compiled-in interfaces
1618 ERROR("No valid jtag interface found (%s)", args
[0]);
1619 ERROR("compiled-in jtag interfaces:");
1620 for (i
= 0; jtag_interfaces
[i
]; i
++)
1622 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1625 return ERROR_JTAG_INVALID_INTERFACE
;
1628 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1630 jtag_device_t
**last_device_p
= &jtag_devices
;
1634 while ((*last_device_p
)->next
)
1635 last_device_p
= &((*last_device_p
)->next
);
1636 last_device_p
= &((*last_device_p
)->next
);
1642 *last_device_p
= malloc(sizeof(jtag_device_t
));
1643 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1645 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1646 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1647 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1648 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1650 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1651 (*last_device_p
)->bypass
= 1;
1652 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1654 (*last_device_p
)->next
= NULL
;
1656 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1663 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1665 jtag_device_t
*device
= jtag_devices
;
1666 int device_count
= 0;
1670 u32 expected
, expected_mask
, cur_instr
;
1671 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1672 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1673 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1674 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
);
1675 device
= device
->next
;
1682 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1686 if (strcmp(args
[0], "none") == 0)
1687 jtag_reset_config
= RESET_NONE
;
1688 else if (strcmp(args
[0], "trst_only") == 0)
1689 jtag_reset_config
= RESET_HAS_TRST
;
1690 else if (strcmp(args
[0], "srst_only") == 0)
1691 jtag_reset_config
= RESET_HAS_SRST
;
1692 else if (strcmp(args
[0], "trst_and_srst") == 0)
1693 jtag_reset_config
= RESET_TRST_AND_SRST
;
1696 ERROR("invalid reset_config argument, defaulting to none");
1697 jtag_reset_config
= RESET_NONE
;
1698 return ERROR_INVALID_ARGUMENTS
;
1704 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1705 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1706 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1707 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1708 else if (strcmp(args
[1], "combined") == 0)
1709 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1710 else if (strcmp(args
[1], "separate") == 0)
1711 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1714 ERROR("invalid reset_config argument, defaulting to none");
1715 jtag_reset_config
= RESET_NONE
;
1716 return ERROR_INVALID_ARGUMENTS
;
1722 if (strcmp(args
[2], "trst_open_drain") == 0)
1723 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1724 else if (strcmp(args
[2], "trst_push_pull") == 0)
1725 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1728 ERROR("invalid reset_config argument, defaulting to none");
1729 jtag_reset_config
= RESET_NONE
;
1730 return ERROR_INVALID_ARGUMENTS
;
1736 if (strcmp(args
[3], "srst_push_pull") == 0)
1737 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1738 else if (strcmp(args
[3], "srst_open_drain") == 0)
1739 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1742 ERROR("invalid reset_config argument, defaulting to none");
1743 jtag_reset_config
= RESET_NONE
;
1744 return ERROR_INVALID_ARGUMENTS
;
1751 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1755 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1760 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1766 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1770 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1775 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1781 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1784 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1788 jtag_speed
= strtoul(args
[0], NULL
, 0);
1789 /* this command can be called during CONFIG,
1790 * in which case jtag isn't initialized */
1792 jtag
->speed(jtag_speed
);
1798 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1800 enum tap_state state
;
1804 return ERROR_COMMAND_SYNTAX_ERROR
;
1808 for (state
= 0; state
< 16; state
++)
1810 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1812 jtag_add_end_state(state
);
1813 jtag_execute_queue();
1817 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1822 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1829 return ERROR_COMMAND_SYNTAX_ERROR
;
1832 if (args
[0][0] == '1')
1834 else if (args
[0][0] == '0')
1838 return ERROR_COMMAND_SYNTAX_ERROR
;
1841 if (args
[1][0] == '1')
1843 else if (args
[1][0] == '0')
1847 return ERROR_COMMAND_SYNTAX_ERROR
;
1850 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1851 return ERROR_JTAG_INIT_FAILED
;
1853 jtag_add_reset(trst
, srst
);
1854 jtag_execute_queue();
1859 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1863 return ERROR_COMMAND_SYNTAX_ERROR
;
1866 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1867 jtag_execute_queue();
1873 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1875 enum tap_state state
;
1880 for (state
= 0; state
< 16; state
++)
1882 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1889 jtag_add_statemove(state
);
1890 jtag_execute_queue();
1896 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1899 scan_field_t
*fields
;
1901 if ((argc
< 2) || (argc
% 2))
1903 return ERROR_COMMAND_SYNTAX_ERROR
;
1906 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1908 for (i
= 0; i
< argc
/ 2; i
++)
1910 int device
= strtoul(args
[i
*2], NULL
, 0);
1911 int field_size
= jtag_get_device(device
)->ir_length
;
1912 fields
[i
].device
= device
;
1913 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1914 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1915 fields
[i
].out_mask
= NULL
;
1916 fields
[i
].in_value
= NULL
;
1917 fields
[i
].in_check_mask
= NULL
;
1918 fields
[i
].in_handler
= NULL
;
1919 fields
[i
].in_handler_priv
= NULL
;
1922 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1923 jtag_execute_queue();
1925 for (i
= 0; i
< argc
/ 2; i
++)
1926 free(fields
[i
].out_value
);
1933 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1935 scan_field_t
*fields
;
1937 int field_count
= 0;
1941 if ((argc
< 2) || (argc
% 2))
1943 return ERROR_COMMAND_SYNTAX_ERROR
;
1946 for (i
= 0; i
< argc
; i
+=2)
1948 var
= get_var_by_namenum(args
[i
+1]);
1951 num_fields
+= var
->num_fields
;
1955 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1960 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1962 for (i
= 0; i
< argc
; i
+=2)
1964 var
= get_var_by_namenum(args
[i
+1]);
1966 for (j
= 0; j
< var
->num_fields
; j
++)
1968 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1969 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1970 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1971 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1972 fields
[field_count
].out_mask
= NULL
;
1973 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1974 fields
[field_count
].in_check_mask
= NULL
;
1975 fields
[field_count
].in_check_value
= NULL
;
1976 fields
[field_count
].in_handler
= field_le_to_host
;
1977 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1981 jtag_add_dr_scan(num_fields
, fields
, -1);
1982 jtag_execute_queue();
1984 for (i
= 0; i
< argc
/ 2; i
++)
1985 free(fields
[i
].out_value
);
1992 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1996 if (strcmp(args
[0], "enable") == 0)
1998 jtag_verify_capture_ir
= 1;
2000 else if (strcmp(args
[0], "disable") == 0)
2002 jtag_verify_capture_ir
= 0;
2005 return ERROR_COMMAND_SYNTAX_ERROR
;
2007 } else if (argc
!= 0)
2009 return ERROR_COMMAND_SYNTAX_ERROR
;
2012 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");
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)