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"
45 /* note that this is not marked as static as it must be available from outside jtag.c for those
46 that implement the jtag_xxx() minidriver layer
48 int jtag_error=ERROR_OK;
50 typedef struct cmd_queue_page_s
54 struct cmd_queue_page_s *next;
57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
58 static cmd_queue_page_t *cmd_queue_pages = NULL;
60 char* jtag_event_strings[] =
62 "JTAG controller reset (RESET or TRST)"
65 const Jim_Nvp nvp_jtag_tap_event[] = {
66 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
67 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
69 { .name = NULL, .value = -1 }
75 jtag_command_t *jtag_command_queue = NULL;
76 jtag_command_t **last_comand_pointer = &jtag_command_queue;
77 static jtag_tap_t *jtag_all_taps = NULL;
79 enum reset_types jtag_reset_config = RESET_NONE;
80 tap_state_t cmd_queue_end_state = TAP_RESET;
81 tap_state_t cmd_queue_cur_state = TAP_RESET;
83 int jtag_verify_capture_ir = 1;
85 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
86 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
87 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
89 /* maximum number of JTAG devices expected in the chain
91 #define JTAG_MAX_CHAIN_SIZE 20
93 /* callbacks to inform high-level handlers about JTAG state changes */
94 jtag_event_callback_t *jtag_event_callbacks;
97 static int speed_khz = 0;
98 /* flag if the kHz speed was defined */
99 static int hasKHz = 0;
101 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
104 #if BUILD_ECOSBOARD == 1
105 extern jtag_interface_t zy1000_interface;
108 #if BUILD_PARPORT == 1
109 extern jtag_interface_t parport_interface;
113 extern jtag_interface_t dummy_interface;
116 #if BUILD_FT2232_FTD2XX == 1
117 extern jtag_interface_t ft2232_interface;
120 #if BUILD_FT2232_LIBFTDI == 1
121 extern jtag_interface_t ft2232_interface;
124 #if BUILD_AMTJTAGACCEL == 1
125 extern jtag_interface_t amt_jtagaccel_interface;
128 #if BUILD_EP93XX == 1
129 extern jtag_interface_t ep93xx_interface;
132 #if BUILD_AT91RM9200 == 1
133 extern jtag_interface_t at91rm9200_interface;
136 #if BUILD_GW16012 == 1
137 extern jtag_interface_t gw16012_interface;
140 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
141 extern jtag_interface_t presto_interface;
144 #if BUILD_USBPROG == 1
145 extern jtag_interface_t usbprog_interface;
149 extern jtag_interface_t jlink_interface;
152 #if BUILD_VSLLINK == 1
153 extern jtag_interface_t vsllink_interface;
157 extern jtag_interface_t rlink_interface;
160 #if BUILD_ARMJTAGEW == 1
161 extern jtag_interface_t armjtagew_interface;
164 jtag_interface_t *jtag_interfaces[] = {
165 #if BUILD_ECOSBOARD == 1
168 #if BUILD_PARPORT == 1
174 #if BUILD_FT2232_FTD2XX == 1
177 #if BUILD_FT2232_LIBFTDI == 1
180 #if BUILD_AMTJTAGACCEL == 1
181 &amt_jtagaccel_interface,
183 #if BUILD_EP93XX == 1
186 #if BUILD_AT91RM9200 == 1
187 &at91rm9200_interface,
189 #if BUILD_GW16012 == 1
192 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
195 #if BUILD_USBPROG == 1
201 #if BUILD_VSLLINK == 1
207 #if BUILD_ARMJTAGEW == 1
208 &armjtagew_interface,
213 jtag_interface_t *jtag = NULL;
216 static jtag_interface_t *jtag_interface = NULL;
219 /* forward declarations */
220 //void jtag_add_pathmove(int num_states, tap_state_t *path);
221 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
222 //void jtag_add_end_state(tap_state_t endstate);
223 //void jtag_add_sleep(u32 us);
224 //int jtag_execute_queue(void);
225 static tap_state_t tap_state_by_name(const char *name);
228 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
229 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
230 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
231 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
232 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
233 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
234 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
236 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
238 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
239 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
240 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
241 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
242 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
244 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
246 jtag_tap_t *jtag_AllTaps(void)
248 return jtag_all_taps;
251 int jtag_NumTotalTaps(void)
265 int jtag_NumEnabledTaps(void)
281 jtag_tap_t *jtag_TapByString( const char *s )
289 if( 0 == strcmp( t->dotted_name, s ) ){
295 /* backup plan is by number */
297 /* ok - is "s" a number? */
299 n = strtol( s, &cp, 0 );
300 if( (s != cp) && (*cp == 0) ){
302 t = jtag_TapByAbsPosition(n);
308 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
313 cp = Jim_GetString( o, NULL );
318 t = jtag_TapByString( cp );
321 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
326 /* returns a pointer to the n-th device in the scan chain */
327 jtag_tap_t * jtag_TapByAbsPosition( int n )
335 while( t && (n > 0)) {
342 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
344 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
346 if (callback == NULL)
348 return ERROR_INVALID_ARGUMENTS;
353 while ((*callbacks_p)->next)
354 callbacks_p = &((*callbacks_p)->next);
355 callbacks_p = &((*callbacks_p)->next);
358 (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
359 (*callbacks_p)->callback = callback;
360 (*callbacks_p)->priv = priv;
361 (*callbacks_p)->next = NULL;
366 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
368 jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
370 if (callback == NULL)
372 return ERROR_INVALID_ARGUMENTS;
377 jtag_event_callback_t **next = &((*callbacks_p)->next);
378 if ((*callbacks_p)->callback == callback)
381 *callbacks_p = *next;
389 int jtag_call_event_callbacks(enum jtag_event event)
391 jtag_event_callback_t *callback = jtag_event_callbacks;
393 LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
397 callback->callback(event, callback->priv);
398 callback = callback->next;
404 /* returns a pointer to the pointer of the last command in queue
405 * this may be a pointer to the root pointer (jtag_command_queue)
406 * or to the next member of the last but one command
408 jtag_command_t** jtag_get_last_command_p(void)
410 /* jtag_command_t *cmd = jtag_command_queue;
416 return &jtag_command_queue;
420 return last_comand_pointer;
423 void* cmd_queue_alloc(size_t size)
425 cmd_queue_page_t **p_page = &cmd_queue_pages;
431 * We align/round the *SIZE* per below
432 * so that all pointers returned by
433 * this function are reasonably well
436 * If we did not, then an "odd-length" request would cause the
437 * *next* allocation to be at an *odd* address, and because
438 * this function has the same type of api as malloc() - we
439 * must also return pointers that have the same type of
442 * What I do not/have is a reasonable portable means
445 * The solution here, is based on these suggestions.
446 * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
449 union worse_case_align {
455 #define ALIGN_SIZE (sizeof(union worse_case_align))
457 /* The alignment process. */
458 size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
463 while ((*p_page)->next)
464 p_page = &((*p_page)->next);
465 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
466 p_page = &((*p_page)->next);
471 *p_page = malloc(sizeof(cmd_queue_page_t));
473 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
474 (*p_page)->next = NULL;
477 offset = (*p_page)->used;
478 (*p_page)->used += size;
480 t=(u8 *)((*p_page)->address);
484 void cmd_queue_free(void)
486 cmd_queue_page_t *page = cmd_queue_pages;
490 cmd_queue_page_t *last = page;
496 cmd_queue_pages = NULL;
499 static void jtag_prelude1(void)
503 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
504 jtag_error=ERROR_JTAG_TRST_ASSERTED;
508 if (cmd_queue_end_state == TAP_RESET)
509 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
512 static void jtag_prelude(tap_state_t state)
516 if (state != TAP_INVALID)
517 jtag_add_end_state(state);
519 cmd_queue_cur_state = cmd_queue_end_state;
522 void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
528 retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state);
529 if (retval!=ERROR_OK)
533 int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
535 jtag_command_t **last_cmd;
542 last_cmd = jtag_get_last_command_p();
544 /* allocate memory for a new list member */
545 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
546 (*last_cmd)->next = NULL;
547 last_comand_pointer = &((*last_cmd)->next);
548 (*last_cmd)->type = JTAG_SCAN;
550 /* allocate memory for ir scan command */
551 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
552 (*last_cmd)->cmd.scan->ir_scan = 1;
553 x = jtag_NumEnabledTaps();
554 (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */
555 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t));
556 (*last_cmd)->cmd.scan->end_state = state;
563 /* do this here so it is not forgotten */
564 tap = jtag_NextEnabledTap(tap);
569 scan_size = tap->ir_length;
570 (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap;
571 (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size;
572 (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL;
573 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */
575 /* search the list */
576 for (j = 0; j < num_fields; j++)
578 if (tap == fields[j].tap)
581 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
582 (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
584 if (jtag_verify_capture_ir)
586 if (fields[j].in_handler==NULL)
588 jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL);
591 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler;
592 (*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv;
593 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected;
594 (*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask;
605 /* if a tap isn't listed, set it to BYPASS */
606 (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
607 (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL;
611 /* update device information */
612 buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
618 void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state)
624 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state);
625 if (retval!=ERROR_OK)
629 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
632 jtag_command_t **last_cmd;
634 last_cmd = jtag_get_last_command_p();
636 /* allocate memory for a new list member */
637 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
638 (*last_cmd)->next = NULL;
639 last_comand_pointer = &((*last_cmd)->next);
640 (*last_cmd)->type = JTAG_SCAN;
642 /* allocate memory for ir scan command */
643 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
644 (*last_cmd)->cmd.scan->ir_scan = 1;
645 (*last_cmd)->cmd.scan->num_fields = num_fields;
646 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
647 (*last_cmd)->cmd.scan->end_state = state;
649 for( i = 0 ; i < num_fields ; i++ ){
650 int num_bits = fields[i].num_bits;
651 int num_bytes = CEIL(fields[i].num_bits, 8);
652 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
653 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
654 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
655 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
656 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
657 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
658 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
659 (*last_cmd)->cmd.scan->fields[i].in_handler = NULL;
660 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL;
665 void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
671 retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state);
672 if (retval!=ERROR_OK)
676 int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
680 int bypass_devices = 0;
684 jtag_command_t **last_cmd = jtag_get_last_command_p();
687 /* count devices in bypass */
691 tap = jtag_NextEnabledTap(tap);
700 /* allocate memory for a new list member */
701 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
702 last_comand_pointer = &((*last_cmd)->next);
703 (*last_cmd)->next = NULL;
704 (*last_cmd)->type = JTAG_SCAN;
706 /* allocate memory for dr scan command */
707 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
708 (*last_cmd)->cmd.scan->ir_scan = 0;
709 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
710 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
711 (*last_cmd)->cmd.scan->end_state = state;
717 tap = jtag_NextEnabledTap(tap);
722 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
724 for (j = 0; j < num_fields; j++)
726 if (tap == fields[j].tap)
729 scan_size = fields[j].num_bits;
730 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
731 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
732 (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
733 (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value;
734 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value;
735 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask;
736 (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler;
737 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv;
742 #ifdef _DEBUG_JTAG_IO_
743 /* if a device isn't listed, the BYPASS register should be selected */
746 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
750 /* program the scan field to 1 bit length, and ignore it's value */
751 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
752 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
753 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
754 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
755 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
756 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
757 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
758 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
762 #ifdef _DEBUG_JTAG_IO_
763 /* if a device is listed, the BYPASS register must not be selected */
766 LOG_ERROR("BUG: scan data for a device in BYPASS");
775 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
779 tap_state_t end_state)
784 int bypass_devices = 0;
786 jtag_command_t **last_cmd = jtag_get_last_command_p();
789 /* count devices in bypass */
793 tap = jtag_NextEnabledTap(tap);
802 /* allocate memory for a new list member */
803 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
804 last_comand_pointer = &((*last_cmd)->next);
805 (*last_cmd)->next = NULL;
806 (*last_cmd)->type = JTAG_SCAN;
808 /* allocate memory for dr scan command */
809 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
810 (*last_cmd)->cmd.scan->ir_scan = 0;
811 (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices;
812 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t));
813 (*last_cmd)->cmd.scan->end_state = end_state;
818 tap = jtag_NextEnabledTap(tap);
823 (*last_cmd)->cmd.scan->fields[field_count].tap = tap;
825 if (tap == target_tap)
828 #ifdef _DEBUG_JTAG_IO_
829 /* if a device is listed, the BYPASS register must not be selected */
832 LOG_ERROR("BUG: scan data for a device in BYPASS");
836 for (j = 0; j < num_fields; j++)
839 scan_size = num_bits[j];
840 buf_set_u32(out_value, 0, scan_size, value[j]);
841 (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size;
842 (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
843 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
844 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
845 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
846 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
847 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
848 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
852 #ifdef _DEBUG_JTAG_IO_
853 /* if a device isn't listed, the BYPASS register should be selected */
856 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
860 /* program the scan field to 1 bit length, and ignore it's value */
861 (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1;
862 (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL;
863 (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL;
864 (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL;
865 (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL;
866 (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL;
867 (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL;
868 (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL;
873 void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state)
879 retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state);
880 if (retval!=ERROR_OK)
884 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state)
887 jtag_command_t **last_cmd = jtag_get_last_command_p();
889 /* allocate memory for a new list member */
890 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
891 last_comand_pointer = &((*last_cmd)->next);
892 (*last_cmd)->next = NULL;
893 (*last_cmd)->type = JTAG_SCAN;
895 /* allocate memory for scan command */
896 (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t));
897 (*last_cmd)->cmd.scan->ir_scan = 0;
898 (*last_cmd)->cmd.scan->num_fields = num_fields;
899 (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t));
900 (*last_cmd)->cmd.scan->end_state = state;
902 for (i = 0; i < num_fields; i++)
904 int num_bits = fields[i].num_bits;
905 int num_bytes = CEIL(fields[i].num_bits, 8);
906 (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap;
907 (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits;
908 (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
909 (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits);
910 (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value;
911 (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value;
912 (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask;
913 (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler;
914 (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv;
920 void jtag_add_tlr(void)
922 jtag_prelude(TAP_RESET);
925 retval=interface_jtag_add_tlr();
926 if (retval!=ERROR_OK)
930 int MINIDRIVER(interface_jtag_add_tlr)(void)
932 tap_state_t state = TAP_RESET;
933 jtag_command_t **last_cmd = jtag_get_last_command_p();
935 /* allocate memory for a new list member */
936 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
937 last_comand_pointer = &((*last_cmd)->next);
938 (*last_cmd)->next = NULL;
939 (*last_cmd)->type = JTAG_STATEMOVE;
941 (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
942 (*last_cmd)->cmd.statemove->end_state = state;
947 void jtag_add_pathmove(int num_states, tap_state_t *path)
949 tap_state_t cur_state=cmd_queue_cur_state;
953 /* the last state has to be a stable state */
954 if (!tap_is_state_stable(path[num_states - 1]))
956 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
960 for (i=0; i<num_states; i++)
962 if (path[i] == TAP_RESET)
964 LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
967 if ( tap_state_transition(cur_state, true) != path[i]
968 && tap_state_transition(cur_state, false) != path[i])
970 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
978 retval=interface_jtag_add_pathmove(num_states, path);
979 cmd_queue_cur_state = path[num_states - 1];
980 if (retval!=ERROR_OK)
984 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path)
986 jtag_command_t **last_cmd = jtag_get_last_command_p();
989 /* allocate memory for a new list member */
990 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
991 last_comand_pointer = &((*last_cmd)->next);
992 (*last_cmd)->next = NULL;
993 (*last_cmd)->type = JTAG_PATHMOVE;
995 (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
996 (*last_cmd)->cmd.pathmove->num_states = num_states;
997 (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
999 for (i = 0; i < num_states; i++)
1000 (*last_cmd)->cmd.pathmove->path[i] = path[i];
1005 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1007 jtag_command_t **last_cmd = jtag_get_last_command_p();
1009 /* allocate memory for a new list member */
1010 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1011 (*last_cmd)->next = NULL;
1012 last_comand_pointer = &((*last_cmd)->next);
1013 (*last_cmd)->type = JTAG_RUNTEST;
1015 (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1016 (*last_cmd)->cmd.runtest->num_cycles = num_cycles;
1017 (*last_cmd)->cmd.runtest->end_state = state;
1022 void jtag_add_runtest(int num_cycles, tap_state_t state)
1026 jtag_prelude(state);
1028 /* executed by sw or hw fifo */
1029 retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1030 if (retval!=ERROR_OK)
1035 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1037 jtag_command_t **last_cmd = jtag_get_last_command_p();
1039 /* allocate memory for a new list member */
1040 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1041 (*last_cmd)->next = NULL;
1042 last_comand_pointer = &((*last_cmd)->next);
1043 (*last_cmd)->type = JTAG_STABLECLOCKS;
1045 (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1046 (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles;
1050 void jtag_add_clocks( int num_cycles )
1054 if( !tap_is_state_stable(cmd_queue_cur_state) )
1056 LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1057 tap_state_name(cmd_queue_cur_state) );
1058 jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1062 if( num_cycles > 0 )
1066 retval = interface_jtag_add_clocks(num_cycles);
1067 if (retval != ERROR_OK)
1072 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1074 int trst_with_tlr = 0;
1077 /* FIX!!! there are *many* different cases here. A better
1078 * approach is needed for legal combinations of transitions...
1080 if ((jtag_reset_config & RESET_HAS_SRST)&&
1081 (jtag_reset_config & RESET_HAS_TRST)&&
1082 ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1084 if (((req_tlr_or_trst&&!jtag_trst)||
1085 (!req_tlr_or_trst&&jtag_trst))&&
1086 ((req_srst&&!jtag_srst)||
1087 (!req_srst&&jtag_srst)))
1089 /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1090 //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1094 /* Make sure that jtag_reset_config allows the requested reset */
1095 /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1096 if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1098 LOG_ERROR("BUG: requested reset would assert trst");
1099 jtag_error=ERROR_FAIL;
1103 /* if TRST pulls SRST, we reset with TAP T-L-R */
1104 if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1109 if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1111 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1112 jtag_error=ERROR_FAIL;
1116 if (req_tlr_or_trst)
1118 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1130 jtag_srst = req_srst;
1132 retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1133 if (retval!=ERROR_OK)
1141 LOG_DEBUG("SRST line asserted");
1145 LOG_DEBUG("SRST line released");
1146 if (jtag_nsrst_delay)
1147 jtag_add_sleep(jtag_nsrst_delay * 1000);
1152 LOG_DEBUG("JTAG reset with RESET instead of TRST");
1153 jtag_add_end_state(TAP_RESET);
1155 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1161 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
1162 * and inform possible listeners about this
1164 LOG_DEBUG("TRST line asserted");
1165 cmd_queue_cur_state = TAP_RESET;
1166 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
1170 if (jtag_ntrst_delay)
1171 jtag_add_sleep(jtag_ntrst_delay * 1000);
1175 int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst)
1177 jtag_command_t **last_cmd = jtag_get_last_command_p();
1179 /* allocate memory for a new list member */
1180 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1181 (*last_cmd)->next = NULL;
1182 last_comand_pointer = &((*last_cmd)->next);
1183 (*last_cmd)->type = JTAG_RESET;
1185 (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t));
1186 (*last_cmd)->cmd.reset->trst = req_trst;
1187 (*last_cmd)->cmd.reset->srst = req_srst;
1192 void jtag_add_end_state(tap_state_t state)
1194 cmd_queue_end_state = state;
1195 if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
1197 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
1201 int MINIDRIVER(interface_jtag_add_sleep)(u32 us)
1203 jtag_command_t **last_cmd = jtag_get_last_command_p();
1205 /* allocate memory for a new list member */
1206 *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1207 (*last_cmd)->next = NULL;
1208 last_comand_pointer = &((*last_cmd)->next);
1209 (*last_cmd)->type = JTAG_SLEEP;
1211 (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t));
1212 (*last_cmd)->cmd.sleep->us = us;
1217 void jtag_add_sleep(u32 us)
1219 keep_alive(); /* we might be running on a very slow JTAG clk */
1220 int retval=interface_jtag_add_sleep(us);
1221 if (retval!=ERROR_OK)
1226 int jtag_scan_size(scan_command_t *cmd)
1231 /* count bits in scan command */
1232 for (i = 0; i < cmd->num_fields; i++)
1234 bit_count += cmd->fields[i].num_bits;
1240 int jtag_build_buffer(scan_command_t *cmd, u8 **buffer)
1245 bit_count = jtag_scan_size(cmd);
1246 *buffer = malloc(CEIL(bit_count, 8));
1250 #ifdef _DEBUG_JTAG_IO_
1251 LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
1254 for (i = 0; i < cmd->num_fields; i++)
1256 if (cmd->fields[i].out_value)
1258 #ifdef _DEBUG_JTAG_IO_
1259 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);
1261 buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
1262 #ifdef _DEBUG_JTAG_IO_
1263 LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
1269 #ifdef _DEBUG_JTAG_IO_
1270 LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
1274 bit_count += cmd->fields[i].num_bits;
1277 #ifdef _DEBUG_JTAG_IO_
1278 //LOG_DEBUG("bit_count totalling: %i", bit_count );
1284 int jtag_read_buffer(u8 *buffer, scan_command_t *cmd)
1290 /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
1293 for (i = 0; i < cmd->num_fields; i++)
1295 /* if neither in_value nor in_handler
1296 * are specified we don't have to examine this field
1298 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1300 int num_bits = cmd->fields[i].num_bits;
1301 u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
1303 #ifdef _DEBUG_JTAG_IO_
1304 char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1305 LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
1309 if (cmd->fields[i].in_value)
1311 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
1313 if (cmd->fields[i].in_handler)
1315 if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1317 LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1318 retval = ERROR_JTAG_QUEUE_FAILED;
1323 /* no in_value specified, but a handler takes care of the scanned data */
1324 if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value))
1326 if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK)
1328 /* We're going to call the error:handler later, but if the in_handler
1329 * reported an error we report this failure upstream
1331 LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" );
1332 retval = ERROR_JTAG_QUEUE_FAILED;
1338 bit_count += cmd->fields[i].num_bits;
1344 static const char *jtag_tap_name(jtag_tap_t *tap)
1346 return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1349 int jtag_check_value(u8 *captured, void *priv, scan_field_t *field)
1351 int retval = ERROR_OK;
1352 int num_bits = field->num_bits;
1354 int compare_failed = 0;
1356 if (field->in_check_mask)
1357 compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits);
1359 compare_failed = buf_cmp(captured, field->in_check_value, num_bits);
1361 if (compare_failed){
1362 /* An error handler could have caught the failing check
1363 * only report a problem when there wasn't a handler, or if the handler
1364 * acknowledged the error
1366 LOG_WARNING("TAP %s:",
1367 jtag_tap_name(field->tap));
1370 char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1371 char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1373 if (field->in_check_mask)
1375 char *in_check_mask_char;
1376 in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1377 LOG_WARNING("value captured during scan didn't pass the requested check:");
1378 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1379 captured_char, in_check_value_char, in_check_mask_char);
1380 free(in_check_mask_char);
1384 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);
1387 free(captured_char);
1388 free(in_check_value_char);
1390 retval = ERROR_JTAG_QUEUE_FAILED;
1398 set up checking of this field using the in_handler. The values passed in must be valid until
1399 after jtag_execute() has completed.
1401 void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler)
1404 field->in_handler = jtag_check_value;
1406 field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */
1407 field->in_handler_priv = NULL;
1408 field->in_check_value = value;
1409 field->in_check_mask = mask;
1412 enum scan_type jtag_scan_type(scan_command_t *cmd)
1417 for (i = 0; i < cmd->num_fields; i++)
1419 if (cmd->fields[i].in_value || cmd->fields[i].in_handler)
1421 if (cmd->fields[i].out_value)
1428 int MINIDRIVER(interface_jtag_execute_queue)(void)
1434 LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets.");
1438 retval = jtag->execute_queue();
1442 jtag_command_queue = NULL;
1443 last_comand_pointer = &jtag_command_queue;
1448 int jtag_execute_queue(void)
1450 int retval=interface_jtag_execute_queue();
1451 if (retval==ERROR_OK)
1455 jtag_error=ERROR_OK;
1459 int jtag_reset_callback(enum jtag_event event, void *priv)
1461 jtag_tap_t *tap = priv;
1465 if (event == JTAG_TRST_ASSERTED)
1467 buf_set_ones(tap->cur_instr, tap->ir_length);
1474 void jtag_sleep(u32 us)
1476 alive_sleep(us/1000);
1479 /* Try to examine chain layout according to IEEE 1149.1 §12
1481 int jtag_examine_chain(void)
1485 u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1488 int device_count = 0;
1489 u8 zero_check = 0x0;
1490 u8 one_check = 0xff;
1493 field.num_bits = sizeof(idcode_buffer) * 8;
1494 field.out_value = idcode_buffer;
1495 field.out_mask = NULL;
1496 field.in_value = idcode_buffer;
1497 field.in_check_value = NULL;
1498 field.in_check_mask = NULL;
1499 field.in_handler = NULL;
1500 field.in_handler_priv = NULL;
1502 for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1504 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1507 jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1508 jtag_execute_queue();
1510 for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1512 zero_check |= idcode_buffer[i];
1513 one_check &= idcode_buffer[i];
1516 /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1517 if ((zero_check == 0x00) || (one_check == 0xff))
1519 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1520 return ERROR_JTAG_INIT_FAILED;
1523 /* point at the 1st tap */
1524 tap = jtag_NextEnabledTap(NULL);
1526 LOG_ERROR("JTAG: No taps enabled?");
1527 return ERROR_JTAG_INIT_FAILED;
1530 for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1532 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1533 if ((idcode & 1) == 0)
1535 /* LSB must not be 0, this indicates a device in bypass */
1536 LOG_WARNING("Tap/Device does not have IDCODE");
1547 /* some devices, such as AVR will output all 1's instead of TDI
1548 input value at end of chain. */
1549 if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1552 /* End of chain (invalid manufacturer ID)
1554 * The JTAG examine is the very first thing that happens
1556 * A single JTAG device requires only 64 bits to be read back correctly.
1558 * The code below adds a check that the rest of the data scanned (640 bits)
1559 * are all as expected. This helps diagnose/catch problems with the JTAG chain
1561 * earlier and gives more helpful/explicit error messages.
1563 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1565 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1566 if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1568 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1576 #define EXTRACT_MFG(X) (((X) & 0xffe) >> 1)
1577 manufacturer = EXTRACT_MFG(idcode);
1578 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1579 part = EXTRACT_PART(idcode);
1580 #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28)
1581 version = EXTRACT_VER(idcode);
1583 LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1584 ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1585 idcode, manufacturer, part, version);
1591 tap->idcode = idcode;
1593 if (tap->expected_ids_cnt > 0) {
1594 /* Loop over the expected identification codes and test for a match */
1596 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1597 if( tap->idcode == tap->expected_ids[ii] ){
1602 /* If none of the expected ids matched, log an error */
1603 if (ii == tap->expected_ids_cnt) {
1604 LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1607 EXTRACT_MFG( tap->idcode ),
1608 EXTRACT_PART( tap->idcode ),
1609 EXTRACT_VER( tap->idcode ) );
1610 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1611 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1614 tap->expected_ids_cnt,
1615 tap->expected_ids[ii],
1616 EXTRACT_MFG( tap->expected_ids[ii] ),
1617 EXTRACT_PART( tap->expected_ids[ii] ),
1618 EXTRACT_VER( tap->expected_ids[ii] ) );
1621 return ERROR_JTAG_INIT_FAILED;
1623 LOG_INFO("JTAG Tap/device matched");
1627 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1631 tap = jtag_NextEnabledTap(tap);
1636 /* see if number of discovered devices matches configuration */
1637 if (device_count != jtag_NumEnabledTaps())
1639 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1640 device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1641 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1642 return ERROR_JTAG_INIT_FAILED;
1648 int jtag_validate_chain(void)
1651 int total_ir_length = 0;
1657 total_ir_length = 0;
1659 tap = jtag_NextEnabledTap(tap);
1663 total_ir_length += tap->ir_length;
1666 total_ir_length += 2;
1667 ir_test = malloc(CEIL(total_ir_length, 8));
1668 buf_set_ones(ir_test, total_ir_length);
1671 field.num_bits = total_ir_length;
1672 field.out_value = ir_test;
1673 field.out_mask = NULL;
1674 field.in_value = ir_test;
1675 field.in_check_value = NULL;
1676 field.in_check_mask = NULL;
1677 field.in_handler = NULL;
1678 field.in_handler_priv = NULL;
1680 jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1681 jtag_execute_queue();
1687 tap = jtag_NextEnabledTap(tap);
1692 val = buf_get_u32(ir_test, chain_pos, 2);
1695 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1696 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);
1699 return ERROR_JTAG_INIT_FAILED;
1701 chain_pos += tap->ir_length;
1704 val = buf_get_u32(ir_test, chain_pos, 2);
1707 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1708 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);
1711 return ERROR_JTAG_INIT_FAILED;
1719 enum jtag_tap_cfg_param {
1723 static Jim_Nvp nvp_config_opts[] = {
1724 { .name = "-event", .value = JCFG_EVENT },
1726 { .name = NULL, .value = -1 }
1729 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1735 /* parse config or cget options */
1736 while (goi->argc > 0) {
1737 Jim_SetEmptyResult (goi->interp);
1739 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1741 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1747 if (goi->argc == 0) {
1748 Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1752 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1754 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1758 if (goi->isconfigure) {
1759 if (goi->argc != 1) {
1760 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1764 if (goi->argc != 0) {
1765 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1771 jtag_tap_event_action_t *jteap;
1773 jteap = tap->event_action;
1774 /* replace existing? */
1776 if (jteap->event == (enum jtag_tap_event)n->value) {
1779 jteap = jteap->next;
1782 if (goi->isconfigure) {
1783 if (jteap == NULL) {
1785 jteap = calloc(1, sizeof (*jteap));
1787 jteap->event = n->value;
1788 Jim_GetOpt_Obj( goi, &o);
1790 Jim_DecrRefCount(interp, jteap->body);
1792 jteap->body = Jim_DuplicateObj(goi->interp, o);
1793 Jim_IncrRefCount(jteap->body);
1795 /* add to head of event list */
1796 jteap->next = tap->event_action;
1797 tap->event_action = jteap;
1798 Jim_SetEmptyResult(goi->interp);
1801 if (jteap == NULL) {
1802 Jim_SetEmptyResult(goi->interp);
1804 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1811 } /* while (goi->argc) */
1816 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1826 const Jim_Nvp opts[] = {
1827 #define NTAP_OPT_IRLEN 0
1828 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
1829 #define NTAP_OPT_IRMASK 1
1830 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
1831 #define NTAP_OPT_IRCAPTURE 2
1832 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
1833 #define NTAP_OPT_ENABLED 3
1834 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
1835 #define NTAP_OPT_DISABLED 4
1836 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
1837 #define NTAP_OPT_EXPECTED_ID 5
1838 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
1839 { .name = NULL , .value = -1 },
1842 pTap = malloc( sizeof(jtag_tap_t) );
1843 memset( pTap, 0, sizeof(*pTap) );
1845 Jim_SetResult_sprintf( goi->interp, "no memory");
1849 * we expect CHIP + TAP + OPTIONS
1851 if( goi->argc < 3 ){
1852 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1855 Jim_GetOpt_String( goi, &cp, NULL );
1856 pTap->chip = strdup(cp);
1858 Jim_GetOpt_String( goi, &cp, NULL );
1859 pTap->tapname = strdup(cp);
1861 /* name + dot + name + null */
1862 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1864 sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1865 pTap->dotted_name = cp;
1867 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1868 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1870 /* default is enabled */
1873 /* deal with options */
1874 #define NTREQ_IRLEN 1
1875 #define NTREQ_IRCAPTURE 2
1876 #define NTREQ_IRMASK 4
1878 /* clear them as we find them */
1879 reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1882 e = Jim_GetOpt_Nvp( goi, opts, &n );
1884 Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1887 LOG_DEBUG("Processing option: %s", n->name );
1889 case NTAP_OPT_ENABLED:
1892 case NTAP_OPT_DISABLED:
1895 case NTAP_OPT_EXPECTED_ID:
1897 u32 *new_expected_ids;
1899 e = Jim_GetOpt_Wide( goi, &w );
1901 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1905 new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1906 if (new_expected_ids == NULL) {
1907 Jim_SetResult_sprintf( goi->interp, "no memory");
1911 memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1913 new_expected_ids[pTap->expected_ids_cnt] = w;
1915 free(pTap->expected_ids);
1916 pTap->expected_ids = new_expected_ids;
1917 pTap->expected_ids_cnt++;
1920 case NTAP_OPT_IRLEN:
1921 case NTAP_OPT_IRMASK:
1922 case NTAP_OPT_IRCAPTURE:
1923 e = Jim_GetOpt_Wide( goi, &w );
1925 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1928 if( (w < 0) || (w > 0xffff) ){
1930 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1931 n->name, (int)(w), (int)(w));
1935 case NTAP_OPT_IRLEN:
1936 pTap->ir_length = w;
1937 reqbits &= (~(NTREQ_IRLEN));
1939 case NTAP_OPT_IRMASK:
1940 pTap->ir_capture_mask = w;
1941 reqbits &= (~(NTREQ_IRMASK));
1943 case NTAP_OPT_IRCAPTURE:
1944 pTap->ir_capture_value = w;
1945 reqbits &= (~(NTREQ_IRCAPTURE));
1948 } /* switch(n->value) */
1949 } /* while( goi->argc ) */
1951 /* Did we get all the options? */
1954 Jim_SetResult_sprintf( goi->interp,
1955 "newtap: %s missing required parameters",
1957 /* TODO: Tell user what is missing :-( */
1958 /* no memory leaks pelase */
1959 free(((void *)(pTap->expected_ids)));
1960 free(((void *)(pTap->chip)));
1961 free(((void *)(pTap->tapname)));
1962 free(((void *)(pTap->dotted_name)));
1963 free(((void *)(pTap)));
1967 pTap->expected = malloc( pTap->ir_length );
1968 pTap->expected_mask = malloc( pTap->ir_length );
1969 pTap->cur_instr = malloc( pTap->ir_length );
1971 buf_set_u32( pTap->expected,
1974 pTap->ir_capture_value );
1975 buf_set_u32( pTap->expected_mask,
1978 pTap->ir_capture_mask );
1979 buf_set_ones( pTap->cur_instr,
1984 jtag_register_event_callback(jtag_reset_callback, pTap );
1986 ppTap = &(jtag_all_taps);
1987 while( (*ppTap) != NULL ){
1988 ppTap = &((*ppTap)->next_tap);
1992 static int n_taps = 0;
1993 pTap->abs_chain_position = n_taps++;
1995 LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1996 (*ppTap)->dotted_name,
1997 (*ppTap)->abs_chain_position,
1998 (*ppTap)->ir_length,
1999 (*ppTap)->ir_capture_value,
2000 (*ppTap)->ir_capture_mask );
2005 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
2011 struct command_context_s *context;
2015 JTAG_CMD_INIT_RESET,
2018 JTAG_CMD_TAPDISABLE,
2019 JTAG_CMD_TAPISENABLED,
2024 const Jim_Nvp jtag_cmds[] = {
2025 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
2026 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
2027 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
2028 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
2029 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
2030 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
2031 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
2032 { .name = "cget" , .value = JTAG_CMD_CGET },
2034 { .name = NULL, .value = -1 },
2037 context = Jim_GetAssocData(interp, "context");
2038 /* go past the command */
2039 Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
2041 e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
2043 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
2046 Jim_SetEmptyResult( goi.interp );
2048 case JTAG_CMD_INTERFACE:
2049 /* return the name of the interface */
2050 /* TCL code might need to know the exact type... */
2051 /* FUTURE: we allow this as a means to "set" the interface. */
2052 if( goi.argc != 0 ){
2053 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2056 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
2058 case JTAG_CMD_INIT_RESET:
2059 if( goi.argc != 0 ){
2060 Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
2063 e = jtag_init_reset(context);
2064 if( e != ERROR_OK ){
2065 Jim_SetResult_sprintf( goi.interp, "error: %d", e);
2069 case JTAG_CMD_NEWTAP:
2070 return jim_newtap_cmd( &goi );
2072 case JTAG_CMD_TAPISENABLED:
2073 case JTAG_CMD_TAPENABLE:
2074 case JTAG_CMD_TAPDISABLE:
2075 if( goi.argc != 1 ){
2076 Jim_SetResultString( goi.interp, "Too many parameters",-1 );
2082 t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
2087 case JTAG_CMD_TAPISENABLED:
2090 case JTAG_CMD_TAPENABLE:
2091 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
2095 case JTAG_CMD_TAPDISABLE:
2096 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
2101 Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
2108 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
2115 Jim_GetOpt_Obj(&goi, &o);
2116 t = jtag_TapByJimObj( goi.interp, o );
2121 goi.isconfigure = 0;
2122 return jtag_tap_configure_cmd( &goi, t);
2126 case JTAG_CMD_CONFIGURE:
2128 Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
2135 Jim_GetOpt_Obj(&goi, &o);
2136 t = jtag_TapByJimObj( goi.interp, o );
2141 goi.isconfigure = 1;
2142 return jtag_tap_configure_cmd( &goi, t);
2149 int jtag_register_commands(struct command_context_s *cmd_ctx)
2151 register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
2153 register_command(cmd_ctx, NULL, "interface", handle_interface_command,
2154 COMMAND_CONFIG, "try to configure interface");
2155 register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
2156 COMMAND_ANY, "set jtag speed (if supported)");
2157 register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2158 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2159 register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2160 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2161 register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2163 "[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]");
2164 register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2165 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2166 register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2167 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2169 register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2170 COMMAND_EXEC, "print current scan chain configuration");
2172 register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2173 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2174 register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2175 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2176 register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2177 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2178 register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2179 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2180 register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2182 register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2183 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2187 int jtag_interface_init(struct command_context_s *cmd_ctx)
2192 if (!jtag_interface)
2194 /* nothing was previously specified by "interface" command */
2195 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2196 return ERROR_JTAG_INVALID_INTERFACE;
2200 jtag_interface->khz(speed_khz, &jtag_speed);
2204 if (jtag_interface->init() != ERROR_OK)
2205 return ERROR_JTAG_INIT_FAILED;
2207 jtag = jtag_interface;
2211 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2216 LOG_DEBUG("Init JTAG chain");
2218 tap = jtag_NextEnabledTap(NULL);
2220 LOG_ERROR("There are no enabled taps?");
2221 return ERROR_JTAG_INIT_FAILED;
2225 if ((retval=jtag_execute_queue())!=ERROR_OK)
2228 /* examine chain first, as this could discover the real chain layout */
2229 if (jtag_examine_chain() != ERROR_OK)
2231 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2234 if (jtag_validate_chain() != ERROR_OK)
2236 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2242 int jtag_init_reset(struct command_context_s *cmd_ctx)
2246 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2249 LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2251 /* Reset can happen after a power cycle.
2253 * Ideally we would only assert TRST or run RESET before the target reset.
2255 * However w/srst_pulls_trst, trst is asserted together with the target
2256 * reset whether we want it or not.
2258 * NB! Some targets have JTAG circuitry disabled until a
2259 * trst & srst has been asserted.
2261 * NB! here we assume nsrst/ntrst delay are sufficient!
2263 * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2266 jtag_add_reset(1, 0); /* RESET or TRST */
2267 if (jtag_reset_config & RESET_HAS_SRST)
2269 jtag_add_reset(1, 1);
2270 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2271 jtag_add_reset(0, 1);
2273 jtag_add_reset(0, 0);
2274 if ((retval = jtag_execute_queue()) != ERROR_OK)
2277 /* Check that we can communication on the JTAG chain + eventually we want to
2278 * be able to perform enumeration only after OpenOCD has started
2279 * telnet and GDB server
2281 * That would allow users to more easily perform any magic they need to before
2284 return jtag_init_inner(cmd_ctx);
2287 int jtag_init(struct command_context_s *cmd_ctx)
2290 if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2292 if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2296 return jtag_init_reset(cmd_ctx);
2299 static int default_khz(int khz, int *jtag_speed)
2301 LOG_ERROR("Translation from khz to jtag_speed not implemented");
2305 static int default_speed_div(int speed, int *khz)
2307 LOG_ERROR("Translation from jtag_speed to khz not implemented");
2311 static int default_power_dropout(int *dropout)
2313 *dropout=0; /* by default we can't detect power dropout */
2317 static int default_srst_asserted(int *srst_asserted)
2319 *srst_asserted=0; /* by default we can't detect srst asserted */
2323 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2328 /* check whether the interface is already configured */
2331 LOG_WARNING("Interface already configured, ignoring");
2335 /* interface name is a mandatory argument */
2336 if (argc < 1 || args[0][0] == '\0')
2338 return ERROR_COMMAND_SYNTAX_ERROR;
2341 for (i=0; jtag_interfaces[i]; i++)
2343 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2345 if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2350 jtag_interface = jtag_interfaces[i];
2352 if (jtag_interface->khz == NULL)
2354 jtag_interface->khz = default_khz;
2356 if (jtag_interface->speed_div == NULL)
2358 jtag_interface->speed_div = default_speed_div;
2360 if (jtag_interface->power_dropout == NULL)
2362 jtag_interface->power_dropout = default_power_dropout;
2364 if (jtag_interface->srst_asserted == NULL)
2366 jtag_interface->srst_asserted = default_srst_asserted;
2373 /* no valid interface was found (i.e. the configuration option,
2374 * didn't match one of the compiled-in interfaces
2376 LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2377 LOG_ERROR("compiled-in jtag interfaces:");
2378 for (i = 0; jtag_interfaces[i]; i++)
2380 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2383 return ERROR_JTAG_INVALID_INTERFACE;
2386 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2390 Jim_Obj *newargs[ 10 ];
2393 * argv[-1] = command
2394 * argv[ 0] = ir length
2395 * argv[ 1] = ir capture
2396 * argv[ 2] = ir mask
2397 * argv[ 3] = not actually used by anything but in the docs
2401 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2404 command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2405 command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2409 command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2410 command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2411 command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2412 command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2414 newargs[0] = Jim_NewStringObj( interp, "jtag", -1 );
2415 newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2416 sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2417 newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2418 sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2419 newargs[3] = Jim_NewStringObj( interp, buf, -1 );
2420 newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 );
2421 newargs[5] = Jim_NewStringObj( interp, args[0], -1 );
2422 newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 );
2423 newargs[7] = Jim_NewStringObj( interp, args[1], -1 );
2424 newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 );
2425 newargs[9] = Jim_NewStringObj( interp, args[2], -1 );
2427 command_print( cmd_ctx, "NEW COMMAND:");
2428 sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2429 Jim_GetString( newargs[0], NULL ),
2430 Jim_GetString( newargs[1], NULL ),
2431 Jim_GetString( newargs[2], NULL ),
2432 Jim_GetString( newargs[3], NULL ),
2433 Jim_GetString( newargs[4], NULL ),
2434 Jim_GetString( newargs[5], NULL ),
2435 Jim_GetString( newargs[6], NULL ),
2436 Jim_GetString( newargs[7], NULL ),
2437 Jim_GetString( newargs[8], NULL ),
2438 Jim_GetString( newargs[9], NULL ) );
2440 e = jim_jtag_command( interp, 10, newargs );
2442 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2447 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2451 tap = jtag_all_taps;
2452 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
2453 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2456 u32 expected, expected_mask, cur_instr, ii;
2457 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2458 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2459 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2461 command_print(cmd_ctx,
2462 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2463 tap->abs_chain_position,
2465 tap->enabled ? 'Y' : 'n',
2467 (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2473 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2474 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
2475 tap->expected_ids[ii]);
2478 tap = tap->next_tap;
2484 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2487 return ERROR_COMMAND_SYNTAX_ERROR;
2491 if (strcmp(args[0], "none") == 0)
2492 jtag_reset_config = RESET_NONE;
2493 else if (strcmp(args[0], "trst_only") == 0)
2494 jtag_reset_config = RESET_HAS_TRST;
2495 else if (strcmp(args[0], "srst_only") == 0)
2496 jtag_reset_config = RESET_HAS_SRST;
2497 else if (strcmp(args[0], "trst_and_srst") == 0)
2498 jtag_reset_config = RESET_TRST_AND_SRST;
2501 LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2502 jtag_reset_config = RESET_NONE;
2503 return ERROR_INVALID_ARGUMENTS;
2509 if (strcmp(args[1], "separate") == 0)
2511 /* seperate reset lines - default */
2514 if (strcmp(args[1], "srst_pulls_trst") == 0)
2515 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2516 else if (strcmp(args[1], "trst_pulls_srst") == 0)
2517 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2518 else if (strcmp(args[1], "combined") == 0)
2519 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2522 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2523 jtag_reset_config = RESET_NONE;
2524 return ERROR_INVALID_ARGUMENTS;
2531 if (strcmp(args[2], "trst_open_drain") == 0)
2532 jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2533 else if (strcmp(args[2], "trst_push_pull") == 0)
2534 jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2537 LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2538 jtag_reset_config = RESET_NONE;
2539 return ERROR_INVALID_ARGUMENTS;
2545 if (strcmp(args[3], "srst_push_pull") == 0)
2546 jtag_reset_config |= RESET_SRST_PUSH_PULL;
2547 else if (strcmp(args[3], "srst_open_drain") == 0)
2548 jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2551 LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2552 jtag_reset_config = RESET_NONE;
2553 return ERROR_INVALID_ARGUMENTS;
2560 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2564 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2569 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2575 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2579 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2584 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2590 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2592 int retval=ERROR_OK;
2596 LOG_DEBUG("handle jtag speed");
2599 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2601 /* this command can be called during CONFIG,
2602 * in which case jtag isn't initialized */
2605 retval=jtag->speed(cur_speed);
2607 } else if (argc == 0)
2611 return ERROR_COMMAND_SYNTAX_ERROR;
2613 command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2618 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2620 int retval=ERROR_OK;
2621 LOG_DEBUG("handle jtag khz");
2625 speed_khz = strtoul(args[0], NULL, 0);
2629 LOG_DEBUG("have interface set up");
2631 if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2637 cur_speed = jtag_speed = speed_div1;
2639 retval=jtag->speed(cur_speed);
2648 return ERROR_COMMAND_SYNTAX_ERROR;
2653 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2659 command_print(cmd_ctx, "RCLK - adaptive");
2662 command_print(cmd_ctx, "%d kHz", speed_khz);
2668 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2674 return ERROR_COMMAND_SYNTAX_ERROR;
2678 state = tap_state_by_name( args[0] );
2680 command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2681 return ERROR_COMMAND_SYNTAX_ERROR;
2683 jtag_add_end_state(state);
2684 jtag_execute_queue();
2686 command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2691 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2698 return ERROR_COMMAND_SYNTAX_ERROR;
2701 if (args[0][0] == '1')
2703 else if (args[0][0] == '0')
2707 return ERROR_COMMAND_SYNTAX_ERROR;
2710 if (args[1][0] == '1')
2712 else if (args[1][0] == '0')
2716 return ERROR_COMMAND_SYNTAX_ERROR;
2719 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2720 return ERROR_JTAG_INIT_FAILED;
2722 jtag_add_reset(trst, srst);
2723 jtag_execute_queue();
2728 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2732 return ERROR_COMMAND_SYNTAX_ERROR;
2735 jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2736 jtag_execute_queue();
2742 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2745 scan_field_t *fields;
2747 tap_state_t endstate;
2749 if ((argc < 2) || (argc % 2))
2751 return ERROR_COMMAND_SYNTAX_ERROR;
2754 /* optional "-endstate" */
2756 /* at the end of the arguments. */
2758 endstate = TAP_INVALID;
2760 /* have at least one pair of numbers. */
2761 /* is last pair the magic text? */
2762 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2765 cpA = args[ argc-1 ];
2766 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2767 cpS = tap_state_name( endstate );
2768 if( 0 == strcmp( cpA, cpS ) ){
2772 if( endstate >= TAP_NUM_STATES ){
2773 return ERROR_COMMAND_SYNTAX_ERROR;
2775 /* found - remove the last 2 args */
2781 fields = malloc(sizeof(scan_field_t) * argc / 2);
2783 for (i = 0; i < argc / 2; i++)
2785 tap = jtag_TapByString( args[i*2] );
2788 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2791 int field_size = tap->ir_length;
2792 fields[i].tap = tap;
2793 fields[i].out_value = malloc(CEIL(field_size, 8));
2794 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2795 fields[i].out_mask = NULL;
2796 fields[i].in_value = NULL;
2797 fields[i].in_check_mask = NULL;
2798 fields[i].in_handler = NULL;
2799 fields[i].in_handler_priv = NULL;
2802 jtag_add_ir_scan(argc / 2, fields, TAP_INVALID);
2803 /* did we have an endstate? */
2804 if (endstate != TAP_INVALID)
2805 jtag_add_end_state(endstate);
2807 jtag_execute_queue();
2809 for (i = 0; i < argc / 2; i++)
2810 free(fields[i].out_value);
2817 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2820 scan_field_t *fields;
2822 int field_count = 0;
2825 tap_state_t endstate;
2828 * args[2] = num_bits
2829 * args[3] = hex string
2830 * ... repeat num bits and hex string ...
2833 * args[N-2] = "-endstate"
2834 * args[N-1] = statename
2836 if ((argc < 4) || ((argc % 2)!=0))
2838 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2842 /* assume no endstate */
2843 endstate = TAP_INVALID;
2844 /* validate arguments as numbers */
2846 for (i = 2; i < argc; i+=2)
2851 e = Jim_GetLong(interp, args[i], &bits);
2852 /* If valid - try next arg */
2857 /* Not valid.. are we at the end? */
2858 if ( ((i+2) != argc) ){
2859 /* nope, then error */
2863 /* it could be: "-endstate FOO" */
2865 /* get arg as a string. */
2866 cp = Jim_GetString( args[i], NULL );
2867 /* is it the magic? */
2868 if( 0 == strcmp( "-endstate", cp ) ){
2869 /* is the statename valid? */
2870 cp = Jim_GetString( args[i+1], NULL );
2872 /* see if it is a valid state name */
2873 endstate = tap_state_by_name(cp);
2875 /* update the error message */
2876 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2878 /* valid - so clear the error */
2880 /* and remove the last 2 args */
2885 /* Still an error? */
2887 return e; /* too bad */
2889 } /* validate args */
2891 tap = jtag_TapByJimObj( interp, args[1] );
2896 num_fields=(argc-2)/2;
2897 fields = malloc(sizeof(scan_field_t) * num_fields);
2898 for (i = 2; i < argc; i+=2)
2904 Jim_GetLong(interp, args[i], &bits);
2905 str = Jim_GetString(args[i+1], &len);
2907 fields[field_count].tap = tap;
2908 fields[field_count].num_bits = bits;
2909 fields[field_count].out_value = malloc(CEIL(bits, 8));
2910 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2911 fields[field_count].out_mask = NULL;
2912 fields[field_count].in_value = fields[field_count].out_value;
2913 fields[field_count].in_check_mask = NULL;
2914 fields[field_count].in_check_value = NULL;
2915 fields[field_count].in_handler = NULL;
2916 fields[field_count++].in_handler_priv = NULL;
2919 jtag_add_dr_scan(num_fields, fields, TAP_INVALID);
2920 /* did we get an end state? */
2921 if (endstate != TAP_INVALID)
2922 jtag_add_end_state(endstate);
2924 retval = jtag_execute_queue();
2925 if (retval != ERROR_OK)
2927 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2932 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2933 for (i = 2; i < argc; i+=2)
2938 Jim_GetLong(interp, args[i], &bits);
2939 str = buf_to_str(fields[field_count].in_value, bits, 16);
2940 free(fields[field_count].out_value);
2942 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2947 Jim_SetResult(interp, list);
2954 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2958 if (strcmp(args[0], "enable") == 0)
2960 jtag_verify_capture_ir = 1;
2962 else if (strcmp(args[0], "disable") == 0)
2964 jtag_verify_capture_ir = 0;
2967 return ERROR_COMMAND_SYNTAX_ERROR;
2969 } else if (argc != 0)
2971 return ERROR_COMMAND_SYNTAX_ERROR;
2974 command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2979 int jtag_power_dropout(int *dropout)
2981 return jtag->power_dropout(dropout);
2984 int jtag_srst_asserted(int *srst_asserted)
2986 return jtag->srst_asserted(srst_asserted);
2989 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2991 jtag_tap_event_action_t * jteap;
2994 jteap = tap->event_action;
2998 if (jteap->event == e) {
3000 LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3003 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
3004 Jim_GetString(jteap->body, NULL) );
3005 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3006 Jim_PrintErrorMessage(interp);
3010 jteap = jteap->next;
3014 LOG_DEBUG( "event %d %s - no action",
3016 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3020 /*-----<Cable Helper API>---------------------------------------*/
3022 /* these Cable Helper API functions are all documented in the jtag.h header file,
3023 using a Doxygen format. And since Doxygen's configuration file "Doxyfile",
3024 is setup to prefer its docs in the header file, no documentation is here, for
3025 if it were, it would have to be doubly maintained.
3029 * @see tap_set_state() and tap_get_state() accessors.
3030 * Actual name is not important since accessors hide it.
3032 static tap_state_t state_follower = TAP_RESET;
3034 void tap_set_state_impl( tap_state_t new_state )
3036 /* this is the state we think the TAPs are in now, was cur_state */
3037 state_follower = new_state;
3040 tap_state_t tap_get_state()
3042 return state_follower;
3046 * @see tap_set_end_state() and tap_get_end_state() accessors.
3047 * Actual name is not important because accessors hide it.
3049 static tap_state_t end_state_follower = TAP_RESET;
3051 void tap_set_end_state( tap_state_t new_end_state )
3053 /* this is the state we think the TAPs will be in at completion of the
3054 current TAP operation, was end_state
3056 end_state_follower = new_end_state;
3059 tap_state_t tap_get_end_state()
3061 return end_state_follower;
3065 int tap_move_ndx( tap_state_t astate )
3067 /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3073 case TAP_RESET: ndx = 0; break;
3074 case TAP_DRSHIFT: ndx = 2; break;
3075 case TAP_DRPAUSE: ndx = 3; break;
3076 case TAP_IDLE: ndx = 1; break;
3077 case TAP_IRSHIFT: ndx = 4; break;
3078 case TAP_IRPAUSE: ndx = 5; break;
3080 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3088 /* tap_move[i][j]: tap movement command to go from state i to state j
3089 * 0: Test-Logic-Reset
3096 * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3103 } tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */
3105 /* value clocked to TMS to move from one of six stable states to another.
3106 * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3107 * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3108 * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3109 * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3113 * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3114 * Read the bits from LSBit first to MSBit last (right-to-left).
3116 #define HEX__(n) 0x##n##LU
3119 (((x) & 0x0000000FLU)?(1<<0):0) \
3120 +(((x) & 0x000000F0LU)?(1<<1):0) \
3121 +(((x) & 0x00000F00LU)?(1<<2):0) \
3122 +(((x) & 0x0000F000LU)?(1<<3):0) \
3123 +(((x) & 0x000F0000LU)?(1<<4):0) \
3124 +(((x) & 0x00F00000LU)?(1<<5):0) \
3125 +(((x) & 0x0F000000LU)?(1<<6):0) \
3126 +(((x) & 0xF0000000LU)?(1<<7):0)
3128 #define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) }
3130 #if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1))
3131 /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3133 OK, I added Peter's version of the state table, and it works OK for
3134 me on MC1322x. I've recreated the jlink portion of patch with this
3135 new state table. His changes to my state table are pretty minor in
3136 terms of total transitions, but Peter feels that his version fixes
3137 some long-standing problems.
3140 I added the bit count into the table
3145 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3146 { B8(11111,5), B8(0,1), B8(0010,4), B8(01010,5), B8(00110,5), B8(010110,6) }, /* RESET */
3147 { B8(11111,5), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */
3148 { B8(11111,5), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */
3149 { B8(11111,5), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */
3150 { B8(11111,5), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */
3151 { B8(11111,5), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */
3153 #else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */
3156 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */
3157 { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */
3158 { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */
3159 { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */
3160 { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */
3161 { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */
3162 { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) }, /* IRPAUSE */
3166 #if 0 /* keeping old hex stuff for awhile, for reference */
3167 /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */
3168 { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16 }, /* RESET */
3169 { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b }, /* IDLE */
3170 { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f }, /* DRSHIFT */
3171 { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f }, /* DRPAUSE */
3172 { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01 }, /* IRSHIFT */
3173 { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f } /* IRPAUSE */
3178 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3180 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3184 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3186 return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3190 bool tap_is_state_stable(tap_state_t astate)
3194 /* A switch() is used because it is symbol dependent
3195 (not value dependent like an array), and can also check bounds.
3214 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3216 tap_state_t new_state;
3218 /* A switch is used because it is symbol dependent and not value dependent
3219 like an array. Also it can check for out of range conditions.
3227 new_state = cur_state;
3232 new_state = TAP_DRSELECT;
3235 new_state = TAP_IRSELECT;
3239 new_state = TAP_DREXIT1;
3243 new_state = TAP_DRUPDATE;
3246 new_state = TAP_DREXIT2;
3249 new_state = TAP_RESET;
3253 new_state = TAP_IREXIT1;
3257 new_state = TAP_IRUPDATE;
3260 new_state = TAP_IREXIT2;
3263 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3276 new_state = TAP_IDLE;
3279 new_state = TAP_DRCAPTURE;
3284 new_state = TAP_DRSHIFT;
3288 new_state = TAP_DRPAUSE;
3291 new_state = TAP_IRCAPTURE;
3296 new_state = TAP_IRSHIFT;
3300 new_state = TAP_IRPAUSE;
3303 LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3312 const char* tap_state_name(tap_state_t state)
3318 case TAP_RESET: ret = "RESET"; break;
3319 case TAP_IDLE: ret = "RUN/IDLE"; break;
3320 case TAP_DRSELECT: ret = "DRSELECT"; break;
3321 case TAP_DRCAPTURE: ret = "DRCAPTURE"; break;
3322 case TAP_DRSHIFT: ret = "DRSHIFT"; break;
3323 case TAP_DREXIT1: ret = "DREXIT1"; break;
3324 case TAP_DRPAUSE: ret = "DRPAUSE"; break;
3325 case TAP_DREXIT2: ret = "DREXIT2"; break;
3326 case TAP_DRUPDATE: ret = "DRUPDATE"; break;
3327 case TAP_IRSELECT: ret = "IRSELECT"; break;
3328 case TAP_IRCAPTURE: ret = "IRCAPTURE"; break;
3329 case TAP_IRSHIFT: ret = "IRSHIFT"; break;
3330 case TAP_IREXIT1: ret = "IREXIT1"; break;
3331 case TAP_IRPAUSE: ret = "IRPAUSE"; break;
3332 case TAP_IREXIT2: ret = "IREXIT2"; break;
3333 case TAP_IRUPDATE: ret = "IRUPDATE"; break;
3334 default: ret = "???";
3340 static tap_state_t tap_state_by_name( const char *name )
3344 for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3345 /* be nice to the human */
3346 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3354 #ifdef _DEBUG_JTAG_IO_
3356 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3357 do { buf[len] = bit ? '1' : '0'; } while(0)
3358 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3359 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3360 tap_state_name(a), tap_state_name(b), astr, bstr)
3362 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3363 unsigned tap_bits, tap_state_t next_state)
3365 const u8 *tms_buffer;
3366 const u8 *tdi_buffer;
3371 unsigned tap_out_bits;
3375 tap_state_t last_state;
3377 // set startstate (and possibly last, if tap_bits == 0)
3378 last_state = next_state;
3379 DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3381 tms_buffer = (const u8 *)tms_buf;
3382 tdi_buffer = (const u8 *)tdi_buf;
3384 tap_bytes = TAP_SCAN_BYTES(tap_bits);
3385 DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3388 for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3390 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3392 // make sure we do not run off the end of the buffers
3393 unsigned tap_bit = cur_byte * 8 + cur_bit;
3394 if (tap_bit == tap_bits)
3397 // check and save TMS bit
3398 tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3399 JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3401 // use TMS bit to find the next TAP state
3402 next_state = tap_state_transition(last_state, tap_bit);
3404 // check and store TDI bit
3405 tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3406 JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3408 // increment TAP bits
3411 // Only show TDO bits on state transitions, or
3412 // after some number of bits in the same state.
3413 if ((next_state == last_state) && (tap_out_bits < 32))
3416 // terminate strings and display state transition
3417 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3418 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3421 last_state = next_state;
3428 // terminate strings and display state transition
3429 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3430 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3433 DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3437 #endif // _DEBUG_JTAG_IO_
3439 /*-----</Cable Helper API>--------------------------------------*/