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"
35 #include "openocd_tcl.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
[] =
110 "JTAG controller reset (TLR or TRST)"
113 /* kludge!!!! these are just global variables that the
114 * interface use internally. They really belong
115 * inside the drivers, but we don't want to break
116 * linking the drivers!!!!
118 enum tap_state end_state
= TAP_TLR
;
119 enum tap_state cur_state
= TAP_TLR
;
123 jtag_command_t
*jtag_command_queue
= NULL
;
124 jtag_command_t
**last_comand_pointer
= &jtag_command_queue
;
125 jtag_device_t
*jtag_devices
= NULL
;
126 int jtag_num_devices
= 0;
127 int jtag_ir_scan_size
= 0;
128 enum reset_types jtag_reset_config
= RESET_NONE
;
129 enum tap_state cmd_queue_end_state
= TAP_TLR
;
130 enum tap_state cmd_queue_cur_state
= TAP_TLR
;
132 int jtag_verify_capture_ir
= 1;
134 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
135 int jtag_nsrst_delay
= 0; /* default to no nSRST delay */
136 int jtag_ntrst_delay
= 0; /* default to no nTRST delay */
138 /* maximum number of JTAG devices expected in the chain
140 #define JTAG_MAX_CHAIN_SIZE 20
142 /* callbacks to inform high-level handlers about JTAG state changes */
143 jtag_event_callback_t
*jtag_event_callbacks
;
146 static int speed1
= 0, speed2
= 0;
147 /* flag if the kHz speed was defined */
148 static int hasKHz
= 0;
150 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
153 #if BUILD_ECOSBOARD == 1
154 extern jtag_interface_t eCosBoard_interface
;
157 #if BUILD_PARPORT == 1
158 extern jtag_interface_t parport_interface
;
162 extern jtag_interface_t dummy_interface
;
165 #if BUILD_FT2232_FTD2XX == 1
166 extern jtag_interface_t ft2232_interface
;
169 #if BUILD_FT2232_LIBFTDI == 1
170 extern jtag_interface_t ft2232_interface
;
173 #if BUILD_AMTJTAGACCEL == 1
174 extern jtag_interface_t amt_jtagaccel_interface
;
177 #if BUILD_EP93XX == 1
178 extern jtag_interface_t ep93xx_interface
;
181 #if BUILD_AT91RM9200 == 1
182 extern jtag_interface_t at91rm9200_interface
;
185 #if BUILD_GW16012 == 1
186 extern jtag_interface_t gw16012_interface
;
189 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
190 extern jtag_interface_t presto_interface
;
193 #if BUILD_USBPROG == 1
194 extern jtag_interface_t usbprog_interface
;
198 extern jtag_interface_t jlink_interface
;
201 jtag_interface_t
*jtag_interfaces
[] = {
202 #if BUILD_ECOSBOARD == 1
203 &eCosBoard_interface
,
205 #if BUILD_PARPORT == 1
211 #if BUILD_FT2232_FTD2XX == 1
214 #if BUILD_FT2232_LIBFTDI == 1
217 #if BUILD_AMTJTAGACCEL == 1
218 &amt_jtagaccel_interface
,
220 #if BUILD_EP93XX == 1
223 #if BUILD_AT91RM9200 == 1
224 &at91rm9200_interface
,
226 #if BUILD_GW16012 == 1
229 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
232 #if BUILD_USBPROG == 1
241 jtag_interface_t
*jtag
= NULL
;
244 jtag_interface_t
*jtag_interface
= NULL
;
246 int jtag_speed_post_reset
= 0;
249 /* forward declarations */
250 void jtag_add_pathmove(int num_states
, enum tap_state
*path
);
251 void jtag_add_runtest(int num_cycles
, enum tap_state endstate
);
252 void jtag_add_end_state(enum tap_state endstate
);
253 void jtag_add_sleep(u32 us
);
254 int jtag_execute_queue(void);
255 int jtag_cancel_queue(void);
258 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
259 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
260 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
261 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
262 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
263 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
264 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
266 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
268 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
269 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
270 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
271 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
272 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
274 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
276 int jtag_register_event_callback(int (*callback
)(enum jtag_event event
, void *priv
), void *priv
)
278 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
280 if (callback
== NULL
)
282 return ERROR_INVALID_ARGUMENTS
;
287 while ((*callbacks_p
)->next
)
288 callbacks_p
= &((*callbacks_p
)->next
);
289 callbacks_p
= &((*callbacks_p
)->next
);
292 (*callbacks_p
) = malloc(sizeof(jtag_event_callback_t
));
293 (*callbacks_p
)->callback
= callback
;
294 (*callbacks_p
)->priv
= priv
;
295 (*callbacks_p
)->next
= NULL
;
300 int jtag_unregister_event_callback(int (*callback
)(enum jtag_event event
, void *priv
))
302 jtag_event_callback_t
**callbacks_p
= &jtag_event_callbacks
;
304 if (callback
== NULL
)
306 return ERROR_INVALID_ARGUMENTS
;
311 jtag_event_callback_t
**next
= &((*callbacks_p
)->next
);
312 if ((*callbacks_p
)->callback
== callback
)
315 *callbacks_p
= *next
;
323 int jtag_call_event_callbacks(enum jtag_event event
)
325 jtag_event_callback_t
*callback
= jtag_event_callbacks
;
327 LOG_DEBUG("jtag event: %s", jtag_event_strings
[event
]);
331 callback
->callback(event
, callback
->priv
);
332 callback
= callback
->next
;
338 /* returns a pointer to the pointer of the last command in queue
339 * this may be a pointer to the root pointer (jtag_command_queue)
340 * or to the next member of the last but one command
342 jtag_command_t
** jtag_get_last_command_p(void)
344 /* jtag_command_t *cmd = jtag_command_queue;
350 return &jtag_command_queue;
354 return last_comand_pointer
;
357 /* returns a pointer to the n-th device in the scan chain */
358 jtag_device_t
* jtag_get_device(int num
)
360 jtag_device_t
*device
= jtag_devices
;
367 device
= device
->next
;
371 LOG_ERROR("jtag device number %d not defined", num
);
375 void* cmd_queue_alloc(size_t size
)
377 cmd_queue_page_t
**p_page
= &cmd_queue_pages
;
383 while ((*p_page
)->next
)
384 p_page
= &((*p_page
)->next
);
385 if (CMD_QUEUE_PAGE_SIZE
- (*p_page
)->used
< size
)
386 p_page
= &((*p_page
)->next
);
391 *p_page
= malloc(sizeof(cmd_queue_page_t
));
393 (*p_page
)->address
= malloc(CMD_QUEUE_PAGE_SIZE
);
394 (*p_page
)->next
= NULL
;
397 offset
= (*p_page
)->used
;
398 (*p_page
)->used
+= size
;
400 t
=(u8
*)((*p_page
)->address
);
404 void cmd_queue_free()
406 cmd_queue_page_t
*page
= cmd_queue_pages
;
410 cmd_queue_page_t
*last
= page
;
416 cmd_queue_pages
= NULL
;
419 static void jtag_prelude1()
423 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
424 jtag_error
=ERROR_JTAG_TRST_ASSERTED
;
428 if (cmd_queue_end_state
== TAP_TLR
)
429 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
432 static void jtag_prelude(enum tap_state state
)
437 jtag_add_end_state(state
);
439 cmd_queue_cur_state
= cmd_queue_end_state
;
442 void jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
448 retval
=interface_jtag_add_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
449 if (retval
!=ERROR_OK
)
453 int MINIDRIVER(interface_jtag_add_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
455 jtag_command_t
**last_cmd
;
456 jtag_device_t
*device
;
461 last_cmd
= jtag_get_last_command_p();
463 /* allocate memory for a new list member */
464 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
465 (*last_cmd
)->next
= NULL
;
466 last_comand_pointer
= &((*last_cmd
)->next
);
467 (*last_cmd
)->type
= JTAG_SCAN
;
469 /* allocate memory for ir scan command */
470 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
471 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
472 (*last_cmd
)->cmd
.scan
->num_fields
= jtag_num_devices
; /* one field per device */
473 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(jtag_num_devices
* sizeof(scan_field_t
));
474 (*last_cmd
)->cmd
.scan
->end_state
= state
;
476 for (i
= 0; i
< jtag_num_devices
; i
++)
479 device
= jtag_get_device(i
);
480 scan_size
= device
->ir_length
;
481 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= i
;
482 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= scan_size
;
483 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= NULL
;
484 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
; /* disable verification by default */
486 /* search the list */
487 for (j
= 0; j
< num_fields
; j
++)
489 if (i
== fields
[j
].device
)
492 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
493 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
495 if (jtag_verify_capture_ir
)
497 if (fields
[j
].in_handler
==NULL
)
499 jtag_set_check_value((*last_cmd
)->cmd
.scan
->fields
+i
, device
->expected
, device
->expected_mask
, NULL
);
502 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[j
].in_handler
;
503 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[j
].in_handler_priv
;
504 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= device
->expected
;
505 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= device
->expected_mask
;
516 /* if a device isn't listed, set it to BYPASS */
517 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_set_ones(cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
518 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= NULL
;
523 /* update device information */
524 buf_cpy((*last_cmd
)->cmd
.scan
->fields
[i
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
530 void jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
536 retval
=interface_jtag_add_plain_ir_scan(num_fields
, fields
, cmd_queue_end_state
);
537 if (retval
!=ERROR_OK
)
541 int MINIDRIVER(interface_jtag_add_plain_ir_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
544 jtag_command_t
**last_cmd
;
546 last_cmd
= jtag_get_last_command_p();
548 /* allocate memory for a new list member */
549 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
550 (*last_cmd
)->next
= NULL
;
551 last_comand_pointer
= &((*last_cmd
)->next
);
552 (*last_cmd
)->type
= JTAG_SCAN
;
554 /* allocate memory for ir scan command */
555 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
556 (*last_cmd
)->cmd
.scan
->ir_scan
= 1;
557 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
558 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
559 (*last_cmd
)->cmd
.scan
->end_state
= state
;
561 for (i
= 0; i
< num_fields
; i
++)
563 int num_bits
= fields
[i
].num_bits
;
564 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
565 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
566 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
567 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
568 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
569 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
570 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
571 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
572 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= NULL
;
573 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= NULL
;
578 void jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
584 retval
=interface_jtag_add_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
585 if (retval
!=ERROR_OK
)
589 int MINIDRIVER(interface_jtag_add_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
592 int bypass_devices
= 0;
596 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
597 jtag_device_t
*device
= jtag_devices
;
599 /* count devices in bypass */
604 device
= device
->next
;
607 /* allocate memory for a new list member */
608 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
609 last_comand_pointer
= &((*last_cmd
)->next
);
610 (*last_cmd
)->next
= NULL
;
611 (*last_cmd
)->type
= JTAG_SCAN
;
613 /* allocate memory for dr scan command */
614 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
615 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
616 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
617 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
618 (*last_cmd
)->cmd
.scan
->end_state
= state
;
620 for (i
= 0; i
< jtag_num_devices
; i
++)
623 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
625 for (j
= 0; j
< num_fields
; j
++)
627 if (i
== fields
[j
].device
)
630 scan_size
= fields
[j
].num_bits
;
631 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
632 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(fields
[j
].out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
633 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= buf_cpy(fields
[j
].out_mask
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
634 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= fields
[j
].in_value
;
635 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= fields
[j
].in_check_value
;
636 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= fields
[j
].in_check_mask
;
637 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= fields
[j
].in_handler
;
638 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= fields
[j
].in_handler_priv
;
643 #ifdef _DEBUG_JTAG_IO_
644 /* if a device isn't listed, the BYPASS register should be selected */
645 if (!jtag_get_device(i
)->bypass
)
647 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
651 /* program the scan field to 1 bit length, and ignore it's value */
652 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
653 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
654 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
655 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
656 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
657 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
658 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
659 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
663 #ifdef _DEBUG_JTAG_IO_
664 /* if a device is listed, the BYPASS register must not be selected */
665 if (jtag_get_device(i
)->bypass
)
667 LOG_ERROR("BUG: scan data for a device in BYPASS");
676 void MINIDRIVER(interface_jtag_add_dr_out
)(int device_num
,
680 enum tap_state end_state
)
685 int bypass_devices
= 0;
687 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
688 jtag_device_t
*device
= jtag_devices
;
689 /* count devices in bypass */
694 device
= device
->next
;
697 /* allocate memory for a new list member */
698 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
699 last_comand_pointer
= &((*last_cmd
)->next
);
700 (*last_cmd
)->next
= NULL
;
701 (*last_cmd
)->type
= JTAG_SCAN
;
703 /* allocate memory for dr scan command */
704 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
705 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
706 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
+ bypass_devices
;
707 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc((num_fields
+ bypass_devices
) * sizeof(scan_field_t
));
708 (*last_cmd
)->cmd
.scan
->end_state
= end_state
;
710 for (i
= 0; i
< jtag_num_devices
; i
++)
712 (*last_cmd
)->cmd
.scan
->fields
[field_count
].device
= i
;
717 #ifdef _DEBUG_JTAG_IO_
718 /* if a device is listed, the BYPASS register must not be selected */
719 if (jtag_get_device(i
)->bypass
)
721 LOG_ERROR("BUG: scan data for a device in BYPASS");
725 for (j
= 0; j
< num_fields
; j
++)
728 scan_size
= num_bits
[j
];
729 buf_set_u32(out_value
, 0, scan_size
, value
[j
]);
730 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= scan_size
;
731 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= buf_cpy(out_value
, cmd_queue_alloc(CEIL(scan_size
, 8)), scan_size
);
732 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
733 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
734 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
735 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
736 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
737 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
741 #ifdef _DEBUG_JTAG_IO_
742 /* if a device isn't listed, the BYPASS register should be selected */
743 if (!jtag_get_device(i
)->bypass
)
745 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
749 /* program the scan field to 1 bit length, and ignore it's value */
750 (*last_cmd
)->cmd
.scan
->fields
[field_count
].num_bits
= 1;
751 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_value
= NULL
;
752 (*last_cmd
)->cmd
.scan
->fields
[field_count
].out_mask
= NULL
;
753 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_value
= NULL
;
754 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_value
= NULL
;
755 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_check_mask
= NULL
;
756 (*last_cmd
)->cmd
.scan
->fields
[field_count
].in_handler
= NULL
;
757 (*last_cmd
)->cmd
.scan
->fields
[field_count
++].in_handler_priv
= NULL
;
765 void jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
771 retval
=interface_jtag_add_plain_dr_scan(num_fields
, fields
, cmd_queue_end_state
);
772 if (retval
!=ERROR_OK
)
776 int MINIDRIVER(interface_jtag_add_plain_dr_scan
)(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
779 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
781 /* allocate memory for a new list member */
782 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
783 last_comand_pointer
= &((*last_cmd
)->next
);
784 (*last_cmd
)->next
= NULL
;
785 (*last_cmd
)->type
= JTAG_SCAN
;
787 /* allocate memory for scan command */
788 (*last_cmd
)->cmd
.scan
= cmd_queue_alloc(sizeof(scan_command_t
));
789 (*last_cmd
)->cmd
.scan
->ir_scan
= 0;
790 (*last_cmd
)->cmd
.scan
->num_fields
= num_fields
;
791 (*last_cmd
)->cmd
.scan
->fields
= cmd_queue_alloc(num_fields
* sizeof(scan_field_t
));
792 (*last_cmd
)->cmd
.scan
->end_state
= state
;
794 for (i
= 0; i
< num_fields
; i
++)
796 int num_bits
= fields
[i
].num_bits
;
797 int num_bytes
= CEIL(fields
[i
].num_bits
, 8);
798 (*last_cmd
)->cmd
.scan
->fields
[i
].device
= fields
[i
].device
;
799 (*last_cmd
)->cmd
.scan
->fields
[i
].num_bits
= num_bits
;
800 (*last_cmd
)->cmd
.scan
->fields
[i
].out_value
= buf_cpy(fields
[i
].out_value
, cmd_queue_alloc(num_bytes
), num_bits
);
801 (*last_cmd
)->cmd
.scan
->fields
[i
].out_mask
= buf_cpy(fields
[i
].out_mask
, cmd_queue_alloc(num_bytes
), num_bits
);
802 (*last_cmd
)->cmd
.scan
->fields
[i
].in_value
= fields
[i
].in_value
;
803 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_value
= fields
[i
].in_check_value
;
804 (*last_cmd
)->cmd
.scan
->fields
[i
].in_check_mask
= fields
[i
].in_check_mask
;
805 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler
= fields
[i
].in_handler
;
806 (*last_cmd
)->cmd
.scan
->fields
[i
].in_handler_priv
= fields
[i
].in_handler_priv
;
814 jtag_prelude(TAP_TLR
);
817 retval
=interface_jtag_add_tlr();
818 if (retval
!=ERROR_OK
)
822 int MINIDRIVER(interface_jtag_add_tlr
)()
824 enum tap_state state
= TAP_TLR
;
825 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
827 /* allocate memory for a new list member */
828 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
829 last_comand_pointer
= &((*last_cmd
)->next
);
830 (*last_cmd
)->next
= NULL
;
831 (*last_cmd
)->type
= JTAG_STATEMOVE
;
833 (*last_cmd
)->cmd
.statemove
= cmd_queue_alloc(sizeof(statemove_command_t
));
834 (*last_cmd
)->cmd
.statemove
->end_state
= state
;
840 void jtag_add_pathmove(int num_states
, enum tap_state
*path
)
842 enum tap_state cur_state
=cmd_queue_cur_state
;
846 /* the last state has to be a stable state */
847 if (tap_move_map
[path
[num_states
- 1]] == -1)
849 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
853 for (i
=0; i
<num_states
; i
++)
855 if ((tap_transitions
[cur_state
].low
!= path
[i
])&&
856 (tap_transitions
[cur_state
].high
!= path
[i
]))
858 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[i
]]);
866 cmd_queue_cur_state
= path
[num_states
- 1];
868 retval
=interface_jtag_add_pathmove(num_states
, path
);
869 if (retval
!=ERROR_OK
)
874 int MINIDRIVER(interface_jtag_add_pathmove
)(int num_states
, enum tap_state
*path
)
876 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
879 /* allocate memory for a new list member */
880 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
881 last_comand_pointer
= &((*last_cmd
)->next
);
882 (*last_cmd
)->next
= NULL
;
883 (*last_cmd
)->type
= JTAG_PATHMOVE
;
885 (*last_cmd
)->cmd
.pathmove
= cmd_queue_alloc(sizeof(pathmove_command_t
));
886 (*last_cmd
)->cmd
.pathmove
->num_states
= num_states
;
887 (*last_cmd
)->cmd
.pathmove
->path
= cmd_queue_alloc(sizeof(enum tap_state
) * num_states
);
889 for (i
= 0; i
< num_states
; i
++)
890 (*last_cmd
)->cmd
.pathmove
->path
[i
] = path
[i
];
895 int MINIDRIVER(interface_jtag_add_runtest
)(int num_cycles
, enum tap_state state
)
897 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
899 /* allocate memory for a new list member */
900 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
901 (*last_cmd
)->next
= NULL
;
902 last_comand_pointer
= &((*last_cmd
)->next
);
903 (*last_cmd
)->type
= JTAG_RUNTEST
;
905 (*last_cmd
)->cmd
.runtest
= cmd_queue_alloc(sizeof(runtest_command_t
));
906 (*last_cmd
)->cmd
.runtest
->num_cycles
= num_cycles
;
907 (*last_cmd
)->cmd
.runtest
->end_state
= state
;
912 void jtag_add_runtest(int num_cycles
, enum tap_state state
)
918 /* executed by sw or hw fifo */
919 retval
=interface_jtag_add_runtest(num_cycles
, cmd_queue_end_state
);
920 if (retval
!=ERROR_OK
)
924 void jtag_add_reset(int req_tlr_or_trst
, int req_srst
)
926 int trst_with_tlr
= 0;
929 /* FIX!!! there are *many* different cases here. A better
930 * approach is needed for legal combinations of transitions...
932 if ((jtag_reset_config
& RESET_HAS_SRST
)&&
933 (jtag_reset_config
& RESET_HAS_TRST
)&&
934 ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0))
936 if (((req_tlr_or_trst
&&!jtag_trst
)||
937 (!req_tlr_or_trst
&&jtag_trst
))&&
938 ((req_srst
&&!jtag_srst
)||
939 (!req_srst
&&jtag_srst
)))
941 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
942 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
946 /* Make sure that jtag_reset_config allows the requested reset */
947 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
948 if (((jtag_reset_config
& RESET_SRST_PULLS_TRST
) && (req_srst
== 1)) && (!req_tlr_or_trst
))
950 LOG_ERROR("BUG: requested reset would assert trst");
951 jtag_error
=ERROR_FAIL
;
955 /* if TRST pulls SRST, we reset with TAP T-L-R */
956 if (((jtag_reset_config
& RESET_TRST_PULLS_SRST
) && (req_tlr_or_trst
)) && (req_srst
== 0))
961 if (req_srst
&& !(jtag_reset_config
& RESET_HAS_SRST
))
963 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
964 jtag_error
=ERROR_FAIL
;
970 if (!trst_with_tlr
&& (jtag_reset_config
& RESET_HAS_TRST
))
982 jtag_srst
= req_srst
;
984 retval
= interface_jtag_add_reset(jtag_trst
, jtag_srst
);
985 if (retval
!=ERROR_OK
)
993 LOG_DEBUG("SRST line asserted");
997 LOG_DEBUG("SRST line released");
998 if (jtag_nsrst_delay
)
999 jtag_add_sleep(jtag_nsrst_delay
* 1000);
1004 LOG_DEBUG("JTAG reset with TLR instead of TRST");
1005 jtag_add_end_state(TAP_TLR
);
1007 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1013 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1014 * and inform possible listeners about this
1016 LOG_DEBUG("TRST line asserted");
1017 cmd_queue_cur_state
= TAP_TLR
;
1018 jtag_call_event_callbacks(JTAG_TRST_ASSERTED
);
1022 if (jtag_ntrst_delay
)
1023 jtag_add_sleep(jtag_ntrst_delay
* 1000);
1027 int MINIDRIVER(interface_jtag_add_reset
)(int req_trst
, int req_srst
)
1029 jtag_command_t
**last_cmd
= jtag_get_last_command_p();
1031 /* allocate memory for a new list member */
1032 *last_cmd
= cmd_queue_alloc(sizeof(jtag_command_t
));
1033 (*last_cmd
)->next
= NULL
;
1034 last_comand_pointer
= &((*last_cmd
)->next
);
1035 (*last_cmd
)->type
= JTAG_RESET
;
1037 (*last_cmd
)->cmd
.reset
= cmd_queue_alloc(sizeof(reset_command_t
));
1038 (*last_cmd
)->cmd
.reset
->trst
= req_trst
;
1039 (*last_cmd
)->cmd
.reset
->srst
= req_srst
;
1045 void jtag_add_end_state(enum tap_state state
)
1047 cmd_queue_end_state
= state
;
1048 if ((cmd_queue_end_state
== TAP_SD
)||(cmd_queue_end_state
== TAP_SD
))
1050 LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field");
1054 int MINIDRIVER(interface_jtag_add_sleep
)(u32 us
)
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_SLEEP
;
1064 (*last_cmd
)->cmd
.sleep
= cmd_queue_alloc(sizeof(sleep_command_t
));
1065 (*last_cmd
)->cmd
.sleep
->us
= us
;
1070 void jtag_add_sleep(u32 us
)
1072 int retval
=interface_jtag_add_sleep(us
);
1073 if (retval
!=ERROR_OK
)
1078 int jtag_scan_size(scan_command_t
*cmd
)
1083 /* count bits in scan command */
1084 for (i
= 0; i
< cmd
->num_fields
; i
++)
1086 bit_count
+= cmd
->fields
[i
].num_bits
;
1092 int jtag_build_buffer(scan_command_t
*cmd
, u8
**buffer
)
1097 bit_count
= jtag_scan_size(cmd
);
1098 *buffer
= malloc(CEIL(bit_count
, 8));
1102 for (i
= 0; i
< cmd
->num_fields
; i
++)
1104 if (cmd
->fields
[i
].out_value
)
1106 #ifdef _DEBUG_JTAG_IO_
1107 char* char_buf
= buf_to_str(cmd
->fields
[i
].out_value
, (cmd
->fields
[i
].num_bits
> 64) ? 64 : cmd
->fields
[i
].num_bits
, 16);
1109 buf_set_buf(cmd
->fields
[i
].out_value
, 0, *buffer
, bit_count
, cmd
->fields
[i
].num_bits
);
1110 #ifdef _DEBUG_JTAG_IO_
1111 LOG_DEBUG("fields[%i].out_value: 0x%s", i
, char_buf
);
1116 bit_count
+= cmd
->fields
[i
].num_bits
;
1123 int jtag_read_buffer(u8
*buffer
, scan_command_t
*cmd
)
1129 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1132 for (i
= 0; i
< cmd
->num_fields
; i
++)
1134 /* if neither in_value nor in_handler
1135 * are specified we don't have to examine this field
1137 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1139 int num_bits
= cmd
->fields
[i
].num_bits
;
1140 u8
*captured
= buf_set_buf(buffer
, bit_count
, malloc(CEIL(num_bits
, 8)), 0, num_bits
);
1142 #ifdef _DEBUG_JTAG_IO_
1145 char_buf
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1146 LOG_DEBUG("fields[%i].in_value: 0x%s", i
, char_buf
);
1150 if (cmd
->fields
[i
].in_value
)
1152 buf_cpy(captured
, cmd
->fields
[i
].in_value
, num_bits
);
1154 if (cmd
->fields
[i
].in_handler
)
1156 if (cmd
->fields
[i
].in_handler(cmd
->fields
[i
].in_value
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1158 LOG_WARNING("in_handler reported a failed check");
1159 retval
= ERROR_JTAG_QUEUE_FAILED
;
1164 /* no in_value specified, but a handler takes care of the scanned data */
1165 if (cmd
->fields
[i
].in_handler
&& (!cmd
->fields
[i
].in_value
))
1167 if (cmd
->fields
[i
].in_handler(captured
, cmd
->fields
[i
].in_handler_priv
, cmd
->fields
+i
) != ERROR_OK
)
1169 /* We're going to call the error:handler later, but if the in_handler
1170 * reported an error we report this failure upstream
1172 LOG_WARNING("in_handler reported a failed check");
1173 retval
= ERROR_JTAG_QUEUE_FAILED
;
1179 bit_count
+= cmd
->fields
[i
].num_bits
;
1185 int jtag_check_value(u8
*captured
, void *priv
, scan_field_t
*field
)
1187 int retval
= ERROR_OK
;
1188 int num_bits
= field
->num_bits
;
1190 int compare_failed
= 0;
1192 if (field
->in_check_mask
)
1193 compare_failed
= buf_cmp_mask(captured
, field
->in_check_value
, field
->in_check_mask
, num_bits
);
1195 compare_failed
= buf_cmp(captured
, field
->in_check_value
, num_bits
);
1199 /* An error handler could have caught the failing check
1200 * only report a problem when there wasn't a handler, or if the handler
1201 * acknowledged the error
1205 char *captured_char
= buf_to_str(captured
, (num_bits
> 64) ? 64 : num_bits
, 16);
1206 char *in_check_value_char
= buf_to_str(field
->in_check_value
, (num_bits
> 64) ? 64 : num_bits
, 16);
1208 if (field
->in_check_mask
)
1210 char *in_check_mask_char
;
1211 in_check_mask_char
= buf_to_str(field
->in_check_mask
, (num_bits
> 64) ? 64 : num_bits
, 16);
1212 LOG_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
);
1213 free(in_check_mask_char
);
1217 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char
, in_check_value_char
);
1220 free(captured_char
);
1221 free(in_check_value_char
);
1223 retval
= ERROR_JTAG_QUEUE_FAILED
;
1231 set up checking of this field using the in_handler. The values passed in must be valid until
1232 after jtag_execute() has completed.
1234 void jtag_set_check_value(scan_field_t
*field
, u8
*value
, u8
*mask
, error_handler_t
*in_error_handler
)
1237 field
->in_handler
= jtag_check_value
;
1239 field
->in_handler
= NULL
; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1240 field
->in_handler_priv
= NULL
;
1241 field
->in_check_value
= value
;
1242 field
->in_check_mask
= mask
;
1245 enum scan_type
jtag_scan_type(scan_command_t
*cmd
)
1250 for (i
= 0; i
< cmd
->num_fields
; i
++)
1252 if (cmd
->fields
[i
].in_value
|| cmd
->fields
[i
].in_handler
)
1254 if (cmd
->fields
[i
].out_value
)
1261 int MINIDRIVER(interface_jtag_execute_queue
)(void)
1267 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1271 retval
= jtag
->execute_queue();
1275 jtag_command_queue
= NULL
;
1276 last_comand_pointer
= &jtag_command_queue
;
1281 int jtag_execute_queue(void)
1283 int retval
=interface_jtag_execute_queue();
1284 if (retval
==ERROR_OK
)
1288 jtag_error
=ERROR_OK
;
1292 int jtag_reset_callback(enum jtag_event event
, void *priv
)
1294 jtag_device_t
*device
= priv
;
1298 if (event
== JTAG_TRST_ASSERTED
)
1300 buf_set_ones(device
->cur_instr
, device
->ir_length
);
1307 void jtag_sleep(u32 us
)
1312 /* Try to examine chain layout according to IEEE 1149.1 §12
1314 int jtag_examine_chain()
1316 jtag_device_t
*device
= jtag_devices
;
1318 u8 idcode_buffer
[JTAG_MAX_CHAIN_SIZE
* 4];
1321 int device_count
= 0;
1322 u8 zero_check
= 0x0;
1323 u8 one_check
= 0xff;
1326 field
.num_bits
= sizeof(idcode_buffer
) * 8;
1327 field
.out_value
= idcode_buffer
;
1328 field
.out_mask
= NULL
;
1329 field
.in_value
= idcode_buffer
;
1330 field
.in_check_value
= NULL
;
1331 field
.in_check_mask
= NULL
;
1332 field
.in_handler
= NULL
;
1333 field
.in_handler_priv
= NULL
;
1335 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
; i
++)
1337 buf_set_u32(idcode_buffer
, i
* 32, 32, 0x000000FF);
1340 jtag_add_plain_dr_scan(1, &field
, TAP_TLR
);
1341 jtag_execute_queue();
1343 for (i
= 0; i
< JTAG_MAX_CHAIN_SIZE
* 4; i
++)
1345 zero_check
|= idcode_buffer
[i
];
1346 one_check
&= idcode_buffer
[i
];
1349 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1350 if ((zero_check
== 0x00) || (one_check
== 0xff))
1352 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1353 return ERROR_JTAG_INIT_FAILED
;
1356 for (bit_count
= 0; bit_count
< (JTAG_MAX_CHAIN_SIZE
* 32) - 31;)
1358 u32 idcode
= buf_get_u32(idcode_buffer
, bit_count
, 32);
1359 if ((idcode
& 1) == 0)
1361 /* LSB must not be 0, this indicates a device in bypass */
1372 if (idcode
== 0x000000FF)
1374 /* End of chain (invalid manufacturer ID) */
1380 device
->idcode
= idcode
;
1381 device
= device
->next
;
1385 manufacturer
= (idcode
& 0xffe) >> 1;
1386 part
= (idcode
& 0xffff000) >> 12;
1387 version
= (idcode
& 0xf0000000) >> 28;
1389 LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1390 idcode
, manufacturer
, part
, version
);
1396 /* see if number of discovered devices matches configuration */
1397 if (device_count
!= jtag_num_devices
)
1399 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)",
1400 device_count
, jtag_num_devices
);
1401 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1402 return ERROR_JTAG_INIT_FAILED
;
1408 int jtag_validate_chain()
1410 jtag_device_t
*device
= jtag_devices
;
1411 int total_ir_length
= 0;
1418 total_ir_length
+= device
->ir_length
;
1419 device
= device
->next
;
1422 total_ir_length
+= 2;
1423 ir_test
= malloc(CEIL(total_ir_length
, 8));
1424 buf_set_ones(ir_test
, total_ir_length
);
1427 field
.num_bits
= total_ir_length
;
1428 field
.out_value
= ir_test
;
1429 field
.out_mask
= NULL
;
1430 field
.in_value
= ir_test
;
1431 field
.in_check_value
= NULL
;
1432 field
.in_check_mask
= NULL
;
1433 field
.in_handler
= NULL
;
1434 field
.in_handler_priv
= NULL
;
1436 jtag_add_plain_ir_scan(1, &field
, TAP_TLR
);
1437 jtag_execute_queue();
1439 device
= jtag_devices
;
1442 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x1)
1444 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1445 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1448 return ERROR_JTAG_INIT_FAILED
;
1450 chain_pos
+= device
->ir_length
;
1451 device
= device
->next
;
1454 if (buf_get_u32(ir_test
, chain_pos
, 2) != 0x3)
1456 char *cbuf
= buf_to_str(ir_test
, total_ir_length
, 16);
1457 LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf
);
1460 return ERROR_JTAG_INIT_FAILED
;
1468 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
1470 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
1471 COMMAND_CONFIG
, NULL
);
1472 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
1473 COMMAND_ANY
, "set jtag speed (if supported) <reset speed> [<post reset speed, default value is reset speed>]");
1474 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
1475 COMMAND_ANY
, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
1476 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
1477 COMMAND_CONFIG
, "jtag_device <ir_length> <ir_expected> <ir_mask>");
1478 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
1479 COMMAND_CONFIG
, NULL
);
1480 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
1481 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1482 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
1483 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1485 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
1486 COMMAND_EXEC
, "print current scan chain configuration");
1488 register_command(cmd_ctx
, NULL
, "endstate", handle_endstate_command
,
1489 COMMAND_EXEC
, "finish JTAG operations in <tap_state>");
1490 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
1491 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
1492 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
1493 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
1494 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
1495 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1497 add_jim("drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1499 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
1500 COMMAND_ANY
, "verify value captured during Capture-IR <enable|disable>");
1504 int jtag_interface_init(struct command_context_s
*cmd_ctx
)
1509 if (!jtag_interface
)
1511 /* nothing was previously specified by "interface" command */
1512 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1513 return ERROR_JTAG_INVALID_INTERFACE
;
1517 /*stay on "reset speed"*/
1518 jtag_interface
->khz(speed1
, &jtag_speed
);
1519 jtag_interface
->khz(speed2
, &jtag_speed_post_reset
);
1523 if (jtag_interface
->init() != ERROR_OK
)
1524 return ERROR_JTAG_INIT_FAILED
;
1528 jtag
= jtag_interface
;
1532 static int jtag_init_inner(struct command_context_s
*cmd_ctx
)
1534 int validate_tries
= 0;
1535 jtag_device_t
*device
;
1538 LOG_DEBUG("Init JTAG chain");
1540 device
= jtag_devices
;
1541 jtag_ir_scan_size
= 0;
1542 jtag_num_devices
= 0;
1543 while (device
!= NULL
)
1545 jtag_ir_scan_size
+= device
->ir_length
;
1547 device
= device
->next
;
1551 if ((retval
=jtag_execute_queue())!=ERROR_OK
)
1554 /* examine chain first, as this could discover the real chain layout */
1555 if (jtag_examine_chain() != ERROR_OK
)
1557 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1560 while (jtag_validate_chain() != ERROR_OK
)
1564 if (validate_tries
> 5)
1566 LOG_ERROR("Could not validate JTAG chain, exit");
1567 return ERROR_JTAG_INVALID_INTERFACE
;
1575 int jtag_init_reset(struct command_context_s
*cmd_ctx
)
1579 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1582 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR");
1584 /* Reset can happen after a power cycle.
1586 * Ideally we would only assert TRST or run TLR before the target reset.
1588 * However w/srst_pulls_trst, trst is asserted together with the target
1589 * reset whether we want it or not.
1591 * NB! Some targets have JTAG circuitry disabled until a
1592 * trst & srst has been asserted.
1594 * NB! here we assume nsrst/ntrst delay are sufficient!
1596 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1599 jtag_add_reset(1, 0); /* TLR or TRST */
1600 if (jtag_reset_config
& RESET_HAS_SRST
)
1602 jtag_add_reset(1, 1);
1603 if ((jtag_reset_config
& RESET_SRST_PULLS_TRST
)==0)
1604 jtag_add_reset(0, 1);
1606 jtag_add_reset(0, 0);
1607 if ((retval
= jtag_execute_queue()) != ERROR_OK
)
1610 /* Check that we can communication on the JTAG chain + eventually we want to
1611 * be able to perform enumeration only after OpenOCD has started
1612 * telnet and GDB server
1614 * That would allow users to more easily perform any magic they need to before
1617 return jtag_init_inner(cmd_ctx
);
1620 int jtag_init(struct command_context_s
*cmd_ctx
)
1623 if ((retval
=jtag_interface_init(cmd_ctx
)) != ERROR_OK
)
1625 if (jtag_init_inner(cmd_ctx
)==ERROR_OK
)
1629 return jtag_init_reset(cmd_ctx
);
1633 static int default_khz(int khz
, int *jtag_speed
)
1635 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1639 static int default_speed_div(int speed
, int *khz
)
1644 int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1648 /* check whether the interface is already configured */
1651 LOG_WARNING("Interface already configured, ignoring");
1655 /* interface name is a mandatory argument */
1656 if (argc
< 1 || args
[0][0] == '\0')
1658 return ERROR_COMMAND_SYNTAX_ERROR
;
1661 for (i
=0; jtag_interfaces
[i
]; i
++)
1663 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) == 0)
1665 if (jtag_interfaces
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
1668 jtag_interface
= jtag_interfaces
[i
];
1670 if (jtag_interface
->khz
== NULL
)
1672 jtag_interface
->khz
= default_khz
;
1674 if (jtag_interface
->speed_div
== NULL
)
1676 jtag_interface
->speed_div
= default_speed_div
;
1682 /* no valid interface was found (i.e. the configuration option,
1683 * didn't match one of the compiled-in interfaces
1685 LOG_ERROR("No valid jtag interface found (%s)", args
[0]);
1686 LOG_ERROR("compiled-in jtag interfaces:");
1687 for (i
= 0; jtag_interfaces
[i
]; i
++)
1689 LOG_ERROR("%i: %s", i
, jtag_interfaces
[i
]->name
);
1692 return ERROR_JTAG_INVALID_INTERFACE
;
1695 int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1697 jtag_device_t
**last_device_p
= &jtag_devices
;
1701 while ((*last_device_p
)->next
)
1702 last_device_p
= &((*last_device_p
)->next
);
1703 last_device_p
= &((*last_device_p
)->next
);
1709 *last_device_p
= malloc(sizeof(jtag_device_t
));
1710 (*last_device_p
)->ir_length
= strtoul(args
[0], NULL
, 0);
1712 (*last_device_p
)->expected
= malloc((*last_device_p
)->ir_length
);
1713 buf_set_u32((*last_device_p
)->expected
, 0, (*last_device_p
)->ir_length
, strtoul(args
[1], NULL
, 0));
1714 (*last_device_p
)->expected_mask
= malloc((*last_device_p
)->ir_length
);
1715 buf_set_u32((*last_device_p
)->expected_mask
, 0, (*last_device_p
)->ir_length
, strtoul(args
[2], NULL
, 0));
1717 (*last_device_p
)->cur_instr
= malloc((*last_device_p
)->ir_length
);
1718 (*last_device_p
)->bypass
= 1;
1719 buf_set_ones((*last_device_p
)->cur_instr
, (*last_device_p
)->ir_length
);
1721 (*last_device_p
)->next
= NULL
;
1723 jtag_register_event_callback(jtag_reset_callback
, (*last_device_p
));
1730 int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1732 jtag_device_t
*device
= jtag_devices
;
1733 int device_count
= 0;
1737 u32 expected
, expected_mask
, cur_instr
;
1738 expected
= buf_get_u32(device
->expected
, 0, device
->ir_length
);
1739 expected_mask
= buf_get_u32(device
->expected_mask
, 0, device
->ir_length
);
1740 cur_instr
= buf_get_u32(device
->cur_instr
, 0, device
->ir_length
);
1741 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
);
1742 device
= device
->next
;
1749 int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1752 return ERROR_COMMAND_SYNTAX_ERROR
;
1756 if (strcmp(args
[0], "none") == 0)
1757 jtag_reset_config
= RESET_NONE
;
1758 else if (strcmp(args
[0], "trst_only") == 0)
1759 jtag_reset_config
= RESET_HAS_TRST
;
1760 else if (strcmp(args
[0], "srst_only") == 0)
1761 jtag_reset_config
= RESET_HAS_SRST
;
1762 else if (strcmp(args
[0], "trst_and_srst") == 0)
1763 jtag_reset_config
= RESET_TRST_AND_SRST
;
1766 LOG_ERROR("invalid reset_config argument, defaulting to none");
1767 jtag_reset_config
= RESET_NONE
;
1768 return ERROR_INVALID_ARGUMENTS
;
1774 if (strcmp(args
[1], "separate") == 0)
1776 /* seperate reset lines - default */
1779 if (strcmp(args
[1], "srst_pulls_trst") == 0)
1780 jtag_reset_config
|= RESET_SRST_PULLS_TRST
;
1781 else if (strcmp(args
[1], "trst_pulls_srst") == 0)
1782 jtag_reset_config
|= RESET_TRST_PULLS_SRST
;
1783 else if (strcmp(args
[1], "combined") == 0)
1784 jtag_reset_config
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
1787 LOG_ERROR("invalid reset_config argument, defaulting to none");
1788 jtag_reset_config
= RESET_NONE
;
1789 return ERROR_INVALID_ARGUMENTS
;
1796 if (strcmp(args
[2], "trst_open_drain") == 0)
1797 jtag_reset_config
|= RESET_TRST_OPEN_DRAIN
;
1798 else if (strcmp(args
[2], "trst_push_pull") == 0)
1799 jtag_reset_config
&= ~RESET_TRST_OPEN_DRAIN
;
1802 LOG_ERROR("invalid reset_config argument, defaulting to none");
1803 jtag_reset_config
= RESET_NONE
;
1804 return ERROR_INVALID_ARGUMENTS
;
1810 if (strcmp(args
[3], "srst_push_pull") == 0)
1811 jtag_reset_config
|= RESET_SRST_PUSH_PULL
;
1812 else if (strcmp(args
[3], "srst_open_drain") == 0)
1813 jtag_reset_config
&= ~RESET_SRST_PUSH_PULL
;
1816 LOG_ERROR("invalid reset_config argument, defaulting to none");
1817 jtag_reset_config
= RESET_NONE
;
1818 return ERROR_INVALID_ARGUMENTS
;
1825 int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1829 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
1834 jtag_nsrst_delay
= strtoul(args
[0], NULL
, 0);
1840 int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1844 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
1849 jtag_ntrst_delay
= strtoul(args
[0], NULL
, 0);
1855 int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1861 if ((argc
<1) || (argc
>2))
1862 return ERROR_COMMAND_SYNTAX_ERROR
;
1864 LOG_DEBUG("handle jtag speed");
1867 cur_speed
= jtag_speed
= jtag_speed_post_reset
= strtoul(args
[0], NULL
, 0);
1869 cur_speed
= jtag_speed_post_reset
= strtoul(args
[1], NULL
, 0);
1871 /* this command can be called during CONFIG,
1872 * in which case jtag isn't initialized */
1875 jtag
->speed_div(jtag_speed
, &speed1
);
1876 jtag
->speed_div(jtag_speed_post_reset
, &speed2
);
1877 jtag
->speed(cur_speed
);
1880 command_print(cmd_ctx
, "jtag_speed: %d, %d", jtag_speed
, jtag_speed_post_reset
);
1885 int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1887 LOG_DEBUG("handle jtag khz");
1890 return ERROR_COMMAND_SYNTAX_ERROR
;
1896 speed1
= speed2
= strtoul(args
[0], NULL
, 0);
1898 speed2
= strtoul(args
[1], NULL
, 0);
1903 LOG_DEBUG("have interface set up");
1904 int speed_div1
, speed_div2
;
1905 if (jtag
->khz(speed1
, &speed_div1
)!=ERROR_OK
)
1907 speed1
= speed2
= 0;
1910 if (jtag
->khz(speed2
, &speed_div2
)!=ERROR_OK
)
1912 speed1
= speed2
= 0;
1917 cur_speed
= jtag_speed
= jtag_speed_post_reset
= speed_div1
;
1919 cur_speed
= jtag_speed_post_reset
= speed_div2
;
1921 jtag
->speed(cur_speed
);
1927 command_print(cmd_ctx
, "jtag_khz: %d, %d", speed1
, speed2
);
1933 int handle_endstate_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1935 enum tap_state state
;
1939 return ERROR_COMMAND_SYNTAX_ERROR
;
1943 for (state
= 0; state
< 16; state
++)
1945 if (strcmp(args
[0], tap_state_strings
[state
]) == 0)
1947 jtag_add_end_state(state
);
1948 jtag_execute_queue();
1952 command_print(cmd_ctx
, "current endstate: %s", tap_state_strings
[cmd_queue_end_state
]);
1957 int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1964 return ERROR_COMMAND_SYNTAX_ERROR
;
1967 if (args
[0][0] == '1')
1969 else if (args
[0][0] == '0')
1973 return ERROR_COMMAND_SYNTAX_ERROR
;
1976 if (args
[1][0] == '1')
1978 else if (args
[1][0] == '0')
1982 return ERROR_COMMAND_SYNTAX_ERROR
;
1985 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1986 return ERROR_JTAG_INIT_FAILED
;
1988 jtag_add_reset(trst
, srst
);
1989 jtag_execute_queue();
1994 int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1998 return ERROR_COMMAND_SYNTAX_ERROR
;
2001 jtag_add_runtest(strtol(args
[0], NULL
, 0), -1);
2002 jtag_execute_queue();
2009 int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2012 scan_field_t
*fields
;
2014 if ((argc
< 2) || (argc
% 2))
2016 return ERROR_COMMAND_SYNTAX_ERROR
;
2019 fields
= malloc(sizeof(scan_field_t
) * argc
/ 2);
2021 for (i
= 0; i
< argc
/ 2; i
++)
2023 int device
= strtoul(args
[i
*2], NULL
, 0);
2024 int field_size
= jtag_get_device(device
)->ir_length
;
2025 fields
[i
].device
= device
;
2026 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
2027 buf_set_u32(fields
[i
].out_value
, 0, field_size
, strtoul(args
[i
*2+1], NULL
, 0));
2028 fields
[i
].out_mask
= NULL
;
2029 fields
[i
].in_value
= NULL
;
2030 fields
[i
].in_check_mask
= NULL
;
2031 fields
[i
].in_handler
= NULL
;
2032 fields
[i
].in_handler_priv
= NULL
;
2035 jtag_add_ir_scan(argc
/ 2, fields
, -1);
2036 jtag_execute_queue();
2038 for (i
= 0; i
< argc
/ 2; i
++)
2039 free(fields
[i
].out_value
);
2046 /* FIX!!! this command is busted for > 32 bits */
2047 int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
2050 scan_field_t
*fields
;
2052 int field_count
= 0;
2055 if ((argc
< 4) || ((argc
% 2)!=0))
2060 for (i
= 2; i
< argc
; i
+=2)
2063 Jim_GetLong(interp
, args
[i
], &bits
);
2064 if ((bits
<=0)||(bits
>32))
2066 // LOG_ERROR("minimum 1/maximum 32 bit fields - patches gratefully accepted!");
2071 Jim_GetLong(interp
, args
[1], &device
);
2072 num_fields
=(argc
-2)/2;
2074 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
2076 for (i
= 2; i
< argc
; i
+=2)
2079 Jim_GetLong(interp
, args
[i
], &bits
);
2081 Jim_GetLong(interp
, args
[i
+1], &val
);
2083 fields
[field_count
].device
= device
;
2084 fields
[field_count
].num_bits
= bits
;
2085 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
2086 buf_set_u32(fields
[field_count
].out_value
, 0, bits
, val
);
2087 fields
[field_count
].out_mask
= NULL
;
2088 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
2089 fields
[field_count
].in_check_mask
= NULL
;
2090 fields
[field_count
].in_check_value
= NULL
;
2091 fields
[field_count
].in_handler
= NULL
;
2092 fields
[field_count
++].in_handler_priv
= NULL
;
2095 jtag_add_dr_scan(num_fields
, fields
, -1);
2096 retval
=jtag_execute_queue();
2099 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
2100 for (i
= 2; i
< argc
; i
+=2)
2103 Jim_GetLong(interp
, args
[i
], &bits
);
2105 u32 val
= buf_get_u32(fields
[field_count
].in_value
, 0, bits
);
2107 Jim_ListAppendElement(interp
, list
, Jim_NewIntObj(interp
, val
));
2109 free(fields
[field_count
].out_value
);
2113 Jim_SetResult(interp
, list
);
2117 return retval
?JIM_OK
:JIM_ERR
;
2120 int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
2124 if (strcmp(args
[0], "enable") == 0)
2126 jtag_verify_capture_ir
= 1;
2128 else if (strcmp(args
[0], "disable") == 0)
2130 jtag_verify_capture_ir
= 0;
2133 return ERROR_COMMAND_SYNTAX_ERROR
;
2135 } else if (argc
!= 0)
2137 return ERROR_COMMAND_SYNTAX_ERROR
;
2140 command_print(cmd_ctx
, "verify Capture-IR is %s", (jtag_verify_capture_ir
) ? "enabled": "disabled");