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 * 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 ***************************************************************************/
35 #include "minidriver.h"
36 #include "interface.h"
37 #include "interfaces.h"
43 static const Jim_Nvp nvp_jtag_tap_event
[] = {
44 { .value
= JTAG_TRST_ASSERTED
, .name
= "post-reset" },
45 { .value
= JTAG_TAP_EVENT_SETUP
, .name
= "setup" },
46 { .value
= JTAG_TAP_EVENT_ENABLE
, .name
= "tap-enable" },
47 { .value
= JTAG_TAP_EVENT_DISABLE
, .name
= "tap-disable" },
49 { .name
= NULL
, .value
= -1 }
52 extern jtag_interface_t
*jtag_interface
;
55 static int handle_interface_list_command(struct command_context_s
*cmd_ctx
,
56 char *cmd
, char **args
, int argc
);
57 static int handle_interface_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 static int handle_jtag_rclk_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
64 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 static int handle_jtag_nsrst_assert_width_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
66 static int handle_jtag_ntrst_assert_width_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
68 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
70 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
71 static int handle_runtest_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
72 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
73 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
74 static int Jim_Command_pathmove(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
);
75 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
);
77 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
78 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
79 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
82 enum jtag_tap_cfg_param
{
86 static Jim_Nvp nvp_config_opts
[] = {
87 { .name
= "-event", .value
= JCFG_EVENT
},
89 { .name
= NULL
, .value
= -1 }
92 static int jtag_tap_configure_cmd(Jim_GetOptInfo
*goi
, jtag_tap_t
* tap
)
98 /* parse config or cget options */
99 while (goi
->argc
> 0) {
100 Jim_SetEmptyResult (goi
->interp
);
102 e
= Jim_GetOpt_Nvp(goi
, nvp_config_opts
, &n
);
104 Jim_GetOpt_NvpUnknown(goi
, nvp_config_opts
, 0);
110 if (goi
->argc
== 0) {
111 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ...");
115 e
= Jim_GetOpt_Nvp(goi
, nvp_jtag_tap_event
, &n
);
117 Jim_GetOpt_NvpUnknown(goi
, nvp_jtag_tap_event
, 1);
121 if (goi
->isconfigure
) {
122 if (goi
->argc
!= 1) {
123 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name? ?EVENT-BODY?");
127 if (goi
->argc
!= 0) {
128 Jim_WrongNumArgs(goi
->interp
, goi
->argc
, goi
->argv
, "-event ?event-name?");
134 jtag_tap_event_action_t
*jteap
;
136 jteap
= tap
->event_action
;
137 /* replace existing? */
139 if (jteap
->event
== (enum jtag_event
)n
->value
) {
145 if (goi
->isconfigure
) {
149 jteap
= calloc(1, sizeof (*jteap
));
152 jteap
->event
= n
->value
;
153 Jim_GetOpt_Obj(goi
, &o
);
155 Jim_DecrRefCount(interp
, jteap
->body
);
157 jteap
->body
= Jim_DuplicateObj(goi
->interp
, o
);
158 Jim_IncrRefCount(jteap
->body
);
162 /* add to head of event list */
163 jteap
->next
= tap
->event_action
;
164 tap
->event_action
= jteap
;
166 Jim_SetEmptyResult(goi
->interp
);
170 Jim_SetEmptyResult(goi
->interp
);
172 Jim_SetResult(goi
->interp
, Jim_DuplicateObj(goi
->interp
, jteap
->body
));
179 } /* while (goi->argc) */
184 static int is_bad_irval(int ir_length
, jim_wide w
)
194 static int jim_newtap_cmd(Jim_GetOptInfo
*goi
)
203 const Jim_Nvp opts
[] = {
204 #define NTAP_OPT_IRLEN 0
205 { .name
= "-irlen" , .value
= NTAP_OPT_IRLEN
},
206 #define NTAP_OPT_IRMASK 1
207 { .name
= "-irmask" , .value
= NTAP_OPT_IRMASK
},
208 #define NTAP_OPT_IRCAPTURE 2
209 { .name
= "-ircapture" , .value
= NTAP_OPT_IRCAPTURE
},
210 #define NTAP_OPT_ENABLED 3
211 { .name
= "-enable" , .value
= NTAP_OPT_ENABLED
},
212 #define NTAP_OPT_DISABLED 4
213 { .name
= "-disable" , .value
= NTAP_OPT_DISABLED
},
214 #define NTAP_OPT_EXPECTED_ID 5
215 { .name
= "-expected-id" , .value
= NTAP_OPT_EXPECTED_ID
},
216 { .name
= NULL
, .value
= -1 },
219 pTap
= calloc(1, sizeof(jtag_tap_t
));
221 Jim_SetResult_sprintf(goi
->interp
, "no memory");
226 * we expect CHIP + TAP + OPTIONS
229 Jim_SetResult_sprintf(goi
->interp
, "Missing CHIP TAP OPTIONS ....");
233 Jim_GetOpt_String(goi
, &cp
, NULL
);
234 pTap
->chip
= strdup(cp
);
236 Jim_GetOpt_String(goi
, &cp
, NULL
);
237 pTap
->tapname
= strdup(cp
);
239 /* name + dot + name + null */
240 x
= strlen(pTap
->chip
) + 1 + strlen(pTap
->tapname
) + 1;
242 sprintf(cp
, "%s.%s", pTap
->chip
, pTap
->tapname
);
243 pTap
->dotted_name
= cp
;
245 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
246 pTap
->chip
, pTap
->tapname
, pTap
->dotted_name
, goi
->argc
);
248 /* IEEE specifies that the two LSBs of an IR scan are 01, so make
249 * that the default. The "-irlen" and "-irmask" options are only
250 * needed to cope with nonstandard TAPs, or to specify more bits.
252 pTap
->ir_capture_mask
= 0x03;
253 pTap
->ir_capture_value
= 0x01;
255 /* clear flags for "required options" them as we find them */
259 e
= Jim_GetOpt_Nvp(goi
, opts
, &n
);
261 Jim_GetOpt_NvpUnknown(goi
, opts
, 0);
262 free((void *)pTap
->dotted_name
);
266 LOG_DEBUG("Processing option: %s", n
->name
);
268 case NTAP_OPT_ENABLED
:
269 pTap
->disabled_after_reset
= false;
271 case NTAP_OPT_DISABLED
:
272 pTap
->disabled_after_reset
= true;
274 case NTAP_OPT_EXPECTED_ID
:
276 uint32_t *new_expected_ids
;
278 e
= Jim_GetOpt_Wide(goi
, &w
);
280 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
281 free((void *)pTap
->dotted_name
);
286 new_expected_ids
= malloc(sizeof(uint32_t) * (pTap
->expected_ids_cnt
+ 1));
287 if (new_expected_ids
== NULL
) {
288 Jim_SetResult_sprintf(goi
->interp
, "no memory");
289 free((void *)pTap
->dotted_name
);
294 memcpy(new_expected_ids
, pTap
->expected_ids
, sizeof(uint32_t) * pTap
->expected_ids_cnt
);
296 new_expected_ids
[pTap
->expected_ids_cnt
] = w
;
298 free(pTap
->expected_ids
);
299 pTap
->expected_ids
= new_expected_ids
;
300 pTap
->expected_ids_cnt
++;
304 case NTAP_OPT_IRMASK
:
305 case NTAP_OPT_IRCAPTURE
:
306 e
= Jim_GetOpt_Wide(goi
, &w
);
308 Jim_SetResult_sprintf(goi
->interp
, "option: %s bad parameter", n
->name
);
309 free((void *)pTap
->dotted_name
);
315 if (w
> (jim_wide
) (8 * sizeof(pTap
->ir_capture_value
)))
316 LOG_WARNING("%s: huge IR length %d",
322 case NTAP_OPT_IRMASK
:
323 if (is_bad_irval(pTap
->ir_length
, w
)) {
324 LOG_ERROR("%s: IR mask %x too big",
327 free((void *)pTap
->dotted_name
);
332 LOG_WARNING("%s: nonstandard IR mask",
334 pTap
->ir_capture_mask
= w
;
336 case NTAP_OPT_IRCAPTURE
:
337 if (is_bad_irval(pTap
->ir_length
, w
)) {
338 LOG_ERROR("%s: IR capture %x too big",
341 free((void *)pTap
->dotted_name
);
346 LOG_WARNING("%s: nonstandard IR value",
348 pTap
->ir_capture_value
= w
;
351 } /* switch (n->value) */
352 } /* while (goi->argc) */
354 /* default is enabled-after-reset */
355 pTap
->enabled
= !pTap
->disabled_after_reset
;
357 /* Did all the required option bits get cleared? */
364 Jim_SetResult_sprintf(goi
->interp
,
365 "newtap: %s missing required parameters",
371 static void jtag_tap_handle_event(jtag_tap_t
*tap
, enum jtag_event e
)
373 jtag_tap_event_action_t
* jteap
;
375 for (jteap
= tap
->event_action
; jteap
!= NULL
; jteap
= jteap
->next
) {
376 if (jteap
->event
== e
) {
377 LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
380 Jim_Nvp_value2name_simple(nvp_jtag_tap_event
, e
)->name
,
381 Jim_GetString(jteap
->body
, NULL
));
382 if (Jim_EvalObj(interp
, jteap
->body
) != JIM_OK
) {
383 Jim_PrintErrorMessage(interp
);
385 case JTAG_TAP_EVENT_ENABLE
:
386 case JTAG_TAP_EVENT_DISABLE
:
387 /* NOTE: we currently assume the handlers
388 * can't fail. Right here is where we should
389 * really be verifying the scan chains ...
391 tap
->enabled
= (e
== JTAG_TAP_EVENT_ENABLE
);
392 LOG_INFO("JTAG tap: %s %s", tap
->dotted_name
,
393 tap
->enabled
? "enabled" : "disabled");
403 static int jim_jtag_command(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
409 struct command_context_s
*context
;
418 JTAG_CMD_TAPISENABLED
,
424 const Jim_Nvp jtag_cmds
[] = {
425 { .name
= "interface" , .value
= JTAG_CMD_INTERFACE
},
426 { .name
= "arp_init" , .value
= JTAG_CMD_INIT
},
427 { .name
= "arp_init-reset", .value
= JTAG_CMD_INIT_RESET
},
428 { .name
= "newtap" , .value
= JTAG_CMD_NEWTAP
},
429 { .name
= "tapisenabled" , .value
= JTAG_CMD_TAPISENABLED
},
430 { .name
= "tapenable" , .value
= JTAG_CMD_TAPENABLE
},
431 { .name
= "tapdisable" , .value
= JTAG_CMD_TAPDISABLE
},
432 { .name
= "configure" , .value
= JTAG_CMD_CONFIGURE
},
433 { .name
= "cget" , .value
= JTAG_CMD_CGET
},
434 { .name
= "names" , .value
= JTAG_CMD_NAMES
},
436 { .name
= NULL
, .value
= -1 },
439 context
= Jim_GetAssocData(interp
, "context");
440 /* go past the command */
441 Jim_GetOpt_Setup(&goi
, interp
, argc
-1, argv
+ 1);
443 e
= Jim_GetOpt_Nvp(&goi
, jtag_cmds
, &n
);
445 Jim_GetOpt_NvpUnknown(&goi
, jtag_cmds
, 0);
448 Jim_SetEmptyResult(goi
.interp
);
450 case JTAG_CMD_INTERFACE
:
451 /* return the name of the interface */
452 /* TCL code might need to know the exact type... */
453 /* FUTURE: we allow this as a means to "set" the interface. */
455 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
458 Jim_SetResultString(goi
.interp
, jtag_interface
->name
, -1);
462 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
465 e
= jtag_init_inner(context
);
467 Jim_SetResult_sprintf(goi
.interp
, "error: %d", e
);
471 case JTAG_CMD_INIT_RESET
:
473 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
-1, "(no params)");
476 e
= jtag_init_reset(context
);
478 Jim_SetResult_sprintf(goi
.interp
, "error: %d", e
);
482 case JTAG_CMD_NEWTAP
:
483 return jim_newtap_cmd(&goi
);
485 case JTAG_CMD_TAPISENABLED
:
486 case JTAG_CMD_TAPENABLE
:
487 case JTAG_CMD_TAPDISABLE
:
489 Jim_SetResultString(goi
.interp
, "Too many parameters",-1);
496 t
= jtag_tap_by_jim_obj(goi
.interp
, goi
.argv
[0]);
501 case JTAG_CMD_TAPISENABLED
:
503 case JTAG_CMD_TAPENABLE
:
506 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_ENABLE
);
510 /* FIXME add JTAG sanity checks, w/o TLR
511 * - scan chain length grew by one (this)
512 * - IDs and IR lengths are as expected
515 jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE
);
517 case JTAG_CMD_TAPDISABLE
:
520 jtag_tap_handle_event(t
, JTAG_TAP_EVENT_DISABLE
);
524 /* FIXME add JTAG sanity checks, w/o TLR
525 * - scan chain length shrank by one (this)
526 * - IDs and IR lengths are as expected
529 jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE
);
533 Jim_SetResult(goi
.interp
, Jim_NewIntObj(goi
.interp
, e
));
540 Jim_WrongNumArgs(goi
.interp
, 0, NULL
,
541 "cget tap_name queryparm");
548 Jim_GetOpt_Obj(&goi
, &o
);
549 t
= jtag_tap_by_jim_obj(goi
.interp
, o
);
555 return jtag_tap_configure_cmd(&goi
, t
);
559 case JTAG_CMD_CONFIGURE
:
561 Jim_WrongNumArgs(goi
.interp
, 0, NULL
,
562 "configure tap_name attribute value ...");
569 Jim_GetOpt_Obj(&goi
, &o
);
570 t
= jtag_tap_by_jim_obj(goi
.interp
, o
);
576 return jtag_tap_configure_cmd(&goi
, t
);
582 Jim_WrongNumArgs(goi
.interp
, 1, goi
.argv
, "Too many parameters");
585 Jim_SetResult(goi
.interp
, Jim_NewListObj(goi
.interp
, NULL
, 0));
589 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
) {
590 Jim_ListAppendElement(goi
.interp
,
591 Jim_GetResult(goi
.interp
),
592 Jim_NewStringObj(goi
.interp
,
593 tap
->dotted_name
, -1));
605 void jtag_notify_event(enum jtag_event event
)
609 for (tap
= jtag_all_taps(); tap
; tap
= tap
->next_tap
)
610 jtag_tap_handle_event(tap
, event
);
614 int jtag_register_commands(struct command_context_s
*cmd_ctx
)
616 register_jim(cmd_ctx
, "jtag", jim_jtag_command
, "perform jtag tap actions");
618 register_command(cmd_ctx
, NULL
, "interface", handle_interface_command
,
619 COMMAND_CONFIG
, "try to configure interface");
620 register_command(cmd_ctx
, NULL
,
621 "interface_list", &handle_interface_list_command
,
622 COMMAND_ANY
, "list all built-in interfaces");
623 register_command(cmd_ctx
, NULL
, "jtag_speed", handle_jtag_speed_command
,
624 COMMAND_ANY
, "(DEPRECATED) set jtag speed (if supported)");
625 register_command(cmd_ctx
, NULL
, "jtag_khz", handle_jtag_khz_command
,
626 COMMAND_ANY
, "set maximum jtag speed (if supported); "
627 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
628 register_command(cmd_ctx
, NULL
, "jtag_rclk", handle_jtag_rclk_command
,
629 COMMAND_ANY
, "fallback_speed_khz - set JTAG speed to RCLK or use fallback speed");
630 register_command(cmd_ctx
, NULL
, "jtag_device", handle_jtag_device_command
,
631 COMMAND_CONFIG
, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
632 register_command(cmd_ctx
, NULL
, "reset_config", handle_reset_config_command
,
635 "[none|trst_only|srst_only|trst_and_srst] "
636 "[srst_pulls_trst|trst_pulls_srst|combined|separate] "
637 "[srst_gates_jtag|srst_nogate] "
638 "[trst_push_pull|trst_open_drain] "
639 "[srst_push_pull|srst_open_drain]");
640 register_command(cmd_ctx
, NULL
, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command
,
641 COMMAND_ANY
, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
642 register_command(cmd_ctx
, NULL
, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command
,
643 COMMAND_ANY
, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
644 register_command(cmd_ctx
, NULL
, "jtag_nsrst_assert_width", handle_jtag_nsrst_assert_width_command
,
645 COMMAND_ANY
, "jtag_nsrst_assert_width <ms> - delay after asserting srst in ms");
646 register_command(cmd_ctx
, NULL
, "jtag_ntrst_assert_width", handle_jtag_ntrst_assert_width_command
,
647 COMMAND_ANY
, "jtag_ntrst_assert_width <ms> - delay after asserting trst in ms");
649 register_command(cmd_ctx
, NULL
, "scan_chain", handle_scan_chain_command
,
650 COMMAND_EXEC
, "print current scan chain configuration");
652 register_command(cmd_ctx
, NULL
, "jtag_reset", handle_jtag_reset_command
,
653 COMMAND_EXEC
, "toggle reset lines <trst> <srst>");
654 register_command(cmd_ctx
, NULL
, "runtest", handle_runtest_command
,
655 COMMAND_EXEC
, "move to Run-Test/Idle, and execute <num_cycles>");
656 register_command(cmd_ctx
, NULL
, "irscan", handle_irscan_command
,
657 COMMAND_EXEC
, "execute IR scan <device> <instr> [dev2] [instr2] ...");
658 register_jim(cmd_ctx
, "drscan", Jim_Command_drscan
, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
659 register_jim(cmd_ctx
, "flush_count", Jim_Command_flush_count
, "returns number of times the JTAG queue has been flushed");
660 register_jim(cmd_ctx
, "pathmove", Jim_Command_pathmove
, "move JTAG to state1 then to state2, state3, etc. <state1>,<state2>,<stat3>...");
662 register_command(cmd_ctx
, NULL
, "verify_ircapture", handle_verify_ircapture_command
,
663 COMMAND_ANY
, "verify value captured during Capture-IR <enable | disable>");
664 register_command(cmd_ctx
, NULL
, "verify_jtag", handle_verify_jtag_command
,
665 COMMAND_ANY
, "verify value capture <enable | disable>");
666 register_command(cmd_ctx
, NULL
, "tms_sequence", handle_tms_sequence_command
,
667 COMMAND_ANY
, "choose short(default) or long tms_sequence <short | long>");
671 static int default_khz(int khz
, int *jtag_speed
)
673 LOG_ERROR("Translation from khz to jtag_speed not implemented");
677 static int default_speed_div(int speed
, int *khz
)
679 LOG_ERROR("Translation from jtag_speed to khz not implemented");
683 static int default_power_dropout(int *dropout
)
685 *dropout
= 0; /* by default we can't detect power dropout */
689 static int default_srst_asserted(int *srst_asserted
)
691 *srst_asserted
= 0; /* by default we can't detect srst asserted */
695 static int handle_interface_command(struct command_context_s
*cmd_ctx
,
696 char *cmd
, char **args
, int argc
)
698 /* check whether the interface is already configured */
701 LOG_WARNING("Interface already configured, ignoring");
705 /* interface name is a mandatory argument */
706 if (argc
!= 1 || args
[0][0] == '\0')
707 return ERROR_COMMAND_SYNTAX_ERROR
;
709 for (unsigned i
= 0; NULL
!= jtag_interfaces
[i
]; i
++)
711 if (strcmp(args
[0], jtag_interfaces
[i
]->name
) != 0)
714 int retval
= jtag_interfaces
[i
]->register_commands(cmd_ctx
);
715 if (ERROR_OK
!= retval
)
718 jtag_interface
= jtag_interfaces
[i
];
720 if (jtag_interface
->khz
== NULL
)
721 jtag_interface
->khz
= default_khz
;
722 if (jtag_interface
->speed_div
== NULL
)
723 jtag_interface
->speed_div
= default_speed_div
;
724 if (jtag_interface
->power_dropout
== NULL
)
725 jtag_interface
->power_dropout
= default_power_dropout
;
726 if (jtag_interface
->srst_asserted
== NULL
)
727 jtag_interface
->srst_asserted
= default_srst_asserted
;
732 /* no valid interface was found (i.e. the configuration option,
733 * didn't match one of the compiled-in interfaces
735 LOG_ERROR("The specified JTAG interface was not found (%s)", args
[0]);
736 handle_interface_list_command(cmd_ctx
, cmd
, args
, argc
);
737 return ERROR_JTAG_INVALID_INTERFACE
;
740 static int handle_interface_list_command(struct command_context_s
*cmd_ctx
,
741 char *cmd
, char **args
, int argc
)
743 if (strcmp(cmd
, "interface_list") == 0 && argc
> 0)
744 return ERROR_COMMAND_SYNTAX_ERROR
;
746 command_print(cmd_ctx
, "The following JTAG interfaces are available:");
747 for (unsigned i
= 0; NULL
!= jtag_interfaces
[i
]; i
++)
749 const char *name
= jtag_interfaces
[i
]->name
;
750 command_print(cmd_ctx
, "%u: %s", i
+ 1, name
);
756 static int handle_jtag_device_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
760 Jim_Obj
*newargs
[ 10 ];
764 * argv[ 0] = ir length
765 * argv[ 1] = ir capture
767 * argv[ 3] = not actually used by anything but in the docs
771 command_print(cmd_ctx
, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
774 command_print(cmd_ctx
, "OLD SYNTAX: DEPRECATED - translating to new syntax");
775 command_print(cmd_ctx
, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
779 command_print(cmd_ctx
, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
780 command_print(cmd_ctx
, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
781 command_print(cmd_ctx
, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
782 command_print(cmd_ctx
, "And then refer to the taps by the dotted name.");
784 newargs
[0] = Jim_NewStringObj(interp
, "jtag", -1);
785 newargs
[1] = Jim_NewStringObj(interp
, "newtap", -1);
786 sprintf(buf
, "chip%d", jtag_tap_count());
787 newargs
[2] = Jim_NewStringObj(interp
, buf
, -1);
788 sprintf(buf
, "tap%d", jtag_tap_count());
789 newargs
[3] = Jim_NewStringObj(interp
, buf
, -1);
790 newargs
[4] = Jim_NewStringObj(interp
, "-irlen", -1);
791 newargs
[5] = Jim_NewStringObj(interp
, args
[0], -1);
792 newargs
[6] = Jim_NewStringObj(interp
, "-ircapture", -1);
793 newargs
[7] = Jim_NewStringObj(interp
, args
[1], -1);
794 newargs
[8] = Jim_NewStringObj(interp
, "-irmask", -1);
795 newargs
[9] = Jim_NewStringObj(interp
, args
[2], -1);
797 command_print(cmd_ctx
, "NEW COMMAND:");
798 sprintf(buf
, "%s %s %s %s %s %s %s %s %s %s",
799 Jim_GetString(newargs
[0], NULL
),
800 Jim_GetString(newargs
[1], NULL
),
801 Jim_GetString(newargs
[2], NULL
),
802 Jim_GetString(newargs
[3], NULL
),
803 Jim_GetString(newargs
[4], NULL
),
804 Jim_GetString(newargs
[5], NULL
),
805 Jim_GetString(newargs
[6], NULL
),
806 Jim_GetString(newargs
[7], NULL
),
807 Jim_GetString(newargs
[8], NULL
),
808 Jim_GetString(newargs
[9], NULL
));
810 e
= jim_jtag_command(interp
, 10, newargs
);
812 command_print(cmd_ctx
, "%s", Jim_GetString(Jim_GetResult(interp
), NULL
));
817 static int handle_scan_chain_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
821 tap
= jtag_all_taps();
822 command_print(cmd_ctx
, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
823 command_print(cmd_ctx
, "---|--------------------|---------|------------|------------|------|------|------|---------");
826 uint32_t expected
, expected_mask
, cur_instr
, ii
;
827 expected
= buf_get_u32(tap
->expected
, 0, tap
->ir_length
);
828 expected_mask
= buf_get_u32(tap
->expected_mask
, 0, tap
->ir_length
);
829 cur_instr
= buf_get_u32(tap
->cur_instr
, 0, tap
->ir_length
);
831 command_print(cmd_ctx
,
832 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
833 tap
->abs_chain_position
,
835 tap
->enabled
? 'Y' : 'n',
836 (unsigned int)(tap
->idcode
),
837 (unsigned int)(tap
->expected_ids_cnt
> 0 ? tap
->expected_ids
[0] : 0),
838 (unsigned int)(tap
->ir_length
),
839 (unsigned int)(expected
),
840 (unsigned int)(expected_mask
),
841 (unsigned int)(cur_instr
));
843 for (ii
= 1; ii
< tap
->expected_ids_cnt
; ii
++) {
844 command_print(cmd_ctx
, " | | | | 0x%08x | | | | ",
845 (unsigned int)(tap
->expected_ids
[ii
]));
854 static int handle_reset_config_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
859 /* Original versions cared about the order of these tokens:
860 * reset_config signals [combination [trst_type [srst_type]]]
861 * They also clobbered the previous configuration even on error.
863 * Here we don't care about the order, and only change values
864 * which have been explicitly specified.
866 for (; argc
; argc
--, args
++) {
871 m
= RESET_SRST_NO_GATING
;
872 if (strcmp(*args
, "srst_gates_jtag") == 0)
873 /* default: don't use JTAG while SRST asserted */;
874 else if (strcmp(*args
, "srst_nogate") == 0)
875 tmp
= RESET_SRST_NO_GATING
;
879 LOG_ERROR("extra reset_config %s spec (%s)",
881 return ERROR_INVALID_ARGUMENTS
;
887 m
= RESET_HAS_TRST
| RESET_HAS_SRST
;
888 if (strcmp(*args
, "none") == 0)
890 else if (strcmp(*args
, "trst_only") == 0)
891 tmp
= RESET_HAS_TRST
;
892 else if (strcmp(*args
, "srst_only") == 0)
893 tmp
= RESET_HAS_SRST
;
894 else if (strcmp(*args
, "trst_and_srst") == 0)
895 tmp
= RESET_HAS_TRST
| RESET_HAS_SRST
;
899 LOG_ERROR("extra reset_config %s spec (%s)",
901 return ERROR_INVALID_ARGUMENTS
;
906 /* combination (options for broken wiring) */
907 m
= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
908 if (strcmp(*args
, "separate") == 0)
909 /* separate reset lines - default */;
910 else if (strcmp(*args
, "srst_pulls_trst") == 0)
911 tmp
|= RESET_SRST_PULLS_TRST
;
912 else if (strcmp(*args
, "trst_pulls_srst") == 0)
913 tmp
|= RESET_TRST_PULLS_SRST
;
914 else if (strcmp(*args
, "combined") == 0)
915 tmp
|= RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
;
919 LOG_ERROR("extra reset_config %s spec (%s)",
920 "combination", *args
);
921 return ERROR_INVALID_ARGUMENTS
;
926 /* trst_type (NOP without HAS_TRST) */
927 m
= RESET_TRST_OPEN_DRAIN
;
928 if (strcmp(*args
, "trst_open_drain") == 0)
929 tmp
|= RESET_TRST_OPEN_DRAIN
;
930 else if (strcmp(*args
, "trst_push_pull") == 0)
931 /* push/pull from adapter - default */;
935 LOG_ERROR("extra reset_config %s spec (%s)",
937 return ERROR_INVALID_ARGUMENTS
;
942 /* srst_type (NOP without HAS_SRST) */
943 m
|= RESET_SRST_PUSH_PULL
;
944 if (strcmp(*args
, "srst_push_pull") == 0)
945 tmp
|= RESET_SRST_PUSH_PULL
;
946 else if (strcmp(*args
, "srst_open_drain") == 0)
947 /* open drain from adapter - default */;
951 LOG_ERROR("extra reset_config %s spec (%s)",
953 return ERROR_INVALID_ARGUMENTS
;
958 /* caller provided nonsense; fail */
959 LOG_ERROR("unknown reset_config flag (%s)", *args
);
960 return ERROR_INVALID_ARGUMENTS
;
963 /* Remember the bits which were specified (mask)
964 * and their new values (new_cfg).
970 /* clear previous values of those bits, save new values */
972 int old_cfg
= jtag_get_reset_config();
976 jtag_set_reset_config(new_cfg
);
978 new_cfg
= jtag_get_reset_config();
982 * Display the (now-)current reset mode
986 /* minimal JTAG has neither SRST nor TRST (so that's the default) */
987 switch (new_cfg
& (RESET_HAS_TRST
| RESET_HAS_SRST
)) {
989 modes
[0] = "srst_only";
992 modes
[0] = "trst_only";
994 case RESET_TRST_AND_SRST
:
995 modes
[0] = "trst_and_srst";
1002 /* normally SRST and TRST are decoupled; but bugs happen ... */
1003 switch (new_cfg
& (RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
)) {
1004 case RESET_SRST_PULLS_TRST
:
1005 modes
[1] = "srst_pulls_trst";
1007 case RESET_TRST_PULLS_SRST
:
1008 modes
[1] = "trst_pulls_srst";
1010 case RESET_SRST_PULLS_TRST
| RESET_TRST_PULLS_SRST
:
1011 modes
[1] = "combined";
1014 modes
[1] = "separate";
1018 /* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
1019 if (new_cfg
& RESET_HAS_TRST
) {
1020 if (new_cfg
& RESET_TRST_OPEN_DRAIN
)
1021 modes
[3] = " trst_open_drain";
1023 modes
[3] = " trst_push_pull";
1027 /* SRST-less connectors include TI-14, Xilinx, and minimal JTAG */
1028 if (new_cfg
& RESET_HAS_SRST
) {
1029 if (new_cfg
& RESET_SRST_NO_GATING
)
1030 modes
[2] = " srst_nogate";
1032 modes
[2] = " srst_gates_jtag";
1034 if (new_cfg
& RESET_SRST_PUSH_PULL
)
1035 modes
[4] = " srst_push_pull";
1037 modes
[4] = " srst_open_drain";
1043 command_print(cmd_ctx
, "%s %s%s%s%s",
1045 modes
[2], modes
[3], modes
[4]);
1050 static int handle_jtag_nsrst_delay_command(struct command_context_s
*cmd_ctx
,
1051 char *cmd
, char **args
, int argc
)
1054 return ERROR_COMMAND_SYNTAX_ERROR
;
1058 int retval
= parse_uint(args
[0], &delay
);
1059 if (ERROR_OK
!= retval
)
1061 jtag_set_nsrst_delay(delay
);
1063 command_print(cmd_ctx
, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
1067 static int handle_jtag_ntrst_delay_command(struct command_context_s
*cmd_ctx
,
1068 char *cmd
, char **args
, int argc
)
1071 return ERROR_COMMAND_SYNTAX_ERROR
;
1075 int retval
= parse_uint(args
[0], &delay
);
1076 if (ERROR_OK
!= retval
)
1078 jtag_set_ntrst_delay(delay
);
1080 command_print(cmd_ctx
, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
1084 static int handle_jtag_nsrst_assert_width_command(struct command_context_s
*cmd_ctx
,
1085 char *cmd
, char **args
, int argc
)
1088 return ERROR_COMMAND_SYNTAX_ERROR
;
1092 int retval
= parse_uint(args
[0], &delay
);
1093 if (ERROR_OK
!= retval
)
1095 jtag_set_nsrst_assert_width(delay
);
1097 command_print(cmd_ctx
, "jtag_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
1101 static int handle_jtag_ntrst_assert_width_command(struct command_context_s
*cmd_ctx
,
1102 char *cmd
, char **args
, int argc
)
1105 return ERROR_COMMAND_SYNTAX_ERROR
;
1109 int retval
= parse_uint(args
[0], &delay
);
1110 if (ERROR_OK
!= retval
)
1112 jtag_set_ntrst_assert_width(delay
);
1114 command_print(cmd_ctx
, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
1118 static int handle_jtag_speed_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1120 int retval
= ERROR_OK
;
1122 command_print(cmd_ctx
, "OLD SYNTAX: DEPRECATED - "
1123 "use jtag_khz, not jtag_speed");
1126 return ERROR_COMMAND_SYNTAX_ERROR
;
1129 LOG_DEBUG("handle jtag speed");
1131 unsigned cur_speed
= 0;
1132 int retval
= parse_uint(args
[0], &cur_speed
);
1133 if (ERROR_OK
!= retval
)
1135 retval
= jtag_config_speed(cur_speed
);
1138 command_print(cmd_ctx
, "jtag_speed: %d", jtag_get_speed());
1143 static int handle_jtag_khz_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1146 return ERROR_COMMAND_SYNTAX_ERROR
;
1148 int retval
= ERROR_OK
;
1152 int retval
= parse_uint(args
[0], &khz
);
1153 if (ERROR_OK
!= retval
)
1155 retval
= jtag_config_khz(khz
);
1156 if (ERROR_OK
!= retval
)
1160 int cur_speed
= jtag_get_speed_khz();
1161 retval
= jtag_get_speed_readable(&cur_speed
);
1162 if (ERROR_OK
!= retval
)
1166 command_print(cmd_ctx
, "%d kHz", cur_speed
);
1168 command_print(cmd_ctx
, "RCLK - adaptive");
1173 static int handle_jtag_rclk_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1176 return ERROR_COMMAND_SYNTAX_ERROR
;
1178 int retval
= ERROR_OK
;
1182 int retval
= parse_uint(args
[0], &khz
);
1183 if (ERROR_OK
!= retval
)
1185 retval
= jtag_config_rclk(khz
);
1186 if (ERROR_OK
!= retval
)
1190 int cur_khz
= jtag_get_speed_khz();
1191 retval
= jtag_get_speed_readable(&cur_khz
);
1192 if (ERROR_OK
!= retval
)
1196 command_print(cmd_ctx
, "RCLK not supported - fallback to %d kHz", cur_khz
);
1198 command_print(cmd_ctx
, "RCLK - adaptive");
1203 static int handle_jtag_reset_command(struct command_context_s
*cmd_ctx
,
1204 char *cmd
, char **args
, int argc
)
1207 return ERROR_COMMAND_SYNTAX_ERROR
;
1210 if (args
[0][0] == '1')
1212 else if (args
[0][0] == '0')
1215 return ERROR_COMMAND_SYNTAX_ERROR
;
1218 if (args
[1][0] == '1')
1220 else if (args
[1][0] == '0')
1223 return ERROR_COMMAND_SYNTAX_ERROR
;
1225 if (jtag_interface_init(cmd_ctx
) != ERROR_OK
)
1226 return ERROR_JTAG_INIT_FAILED
;
1228 jtag_add_reset(trst
, srst
);
1229 return jtag_execute_queue();
1232 static int handle_runtest_command(struct command_context_s
*cmd_ctx
,
1233 char *cmd
, char **args
, int argc
)
1236 return ERROR_COMMAND_SYNTAX_ERROR
;
1238 unsigned num_clocks
;
1239 int retval
= parse_uint(args
[0], &num_clocks
);
1240 if (ERROR_OK
!= retval
)
1243 jtag_add_runtest(num_clocks
, TAP_IDLE
);
1244 return jtag_execute_queue();
1248 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1249 * should be stable ... and *NOT* a shift state, otherwise free-running
1250 * jtag clocks could change the values latched by the update state.
1252 static bool scan_is_safe(tap_state_t state
)
1267 static int handle_irscan_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1270 scan_field_t
*fields
;
1272 tap_state_t endstate
;
1274 if ((argc
< 2) || (argc
% 2))
1276 return ERROR_COMMAND_SYNTAX_ERROR
;
1279 /* optional "-endstate" "statename" at the end of the arguments,
1280 * so that e.g. IRPAUSE can let us load the data register before
1281 * entering RUN/IDLE to execute the instruction we load here.
1283 endstate
= TAP_IDLE
;
1286 /* have at least one pair of numbers. */
1287 /* is last pair the magic text? */
1288 if (0 == strcmp("-endstate", args
[ argc
- 2 ])) {
1291 cpA
= args
[ argc
-1 ];
1292 for (endstate
= 0 ; endstate
< TAP_NUM_STATES
; endstate
++) {
1293 cpS
= tap_state_name(endstate
);
1294 if (0 == strcmp(cpA
, cpS
)) {
1298 if (endstate
>= TAP_NUM_STATES
) {
1299 return ERROR_COMMAND_SYNTAX_ERROR
;
1301 if (!scan_is_safe(endstate
))
1302 LOG_WARNING("irscan with unsafe "
1303 "endstate \"%s\"", cpA
);
1304 /* found - remove the last 2 args */
1310 int num_fields
= argc
/ 2;
1311 size_t fields_len
= sizeof(scan_field_t
) * num_fields
;
1312 fields
= malloc(fields_len
);
1313 memset(fields
, 0, fields_len
);
1316 for (i
= 0; i
< num_fields
; i
++)
1318 tap
= jtag_tap_by_string(args
[i
*2]);
1322 for (j
= 0; j
< i
; j
++)
1323 free(fields
[j
].out_value
);
1325 command_print(cmd_ctx
, "Tap: %s unknown", args
[i
*2]);
1329 int field_size
= tap
->ir_length
;
1330 fields
[i
].tap
= tap
;
1331 fields
[i
].num_bits
= field_size
;
1332 fields
[i
].out_value
= malloc(CEIL(field_size
, 8));
1335 retval
= parse_u32(args
[i
* 2 + 1], &value
);
1336 if (ERROR_OK
!= retval
)
1338 buf_set_u32(fields
[i
].out_value
, 0, field_size
, value
);
1339 fields
[i
].in_value
= NULL
;
1342 /* did we have an endstate? */
1343 jtag_add_ir_scan(num_fields
, fields
, endstate
);
1345 retval
= jtag_execute_queue();
1348 for (i
= 0; i
< num_fields
; i
++)
1350 if (NULL
!= fields
[i
].out_value
)
1351 free(fields
[i
].out_value
);
1359 static int Jim_Command_drscan(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
1362 scan_field_t
*fields
;
1364 int field_count
= 0;
1367 tap_state_t endstate
;
1370 * args[2] = num_bits
1371 * args[3] = hex string
1372 * ... repeat num bits and hex string ...
1375 * args[N-2] = "-endstate"
1376 * args[N-1] = statename
1378 if ((argc
< 4) || ((argc
% 2) != 0))
1380 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
1384 endstate
= TAP_IDLE
;
1386 script_debug(interp
, "drscan", argc
, args
);
1388 /* validate arguments as numbers */
1390 for (i
= 2; i
< argc
; i
+= 2)
1395 e
= Jim_GetLong(interp
, args
[i
], &bits
);
1396 /* If valid - try next arg */
1401 /* Not valid.. are we at the end? */
1402 if (((i
+ 2) != argc
)) {
1403 /* nope, then error */
1407 /* it could be: "-endstate FOO"
1408 * e.g. DRPAUSE so we can issue more instructions
1409 * before entering RUN/IDLE and executing them.
1412 /* get arg as a string. */
1413 cp
= Jim_GetString(args
[i
], NULL
);
1414 /* is it the magic? */
1415 if (0 == strcmp("-endstate", cp
)) {
1416 /* is the statename valid? */
1417 cp
= Jim_GetString(args
[i
+ 1], NULL
);
1419 /* see if it is a valid state name */
1420 endstate
= tap_state_by_name(cp
);
1422 /* update the error message */
1423 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
1425 if (!scan_is_safe(endstate
))
1426 LOG_WARNING("drscan with unsafe "
1427 "endstate \"%s\"", cp
);
1429 /* valid - so clear the error */
1431 /* and remove the last 2 args */
1436 /* Still an error? */
1438 return e
; /* too bad */
1440 } /* validate args */
1442 tap
= jtag_tap_by_jim_obj(interp
, args
[1]);
1447 num_fields
= (argc
-2)/2;
1448 fields
= malloc(sizeof(scan_field_t
) * num_fields
);
1449 for (i
= 2; i
< argc
; i
+= 2)
1455 Jim_GetLong(interp
, args
[i
], &bits
);
1456 str
= Jim_GetString(args
[i
+ 1], &len
);
1458 fields
[field_count
].tap
= tap
;
1459 fields
[field_count
].num_bits
= bits
;
1460 fields
[field_count
].out_value
= malloc(CEIL(bits
, 8));
1461 str_to_buf(str
, len
, fields
[field_count
].out_value
, bits
, 0);
1462 fields
[field_count
].in_value
= fields
[field_count
].out_value
;
1466 jtag_add_dr_scan(num_fields
, fields
, endstate
);
1468 retval
= jtag_execute_queue();
1469 if (retval
!= ERROR_OK
)
1471 Jim_SetResultString(interp
, "drscan: jtag execute failed",-1);
1476 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
1477 for (i
= 2; i
< argc
; i
+= 2)
1482 Jim_GetLong(interp
, args
[i
], &bits
);
1483 str
= buf_to_str(fields
[field_count
].in_value
, bits
, 16);
1484 free(fields
[field_count
].out_value
);
1486 Jim_ListAppendElement(interp
, list
, Jim_NewStringObj(interp
, str
, strlen(str
)));
1491 Jim_SetResult(interp
, list
);
1499 static int Jim_Command_pathmove(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
1501 tap_state_t states
[8];
1503 if ((argc
< 2) || ((size_t)argc
> (sizeof(states
)/sizeof(*states
) + 1)))
1505 Jim_WrongNumArgs(interp
, 1, args
, "wrong arguments");
1509 script_debug(interp
, "pathmove", argc
, args
);
1512 for (i
= 0; i
< argc
-1; i
++)
1515 cp
= Jim_GetString(args
[i
+ 1], NULL
);
1516 states
[i
] = tap_state_by_name(cp
);
1519 /* update the error message */
1520 Jim_SetResult_sprintf(interp
,"endstate: %s invalid", cp
);
1525 if ((jtag_add_statemove(states
[0]) != ERROR_OK
) || (jtag_execute_queue()!= ERROR_OK
))
1527 Jim_SetResultString(interp
, "pathmove: jtag execute failed",-1);
1531 jtag_add_pathmove(argc
-2, states
+ 1);
1533 if (jtag_execute_queue()!= ERROR_OK
)
1535 Jim_SetResultString(interp
, "pathmove: failed",-1);
1543 static int Jim_Command_flush_count(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *args
)
1545 script_debug(interp
, "flush_count", argc
, args
);
1547 Jim_SetResult(interp
, Jim_NewIntObj(interp
, jtag_get_flush_queue_count()));
1553 static int handle_verify_ircapture_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1556 return ERROR_COMMAND_SYNTAX_ERROR
;
1560 if (strcmp(args
[0], "enable") == 0)
1561 jtag_set_verify_capture_ir(true);
1562 else if (strcmp(args
[0], "disable") == 0)
1563 jtag_set_verify_capture_ir(false);
1565 return ERROR_COMMAND_SYNTAX_ERROR
;
1568 const char *status
= jtag_will_verify_capture_ir() ? "enabled": "disabled";
1569 command_print(cmd_ctx
, "verify Capture-IR is %s", status
);
1574 static int handle_verify_jtag_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1577 return ERROR_COMMAND_SYNTAX_ERROR
;
1581 if (strcmp(args
[0], "enable") == 0)
1582 jtag_set_verify(true);
1583 else if (strcmp(args
[0], "disable") == 0)
1584 jtag_set_verify(false);
1586 return ERROR_COMMAND_SYNTAX_ERROR
;
1589 const char *status
= jtag_will_verify() ? "enabled": "disabled";
1590 command_print(cmd_ctx
, "verify jtag capture is %s", status
);
1595 static int handle_tms_sequence_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1598 return ERROR_COMMAND_SYNTAX_ERROR
;
1603 if (strcmp(args
[0], "short") == 0)
1604 use_new_table
= true;
1605 else if (strcmp(args
[0], "long") == 0)
1606 use_new_table
= false;
1608 return ERROR_COMMAND_SYNTAX_ERROR
;
1610 tap_use_new_tms_table(use_new_table
);
1613 command_print(cmd_ctx
, "tms sequence is %s",
1614 tap_uses_new_tms_table() ? "short": "long");
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)