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"
38 /* note that this is not marked as static as it must be available from outside jtag.c for those
39 that implement the jtag_xxx() minidriver layer
41 int jtag_error
=ERROR_OK
;
44 char* tap_state_strings
[16] =
47 "sds", "cd", "sd", "e1d", "pd", "e2d", "ud",
49 "sis", "ci", "si", "e1i", "pi", "e2i", "ui"
52 typedef struct cmd_queue_page_s
56 struct cmd_queue_page_s
*next
;
59 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
60 static cmd_queue_page_t
*cmd_queue_pages
= NULL
;
62 /* tap_move[i][j]: tap movement command to go from state i to state j
70 * SD->SD and SI->SI have to be caught in interface specific code
74 /* TLR RTI SD PD SI PI */
75 {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */
76 {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */
77 {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */
78 {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */
79 {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */
80 {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */
83 int tap_move_map
[16] = {
84 0, -1, -1, 2, -1, 3, -1, -1,
85 1, -1, -1, 4, -1, 5, -1, -1
88 tap_transition_t tap_transitions
[16] =
90 {TAP_TLR
, TAP_RTI
}, /* TLR */
91 {TAP_SIS
, TAP_CD
}, /* SDS */
92 {TAP_E1D
, TAP_SD
}, /* CD */
93 {TAP_E1D
, TAP_SD
}, /* SD */
94 {TAP_UD
, TAP_PD
}, /* E1D */
95 {TAP_E2D
, TAP_PD
}, /* PD */
96 {TAP_UD
, TAP_SD
}, /* E2D */
97 {TAP_SDS
, TAP_RTI
}, /* UD */
98 {TAP_SDS
, TAP_RTI
}, /* RTI */
99 {TAP_TLR
, TAP_CI
}, /* SIS */
100 {TAP_E1I
, TAP_SI
}, /* CI */
101 {TAP_E1I
, TAP_SI
}, /* SI */
102 {TAP_UI
, TAP_PI
}, /* E1I */
103 {TAP_E2I
, TAP_PI
}, /* PI */
104 {TAP_UI
, TAP_SI
}, /* E2I */
105 {TAP_SDS
, TAP_RTI
} /* UI */
108 char* jtag_event_strings
[] =
116 enum tap_state end_state
= TAP_TLR
;
117 enum tap_state cur_state
= TAP_TLR
;
121 jtag_command_t
*jtag_command_queue
= NULL
;
122 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
123 jtag_device_t
*jtag_devices
= NULL
;
124 int jtag_num_devices
= 0;
125 int jtag_ir_scan_size
= 0;
126 enum reset_types jtag_reset_config
= RESET_NONE
;
127 enum tap_state cmd_queue_end_state
= TAP_TLR
;
128 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
130 int jtag_verify_capture_ir
= 1;
132 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
133 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
134 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
136 /* maximum number of JTAG devices expected in the chain
138 #define JTAG_MAX_CHAIN_SIZE 20
140 /* callbacks to inform high-level handlers about JTAG state changes */
141 jtag_event_callback_t
*jtag_event_callbacks
;
143 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
145 #if BUILD_PARPORT == 1
146 extern jtag_interface_t parport_interface
;
149 #if BUILD_FT2232_FTD2XX == 1
150 extern jtag_interface_t ft2232_interface
;
153 #if BUILD_FT2232_LIBFTDI == 1
154 extern jtag_interface_t ft2232_interface
;
157 #if BUILD_AMTJTAGACCEL == 1
158 extern jtag_interface_t amt_jtagaccel_interface
;
161 #if BUILD_EP93XX == 1
162 extern jtag_interface_t ep93xx_interface
;
165 #if BUILD_AT91RM9200 == 1
166 extern jtag_interface_t at91rm9200_interface
;
169 #if BUILD_GW16012 == 1
170 extern jtag_interface_t gw16012_interface
;
173 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
174 extern jtag_interface_t presto_interface
;
177 #if BUILD_USBPROG == 1
178 extern jtag_interface_t usbprog_interface
;
181 jtag_interface_t
*jtag_interfaces
[] = {
182 #if BUILD_PARPORT == 1
185 #if BUILD_FT2232_FTD2XX == 1
188 #if BUILD_FT2232_LIBFTDI == 1
191 #if BUILD_AMTJTAGACCEL == 1
192 &amt_jtagaccel_interface
,
194 #if BUILD_EP93XX == 1
197 #if BUILD_AT91RM9200 == 1
198 &at91rm9200_interface
,
200 #if BUILD_GW16012 == 1
203 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
206 #if BUILD_USBPROG == 1
212 jtag_interface_t
*jtag
= NULL
;
215 jtag_interface_t
*jtag_interface
= NULL
;
219 /* forward declarations */
220 int jtag_add_statemove(enum tap_state endstate
);
221 int jtag_add_pathmove(int num_states
, enum tap_state
*path
);
222 int jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
223 int jtag_add_reset(int trst
, int srst
);
224 int jtag_add_end_state(enum tap_state endstate
);
225 int jtag_add_sleep(u32 us
);
226 int jtag_execute_queue(void);
227 int jtag_cancel_queue(void);
230 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
231 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
232 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
233 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
234 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
235 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
237 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
239 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
240 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
241 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
242 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
243 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
244 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
246 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
248 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
250 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
252 if (callback
== NULL
)
254 return ERROR_INVALID_ARGUMENTS
;
259 while ((*callbacks_p
)->next
)
260 callbacks_p
= &((*callbacks_p
)->next
);
261 callbacks_p
= &((*callbacks_p
)->next
);
264 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
265 (*callbacks_p
)->callback
= callback
;
266 (*callbacks_p
)->priv
= priv
;
267 (*callbacks_p
)->next
= NULL
;
272 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
274 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
276 if (callback
== NULL
)
278 return ERROR_INVALID_ARGUMENTS
;
283 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
284 if ((*callbacks_p
)->callback
== callback
)
287 *callbacks_p
= *next
;
295 int jtag_call_event_callbacks(enum jtag_event event
)
297 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
299 DEBUG("jtag event: %s", jtag_event_strings
[event
]);
303 callback
->callback(event
, callback
->priv
);
304 callback
= callback
->next
;
310 /* returns a pointer to the pointer of the last command in queue
311 * this may be a pointer to the root pointer (jtag_command_queue)
312 * or to the next member of the last but one command
314 jtag_command_t
** jtag_get_last_command_p(void)
316 /* jtag_command_t *cmd = jtag_command_queue;
322 return &jtag_command_queue;
326 return last_comand_pointer
;
329 /* returns a pointer to the n-th device in the scan chain */
330 jtag_device_t
* jtag_get_device(int num
)
332 jtag_device_t
*device
= jtag_devices
;
339 device
= device
->next
;
343 ERROR("jtag device number %d not defined", num
);
347 void* cmd_queue_alloc(size_t size
)
349 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
354 while ((*p_page
)->next
)
355 p_page
= &((*p_page
)->next
);
356 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
357 p_page
= &((*p_page
)->next
);
362 *p_page
= malloc(sizeof(cmd_queue_page_t
));
364 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
365 (*p_page
)->next
= NULL
;
368 offset
= (*p_page
)->used
;
369 (*p_page
)->used
+= size
;
371 u8
*t
=(u8
*)((*p_page
)->address
);
375 void cmd_queue_free()
377 cmd_queue_page_t
*page
= cmd_queue_pages
;
381 cmd_queue_page_t
*last
= page
;
387 cmd_queue_pages
= NULL
;
390 int jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
394 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
395 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
396 return ERROR_JTAG_TRST_ASSERTED
;
400 cmd_queue_end_state
= state
;
402 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
403 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
405 if (cmd_queue_end_state
== TAP_TLR
)
406 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
408 cmd_queue_cur_state
= cmd_queue_end_state
;
410 int retval
=interface_jtag_add_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
411 if (retval
!=ERROR_OK
)
416 int MINIDRIVER(interface_jtag_add_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
418 jtag_command_t
**last_cmd
;
419 jtag_device_t
*device
;
424 last_cmd
= jtag_get_last_command_p();
426 /* allocate memory for a new list member */
427 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
428 (*last_cmd
)->next
= NULL
;
429 last_comand_pointer
= &((*last_cmd
)->next
);
430 (*last_cmd
)->type
= JTAG_SCAN
;
432 /* allocate memory for ir scan command */
433 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
434 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
435 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
436 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
437 (*last_cmd
)->cmd
.scan
->end_state
= state
;
439 for (i
= 0; i
< jtag_num_devices
; i
++)
442 device
= jtag_get_device(i
);
443 scan_size
= device
->ir_length
;
444 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
445 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
446 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
447 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
; /* disable verification by default */
449 /* search the list */
450 for (j
= 0; j
< num_fields
; j
++)
452 if (i
== fields
[j
].device
)
455 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
456 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
458 if (jtag_verify_capture_ir
)
460 if (fields
[j
].in_handler
==NULL
)
462 jtag_set_check_value((*last_cmd
)->cmd
.scan
->fields
+i
, device
->expected
, device
->expected_mask
, NULL
);
465 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[j
].in_handler
;
466 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[j
].in_handler_priv
;
467 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= device
->expected
;
468 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= device
->expected_mask
;
479 /* if a device isn't listed, set it to BYPASS */
480 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
481 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
486 /* update device information */
487 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
493 int jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
497 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
498 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
502 cmd_queue_end_state
= state
;
504 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
505 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
507 if (cmd_queue_end_state
== TAP_TLR
)
508 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
510 cmd_queue_cur_state
= cmd_queue_end_state
;
512 return interface_jtag_add_plain_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
515 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
518 jtag_command_t
**last_cmd
;
520 last_cmd
= jtag_get_last_command_p();
522 /* allocate memory for a new list member */
523 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
524 (*last_cmd
)->next
= NULL
;
525 last_comand_pointer
= &((*last_cmd
)->next
);
526 (*last_cmd
)->type
= JTAG_SCAN
;
528 /* allocate memory for ir scan command */
529 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
530 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
531 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
532 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
533 (*last_cmd
)->cmd
.scan
->end_state
= state
;
535 for (i
= 0; i
< num_fields
; i
++)
537 int num_bits
= fields
[i
].num_bits
;
538 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
539 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
540 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
541 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
542 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
543 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
544 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
545 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
546 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
547 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
552 int jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
556 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
557 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
561 cmd_queue_end_state
= state
;
563 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
564 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
566 if (cmd_queue_end_state
== TAP_TLR
)
567 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
569 cmd_queue_cur_state
= cmd_queue_end_state
;
571 return interface_jtag_add_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
574 int MINIDRIVER(interface_jtag_add_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
577 int bypass_devices
= 0;
581 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
582 jtag_device_t
*device
= jtag_devices
;
584 /* count devices in bypass */
589 device
= device
->next
;
592 /* allocate memory for a new list member */
593 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
594 last_comand_pointer
= &((*last_cmd
)->next
);
595 (*last_cmd
)->next
= NULL
;
596 (*last_cmd
)->type
= JTAG_SCAN
;
598 /* allocate memory for dr scan command */
599 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
600 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
601 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
602 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
603 (*last_cmd
)->cmd
.scan
->end_state
= state
;
605 for (i
= 0; i
< jtag_num_devices
; i
++)
608 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
610 for (j
= 0; j
< num_fields
; j
++)
612 if (i
== fields
[j
].device
)
615 scan_size
= fields
[j
].num_bits
;
616 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
617 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
618 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
619 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
620 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= fields
[j
].in_check_value
;
621 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= fields
[j
].in_check_mask
;
622 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
623 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
628 #ifdef _DEBUG_JTAG_IO_
629 /* if a device isn't listed, the BYPASS register should be selected */
630 if (!jtag_get_device(i
)->bypass
)
632 ERROR("BUG: no scan data for a device not in BYPASS");
636 /* program the scan field to 1 bit length, and ignore it's value */
637 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
638 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
639 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
640 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
641 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
642 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
643 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
644 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
648 #ifdef _DEBUG_JTAG_IO_
649 /* if a device is listed, the BYPASS register must not be selected */
650 if (jtag_get_device(i
)->bypass
)
652 WARNING("scan data for a device in BYPASS");
660 void MINIDRIVER(interface_jtag_add_dr_out
)(int device_num
,
664 enum tap_state end_state
)
669 int bypass_devices
= 0;
671 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
672 jtag_device_t
*device
= jtag_devices
;
673 /* count devices in bypass */
678 device
= device
->next
;
681 /* allocate memory for a new list member */
682 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
683 last_comand_pointer
= &((*last_cmd
)->next
);
684 (*last_cmd
)->next
= NULL
;
685 (*last_cmd
)->type
= JTAG_SCAN
;
687 /* allocate memory for dr scan command */
688 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
689 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
690 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
691 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
692 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
694 for (i
= 0; i
< jtag_num_devices
; i
++)
696 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
701 #ifdef _DEBUG_JTAG_IO_
702 /* if a device is listed, the BYPASS register must not be selected */
703 if (jtag_get_device(i
)->bypass
)
705 ERROR("scan data for a device in BYPASS");
709 for (j
= 0; j
< num_fields
; j
++)
712 scan_size
= num_bits
[j
];
713 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
714 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
715 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
716 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
717 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
718 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
719 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
720 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
721 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
725 #ifdef _DEBUG_JTAG_IO_
726 /* if a device isn't listed, the BYPASS register should be selected */
727 if (!jtag_get_device(i
)->bypass
)
729 ERROR("BUG: no scan data for a device not in BYPASS");
733 /* program the scan field to 1 bit length, and ignore it's value */
734 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
735 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
736 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
737 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
738 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
739 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
740 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
741 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
749 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
753 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
754 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
758 cmd_queue_end_state
= state
;
760 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
761 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
763 if (cmd_queue_end_state
== TAP_TLR
)
764 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
766 cmd_queue_cur_state
= cmd_queue_end_state
;
768 return interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
771 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
774 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
776 /* allocate memory for a new list member */
777 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
778 last_comand_pointer
= &((*last_cmd
)->next
);
779 (*last_cmd
)->next
= NULL
;
780 (*last_cmd
)->type
= JTAG_SCAN
;
782 /* allocate memory for scan command */
783 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
784 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
785 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
786 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
787 (*last_cmd
)->cmd
.scan
->end_state
= state
;
789 for (i
= 0; i
< num_fields
; i
++)
791 int num_bits
= fields
[i
].num_bits
;
792 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
793 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
794 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
795 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
796 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
797 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
798 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
799 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
800 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
801 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
806 int jtag_add_statemove(enum tap_state state
)
810 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
811 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
815 cmd_queue_end_state
= state
;
817 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
818 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
820 if (cmd_queue_end_state
== TAP_TLR
)
821 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
823 cmd_queue_cur_state
= cmd_queue_end_state
;
825 return interface_jtag_add_statemove(cmd_queue_end_state
);
828 int MINIDRIVER(interface_jtag_add_statemove
)(enum tap_state state
)
830 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
832 /* allocate memory for a new list member */
833 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
834 last_comand_pointer
= &((*last_cmd
)->next
);
835 (*last_cmd
)->next
= NULL
;
836 (*last_cmd
)->type
= JTAG_STATEMOVE
;
838 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
839 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
845 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
849 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
850 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
853 /* the last state has to be a stable state */
854 if (tap_move_map
[path
[num_states
- 1]] == -1)
856 ERROR("TAP path doesn't finish in a stable state");
857 return jtag_error
=ERROR_JTAG_NOT_IMPLEMENTED
;
860 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
861 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
863 if (cmd_queue_end_state
== TAP_TLR
)
864 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
867 enum tap_state cur_state
=cmd_queue_cur_state
;
869 for (i
=0; i
<num_states
; i
++)
871 if ((tap_transitions
[cur_state
].low
!= path
[i
])&&
872 (tap_transitions
[cur_state
].high
!= path
[i
]))
874 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[i
]]);
880 cmd_queue_cur_state
= path
[num_states
- 1];
882 return interface_jtag_add_pathmove(num_states
, path
);
886 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
888 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
891 /* allocate memory for a new list member */
892 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
893 last_comand_pointer
= &((*last_cmd
)->next
);
894 (*last_cmd
)->next
= NULL
;
895 (*last_cmd
)->type
= JTAG_PATHMOVE
;
897 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
898 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
899 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
901 for (i
= 0; i
< num_states
; i
++)
902 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
907 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
909 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
911 /* allocate memory for a new list member */
912 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
913 (*last_cmd
)->next
= NULL
;
914 last_comand_pointer
= &((*last_cmd
)->next
);
915 (*last_cmd
)->type
= JTAG_RUNTEST
;
917 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
918 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
919 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
924 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
928 jtag_error
=ERROR_JTAG_QUEUE_FAILED
;
929 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
930 return ERROR_JTAG_TRST_ASSERTED
;
934 cmd_queue_end_state
= state
;
936 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
937 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
939 if (cmd_queue_end_state
== TAP_TLR
)
940 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
942 cmd_queue_cur_state
= cmd_queue_end_state
;
944 /* executed by sw or hw fifo */
945 return interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
948 int jtag_add_reset(int req_trst
, int req_srst
)
950 int trst_with_tms
= 0;
954 req_trst
= jtag_trst
;
957 req_srst
= jtag_srst
;
959 /* Make sure that jtag_reset_config allows the requested reset */
960 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
961 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
963 return jtag_error
=ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
966 /* if TRST pulls SRST, we reset with TAP T-L-R */
967 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
973 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
975 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
976 return jtag_error
=ERROR_JTAG_RESET_CANT_SRST
;
979 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
985 jtag_trst
= req_trst
;
986 jtag_srst
= req_srst
;
988 retval
= interface_jtag_add_reset(req_trst
, req_srst
);
989 if (retval
!=ERROR_OK
)
997 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
1001 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
1002 if (jtag_nsrst_delay
)
1003 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1008 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1009 jtag_add_end_state(TAP_TLR
);
1010 jtag_add_statemove(TAP_TLR
);
1017 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1018 * and inform possible listeners about this
1020 cmd_queue_cur_state
= TAP_TLR
;
1021 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1025 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
1026 * but we might want to add a delay to give the TAP time to settle
1028 if (jtag_ntrst_delay
)
1029 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1036 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1038 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1040 /* allocate memory for a new list member */
1041 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1042 (*last_cmd
)->next
= NULL
;
1043 last_comand_pointer
= &((*last_cmd
)->next
);
1044 (*last_cmd
)->type
= JTAG_RESET
;
1046 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1047 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1048 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1054 int MINIDRIVER(interface_jtag_add_end_state
)(enum tap_state state
)
1056 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1058 /* allocate memory for a new list member */
1059 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1060 (*last_cmd
)->next
= NULL
;
1061 last_comand_pointer
= &((*last_cmd
)->next
);
1062 (*last_cmd
)->type
= JTAG_END_STATE
;
1064 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
1065 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
1070 int jtag_add_end_state(enum tap_state state
)
1073 cmd_queue_end_state
= state
;
1074 int retval
= interface_jtag_add_end_state(cmd_queue_end_state
);
1078 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1080 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1082 /* allocate memory for a new list member */
1083 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1084 (*last_cmd
)->next
= NULL
;
1085 last_comand_pointer
= &((*last_cmd
)->next
);
1086 (*last_cmd
)->type
= JTAG_SLEEP
;
1088 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1089 (*last_cmd
)->cmd
.sleep
->us
= us
;
1094 int jtag_add_sleep(u32 us
)
1096 return interface_jtag_add_sleep(us
);
1099 int jtag_scan_size(scan_command_t
*cmd
)
1104 /* count bits in scan command */
1105 for (i
= 0; i
< cmd
->num_fields
; i
++)
1107 bit_count
+= cmd
->fields
[i
].num_bits
;
1113 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1118 bit_count
= jtag_scan_size(cmd
);
1119 *buffer
= malloc(CEIL(bit_count
, 8));
1123 for (i
= 0; i
< cmd
->num_fields
; i
++)
1125 if (cmd
->fields
[i
].out_value
)
1127 #ifdef _DEBUG_JTAG_IO_
1128 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1130 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1131 #ifdef _DEBUG_JTAG_IO_
1132 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1137 bit_count
+= cmd
->fields
[i
].num_bits
;
1144 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1150 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1153 for (i
= 0; i
< cmd
->num_fields
; i
++)
1155 /* if neither in_value nor in_handler
1156 * are specified we don't have to examine this field
1158 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1160 int num_bits
= cmd
->fields
[i
].num_bits
;
1161 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1163 #ifdef _DEBUG_JTAG_IO_
1166 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1167 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1171 if (cmd
->fields
[i
].in_value
)
1173 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1175 if (cmd
->fields
[i
].in_handler
)
1177 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1179 WARNING("in_handler reported a failed check");
1180 retval
= ERROR_JTAG_QUEUE_FAILED
;
1185 /* no in_value specified, but a handler takes care of the scanned data */
1186 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1188 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1190 /* We're going to call the error:handler later, but if the in_handler
1191 * reported an error we report this failure upstream
1193 WARNING("in_handler reported a failed check");
1194 retval
= ERROR_JTAG_QUEUE_FAILED
;
1200 bit_count
+= cmd
->fields
[i
].num_bits
;
1206 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1208 int retval
= ERROR_OK
;
1209 int num_bits
= field
->num_bits
;
1211 int compare_failed
= 0;
1213 if (field
->in_check_mask
)
1214 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1216 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1220 /* An error handler could have caught the failing check
1221 * only report a problem when there wasn't a handler, or if the handler
1222 * acknowledged the error
1226 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1227 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1229 if (field
->in_check_mask
)
1231 char *in_check_mask_char
;
1232 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1233 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
);
1234 free(in_check_mask_char
);
1238 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1241 free(captured_char
);
1242 free(in_check_value_char
);
1244 retval
= ERROR_JTAG_QUEUE_FAILED
;
1252 set up checking of this field using the in_handler. The values passed in must be valid until
1253 after jtag_execute() has completed.
1255 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1258 field
->in_handler
= jtag_check_value
;
1260 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1261 field
->in_handler_priv
= NULL
; /* this will be filled in at the invocation site to point to the field duplicate */
1262 field
->in_check_value
= value
;
1263 field
->in_check_mask
= mask
;
1266 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1271 for (i
= 0; i
< cmd
->num_fields
; i
++)
1273 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1275 if (cmd
->fields
[i
].out_value
)
1282 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1286 retval
= jtag
->execute_queue();
1290 jtag_command_queue
= NULL
;
1291 last_comand_pointer
= &jtag_command_queue
;
1296 int jtag_execute_queue(void)
1298 int retval
=interface_jtag_execute_queue();
1299 if (retval
==ERROR_OK
)
1303 jtag_error
=ERROR_OK
;
1307 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1309 jtag_device_t
*device
= priv
;
1313 if (event
== JTAG_TRST_ASSERTED
)
1315 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1322 void jtag_sleep(u32 us
)
1327 /* Try to examine chain layout according to IEEE 1149.1 §12
1329 int jtag_examine_chain()
1331 jtag_device_t
*device
= jtag_devices
;
1333 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1336 int device_count
= 0;
1337 u8 zero_check
= 0x0;
1338 u8 one_check
= 0xff;
1341 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1342 field
.out_value
= idcode_buffer
;
1343 field
.out_mask
= NULL
;
1344 field
.in_value
= idcode_buffer
;
1345 field
.in_check_value
= NULL
;
1346 field
.in_check_mask
= NULL
;
1347 field
.in_handler
= NULL
;
1348 field
.in_handler_priv
= NULL
;
1350 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1352 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1355 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1356 jtag_execute_queue();
1358 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1360 zero_check
|= idcode_buffer
[i
];
1361 one_check
&= idcode_buffer
[i
];
1364 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1365 if ((zero_check
== 0x00) || (one_check
== 0xff))
1367 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1368 return ERROR_JTAG_INIT_FAILED
;
1371 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1373 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1374 if ((idcode
& 1) == 0)
1376 /* LSB must not be 0, this indicates a device in bypass */
1387 if (idcode
== 0x000000FF)
1389 /* End of chain (invalid manufacturer ID) */
1395 device
->idcode
= idcode
;
1396 device
= device
->next
;
1400 manufacturer
= (idcode
& 0xffe) >> 1;
1401 part
= (idcode
& 0xffff000) >> 12;
1402 version
= (idcode
& 0xf0000000) >> 28;
1404 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1405 idcode
, manufacturer
, part
, version
);
1411 /* see if number of discovered devices matches configuration */
1412 if (device_count
!= jtag_num_devices
)
1414 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1415 device_count
, jtag_num_devices
);
1416 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1417 return ERROR_JTAG_INIT_FAILED
;
1423 int jtag_validate_chain()
1425 jtag_device_t
*device
= jtag_devices
;
1426 int total_ir_length
= 0;
1433 total_ir_length
+= device
->ir_length
;
1434 device
= device
->next
;
1437 total_ir_length
+= 2;
1438 ir_test
= malloc(CEIL(total_ir_length
, 8));
1439 buf_set_ones(ir_test
, total_ir_length
);
1442 field
.num_bits
= total_ir_length
;
1443 field
.out_value
= ir_test
;
1444 field
.out_mask
= NULL
;
1445 field
.in_value
= ir_test
;
1446 field
.in_check_value
= NULL
;
1447 field
.in_check_mask
= NULL
;
1448 field
.in_handler
= NULL
;
1449 field
.in_handler_priv
= NULL
;
1451 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1452 jtag_execute_queue();
1454 device
= jtag_devices
;
1457 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1459 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1460 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1463 return ERROR_JTAG_INIT_FAILED
;
1465 chain_pos
+= device
->ir_length
;
1466 device
= device
->next
;
1469 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1471 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1472 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1475 return ERROR_JTAG_INIT_FAILED
;
1483 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1485 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1486 COMMAND_CONFIG
, NULL
);
1487 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1488 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1489 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1490 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1491 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1492 COMMAND_CONFIG
, NULL
);
1493 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1494 COMMAND_CONFIG
, NULL
);
1495 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1496 COMMAND_CONFIG
, NULL
);
1498 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1499 COMMAND_EXEC
, "print current scan chain configuration");
1501 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1502 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1503 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1504 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1505 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1506 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1507 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1508 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1509 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1510 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1511 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1512 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1514 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1515 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1519 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1521 if (!jtag_interface
)
1523 /* nothing was previously specified by "interface" command */
1524 ERROR("JTAG interface has to be specified, see \"interface\" command");
1525 return ERROR_JTAG_INVALID_INTERFACE
;
1528 if (jtag_interface
->init() != ERROR_OK
)
1529 return ERROR_JTAG_INIT_FAILED
;
1531 jtag
= jtag_interface
;
1535 int jtag_init(struct command_context_s
*cmd_ctx
)
1537 int validate_tries
= 0;
1538 jtag_device_t
*device
;
1542 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1543 return ERROR_JTAG_INIT_FAILED
;
1545 device
= jtag_devices
;
1546 jtag_ir_scan_size
= 0;
1547 jtag_num_devices
= 0;
1548 while (device
!= NULL
)
1550 jtag_ir_scan_size
+= device
->ir_length
;
1552 device
= device
->next
;
1555 jtag_add_statemove(TAP_TLR
);
1556 jtag_execute_queue();
1558 /* examine chain first, as this could discover the real chain layout */
1559 if (jtag_examine_chain() != ERROR_OK
)
1561 ERROR("trying to validate configured JTAG chain anyway...");
1564 while (jtag_validate_chain() != ERROR_OK
)
1567 if (validate_tries
> 5)
1569 ERROR("Could not validate JTAG chain, exit");
1570 return ERROR_JTAG_INVALID_INTERFACE
;
1578 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1582 /* check whether the interface is already configured */
1585 WARNING("Interface already configured, ignoring");
1589 /* interface name is a mandatory argument */
1590 if (argc
< 1 || args
[0][0] == '\0')
1592 return ERROR_COMMAND_SYNTAX_ERROR
;
1595 for (i
=0; jtag_interfaces
[i
]; i
++)
1597 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1599 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1602 jtag_interface
= jtag_interfaces
[i
];
1607 /* no valid interface was found (i.e. the configuration option,
1608 * didn't match one of the compiled-in interfaces
1610 ERROR("No valid jtag interface found (%s)", args
[0]);
1611 ERROR("compiled-in jtag interfaces:");
1612 for (i
= 0; jtag_interfaces
[i
]; i
++)
1614 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1617 return ERROR_JTAG_INVALID_INTERFACE
;
1620 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1622 jtag_device_t
**last_device_p
= &jtag_devices
;
1626 while ((*last_device_p
)->next
)
1627 last_device_p
= &((*last_device_p
)->next
);
1628 last_device_p
= &((*last_device_p
)->next
);
1634 *last_device_p
= malloc(sizeof(jtag_device_t
));
1635 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1637 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1638 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1639 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1640 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1642 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1643 (*last_device_p
)->bypass
= 1;
1644 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1646 (*last_device_p
)->next
= NULL
;
1648 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1655 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1657 jtag_device_t
*device
= jtag_devices
;
1658 int device_count
= 0;
1662 u32 expected
, expected_mask
, cur_instr
;
1663 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1664 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1665 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1666 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
);
1667 device
= device
->next
;
1674 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1678 if (strcmp(args
[0], "none") == 0)
1679 jtag_reset_config
= RESET_NONE
;
1680 else if (strcmp(args
[0], "trst_only") == 0)
1681 jtag_reset_config
= RESET_HAS_TRST
;
1682 else if (strcmp(args
[0], "srst_only") == 0)
1683 jtag_reset_config
= RESET_HAS_SRST
;
1684 else if (strcmp(args
[0], "trst_and_srst") == 0)
1685 jtag_reset_config
= RESET_TRST_AND_SRST
;
1688 ERROR("invalid reset_config argument, defaulting to none");
1689 jtag_reset_config
= RESET_NONE
;
1690 return ERROR_INVALID_ARGUMENTS
;
1696 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1697 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1698 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1699 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1700 else if (strcmp(args
[1], "combined") == 0)
1701 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1702 else if (strcmp(args
[1], "separate") == 0)
1703 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1706 ERROR("invalid reset_config argument, defaulting to none");
1707 jtag_reset_config
= RESET_NONE
;
1708 return ERROR_INVALID_ARGUMENTS
;
1714 if (strcmp(args
[2], "trst_open_drain") == 0)
1715 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1716 else if (strcmp(args
[2], "trst_push_pull") == 0)
1717 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1720 ERROR("invalid reset_config argument, defaulting to none");
1721 jtag_reset_config
= RESET_NONE
;
1722 return ERROR_INVALID_ARGUMENTS
;
1728 if (strcmp(args
[3], "srst_push_pull") == 0)
1729 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1730 else if (strcmp(args
[3], "srst_open_drain") == 0)
1731 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1734 ERROR("invalid reset_config argument, defaulting to none");
1735 jtag_reset_config
= RESET_NONE
;
1736 return ERROR_INVALID_ARGUMENTS
;
1743 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1747 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1752 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1758 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1762 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1767 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1773 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1776 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1780 /* this command can be called during CONFIG,
1781 * in which case jtag isn't initialized */
1783 jtag
->speed(strtoul(args
[0], NULL
, 0));
1785 jtag_speed
= strtoul(args
[0], NULL
, 0);
1791 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1793 enum tap_state state
;
1797 return ERROR_COMMAND_SYNTAX_ERROR
;
1801 for (state
= 0; state
< 16; state
++)
1803 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1805 jtag_add_end_state(state
);
1806 jtag_execute_queue();
1810 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1815 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1823 return ERROR_COMMAND_SYNTAX_ERROR
;
1827 if (args
[0][0] == '1')
1829 else if (args
[0][0] == '0')
1833 return ERROR_COMMAND_SYNTAX_ERROR
;
1836 if (args
[1][0] == '1')
1838 else if (args
[1][0] == '0')
1842 return ERROR_COMMAND_SYNTAX_ERROR
;
1845 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1846 return ERROR_JTAG_INIT_FAILED
;
1848 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1852 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1853 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1855 case ERROR_JTAG_RESET_CANT_SRST
:
1856 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1859 command_print(cmd_ctx
, "unknown error");
1862 jtag_execute_queue();
1867 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1871 return ERROR_COMMAND_SYNTAX_ERROR
;
1874 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1875 jtag_execute_queue();
1881 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1883 enum tap_state state
;
1888 for (state
= 0; state
< 16; state
++)
1890 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1897 jtag_add_statemove(state
);
1898 jtag_execute_queue();
1904 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1907 scan_field_t
*fields
;
1909 if ((argc
< 2) || (argc
% 2))
1911 return ERROR_COMMAND_SYNTAX_ERROR
;
1914 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1916 for (i
= 0; i
< argc
/ 2; i
++)
1918 int device
= strtoul(args
[i
*2], NULL
, 0);
1919 int field_size
= jtag_get_device(device
)->ir_length
;
1920 fields
[i
].device
= device
;
1921 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1922 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1923 fields
[i
].out_mask
= NULL
;
1924 fields
[i
].in_value
= NULL
;
1925 fields
[i
].in_check_mask
= NULL
;
1926 fields
[i
].in_handler
= NULL
;
1927 fields
[i
].in_handler_priv
= NULL
;
1930 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1931 jtag_execute_queue();
1933 for (i
= 0; i
< argc
/ 2; i
++)
1934 free(fields
[i
].out_value
);
1941 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1943 scan_field_t
*fields
;
1945 int field_count
= 0;
1949 if ((argc
< 2) || (argc
% 2))
1951 return ERROR_COMMAND_SYNTAX_ERROR
;
1954 for (i
= 0; i
< argc
; i
+=2)
1956 var
= get_var_by_namenum(args
[i
+1]);
1959 num_fields
+= var
->num_fields
;
1963 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1968 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1970 for (i
= 0; i
< argc
; i
+=2)
1972 var
= get_var_by_namenum(args
[i
+1]);
1974 for (j
= 0; j
< var
->num_fields
; j
++)
1976 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1977 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1978 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1979 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1980 fields
[field_count
].out_mask
= NULL
;
1981 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1982 fields
[field_count
].in_check_mask
= NULL
;
1983 fields
[field_count
].in_check_value
= NULL
;
1984 fields
[field_count
].in_handler
= field_le_to_host
;
1985 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1989 jtag_add_dr_scan(num_fields
, fields
, -1);
1990 jtag_execute_queue();
1992 for (i
= 0; i
< argc
/ 2; i
++)
1993 free(fields
[i
].out_value
);
2000 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2004 if (strcmp(args
[0], "enable") == 0)
2006 jtag_verify_capture_ir
= 1;
2008 else if (strcmp(args
[0], "disable") == 0)
2010 jtag_verify_capture_ir
= 0;
2013 return ERROR_COMMAND_SYNTAX_ERROR
;
2015 } else if (argc
!= 0)
2017 return ERROR_COMMAND_SYNTAX_ERROR
;
2020 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)