1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License as published by *
14 * the Free Software Foundation; either version 2 of the License, or *
15 * (at your option) any later version. *
17 * This program is distributed in the hope that it will be useful, *
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
20 * GNU General Public License for more details. *
22 * You should have received a copy of the GNU General Public License *
23 * along with this program; if not, write to the *
24 * Free Software Foundation, Inc., *
25 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
26 ***************************************************************************/
31 #include "replacements.h"
42 /* note that this is not marked as static as it must be available from outside jtag.c for those
43 that implement the jtag_xxx() minidriver layer
45 int jtag_error=ERROR_OK;
47 typedef struct cmd_queue_page_s
51 struct cmd_queue_page_s *next;
54 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
55 static cmd_queue_page_t *cmd_queue_pages = NULL;
57 char* jtag_event_strings[] =
59 "JTAG controller reset (RESET or TRST)"
62 const Jim_Nvp nvp_jtag_tap_event[] = {
63 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
64 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
66 { .name = NULL, .value = -1 }
72 jtag_command_t *jtag_command_queue = NULL;
73 jtag_command_t **last_comand_pointer = &jtag_command_queue;
74 static jtag_tap_t *jtag_all_taps = NULL;
76 enum reset_types jtag_reset_config = RESET_NONE;
77 tap_state_t cmd_queue_end_state = TAP_RESET;
78 tap_state_t cmd_queue_cur_state = TAP_RESET;
80 int jtag_verify_capture_ir = 1;
82 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
83 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
84 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
86 /* maximum number of JTAG devices expected in the chain
88 #define JTAG_MAX_CHAIN_SIZE 20
90 /* callbacks to inform high-level handlers about JTAG state changes */
91 jtag_event_callback_t *jtag_event_callbacks;
94 static int speed_khz = 0;
95 /* flag if the kHz speed was defined */
96 static int hasKHz = 0;
98 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
101 #if BUILD_ECOSBOARD == 1
102 extern jtag_interface_t zy1000_interface;
105 #if BUILD_PARPORT == 1
106 extern jtag_interface_t parport_interface;
110 extern jtag_interface_t dummy_interface;
113 #if BUILD_FT2232_FTD2XX == 1
114 extern jtag_interface_t ft2232_interface;
117 #if BUILD_FT2232_LIBFTDI == 1
118 extern jtag_interface_t ft2232_interface;
121 #if BUILD_AMTJTAGACCEL == 1
122 extern jtag_interface_t amt_jtagaccel_interface;
125 #if BUILD_EP93XX == 1
126 extern jtag_interface_t ep93xx_interface;
129 #if BUILD_AT91RM9200 == 1
130 extern jtag_interface_t at91rm9200_interface;
133 #if BUILD_GW16012 == 1
134 extern jtag_interface_t gw16012_interface;
137 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
138 extern jtag_interface_t presto_interface;
141 #if BUILD_USBPROG == 1
142 extern jtag_interface_t usbprog_interface;
146 extern jtag_interface_t jlink_interface;
149 #if BUILD_VSLLINK == 1
150 extern jtag_interface_t vsllink_interface;
154 extern jtag_interface_t rlink_interface;
157 #if BUILD_ARMJTAGEW == 1
158 extern jtag_interface_t armjtagew_interface;
161 jtag_interface_t *jtag_interfaces[] = {
162 #if BUILD_ECOSBOARD == 1
165 #if BUILD_PARPORT == 1
171 #if BUILD_FT2232_FTD2XX == 1
174 #if BUILD_FT2232_LIBFTDI == 1
177 #if BUILD_AMTJTAGACCEL == 1
178 &amt_jtagaccel_interface,
180 #if BUILD_EP93XX == 1
183 #if BUILD_AT91RM9200 == 1
184 &at91rm9200_interface,
186 #if BUILD_GW16012 == 1
189 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
192 #if BUILD_USBPROG == 1
198 #if BUILD_VSLLINK == 1
204 #if BUILD_ARMJTAGEW == 1
205 &armjtagew_interface,
210 jtag_interface_t *jtag = NULL;
213 static jtag_interface_t *jtag_interface = NULL;
216 /* forward declarations */
217 //void jtag_add_pathmove(int num_states, tap_state_t *path);
218 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
219 //void jtag_add_end_state(tap_state_t endstate);
220 //void jtag_add_sleep(u32 us);
221 //int jtag_execute_queue(void);
222 static tap_state_t tap_state_by_name(const char *name);
225 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
226 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
227 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
228 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
229 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
230 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
231 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
238 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
241 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
243 jtag_tap_t *jtag_AllTaps(void)
245 return jtag_all_taps;
248 int jtag_NumTotalTaps(void)
262 int jtag_NumEnabledTaps(void)
278 jtag_tap_t *jtag_TapByString( const char *s )
286 if( 0 == strcmp( t->dotted_name, s ) ){
292 /* backup plan is by number */
294 /* ok - is "s" a number? */
296 n = strtol( s, &cp, 0 );
297 if( (s != cp) && (*cp == 0) ){
299 t = jtag_TapByAbsPosition(n);
305 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
310 cp = Jim_GetString( o, NULL );
315 t = jtag_TapByString( cp );
318 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
323 /* returns a pointer to the n-th device in the scan chain */
324 jtag_tap_t * jtag_TapByAbsPosition( int n )
332 while( t && (n > 0)) {
339 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
341 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
343 if (callback == NULL)
345 return ERROR_INVALID_ARGUMENTS;
350 while ((*callbacks_p)->next)
351 callbacks_p = &((*callbacks_p)->next);
352 callbacks_p = &((*callbacks_p)->next);
355 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
356 (*callbacks_p)->callback = callback;
357 (*callbacks_p)->priv = priv;
358 (*callbacks_p)->next = NULL;
363 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
365 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
367 if (callback == NULL)
369 return ERROR_INVALID_ARGUMENTS;
374 jtag_event_callback_t **next = &((*callbacks_p)->next);
375 if ((*callbacks_p)->callback == callback)
378 *callbacks_p = *next;
386 int jtag_call_event_callbacks(enum jtag_event event)
388 jtag_event_callback_t *callback = jtag_event_callbacks;
390 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
394 callback->callback(event, callback->priv);
395 callback = callback->next;
401 /* returns a pointer to the pointer of the last command in queue
402 * this may be a pointer to the root pointer (jtag_command_queue)
403 * or to the next member of the last but one command
405 jtag_command_t** jtag_get_last_command_p(void)
407 /* jtag_command_t *cmd = jtag_command_queue;
413 return &jtag_command_queue;
417 return last_comand_pointer;
420 void* cmd_queue_alloc(size_t size)
422 cmd_queue_page_t **p_page = &cmd_queue_pages;
428 * We align/round the *SIZE* per below
429 * so that all pointers returned by
430 * this function are reasonably well
433 * If we did not, then an "odd-length" request would cause the
434 * *next* allocation to be at an *odd* address, and because
435 * this function has the same type of api as malloc() - we
436 * must also return pointers that have the same type of
439 * What I do not/have is a reasonable portable means
442 * The solution here, is based on these suggestions.
443 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
446 union worse_case_align {
452 #define ALIGN_SIZE (sizeof(union worse_case_align))
454 /* The alignment process. */
455 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
460 while ((*p_page)->next)
461 p_page = &((*p_page)->next);
462 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
463 p_page = &((*p_page)->next);
468 *p_page = malloc(sizeof(cmd_queue_page_t));
470 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
471 (*p_page)->next = NULL;
474 offset = (*p_page)->used;
475 (*p_page)->used += size;
477 t=(u8 *)((*p_page)->address);
481 void cmd_queue_free(void)
483 cmd_queue_page_t *page = cmd_queue_pages;
487 cmd_queue_page_t *last = page;
493 cmd_queue_pages = NULL;
496 static void jtag_prelude1(void)
500 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
501 jtag_error=ERROR_JTAG_TRST_ASSERTED;
505 if (cmd_queue_end_state == TAP_RESET)
506 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
509 static void jtag_prelude(tap_state_t state)
513 if (state != TAP_INVALID)
514 jtag_add_end_state(state);
516 cmd_queue_cur_state = cmd_queue_end_state;
519 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
525 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
526 if (retval!=ERROR_OK)
530 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
532 jtag_command_t **last_cmd;
539 last_cmd = jtag_get_last_command_p();
541 /* allocate memory for a new list member */
542 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
543 (*last_cmd)->next = NULL;
544 last_comand_pointer = &((*last_cmd)->next);
545 (*last_cmd)->type = JTAG_SCAN;
547 /* allocate memory for ir scan command */
548 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
549 (*last_cmd)->cmd.scan->ir_scan = 1;
550 x = jtag_NumEnabledTaps();
551 (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
552 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
553 (*last_cmd)->cmd.scan->end_state = state;
560 /* do this here so it is not forgotten */
561 tap = jtag_NextEnabledTap(tap);
566 scan_size = tap->ir_length;
567 (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
568 (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
569 (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
570 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */
572 /* search the list */
573 for (j = 0; j < num_fields; j++)
575 if (tap == fields[j].tap)
578 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
579 (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
581 if (jtag_verify_capture_ir)
583 if (fields[j].in_handler==NULL)
585 jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL);
588 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler;
589 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv;
590 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected;
591 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask;
602 /* if a tap isn't listed, set it to BYPASS */
603 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
604 (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL;
608 /* update device information */
609 buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
615 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
621 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
622 if (retval!=ERROR_OK)
626 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
629 jtag_command_t **last_cmd;
631 last_cmd = jtag_get_last_command_p();
633 /* allocate memory for a new list member */
634 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
635 (*last_cmd)->next = NULL;
636 last_comand_pointer = &((*last_cmd)->next);
637 (*last_cmd)->type = JTAG_SCAN;
639 /* allocate memory for ir scan command */
640 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
641 (*last_cmd)->cmd.scan->ir_scan = 1;
642 (*last_cmd)->cmd.scan->num_fields = num_fields;
643 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
644 (*last_cmd)->cmd.scan->end_state = state;
646 for( i = 0 ; i < num_fields ; i++ ){
647 int num_bits = fields[i].num_bits;
648 int num_bytes = CEIL(fields[i].num_bits, 8);
649 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
650 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
651 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
652 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
653 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
654 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
655 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
656 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
657 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
662 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
668 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
669 if (retval!=ERROR_OK)
673 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
677 int bypass_devices = 0;
681 jtag_command_t **last_cmd = jtag_get_last_command_p();
684 /* count devices in bypass */
688 tap = jtag_NextEnabledTap(tap);
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 = state;
714 tap = jtag_NextEnabledTap(tap);
719 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
721 for (j = 0; j < num_fields; j++)
723 if (tap == fields[j].tap)
726 scan_size = fields[j].num_bits;
727 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
728 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
729 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
730 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
731 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
732 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
733 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
734 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
739 #ifdef _DEBUG_JTAG_IO_
740 /* if a device isn't listed, the BYPASS register should be selected */
743 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
747 /* program the scan field to 1 bit length, and ignore it's value */
748 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
749 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
750 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
751 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
752 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
753 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
754 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
755 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
759 #ifdef _DEBUG_JTAG_IO_
760 /* if a device is listed, the BYPASS register must not be selected */
763 LOG_ERROR("BUG: scan data for a device in BYPASS");
772 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
776 tap_state_t end_state)
781 int bypass_devices = 0;
783 jtag_command_t **last_cmd = jtag_get_last_command_p();
786 /* count devices in bypass */
790 tap = jtag_NextEnabledTap(tap);
799 /* allocate memory for a new list member */
800 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
801 last_comand_pointer = &((*last_cmd)->next);
802 (*last_cmd)->next = NULL;
803 (*last_cmd)->type = JTAG_SCAN;
805 /* allocate memory for dr scan command */
806 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
807 (*last_cmd)->cmd.scan->ir_scan = 0;
808 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
809 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
810 (*last_cmd)->cmd.scan->end_state = end_state;
815 tap = jtag_NextEnabledTap(tap);
820 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
822 if (tap == target_tap)
825 #ifdef _DEBUG_JTAG_IO_
826 /* if a device is listed, the BYPASS register must not be selected */
829 LOG_ERROR("BUG: scan data for a device in BYPASS");
833 for (j = 0; j < num_fields; j++)
836 scan_size = num_bits[j];
837 buf_set_u32(out_value, 0, scan_size, value[j]);
838 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
839 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
840 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
841 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
842 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
843 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
844 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
845 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
849 #ifdef _DEBUG_JTAG_IO_
850 /* if a device isn't listed, the BYPASS register should be selected */
853 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
857 /* program the scan field to 1 bit length, and ignore it's value */
858 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
859 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
860 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
861 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
862 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
863 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
864 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
865 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
870 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
876 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
877 if (retval!=ERROR_OK)
881 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
884 jtag_command_t **last_cmd = jtag_get_last_command_p();
886 /* allocate memory for a new list member */
887 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
888 last_comand_pointer = &((*last_cmd)->next);
889 (*last_cmd)->next = NULL;
890 (*last_cmd)->type = JTAG_SCAN;
892 /* allocate memory for scan command */
893 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
894 (*last_cmd)->cmd.scan->ir_scan = 0;
895 (*last_cmd)->cmd.scan->num_fields = num_fields;
896 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
897 (*last_cmd)->cmd.scan->end_state = state;
899 for (i = 0; i < num_fields; i++)
901 int num_bits = fields[i].num_bits;
902 int num_bytes = CEIL(fields[i].num_bits, 8);
903 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
904 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
905 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
906 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
907 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
908 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
909 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
910 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
911 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
917 void jtag_add_tlr(void)
919 jtag_prelude(TAP_RESET);
922 retval=interface_jtag_add_tlr();
923 if (retval!=ERROR_OK)
927 int MINIDRIVER(interface_jtag_add_tlr)(void)
929 tap_state_t state = TAP_RESET;
930 jtag_command_t **last_cmd = jtag_get_last_command_p();
932 /* allocate memory for a new list member */
933 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
934 last_comand_pointer = &((*last_cmd)->next);
935 (*last_cmd)->next = NULL;
936 (*last_cmd)->type = JTAG_STATEMOVE;
938 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
939 (*last_cmd)->cmd.statemove->end_state = state;
944 void jtag_add_pathmove(int num_states, tap_state_t *path)
946 tap_state_t cur_state=cmd_queue_cur_state;
950 /* the last state has to be a stable state */
951 if (!tap_is_state_stable(path[num_states - 1]))
953 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
957 for (i=0; i<num_states; i++)
959 if (path[i] == TAP_RESET)
961 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
964 if ( tap_state_transition(cur_state, true) != path[i]
965 && tap_state_transition(cur_state, false) != path[i])
967 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
975 retval=interface_jtag_add_pathmove(num_states, path);
976 cmd_queue_cur_state = path[num_states - 1];
977 if (retval!=ERROR_OK)
981 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
983 jtag_command_t **last_cmd = jtag_get_last_command_p();
986 /* allocate memory for a new list member */
987 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
988 last_comand_pointer = &((*last_cmd)->next);
989 (*last_cmd)->next = NULL;
990 (*last_cmd)->type = JTAG_PATHMOVE;
992 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
993 (*last_cmd)->cmd.pathmove->num_states = num_states;
994 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
996 for (i = 0; i < num_states; i++)
997 (*last_cmd)->cmd.pathmove->path[i] = path[i];
1002 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1004 jtag_command_t **last_cmd = jtag_get_last_command_p();
1006 /* allocate memory for a new list member */
1007 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1008 (*last_cmd)->next = NULL;
1009 last_comand_pointer = &((*last_cmd)->next);
1010 (*last_cmd)->type = JTAG_RUNTEST;
1012 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1013 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1014 (*last_cmd)->cmd.runtest->end_state = state;
1019 void jtag_add_runtest(int num_cycles, tap_state_t state)
1023 jtag_prelude(state);
1025 /* executed by sw or hw fifo */
1026 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1027 if (retval!=ERROR_OK)
1032 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1034 jtag_command_t **last_cmd = jtag_get_last_command_p();
1036 /* allocate memory for a new list member */
1037 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1038 (*last_cmd)->next = NULL;
1039 last_comand_pointer = &((*last_cmd)->next);
1040 (*last_cmd)->type = JTAG_STABLECLOCKS;
1042 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1043 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1047 void jtag_add_clocks( int num_cycles )
1051 if( !tap_is_state_stable(cmd_queue_cur_state) )
1053 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1054 tap_state_name(cmd_queue_cur_state) );
1055 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1059 if( num_cycles > 0 )
1063 retval = interface_jtag_add_clocks(num_cycles);
1064 if (retval != ERROR_OK)
1069 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1071 int trst_with_tlr = 0;
1074 /* FIX!!! there are *many* different cases here. A better
1075 * approach is needed for legal combinations of transitions...
1077 if ((jtag_reset_config & RESET_HAS_SRST)&&
1078 (jtag_reset_config & RESET_HAS_TRST)&&
1079 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1081 if (((req_tlr_or_trst&&!jtag_trst)||
1082 (!req_tlr_or_trst&&jtag_trst))&&
1083 ((req_srst&&!jtag_srst)||
1084 (!req_srst&&jtag_srst)))
1086 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1087 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1091 /* Make sure that jtag_reset_config allows the requested reset */
1092 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1093 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1095 LOG_ERROR("BUG: requested reset would assert trst");
1096 jtag_error=ERROR_FAIL;
1100 /* if TRST pulls SRST, we reset with TAP T-L-R */
1101 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1106 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1108 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1109 jtag_error=ERROR_FAIL;
1113 if (req_tlr_or_trst)
1115 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1127 jtag_srst = req_srst;
1129 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1130 if (retval!=ERROR_OK)
1138 LOG_DEBUG("SRST line asserted");
1142 LOG_DEBUG("SRST line released");
1143 if (jtag_nsrst_delay)
1144 jtag_add_sleep(jtag_nsrst_delay * 1000);
1149 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1150 jtag_add_end_state(TAP_RESET);
1152 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1158 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1159 * and inform possible listeners about this
1161 LOG_DEBUG("TRST line asserted");
1162 cmd_queue_cur_state = TAP_RESET;
1163 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1167 if (jtag_ntrst_delay)
1168 jtag_add_sleep(jtag_ntrst_delay * 1000);
1172 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1174 jtag_command_t **last_cmd = jtag_get_last_command_p();
1176 /* allocate memory for a new list member */
1177 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1178 (*last_cmd)->next = NULL;
1179 last_comand_pointer = &((*last_cmd)->next);
1180 (*last_cmd)->type = JTAG_RESET;
1182 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1183 (*last_cmd)->cmd.reset->trst = req_trst;
1184 (*last_cmd)->cmd.reset->srst = req_srst;
1189 void jtag_add_end_state(tap_state_t state)
1191 cmd_queue_end_state = state;
1192 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1194 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1198 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1200 jtag_command_t **last_cmd = jtag_get_last_command_p();
1202 /* allocate memory for a new list member */
1203 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1204 (*last_cmd)->next = NULL;
1205 last_comand_pointer = &((*last_cmd)->next);
1206 (*last_cmd)->type = JTAG_SLEEP;
1208 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1209 (*last_cmd)->cmd.sleep->us = us;
1214 void jtag_add_sleep(u32 us)
1216 keep_alive(); /* we might be running on a very slow JTAG clk */
1217 int retval=interface_jtag_add_sleep(us);
1218 if (retval!=ERROR_OK)
1223 int jtag_scan_size(scan_command_t *cmd)
1228 /* count bits in scan command */
1229 for (i = 0; i < cmd->num_fields; i++)
1231 bit_count += cmd->fields[i].num_bits;
1237 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1242 bit_count = jtag_scan_size(cmd);
1243 *buffer = malloc(CEIL(bit_count, 8));
1247 #ifdef _DEBUG_JTAG_IO_
1248 LOG_DEBUG("num_fields: %i",cmd->num_fields);
1251 for (i = 0; i < cmd->num_fields; i++)
1253 if (cmd->fields[i].out_value)
1255 #ifdef _DEBUG_JTAG_IO_
1256 char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16);
1258 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1259 #ifdef _DEBUG_JTAG_IO_
1260 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1265 bit_count += cmd->fields[i].num_bits;
1271 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1277 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1280 for (i = 0; i < cmd->num_fields; i++)
1282 /* if neither in_value nor in_handler
1283 * are specified we don't have to examine this field
1285 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1287 int num_bits = cmd->fields[i].num_bits;
1288 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1290 #ifdef _DEBUG_JTAG_IO_
1291 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1292 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1296 if (cmd->fields[i].in_value)
1298 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1300 if (cmd->fields[i].in_handler)
1302 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1304 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1305 retval = ERROR_JTAG_QUEUE_FAILED;
1310 /* no in_value specified, but a handler takes care of the scanned data */
1311 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1313 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1315 /* We're going to call the error:handler later, but if the in_handler
1316 * reported an error we report this failure upstream
1318 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1319 retval = ERROR_JTAG_QUEUE_FAILED;
1325 bit_count += cmd->fields[i].num_bits;
1331 static const char *jtag_tap_name(jtag_tap_t *tap)
1333 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1336 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1338 int retval = ERROR_OK;
1339 int num_bits = field->num_bits;
1341 int compare_failed = 0;
1343 if (field->in_check_mask)
1344 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1346 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1348 if (compare_failed){
1349 /* An error handler could have caught the failing check
1350 * only report a problem when there wasn't a handler, or if the handler
1351 * acknowledged the error
1353 LOG_WARNING("TAP %s:",
1354 jtag_tap_name(field->tap));
1357 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1358 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1360 if (field->in_check_mask)
1362 char *in_check_mask_char;
1363 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1364 LOG_WARNING("value captured during scan didn't pass the requested check:");
1365 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1366 captured_char, in_check_value_char, in_check_mask_char);
1367 free(in_check_mask_char);
1371 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);
1374 free(captured_char);
1375 free(in_check_value_char);
1377 retval = ERROR_JTAG_QUEUE_FAILED;
1385 set up checking of this field using the in_handler. The values passed in must be valid until
1386 after jtag_execute() has completed.
1388 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1391 field->in_handler = jtag_check_value;
1393 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1394 field->in_handler_priv = NULL;
1395 field->in_check_value = value;
1396 field->in_check_mask = mask;
1399 enum scan_type jtag_scan_type(scan_command_t *cmd)
1404 for (i = 0; i < cmd->num_fields; i++)
1406 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1408 if (cmd->fields[i].out_value)
1415 int MINIDRIVER(interface_jtag_execute_queue)(void)
1421 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1425 retval = jtag->execute_queue();
1429 jtag_command_queue = NULL;
1430 last_comand_pointer = &jtag_command_queue;
1435 int jtag_execute_queue(void)
1437 int retval=interface_jtag_execute_queue();
1438 if (retval==ERROR_OK)
1442 jtag_error=ERROR_OK;
1446 int jtag_reset_callback(enum jtag_event event, void *priv)
1448 jtag_tap_t *tap = priv;
1452 if (event == JTAG_TRST_ASSERTED)
1454 buf_set_ones(tap->cur_instr, tap->ir_length);
1461 void jtag_sleep(u32 us)
1463 alive_sleep(us/1000);
1466 /* Try to examine chain layout according to IEEE 1149.1 §12
1468 int jtag_examine_chain(void)
1472 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1475 int device_count = 0;
1476 u8 zero_check = 0x0;
1477 u8 one_check = 0xff;
1480 field.num_bits = sizeof(idcode_buffer) * 8;
1481 field.out_value = idcode_buffer;
1482 field.out_mask = NULL;
1483 field.in_value = idcode_buffer;
1484 field.in_check_value = NULL;
1485 field.in_check_mask = NULL;
1486 field.in_handler = NULL;
1487 field.in_handler_priv = NULL;
1489 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1491 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1494 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1495 jtag_execute_queue();
1497 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1499 zero_check |= idcode_buffer[i];
1500 one_check &= idcode_buffer[i];
1503 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1504 if ((zero_check == 0x00) || (one_check == 0xff))
1506 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1507 return ERROR_JTAG_INIT_FAILED;
1510 /* point at the 1st tap */
1511 tap = jtag_NextEnabledTap(NULL);
1513 LOG_ERROR("JTAG: No taps enabled?");
1514 return ERROR_JTAG_INIT_FAILED;
1517 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1519 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1520 if ((idcode & 1) == 0)
1522 /* LSB must not be 0, this indicates a device in bypass */
1523 LOG_WARNING("Tap/Device does not have IDCODE");
1534 if (idcode == 0x000000FF)
1537 /* End of chain (invalid manufacturer ID)
1539 * The JTAG examine is the very first thing that happens
1541 * A single JTAG device requires only 64 bits to be read back correctly.
1543 * The code below adds a check that the rest of the data scanned (640 bits)
1544 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1546 * earlier and gives more helpful/explicit error messages.
1548 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1550 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1551 if (unexpected||(idcode != 0x000000FF))
1553 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1561 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1562 manufacturer = EXTRACT_MFG(idcode);
1563 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1564 part = EXTRACT_PART(idcode);
1565 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1566 version = EXTRACT_VER(idcode);
1568 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1569 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1570 idcode, manufacturer, part, version);
1576 tap->idcode = idcode;
1578 if (tap->expected_ids_cnt > 0) {
1579 /* Loop over the expected identification codes and test for a match */
1581 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1582 if( tap->idcode == tap->expected_ids[ii] ){
1587 /* If none of the expected ids matched, log an error */
1588 if (ii == tap->expected_ids_cnt) {
1589 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1592 EXTRACT_MFG( tap->idcode ),
1593 EXTRACT_PART( tap->idcode ),
1594 EXTRACT_VER( tap->idcode ) );
1595 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1596 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1599 tap->expected_ids_cnt,
1600 tap->expected_ids[ii],
1601 EXTRACT_MFG( tap->expected_ids[ii] ),
1602 EXTRACT_PART( tap->expected_ids[ii] ),
1603 EXTRACT_VER( tap->expected_ids[ii] ) );
1606 return ERROR_JTAG_INIT_FAILED;
1608 LOG_INFO("JTAG Tap/device matched");
1612 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1616 tap = jtag_NextEnabledTap(tap);
1621 /* see if number of discovered devices matches configuration */
1622 if (device_count != jtag_NumEnabledTaps())
1624 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1625 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1626 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1627 return ERROR_JTAG_INIT_FAILED;
1633 int jtag_validate_chain(void)
1636 int total_ir_length = 0;
1642 total_ir_length = 0;
1644 tap = jtag_NextEnabledTap(tap);
1648 total_ir_length += tap->ir_length;
1651 total_ir_length += 2;
1652 ir_test = malloc(CEIL(total_ir_length, 8));
1653 buf_set_ones(ir_test, total_ir_length);
1656 field.num_bits = total_ir_length;
1657 field.out_value = ir_test;
1658 field.out_mask = NULL;
1659 field.in_value = ir_test;
1660 field.in_check_value = NULL;
1661 field.in_check_mask = NULL;
1662 field.in_handler = NULL;
1663 field.in_handler_priv = NULL;
1665 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1666 jtag_execute_queue();
1672 tap = jtag_NextEnabledTap(tap);
1677 val = buf_get_u32(ir_test, chain_pos, 2);
1680 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1681 LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf, jtag_tap_name(tap), chain_pos, val);
1684 return ERROR_JTAG_INIT_FAILED;
1686 chain_pos += tap->ir_length;
1689 val = buf_get_u32(ir_test, chain_pos, 2);
1692 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1693 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf, chain_pos, val);
1696 return ERROR_JTAG_INIT_FAILED;
1704 enum jtag_tap_cfg_param {
1708 static Jim_Nvp nvp_config_opts[] = {
1709 { .name = "-event", .value = JCFG_EVENT },
1711 { .name = NULL, .value = -1 }
1714 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1720 /* parse config or cget options */
1721 while (goi->argc > 0) {
1722 Jim_SetEmptyResult (goi->interp);
1724 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1726 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1732 if (goi->argc == 0) {
1733 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1737 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1739 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1743 if (goi->isconfigure) {
1744 if (goi->argc != 1) {
1745 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1749 if (goi->argc != 0) {
1750 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1756 jtag_tap_event_action_t *jteap;
1758 jteap = tap->event_action;
1759 /* replace existing? */
1761 if (jteap->event == (enum jtag_tap_event)n->value) {
1764 jteap = jteap->next;
1767 if (goi->isconfigure) {
1768 if (jteap == NULL) {
1770 jteap = calloc(1, sizeof (*jteap));
1772 jteap->event = n->value;
1773 Jim_GetOpt_Obj( goi, &o);
1775 Jim_DecrRefCount(interp, jteap->body);
1777 jteap->body = Jim_DuplicateObj(goi->interp, o);
1778 Jim_IncrRefCount(jteap->body);
1780 /* add to head of event list */
1781 jteap->next = tap->event_action;
1782 tap->event_action = jteap;
1783 Jim_SetEmptyResult(goi->interp);
1786 if (jteap == NULL) {
1787 Jim_SetEmptyResult(goi->interp);
1789 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1796 } /* while (goi->argc) */
1801 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1811 const Jim_Nvp opts[] = {
1812 #define NTAP_OPT_IRLEN 0
1813 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1814 #define NTAP_OPT_IRMASK 1
1815 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1816 #define NTAP_OPT_IRCAPTURE 2
1817 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1818 #define NTAP_OPT_ENABLED 3
1819 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1820 #define NTAP_OPT_DISABLED 4
1821 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1822 #define NTAP_OPT_EXPECTED_ID 5
1823 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1824 { .name = NULL , .value = -1 },
1827 pTap = malloc( sizeof(jtag_tap_t) );
1828 memset( pTap, 0, sizeof(*pTap) );
1830 Jim_SetResult_sprintf( goi->interp, "no memory");
1834 * we expect CHIP + TAP + OPTIONS
1836 if( goi->argc < 3 ){
1837 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1840 Jim_GetOpt_String( goi, &cp, NULL );
1841 pTap->chip = strdup(cp);
1843 Jim_GetOpt_String( goi, &cp, NULL );
1844 pTap->tapname = strdup(cp);
1846 /* name + dot + name + null */
1847 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1849 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1850 pTap->dotted_name = cp;
1852 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1853 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1855 /* default is enabled */
1858 /* deal with options */
1859 #define NTREQ_IRLEN 1
1860 #define NTREQ_IRCAPTURE 2
1861 #define NTREQ_IRMASK 4
1863 /* clear them as we find them */
1864 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1867 e = Jim_GetOpt_Nvp( goi, opts, &n );
1869 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1872 LOG_DEBUG("Processing option: %s", n->name );
1874 case NTAP_OPT_ENABLED:
1877 case NTAP_OPT_DISABLED:
1880 case NTAP_OPT_EXPECTED_ID:
1882 u32 *new_expected_ids;
1884 e = Jim_GetOpt_Wide( goi, &w );
1886 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1890 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1891 if (new_expected_ids == NULL) {
1892 Jim_SetResult_sprintf( goi->interp, "no memory");
1896 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1898 new_expected_ids[pTap->expected_ids_cnt] = w;
1900 free(pTap->expected_ids);
1901 pTap->expected_ids = new_expected_ids;
1902 pTap->expected_ids_cnt++;
1905 case NTAP_OPT_IRLEN:
1906 case NTAP_OPT_IRMASK:
1907 case NTAP_OPT_IRCAPTURE:
1908 e = Jim_GetOpt_Wide( goi, &w );
1910 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1913 if( (w < 0) || (w > 0xffff) ){
1915 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1916 n->name, (int)(w), (int)(w));
1920 case NTAP_OPT_IRLEN:
1921 pTap->ir_length = w;
1922 reqbits &= (~(NTREQ_IRLEN));
1924 case NTAP_OPT_IRMASK:
1925 pTap->ir_capture_mask = w;
1926 reqbits &= (~(NTREQ_IRMASK));
1928 case NTAP_OPT_IRCAPTURE:
1929 pTap->ir_capture_value = w;
1930 reqbits &= (~(NTREQ_IRCAPTURE));
1933 } /* switch(n->value) */
1934 } /* while( goi->argc ) */
1936 /* Did we get all the options? */
1939 Jim_SetResult_sprintf( goi->interp,
1940 "newtap: %s missing required parameters",
1942 /* TODO: Tell user what is missing :-( */
1943 /* no memory leaks pelase */
1944 free(((void *)(pTap->expected_ids)));
1945 free(((void *)(pTap->chip)));
1946 free(((void *)(pTap->tapname)));
1947 free(((void *)(pTap->dotted_name)));
1948 free(((void *)(pTap)));
1952 pTap->expected = malloc( pTap->ir_length );
1953 pTap->expected_mask = malloc( pTap->ir_length );
1954 pTap->cur_instr = malloc( pTap->ir_length );
1956 buf_set_u32( pTap->expected,
1959 pTap->ir_capture_value );
1960 buf_set_u32( pTap->expected_mask,
1963 pTap->ir_capture_mask );
1964 buf_set_ones( pTap->cur_instr,
1969 jtag_register_event_callback(jtag_reset_callback, pTap );
1971 ppTap = &(jtag_all_taps);
1972 while( (*ppTap) != NULL ){
1973 ppTap = &((*ppTap)->next_tap);
1977 static int n_taps = 0;
1978 pTap->abs_chain_position = n_taps++;
1980 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1981 (*ppTap)->dotted_name,
1982 (*ppTap)->abs_chain_position,
1983 (*ppTap)->ir_length,
1984 (*ppTap)->ir_capture_value,
1985 (*ppTap)->ir_capture_mask );
1990 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1996 struct command_context_s *context;
2000 JTAG_CMD_INIT_RESET,
2003 JTAG_CMD_TAPDISABLE,
2004 JTAG_CMD_TAPISENABLED,
2009 const Jim_Nvp jtag_cmds[] = {
2010 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2011 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2012 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2013 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2014 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2015 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2016 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2017 { .name = "cget" , .value = JTAG_CMD_CGET },
2019 { .name = NULL, .value = -1 },
2022 context = Jim_GetAssocData(interp, "context");
2023 /* go past the command */
2024 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2026 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2028 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2031 Jim_SetEmptyResult( goi.interp );
2033 case JTAG_CMD_INTERFACE:
2034 /* return the name of the interface */
2035 /* TCL code might need to know the exact type... */
2036 /* FUTURE: we allow this as a means to "set" the interface. */
2037 if( goi.argc != 0 ){
2038 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2041 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2043 case JTAG_CMD_INIT_RESET:
2044 if( goi.argc != 0 ){
2045 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2048 e = jtag_init_reset(context);
2049 if( e != ERROR_OK ){
2050 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2054 case JTAG_CMD_NEWTAP:
2055 return jim_newtap_cmd( &goi );
2057 case JTAG_CMD_TAPISENABLED:
2058 case JTAG_CMD_TAPENABLE:
2059 case JTAG_CMD_TAPDISABLE:
2060 if( goi.argc != 1 ){
2061 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2067 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2072 case JTAG_CMD_TAPISENABLED:
2075 case JTAG_CMD_TAPENABLE:
2076 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2080 case JTAG_CMD_TAPDISABLE:
2081 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2086 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2093 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2100 Jim_GetOpt_Obj(&goi, &o);
2101 t = jtag_TapByJimObj( goi.interp, o );
2106 goi.isconfigure = 0;
2107 return jtag_tap_configure_cmd( &goi, t);
2111 case JTAG_CMD_CONFIGURE:
2113 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2120 Jim_GetOpt_Obj(&goi, &o);
2121 t = jtag_TapByJimObj( goi.interp, o );
2126 goi.isconfigure = 1;
2127 return jtag_tap_configure_cmd( &goi, t);
2134 int jtag_register_commands(struct command_context_s *cmd_ctx)
2136 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2138 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2139 COMMAND_CONFIG, "try to configure interface");
2140 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2141 COMMAND_ANY, "set jtag speed (if supported)");
2142 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2143 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2144 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2145 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2146 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2148 "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]");
2149 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2150 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2151 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2152 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2154 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2155 COMMAND_EXEC, "print current scan chain configuration");
2157 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2158 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2159 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2160 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2161 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2162 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2163 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2164 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2165 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2167 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2168 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2172 int jtag_interface_init(struct command_context_s *cmd_ctx)
2177 if (!jtag_interface)
2179 /* nothing was previously specified by "interface" command */
2180 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2181 return ERROR_JTAG_INVALID_INTERFACE;
2185 jtag_interface->khz(speed_khz, &jtag_speed);
2189 if (jtag_interface->init() != ERROR_OK)
2190 return ERROR_JTAG_INIT_FAILED;
2192 jtag = jtag_interface;
2196 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2201 LOG_DEBUG("Init JTAG chain");
2203 tap = jtag_NextEnabledTap(NULL);
2205 LOG_ERROR("There are no enabled taps?");
2206 return ERROR_JTAG_INIT_FAILED;
2210 if ((retval=jtag_execute_queue())!=ERROR_OK)
2213 /* examine chain first, as this could discover the real chain layout */
2214 if (jtag_examine_chain() != ERROR_OK)
2216 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2219 if (jtag_validate_chain() != ERROR_OK)
2221 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2227 int jtag_init_reset(struct command_context_s *cmd_ctx)
2231 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2234 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2236 /* Reset can happen after a power cycle.
2238 * Ideally we would only assert TRST or run RESET before the target reset.
2240 * However w/srst_pulls_trst, trst is asserted together with the target
2241 * reset whether we want it or not.
2243 * NB! Some targets have JTAG circuitry disabled until a
2244 * trst & srst has been asserted.
2246 * NB! here we assume nsrst/ntrst delay are sufficient!
2248 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2251 jtag_add_reset(1, 0); /* RESET or TRST */
2252 if (jtag_reset_config & RESET_HAS_SRST)
2254 jtag_add_reset(1, 1);
2255 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2256 jtag_add_reset(0, 1);
2258 jtag_add_reset(0, 0);
2259 if ((retval = jtag_execute_queue()) != ERROR_OK)
2262 /* Check that we can communication on the JTAG chain + eventually we want to
2263 * be able to perform enumeration only after OpenOCD has started
2264 * telnet and GDB server
2266 * That would allow users to more easily perform any magic they need to before
2269 return jtag_init_inner(cmd_ctx);
2272 int jtag_init(struct command_context_s *cmd_ctx)
2275 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2277 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2281 return jtag_init_reset(cmd_ctx);
2284 static int default_khz(int khz, int *jtag_speed)
2286 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2290 static int default_speed_div(int speed, int *khz)
2292 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2296 static int default_power_dropout(int *dropout)
2298 *dropout=0; /* by default we can't detect power dropout */
2302 static int default_srst_asserted(int *srst_asserted)
2304 *srst_asserted=0; /* by default we can't detect srst asserted */
2308 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2313 /* check whether the interface is already configured */
2316 LOG_WARNING("Interface already configured, ignoring");
2320 /* interface name is a mandatory argument */
2321 if (argc < 1 || args[0][0] == '\0')
2323 return ERROR_COMMAND_SYNTAX_ERROR;
2326 for (i=0; jtag_interfaces[i]; i++)
2328 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2330 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2335 jtag_interface = jtag_interfaces[i];
2337 if (jtag_interface->khz == NULL)
2339 jtag_interface->khz = default_khz;
2341 if (jtag_interface->speed_div == NULL)
2343 jtag_interface->speed_div = default_speed_div;
2345 if (jtag_interface->power_dropout == NULL)
2347 jtag_interface->power_dropout = default_power_dropout;
2349 if (jtag_interface->srst_asserted == NULL)
2351 jtag_interface->srst_asserted = default_srst_asserted;
2358 /* no valid interface was found (i.e. the configuration option,
2359 * didn't match one of the compiled-in interfaces
2361 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2362 LOG_ERROR("compiled-in jtag interfaces:");
2363 for (i = 0; jtag_interfaces[i]; i++)
2365 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2368 return ERROR_JTAG_INVALID_INTERFACE;
2371 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2375 Jim_Obj *newargs[ 10 ];
2378 * argv[-1] = command
2379 * argv[ 0] = ir length
2380 * argv[ 1] = ir capture
2381 * argv[ 2] = ir mask
2382 * argv[ 3] = not actually used by anything but in the docs
2386 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2389 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2390 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2394 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2395 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2396 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2397 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2399 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2400 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2401 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2402 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2403 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2404 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2405 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2406 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2407 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2408 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2409 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2410 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2412 command_print( cmd_ctx, "NEW COMMAND:");
2413 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2414 Jim_GetString( newargs[0], NULL ),
2415 Jim_GetString( newargs[1], NULL ),
2416 Jim_GetString( newargs[2], NULL ),
2417 Jim_GetString( newargs[3], NULL ),
2418 Jim_GetString( newargs[4], NULL ),
2419 Jim_GetString( newargs[5], NULL ),
2420 Jim_GetString( newargs[6], NULL ),
2421 Jim_GetString( newargs[7], NULL ),
2422 Jim_GetString( newargs[8], NULL ),
2423 Jim_GetString( newargs[9], NULL ) );
2425 e = jim_jtag_command( interp, 10, newargs );
2427 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2432 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2436 tap = jtag_all_taps;
2437 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2438 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2441 u32 expected, expected_mask, cur_instr, ii;
2442 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2443 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2444 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2446 command_print(cmd_ctx,
2447 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2448 tap->abs_chain_position,
2450 tap->enabled ? 'Y' : 'n',
2452 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2458 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2459 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2460 tap->expected_ids[ii]);
2463 tap = tap->next_tap;
2469 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2472 return ERROR_COMMAND_SYNTAX_ERROR;
2476 if (strcmp(args[0], "none") == 0)
2477 jtag_reset_config = RESET_NONE;
2478 else if (strcmp(args[0], "trst_only") == 0)
2479 jtag_reset_config = RESET_HAS_TRST;
2480 else if (strcmp(args[0], "srst_only") == 0)
2481 jtag_reset_config = RESET_HAS_SRST;
2482 else if (strcmp(args[0], "trst_and_srst") == 0)
2483 jtag_reset_config = RESET_TRST_AND_SRST;
2486 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2487 jtag_reset_config = RESET_NONE;
2488 return ERROR_INVALID_ARGUMENTS;
2494 if (strcmp(args[1], "separate") == 0)
2496 /* seperate reset lines - default */
2499 if (strcmp(args[1], "srst_pulls_trst") == 0)
2500 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2501 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2502 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2503 else if (strcmp(args[1], "combined") == 0)
2504 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2507 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2508 jtag_reset_config = RESET_NONE;
2509 return ERROR_INVALID_ARGUMENTS;
2516 if (strcmp(args[2], "trst_open_drain") == 0)
2517 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2518 else if (strcmp(args[2], "trst_push_pull") == 0)
2519 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2522 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2523 jtag_reset_config = RESET_NONE;
2524 return ERROR_INVALID_ARGUMENTS;
2530 if (strcmp(args[3], "srst_push_pull") == 0)
2531 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2532 else if (strcmp(args[3], "srst_open_drain") == 0)
2533 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2536 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2537 jtag_reset_config = RESET_NONE;
2538 return ERROR_INVALID_ARGUMENTS;
2545 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2549 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2554 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2560 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2564 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2569 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2575 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2577 int retval=ERROR_OK;
2581 LOG_DEBUG("handle jtag speed");
2584 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2586 /* this command can be called during CONFIG,
2587 * in which case jtag isn't initialized */
2590 retval=jtag->speed(cur_speed);
2592 } else if (argc == 0)
2596 return ERROR_COMMAND_SYNTAX_ERROR;
2598 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2603 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2605 int retval=ERROR_OK;
2606 LOG_DEBUG("handle jtag khz");
2610 speed_khz = strtoul(args[0], NULL, 0);
2614 LOG_DEBUG("have interface set up");
2616 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2622 cur_speed = jtag_speed = speed_div1;
2624 retval=jtag->speed(cur_speed);
2633 return ERROR_COMMAND_SYNTAX_ERROR;
2638 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2644 command_print(cmd_ctx, "RCLK - adaptive");
2647 command_print(cmd_ctx, "%d kHz", speed_khz);
2653 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2659 return ERROR_COMMAND_SYNTAX_ERROR;
2663 state = tap_state_by_name( args[0] );
2665 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2666 return ERROR_COMMAND_SYNTAX_ERROR;
2668 jtag_add_end_state(state);
2669 jtag_execute_queue();
2671 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2676 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2683 return ERROR_COMMAND_SYNTAX_ERROR;
2686 if (args[0][0] == '1')
2688 else if (args[0][0] == '0')
2692 return ERROR_COMMAND_SYNTAX_ERROR;
2695 if (args[1][0] == '1')
2697 else if (args[1][0] == '0')
2701 return ERROR_COMMAND_SYNTAX_ERROR;
2704 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2705 return ERROR_JTAG_INIT_FAILED;
2707 jtag_add_reset(trst, srst);
2708 jtag_execute_queue();
2713 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2717 return ERROR_COMMAND_SYNTAX_ERROR;
2720 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2721 jtag_execute_queue();
2727 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2730 scan_field_t *fields;
2732 tap_state_t endstate;
2734 if ((argc < 2) || (argc % 2))
2736 return ERROR_COMMAND_SYNTAX_ERROR;
2739 /* optional "-endstate" */
2741 /* at the end of the arguments. */
2743 endstate = TAP_INVALID;
2745 /* have at least one pair of numbers. */
2746 /* is last pair the magic text? */
2747 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2750 cpA = args[ argc-1 ];
2751 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2752 cpS = tap_state_name( endstate );
2753 if( 0 == strcmp( cpA, cpS ) ){
2757 if( endstate >= TAP_NUM_STATES ){
2758 return ERROR_COMMAND_SYNTAX_ERROR;
2760 /* found - remove the last 2 args */
2766 fields = malloc(sizeof(scan_field_t) * argc / 2);
2768 for (i = 0; i < argc / 2; i++)
2770 tap = jtag_TapByString( args[i*2] );
2773 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2776 int field_size = tap->ir_length;
2777 fields[i].tap = tap;
2778 fields[i].out_value = malloc(CEIL(field_size, 8));
2779 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2780 fields[i].out_mask = NULL;
2781 fields[i].in_value = NULL;
2782 fields[i].in_check_mask = NULL;
2783 fields[i].in_handler = NULL;
2784 fields[i].in_handler_priv = NULL;
2787 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2788 /* did we have an endstate? */
2789 if (endstate != TAP_INVALID)
2790 jtag_add_end_state(endstate);
2792 jtag_execute_queue();
2794 for (i = 0; i < argc / 2; i++)
2795 free(fields[i].out_value);
2802 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2805 scan_field_t *fields;
2807 int field_count = 0;
2810 tap_state_t endstate;
2813 * args[2] = num_bits
2814 * args[3] = hex string
2815 * ... repeat num bits and hex string ...
2818 * args[N-2] = "-endstate"
2819 * args[N-1] = statename
2821 if ((argc < 4) || ((argc % 2)!=0))
2823 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2827 /* assume no endstate */
2828 endstate = TAP_INVALID;
2829 /* validate arguments as numbers */
2831 for (i = 2; i < argc; i+=2)
2836 e = Jim_GetLong(interp, args[i], &bits);
2837 /* If valid - try next arg */
2842 /* Not valid.. are we at the end? */
2843 if ( ((i+2) != argc) ){
2844 /* nope, then error */
2848 /* it could be: "-endstate FOO" */
2850 /* get arg as a string. */
2851 cp = Jim_GetString( args[i], NULL );
2852 /* is it the magic? */
2853 if( 0 == strcmp( "-endstate", cp ) ){
2854 /* is the statename valid? */
2855 cp = Jim_GetString( args[i+1], NULL );
2857 /* see if it is a valid state name */
2858 endstate = tap_state_by_name(cp);
2860 /* update the error message */
2861 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2863 /* valid - so clear the error */
2865 /* and remove the last 2 args */
2870 /* Still an error? */
2872 return e; /* too bad */
2874 } /* validate args */
2876 tap = jtag_TapByJimObj( interp, args[1] );
2881 num_fields=(argc-2)/2;
2882 fields = malloc(sizeof(scan_field_t) * num_fields);
2883 for (i = 2; i < argc; i+=2)
2889 Jim_GetLong(interp, args[i], &bits);
2890 str = Jim_GetString(args[i+1], &len);
2892 fields[field_count].tap = tap;
2893 fields[field_count].num_bits = bits;
2894 fields[field_count].out_value = malloc(CEIL(bits, 8));
2895 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2896 fields[field_count].out_mask = NULL;
2897 fields[field_count].in_value = fields[field_count].out_value;
2898 fields[field_count].in_check_mask = NULL;
2899 fields[field_count].in_check_value = NULL;
2900 fields[field_count].in_handler = NULL;
2901 fields[field_count++].in_handler_priv = NULL;
2904 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2905 /* did we get an end state? */
2906 if (endstate != TAP_INVALID)
2907 jtag_add_end_state(endstate);
2909 retval = jtag_execute_queue();
2910 if (retval != ERROR_OK)
2912 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2917 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2918 for (i = 2; i < argc; i+=2)
2923 Jim_GetLong(interp, args[i], &bits);
2924 str = buf_to_str(fields[field_count].in_value, bits, 16);
2925 free(fields[field_count].out_value);
2927 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2932 Jim_SetResult(interp, list);
2939 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2943 if (strcmp(args[0], "enable") == 0)
2945 jtag_verify_capture_ir = 1;
2947 else if (strcmp(args[0], "disable") == 0)
2949 jtag_verify_capture_ir = 0;
2952 return ERROR_COMMAND_SYNTAX_ERROR;
2954 } else if (argc != 0)
2956 return ERROR_COMMAND_SYNTAX_ERROR;
2959 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2964 int jtag_power_dropout(int *dropout)
2966 return jtag->power_dropout(dropout);
2969 int jtag_srst_asserted(int *srst_asserted)
2971 return jtag->srst_asserted(srst_asserted);
2974 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2976 jtag_tap_event_action_t * jteap;
2979 jteap = tap->event_action;
2983 if (jteap->event == e) {
2985 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2988 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2989 Jim_GetString(jteap->body, NULL) );
2990 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2991 Jim_PrintErrorMessage(interp);
2995 jteap = jteap->next;
2999 LOG_DEBUG( "event %d %s - no action",
3001 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3005 /*-----<Cable Helper API>---------------------------------------*/
3007 /* these Cable Helper API functions are all documented in the jtag.h header file,
3008 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3009 is setup to prefer its docs in the header file, no documentation is here, for
3010 if it were, it would have to be doubly maintained.
3014 * @see tap_set_state() and tap_get_state() accessors.
3015 * Actual name is not important since accessors hide it.
3017 static tap_state_t state_follower = TAP_RESET;
3019 void tap_set_state_impl( tap_state_t new_state )
3021 /* this is the state we think the TAPs are in now, was cur_state */
3022 state_follower = new_state;
3025 tap_state_t tap_get_state()
3027 return state_follower;
3031 * @see tap_set_end_state() and tap_get_end_state() accessors.
3032 * Actual name is not important because accessors hide it.
3034 static tap_state_t end_state_follower = TAP_RESET;
3036 void tap_set_end_state( tap_state_t new_end_state )
3038 /* this is the state we think the TAPs will be in at completion of the
3039 current TAP operation, was end_state
3041 end_state_follower = new_end_state;
3044 tap_state_t tap_get_end_state()
3046 return end_state_follower;
3050 int tap_move_ndx( tap_state_t astate )
3052 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3055 const static int move_map[16] =
3057 0, -1, -1, 2, -1, 3, -1, -1,
3058 1, -1, -1, 4, -1, 5, -1, -1
3066 case TAP_RESET: ndx = 0; break;
3067 case TAP_DRSHIFT: ndx = 2; break;
3068 case TAP_DRPAUSE: ndx = 3; break;
3069 case TAP_IDLE: ndx = 1; break;
3070 case TAP_IRSHIFT: ndx = 4; break;
3071 case TAP_IRPAUSE: ndx = 5; break;
3073 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3080 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3082 /* tap_move[i][j]: tap movement command to go from state i to state j
3083 * 0: Test-Logic-Reset
3090 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3092 static const u8 tms_seqs[6][6] =
3094 /* value clocked to TMS to move from one of six stable states to another */
3096 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3097 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3098 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3099 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3100 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3101 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3102 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3105 if( !tap_is_state_stable(from) )
3107 LOG_ERROR( "fatal: tap_state \"from\" (=%s) is not stable", tap_state_name(from) );
3111 if( !tap_is_state_stable(to) )
3113 LOG_ERROR( "fatal: tap_state \"to\" (=%s) is not stable", tap_state_name(to) );
3117 /* @todo: support other than 7 clocks ? */
3118 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)];
3122 bool tap_is_state_stable(tap_state_t astate)
3126 /* A switch() is used because it is symbol dependent
3127 (not value dependent like an array), and can also check bounds.
3146 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3148 tap_state_t new_state;
3150 /* A switch is used because it is symbol dependent and not value dependent
3151 like an array. Also it can check for out of range conditions.
3159 new_state = cur_state;
3164 new_state = TAP_DRSELECT;
3167 new_state = TAP_IRSELECT;
3171 new_state = TAP_DREXIT1;
3175 new_state = TAP_DRUPDATE;
3178 new_state = TAP_DREXIT2;
3181 new_state = TAP_RESET;
3185 new_state = TAP_IREXIT1;
3189 new_state = TAP_IRUPDATE;
3192 new_state = TAP_IREXIT2;
3195 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3208 new_state = TAP_IDLE;
3211 new_state = TAP_DRCAPTURE;
3216 new_state = TAP_DRSHIFT;
3220 new_state = TAP_DRPAUSE;
3223 new_state = TAP_IRCAPTURE;
3228 new_state = TAP_IRSHIFT;
3232 new_state = TAP_IRPAUSE;
3235 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3244 const char* tap_state_name(tap_state_t state)
3250 case TAP_RESET: ret = "RESET"; break;
3251 case TAP_IDLE: ret = "RUN/IDLE"; break;
3252 case TAP_DRSELECT: ret = "DRSELECT"; break;
3253 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3254 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3255 case TAP_DREXIT1: ret = "DREXIT1"; break;
3256 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3257 case TAP_DREXIT2: ret = "DREXIT2"; break;
3258 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3259 case TAP_IRSELECT: ret = "IRSELECT"; break;
3260 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3261 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3262 case TAP_IREXIT1: ret = "IREXIT1"; break;
3263 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3264 case TAP_IREXIT2: ret = "IREXIT2"; break;
3265 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3266 default: ret = "???";
3272 static tap_state_t tap_state_by_name( const char *name )
3276 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3277 /* be nice to the human */
3278 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3286 /*-----</Cable Helper API>--------------------------------------*/