1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007-2010 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2009 SoftPLC Corporation *
12 * Copyright (C) 2009 Zachary T Welch *
13 * zw@superlucidity.net *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
20 * This program is distributed in the hope that it will be useful, *
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
23 * GNU General Public License for more details. *
25 * You should have received a copy of the GNU General Public License *
26 * along with this program; if not, write to the *
27 * Free Software Foundation, Inc., *
28 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
29 ***************************************************************************/
37 #include "minidriver.h"
38 #include "interface.h"
39 #include "interfaces.h"
46 #include <helper/time_support.h>
50 * Holds support for accessing JTAG-specific mechanisms from TCl scripts.
53 static const Jim_Nvp nvp_jtag_tap_event
[] = {
54 { .value
= JTAG_TRST_ASSERTED
, .name
= "post-reset" },
55 { .value
= JTAG_TAP_EVENT_SETUP
, .name
= "setup" },
56 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
57 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
59 { .name
= NULL
, .value
= -1 }
62 struct jtag_tap
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
64 const char *cp
= Jim_GetString(o
, NULL
);
65 struct jtag_tap
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
69 Jim_SetResultFormatted(interp
, "Tap '%s' could not be found", cp
);
73 static bool scan_is_safe(tap_state_t state
)
86 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
89 struct scan_field
*fields
;
98 * args[3] = hex string
99 * ... repeat num bits and hex string ...
102 * args[N-2] = "-endstate"
103 * args[N-1] = statename
105 if ((argc
< 4) || ((argc
% 2) != 0)) {
106 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
112 script_debug(interp
, "drscan", argc
, args
);
114 /* validate arguments as numbers */
116 for (i
= 2; i
< argc
; i
+= 2) {
120 e
= Jim_GetLong(interp
, args
[i
], &bits
);
121 /* If valid - try next arg */
125 /* Not valid.. are we at the end? */
126 if (((i
+ 2) != argc
)) {
127 /* nope, then error */
131 /* it could be: "-endstate FOO"
132 * e.g. DRPAUSE so we can issue more instructions
133 * before entering RUN/IDLE and executing them.
136 /* get arg as a string. */
137 cp
= Jim_GetString(args
[i
], NULL
);
138 /* is it the magic? */
139 if (0 == strcmp("-endstate", cp
)) {
140 /* is the statename valid? */
141 cp
= Jim_GetString(args
[i
+ 1], NULL
);
143 /* see if it is a valid state name */
144 endstate
= tap_state_by_name(cp
);
146 /* update the error message */
147 Jim_SetResultFormatted(interp
, "endstate: %s invalid", cp
);
149 if (!scan_is_safe(endstate
))
150 LOG_WARNING("drscan with unsafe "
151 "endstate \"%s\"", cp
);
153 /* valid - so clear the error */
155 /* and remove the last 2 args */
160 /* Still an error? */
162 return e
; /* too bad */
163 } /* validate args */
167 tap
= jtag_tap_by_jim_obj(interp
, args
[1]);
171 num_fields
= (argc
-2)/2;
172 if (num_fields
<= 0) {
173 Jim_SetResultString(interp
, "drscan: no scan fields supplied", -1);
176 fields
= malloc(sizeof(struct scan_field
) * num_fields
);
177 for (i
= 2; i
< argc
; i
+= 2) {
182 Jim_GetLong(interp
, args
[i
], &bits
);
183 str
= Jim_GetString(args
[i
+ 1], &len
);
185 fields
[field_count
].num_bits
= bits
;
186 void *t
= malloc(DIV_ROUND_UP(bits
, 8));
187 fields
[field_count
].out_value
= t
;
188 str_to_buf(str
, len
, t
, bits
, 0);
189 fields
[field_count
].in_value
= t
;
193 jtag_add_dr_scan(tap
, num_fields
, fields
, endstate
);
195 retval
= jtag_execute_queue();
196 if (retval
!= ERROR_OK
) {
197 Jim_SetResultString(interp
, "drscan: jtag execute failed", -1);
202 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
203 for (i
= 2; i
< argc
; i
+= 2) {
207 Jim_GetLong(interp
, args
[i
], &bits
);
208 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
209 free(fields
[field_count
].in_value
);
211 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
216 Jim_SetResult(interp
, list
);
224 static int Jim_Command_pathmove(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
226 tap_state_t states
[8];
228 if ((argc
< 2) || ((size_t)argc
> (ARRAY_SIZE(states
) + 1))) {
229 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
233 script_debug(interp
, "pathmove", argc
, args
);
236 for (i
= 0; i
< argc
-1; i
++) {
238 cp
= Jim_GetString(args
[i
+ 1], NULL
);
239 states
[i
] = tap_state_by_name(cp
);
241 /* update the error message */
242 Jim_SetResultFormatted(interp
, "endstate: %s invalid", cp
);
247 if ((jtag_add_statemove(states
[0]) != ERROR_OK
) || (jtag_execute_queue() != ERROR_OK
)) {
248 Jim_SetResultString(interp
, "pathmove: jtag execute failed", -1);
252 jtag_add_pathmove(argc
- 2, states
+ 1);
254 if (jtag_execute_queue() != ERROR_OK
) {
255 Jim_SetResultString(interp
, "pathmove: failed", -1);
263 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
265 script_debug(interp
, "flush_count", argc
, args
);
267 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_get_flush_queue_count()));
272 /* REVISIT Just what about these should "move" ... ?
273 * These registrations, into the main JTAG table?
275 * There's a minor compatibility issue, these all show up twice;
276 * that's not desirable:
277 * - jtag drscan ... NOT DOCUMENTED!
280 * The "irscan" command (for example) doesn't show twice.
282 static const struct command_registration jtag_command_handlers_to_move
[] = {
285 .mode
= COMMAND_EXEC
,
286 .jim_handler
= Jim_Command_drscan
,
287 .help
= "Execute Data Register (DR) scan for one TAP. "
288 "Other TAPs must be in BYPASS mode.",
289 .usage
= "tap_name [num_bits value]* ['-endstate' state_name]",
292 .name
= "flush_count",
293 .mode
= COMMAND_EXEC
,
294 .jim_handler
= Jim_Command_flush_count
,
295 .help
= "Returns the number of times the JTAG queue "
300 .mode
= COMMAND_EXEC
,
301 .jim_handler
= Jim_Command_pathmove
,
302 .usage
= "start_state state1 [state2 [state3 ...]]",
303 .help
= "Move JTAG state machine from current state "
304 "(start_state) to state1, then state2, state3, etc.",
306 COMMAND_REGISTRATION_DONE
310 enum jtag_tap_cfg_param
{
314 static Jim_Nvp nvp_config_opts
[] = {
315 { .name
= "-event", .value
= JCFG_EVENT
},
317 { .name
= NULL
, .value
= -1 }
320 static int jtag_tap_configure_event(Jim_GetOptInfo
*goi
, struct jtag_tap
*tap
)
322 if (goi
->argc
== 0) {
323 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event <event-name> ...");
328 int e
= Jim_GetOpt_Nvp(goi
, nvp_jtag_tap_event
, &n
);
330 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
334 if (goi
->isconfigure
) {
335 if (goi
->argc
!= 1) {
336 Jim_WrongNumArgs(goi
->interp
,
339 "-event <event-name> <event-body>");
343 if (goi
->argc
!= 0) {
344 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event <event-name>");
349 struct jtag_tap_event_action
*jteap
= tap
->event_action
;
350 /* replace existing event body */
353 if (jteap
->event
== (enum jtag_event
)n
->value
) {
360 Jim_SetEmptyResult(goi
->interp
);
362 if (goi
->isconfigure
) {
364 jteap
= calloc(1, sizeof(*jteap
));
365 else if (NULL
!= jteap
->body
)
366 Jim_DecrRefCount(goi
->interp
, jteap
->body
);
368 jteap
->interp
= goi
->interp
;
369 jteap
->event
= n
->value
;
372 Jim_GetOpt_Obj(goi
, &o
);
373 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
374 Jim_IncrRefCount(jteap
->body
);
377 /* add to head of event list */
378 jteap
->next
= tap
->event_action
;
379 tap
->event_action
= jteap
;
382 jteap
->interp
= goi
->interp
;
383 Jim_SetResult(goi
->interp
,
384 Jim_DuplicateObj(goi
->interp
, jteap
->body
));
389 static int jtag_tap_configure_cmd(Jim_GetOptInfo
*goi
, struct jtag_tap
*tap
)
391 /* parse config or cget options */
392 while (goi
->argc
> 0) {
393 Jim_SetEmptyResult(goi
->interp
);
396 int e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
398 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
404 e
= jtag_tap_configure_event(goi
, tap
);
409 Jim_SetResultFormatted(goi
->interp
, "unknown event: %s", n
->name
);
417 static int is_bad_irval(int ir_length
, jim_wide w
)
427 static int jim_newtap_expected_id(Jim_Nvp
*n
, Jim_GetOptInfo
*goi
,
428 struct jtag_tap
*pTap
)
431 int e
= Jim_GetOpt_Wide(goi
, &w
);
433 Jim_SetResultFormatted(goi
->interp
, "option: %s bad parameter", n
->name
);
437 unsigned expected_len
= sizeof(uint32_t) * pTap
->expected_ids_cnt
;
438 uint32_t *new_expected_ids
= malloc(expected_len
+ sizeof(uint32_t));
439 if (new_expected_ids
== NULL
) {
440 Jim_SetResultFormatted(goi
->interp
, "no memory");
444 memcpy(new_expected_ids
, pTap
->expected_ids
, expected_len
);
446 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
448 free(pTap
->expected_ids
);
449 pTap
->expected_ids
= new_expected_ids
;
450 pTap
->expected_ids_cnt
++;
455 #define NTAP_OPT_IRLEN 0
456 #define NTAP_OPT_IRMASK 1
457 #define NTAP_OPT_IRCAPTURE 2
458 #define NTAP_OPT_ENABLED 3
459 #define NTAP_OPT_DISABLED 4
460 #define NTAP_OPT_EXPECTED_ID 5
461 #define NTAP_OPT_VERSION 6
463 static int jim_newtap_ir_param(Jim_Nvp
*n
, Jim_GetOptInfo
*goi
,
464 struct jtag_tap
*pTap
)
467 int e
= Jim_GetOpt_Wide(goi
, &w
);
469 Jim_SetResultFormatted(goi
->interp
,
470 "option: %s bad parameter", n
->name
);
475 if (w
> (jim_wide
) (8 * sizeof(pTap
->ir_capture_value
))) {
476 LOG_WARNING("%s: huge IR length %d",
477 pTap
->dotted_name
, (int) w
);
481 case NTAP_OPT_IRMASK
:
482 if (is_bad_irval(pTap
->ir_length
, w
)) {
483 LOG_ERROR("%s: IR mask %x too big",
489 LOG_WARNING("%s: nonstandard IR mask", pTap
->dotted_name
);
490 pTap
->ir_capture_mask
= w
;
492 case NTAP_OPT_IRCAPTURE
:
493 if (is_bad_irval(pTap
->ir_length
, w
)) {
494 LOG_ERROR("%s: IR capture %x too big",
495 pTap
->dotted_name
, (int) w
);
499 LOG_WARNING("%s: nonstandard IR value",
501 pTap
->ir_capture_value
= w
;
509 static int jim_newtap_cmd(Jim_GetOptInfo
*goi
)
511 struct jtag_tap
*pTap
;
516 const Jim_Nvp opts
[] = {
517 { .name
= "-irlen", .value
= NTAP_OPT_IRLEN
},
518 { .name
= "-irmask", .value
= NTAP_OPT_IRMASK
},
519 { .name
= "-ircapture", .value
= NTAP_OPT_IRCAPTURE
},
520 { .name
= "-enable", .value
= NTAP_OPT_ENABLED
},
521 { .name
= "-disable", .value
= NTAP_OPT_DISABLED
},
522 { .name
= "-expected-id", .value
= NTAP_OPT_EXPECTED_ID
},
523 { .name
= "-ignore-version", .value
= NTAP_OPT_VERSION
},
524 { .name
= NULL
, .value
= -1 },
527 pTap
= calloc(1, sizeof(struct jtag_tap
));
529 Jim_SetResultFormatted(goi
->interp
, "no memory");
534 * we expect CHIP + TAP + OPTIONS
537 Jim_SetResultFormatted(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
541 Jim_GetOpt_String(goi
, &cp
, NULL
);
542 pTap
->chip
= strdup(cp
);
544 Jim_GetOpt_String(goi
, &cp
, NULL
);
545 pTap
->tapname
= strdup(cp
);
547 /* name + dot + name + null */
548 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
550 sprintf(cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
551 pTap
->dotted_name
= cp
;
553 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
554 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
556 if (!transport_is_jtag()) {
557 /* SWD or CMSIS-DAP (which is currently SWD-only) doesn't
558 require any JTAG tap parameters */
559 pTap
->enabled
= true;
564 /* IEEE specifies that the two LSBs of an IR scan are 01, so make
565 * that the default. The "-ircapture" and "-irmask" options are only
566 * needed to cope with nonstandard TAPs, or to specify more bits.
568 pTap
->ir_capture_mask
= 0x03;
569 pTap
->ir_capture_value
= 0x01;
572 e
= Jim_GetOpt_Nvp(goi
, opts
, &n
);
574 Jim_GetOpt_NvpUnknown(goi
, opts
, 0);
579 LOG_DEBUG("Processing option: %s", n
->name
);
581 case NTAP_OPT_ENABLED
:
582 pTap
->disabled_after_reset
= false;
584 case NTAP_OPT_DISABLED
:
585 pTap
->disabled_after_reset
= true;
587 case NTAP_OPT_EXPECTED_ID
:
588 e
= jim_newtap_expected_id(n
, goi
, pTap
);
596 case NTAP_OPT_IRMASK
:
597 case NTAP_OPT_IRCAPTURE
:
598 e
= jim_newtap_ir_param(n
, goi
, pTap
);
605 case NTAP_OPT_VERSION
:
606 pTap
->ignore_version
= true;
608 } /* switch (n->value) */
609 } /* while (goi->argc) */
611 /* default is enabled-after-reset */
612 pTap
->enabled
= !pTap
->disabled_after_reset
;
614 /* Did all the required option bits get cleared? */
615 if (pTap
->ir_length
!= 0) {
620 Jim_SetResultFormatted(goi
->interp
,
621 "newtap: %s missing IR length",
627 static void jtag_tap_handle_event(struct jtag_tap
*tap
, enum jtag_event e
)
629 struct jtag_tap_event_action
*jteap
;
631 for (jteap
= tap
->event_action
; jteap
!= NULL
; jteap
= jteap
->next
) {
632 if (jteap
->event
!= e
)
635 Jim_Nvp
*nvp
= Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
);
636 LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
637 tap
->dotted_name
, e
, nvp
->name
,
638 Jim_GetString(jteap
->body
, NULL
));
640 if (Jim_EvalObj(jteap
->interp
, jteap
->body
) != JIM_OK
) {
641 Jim_MakeErrorMessage(jteap
->interp
);
642 LOG_USER("%s", Jim_GetString(Jim_GetResult(jteap
->interp
), NULL
));
647 case JTAG_TAP_EVENT_ENABLE
:
648 case JTAG_TAP_EVENT_DISABLE
:
649 /* NOTE: we currently assume the handlers
650 * can't fail. Right here is where we should
651 * really be verifying the scan chains ...
653 tap
->enabled
= (e
== JTAG_TAP_EVENT_ENABLE
);
654 LOG_INFO("JTAG tap: %s %s", tap
->dotted_name
,
655 tap
->enabled
? "enabled" : "disabled");
663 static int jim_jtag_arp_init(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
666 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
668 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
671 struct command_context
*context
= current_command_context(interp
);
672 int e
= jtag_init_inner(context
);
674 Jim_Obj
*eObj
= Jim_NewIntObj(goi
.interp
, e
);
675 Jim_SetResultFormatted(goi
.interp
, "error: %#s", eObj
);
676 Jim_FreeNewObj(goi
.interp
, eObj
);
682 static int jim_jtag_arp_init_reset(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
686 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
688 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
691 struct command_context
*context
= current_command_context(interp
);
692 if (transport_is_jtag())
693 e
= jtag_init_reset(context
);
694 else if (transport_is_swd())
695 e
= swd_init_reset(context
);
698 Jim_Obj
*eObj
= Jim_NewIntObj(goi
.interp
, e
);
699 Jim_SetResultFormatted(goi
.interp
, "error: %#s", eObj
);
700 Jim_FreeNewObj(goi
.interp
, eObj
);
706 int jim_jtag_newtap(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
709 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
710 return jim_newtap_cmd(&goi
);
713 static bool jtag_tap_enable(struct jtag_tap
*t
)
717 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_ENABLE
);
721 /* FIXME add JTAG sanity checks, w/o TLR
722 * - scan chain length grew by one (this)
723 * - IDs and IR lengths are as expected
725 jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE
);
728 static bool jtag_tap_disable(struct jtag_tap
*t
)
732 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_DISABLE
);
736 /* FIXME add JTAG sanity checks, w/o TLR
737 * - scan chain length shrank by one (this)
738 * - IDs and IR lengths are as expected
740 jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE
);
744 int jim_jtag_tap_enabler(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
746 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
748 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
750 Jim_SetResultFormatted(goi
.interp
, "usage: %s <name>", cmd_name
);
756 t
= jtag_tap_by_jim_obj(goi
.interp
, goi
.argv
[0]);
760 if (strcasecmp(cmd_name
, "tapisenabled") == 0) {
761 /* do nothing, just return the value */
762 } else if (strcasecmp(cmd_name
, "tapenable") == 0) {
763 if (!jtag_tap_enable(t
)) {
764 LOG_WARNING("failed to enable tap %s", t
->dotted_name
);
767 } else if (strcasecmp(cmd_name
, "tapdisable") == 0) {
768 if (!jtag_tap_disable(t
)) {
769 LOG_WARNING("failed to disable tap %s", t
->dotted_name
);
773 LOG_ERROR("command '%s' unknown", cmd_name
);
777 Jim_SetResult(goi
.interp
, Jim_NewIntObj(goi
.interp
, e
));
781 int jim_jtag_configure(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
783 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
785 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
786 goi
.isconfigure
= !strcmp(cmd_name
, "configure");
787 if (goi
.argc
< 2 + goi
.isconfigure
) {
788 Jim_WrongNumArgs(goi
.interp
, 0, NULL
,
789 "<tap_name> <attribute> ...");
796 Jim_GetOpt_Obj(&goi
, &o
);
797 t
= jtag_tap_by_jim_obj(goi
.interp
, o
);
801 return jtag_tap_configure_cmd(&goi
, t
);
804 static int jim_jtag_names(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
807 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
809 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
, "Too many parameters");
812 Jim_SetResult(goi
.interp
, Jim_NewListObj(goi
.interp
, NULL
, 0));
813 struct jtag_tap
*tap
;
815 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
) {
816 Jim_ListAppendElement(goi
.interp
,
817 Jim_GetResult(goi
.interp
),
818 Jim_NewStringObj(goi
.interp
,
819 tap
->dotted_name
, -1));
824 COMMAND_HANDLER(handle_jtag_init_command
)
827 return ERROR_COMMAND_SYNTAX_ERROR
;
829 static bool jtag_initialized
;
830 if (jtag_initialized
) {
831 LOG_INFO("'jtag init' has already been called");
834 jtag_initialized
= true;
836 LOG_DEBUG("Initializing jtag devices...");
837 return jtag_init(CMD_CTX
);
840 static const struct command_registration jtag_subcommand_handlers
[] = {
844 .handler
= handle_jtag_init_command
,
845 .help
= "initialize jtag scan chain",
851 .jim_handler
= jim_jtag_arp_init
,
852 .help
= "Validates JTAG scan chain against the list of "
853 "declared TAPs using just the four standard JTAG "
857 .name
= "arp_init-reset",
859 .jim_handler
= jim_jtag_arp_init_reset
,
860 .help
= "Uses TRST and SRST to try resetting everything on "
861 "the JTAG scan chain, then performs 'jtag arp_init'."
865 .mode
= COMMAND_CONFIG
,
866 .jim_handler
= jim_jtag_newtap
,
867 .help
= "Create a new TAP instance named basename.tap_type, "
868 "and appends it to the scan chain.",
869 .usage
= "basename tap_type '-irlen' count "
870 "['-enable'|'-disable'] "
871 "['-expected_id' number] "
872 "['-ignore-version'] "
873 "['-ircapture' number] "
877 .name
= "tapisenabled",
878 .mode
= COMMAND_EXEC
,
879 .jim_handler
= jim_jtag_tap_enabler
,
880 .help
= "Returns a Tcl boolean (0/1) indicating whether "
881 "the TAP is enabled (1) or not (0).",
886 .mode
= COMMAND_EXEC
,
887 .jim_handler
= jim_jtag_tap_enabler
,
888 .help
= "Try to enable the specified TAP using the "
889 "'tap-enable' TAP event.",
893 .name
= "tapdisable",
894 .mode
= COMMAND_EXEC
,
895 .jim_handler
= jim_jtag_tap_enabler
,
896 .help
= "Try to disable the specified TAP using the "
897 "'tap-disable' TAP event.",
902 .mode
= COMMAND_EXEC
,
903 .jim_handler
= jim_jtag_configure
,
904 .help
= "Provide a Tcl handler for the specified "
906 .usage
= "tap_name '-event' event_name handler",
910 .mode
= COMMAND_EXEC
,
911 .jim_handler
= jim_jtag_configure
,
912 .help
= "Return any Tcl handler for the specified "
914 .usage
= "tap_name '-event' event_name",
919 .jim_handler
= jim_jtag_names
,
920 .help
= "Returns list of all JTAG tap names.",
923 .chain
= jtag_command_handlers_to_move
,
925 COMMAND_REGISTRATION_DONE
928 void jtag_notify_event(enum jtag_event event
)
930 struct jtag_tap
*tap
;
932 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
)
933 jtag_tap_handle_event(tap
, event
);
937 COMMAND_HANDLER(handle_scan_chain_command
)
939 struct jtag_tap
*tap
;
940 char expected_id
[12];
942 tap
= jtag_all_taps();
943 command_print(CMD_CTX
,
944 " TapName Enabled IdCode Expected IrLen IrCap IrMask");
945 command_print(CMD_CTX
,
946 "-- ------------------- -------- ---------- ---------- ----- ----- ------");
949 uint32_t expected
, expected_mask
, ii
;
951 snprintf(expected_id
, sizeof expected_id
, "0x%08x",
952 (unsigned)((tap
->expected_ids_cnt
> 0)
953 ? tap
->expected_ids
[0]
955 if (tap
->ignore_version
)
956 expected_id
[2] = '*';
958 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
959 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
961 command_print(CMD_CTX
,
962 "%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
963 tap
->abs_chain_position
,
965 tap
->enabled
? 'Y' : 'n',
966 (unsigned int)(tap
->idcode
),
968 (unsigned int)(tap
->ir_length
),
969 (unsigned int)(expected
),
970 (unsigned int)(expected_mask
));
972 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
973 snprintf(expected_id
, sizeof expected_id
, "0x%08x",
974 (unsigned) tap
->expected_ids
[ii
]);
975 if (tap
->ignore_version
)
976 expected_id
[2] = '*';
978 command_print(CMD_CTX
,
989 COMMAND_HANDLER(handle_jtag_ntrst_delay_command
)
992 return ERROR_COMMAND_SYNTAX_ERROR
;
995 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], delay
);
997 jtag_set_ntrst_delay(delay
);
999 command_print(CMD_CTX
, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
1003 COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command
)
1006 return ERROR_COMMAND_SYNTAX_ERROR
;
1007 if (CMD_ARGC
== 1) {
1009 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], delay
);
1011 jtag_set_ntrst_assert_width(delay
);
1013 command_print(CMD_CTX
, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
1017 COMMAND_HANDLER(handle_jtag_rclk_command
)
1020 return ERROR_COMMAND_SYNTAX_ERROR
;
1022 int retval
= ERROR_OK
;
1023 if (CMD_ARGC
== 1) {
1025 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], khz
);
1027 retval
= jtag_config_rclk(khz
);
1028 if (ERROR_OK
!= retval
)
1032 int cur_khz
= jtag_get_speed_khz();
1033 retval
= jtag_get_speed_readable(&cur_khz
);
1034 if (ERROR_OK
!= retval
)
1038 command_print(CMD_CTX
, "RCLK not supported - fallback to %d kHz", cur_khz
);
1040 command_print(CMD_CTX
, "RCLK - adaptive");
1045 COMMAND_HANDLER(handle_jtag_reset_command
)
1048 return ERROR_COMMAND_SYNTAX_ERROR
;
1051 if (CMD_ARGV
[0][0] == '1')
1053 else if (CMD_ARGV
[0][0] == '0')
1056 return ERROR_COMMAND_SYNTAX_ERROR
;
1059 if (CMD_ARGV
[1][0] == '1')
1061 else if (CMD_ARGV
[1][0] == '0')
1064 return ERROR_COMMAND_SYNTAX_ERROR
;
1066 if (adapter_init(CMD_CTX
) != ERROR_OK
)
1067 return ERROR_JTAG_INIT_FAILED
;
1069 jtag_add_reset(trst
, srst
);
1070 return jtag_execute_queue();
1073 COMMAND_HANDLER(handle_runtest_command
)
1076 return ERROR_COMMAND_SYNTAX_ERROR
;
1078 unsigned num_clocks
;
1079 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], num_clocks
);
1081 jtag_add_runtest(num_clocks
, TAP_IDLE
);
1082 return jtag_execute_queue();
1086 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1087 * should be stable ... and *NOT* a shift state, otherwise free-running
1088 * jtag clocks could change the values latched by the update state.
1089 * Not surprisingly, this is the same constraint as SVF; the "irscan"
1090 * and "drscan" commands are a write-only subset of what SVF provides.
1093 COMMAND_HANDLER(handle_irscan_command
)
1096 struct scan_field
*fields
;
1097 struct jtag_tap
*tap
= NULL
;
1098 tap_state_t endstate
;
1100 if ((CMD_ARGC
< 2) || (CMD_ARGC
% 2))
1101 return ERROR_COMMAND_SYNTAX_ERROR
;
1103 /* optional "-endstate" "statename" at the end of the arguments,
1104 * so that e.g. IRPAUSE can let us load the data register before
1105 * entering RUN/IDLE to execute the instruction we load here.
1107 endstate
= TAP_IDLE
;
1109 if (CMD_ARGC
>= 4) {
1110 /* have at least one pair of numbers.
1111 * is last pair the magic text? */
1112 if (strcmp("-endstate", CMD_ARGV
[CMD_ARGC
- 2]) == 0) {
1113 endstate
= tap_state_by_name(CMD_ARGV
[CMD_ARGC
- 1]);
1114 if (endstate
== TAP_INVALID
)
1115 return ERROR_COMMAND_SYNTAX_ERROR
;
1116 if (!scan_is_safe(endstate
))
1117 LOG_WARNING("unstable irscan endstate \"%s\"",
1118 CMD_ARGV
[CMD_ARGC
- 1]);
1123 int num_fields
= CMD_ARGC
/ 2;
1124 if (num_fields
> 1) {
1125 /* we really should be looking at plain_ir_scan if we want
1126 * anything more fancy.
1128 LOG_ERROR("Specify a single value for tap");
1129 return ERROR_COMMAND_SYNTAX_ERROR
;
1132 fields
= calloc(num_fields
, sizeof(*fields
));
1135 for (i
= 0; i
< num_fields
; i
++) {
1136 tap
= jtag_tap_by_string(CMD_ARGV
[i
*2]);
1139 command_print(CMD_CTX
, "Tap: %s unknown", CMD_ARGV
[i
*2]);
1143 int field_size
= tap
->ir_length
;
1144 fields
[i
].num_bits
= field_size
;
1145 uint8_t *v
= malloc(DIV_ROUND_UP(field_size
, 8));
1148 retval
= parse_u64(CMD_ARGV
[i
* 2 + 1], &value
);
1149 if (ERROR_OK
!= retval
)
1151 buf_set_u64(v
, 0, field_size
, value
);
1152 fields
[i
].out_value
= v
;
1153 fields
[i
].in_value
= NULL
;
1156 /* did we have an endstate? */
1157 jtag_add_ir_scan(tap
, fields
, endstate
);
1159 retval
= jtag_execute_queue();
1162 for (i
= 0; i
< num_fields
; i
++) {
1163 if (NULL
!= fields
[i
].out_value
)
1164 free((void *)fields
[i
].out_value
);
1172 COMMAND_HANDLER(handle_verify_ircapture_command
)
1175 return ERROR_COMMAND_SYNTAX_ERROR
;
1177 if (CMD_ARGC
== 1) {
1179 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
1180 jtag_set_verify_capture_ir(enable
);
1183 const char *status
= jtag_will_verify_capture_ir() ? "enabled" : "disabled";
1184 command_print(CMD_CTX
, "verify Capture-IR is %s", status
);
1189 COMMAND_HANDLER(handle_verify_jtag_command
)
1192 return ERROR_COMMAND_SYNTAX_ERROR
;
1194 if (CMD_ARGC
== 1) {
1196 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
1197 jtag_set_verify(enable
);
1200 const char *status
= jtag_will_verify() ? "enabled" : "disabled";
1201 command_print(CMD_CTX
, "verify jtag capture is %s", status
);
1206 COMMAND_HANDLER(handle_tms_sequence_command
)
1209 return ERROR_COMMAND_SYNTAX_ERROR
;
1211 if (CMD_ARGC
== 1) {
1213 if (strcmp(CMD_ARGV
[0], "short") == 0)
1214 use_new_table
= true;
1215 else if (strcmp(CMD_ARGV
[0], "long") == 0)
1216 use_new_table
= false;
1218 return ERROR_COMMAND_SYNTAX_ERROR
;
1220 tap_use_new_tms_table(use_new_table
);
1223 command_print(CMD_CTX
, "tms sequence is %s",
1224 tap_uses_new_tms_table() ? "short" : "long");
1229 COMMAND_HANDLER(handle_jtag_flush_queue_sleep
)
1232 return ERROR_COMMAND_SYNTAX_ERROR
;
1235 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], sleep_ms
);
1237 jtag_set_flush_queue_sleep(sleep_ms
);
1242 COMMAND_HANDLER(handle_wait_srst_deassert
)
1245 return ERROR_COMMAND_SYNTAX_ERROR
;
1248 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], timeout_ms
);
1249 if ((timeout_ms
<= 0) || (timeout_ms
> 100000)) {
1250 LOG_ERROR("Timeout must be an integer between 0 and 100000");
1254 LOG_USER("Waiting for srst assert + deassert for at most %dms", timeout_ms
);
1256 long long then
= timeval_ms();
1257 while (jtag_srst_asserted(&asserted_yet
) == ERROR_OK
) {
1258 if ((timeval_ms() - then
) > timeout_ms
) {
1259 LOG_ERROR("Timed out");
1265 while (jtag_srst_asserted(&asserted_yet
) == ERROR_OK
) {
1266 if ((timeval_ms() - then
) > timeout_ms
) {
1267 LOG_ERROR("Timed out");
1277 static const struct command_registration jtag_command_handlers
[] = {
1280 .name
= "jtag_flush_queue_sleep",
1281 .handler
= handle_jtag_flush_queue_sleep
,
1282 .mode
= COMMAND_ANY
,
1283 .help
= "For debug purposes(simulate long delays of interface) "
1284 "to test performance or change in behavior. Default 0ms.",
1285 .usage
= "[sleep in ms]",
1288 .name
= "jtag_rclk",
1289 .handler
= handle_jtag_rclk_command
,
1290 .mode
= COMMAND_ANY
,
1291 .help
= "With an argument, change to to use adaptive clocking "
1292 "if possible; else to use the fallback speed. "
1293 "With or without argument, display current setting.",
1294 .usage
= "[fallback_speed_khz]",
1297 .name
= "jtag_ntrst_delay",
1298 .handler
= handle_jtag_ntrst_delay_command
,
1299 .mode
= COMMAND_ANY
,
1300 .help
= "delay after deasserting trst in ms",
1301 .usage
= "[milliseconds]",
1304 .name
= "jtag_ntrst_assert_width",
1305 .handler
= handle_jtag_ntrst_assert_width_command
,
1306 .mode
= COMMAND_ANY
,
1307 .help
= "delay after asserting trst in ms",
1308 .usage
= "[milliseconds]",
1311 .name
= "scan_chain",
1312 .handler
= handle_scan_chain_command
,
1313 .mode
= COMMAND_ANY
,
1314 .help
= "print current scan chain configuration",
1318 .name
= "jtag_reset",
1319 .handler
= handle_jtag_reset_command
,
1320 .mode
= COMMAND_EXEC
,
1321 .help
= "Set reset line values. Value '1' is active, "
1322 "value '0' is inactive.",
1323 .usage
= "trst_active srst_active",
1327 .handler
= handle_runtest_command
,
1328 .mode
= COMMAND_EXEC
,
1329 .help
= "Move to Run-Test/Idle, and issue TCK for num_cycles.",
1330 .usage
= "num_cycles"
1334 .handler
= handle_irscan_command
,
1335 .mode
= COMMAND_EXEC
,
1336 .help
= "Execute Instruction Register (DR) scan. The "
1337 "specified opcodes are put into each TAP's IR, "
1338 "and other TAPs are put in BYPASS.",
1339 .usage
= "[tap_name instruction]* ['-endstate' state_name]",
1342 .name
= "verify_ircapture",
1343 .handler
= handle_verify_ircapture_command
,
1344 .mode
= COMMAND_ANY
,
1345 .help
= "Display or assign flag controlling whether to "
1346 "verify values captured during Capture-IR.",
1347 .usage
= "['enable'|'disable']",
1350 .name
= "verify_jtag",
1351 .handler
= handle_verify_jtag_command
,
1352 .mode
= COMMAND_ANY
,
1353 .help
= "Display or assign flag controlling whether to "
1354 "verify values captured during IR and DR scans.",
1355 .usage
= "['enable'|'disable']",
1358 .name
= "tms_sequence",
1359 .handler
= handle_tms_sequence_command
,
1360 .mode
= COMMAND_ANY
,
1361 .help
= "Display or change what style TMS sequences to use "
1362 "for JTAG state transitions: short (default) or "
1363 "long. Only for working around JTAG bugs.",
1364 /* Specifically for working around DRIVER bugs... */
1365 .usage
= "['short'|'long']",
1368 .name
= "wait_srst_deassert",
1369 .handler
= handle_wait_srst_deassert
,
1370 .mode
= COMMAND_ANY
,
1371 .help
= "Wait for an SRST deassert. "
1372 "Useful for cases where you need something to happen within ms "
1373 "of an srst deassert. Timeout in ms ",
1378 .mode
= COMMAND_ANY
,
1379 .help
= "perform jtag tap actions",
1382 .chain
= jtag_subcommand_handlers
,
1385 .chain
= jtag_command_handlers_to_move
,
1387 COMMAND_REGISTRATION_DONE
1390 int jtag_register_commands(struct command_context
*cmd_ctx
)
1392 return register_commands(cmd_ctx
, NULL
, jtag_command_handlers
);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)