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 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
29 ***************************************************************************/
36 #include "minidriver.h"
37 #include "interface.h"
38 #include "interfaces.h"
45 #include <helper/time_support.h>
49 * Holds support for accessing JTAG-specific mechanisms from TCl scripts.
52 static const Jim_Nvp nvp_jtag_tap_event
[] = {
53 { .value
= JTAG_TRST_ASSERTED
, .name
= "post-reset" },
54 { .value
= JTAG_TAP_EVENT_SETUP
, .name
= "setup" },
55 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
56 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
58 { .name
= NULL
, .value
= -1 }
61 extern struct jtag_interface
*jtag_interface
;
63 struct jtag_tap
*jtag_tap_by_jim_obj(Jim_Interp
*interp
, Jim_Obj
*o
)
65 const char *cp
= Jim_GetString(o
, NULL
);
66 struct jtag_tap
*t
= cp
? jtag_tap_by_string(cp
) : NULL
;
70 Jim_SetResultFormatted(interp
, "Tap '%s' could not be found", cp
);
74 static bool scan_is_safe(tap_state_t state
)
87 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
90 struct scan_field
*fields
;
99 * args[3] = hex string
100 * ... repeat num bits and hex string ...
103 * args[N-2] = "-endstate"
104 * args[N-1] = statename
106 if ((argc
< 4) || ((argc
% 2) != 0)) {
107 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
113 script_debug(interp
, "drscan", argc
, args
);
115 /* validate arguments as numbers */
117 for (i
= 2; i
< argc
; i
+= 2) {
121 e
= Jim_GetLong(interp
, args
[i
], &bits
);
122 /* If valid - try next arg */
126 /* Not valid.. are we at the end? */
127 if (((i
+ 2) != argc
)) {
128 /* nope, then error */
132 /* it could be: "-endstate FOO"
133 * e.g. DRPAUSE so we can issue more instructions
134 * before entering RUN/IDLE and executing them.
137 /* get arg as a string. */
138 cp
= Jim_GetString(args
[i
], NULL
);
139 /* is it the magic? */
140 if (0 == strcmp("-endstate", cp
)) {
141 /* is the statename valid? */
142 cp
= Jim_GetString(args
[i
+ 1], NULL
);
144 /* see if it is a valid state name */
145 endstate
= tap_state_by_name(cp
);
147 /* update the error message */
148 Jim_SetResultFormatted(interp
, "endstate: %s invalid", cp
);
150 if (!scan_is_safe(endstate
))
151 LOG_WARNING("drscan with unsafe "
152 "endstate \"%s\"", cp
);
154 /* valid - so clear the error */
156 /* and remove the last 2 args */
161 /* Still an error? */
163 return e
; /* too bad */
164 } /* validate args */
168 tap
= jtag_tap_by_jim_obj(interp
, args
[1]);
172 num_fields
= (argc
-2)/2;
173 assert(num_fields
> 0);
174 fields
= malloc(sizeof(struct scan_field
) * num_fields
);
175 for (i
= 2; i
< argc
; i
+= 2) {
180 Jim_GetLong(interp
, args
[i
], &bits
);
181 str
= Jim_GetString(args
[i
+ 1], &len
);
183 fields
[field_count
].num_bits
= bits
;
184 void *t
= malloc(DIV_ROUND_UP(bits
, 8));
185 fields
[field_count
].out_value
= t
;
186 str_to_buf(str
, len
, t
, bits
, 0);
187 fields
[field_count
].in_value
= t
;
191 jtag_add_dr_scan(tap
, num_fields
, fields
, endstate
);
193 retval
= jtag_execute_queue();
194 if (retval
!= ERROR_OK
) {
195 Jim_SetResultString(interp
, "drscan: jtag execute failed", -1);
200 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
201 for (i
= 2; i
< argc
; i
+= 2) {
205 Jim_GetLong(interp
, args
[i
], &bits
);
206 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
207 free((void *)fields
[field_count
].out_value
);
209 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
214 Jim_SetResult(interp
, list
);
222 static int Jim_Command_pathmove(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
224 tap_state_t states
[8];
226 if ((argc
< 2) || ((size_t)argc
> (ARRAY_SIZE(states
) + 1))) {
227 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
231 script_debug(interp
, "pathmove", argc
, args
);
234 for (i
= 0; i
< argc
-1; i
++) {
236 cp
= Jim_GetString(args
[i
+ 1], NULL
);
237 states
[i
] = tap_state_by_name(cp
);
239 /* update the error message */
240 Jim_SetResultFormatted(interp
, "endstate: %s invalid", cp
);
245 if ((jtag_add_statemove(states
[0]) != ERROR_OK
) || (jtag_execute_queue() != ERROR_OK
)) {
246 Jim_SetResultString(interp
, "pathmove: jtag execute failed", -1);
250 jtag_add_pathmove(argc
- 2, states
+ 1);
252 if (jtag_execute_queue() != ERROR_OK
) {
253 Jim_SetResultString(interp
, "pathmove: failed", -1);
261 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
263 script_debug(interp
, "flush_count", argc
, args
);
265 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_get_flush_queue_count()));
270 /* REVISIT Just what about these should "move" ... ?
271 * These registrations, into the main JTAG table?
273 * There's a minor compatibility issue, these all show up twice;
274 * that's not desirable:
275 * - jtag drscan ... NOT DOCUMENTED!
278 * The "irscan" command (for example) doesn't show twice.
280 static const struct command_registration jtag_command_handlers_to_move
[] = {
283 .mode
= COMMAND_EXEC
,
284 .jim_handler
= Jim_Command_drscan
,
285 .help
= "Execute Data Register (DR) scan for one TAP. "
286 "Other TAPs must be in BYPASS mode.",
287 .usage
= "tap_name [num_bits value]* ['-endstate' state_name]",
290 .name
= "flush_count",
291 .mode
= COMMAND_EXEC
,
292 .jim_handler
= Jim_Command_flush_count
,
293 .help
= "Returns the number of times the JTAG queue "
298 .mode
= COMMAND_EXEC
,
299 .jim_handler
= Jim_Command_pathmove
,
300 .usage
= "start_state state1 [state2 [state3 ...]]",
301 .help
= "Move JTAG state machine from current state "
302 "(start_state) to state1, then state2, state3, etc.",
304 COMMAND_REGISTRATION_DONE
308 enum jtag_tap_cfg_param
{
312 static Jim_Nvp nvp_config_opts
[] = {
313 { .name
= "-event", .value
= JCFG_EVENT
},
315 { .name
= NULL
, .value
= -1 }
318 static int jtag_tap_configure_event(Jim_GetOptInfo
*goi
, struct jtag_tap
*tap
)
320 if (goi
->argc
== 0) {
321 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event <event-name> ...");
326 int e
= Jim_GetOpt_Nvp(goi
, nvp_jtag_tap_event
, &n
);
328 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
332 if (goi
->isconfigure
) {
333 if (goi
->argc
!= 1) {
334 Jim_WrongNumArgs(goi
->interp
,
337 "-event <event-name> <event-body>");
341 if (goi
->argc
!= 0) {
342 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event <event-name>");
347 struct jtag_tap_event_action
*jteap
= tap
->event_action
;
348 /* replace existing event body */
351 if (jteap
->event
== (enum jtag_event
)n
->value
) {
358 Jim_SetEmptyResult(goi
->interp
);
360 if (goi
->isconfigure
) {
362 jteap
= calloc(1, sizeof(*jteap
));
363 else if (NULL
!= jteap
->body
)
364 Jim_DecrRefCount(goi
->interp
, jteap
->body
);
366 jteap
->interp
= goi
->interp
;
367 jteap
->event
= n
->value
;
370 Jim_GetOpt_Obj(goi
, &o
);
371 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
372 Jim_IncrRefCount(jteap
->body
);
375 /* add to head of event list */
376 jteap
->next
= tap
->event_action
;
377 tap
->event_action
= jteap
;
380 jteap
->interp
= goi
->interp
;
381 Jim_SetResult(goi
->interp
,
382 Jim_DuplicateObj(goi
->interp
, jteap
->body
));
387 static int jtag_tap_configure_cmd(Jim_GetOptInfo
*goi
, struct jtag_tap
*tap
)
389 /* parse config or cget options */
390 while (goi
->argc
> 0) {
391 Jim_SetEmptyResult(goi
->interp
);
394 int e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
396 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
402 e
= jtag_tap_configure_event(goi
, tap
);
407 Jim_SetResultFormatted(goi
->interp
, "unknown event: %s", n
->name
);
415 static int is_bad_irval(int ir_length
, jim_wide w
)
425 static int jim_newtap_expected_id(Jim_Nvp
*n
, Jim_GetOptInfo
*goi
,
426 struct jtag_tap
*pTap
)
429 int e
= Jim_GetOpt_Wide(goi
, &w
);
431 Jim_SetResultFormatted(goi
->interp
, "option: %s bad parameter", n
->name
);
435 unsigned expected_len
= sizeof(uint32_t) * pTap
->expected_ids_cnt
;
436 uint32_t *new_expected_ids
= malloc(expected_len
+ sizeof(uint32_t));
437 if (new_expected_ids
== NULL
) {
438 Jim_SetResultFormatted(goi
->interp
, "no memory");
442 memcpy(new_expected_ids
, pTap
->expected_ids
, expected_len
);
444 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
446 free(pTap
->expected_ids
);
447 pTap
->expected_ids
= new_expected_ids
;
448 pTap
->expected_ids_cnt
++;
453 #define NTAP_OPT_IRLEN 0
454 #define NTAP_OPT_IRMASK 1
455 #define NTAP_OPT_IRCAPTURE 2
456 #define NTAP_OPT_ENABLED 3
457 #define NTAP_OPT_DISABLED 4
458 #define NTAP_OPT_EXPECTED_ID 5
459 #define NTAP_OPT_VERSION 6
461 static int jim_newtap_ir_param(Jim_Nvp
*n
, Jim_GetOptInfo
*goi
,
462 struct jtag_tap
*pTap
)
465 int e
= Jim_GetOpt_Wide(goi
, &w
);
467 Jim_SetResultFormatted(goi
->interp
,
468 "option: %s bad parameter", n
->name
);
469 free((void *)pTap
->dotted_name
);
474 if (w
> (jim_wide
) (8 * sizeof(pTap
->ir_capture_value
))) {
475 LOG_WARNING("%s: huge IR length %d",
476 pTap
->dotted_name
, (int) w
);
480 case NTAP_OPT_IRMASK
:
481 if (is_bad_irval(pTap
->ir_length
, w
)) {
482 LOG_ERROR("%s: IR mask %x too big",
488 LOG_WARNING("%s: nonstandard IR mask", pTap
->dotted_name
);
489 pTap
->ir_capture_mask
= w
;
491 case NTAP_OPT_IRCAPTURE
:
492 if (is_bad_irval(pTap
->ir_length
, w
)) {
493 LOG_ERROR("%s: IR capture %x too big",
494 pTap
->dotted_name
, (int) w
);
498 LOG_WARNING("%s: nonstandard IR value",
500 pTap
->ir_capture_value
= w
;
508 static int jim_newtap_cmd(Jim_GetOptInfo
*goi
)
510 struct jtag_tap
*pTap
;
515 const Jim_Nvp opts
[] = {
516 { .name
= "-irlen", .value
= NTAP_OPT_IRLEN
},
517 { .name
= "-irmask", .value
= NTAP_OPT_IRMASK
},
518 { .name
= "-ircapture", .value
= NTAP_OPT_IRCAPTURE
},
519 { .name
= "-enable", .value
= NTAP_OPT_ENABLED
},
520 { .name
= "-disable", .value
= NTAP_OPT_DISABLED
},
521 { .name
= "-expected-id", .value
= NTAP_OPT_EXPECTED_ID
},
522 { .name
= "-ignore-version", .value
= NTAP_OPT_VERSION
},
523 { .name
= NULL
, .value
= -1 },
526 pTap
= calloc(1, sizeof(struct jtag_tap
));
528 Jim_SetResultFormatted(goi
->interp
, "no memory");
533 * we expect CHIP + TAP + OPTIONS
536 Jim_SetResultFormatted(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
540 Jim_GetOpt_String(goi
, &cp
, NULL
);
541 pTap
->chip
= strdup(cp
);
543 Jim_GetOpt_String(goi
, &cp
, NULL
);
544 pTap
->tapname
= strdup(cp
);
546 /* name + dot + name + null */
547 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
549 sprintf(cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
550 pTap
->dotted_name
= cp
;
552 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
553 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
555 /* IEEE specifies that the two LSBs of an IR scan are 01, so make
556 * that the default. The "-irlen" and "-irmask" options are only
557 * needed to cope with nonstandard TAPs, or to specify more bits.
559 pTap
->ir_capture_mask
= 0x03;
560 pTap
->ir_capture_value
= 0x01;
563 e
= Jim_GetOpt_Nvp(goi
, opts
, &n
);
565 Jim_GetOpt_NvpUnknown(goi
, opts
, 0);
566 free((void *)pTap
->dotted_name
);
570 LOG_DEBUG("Processing option: %s", n
->name
);
572 case NTAP_OPT_ENABLED
:
573 pTap
->disabled_after_reset
= false;
575 case NTAP_OPT_DISABLED
:
576 pTap
->disabled_after_reset
= true;
578 case NTAP_OPT_EXPECTED_ID
:
579 e
= jim_newtap_expected_id(n
, goi
, pTap
);
581 free((void *)pTap
->dotted_name
);
587 case NTAP_OPT_IRMASK
:
588 case NTAP_OPT_IRCAPTURE
:
589 e
= jim_newtap_ir_param(n
, goi
, pTap
);
591 free((void *)pTap
->dotted_name
);
596 case NTAP_OPT_VERSION
:
597 pTap
->ignore_version
= true;
599 } /* switch (n->value) */
600 } /* while (goi->argc) */
602 /* default is enabled-after-reset */
603 pTap
->enabled
= !pTap
->disabled_after_reset
;
605 /* Did all the required option bits get cleared? */
606 if (pTap
->ir_length
!= 0) {
611 Jim_SetResultFormatted(goi
->interp
,
612 "newtap: %s missing IR length",
618 static void jtag_tap_handle_event(struct jtag_tap
*tap
, enum jtag_event e
)
620 struct jtag_tap_event_action
*jteap
;
622 for (jteap
= tap
->event_action
; jteap
!= NULL
; jteap
= jteap
->next
) {
623 if (jteap
->event
!= e
)
626 Jim_Nvp
*nvp
= Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
);
627 LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
628 tap
->dotted_name
, e
, nvp
->name
,
629 Jim_GetString(jteap
->body
, NULL
));
631 if (Jim_EvalObj(jteap
->interp
, jteap
->body
) != JIM_OK
) {
632 Jim_MakeErrorMessage(jteap
->interp
);
633 LOG_USER("%s", Jim_GetString(Jim_GetResult(jteap
->interp
), NULL
));
638 case JTAG_TAP_EVENT_ENABLE
:
639 case JTAG_TAP_EVENT_DISABLE
:
640 /* NOTE: we currently assume the handlers
641 * can't fail. Right here is where we should
642 * really be verifying the scan chains ...
644 tap
->enabled
= (e
== JTAG_TAP_EVENT_ENABLE
);
645 LOG_INFO("JTAG tap: %s %s", tap
->dotted_name
,
646 tap
->enabled
? "enabled" : "disabled");
654 static int jim_jtag_arp_init(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
657 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
659 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
662 struct command_context
*context
= current_command_context(interp
);
663 int e
= jtag_init_inner(context
);
665 Jim_Obj
*eObj
= Jim_NewIntObj(goi
.interp
, e
);
666 Jim_SetResultFormatted(goi
.interp
, "error: %#s", eObj
);
667 Jim_FreeNewObj(goi
.interp
, eObj
);
673 static int jim_jtag_arp_init_reset(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
676 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
678 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
681 struct command_context
*context
= current_command_context(interp
);
682 int e
= jtag_init_reset(context
);
684 Jim_Obj
*eObj
= Jim_NewIntObj(goi
.interp
, e
);
685 Jim_SetResultFormatted(goi
.interp
, "error: %#s", eObj
);
686 Jim_FreeNewObj(goi
.interp
, eObj
);
692 int jim_jtag_newtap(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
695 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
696 return jim_newtap_cmd(&goi
);
699 static bool jtag_tap_enable(struct jtag_tap
*t
)
703 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_ENABLE
);
707 /* FIXME add JTAG sanity checks, w/o TLR
708 * - scan chain length grew by one (this)
709 * - IDs and IR lengths are as expected
711 jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE
);
714 static bool jtag_tap_disable(struct jtag_tap
*t
)
718 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_DISABLE
);
722 /* FIXME add JTAG sanity checks, w/o TLR
723 * - scan chain length shrank by one (this)
724 * - IDs and IR lengths are as expected
726 jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE
);
730 int jim_jtag_tap_enabler(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
732 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
734 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
736 Jim_SetResultFormatted(goi
.interp
, "usage: %s <name>", cmd_name
);
742 t
= jtag_tap_by_jim_obj(goi
.interp
, goi
.argv
[0]);
746 if (strcasecmp(cmd_name
, "tapisenabled") == 0) {
747 /* do nothing, just return the value */
748 } else if (strcasecmp(cmd_name
, "tapenable") == 0) {
749 if (!jtag_tap_enable(t
)) {
750 LOG_WARNING("failed to enable tap %s", t
->dotted_name
);
753 } else if (strcasecmp(cmd_name
, "tapdisable") == 0) {
754 if (!jtag_tap_disable(t
)) {
755 LOG_WARNING("failed to disable tap %s", t
->dotted_name
);
759 LOG_ERROR("command '%s' unknown", cmd_name
);
763 Jim_SetResult(goi
.interp
, Jim_NewIntObj(goi
.interp
, e
));
767 int jim_jtag_configure(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
769 const char *cmd_name
= Jim_GetString(argv
[0], NULL
);
771 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
772 goi
.isconfigure
= !strcmp(cmd_name
, "configure");
773 if (goi
.argc
< 2 + goi
.isconfigure
) {
774 Jim_WrongNumArgs(goi
.interp
, 0, NULL
,
775 "<tap_name> <attribute> ...");
782 Jim_GetOpt_Obj(&goi
, &o
);
783 t
= jtag_tap_by_jim_obj(goi
.interp
, o
);
787 return jtag_tap_configure_cmd(&goi
, t
);
790 static int jim_jtag_names(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
793 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
795 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
, "Too many parameters");
798 Jim_SetResult(goi
.interp
, Jim_NewListObj(goi
.interp
, NULL
, 0));
799 struct jtag_tap
*tap
;
801 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
) {
802 Jim_ListAppendElement(goi
.interp
,
803 Jim_GetResult(goi
.interp
),
804 Jim_NewStringObj(goi
.interp
,
805 tap
->dotted_name
, -1));
810 COMMAND_HANDLER(handle_jtag_init_command
)
813 return ERROR_COMMAND_SYNTAX_ERROR
;
815 static bool jtag_initialized
;
816 if (jtag_initialized
) {
817 LOG_INFO("'jtag init' has already been called");
820 jtag_initialized
= true;
822 LOG_DEBUG("Initializing jtag devices...");
823 return jtag_init(CMD_CTX
);
826 static const struct command_registration jtag_subcommand_handlers
[] = {
830 .handler
= handle_jtag_init_command
,
831 .help
= "initialize jtag scan chain",
837 .jim_handler
= jim_jtag_arp_init
,
838 .help
= "Validates JTAG scan chain against the list of "
839 "declared TAPs using just the four standard JTAG "
843 .name
= "arp_init-reset",
845 .jim_handler
= jim_jtag_arp_init_reset
,
846 .help
= "Uses TRST and SRST to try resetting everything on "
847 "the JTAG scan chain, then performs 'jtag arp_init'."
851 .mode
= COMMAND_CONFIG
,
852 .jim_handler
= jim_jtag_newtap
,
853 .help
= "Create a new TAP instance named basename.tap_type, "
854 "and appends it to the scan chain.",
855 .usage
= "basename tap_type '-irlen' count "
856 "['-enable'|'-disable'] "
857 "['-expected_id' number] "
858 "['-ignore-version'] "
859 "['-ircapture' number] "
863 .name
= "tapisenabled",
864 .mode
= COMMAND_EXEC
,
865 .jim_handler
= jim_jtag_tap_enabler
,
866 .help
= "Returns a Tcl boolean (0/1) indicating whether "
867 "the TAP is enabled (1) or not (0).",
872 .mode
= COMMAND_EXEC
,
873 .jim_handler
= jim_jtag_tap_enabler
,
874 .help
= "Try to enable the specified TAP using the "
875 "'tap-enable' TAP event.",
879 .name
= "tapdisable",
880 .mode
= COMMAND_EXEC
,
881 .jim_handler
= jim_jtag_tap_enabler
,
882 .help
= "Try to disable the specified TAP using the "
883 "'tap-disable' TAP event.",
888 .mode
= COMMAND_EXEC
,
889 .jim_handler
= jim_jtag_configure
,
890 .help
= "Provide a Tcl handler for the specified "
892 .usage
= "tap_name '-event' event_name handler",
896 .mode
= COMMAND_EXEC
,
897 .jim_handler
= jim_jtag_configure
,
898 .help
= "Return any Tcl handler for the specified "
900 .usage
= "tap_name '-event' event_name",
905 .jim_handler
= jim_jtag_names
,
906 .help
= "Returns list of all JTAG tap names.",
909 .chain
= jtag_command_handlers_to_move
,
911 COMMAND_REGISTRATION_DONE
914 void jtag_notify_event(enum jtag_event event
)
916 struct jtag_tap
*tap
;
918 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
)
919 jtag_tap_handle_event(tap
, event
);
923 COMMAND_HANDLER(handle_scan_chain_command
)
925 struct jtag_tap
*tap
;
926 char expected_id
[12];
928 tap
= jtag_all_taps();
929 command_print(CMD_CTX
,
930 " TapName Enabled IdCode Expected IrLen IrCap IrMask");
931 command_print(CMD_CTX
,
932 "-- ------------------- -------- ---------- ---------- ----- ----- ------");
935 uint32_t expected
, expected_mask
, ii
;
937 snprintf(expected_id
, sizeof expected_id
, "0x%08x",
938 (unsigned)((tap
->expected_ids_cnt
> 0)
939 ? tap
->expected_ids
[0]
941 if (tap
->ignore_version
)
942 expected_id
[2] = '*';
944 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
945 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
947 command_print(CMD_CTX
,
948 "%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
949 tap
->abs_chain_position
,
951 tap
->enabled
? 'Y' : 'n',
952 (unsigned int)(tap
->idcode
),
954 (unsigned int)(tap
->ir_length
),
955 (unsigned int)(expected
),
956 (unsigned int)(expected_mask
));
958 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
959 snprintf(expected_id
, sizeof expected_id
, "0x%08x",
960 (unsigned) tap
->expected_ids
[1]);
961 if (tap
->ignore_version
)
962 expected_id
[2] = '*';
964 command_print(CMD_CTX
,
975 COMMAND_HANDLER(handle_jtag_ntrst_delay_command
)
978 return ERROR_COMMAND_SYNTAX_ERROR
;
981 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], delay
);
983 jtag_set_ntrst_delay(delay
);
985 command_print(CMD_CTX
, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
989 COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command
)
992 return ERROR_COMMAND_SYNTAX_ERROR
;
995 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], delay
);
997 jtag_set_ntrst_assert_width(delay
);
999 command_print(CMD_CTX
, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
1003 COMMAND_HANDLER(handle_jtag_rclk_command
)
1006 return ERROR_COMMAND_SYNTAX_ERROR
;
1008 int retval
= ERROR_OK
;
1009 if (CMD_ARGC
== 1) {
1011 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], khz
);
1013 retval
= jtag_config_rclk(khz
);
1014 if (ERROR_OK
!= retval
)
1018 int cur_khz
= jtag_get_speed_khz();
1019 retval
= jtag_get_speed_readable(&cur_khz
);
1020 if (ERROR_OK
!= retval
)
1024 command_print(CMD_CTX
, "RCLK not supported - fallback to %d kHz", cur_khz
);
1026 command_print(CMD_CTX
, "RCLK - adaptive");
1031 COMMAND_HANDLER(handle_jtag_reset_command
)
1034 return ERROR_COMMAND_SYNTAX_ERROR
;
1037 if (CMD_ARGV
[0][0] == '1')
1039 else if (CMD_ARGV
[0][0] == '0')
1042 return ERROR_COMMAND_SYNTAX_ERROR
;
1045 if (CMD_ARGV
[1][0] == '1')
1047 else if (CMD_ARGV
[1][0] == '0')
1050 return ERROR_COMMAND_SYNTAX_ERROR
;
1052 if (adapter_init(CMD_CTX
) != ERROR_OK
)
1053 return ERROR_JTAG_INIT_FAILED
;
1055 jtag_add_reset(trst
, srst
);
1056 return jtag_execute_queue();
1059 COMMAND_HANDLER(handle_runtest_command
)
1062 return ERROR_COMMAND_SYNTAX_ERROR
;
1064 unsigned num_clocks
;
1065 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], num_clocks
);
1067 jtag_add_runtest(num_clocks
, TAP_IDLE
);
1068 return jtag_execute_queue();
1072 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1073 * should be stable ... and *NOT* a shift state, otherwise free-running
1074 * jtag clocks could change the values latched by the update state.
1075 * Not surprisingly, this is the same constraint as SVF; the "irscan"
1076 * and "drscan" commands are a write-only subset of what SVF provides.
1079 COMMAND_HANDLER(handle_irscan_command
)
1082 struct scan_field
*fields
;
1083 struct jtag_tap
*tap
= NULL
;
1084 tap_state_t endstate
;
1086 if ((CMD_ARGC
< 2) || (CMD_ARGC
% 2))
1087 return ERROR_COMMAND_SYNTAX_ERROR
;
1089 /* optional "-endstate" "statename" at the end of the arguments,
1090 * so that e.g. IRPAUSE can let us load the data register before
1091 * entering RUN/IDLE to execute the instruction we load here.
1093 endstate
= TAP_IDLE
;
1095 if (CMD_ARGC
>= 4) {
1096 /* have at least one pair of numbers.
1097 * is last pair the magic text? */
1098 if (strcmp("-endstate", CMD_ARGV
[CMD_ARGC
- 2]) == 0) {
1099 endstate
= tap_state_by_name(CMD_ARGV
[CMD_ARGC
- 1]);
1100 if (endstate
== TAP_INVALID
)
1101 return ERROR_COMMAND_SYNTAX_ERROR
;
1102 if (!scan_is_safe(endstate
))
1103 LOG_WARNING("unstable irscan endstate \"%s\"",
1104 CMD_ARGV
[CMD_ARGC
- 1]);
1109 int num_fields
= CMD_ARGC
/ 2;
1110 if (num_fields
> 1) {
1111 /* we really should be looking at plain_ir_scan if we want
1112 * anything more fancy.
1114 LOG_ERROR("Specify a single value for tap");
1115 return ERROR_COMMAND_SYNTAX_ERROR
;
1118 size_t fields_len
= sizeof(struct scan_field
) * num_fields
;
1119 fields
= malloc(fields_len
);
1120 memset(fields
, 0, fields_len
);
1123 for (i
= 0; i
< num_fields
; i
++) {
1124 tap
= jtag_tap_by_string(CMD_ARGV
[i
*2]);
1127 for (j
= 0; j
< i
; j
++)
1128 free((void *)fields
[j
].out_value
);
1130 command_print(CMD_CTX
, "Tap: %s unknown", CMD_ARGV
[i
*2]);
1134 int field_size
= tap
->ir_length
;
1135 fields
[i
].num_bits
= field_size
;
1136 fields
[i
].out_value
= malloc(DIV_ROUND_UP(field_size
, 8));
1139 retval
= parse_u32(CMD_ARGV
[i
* 2 + 1], &value
);
1140 if (ERROR_OK
!= retval
)
1142 void *v
= (void *)fields
[i
].out_value
;
1143 buf_set_u32(v
, 0, field_size
, value
);
1144 fields
[i
].in_value
= NULL
;
1147 /* did we have an endstate? */
1148 jtag_add_ir_scan(tap
, fields
, endstate
);
1150 retval
= jtag_execute_queue();
1153 for (i
= 0; i
< num_fields
; i
++) {
1154 if (NULL
!= fields
[i
].out_value
)
1155 free((void *)fields
[i
].out_value
);
1163 COMMAND_HANDLER(handle_verify_ircapture_command
)
1166 return ERROR_COMMAND_SYNTAX_ERROR
;
1168 if (CMD_ARGC
== 1) {
1170 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
1171 jtag_set_verify_capture_ir(enable
);
1174 const char *status
= jtag_will_verify_capture_ir() ? "enabled" : "disabled";
1175 command_print(CMD_CTX
, "verify Capture-IR is %s", status
);
1180 COMMAND_HANDLER(handle_verify_jtag_command
)
1183 return ERROR_COMMAND_SYNTAX_ERROR
;
1185 if (CMD_ARGC
== 1) {
1187 COMMAND_PARSE_ENABLE(CMD_ARGV
[0], enable
);
1188 jtag_set_verify(enable
);
1191 const char *status
= jtag_will_verify() ? "enabled" : "disabled";
1192 command_print(CMD_CTX
, "verify jtag capture is %s", status
);
1197 COMMAND_HANDLER(handle_tms_sequence_command
)
1200 return ERROR_COMMAND_SYNTAX_ERROR
;
1202 if (CMD_ARGC
== 1) {
1204 if (strcmp(CMD_ARGV
[0], "short") == 0)
1205 use_new_table
= true;
1206 else if (strcmp(CMD_ARGV
[0], "long") == 0)
1207 use_new_table
= false;
1209 return ERROR_COMMAND_SYNTAX_ERROR
;
1211 tap_use_new_tms_table(use_new_table
);
1214 command_print(CMD_CTX
, "tms sequence is %s",
1215 tap_uses_new_tms_table() ? "short" : "long");
1220 COMMAND_HANDLER(handle_jtag_flush_queue_sleep
)
1223 return ERROR_COMMAND_SYNTAX_ERROR
;
1226 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], sleep_ms
);
1228 jtag_set_flush_queue_sleep(sleep_ms
);
1233 COMMAND_HANDLER(handle_wait_srst_deassert
)
1236 return ERROR_COMMAND_SYNTAX_ERROR
;
1239 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], timeout_ms
);
1240 if ((timeout_ms
<= 0) || (timeout_ms
> 100000)) {
1241 LOG_ERROR("Timeout must be an integer between 0 and 100000");
1245 LOG_USER("Waiting for srst assert + deassert for at most %dms", timeout_ms
);
1247 long long then
= timeval_ms();
1248 while (jtag_srst_asserted(&asserted_yet
) == ERROR_OK
) {
1249 if ((timeval_ms() - then
) > timeout_ms
) {
1250 LOG_ERROR("Timed out");
1256 while (jtag_srst_asserted(&asserted_yet
) == ERROR_OK
) {
1257 if ((timeval_ms() - then
) > timeout_ms
) {
1258 LOG_ERROR("Timed out");
1268 static const struct command_registration jtag_command_handlers
[] = {
1271 .name
= "jtag_flush_queue_sleep",
1272 .handler
= handle_jtag_flush_queue_sleep
,
1273 .mode
= COMMAND_ANY
,
1274 .help
= "For debug purposes(simulate long delays of interface) "
1275 "to test performance or change in behavior. Default 0ms.",
1276 .usage
= "[sleep in ms]",
1279 .name
= "jtag_rclk",
1280 .handler
= handle_jtag_rclk_command
,
1281 .mode
= COMMAND_ANY
,
1282 .help
= "With an argument, change to to use adaptive clocking "
1283 "if possible; else to use the fallback speed. "
1284 "With or without argument, display current setting.",
1285 .usage
= "[fallback_speed_khz]",
1288 .name
= "jtag_ntrst_delay",
1289 .handler
= handle_jtag_ntrst_delay_command
,
1290 .mode
= COMMAND_ANY
,
1291 .help
= "delay after deasserting trst in ms",
1292 .usage
= "[milliseconds]",
1295 .name
= "jtag_ntrst_assert_width",
1296 .handler
= handle_jtag_ntrst_assert_width_command
,
1297 .mode
= COMMAND_ANY
,
1298 .help
= "delay after asserting trst in ms",
1299 .usage
= "[milliseconds]",
1302 .name
= "scan_chain",
1303 .handler
= handle_scan_chain_command
,
1304 .mode
= COMMAND_ANY
,
1305 .help
= "print current scan chain configuration",
1309 .name
= "jtag_reset",
1310 .handler
= handle_jtag_reset_command
,
1311 .mode
= COMMAND_EXEC
,
1312 .help
= "Set reset line values. Value '1' is active, "
1313 "value '0' is inactive.",
1314 .usage
= "trst_active srst_active",
1318 .handler
= handle_runtest_command
,
1319 .mode
= COMMAND_EXEC
,
1320 .help
= "Move to Run-Test/Idle, and issue TCK for num_cycles.",
1321 .usage
= "num_cycles"
1325 .handler
= handle_irscan_command
,
1326 .mode
= COMMAND_EXEC
,
1327 .help
= "Execute Instruction Register (DR) scan. The "
1328 "specified opcodes are put into each TAP's IR, "
1329 "and other TAPs are put in BYPASS.",
1330 .usage
= "[tap_name instruction]* ['-endstate' state_name]",
1333 .name
= "verify_ircapture",
1334 .handler
= handle_verify_ircapture_command
,
1335 .mode
= COMMAND_ANY
,
1336 .help
= "Display or assign flag controlling whether to "
1337 "verify values captured during Capture-IR.",
1338 .usage
= "['enable'|'disable']",
1341 .name
= "verify_jtag",
1342 .handler
= handle_verify_jtag_command
,
1343 .mode
= COMMAND_ANY
,
1344 .help
= "Display or assign flag controlling whether to "
1345 "verify values captured during IR and DR scans.",
1346 .usage
= "['enable'|'disable']",
1349 .name
= "tms_sequence",
1350 .handler
= handle_tms_sequence_command
,
1351 .mode
= COMMAND_ANY
,
1352 .help
= "Display or change what style TMS sequences to use "
1353 "for JTAG state transitions: short (default) or "
1354 "long. Only for working around JTAG bugs.",
1355 /* Specifically for working around DRIVER bugs... */
1356 .usage
= "['short'|'long']",
1359 .name
= "wait_srst_deassert",
1360 .handler
= handle_wait_srst_deassert
,
1361 .mode
= COMMAND_ANY
,
1362 .help
= "Wait for an SRST deassert. "
1363 "Useful for cases where you need something to happen within ms "
1364 "of an srst deassert. Timeout in ms ",
1369 .mode
= COMMAND_ANY
,
1370 .help
= "perform jtag tap actions",
1373 .chain
= jtag_subcommand_handlers
,
1376 .chain
= jtag_command_handlers_to_move
,
1378 COMMAND_REGISTRATION_DONE
1381 int jtag_register_commands(struct command_context
*cmd_ctx
)
1383 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)