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 /* if a device isn't listed, the BYPASS register should be selected */
629 if (!jtag_get_device(i
)->bypass
)
631 ERROR("BUG: no scan data for a device not in BYPASS");
635 /* program the scan field to 1 bit length, and ignore it's value */
636 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
637 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
638 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
639 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
640 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
641 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
642 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
643 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
647 /* if a device is listed, the BYPASS register must not be selected */
648 if (jtag_get_device(i
)->bypass
)
650 WARNING("scan data for a device in BYPASS");
657 void MINIDRIVER(interface_jtag_add_dr_out
)(int device_num
,
661 enum tap_state end_state
)
666 int bypass_devices
= 0;
668 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
669 jtag_device_t
*device
= jtag_devices
;
670 /* count devices in bypass */
675 device
= device
->next
;
678 /* allocate memory for a new list member */
679 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
680 last_comand_pointer
= &((*last_cmd
)->next
);
681 (*last_cmd
)->next
= NULL
;
682 (*last_cmd
)->type
= JTAG_SCAN
;
684 /* allocate memory for dr scan command */
685 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
686 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
687 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
688 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
689 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
691 for (i
= 0; i
< jtag_num_devices
; i
++)
693 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
698 #ifdef _DEBUG_JTAG_IO_
699 /* if a device is listed, the BYPASS register must not be selected */
700 if (jtag_get_device(i
)->bypass
)
702 ERROR("scan data for a device in BYPASS");
706 for (j
= 0; j
< num_fields
; j
++)
709 scan_size
= num_bits
[j
];
710 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
711 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
712 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
713 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
714 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
715 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
716 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
717 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
718 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
722 #ifdef _DEBUG_JTAG_IO_
723 /* if a device isn't listed, the BYPASS register should be selected */
724 if (!jtag_get_device(i
)->bypass
)
726 ERROR("BUG: no scan data for a device not in BYPASS");
730 /* program the scan field to 1 bit length, and ignore it's value */
731 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
732 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
733 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
734 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
735 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
736 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
737 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
738 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
746 int jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
750 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
751 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
755 cmd_queue_end_state
= state
;
757 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
758 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
760 if (cmd_queue_end_state
== TAP_TLR
)
761 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
763 cmd_queue_cur_state
= cmd_queue_end_state
;
765 return interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
768 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
771 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
773 /* allocate memory for a new list member */
774 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
775 last_comand_pointer
= &((*last_cmd
)->next
);
776 (*last_cmd
)->next
= NULL
;
777 (*last_cmd
)->type
= JTAG_SCAN
;
779 /* allocate memory for scan command */
780 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
781 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
782 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
783 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
784 (*last_cmd
)->cmd
.scan
->end_state
= state
;
786 for (i
= 0; i
< num_fields
; i
++)
788 int num_bits
= fields
[i
].num_bits
;
789 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
790 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
791 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
792 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
793 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
794 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
795 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
796 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
797 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
798 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
803 int jtag_add_statemove(enum tap_state state
)
807 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
808 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
812 cmd_queue_end_state
= state
;
814 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
815 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
817 if (cmd_queue_end_state
== TAP_TLR
)
818 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
820 cmd_queue_cur_state
= cmd_queue_end_state
;
822 return interface_jtag_add_statemove(cmd_queue_end_state
);
825 int MINIDRIVER(interface_jtag_add_statemove
)(enum tap_state state
)
827 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
829 /* allocate memory for a new list member */
830 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
831 last_comand_pointer
= &((*last_cmd
)->next
);
832 (*last_cmd
)->next
= NULL
;
833 (*last_cmd
)->type
= JTAG_STATEMOVE
;
835 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
836 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
842 int jtag_add_pathmove(int num_states
, enum tap_state
*path
)
846 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
847 return jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
850 /* the last state has to be a stable state */
851 if (tap_move_map
[path
[num_states
- 1]] == -1)
853 ERROR("TAP path doesn't finish in a stable state");
854 return jtag_error
=ERROR_JTAG_NOT_IMPLEMENTED
;
857 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
858 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
860 if (cmd_queue_end_state
== TAP_TLR
)
861 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
863 cmd_queue_cur_state
= path
[num_states
- 1];
865 return interface_jtag_add_pathmove(num_states
, path
);
869 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
871 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
874 /* allocate memory for a new list member */
875 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
876 last_comand_pointer
= &((*last_cmd
)->next
);
877 (*last_cmd
)->next
= NULL
;
878 (*last_cmd
)->type
= JTAG_PATHMOVE
;
880 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
881 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
882 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
884 for (i
= 0; i
< num_states
; i
++)
885 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
890 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
892 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
894 /* allocate memory for a new list member */
895 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
896 (*last_cmd
)->next
= NULL
;
897 last_comand_pointer
= &((*last_cmd
)->next
);
898 (*last_cmd
)->type
= JTAG_RUNTEST
;
900 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
901 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
902 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
907 int jtag_add_runtest(int num_cycles
, enum tap_state state
)
911 jtag_error
=ERROR_JTAG_QUEUE_FAILED
;
912 WARNING("JTAG command queued, while TRST is low (TAP in reset)");
913 return ERROR_JTAG_TRST_ASSERTED
;
917 cmd_queue_end_state
= state
;
919 if (cmd_queue_cur_state
== TAP_TLR
&& cmd_queue_end_state
!= TAP_TLR
)
920 jtag_call_event_callbacks(JTAG_TRST_RELEASED
);
922 if (cmd_queue_end_state
== TAP_TLR
)
923 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
925 cmd_queue_cur_state
= cmd_queue_end_state
;
927 /* executed by sw or hw fifo */
928 return interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
931 int jtag_add_reset(int req_trst
, int req_srst
)
933 int trst_with_tms
= 0;
937 req_trst
= jtag_trst
;
940 req_srst
= jtag_srst
;
942 /* Make sure that jtag_reset_config allows the requested reset */
943 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
944 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (req_trst
== 0))
946 return jtag_error
=ERROR_JTAG_RESET_WOULD_ASSERT_TRST
;
949 /* if TRST pulls SRST, we reset with TAP T-L-R */
950 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_trst
== 1)) && (req_srst
== 0))
956 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
958 ERROR("requested nSRST assertion, but the current configuration doesn't support this");
959 return jtag_error
=ERROR_JTAG_RESET_CANT_SRST
;
962 if (req_trst
&& !(jtag_reset_config
& RESET_HAS_TRST
))
968 jtag_trst
= req_trst
;
969 jtag_srst
= req_srst
;
971 retval
= interface_jtag_add_reset(req_trst
, req_srst
);
972 if (retval
!=ERROR_OK
)
980 jtag_call_event_callbacks(JTAG_SRST_ASSERTED
);
984 jtag_call_event_callbacks(JTAG_SRST_RELEASED
);
985 if (jtag_nsrst_delay
)
986 jtag_add_sleep(jtag_nsrst_delay
* 1000);
991 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
992 jtag_add_end_state(TAP_TLR
);
993 jtag_add_statemove(TAP_TLR
);
1000 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1001 * and inform possible listeners about this
1003 cmd_queue_cur_state
= TAP_TLR
;
1004 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1008 /* the nTRST line got deasserted, so we're still in Test-Logic-Reset,
1009 * but we might want to add a delay to give the TAP time to settle
1011 if (jtag_ntrst_delay
)
1012 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1019 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1021 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1023 /* allocate memory for a new list member */
1024 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1025 (*last_cmd
)->next
= NULL
;
1026 last_comand_pointer
= &((*last_cmd
)->next
);
1027 (*last_cmd
)->type
= JTAG_RESET
;
1029 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1030 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1031 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1037 int MINIDRIVER(interface_jtag_add_end_state
)(enum tap_state state
)
1039 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1041 /* allocate memory for a new list member */
1042 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1043 (*last_cmd
)->next
= NULL
;
1044 last_comand_pointer
= &((*last_cmd
)->next
);
1045 (*last_cmd
)->type
= JTAG_END_STATE
;
1047 (*last_cmd
)->cmd
.end_state
= cmd_queue_alloc(sizeof(end_state_command_t
));
1048 (*last_cmd
)->cmd
.end_state
->end_state
= state
;
1053 int jtag_add_end_state(enum tap_state state
)
1056 cmd_queue_end_state
= state
;
1057 int retval
= interface_jtag_add_end_state(cmd_queue_end_state
);
1061 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
1063 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1065 /* allocate memory for a new list member */
1066 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1067 (*last_cmd
)->next
= NULL
;
1068 last_comand_pointer
= &((*last_cmd
)->next
);
1069 (*last_cmd
)->type
= JTAG_SLEEP
;
1071 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1072 (*last_cmd
)->cmd
.sleep
->us
= us
;
1077 int jtag_add_sleep(u32 us
)
1079 return interface_jtag_add_sleep(us
);
1082 int jtag_scan_size(scan_command_t
*cmd
)
1087 /* count bits in scan command */
1088 for (i
= 0; i
< cmd
->num_fields
; i
++)
1090 bit_count
+= cmd
->fields
[i
].num_bits
;
1096 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1101 bit_count
= jtag_scan_size(cmd
);
1102 *buffer
= malloc(CEIL(bit_count
, 8));
1106 for (i
= 0; i
< cmd
->num_fields
; i
++)
1108 if (cmd
->fields
[i
].out_value
)
1110 #ifdef _DEBUG_JTAG_IO_
1111 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1113 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1114 #ifdef _DEBUG_JTAG_IO_
1115 DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1120 bit_count
+= cmd
->fields
[i
].num_bits
;
1127 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1133 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1136 for (i
= 0; i
< cmd
->num_fields
; i
++)
1138 /* if neither in_value nor in_handler
1139 * are specified we don't have to examine this field
1141 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1143 int num_bits
= cmd
->fields
[i
].num_bits
;
1144 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1146 #ifdef _DEBUG_JTAG_IO_
1149 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1150 DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1154 if (cmd
->fields
[i
].in_value
)
1156 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1158 if (cmd
->fields
[i
].in_handler
)
1160 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1162 WARNING("in_handler reported a failed check");
1163 retval
= ERROR_JTAG_QUEUE_FAILED
;
1168 /* no in_value specified, but a handler takes care of the scanned data */
1169 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1171 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1173 /* We're going to call the error:handler later, but if the in_handler
1174 * reported an error we report this failure upstream
1176 WARNING("in_handler reported a failed check");
1177 retval
= ERROR_JTAG_QUEUE_FAILED
;
1183 bit_count
+= cmd
->fields
[i
].num_bits
;
1189 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1191 int retval
= ERROR_OK
;
1192 int num_bits
= field
->num_bits
;
1194 int compare_failed
= 0;
1196 if (field
->in_check_mask
)
1197 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1199 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1203 /* An error handler could have caught the failing check
1204 * only report a problem when there wasn't a handler, or if the handler
1205 * acknowledged the error
1209 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1210 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1212 if (field
->in_check_mask
)
1214 char *in_check_mask_char
;
1215 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1216 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
);
1217 free(in_check_mask_char
);
1221 WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1224 free(captured_char
);
1225 free(in_check_value_char
);
1227 retval
= ERROR_JTAG_QUEUE_FAILED
;
1235 set up checking of this field using the in_handler. The values passed in must be valid until
1236 after jtag_execute() has completed.
1238 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1241 field
->in_handler
= jtag_check_value
;
1243 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1244 field
->in_handler_priv
= NULL
; /* this will be filled in at the invocation site to point to the field duplicate */
1245 field
->in_check_value
= value
;
1246 field
->in_check_mask
= mask
;
1249 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1254 for (i
= 0; i
< cmd
->num_fields
; i
++)
1256 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1258 if (cmd
->fields
[i
].out_value
)
1265 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1269 retval
= jtag
->execute_queue();
1273 jtag_command_queue
= NULL
;
1274 last_comand_pointer
= &jtag_command_queue
;
1279 int jtag_execute_queue(void)
1281 int retval
=interface_jtag_execute_queue();
1282 if (retval
==ERROR_OK
)
1286 jtag_error
=ERROR_OK
;
1290 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1292 jtag_device_t
*device
= priv
;
1296 if (event
== JTAG_TRST_ASSERTED
)
1298 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1305 void jtag_sleep(u32 us
)
1310 /* Try to examine chain layout according to IEEE 1149.1 §12
1312 int jtag_examine_chain()
1314 jtag_device_t
*device
= jtag_devices
;
1316 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1319 int device_count
= 0;
1320 u8 zero_check
= 0x0;
1321 u8 one_check
= 0xff;
1324 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1325 field
.out_value
= idcode_buffer
;
1326 field
.out_mask
= NULL
;
1327 field
.in_value
= idcode_buffer
;
1328 field
.in_check_value
= NULL
;
1329 field
.in_check_mask
= NULL
;
1330 field
.in_handler
= NULL
;
1331 field
.in_handler_priv
= NULL
;
1333 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1335 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1338 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1339 jtag_execute_queue();
1341 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1343 zero_check
|= idcode_buffer
[i
];
1344 one_check
&= idcode_buffer
[i
];
1347 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1348 if ((zero_check
== 0x00) || (one_check
== 0xff))
1350 ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1351 return ERROR_JTAG_INIT_FAILED
;
1354 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1356 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1357 if ((idcode
& 1) == 0)
1359 /* LSB must not be 0, this indicates a device in bypass */
1370 if (idcode
== 0x000000FF)
1372 /* End of chain (invalid manufacturer ID) */
1378 device
->idcode
= idcode
;
1379 device
= device
->next
;
1383 manufacturer
= (idcode
& 0xffe) >> 1;
1384 part
= (idcode
& 0xffff000) >> 12;
1385 version
= (idcode
& 0xf0000000) >> 28;
1387 INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1388 idcode
, manufacturer
, part
, version
);
1394 /* see if number of discovered devices matches configuration */
1395 if (device_count
!= jtag_num_devices
)
1397 ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1398 device_count
, jtag_num_devices
);
1399 ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1400 return ERROR_JTAG_INIT_FAILED
;
1406 int jtag_validate_chain()
1408 jtag_device_t
*device
= jtag_devices
;
1409 int total_ir_length
= 0;
1416 total_ir_length
+= device
->ir_length
;
1417 device
= device
->next
;
1420 total_ir_length
+= 2;
1421 ir_test
= malloc(CEIL(total_ir_length
, 8));
1422 buf_set_ones(ir_test
, total_ir_length
);
1425 field
.num_bits
= total_ir_length
;
1426 field
.out_value
= ir_test
;
1427 field
.out_mask
= NULL
;
1428 field
.in_value
= ir_test
;
1429 field
.in_check_value
= NULL
;
1430 field
.in_check_mask
= NULL
;
1431 field
.in_handler
= NULL
;
1432 field
.in_handler_priv
= NULL
;
1434 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1435 jtag_execute_queue();
1437 device
= jtag_devices
;
1440 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1442 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1443 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1446 return ERROR_JTAG_INIT_FAILED
;
1448 chain_pos
+= device
->ir_length
;
1449 device
= device
->next
;
1452 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1454 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1455 ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1458 return ERROR_JTAG_INIT_FAILED
;
1466 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1468 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1469 COMMAND_CONFIG
, NULL
);
1470 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1471 COMMAND_ANY
, "set jtag speed (if supported) <speed>");
1472 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1473 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1474 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1475 COMMAND_CONFIG
, NULL
);
1476 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1477 COMMAND_CONFIG
, NULL
);
1478 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1479 COMMAND_CONFIG
, NULL
);
1481 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1482 COMMAND_EXEC
, "print current scan chain configuration");
1484 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1485 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1486 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1487 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1488 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1489 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1490 register_command(cmd_ctx
, NULL
, "statemove", handle_statemove_command
,
1491 COMMAND_EXEC
, "move to current endstate or [tap_state]");
1492 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1493 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1494 register_command(cmd_ctx
, NULL
, "drscan", handle_drscan_command
,
1495 COMMAND_EXEC
, "execute DR scan <device> <var> [dev2] [var2] ...");
1497 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1498 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1502 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1504 if (!jtag_interface
)
1506 /* nothing was previously specified by "interface" command */
1507 ERROR("JTAG interface has to be specified, see \"interface\" command");
1508 return ERROR_JTAG_INVALID_INTERFACE
;
1511 if (jtag_interface
->init() != ERROR_OK
)
1512 return ERROR_JTAG_INIT_FAILED
;
1514 jtag
= jtag_interface
;
1518 int jtag_init(struct command_context_s
*cmd_ctx
)
1520 int validate_tries
= 0;
1521 jtag_device_t
*device
;
1525 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1526 return ERROR_JTAG_INIT_FAILED
;
1528 device
= jtag_devices
;
1529 jtag_ir_scan_size
= 0;
1530 jtag_num_devices
= 0;
1531 while (device
!= NULL
)
1533 jtag_ir_scan_size
+= device
->ir_length
;
1535 device
= device
->next
;
1538 jtag_add_statemove(TAP_TLR
);
1539 jtag_execute_queue();
1541 /* examine chain first, as this could discover the real chain layout */
1542 if (jtag_examine_chain() != ERROR_OK
)
1544 ERROR("trying to validate configured JTAG chain anyway...");
1547 while (jtag_validate_chain() != ERROR_OK
)
1550 if (validate_tries
> 5)
1552 ERROR("Could not validate JTAG chain, exit");
1553 return ERROR_JTAG_INVALID_INTERFACE
;
1561 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1565 /* check whether the interface is already configured */
1568 WARNING("Interface already configured, ignoring");
1572 /* interface name is a mandatory argument */
1573 if (argc
< 1 || args
[0][0] == '\0')
1575 return ERROR_COMMAND_SYNTAX_ERROR
;
1578 for (i
=0; jtag_interfaces
[i
]; i
++)
1580 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1582 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1585 jtag_interface
= jtag_interfaces
[i
];
1590 /* no valid interface was found (i.e. the configuration option,
1591 * didn't match one of the compiled-in interfaces
1593 ERROR("No valid jtag interface found (%s)", args
[0]);
1594 ERROR("compiled-in jtag interfaces:");
1595 for (i
= 0; jtag_interfaces
[i
]; i
++)
1597 ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1600 return ERROR_JTAG_INVALID_INTERFACE
;
1603 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1605 jtag_device_t
**last_device_p
= &jtag_devices
;
1609 while ((*last_device_p
)->next
)
1610 last_device_p
= &((*last_device_p
)->next
);
1611 last_device_p
= &((*last_device_p
)->next
);
1617 *last_device_p
= malloc(sizeof(jtag_device_t
));
1618 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1620 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1621 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1622 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1623 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1625 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1626 (*last_device_p
)->bypass
= 1;
1627 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1629 (*last_device_p
)->next
= NULL
;
1631 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1638 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1640 jtag_device_t
*device
= jtag_devices
;
1641 int device_count
= 0;
1645 u32 expected
, expected_mask
, cur_instr
;
1646 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1647 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1648 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1649 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
);
1650 device
= device
->next
;
1657 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1661 if (strcmp(args
[0], "none") == 0)
1662 jtag_reset_config
= RESET_NONE
;
1663 else if (strcmp(args
[0], "trst_only") == 0)
1664 jtag_reset_config
= RESET_HAS_TRST
;
1665 else if (strcmp(args
[0], "srst_only") == 0)
1666 jtag_reset_config
= RESET_HAS_SRST
;
1667 else if (strcmp(args
[0], "trst_and_srst") == 0)
1668 jtag_reset_config
= RESET_TRST_AND_SRST
;
1671 ERROR("invalid reset_config argument, defaulting to none");
1672 jtag_reset_config
= RESET_NONE
;
1673 return ERROR_INVALID_ARGUMENTS
;
1679 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1680 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1681 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1682 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1683 else if (strcmp(args
[1], "combined") == 0)
1684 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1685 else if (strcmp(args
[1], "separate") == 0)
1686 jtag_reset_config
&= ~(RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
);
1689 ERROR("invalid reset_config argument, defaulting to none");
1690 jtag_reset_config
= RESET_NONE
;
1691 return ERROR_INVALID_ARGUMENTS
;
1697 if (strcmp(args
[2], "trst_open_drain") == 0)
1698 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1699 else if (strcmp(args
[2], "trst_push_pull") == 0)
1700 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1703 ERROR("invalid reset_config argument, defaulting to none");
1704 jtag_reset_config
= RESET_NONE
;
1705 return ERROR_INVALID_ARGUMENTS
;
1711 if (strcmp(args
[3], "srst_push_pull") == 0)
1712 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1713 else if (strcmp(args
[3], "srst_open_drain") == 0)
1714 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1717 ERROR("invalid reset_config argument, defaulting to none");
1718 jtag_reset_config
= RESET_NONE
;
1719 return ERROR_INVALID_ARGUMENTS
;
1726 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1730 ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1735 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1741 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1745 ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1750 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1756 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1759 command_print(cmd_ctx
, "jtag_speed: %i", jtag_speed
);
1763 /* this command can be called during CONFIG,
1764 * in which case jtag isn't initialized */
1766 jtag
->speed(strtoul(args
[0], NULL
, 0));
1768 jtag_speed
= strtoul(args
[0], NULL
, 0);
1774 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1776 enum tap_state state
;
1780 return ERROR_COMMAND_SYNTAX_ERROR
;
1784 for (state
= 0; state
< 16; state
++)
1786 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1788 jtag_add_end_state(state
);
1789 jtag_execute_queue();
1793 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[end_state
]);
1798 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1806 return ERROR_COMMAND_SYNTAX_ERROR
;
1810 if (args
[0][0] == '1')
1812 else if (args
[0][0] == '0')
1816 return ERROR_COMMAND_SYNTAX_ERROR
;
1819 if (args
[1][0] == '1')
1821 else if (args
[1][0] == '0')
1825 return ERROR_COMMAND_SYNTAX_ERROR
;
1828 if (!jtag
&& jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1829 return ERROR_JTAG_INIT_FAILED
;
1831 if ((retval
= jtag_add_reset(trst
, srst
)) != ERROR_OK
)
1835 case ERROR_JTAG_RESET_WOULD_ASSERT_TRST
:
1836 command_print(cmd_ctx
, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args
[1][0]);
1838 case ERROR_JTAG_RESET_CANT_SRST
:
1839 command_print(cmd_ctx
, "can't assert srst because the current reset_config doesn't support it");
1842 command_print(cmd_ctx
, "unknown error");
1845 jtag_execute_queue();
1850 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1854 return ERROR_COMMAND_SYNTAX_ERROR
;
1857 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
1858 jtag_execute_queue();
1864 int handle_statemove_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1866 enum tap_state state
;
1871 for (state
= 0; state
< 16; state
++)
1873 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1880 jtag_add_statemove(state
);
1881 jtag_execute_queue();
1887 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1890 scan_field_t
*fields
;
1892 if ((argc
< 2) || (argc
% 2))
1894 return ERROR_COMMAND_SYNTAX_ERROR
;
1897 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
1899 for (i
= 0; i
< argc
/ 2; i
++)
1901 int device
= strtoul(args
[i
*2], NULL
, 0);
1902 int field_size
= jtag_get_device(device
)->ir_length
;
1903 fields
[i
].device
= device
;
1904 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1905 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
1906 fields
[i
].out_mask
= NULL
;
1907 fields
[i
].in_value
= NULL
;
1908 fields
[i
].in_check_mask
= NULL
;
1909 fields
[i
].in_handler
= NULL
;
1910 fields
[i
].in_handler_priv
= NULL
;
1913 jtag_add_ir_scan(argc
/ 2, fields
, -1);
1914 jtag_execute_queue();
1916 for (i
= 0; i
< argc
/ 2; i
++)
1917 free(fields
[i
].out_value
);
1924 int handle_drscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1926 scan_field_t
*fields
;
1928 int field_count
= 0;
1932 if ((argc
< 2) || (argc
% 2))
1934 return ERROR_COMMAND_SYNTAX_ERROR
;
1937 for (i
= 0; i
< argc
; i
+=2)
1939 var
= get_var_by_namenum(args
[i
+1]);
1942 num_fields
+= var
->num_fields
;
1946 command_print(cmd_ctx
, "variable %s doesn't exist", args
[i
+1]);
1951 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1953 for (i
= 0; i
< argc
; i
+=2)
1955 var
= get_var_by_namenum(args
[i
+1]);
1957 for (j
= 0; j
< var
->num_fields
; j
++)
1959 fields
[field_count
].device
= strtol(args
[i
], NULL
, 0);
1960 fields
[field_count
].num_bits
= var
->fields
[j
].num_bits
;
1961 fields
[field_count
].out_value
= malloc(CEIL(var
->fields
[j
].num_bits
, 8));
1962 buf_set_u32(fields
[field_count
].out_value
, 0, var
->fields
[j
].num_bits
, var
->fields
[j
].value
);
1963 fields
[field_count
].out_mask
= NULL
;
1964 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1965 fields
[field_count
].in_check_mask
= NULL
;
1966 fields
[field_count
].in_check_value
= NULL
;
1967 fields
[field_count
].in_handler
= field_le_to_host
;
1968 fields
[field_count
++].in_handler_priv
= &(var
->fields
[j
]);
1972 jtag_add_dr_scan(num_fields
, fields
, -1);
1973 jtag_execute_queue();
1975 for (i
= 0; i
< argc
/ 2; i
++)
1976 free(fields
[i
].out_value
);
1983 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1987 if (strcmp(args
[0], "enable") == 0)
1989 jtag_verify_capture_ir
= 1;
1991 else if (strcmp(args
[0], "disable") == 0)
1993 jtag_verify_capture_ir
= 0;
1996 return ERROR_COMMAND_SYNTAX_ERROR
;
1998 } else if (argc
!= 0)
2000 return ERROR_COMMAND_SYNTAX_ERROR
;
2003 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)