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"
48 /* note that this is not marked as static as it must be available from outside jtag.c for those
49 that implement the jtag_xxx() minidriver layer
51 int jtag_error=ERROR_OK;
53 typedef struct cmd_queue_page_s
57 struct cmd_queue_page_s *next;
60 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
61 static cmd_queue_page_t *cmd_queue_pages = NULL;
63 char* jtag_event_strings[] =
65 "JTAG controller reset (RESET or TRST)"
68 const Jim_Nvp nvp_jtag_tap_event[] = {
69 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
70 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
72 { .name = NULL, .value = -1 }
78 jtag_command_t *jtag_command_queue = NULL;
79 jtag_command_t **last_comand_pointer = &jtag_command_queue;
80 static jtag_tap_t *jtag_all_taps = NULL;
82 enum reset_types jtag_reset_config = RESET_NONE;
83 tap_state_t cmd_queue_end_state = TAP_RESET;
84 tap_state_t cmd_queue_cur_state = TAP_RESET;
86 int jtag_verify_capture_ir = 1;
88 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
89 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
90 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
92 /* maximum number of JTAG devices expected in the chain
94 #define JTAG_MAX_CHAIN_SIZE 20
96 /* callbacks to inform high-level handlers about JTAG state changes */
97 jtag_event_callback_t *jtag_event_callbacks;
100 static int speed_khz = 0;
101 /* flag if the kHz speed was defined */
102 static int hasKHz = 0;
104 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
107 #if BUILD_ECOSBOARD == 1
108 extern jtag_interface_t zy1000_interface;
111 #if BUILD_PARPORT == 1
112 extern jtag_interface_t parport_interface;
116 extern jtag_interface_t dummy_interface;
119 #if BUILD_FT2232_FTD2XX == 1
120 extern jtag_interface_t ft2232_interface;
123 #if BUILD_FT2232_LIBFTDI == 1
124 extern jtag_interface_t ft2232_interface;
127 #if BUILD_AMTJTAGACCEL == 1
128 extern jtag_interface_t amt_jtagaccel_interface;
131 #if BUILD_EP93XX == 1
132 extern jtag_interface_t ep93xx_interface;
135 #if BUILD_AT91RM9200 == 1
136 extern jtag_interface_t at91rm9200_interface;
139 #if BUILD_GW16012 == 1
140 extern jtag_interface_t gw16012_interface;
143 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
144 extern jtag_interface_t presto_interface;
147 #if BUILD_USBPROG == 1
148 extern jtag_interface_t usbprog_interface;
152 extern jtag_interface_t jlink_interface;
155 #if BUILD_VSLLINK == 1
156 extern jtag_interface_t vsllink_interface;
160 extern jtag_interface_t rlink_interface;
163 #if BUILD_ARMJTAGEW == 1
164 extern jtag_interface_t armjtagew_interface;
167 jtag_interface_t *jtag_interfaces[] = {
168 #if BUILD_ECOSBOARD == 1
171 #if BUILD_PARPORT == 1
177 #if BUILD_FT2232_FTD2XX == 1
180 #if BUILD_FT2232_LIBFTDI == 1
183 #if BUILD_AMTJTAGACCEL == 1
184 &amt_jtagaccel_interface,
186 #if BUILD_EP93XX == 1
189 #if BUILD_AT91RM9200 == 1
190 &at91rm9200_interface,
192 #if BUILD_GW16012 == 1
195 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
198 #if BUILD_USBPROG == 1
204 #if BUILD_VSLLINK == 1
210 #if BUILD_ARMJTAGEW == 1
211 &armjtagew_interface,
216 jtag_interface_t *jtag = NULL;
219 static jtag_interface_t *jtag_interface = NULL;
222 /* forward declarations */
223 //void jtag_add_pathmove(int num_states, tap_state_t *path);
224 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
225 //void jtag_add_end_state(tap_state_t endstate);
226 //void jtag_add_sleep(u32 us);
227 //int jtag_execute_queue(void);
228 static tap_state_t tap_state_by_name(const char *name);
231 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
235 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
237 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
242 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
243 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
244 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
245 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
247 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
249 jtag_tap_t *jtag_AllTaps(void)
251 return jtag_all_taps;
254 int jtag_NumTotalTaps(void)
268 int jtag_NumEnabledTaps(void)
284 jtag_tap_t *jtag_TapByString( const char *s )
292 if( 0 == strcmp( t->dotted_name, s ) ){
298 /* backup plan is by number */
300 /* ok - is "s" a number? */
302 n = strtol( s, &cp, 0 );
303 if( (s != cp) && (*cp == 0) ){
305 t = jtag_TapByAbsPosition(n);
311 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
316 cp = Jim_GetString( o, NULL );
321 t = jtag_TapByString( cp );
324 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
329 /* returns a pointer to the n-th device in the scan chain */
330 jtag_tap_t * jtag_TapByAbsPosition( int n )
338 while( t && (n > 0)) {
345 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
347 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
349 if (callback == NULL)
351 return ERROR_INVALID_ARGUMENTS;
356 while ((*callbacks_p)->next)
357 callbacks_p = &((*callbacks_p)->next);
358 callbacks_p = &((*callbacks_p)->next);
361 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
362 (*callbacks_p)->callback = callback;
363 (*callbacks_p)->priv = priv;
364 (*callbacks_p)->next = NULL;
369 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
371 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
373 if (callback == NULL)
375 return ERROR_INVALID_ARGUMENTS;
380 jtag_event_callback_t **next = &((*callbacks_p)->next);
381 if ((*callbacks_p)->callback == callback)
384 *callbacks_p = *next;
392 int jtag_call_event_callbacks(enum jtag_event event)
394 jtag_event_callback_t *callback = jtag_event_callbacks;
396 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
400 callback->callback(event, callback->priv);
401 callback = callback->next;
407 /* returns a pointer to the pointer of the last command in queue
408 * this may be a pointer to the root pointer (jtag_command_queue)
409 * or to the next member of the last but one command
411 jtag_command_t** jtag_get_last_command_p(void)
413 /* jtag_command_t *cmd = jtag_command_queue;
419 return &jtag_command_queue;
423 return last_comand_pointer;
426 void* cmd_queue_alloc(size_t size)
428 cmd_queue_page_t **p_page = &cmd_queue_pages;
434 * We align/round the *SIZE* per below
435 * so that all pointers returned by
436 * this function are reasonably well
439 * If we did not, then an "odd-length" request would cause the
440 * *next* allocation to be at an *odd* address, and because
441 * this function has the same type of api as malloc() - we
442 * must also return pointers that have the same type of
445 * What I do not/have is a reasonable portable means
448 * The solution here, is based on these suggestions.
449 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
452 union worse_case_align {
458 #define ALIGN_SIZE (sizeof(union worse_case_align))
460 /* The alignment process. */
461 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
466 while ((*p_page)->next)
467 p_page = &((*p_page)->next);
468 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
469 p_page = &((*p_page)->next);
474 *p_page = malloc(sizeof(cmd_queue_page_t));
476 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
477 (*p_page)->next = NULL;
480 offset = (*p_page)->used;
481 (*p_page)->used += size;
483 t=(u8 *)((*p_page)->address);
487 void cmd_queue_free(void)
489 cmd_queue_page_t *page = cmd_queue_pages;
493 cmd_queue_page_t *last = page;
499 cmd_queue_pages = NULL;
502 static void jtag_prelude1(void)
506 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
507 jtag_error=ERROR_JTAG_TRST_ASSERTED;
511 if (cmd_queue_end_state == TAP_RESET)
512 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
515 static void jtag_prelude(tap_state_t state)
519 if (state != TAP_INVALID)
520 jtag_add_end_state(state);
522 cmd_queue_cur_state = cmd_queue_end_state;
525 void jtag_add_ir_scan_noverify(int num_fields, scan_field_t *fields, tap_state_t state)
530 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
531 if (retval!=ERROR_OK)
537 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
539 /* 8 x 32 bit id's is enough for all invoations */
543 /* if we are to run a verification of the ir scan, we need to get the input back.
544 * We may have to allocate space if the caller didn't ask for the input back.
547 if (jtag_verify_capture_ir)
550 for (j = 0; j < num_fields; j++)
553 if ((fields[j].in_value==NULL)&&(fields[j].num_bits<=32))
558 fields[j].in_value=(u8 *)(id+j);
561 LOG_DEBUG("caller must provide in_value space for verify_capture_ir to work");
567 jtag_add_ir_scan_noverify(num_fields, fields, state);
569 if (jtag_verify_capture_ir)
572 for (j = 0; j < num_fields; j++)
574 jtag_tap_t *tap=fields[j].tap;
575 jtag_check_value_mask(fields+j, tap->expected, tap->expected_mask);
579 fields[j].in_value=NULL;
586 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
588 jtag_command_t **last_cmd;
595 last_cmd = jtag_get_last_command_p();
597 /* allocate memory for a new list member */
598 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
599 (*last_cmd)->next = NULL;
600 last_comand_pointer = &((*last_cmd)->next);
601 (*last_cmd)->type = JTAG_SCAN;
603 /* allocate memory for ir scan command */
604 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
605 (*last_cmd)->cmd.scan->ir_scan = 1;
606 x = jtag_NumEnabledTaps();
607 (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
608 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
609 (*last_cmd)->cmd.scan->end_state = state;
616 /* do this here so it is not forgotten */
617 tap = jtag_NextEnabledTap(tap);
622 scan_size = tap->ir_length;
623 (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
624 (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
625 (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
626 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */
628 /* search the list */
629 for (j = 0; j < num_fields; j++)
631 if (tap == fields[j].tap)
634 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
643 /* if a tap isn't listed, set it to BYPASS */
644 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
648 /* update device information */
649 buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
655 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
661 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
662 if (retval!=ERROR_OK)
666 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
669 jtag_command_t **last_cmd;
671 last_cmd = jtag_get_last_command_p();
673 /* allocate memory for a new list member */
674 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
675 (*last_cmd)->next = NULL;
676 last_comand_pointer = &((*last_cmd)->next);
677 (*last_cmd)->type = JTAG_SCAN;
679 /* allocate memory for ir scan command */
680 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
681 (*last_cmd)->cmd.scan->ir_scan = 1;
682 (*last_cmd)->cmd.scan->num_fields = num_fields;
683 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
684 (*last_cmd)->cmd.scan->end_state = state;
686 for( i = 0 ; i < num_fields ; i++ ){
687 int num_bits = fields[i].num_bits;
688 int num_bytes = CEIL(fields[i].num_bits, 8);
689 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
690 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
691 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
692 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
693 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
694 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
695 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
696 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
701 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
707 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
708 if (retval!=ERROR_OK)
712 void jtag_add_dr_scan_now(int num_fields, scan_field_t *fields, tap_state_t state)
714 jtag_add_dr_scan(num_fields, fields, state);
715 jtag_execute_queue_noclear();
718 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
722 int bypass_devices = 0;
726 jtag_command_t **last_cmd = jtag_get_last_command_p();
729 /* count devices in bypass */
733 tap = jtag_NextEnabledTap(tap);
742 /* allocate memory for a new list member */
743 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
744 last_comand_pointer = &((*last_cmd)->next);
745 (*last_cmd)->next = NULL;
746 (*last_cmd)->type = JTAG_SCAN;
748 /* allocate memory for dr scan command */
749 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
750 (*last_cmd)->cmd.scan->ir_scan = 0;
751 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
752 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
753 (*last_cmd)->cmd.scan->end_state = state;
759 tap = jtag_NextEnabledTap(tap);
764 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
766 for (j = 0; j < num_fields; j++)
768 if (tap == fields[j].tap)
771 scan_size = fields[j].num_bits;
772 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
773 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
774 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
775 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
776 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
777 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
778 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
783 #ifdef _DEBUG_JTAG_IO_
784 /* if a device isn't listed, the BYPASS register should be selected */
787 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
791 /* program the scan field to 1 bit length, and ignore it's value */
792 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
793 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
794 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
795 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
796 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
797 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
798 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
802 #ifdef _DEBUG_JTAG_IO_
803 /* if a device is listed, the BYPASS register must not be selected */
806 LOG_ERROR("BUG: scan data for a device in BYPASS");
815 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
819 tap_state_t end_state)
824 int bypass_devices = 0;
826 jtag_command_t **last_cmd = jtag_get_last_command_p();
829 /* count devices in bypass */
833 tap = jtag_NextEnabledTap(tap);
842 /* allocate memory for a new list member */
843 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
844 last_comand_pointer = &((*last_cmd)->next);
845 (*last_cmd)->next = NULL;
846 (*last_cmd)->type = JTAG_SCAN;
848 /* allocate memory for dr scan command */
849 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
850 (*last_cmd)->cmd.scan->ir_scan = 0;
851 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
852 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
853 (*last_cmd)->cmd.scan->end_state = end_state;
858 tap = jtag_NextEnabledTap(tap);
863 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
865 if (tap == target_tap)
868 #ifdef _DEBUG_JTAG_IO_
869 /* if a device is listed, the BYPASS register must not be selected */
872 LOG_ERROR("BUG: scan data for a device in BYPASS");
876 for (j = 0; j < num_fields; j++)
879 scan_size = num_bits[j];
880 buf_set_u32(out_value, 0, scan_size, value[j]);
881 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
882 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
883 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
884 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
885 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
886 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
887 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
891 #ifdef _DEBUG_JTAG_IO_
892 /* if a device isn't listed, the BYPASS register should be selected */
895 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
899 /* program the scan field to 1 bit length, and ignore it's value */
900 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
901 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
902 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
903 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
904 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
905 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
906 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
911 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
917 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
918 if (retval!=ERROR_OK)
922 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
925 jtag_command_t **last_cmd = jtag_get_last_command_p();
927 /* allocate memory for a new list member */
928 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
929 last_comand_pointer = &((*last_cmd)->next);
930 (*last_cmd)->next = NULL;
931 (*last_cmd)->type = JTAG_SCAN;
933 /* allocate memory for scan command */
934 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
935 (*last_cmd)->cmd.scan->ir_scan = 0;
936 (*last_cmd)->cmd.scan->num_fields = num_fields;
937 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
938 (*last_cmd)->cmd.scan->end_state = state;
940 for (i = 0; i < num_fields; i++)
942 int num_bits = fields[i].num_bits;
943 int num_bytes = CEIL(fields[i].num_bits, 8);
944 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
945 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
946 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
947 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
948 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
949 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
950 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
951 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
957 void jtag_add_tlr(void)
959 jtag_prelude(TAP_RESET);
962 retval=interface_jtag_add_tlr();
963 if (retval!=ERROR_OK)
967 int MINIDRIVER(interface_jtag_add_tlr)(void)
969 tap_state_t state = TAP_RESET;
970 jtag_command_t **last_cmd = jtag_get_last_command_p();
972 /* allocate memory for a new list member */
973 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
974 last_comand_pointer = &((*last_cmd)->next);
975 (*last_cmd)->next = NULL;
976 (*last_cmd)->type = JTAG_STATEMOVE;
978 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
979 (*last_cmd)->cmd.statemove->end_state = state;
984 void jtag_add_pathmove(int num_states, tap_state_t *path)
986 tap_state_t cur_state = cmd_queue_cur_state;
990 /* the last state has to be a stable state */
991 if (!tap_is_state_stable(path[num_states - 1]))
993 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
997 for (i=0; i<num_states; i++)
999 if (path[i] == TAP_RESET)
1001 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1005 if ( tap_state_transition(cur_state, true) != path[i]
1006 && tap_state_transition(cur_state, false) != path[i])
1008 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
1011 cur_state = path[i];
1016 retval = interface_jtag_add_pathmove(num_states, path);
1017 cmd_queue_cur_state = path[num_states - 1];
1018 if (retval!=ERROR_OK)
1022 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
1024 jtag_command_t **last_cmd = jtag_get_last_command_p();
1027 /* allocate memory for a new list member */
1028 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1029 last_comand_pointer = &((*last_cmd)->next);
1030 (*last_cmd)->next = NULL;
1031 (*last_cmd)->type = JTAG_PATHMOVE;
1033 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
1034 (*last_cmd)->cmd.pathmove->num_states = num_states;
1035 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
1037 for (i = 0; i < num_states; i++)
1038 (*last_cmd)->cmd.pathmove->path[i] = path[i];
1043 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1045 jtag_command_t **last_cmd = jtag_get_last_command_p();
1047 /* allocate memory for a new list member */
1048 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1049 (*last_cmd)->next = NULL;
1050 last_comand_pointer = &((*last_cmd)->next);
1051 (*last_cmd)->type = JTAG_RUNTEST;
1053 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1054 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1055 (*last_cmd)->cmd.runtest->end_state = state;
1060 void jtag_add_runtest(int num_cycles, tap_state_t state)
1064 jtag_prelude(state);
1066 /* executed by sw or hw fifo */
1067 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1068 if (retval!=ERROR_OK)
1073 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1075 jtag_command_t **last_cmd = jtag_get_last_command_p();
1077 /* allocate memory for a new list member */
1078 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1079 (*last_cmd)->next = NULL;
1080 last_comand_pointer = &((*last_cmd)->next);
1081 (*last_cmd)->type = JTAG_STABLECLOCKS;
1083 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1084 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1088 void jtag_add_clocks( int num_cycles )
1092 if( !tap_is_state_stable(cmd_queue_cur_state) )
1094 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1095 tap_state_name(cmd_queue_cur_state) );
1096 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1100 if( num_cycles > 0 )
1104 retval = interface_jtag_add_clocks(num_cycles);
1105 if (retval != ERROR_OK)
1110 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1112 int trst_with_tlr = 0;
1115 /* FIX!!! there are *many* different cases here. A better
1116 * approach is needed for legal combinations of transitions...
1118 if ((jtag_reset_config & RESET_HAS_SRST)&&
1119 (jtag_reset_config & RESET_HAS_TRST)&&
1120 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1122 if (((req_tlr_or_trst&&!jtag_trst)||
1123 (!req_tlr_or_trst&&jtag_trst))&&
1124 ((req_srst&&!jtag_srst)||
1125 (!req_srst&&jtag_srst)))
1127 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1128 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1132 /* Make sure that jtag_reset_config allows the requested reset */
1133 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1134 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1136 LOG_ERROR("BUG: requested reset would assert trst");
1137 jtag_error=ERROR_FAIL;
1141 /* if TRST pulls SRST, we reset with TAP T-L-R */
1142 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1147 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1149 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1150 jtag_error=ERROR_FAIL;
1154 if (req_tlr_or_trst)
1156 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1168 jtag_srst = req_srst;
1170 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1171 if (retval!=ERROR_OK)
1179 LOG_DEBUG("SRST line asserted");
1183 LOG_DEBUG("SRST line released");
1184 if (jtag_nsrst_delay)
1185 jtag_add_sleep(jtag_nsrst_delay * 1000);
1190 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1191 jtag_add_end_state(TAP_RESET);
1193 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1199 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1200 * and inform possible listeners about this
1202 LOG_DEBUG("TRST line asserted");
1203 cmd_queue_cur_state = TAP_RESET;
1204 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1208 if (jtag_ntrst_delay)
1209 jtag_add_sleep(jtag_ntrst_delay * 1000);
1213 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1215 jtag_command_t **last_cmd = jtag_get_last_command_p();
1217 /* allocate memory for a new list member */
1218 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1219 (*last_cmd)->next = NULL;
1220 last_comand_pointer = &((*last_cmd)->next);
1221 (*last_cmd)->type = JTAG_RESET;
1223 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1224 (*last_cmd)->cmd.reset->trst = req_trst;
1225 (*last_cmd)->cmd.reset->srst = req_srst;
1230 void jtag_add_end_state(tap_state_t state)
1232 cmd_queue_end_state = state;
1233 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1235 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1239 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1241 jtag_command_t **last_cmd = jtag_get_last_command_p();
1243 /* allocate memory for a new list member */
1244 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1245 (*last_cmd)->next = NULL;
1246 last_comand_pointer = &((*last_cmd)->next);
1247 (*last_cmd)->type = JTAG_SLEEP;
1249 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1250 (*last_cmd)->cmd.sleep->us = us;
1255 void jtag_add_sleep(u32 us)
1257 keep_alive(); /* we might be running on a very slow JTAG clk */
1258 int retval=interface_jtag_add_sleep(us);
1259 if (retval!=ERROR_OK)
1264 int jtag_scan_size(scan_command_t *cmd)
1269 /* count bits in scan command */
1270 for (i = 0; i < cmd->num_fields; i++)
1272 bit_count += cmd->fields[i].num_bits;
1278 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1283 bit_count = jtag_scan_size(cmd);
1284 *buffer = malloc(CEIL(bit_count, 8));
1288 #ifdef _DEBUG_JTAG_IO_
1289 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1292 for (i = 0; i < cmd->num_fields; i++)
1294 if (cmd->fields[i].out_value)
1296 #ifdef _DEBUG_JTAG_IO_
1297 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);
1299 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1300 #ifdef _DEBUG_JTAG_IO_
1301 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1307 #ifdef _DEBUG_JTAG_IO_
1308 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1312 bit_count += cmd->fields[i].num_bits;
1315 #ifdef _DEBUG_JTAG_IO_
1316 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1322 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1328 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1331 for (i = 0; i < cmd->num_fields; i++)
1333 /* if neither in_value nor in_handler
1334 * are specified we don't have to examine this field
1336 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1338 int num_bits = cmd->fields[i].num_bits;
1339 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1341 #ifdef _DEBUG_JTAG_IO_
1342 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1343 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1347 if (cmd->fields[i].in_value)
1349 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1351 if (cmd->fields[i].in_handler)
1353 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1355 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1356 retval = ERROR_JTAG_QUEUE_FAILED;
1361 /* no in_value specified, but a handler takes care of the scanned data */
1362 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1364 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1366 /* We're going to call the error:handler later, but if the in_handler
1367 * reported an error we report this failure upstream
1369 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1370 retval = ERROR_JTAG_QUEUE_FAILED;
1376 bit_count += cmd->fields[i].num_bits;
1382 static const char *jtag_tap_name(jtag_tap_t *tap)
1384 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1387 int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value, u8 *in_check_mask)
1389 int retval = ERROR_OK;
1390 int num_bits = field->num_bits;
1392 int compare_failed = 0;
1394 if (field->in_check_mask)
1395 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1397 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1399 if (compare_failed){
1400 /* An error handler could have caught the failing check
1401 * only report a problem when there wasn't a handler, or if the handler
1402 * acknowledged the error
1404 LOG_WARNING("TAP %s:",
1405 jtag_tap_name(field->tap));
1408 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1409 char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1413 char *in_check_mask_char;
1414 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1415 LOG_WARNING("value captured during scan didn't pass the requested check:");
1416 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1417 captured_char, in_check_value_char, in_check_mask_char);
1418 free(in_check_mask_char);
1422 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);
1425 free(captured_char);
1426 free(in_check_value_char);
1428 retval = ERROR_JTAG_QUEUE_FAILED;
1435 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1437 return jtag_check_value_inner(captured, field, field->in_check_value, field->in_check_mask);
1441 set up checking of this field using the in_handler. The values passed in must be valid until
1442 after jtag_execute() has completed.
1444 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, struct invalidstruct *obsolete)
1447 field->in_handler = jtag_check_value;
1449 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1450 field->in_handler_priv = NULL;
1451 field->in_check_value = value;
1452 field->in_check_mask = mask;
1455 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1457 assert(field->in_value != NULL);
1461 /* no checking to do */
1465 jtag_execute_queue_noclear();
1467 int retval=jtag_check_value_inner(field->in_value, field, value, mask);
1468 jtag_set_error(retval);
1474 enum scan_type jtag_scan_type(scan_command_t *cmd)
1479 for (i = 0; i < cmd->num_fields; i++)
1481 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1483 if (cmd->fields[i].out_value)
1490 int MINIDRIVER(interface_jtag_execute_queue)(void)
1496 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1500 retval = jtag->execute_queue();
1504 jtag_command_queue = NULL;
1505 last_comand_pointer = &jtag_command_queue;
1510 void jtag_execute_queue_noclear(void)
1512 int retval=interface_jtag_execute_queue();
1513 /* we keep the first error */
1514 if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1520 int jtag_execute_queue(void)
1523 jtag_execute_queue_noclear();
1525 jtag_error=ERROR_OK;
1529 int jtag_reset_callback(enum jtag_event event, void *priv)
1531 jtag_tap_t *tap = priv;
1535 if (event == JTAG_TRST_ASSERTED)
1537 buf_set_ones(tap->cur_instr, tap->ir_length);
1544 void jtag_sleep(u32 us)
1546 alive_sleep(us/1000);
1549 /* Try to examine chain layout according to IEEE 1149.1 §12
1551 int jtag_examine_chain(void)
1555 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1558 int device_count = 0;
1559 u8 zero_check = 0x0;
1560 u8 one_check = 0xff;
1563 field.num_bits = sizeof(idcode_buffer) * 8;
1564 field.out_value = idcode_buffer;
1566 field.in_value = idcode_buffer;
1569 field.in_handler = NULL;
1571 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1573 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1576 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1577 jtag_execute_queue();
1579 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1581 zero_check |= idcode_buffer[i];
1582 one_check &= idcode_buffer[i];
1585 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1586 if ((zero_check == 0x00) || (one_check == 0xff))
1588 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1589 return ERROR_JTAG_INIT_FAILED;
1592 /* point at the 1st tap */
1593 tap = jtag_NextEnabledTap(NULL);
1595 LOG_ERROR("JTAG: No taps enabled?");
1596 return ERROR_JTAG_INIT_FAILED;
1599 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1601 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1602 if ((idcode & 1) == 0)
1604 /* LSB must not be 0, this indicates a device in bypass */
1605 LOG_WARNING("Tap/Device does not have IDCODE");
1616 /* some devices, such as AVR will output all 1's instead of TDI
1617 input value at end of chain. */
1618 if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1621 /* End of chain (invalid manufacturer ID)
1623 * The JTAG examine is the very first thing that happens
1625 * A single JTAG device requires only 64 bits to be read back correctly.
1627 * The code below adds a check that the rest of the data scanned (640 bits)
1628 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1630 * earlier and gives more helpful/explicit error messages.
1632 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1634 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1635 if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1637 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1645 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1646 manufacturer = EXTRACT_MFG(idcode);
1647 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1648 part = EXTRACT_PART(idcode);
1649 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1650 version = EXTRACT_VER(idcode);
1652 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1653 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1654 idcode, manufacturer, part, version);
1660 tap->idcode = idcode;
1662 if (tap->expected_ids_cnt > 0) {
1663 /* Loop over the expected identification codes and test for a match */
1665 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1666 if( tap->idcode == tap->expected_ids[ii] ){
1671 /* If none of the expected ids matched, log an error */
1672 if (ii == tap->expected_ids_cnt) {
1673 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1676 EXTRACT_MFG( tap->idcode ),
1677 EXTRACT_PART( tap->idcode ),
1678 EXTRACT_VER( tap->idcode ) );
1679 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1680 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1683 tap->expected_ids_cnt,
1684 tap->expected_ids[ii],
1685 EXTRACT_MFG( tap->expected_ids[ii] ),
1686 EXTRACT_PART( tap->expected_ids[ii] ),
1687 EXTRACT_VER( tap->expected_ids[ii] ) );
1690 return ERROR_JTAG_INIT_FAILED;
1692 LOG_INFO("JTAG Tap/device matched");
1696 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1700 tap = jtag_NextEnabledTap(tap);
1705 /* see if number of discovered devices matches configuration */
1706 if (device_count != jtag_NumEnabledTaps())
1708 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1709 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1710 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1711 return ERROR_JTAG_INIT_FAILED;
1717 int jtag_validate_chain(void)
1720 int total_ir_length = 0;
1726 total_ir_length = 0;
1728 tap = jtag_NextEnabledTap(tap);
1732 total_ir_length += tap->ir_length;
1735 total_ir_length += 2;
1736 ir_test = malloc(CEIL(total_ir_length, 8));
1737 buf_set_ones(ir_test, total_ir_length);
1740 field.num_bits = total_ir_length;
1741 field.out_value = ir_test;
1742 field.in_value = ir_test;
1743 field.in_handler = NULL;
1745 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1746 jtag_execute_queue();
1752 tap = jtag_NextEnabledTap(tap);
1757 val = buf_get_u32(ir_test, chain_pos, 2);
1760 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1761 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);
1764 return ERROR_JTAG_INIT_FAILED;
1766 chain_pos += tap->ir_length;
1769 val = buf_get_u32(ir_test, chain_pos, 2);
1772 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1773 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);
1776 return ERROR_JTAG_INIT_FAILED;
1784 enum jtag_tap_cfg_param {
1788 static Jim_Nvp nvp_config_opts[] = {
1789 { .name = "-event", .value = JCFG_EVENT },
1791 { .name = NULL, .value = -1 }
1794 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1800 /* parse config or cget options */
1801 while (goi->argc > 0) {
1802 Jim_SetEmptyResult (goi->interp);
1804 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1806 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1812 if (goi->argc == 0) {
1813 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1817 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1819 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1823 if (goi->isconfigure) {
1824 if (goi->argc != 1) {
1825 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1829 if (goi->argc != 0) {
1830 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1836 jtag_tap_event_action_t *jteap;
1838 jteap = tap->event_action;
1839 /* replace existing? */
1841 if (jteap->event == (enum jtag_tap_event)n->value) {
1844 jteap = jteap->next;
1847 if (goi->isconfigure) {
1848 if (jteap == NULL) {
1850 jteap = calloc(1, sizeof (*jteap));
1852 jteap->event = n->value;
1853 Jim_GetOpt_Obj( goi, &o);
1855 Jim_DecrRefCount(interp, jteap->body);
1857 jteap->body = Jim_DuplicateObj(goi->interp, o);
1858 Jim_IncrRefCount(jteap->body);
1860 /* add to head of event list */
1861 jteap->next = tap->event_action;
1862 tap->event_action = jteap;
1863 Jim_SetEmptyResult(goi->interp);
1866 if (jteap == NULL) {
1867 Jim_SetEmptyResult(goi->interp);
1869 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1876 } /* while (goi->argc) */
1881 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1891 const Jim_Nvp opts[] = {
1892 #define NTAP_OPT_IRLEN 0
1893 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1894 #define NTAP_OPT_IRMASK 1
1895 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1896 #define NTAP_OPT_IRCAPTURE 2
1897 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1898 #define NTAP_OPT_ENABLED 3
1899 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1900 #define NTAP_OPT_DISABLED 4
1901 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1902 #define NTAP_OPT_EXPECTED_ID 5
1903 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1904 { .name = NULL , .value = -1 },
1907 pTap = malloc( sizeof(jtag_tap_t) );
1908 memset( pTap, 0, sizeof(*pTap) );
1910 Jim_SetResult_sprintf( goi->interp, "no memory");
1914 * we expect CHIP + TAP + OPTIONS
1916 if( goi->argc < 3 ){
1917 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1920 Jim_GetOpt_String( goi, &cp, NULL );
1921 pTap->chip = strdup(cp);
1923 Jim_GetOpt_String( goi, &cp, NULL );
1924 pTap->tapname = strdup(cp);
1926 /* name + dot + name + null */
1927 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1929 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1930 pTap->dotted_name = cp;
1932 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1933 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1935 /* default is enabled */
1938 /* deal with options */
1939 #define NTREQ_IRLEN 1
1940 #define NTREQ_IRCAPTURE 2
1941 #define NTREQ_IRMASK 4
1943 /* clear them as we find them */
1944 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1947 e = Jim_GetOpt_Nvp( goi, opts, &n );
1949 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1952 LOG_DEBUG("Processing option: %s", n->name );
1954 case NTAP_OPT_ENABLED:
1957 case NTAP_OPT_DISABLED:
1960 case NTAP_OPT_EXPECTED_ID:
1962 u32 *new_expected_ids;
1964 e = Jim_GetOpt_Wide( goi, &w );
1966 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1970 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1971 if (new_expected_ids == NULL) {
1972 Jim_SetResult_sprintf( goi->interp, "no memory");
1976 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1978 new_expected_ids[pTap->expected_ids_cnt] = w;
1980 free(pTap->expected_ids);
1981 pTap->expected_ids = new_expected_ids;
1982 pTap->expected_ids_cnt++;
1985 case NTAP_OPT_IRLEN:
1986 case NTAP_OPT_IRMASK:
1987 case NTAP_OPT_IRCAPTURE:
1988 e = Jim_GetOpt_Wide( goi, &w );
1990 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1993 if( (w < 0) || (w > 0xffff) ){
1995 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1996 n->name, (int)(w), (int)(w));
2000 case NTAP_OPT_IRLEN:
2001 pTap->ir_length = w;
2002 reqbits &= (~(NTREQ_IRLEN));
2004 case NTAP_OPT_IRMASK:
2005 pTap->ir_capture_mask = w;
2006 reqbits &= (~(NTREQ_IRMASK));
2008 case NTAP_OPT_IRCAPTURE:
2009 pTap->ir_capture_value = w;
2010 reqbits &= (~(NTREQ_IRCAPTURE));
2013 } /* switch(n->value) */
2014 } /* while( goi->argc ) */
2016 /* Did we get all the options? */
2019 Jim_SetResult_sprintf( goi->interp,
2020 "newtap: %s missing required parameters",
2022 /* TODO: Tell user what is missing :-( */
2023 /* no memory leaks pelase */
2024 free(((void *)(pTap->expected_ids)));
2025 free(((void *)(pTap->chip)));
2026 free(((void *)(pTap->tapname)));
2027 free(((void *)(pTap->dotted_name)));
2028 free(((void *)(pTap)));
2032 pTap->expected = malloc( pTap->ir_length );
2033 pTap->expected_mask = malloc( pTap->ir_length );
2034 pTap->cur_instr = malloc( pTap->ir_length );
2036 buf_set_u32( pTap->expected,
2039 pTap->ir_capture_value );
2040 buf_set_u32( pTap->expected_mask,
2043 pTap->ir_capture_mask );
2044 buf_set_ones( pTap->cur_instr,
2049 jtag_register_event_callback(jtag_reset_callback, pTap );
2051 ppTap = &(jtag_all_taps);
2052 while( (*ppTap) != NULL ){
2053 ppTap = &((*ppTap)->next_tap);
2057 static int n_taps = 0;
2058 pTap->abs_chain_position = n_taps++;
2060 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
2061 (*ppTap)->dotted_name,
2062 (*ppTap)->abs_chain_position,
2063 (*ppTap)->ir_length,
2064 (*ppTap)->ir_capture_value,
2065 (*ppTap)->ir_capture_mask );
2070 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2076 struct command_context_s *context;
2080 JTAG_CMD_INIT_RESET,
2083 JTAG_CMD_TAPDISABLE,
2084 JTAG_CMD_TAPISENABLED,
2089 const Jim_Nvp jtag_cmds[] = {
2090 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2091 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2092 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2093 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2094 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2095 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2096 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2097 { .name = "cget" , .value = JTAG_CMD_CGET },
2099 { .name = NULL, .value = -1 },
2102 context = Jim_GetAssocData(interp, "context");
2103 /* go past the command */
2104 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2106 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2108 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2111 Jim_SetEmptyResult( goi.interp );
2113 case JTAG_CMD_INTERFACE:
2114 /* return the name of the interface */
2115 /* TCL code might need to know the exact type... */
2116 /* FUTURE: we allow this as a means to "set" the interface. */
2117 if( goi.argc != 0 ){
2118 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2121 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2123 case JTAG_CMD_INIT_RESET:
2124 if( goi.argc != 0 ){
2125 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2128 e = jtag_init_reset(context);
2129 if( e != ERROR_OK ){
2130 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2134 case JTAG_CMD_NEWTAP:
2135 return jim_newtap_cmd( &goi );
2137 case JTAG_CMD_TAPISENABLED:
2138 case JTAG_CMD_TAPENABLE:
2139 case JTAG_CMD_TAPDISABLE:
2140 if( goi.argc != 1 ){
2141 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2147 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2152 case JTAG_CMD_TAPISENABLED:
2155 case JTAG_CMD_TAPENABLE:
2156 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2160 case JTAG_CMD_TAPDISABLE:
2161 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2166 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2173 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2180 Jim_GetOpt_Obj(&goi, &o);
2181 t = jtag_TapByJimObj( goi.interp, o );
2186 goi.isconfigure = 0;
2187 return jtag_tap_configure_cmd( &goi, t);
2191 case JTAG_CMD_CONFIGURE:
2193 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2200 Jim_GetOpt_Obj(&goi, &o);
2201 t = jtag_TapByJimObj( goi.interp, o );
2206 goi.isconfigure = 1;
2207 return jtag_tap_configure_cmd( &goi, t);
2214 int jtag_register_commands(struct command_context_s *cmd_ctx)
2216 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2218 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2219 COMMAND_CONFIG, "try to configure interface");
2220 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2221 COMMAND_ANY, "set jtag speed (if supported)");
2222 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2223 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2224 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2225 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2226 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2228 "[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]");
2229 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2230 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2231 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2232 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2234 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2235 COMMAND_EXEC, "print current scan chain configuration");
2237 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2238 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2239 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2240 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2241 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2242 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2243 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2244 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2245 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2247 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2248 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2252 int jtag_interface_init(struct command_context_s *cmd_ctx)
2257 if (!jtag_interface)
2259 /* nothing was previously specified by "interface" command */
2260 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2261 return ERROR_JTAG_INVALID_INTERFACE;
2265 jtag_interface->khz(speed_khz, &jtag_speed);
2269 if (jtag_interface->init() != ERROR_OK)
2270 return ERROR_JTAG_INIT_FAILED;
2272 jtag = jtag_interface;
2276 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2281 LOG_DEBUG("Init JTAG chain");
2283 tap = jtag_NextEnabledTap(NULL);
2285 LOG_ERROR("There are no enabled taps?");
2286 return ERROR_JTAG_INIT_FAILED;
2290 if ((retval=jtag_execute_queue())!=ERROR_OK)
2293 /* examine chain first, as this could discover the real chain layout */
2294 if (jtag_examine_chain() != ERROR_OK)
2296 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2299 if (jtag_validate_chain() != ERROR_OK)
2301 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2307 int jtag_init_reset(struct command_context_s *cmd_ctx)
2311 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2314 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2316 /* Reset can happen after a power cycle.
2318 * Ideally we would only assert TRST or run RESET before the target reset.
2320 * However w/srst_pulls_trst, trst is asserted together with the target
2321 * reset whether we want it or not.
2323 * NB! Some targets have JTAG circuitry disabled until a
2324 * trst & srst has been asserted.
2326 * NB! here we assume nsrst/ntrst delay are sufficient!
2328 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2331 jtag_add_reset(1, 0); /* RESET or TRST */
2332 if (jtag_reset_config & RESET_HAS_SRST)
2334 jtag_add_reset(1, 1);
2335 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2336 jtag_add_reset(0, 1);
2338 jtag_add_reset(0, 0);
2339 if ((retval = jtag_execute_queue()) != ERROR_OK)
2342 /* Check that we can communication on the JTAG chain + eventually we want to
2343 * be able to perform enumeration only after OpenOCD has started
2344 * telnet and GDB server
2346 * That would allow users to more easily perform any magic they need to before
2349 return jtag_init_inner(cmd_ctx);
2352 int jtag_init(struct command_context_s *cmd_ctx)
2355 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2357 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2361 return jtag_init_reset(cmd_ctx);
2364 static int default_khz(int khz, int *jtag_speed)
2366 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2370 static int default_speed_div(int speed, int *khz)
2372 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2376 static int default_power_dropout(int *dropout)
2378 *dropout=0; /* by default we can't detect power dropout */
2382 static int default_srst_asserted(int *srst_asserted)
2384 *srst_asserted=0; /* by default we can't detect srst asserted */
2388 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2393 /* check whether the interface is already configured */
2396 LOG_WARNING("Interface already configured, ignoring");
2400 /* interface name is a mandatory argument */
2401 if (argc < 1 || args[0][0] == '\0')
2403 return ERROR_COMMAND_SYNTAX_ERROR;
2406 for (i=0; jtag_interfaces[i]; i++)
2408 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2410 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2415 jtag_interface = jtag_interfaces[i];
2417 if (jtag_interface->khz == NULL)
2419 jtag_interface->khz = default_khz;
2421 if (jtag_interface->speed_div == NULL)
2423 jtag_interface->speed_div = default_speed_div;
2425 if (jtag_interface->power_dropout == NULL)
2427 jtag_interface->power_dropout = default_power_dropout;
2429 if (jtag_interface->srst_asserted == NULL)
2431 jtag_interface->srst_asserted = default_srst_asserted;
2438 /* no valid interface was found (i.e. the configuration option,
2439 * didn't match one of the compiled-in interfaces
2441 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2442 LOG_ERROR("compiled-in jtag interfaces:");
2443 for (i = 0; jtag_interfaces[i]; i++)
2445 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2448 return ERROR_JTAG_INVALID_INTERFACE;
2451 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2455 Jim_Obj *newargs[ 10 ];
2458 * argv[-1] = command
2459 * argv[ 0] = ir length
2460 * argv[ 1] = ir capture
2461 * argv[ 2] = ir mask
2462 * argv[ 3] = not actually used by anything but in the docs
2466 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2469 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2470 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2474 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2475 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2476 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2477 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2479 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2480 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2481 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2482 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2483 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2484 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2485 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2486 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2487 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2488 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2489 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2490 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2492 command_print( cmd_ctx, "NEW COMMAND:");
2493 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2494 Jim_GetString( newargs[0], NULL ),
2495 Jim_GetString( newargs[1], NULL ),
2496 Jim_GetString( newargs[2], NULL ),
2497 Jim_GetString( newargs[3], NULL ),
2498 Jim_GetString( newargs[4], NULL ),
2499 Jim_GetString( newargs[5], NULL ),
2500 Jim_GetString( newargs[6], NULL ),
2501 Jim_GetString( newargs[7], NULL ),
2502 Jim_GetString( newargs[8], NULL ),
2503 Jim_GetString( newargs[9], NULL ) );
2505 e = jim_jtag_command( interp, 10, newargs );
2507 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2512 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2516 tap = jtag_all_taps;
2517 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2518 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2521 u32 expected, expected_mask, cur_instr, ii;
2522 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2523 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2524 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2526 command_print(cmd_ctx,
2527 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2528 tap->abs_chain_position,
2530 tap->enabled ? 'Y' : 'n',
2532 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2538 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2539 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2540 tap->expected_ids[ii]);
2543 tap = tap->next_tap;
2549 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2552 return ERROR_COMMAND_SYNTAX_ERROR;
2556 if (strcmp(args[0], "none") == 0)
2557 jtag_reset_config = RESET_NONE;
2558 else if (strcmp(args[0], "trst_only") == 0)
2559 jtag_reset_config = RESET_HAS_TRST;
2560 else if (strcmp(args[0], "srst_only") == 0)
2561 jtag_reset_config = RESET_HAS_SRST;
2562 else if (strcmp(args[0], "trst_and_srst") == 0)
2563 jtag_reset_config = RESET_TRST_AND_SRST;
2566 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2567 jtag_reset_config = RESET_NONE;
2568 return ERROR_INVALID_ARGUMENTS;
2574 if (strcmp(args[1], "separate") == 0)
2576 /* seperate reset lines - default */
2579 if (strcmp(args[1], "srst_pulls_trst") == 0)
2580 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2581 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2582 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2583 else if (strcmp(args[1], "combined") == 0)
2584 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2587 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2588 jtag_reset_config = RESET_NONE;
2589 return ERROR_INVALID_ARGUMENTS;
2596 if (strcmp(args[2], "trst_open_drain") == 0)
2597 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2598 else if (strcmp(args[2], "trst_push_pull") == 0)
2599 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2602 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2603 jtag_reset_config = RESET_NONE;
2604 return ERROR_INVALID_ARGUMENTS;
2610 if (strcmp(args[3], "srst_push_pull") == 0)
2611 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2612 else if (strcmp(args[3], "srst_open_drain") == 0)
2613 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2616 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2617 jtag_reset_config = RESET_NONE;
2618 return ERROR_INVALID_ARGUMENTS;
2625 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2629 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2634 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2640 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2644 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2649 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2655 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2657 int retval=ERROR_OK;
2661 LOG_DEBUG("handle jtag speed");
2664 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2666 /* this command can be called during CONFIG,
2667 * in which case jtag isn't initialized */
2670 retval=jtag->speed(cur_speed);
2672 } else if (argc == 0)
2676 return ERROR_COMMAND_SYNTAX_ERROR;
2678 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2683 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2685 int retval=ERROR_OK;
2686 LOG_DEBUG("handle jtag khz");
2690 speed_khz = strtoul(args[0], NULL, 0);
2694 LOG_DEBUG("have interface set up");
2696 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2702 cur_speed = jtag_speed = speed_div1;
2704 retval=jtag->speed(cur_speed);
2713 return ERROR_COMMAND_SYNTAX_ERROR;
2718 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2724 command_print(cmd_ctx, "RCLK - adaptive");
2727 command_print(cmd_ctx, "%d kHz", speed_khz);
2733 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2739 return ERROR_COMMAND_SYNTAX_ERROR;
2743 state = tap_state_by_name( args[0] );
2745 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2746 return ERROR_COMMAND_SYNTAX_ERROR;
2748 jtag_add_end_state(state);
2749 jtag_execute_queue();
2751 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2756 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2763 return ERROR_COMMAND_SYNTAX_ERROR;
2766 if (args[0][0] == '1')
2768 else if (args[0][0] == '0')
2772 return ERROR_COMMAND_SYNTAX_ERROR;
2775 if (args[1][0] == '1')
2777 else if (args[1][0] == '0')
2781 return ERROR_COMMAND_SYNTAX_ERROR;
2784 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2785 return ERROR_JTAG_INIT_FAILED;
2787 jtag_add_reset(trst, srst);
2788 jtag_execute_queue();
2793 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2797 return ERROR_COMMAND_SYNTAX_ERROR;
2800 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2801 jtag_execute_queue();
2807 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2810 scan_field_t *fields;
2812 tap_state_t endstate;
2814 if ((argc < 2) || (argc % 2))
2816 return ERROR_COMMAND_SYNTAX_ERROR;
2819 /* optional "-endstate" */
2821 /* at the end of the arguments. */
2823 endstate = TAP_INVALID;
2825 /* have at least one pair of numbers. */
2826 /* is last pair the magic text? */
2827 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2830 cpA = args[ argc-1 ];
2831 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2832 cpS = tap_state_name( endstate );
2833 if( 0 == strcmp( cpA, cpS ) ){
2837 if( endstate >= TAP_NUM_STATES ){
2838 return ERROR_COMMAND_SYNTAX_ERROR;
2840 /* found - remove the last 2 args */
2846 fields = malloc(sizeof(scan_field_t) * argc / 2);
2848 for (i = 0; i < argc / 2; i++)
2850 tap = jtag_TapByString( args[i*2] );
2853 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2856 int field_size = tap->ir_length;
2857 fields[i].tap = tap;
2858 fields[i].out_value = malloc(CEIL(field_size, 8));
2859 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2860 fields[i].in_value = NULL;
2861 fields[i].in_check_mask = NULL;
2862 fields[i].in_handler = NULL;
2863 fields[i].in_handler_priv = NULL;
2866 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2867 /* did we have an endstate? */
2868 if (endstate != TAP_INVALID)
2869 jtag_add_end_state(endstate);
2871 jtag_execute_queue();
2873 for (i = 0; i < argc / 2; i++)
2874 free(fields[i].out_value);
2881 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2884 scan_field_t *fields;
2886 int field_count = 0;
2889 tap_state_t endstate;
2892 * args[2] = num_bits
2893 * args[3] = hex string
2894 * ... repeat num bits and hex string ...
2897 * args[N-2] = "-endstate"
2898 * args[N-1] = statename
2900 if ((argc < 4) || ((argc % 2)!=0))
2902 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2906 /* assume no endstate */
2907 endstate = TAP_INVALID;
2908 /* validate arguments as numbers */
2910 for (i = 2; i < argc; i+=2)
2915 e = Jim_GetLong(interp, args[i], &bits);
2916 /* If valid - try next arg */
2921 /* Not valid.. are we at the end? */
2922 if ( ((i+2) != argc) ){
2923 /* nope, then error */
2927 /* it could be: "-endstate FOO" */
2929 /* get arg as a string. */
2930 cp = Jim_GetString( args[i], NULL );
2931 /* is it the magic? */
2932 if( 0 == strcmp( "-endstate", cp ) ){
2933 /* is the statename valid? */
2934 cp = Jim_GetString( args[i+1], NULL );
2936 /* see if it is a valid state name */
2937 endstate = tap_state_by_name(cp);
2939 /* update the error message */
2940 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2942 /* valid - so clear the error */
2944 /* and remove the last 2 args */
2949 /* Still an error? */
2951 return e; /* too bad */
2953 } /* validate args */
2955 tap = jtag_TapByJimObj( interp, args[1] );
2960 num_fields=(argc-2)/2;
2961 fields = malloc(sizeof(scan_field_t) * num_fields);
2962 for (i = 2; i < argc; i+=2)
2968 Jim_GetLong(interp, args[i], &bits);
2969 str = Jim_GetString(args[i+1], &len);
2971 fields[field_count].tap = tap;
2972 fields[field_count].num_bits = bits;
2973 fields[field_count].out_value = malloc(CEIL(bits, 8));
2974 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2975 fields[field_count].in_value = fields[field_count].out_value;
2976 fields[field_count].in_check_mask = NULL;
2977 fields[field_count].in_check_value = NULL;
2978 fields[field_count].in_handler = NULL;
2979 fields[field_count++].in_handler_priv = NULL;
2982 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2983 /* did we get an end state? */
2984 if (endstate != TAP_INVALID)
2985 jtag_add_end_state(endstate);
2987 retval = jtag_execute_queue();
2988 if (retval != ERROR_OK)
2990 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2995 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2996 for (i = 2; i < argc; i+=2)
3001 Jim_GetLong(interp, args[i], &bits);
3002 str = buf_to_str(fields[field_count].in_value, bits, 16);
3003 free(fields[field_count].out_value);
3005 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
3010 Jim_SetResult(interp, list);
3017 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3021 if (strcmp(args[0], "enable") == 0)
3023 jtag_verify_capture_ir = 1;
3025 else if (strcmp(args[0], "disable") == 0)
3027 jtag_verify_capture_ir = 0;
3030 return ERROR_COMMAND_SYNTAX_ERROR;
3032 } else if (argc != 0)
3034 return ERROR_COMMAND_SYNTAX_ERROR;
3037 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
3042 int jtag_power_dropout(int *dropout)
3044 return jtag->power_dropout(dropout);
3047 int jtag_srst_asserted(int *srst_asserted)
3049 return jtag->srst_asserted(srst_asserted);
3052 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
3054 jtag_tap_event_action_t * jteap;
3057 jteap = tap->event_action;
3061 if (jteap->event == e) {
3063 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3066 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
3067 Jim_GetString(jteap->body, NULL) );
3068 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3069 Jim_PrintErrorMessage(interp);
3073 jteap = jteap->next;
3077 LOG_DEBUG( "event %d %s - no action",
3079 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3083 /*-----<Cable Helper API>---------------------------------------*/
3085 /* these Cable Helper API functions are all documented in the jtag.h header file,
3086 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3087 is setup to prefer its docs in the header file, no documentation is here, for
3088 if it were, it would have to be doubly maintained.
3092 * @see tap_set_state() and tap_get_state() accessors.
3093 * Actual name is not important since accessors hide it.
3095 static tap_state_t state_follower = TAP_RESET;
3097 void tap_set_state_impl( tap_state_t new_state )
3099 /* this is the state we think the TAPs are in now, was cur_state */
3100 state_follower = new_state;
3103 tap_state_t tap_get_state()
3105 return state_follower;
3109 * @see tap_set_end_state() and tap_get_end_state() accessors.
3110 * Actual name is not important because accessors hide it.
3112 static tap_state_t end_state_follower = TAP_RESET;
3114 void tap_set_end_state( tap_state_t new_end_state )
3116 /* this is the state we think the TAPs will be in at completion of the
3117 current TAP operation, was end_state
3119 end_state_follower = new_end_state;
3122 tap_state_t tap_get_end_state()
3124 return end_state_follower;
3128 int tap_move_ndx( tap_state_t astate )
3130 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3136 case TAP_RESET: ndx = 0; break;
3137 case TAP_DRSHIFT: ndx = 2; break;
3138 case TAP_DRPAUSE: ndx = 3; break;
3139 case TAP_IDLE: ndx = 1; break;
3140 case TAP_IRSHIFT: ndx = 4; break;
3141 case TAP_IRPAUSE: ndx = 5; break;
3143 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3151 /* tap_move[i][j]: tap movement command to go from state i to state j
3152 * 0: Test-Logic-Reset
3159 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3166 } tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3168 /* value clocked to TMS to move from one of six stable states to another.
3169 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3170 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3171 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3172 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3176 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3177 * Read the bits from LSBit first to MSBit last (right-to-left).
3179 #define HEX__(n) 0x##n##LU
3182 (((x) & 0x0000000FLU)?(1<<0):0) \
3183 +(((x) & 0x000000F0LU)?(1<<1):0) \
3184 +(((x) & 0x00000F00LU)?(1<<2):0) \
3185 +(((x) & 0x0000F000LU)?(1<<3):0) \
3186 +(((x) & 0x000F0000LU)?(1<<4):0) \
3187 +(((x) & 0x00F00000LU)?(1<<5):0) \
3188 +(((x) & 0x0F000000LU)?(1<<6):0) \
3189 +(((x) & 0xF0000000LU)?(1<<7):0)
3191 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3193 #if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1) || (BUILD_JLINK==1))
3194 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3196 OK, I added Peter's version of the state table, and it works OK for
3197 me on MC1322x. I've recreated the jlink portion of patch with this
3198 new state table. His changes to my state table are pretty minor in
3199 terms of total transitions, but Peter feels that his version fixes
3200 some long-standing problems.
3203 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3206 state specific comments:
3207 ------------------------
3208 *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to
3209 work better on ARM9 with ft2232 driver. (Dick)
3211 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3212 needed on ARM9 with ft2232 driver. (Dick)
3214 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3215 needed on ARM9 with ft2232 driver. (Dick)
3219 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3220 { B8(1111111,7), B8(0,1), B8(00101,5), B8(01010,5), B8(001101,6), B8(010110,6) }, /* RESET */
3221 { B8(1111111,7), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3222 { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3223 { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3224 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3225 { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3227 #else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */
3230 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3231 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3232 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3233 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3234 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3235 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3236 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) } /* IRPAUSE */
3240 #if 0 /* keeping old hex stuff for awhile, for reference */
3241 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3242 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3243 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3244 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3245 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3246 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3247 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3252 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3254 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3258 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3260 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3264 bool tap_is_state_stable(tap_state_t astate)
3268 /* A switch() is used because it is symbol dependent
3269 (not value dependent like an array), and can also check bounds.
3288 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3290 tap_state_t new_state;
3292 /* A switch is used because it is symbol dependent and not value dependent
3293 like an array. Also it can check for out of range conditions.
3301 new_state = cur_state;
3306 new_state = TAP_DRSELECT;
3309 new_state = TAP_IRSELECT;
3313 new_state = TAP_DREXIT1;
3317 new_state = TAP_DRUPDATE;
3320 new_state = TAP_DREXIT2;
3323 new_state = TAP_RESET;
3327 new_state = TAP_IREXIT1;
3331 new_state = TAP_IRUPDATE;
3334 new_state = TAP_IREXIT2;
3337 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3350 new_state = TAP_IDLE;
3353 new_state = TAP_DRCAPTURE;
3358 new_state = TAP_DRSHIFT;
3362 new_state = TAP_DRPAUSE;
3365 new_state = TAP_IRCAPTURE;
3370 new_state = TAP_IRSHIFT;
3374 new_state = TAP_IRPAUSE;
3377 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3386 const char* tap_state_name(tap_state_t state)
3392 case TAP_RESET: ret = "RESET"; break;
3393 case TAP_IDLE: ret = "RUN/IDLE"; break;
3394 case TAP_DRSELECT: ret = "DRSELECT"; break;
3395 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3396 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3397 case TAP_DREXIT1: ret = "DREXIT1"; break;
3398 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3399 case TAP_DREXIT2: ret = "DREXIT2"; break;
3400 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3401 case TAP_IRSELECT: ret = "IRSELECT"; break;
3402 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3403 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3404 case TAP_IREXIT1: ret = "IREXIT1"; break;
3405 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3406 case TAP_IREXIT2: ret = "IREXIT2"; break;
3407 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3408 default: ret = "???";
3414 static tap_state_t tap_state_by_name( const char *name )
3418 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3419 /* be nice to the human */
3420 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3428 #ifdef _DEBUG_JTAG_IO_
3430 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3431 do { buf[len] = bit ? '1' : '0'; } while(0)
3432 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3433 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3434 tap_state_name(a), tap_state_name(b), astr, bstr)
3436 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3437 unsigned tap_bits, tap_state_t next_state)
3439 const u8 *tms_buffer;
3440 const u8 *tdi_buffer;
3445 unsigned tap_out_bits;
3449 tap_state_t last_state;
3451 // set startstate (and possibly last, if tap_bits == 0)
3452 last_state = next_state;
3453 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3455 tms_buffer = (const u8 *)tms_buf;
3456 tdi_buffer = (const u8 *)tdi_buf;
3458 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3459 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3462 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3464 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3466 // make sure we do not run off the end of the buffers
3467 unsigned tap_bit = cur_byte * 8 + cur_bit;
3468 if (tap_bit == tap_bits)
3471 // check and save TMS bit
3472 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3473 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3475 // use TMS bit to find the next TAP state
3476 next_state = tap_state_transition(last_state, tap_bit);
3478 // check and store TDI bit
3479 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3480 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3482 // increment TAP bits
3485 // Only show TDO bits on state transitions, or
3486 // after some number of bits in the same state.
3487 if ((next_state == last_state) && (tap_out_bits < 32))
3490 // terminate strings and display state transition
3491 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3492 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3495 last_state = next_state;
3502 // terminate strings and display state transition
3503 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3504 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3507 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3511 #endif // _DEBUG_JTAG_IO_
3513 /*-----</Cable Helper API>--------------------------------------*/