add CMD_NAME macro for command handlers
[openocd.git] / src / jtag / tcl.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 √ėyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2009 SoftPLC Corporation *
9 * http://softplc.com *
10 * dick@softplc.com *
11 * *
12 * Copyright (C) 2009 Zachary T Welch *
13 * zw@superlucidity.net *
14 * *
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. *
19 * *
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. *
24 * *
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 ***************************************************************************/
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "jtag.h"
35 #include "minidriver.h"
36 #include "interface.h"
37 #include "interfaces.h"
38
39 #ifdef HAVE_STRINGS_H
40 #include <strings.h>
41 #endif
42
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" },
48
49 { .name = NULL, .value = -1 }
50 };
51
52 extern jtag_interface_t *jtag_interface;
53
54 enum jtag_tap_cfg_param {
55 JCFG_EVENT
56 };
57
58 static Jim_Nvp nvp_config_opts[] = {
59 { .name = "-event", .value = JCFG_EVENT },
60
61 { .name = NULL, .value = -1 }
62 };
63
64 static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, jtag_tap_t * tap)
65 {
66 Jim_Nvp *n;
67 Jim_Obj *o;
68 int e;
69
70 /* parse config or cget options */
71 while (goi->argc > 0) {
72 Jim_SetEmptyResult (goi->interp);
73
74 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
75 if (e != JIM_OK) {
76 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
77 return e;
78 }
79
80 switch (n->value) {
81 case JCFG_EVENT:
82 if (goi->argc == 0) {
83 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ...");
84 return JIM_ERR;
85 }
86
87 e = Jim_GetOpt_Nvp(goi, nvp_jtag_tap_event, &n);
88 if (e != JIM_OK) {
89 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
90 return e;
91 }
92
93 if (goi->isconfigure) {
94 if (goi->argc != 1) {
95 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
96 return JIM_ERR;
97 }
98 } else {
99 if (goi->argc != 0) {
100 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
101 return JIM_ERR;
102 }
103 }
104
105 {
106 jtag_tap_event_action_t *jteap;
107
108 jteap = tap->event_action;
109 /* replace existing? */
110 while (jteap) {
111 if (jteap->event == (enum jtag_event)n->value) {
112 break;
113 }
114 jteap = jteap->next;
115 }
116
117 if (goi->isconfigure) {
118 bool replace = true;
119 if (jteap == NULL) {
120 /* create new */
121 jteap = calloc(1, sizeof (*jteap));
122 replace = false;
123 }
124 jteap->event = n->value;
125 Jim_GetOpt_Obj(goi, &o);
126 if (jteap->body) {
127 Jim_DecrRefCount(interp, jteap->body);
128 }
129 jteap->body = Jim_DuplicateObj(goi->interp, o);
130 Jim_IncrRefCount(jteap->body);
131
132 if (!replace)
133 {
134 /* add to head of event list */
135 jteap->next = tap->event_action;
136 tap->event_action = jteap;
137 }
138 Jim_SetEmptyResult(goi->interp);
139 } else {
140 /* get */
141 if (jteap == NULL) {
142 Jim_SetEmptyResult(goi->interp);
143 } else {
144 Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
145 }
146 }
147 }
148 /* loop for more */
149 break;
150 }
151 } /* while (goi->argc) */
152
153 return JIM_OK;
154 }
155
156 static int is_bad_irval(int ir_length, jim_wide w)
157 {
158 jim_wide v = 1;
159
160 v <<= ir_length;
161 v -= 1;
162 v = ~v;
163 return (w & v) != 0;
164 }
165
166 static int jim_newtap_cmd(Jim_GetOptInfo *goi)
167 {
168 jtag_tap_t *pTap;
169 jim_wide w;
170 int x;
171 int e;
172 Jim_Nvp *n;
173 char *cp;
174 const Jim_Nvp opts[] = {
175 #define NTAP_OPT_IRLEN 0
176 { .name = "-irlen" , .value = NTAP_OPT_IRLEN },
177 #define NTAP_OPT_IRMASK 1
178 { .name = "-irmask" , .value = NTAP_OPT_IRMASK },
179 #define NTAP_OPT_IRCAPTURE 2
180 { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE },
181 #define NTAP_OPT_ENABLED 3
182 { .name = "-enable" , .value = NTAP_OPT_ENABLED },
183 #define NTAP_OPT_DISABLED 4
184 { .name = "-disable" , .value = NTAP_OPT_DISABLED },
185 #define NTAP_OPT_EXPECTED_ID 5
186 { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID },
187 { .name = NULL , .value = -1 },
188 };
189
190 pTap = calloc(1, sizeof(jtag_tap_t));
191 if (!pTap) {
192 Jim_SetResult_sprintf(goi->interp, "no memory");
193 return JIM_ERR;
194 }
195
196 /*
197 * we expect CHIP + TAP + OPTIONS
198 * */
199 if (goi->argc < 3) {
200 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
201 free(pTap);
202 return JIM_ERR;
203 }
204 Jim_GetOpt_String(goi, &cp, NULL);
205 pTap->chip = strdup(cp);
206
207 Jim_GetOpt_String(goi, &cp, NULL);
208 pTap->tapname = strdup(cp);
209
210 /* name + dot + name + null */
211 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
212 cp = malloc(x);
213 sprintf(cp, "%s.%s", pTap->chip, pTap->tapname);
214 pTap->dotted_name = cp;
215
216 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
217 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
218
219 /* IEEE specifies that the two LSBs of an IR scan are 01, so make
220 * that the default. The "-irlen" and "-irmask" options are only
221 * needed to cope with nonstandard TAPs, or to specify more bits.
222 */
223 pTap->ir_capture_mask = 0x03;
224 pTap->ir_capture_value = 0x01;
225
226 while (goi->argc) {
227 e = Jim_GetOpt_Nvp(goi, opts, &n);
228 if (e != JIM_OK) {
229 Jim_GetOpt_NvpUnknown(goi, opts, 0);
230 free((void *)pTap->dotted_name);
231 free(pTap);
232 return e;
233 }
234 LOG_DEBUG("Processing option: %s", n->name);
235 switch (n->value) {
236 case NTAP_OPT_ENABLED:
237 pTap->disabled_after_reset = false;
238 break;
239 case NTAP_OPT_DISABLED:
240 pTap->disabled_after_reset = true;
241 break;
242 case NTAP_OPT_EXPECTED_ID:
243 {
244 uint32_t *new_expected_ids;
245
246 e = Jim_GetOpt_Wide(goi, &w);
247 if (e != JIM_OK) {
248 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
249 free((void *)pTap->dotted_name);
250 free(pTap);
251 return e;
252 }
253
254 new_expected_ids = malloc(sizeof(uint32_t) * (pTap->expected_ids_cnt + 1));
255 if (new_expected_ids == NULL) {
256 Jim_SetResult_sprintf(goi->interp, "no memory");
257 free((void *)pTap->dotted_name);
258 free(pTap);
259 return JIM_ERR;
260 }
261
262 memcpy(new_expected_ids, pTap->expected_ids, sizeof(uint32_t) * pTap->expected_ids_cnt);
263
264 new_expected_ids[pTap->expected_ids_cnt] = w;
265
266 free(pTap->expected_ids);
267 pTap->expected_ids = new_expected_ids;
268 pTap->expected_ids_cnt++;
269 break;
270 }
271 case NTAP_OPT_IRLEN:
272 case NTAP_OPT_IRMASK:
273 case NTAP_OPT_IRCAPTURE:
274 e = Jim_GetOpt_Wide(goi, &w);
275 if (e != JIM_OK) {
276 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
277 free((void *)pTap->dotted_name);
278 free(pTap);
279 return e;
280 }
281 switch (n->value) {
282 case NTAP_OPT_IRLEN:
283 if (w > (jim_wide) (8 * sizeof(pTap->ir_capture_value)))
284 LOG_WARNING("%s: huge IR length %d",
285 pTap->dotted_name,
286 (int) w);
287 pTap->ir_length = w;
288 break;
289 case NTAP_OPT_IRMASK:
290 if (is_bad_irval(pTap->ir_length, w)) {
291 LOG_ERROR("%s: IR mask %x too big",
292 pTap->dotted_name,
293 (int) w);
294 free((void *)pTap->dotted_name);
295 free(pTap);
296 return ERROR_FAIL;
297 }
298 if ((w & 3) != 3)
299 LOG_WARNING("%s: nonstandard IR mask",
300 pTap->dotted_name);
301 pTap->ir_capture_mask = w;
302 break;
303 case NTAP_OPT_IRCAPTURE:
304 if (is_bad_irval(pTap->ir_length, w)) {
305 LOG_ERROR("%s: IR capture %x too big",
306 pTap->dotted_name,
307 (int) w);
308 free((void *)pTap->dotted_name);
309 free(pTap);
310 return ERROR_FAIL;
311 }
312 if ((w & 3) != 1)
313 LOG_WARNING("%s: nonstandard IR value",
314 pTap->dotted_name);
315 pTap->ir_capture_value = w;
316 break;
317 }
318 } /* switch (n->value) */
319 } /* while (goi->argc) */
320
321 /* default is enabled-after-reset */
322 pTap->enabled = !pTap->disabled_after_reset;
323
324 /* Did all the required option bits get cleared? */
325 if (pTap->ir_length != 0)
326 {
327 jtag_tap_init(pTap);
328 return ERROR_OK;
329 }
330
331 Jim_SetResult_sprintf(goi->interp,
332 "newtap: %s missing IR length",
333 pTap->dotted_name);
334 jtag_tap_free(pTap);
335 return JIM_ERR;
336 }
337
338 static void jtag_tap_handle_event(jtag_tap_t *tap, enum jtag_event e)
339 {
340 jtag_tap_event_action_t * jteap;
341
342 for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next) {
343 if (jteap->event == e) {
344 LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
345 tap->dotted_name,
346 e,
347 Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
348 Jim_GetString(jteap->body, NULL));
349 if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
350 Jim_PrintErrorMessage(interp);
351 } else switch (e) {
352 case JTAG_TAP_EVENT_ENABLE:
353 case JTAG_TAP_EVENT_DISABLE:
354 /* NOTE: we currently assume the handlers
355 * can't fail. Right here is where we should
356 * really be verifying the scan chains ...
357 */
358 tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
359 LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
360 tap->enabled ? "enabled" : "disabled");
361 break;
362 default:
363 break;
364 }
365 }
366 }
367 }
368
369
370 static int jim_jtag_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
371 {
372 Jim_GetOptInfo goi;
373 int e;
374 Jim_Nvp *n;
375 Jim_Obj *o;
376 struct command_context_s *context;
377
378 enum {
379 JTAG_CMD_INTERFACE,
380 JTAG_CMD_INIT,
381 JTAG_CMD_INIT_RESET,
382 JTAG_CMD_NEWTAP,
383 JTAG_CMD_TAPENABLE,
384 JTAG_CMD_TAPDISABLE,
385 JTAG_CMD_TAPISENABLED,
386 JTAG_CMD_CONFIGURE,
387 JTAG_CMD_CGET,
388 JTAG_CMD_NAMES,
389 };
390
391 const Jim_Nvp jtag_cmds[] = {
392 { .name = "interface" , .value = JTAG_CMD_INTERFACE },
393 { .name = "arp_init" , .value = JTAG_CMD_INIT },
394 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
395 { .name = "newtap" , .value = JTAG_CMD_NEWTAP },
396 { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED },
397 { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE },
398 { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE },
399 { .name = "configure" , .value = JTAG_CMD_CONFIGURE },
400 { .name = "cget" , .value = JTAG_CMD_CGET },
401 { .name = "names" , .value = JTAG_CMD_NAMES },
402
403 { .name = NULL, .value = -1 },
404 };
405
406 context = Jim_GetAssocData(interp, "context");
407 /* go past the command */
408 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
409
410 e = Jim_GetOpt_Nvp(&goi, jtag_cmds, &n);
411 if (e != JIM_OK) {
412 Jim_GetOpt_NvpUnknown(&goi, jtag_cmds, 0);
413 return e;
414 }
415 Jim_SetEmptyResult(goi.interp);
416 switch (n->value) {
417 case JTAG_CMD_INTERFACE:
418 /* return the name of the interface */
419 /* TCL code might need to know the exact type... */
420 /* FUTURE: we allow this as a means to "set" the interface. */
421 if (goi.argc != 0) {
422 Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
423 return JIM_ERR;
424 }
425 const char *name = jtag_interface ? jtag_interface->name : NULL;
426 Jim_SetResultString(goi.interp, name ? : "undefined", -1);
427 return JIM_OK;
428 case JTAG_CMD_INIT:
429 if (goi.argc != 0) {
430 Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
431 return JIM_ERR;
432 }
433 e = jtag_init_inner(context);
434 if (e != ERROR_OK) {
435 Jim_SetResult_sprintf(goi.interp, "error: %d", e);
436 return JIM_ERR;
437 }
438 return JIM_OK;
439 case JTAG_CMD_INIT_RESET:
440 if (goi.argc != 0) {
441 Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
442 return JIM_ERR;
443 }
444 e = jtag_init_reset(context);
445 if (e != ERROR_OK) {
446 Jim_SetResult_sprintf(goi.interp, "error: %d", e);
447 return JIM_ERR;
448 }
449 return JIM_OK;
450 case JTAG_CMD_NEWTAP:
451 return jim_newtap_cmd(&goi);
452 break;
453 case JTAG_CMD_TAPISENABLED:
454 case JTAG_CMD_TAPENABLE:
455 case JTAG_CMD_TAPDISABLE:
456 if (goi.argc != 1) {
457 Jim_SetResultString(goi.interp, "Too many parameters",-1);
458 return JIM_ERR;
459 }
460
461 {
462 jtag_tap_t *t;
463
464 t = jtag_tap_by_jim_obj(goi.interp, goi.argv[0]);
465 if (t == NULL)
466 return JIM_ERR;
467
468 switch (n->value) {
469 case JTAG_CMD_TAPISENABLED:
470 break;
471 case JTAG_CMD_TAPENABLE:
472 if (t->enabled)
473 break;
474 jtag_tap_handle_event(t, JTAG_TAP_EVENT_ENABLE);
475 if (!t->enabled)
476 break;
477
478 /* FIXME add JTAG sanity checks, w/o TLR
479 * - scan chain length grew by one (this)
480 * - IDs and IR lengths are as expected
481 */
482
483 jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE);
484 break;
485 case JTAG_CMD_TAPDISABLE:
486 if (!t->enabled)
487 break;
488 jtag_tap_handle_event(t, JTAG_TAP_EVENT_DISABLE);
489 if (t->enabled)
490 break;
491
492 /* FIXME add JTAG sanity checks, w/o TLR
493 * - scan chain length shrank by one (this)
494 * - IDs and IR lengths are as expected
495 */
496
497 jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE);
498 break;
499 }
500 e = t->enabled;
501 Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, e));
502 return JIM_OK;
503 }
504 break;
505
506 case JTAG_CMD_CGET:
507 if (goi.argc < 2) {
508 Jim_WrongNumArgs(goi.interp, 0, NULL,
509 "cget tap_name queryparm");
510 return JIM_ERR;
511 }
512
513 {
514 jtag_tap_t *t;
515
516 Jim_GetOpt_Obj(&goi, &o);
517 t = jtag_tap_by_jim_obj(goi.interp, o);
518 if (t == NULL) {
519 return JIM_ERR;
520 }
521
522 goi.isconfigure = 0;
523 return jtag_tap_configure_cmd(&goi, t);
524 }
525 break;
526
527 case JTAG_CMD_CONFIGURE:
528 if (goi.argc < 3) {
529 Jim_WrongNumArgs(goi.interp, 0, NULL,
530 "configure tap_name attribute value ...");
531 return JIM_ERR;
532 }
533
534 {
535 jtag_tap_t *t;
536
537 Jim_GetOpt_Obj(&goi, &o);
538 t = jtag_tap_by_jim_obj(goi.interp, o);
539 if (t == NULL) {
540 return JIM_ERR;
541 }
542
543 goi.isconfigure = 1;
544 return jtag_tap_configure_cmd(&goi, t);
545 }
546 break;
547
548 case JTAG_CMD_NAMES:
549 if (goi.argc != 0) {
550 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
551 return JIM_ERR;
552 }
553 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
554 {
555 jtag_tap_t *tap;
556
557 for (tap = jtag_all_taps(); tap; tap = tap->next_tap) {
558 Jim_ListAppendElement(goi.interp,
559 Jim_GetResult(goi.interp),
560 Jim_NewStringObj(goi.interp,
561 tap->dotted_name, -1));
562 }
563 return JIM_OK;
564 }
565 break;
566
567 }
568
569 return JIM_ERR;
570 }
571
572
573 void jtag_notify_event(enum jtag_event event)
574 {
575 jtag_tap_t *tap;
576
577 for (tap = jtag_all_taps(); tap; tap = tap->next_tap)
578 jtag_tap_handle_event(tap, event);
579 }
580
581
582 static int default_khz(int khz, int *jtag_speed)
583 {
584 LOG_ERROR("Translation from khz to jtag_speed not implemented");
585 return ERROR_FAIL;
586 }
587
588 static int default_speed_div(int speed, int *khz)
589 {
590 LOG_ERROR("Translation from jtag_speed to khz not implemented");
591 return ERROR_FAIL;
592 }
593
594 static int default_power_dropout(int *dropout)
595 {
596 *dropout = 0; /* by default we can't detect power dropout */
597 return ERROR_OK;
598 }
599
600 static int default_srst_asserted(int *srst_asserted)
601 {
602 *srst_asserted = 0; /* by default we can't detect srst asserted */
603 return ERROR_OK;
604 }
605
606 COMMAND_HANDLER(handle_interface_list_command)
607 {
608 if (strcmp(CMD_NAME, "interface_list") == 0 && argc > 0)
609 return ERROR_COMMAND_SYNTAX_ERROR;
610
611 command_print(cmd_ctx, "The following JTAG interfaces are available:");
612 for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
613 {
614 const char *name = jtag_interfaces[i]->name;
615 command_print(cmd_ctx, "%u: %s", i + 1, name);
616 }
617
618 return ERROR_OK;
619 }
620
621 COMMAND_HANDLER(handle_interface_command)
622 {
623 /* check whether the interface is already configured */
624 if (jtag_interface)
625 {
626 LOG_WARNING("Interface already configured, ignoring");
627 return ERROR_OK;
628 }
629
630 /* interface name is a mandatory argument */
631 if (argc != 1 || args[0][0] == '\0')
632 return ERROR_COMMAND_SYNTAX_ERROR;
633
634 for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
635 {
636 if (strcmp(args[0], jtag_interfaces[i]->name) != 0)
637 continue;
638
639 int retval = jtag_interfaces[i]->register_commands(cmd_ctx);
640 if (ERROR_OK != retval)
641 return retval;
642
643 jtag_interface = jtag_interfaces[i];
644
645 if (jtag_interface->khz == NULL)
646 jtag_interface->khz = default_khz;
647 if (jtag_interface->speed_div == NULL)
648 jtag_interface->speed_div = default_speed_div;
649 if (jtag_interface->power_dropout == NULL)
650 jtag_interface->power_dropout = default_power_dropout;
651 if (jtag_interface->srst_asserted == NULL)
652 jtag_interface->srst_asserted = default_srst_asserted;
653
654 return ERROR_OK;
655 }
656
657 /* no valid interface was found (i.e. the configuration option,
658 * didn't match one of the compiled-in interfaces
659 */
660 LOG_ERROR("The specified JTAG interface was not found (%s)", args[0]);
661 CALL_COMMAND_HANDLER(handle_interface_list_command);
662 return ERROR_JTAG_INVALID_INTERFACE;
663 }
664
665 COMMAND_HANDLER(handle_scan_chain_command)
666 {
667 jtag_tap_t *tap;
668
669 tap = jtag_all_taps();
670 command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
671 command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
672
673 while (tap) {
674 uint32_t expected, expected_mask, cur_instr, ii;
675 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
676 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
677 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
678
679 command_print(cmd_ctx,
680 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
681 tap->abs_chain_position,
682 tap->dotted_name,
683 tap->enabled ? 'Y' : 'n',
684 (unsigned int)(tap->idcode),
685 (unsigned int)(tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
686 (unsigned int)(tap->ir_length),
687 (unsigned int)(expected),
688 (unsigned int)(expected_mask),
689 (unsigned int)(cur_instr));
690
691 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
692 command_print(cmd_ctx, " | | | | 0x%08x | | | | ",
693 (unsigned int)(tap->expected_ids[ii]));
694 }
695
696 tap = tap->next_tap;
697 }
698
699 return ERROR_OK;
700 }
701
702 COMMAND_HANDLER(handle_reset_config_command)
703 {
704 int new_cfg = 0;
705 int mask = 0;
706
707 /* Original versions cared about the order of these tokens:
708 * reset_config signals [combination [trst_type [srst_type]]]
709 * They also clobbered the previous configuration even on error.
710 *
711 * Here we don't care about the order, and only change values
712 * which have been explicitly specified.
713 */
714 for (; argc; argc--, args++) {
715 int tmp = 0;
716 int m;
717
718 /* gating */
719 m = RESET_SRST_NO_GATING;
720 if (strcmp(*args, "srst_gates_jtag") == 0)
721 /* default: don't use JTAG while SRST asserted */;
722 else if (strcmp(*args, "srst_nogate") == 0)
723 tmp = RESET_SRST_NO_GATING;
724 else
725 m = 0;
726 if (mask & m) {
727 LOG_ERROR("extra reset_config %s spec (%s)",
728 "gating", *args);
729 return ERROR_INVALID_ARGUMENTS;
730 }
731 if (m)
732 goto next;
733
734 /* signals */
735 m = RESET_HAS_TRST | RESET_HAS_SRST;
736 if (strcmp(*args, "none") == 0)
737 tmp = RESET_NONE;
738 else if (strcmp(*args, "trst_only") == 0)
739 tmp = RESET_HAS_TRST;
740 else if (strcmp(*args, "srst_only") == 0)
741 tmp = RESET_HAS_SRST;
742 else if (strcmp(*args, "trst_and_srst") == 0)
743 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
744 else
745 m = 0;
746 if (mask & m) {
747 LOG_ERROR("extra reset_config %s spec (%s)",
748 "signal", *args);
749 return ERROR_INVALID_ARGUMENTS;
750 }
751 if (m)
752 goto next;
753
754 /* combination (options for broken wiring) */
755 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
756 if (strcmp(*args, "separate") == 0)
757 /* separate reset lines - default */;
758 else if (strcmp(*args, "srst_pulls_trst") == 0)
759 tmp |= RESET_SRST_PULLS_TRST;
760 else if (strcmp(*args, "trst_pulls_srst") == 0)
761 tmp |= RESET_TRST_PULLS_SRST;
762 else if (strcmp(*args, "combined") == 0)
763 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
764 else
765 m = 0;
766 if (mask & m) {
767 LOG_ERROR("extra reset_config %s spec (%s)",
768 "combination", *args);
769 return ERROR_INVALID_ARGUMENTS;
770 }
771 if (m)
772 goto next;
773
774 /* trst_type (NOP without HAS_TRST) */
775 m = RESET_TRST_OPEN_DRAIN;
776 if (strcmp(*args, "trst_open_drain") == 0)
777 tmp |= RESET_TRST_OPEN_DRAIN;
778 else if (strcmp(*args, "trst_push_pull") == 0)
779 /* push/pull from adapter - default */;
780 else
781 m = 0;
782 if (mask & m) {
783 LOG_ERROR("extra reset_config %s spec (%s)",
784 "trst_type", *args);
785 return ERROR_INVALID_ARGUMENTS;
786 }
787 if (m)
788 goto next;
789
790 /* srst_type (NOP without HAS_SRST) */
791 m |= RESET_SRST_PUSH_PULL;
792 if (strcmp(*args, "srst_push_pull") == 0)
793 tmp |= RESET_SRST_PUSH_PULL;
794 else if (strcmp(*args, "srst_open_drain") == 0)
795 /* open drain from adapter - default */;
796 else
797 m = 0;
798 if (mask & m) {
799 LOG_ERROR("extra reset_config %s spec (%s)",
800 "srst_type", *args);
801 return ERROR_INVALID_ARGUMENTS;
802 }
803 if (m)
804 goto next;
805
806 /* caller provided nonsense; fail */
807 LOG_ERROR("unknown reset_config flag (%s)", *args);
808 return ERROR_INVALID_ARGUMENTS;
809
810 next:
811 /* Remember the bits which were specified (mask)
812 * and their new values (new_cfg).
813 */
814 mask |= m;
815 new_cfg |= tmp;
816 }
817
818 /* clear previous values of those bits, save new values */
819 if (mask) {
820 int old_cfg = jtag_get_reset_config();
821
822 old_cfg &= ~mask;
823 new_cfg |= old_cfg;
824 jtag_set_reset_config(new_cfg);
825 } else
826 new_cfg = jtag_get_reset_config();
827
828
829 /*
830 * Display the (now-)current reset mode
831 */
832 char *modes[5];
833
834 /* minimal JTAG has neither SRST nor TRST (so that's the default) */
835 switch (new_cfg & (RESET_HAS_TRST | RESET_HAS_SRST)) {
836 case RESET_HAS_SRST:
837 modes[0] = "srst_only";
838 break;
839 case RESET_HAS_TRST:
840 modes[0] = "trst_only";
841 break;
842 case RESET_TRST_AND_SRST:
843 modes[0] = "trst_and_srst";
844 break;
845 default:
846 modes[0] = "none";
847 break;
848 }
849
850 /* normally SRST and TRST are decoupled; but bugs happen ... */
851 switch (new_cfg & (RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST)) {
852 case RESET_SRST_PULLS_TRST:
853 modes[1] = "srst_pulls_trst";
854 break;
855 case RESET_TRST_PULLS_SRST:
856 modes[1] = "trst_pulls_srst";
857 break;
858 case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
859 modes[1] = "combined";
860 break;
861 default:
862 modes[1] = "separate";
863 break;
864 }
865
866 /* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
867 if (new_cfg & RESET_HAS_TRST) {
868 if (new_cfg & RESET_TRST_OPEN_DRAIN)
869 modes[3] = " trst_open_drain";
870 else
871 modes[3] = " trst_push_pull";
872 } else
873 modes[3] = "";
874
875 /* SRST-less connectors include TI-14, Xilinx, and minimal JTAG */
876 if (new_cfg & RESET_HAS_SRST) {
877 if (new_cfg & RESET_SRST_NO_GATING)
878 modes[2] = " srst_nogate";
879 else
880 modes[2] = " srst_gates_jtag";
881
882 if (new_cfg & RESET_SRST_PUSH_PULL)
883 modes[4] = " srst_push_pull";
884 else
885 modes[4] = " srst_open_drain";
886 } else {
887 modes[2] = "";
888 modes[4] = "";
889 }
890
891 command_print(cmd_ctx, "%s %s%s%s%s",
892 modes[0], modes[1],
893 modes[2], modes[3], modes[4]);
894
895 return ERROR_OK;
896 }
897
898 COMMAND_HANDLER(handle_jtag_nsrst_delay_command)
899 {
900 if (argc > 1)
901 return ERROR_COMMAND_SYNTAX_ERROR;
902 if (argc == 1)
903 {
904 unsigned delay;
905 COMMAND_PARSE_NUMBER(uint, args[0], delay);
906
907 jtag_set_nsrst_delay(delay);
908 }
909 command_print(cmd_ctx, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
910 return ERROR_OK;
911 }
912
913 COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
914 {
915 if (argc > 1)
916 return ERROR_COMMAND_SYNTAX_ERROR;
917 if (argc == 1)
918 {
919 unsigned delay;
920 COMMAND_PARSE_NUMBER(uint, args[0], delay);
921
922 jtag_set_ntrst_delay(delay);
923 }
924 command_print(cmd_ctx, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
925 return ERROR_OK;
926 }
927
928 COMMAND_HANDLER(handle_jtag_nsrst_assert_width_command)
929 {
930 if (argc > 1)
931 return ERROR_COMMAND_SYNTAX_ERROR;
932 if (argc == 1)
933 {
934 unsigned delay;
935 COMMAND_PARSE_NUMBER(uint, args[0], delay);
936
937 jtag_set_nsrst_assert_width(delay);
938 }
939 command_print(cmd_ctx, "jtag_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
940 return ERROR_OK;
941 }
942
943 COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
944 {
945 if (argc > 1)
946 return ERROR_COMMAND_SYNTAX_ERROR;
947 if (argc == 1)
948 {
949 unsigned delay;
950 COMMAND_PARSE_NUMBER(uint, args[0], delay);
951
952 jtag_set_ntrst_assert_width(delay);
953 }
954 command_print(cmd_ctx, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
955 return ERROR_OK;
956 }
957
958 COMMAND_HANDLER(handle_jtag_khz_command)
959 {
960 if (argc > 1)
961 return ERROR_COMMAND_SYNTAX_ERROR;
962
963 int retval = ERROR_OK;
964 if (argc == 1)
965 {
966 unsigned khz = 0;
967 COMMAND_PARSE_NUMBER(uint, args[0], khz);
968
969 retval = jtag_config_khz(khz);
970 if (ERROR_OK != retval)
971 return retval;
972 }
973
974 int cur_speed = jtag_get_speed_khz();
975 retval = jtag_get_speed_readable(&cur_speed);
976 if (ERROR_OK != retval)
977 return retval;
978
979 if (cur_speed)
980 command_print(cmd_ctx, "%d kHz", cur_speed);
981 else
982 command_print(cmd_ctx, "RCLK - adaptive");
983
984 return retval;
985 }
986
987 COMMAND_HANDLER(handle_jtag_rclk_command)
988 {
989 if (argc > 1)
990 return ERROR_COMMAND_SYNTAX_ERROR;
991
992 int retval = ERROR_OK;
993 if (argc == 1)
994 {
995 unsigned khz = 0;
996 COMMAND_PARSE_NUMBER(uint, args[0], khz);
997
998 retval = jtag_config_rclk(khz);
999 if (ERROR_OK != retval)
1000 return retval;
1001 }
1002
1003 int cur_khz = jtag_get_speed_khz();
1004 retval = jtag_get_speed_readable(&cur_khz);
1005 if (ERROR_OK != retval)
1006 return retval;
1007
1008 if (cur_khz)
1009 command_print(cmd_ctx, "RCLK not supported - fallback to %d kHz", cur_khz);
1010 else
1011 command_print(cmd_ctx, "RCLK - adaptive");
1012
1013 return retval;
1014 }
1015
1016 COMMAND_HANDLER(handle_jtag_reset_command)
1017 {
1018 if (argc != 2)
1019 return ERROR_COMMAND_SYNTAX_ERROR;
1020
1021 int trst = -1;
1022 if (args[0][0] == '1')
1023 trst = 1;
1024 else if (args[0][0] == '0')
1025 trst = 0;
1026 else
1027 return ERROR_COMMAND_SYNTAX_ERROR;
1028
1029 int srst = -1;
1030 if (args[1][0] == '1')
1031 srst = 1;
1032 else if (args[1][0] == '0')
1033 srst = 0;
1034 else
1035 return ERROR_COMMAND_SYNTAX_ERROR;
1036
1037 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1038 return ERROR_JTAG_INIT_FAILED;
1039
1040 jtag_add_reset(trst, srst);
1041 return jtag_execute_queue();
1042 }
1043
1044 COMMAND_HANDLER(handle_runtest_command)
1045 {
1046 if (argc != 1)
1047 return ERROR_COMMAND_SYNTAX_ERROR;
1048
1049 unsigned num_clocks;
1050 COMMAND_PARSE_NUMBER(uint, args[0], num_clocks);
1051
1052 jtag_add_runtest(num_clocks, TAP_IDLE);
1053 return jtag_execute_queue();
1054 }
1055
1056 /*
1057 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1058 * should be stable ... and *NOT* a shift state, otherwise free-running
1059 * jtag clocks could change the values latched by the update state.
1060 * Not surprisingly, this is the same constraint as SVF; the "irscan"
1061 * and "drscan" commands are a write-only subset of what SVF provides.
1062 */
1063 static bool scan_is_safe(tap_state_t state)
1064 {
1065 switch (state)
1066 {
1067 case TAP_RESET:
1068 case TAP_IDLE:
1069 case TAP_DRPAUSE:
1070 case TAP_IRPAUSE:
1071 return true;
1072 default:
1073 return false;
1074 }
1075 }
1076
1077
1078 COMMAND_HANDLER(handle_irscan_command)
1079 {
1080 int i;
1081 scan_field_t *fields;
1082 jtag_tap_t *tap;
1083 tap_state_t endstate;
1084
1085 if ((argc < 2) || (argc % 2))
1086 {
1087 return ERROR_COMMAND_SYNTAX_ERROR;
1088 }
1089
1090 /* optional "-endstate" "statename" at the end of the arguments,
1091 * so that e.g. IRPAUSE can let us load the data register before
1092 * entering RUN/IDLE to execute the instruction we load here.
1093 */
1094 endstate = TAP_IDLE;
1095
1096 if (argc >= 4) {
1097 /* have at least one pair of numbers. */
1098 /* is last pair the magic text? */
1099 if (strcmp("-endstate", args[argc - 2]) == 0) {
1100 endstate = tap_state_by_name(args[argc - 1]);
1101 if (endstate == TAP_INVALID)
1102 return ERROR_COMMAND_SYNTAX_ERROR;
1103 if (!scan_is_safe(endstate))
1104 LOG_WARNING("unstable irscan endstate \"%s\"",
1105 args[argc - 1]);
1106 argc -= 2;
1107 }
1108 }
1109
1110 int num_fields = argc / 2;
1111 size_t fields_len = sizeof(scan_field_t) * num_fields;
1112 fields = malloc(fields_len);
1113 memset(fields, 0, fields_len);
1114
1115 int retval;
1116 for (i = 0; i < num_fields; i++)
1117 {
1118 tap = jtag_tap_by_string(args[i*2]);
1119 if (tap == NULL)
1120 {
1121 int j;
1122 for (j = 0; j < i; j++)
1123 free(fields[j].out_value);
1124 free(fields);
1125 command_print(cmd_ctx, "Tap: %s unknown", args[i*2]);
1126
1127 return ERROR_FAIL;
1128 }
1129 int field_size = tap->ir_length;
1130 fields[i].tap = tap;
1131 fields[i].num_bits = field_size;
1132 fields[i].out_value = malloc(CEIL(field_size, 8));
1133
1134 uint32_t value;
1135 retval = parse_u32(args[i * 2 + 1], &value);
1136 if (ERROR_OK != retval)
1137 goto error_return;
1138 buf_set_u32(fields[i].out_value, 0, field_size, value);
1139 fields[i].in_value = NULL;
1140 }
1141
1142 /* did we have an endstate? */
1143 jtag_add_ir_scan(num_fields, fields, endstate);
1144
1145 retval = jtag_execute_queue();
1146
1147 error_return:
1148 for (i = 0; i < num_fields; i++)
1149 {
1150 if (NULL != fields[i].out_value)
1151 free(fields[i].out_value);
1152 }
1153
1154 free (fields);
1155
1156 return retval;
1157 }
1158
1159 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1160 {
1161 int retval;
1162 scan_field_t *fields;
1163 int num_fields;
1164 int field_count = 0;
1165 int i, e;
1166 jtag_tap_t *tap;
1167 tap_state_t endstate;
1168
1169 /* args[1] = device
1170 * args[2] = num_bits
1171 * args[3] = hex string
1172 * ... repeat num bits and hex string ...
1173 *
1174 * .. optionally:
1175 * args[N-2] = "-endstate"
1176 * args[N-1] = statename
1177 */
1178 if ((argc < 4) || ((argc % 2) != 0))
1179 {
1180 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1181 return JIM_ERR;
1182 }
1183
1184 endstate = TAP_IDLE;
1185
1186 script_debug(interp, "drscan", argc, args);
1187
1188 /* validate arguments as numbers */
1189 e = JIM_OK;
1190 for (i = 2; i < argc; i += 2)
1191 {
1192 long bits;
1193 const char *cp;
1194
1195 e = Jim_GetLong(interp, args[i], &bits);
1196 /* If valid - try next arg */
1197 if (e == JIM_OK) {
1198 continue;
1199 }
1200
1201 /* Not valid.. are we at the end? */
1202 if (((i + 2) != argc)) {
1203 /* nope, then error */
1204 return e;
1205 }
1206
1207 /* it could be: "-endstate FOO"
1208 * e.g. DRPAUSE so we can issue more instructions
1209 * before entering RUN/IDLE and executing them.
1210 */
1211
1212 /* get arg as a string. */
1213 cp = Jim_GetString(args[i], NULL);
1214 /* is it the magic? */
1215 if (0 == strcmp("-endstate", cp)) {
1216 /* is the statename valid? */
1217 cp = Jim_GetString(args[i + 1], NULL);
1218
1219 /* see if it is a valid state name */
1220 endstate = tap_state_by_name(cp);
1221 if (endstate < 0) {
1222 /* update the error message */
1223 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1224 } else {
1225 if (!scan_is_safe(endstate))
1226 LOG_WARNING("drscan with unsafe "
1227 "endstate \"%s\"", cp);
1228
1229 /* valid - so clear the error */
1230 e = JIM_OK;
1231 /* and remove the last 2 args */
1232 argc -= 2;
1233 }
1234 }
1235
1236 /* Still an error? */
1237 if (e != JIM_OK) {
1238 return e; /* too bad */
1239 }
1240 } /* validate args */
1241
1242 tap = jtag_tap_by_jim_obj(interp, args[1]);
1243 if (tap == NULL) {
1244 return JIM_ERR;
1245 }
1246
1247 num_fields = (argc-2)/2;
1248 fields = malloc(sizeof(scan_field_t) * num_fields);
1249 for (i = 2; i < argc; i += 2)
1250 {
1251 long bits;
1252 int len;
1253 const char *str;
1254
1255 Jim_GetLong(interp, args[i], &bits);
1256 str = Jim_GetString(args[i + 1], &len);
1257
1258 fields[field_count].tap = tap;
1259 fields[field_count].num_bits = bits;
1260 fields[field_count].out_value = malloc(CEIL(bits, 8));
1261 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
1262 fields[field_count].in_value = fields[field_count].out_value;
1263 field_count++;
1264 }
1265
1266 jtag_add_dr_scan(num_fields, fields, endstate);
1267
1268 retval = jtag_execute_queue();
1269 if (retval != ERROR_OK)
1270 {
1271 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
1272 return JIM_ERR;
1273 }
1274
1275 field_count = 0;
1276 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1277 for (i = 2; i < argc; i += 2)
1278 {
1279 long bits;
1280 char *str;
1281
1282 Jim_GetLong(interp, args[i], &bits);
1283 str = buf_to_str(fields[field_count].in_value, bits, 16);
1284 free(fields[field_count].out_value);
1285
1286 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
1287 free(str);
1288 field_count++;
1289 }
1290
1291 Jim_SetResult(interp, list);
1292
1293 free(fields);
1294
1295 return JIM_OK;
1296 }
1297
1298
1299 static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1300 {
1301 tap_state_t states[8];
1302
1303 if ((argc < 2) || ((size_t)argc > (sizeof(states)/sizeof(*states) + 1)))
1304 {
1305 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1306 return JIM_ERR;
1307 }
1308
1309 script_debug(interp, "pathmove", argc, args);
1310
1311 int i;
1312 for (i = 0; i < argc-1; i++)
1313 {
1314 const char *cp;
1315 cp = Jim_GetString(args[i + 1], NULL);
1316 states[i] = tap_state_by_name(cp);
1317 if (states[i] < 0)
1318 {
1319 /* update the error message */
1320 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1321 return JIM_ERR;
1322 }
1323 }
1324
1325 if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
1326 {
1327 Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
1328 return JIM_ERR;
1329 }
1330
1331 jtag_add_pathmove(argc-2, states + 1);
1332
1333 if (jtag_execute_queue()!= ERROR_OK)
1334 {
1335 Jim_SetResultString(interp, "pathmove: failed",-1);
1336 return JIM_ERR;
1337 }
1338
1339 return JIM_OK;
1340 }
1341
1342
1343 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1344 {
1345 script_debug(interp, "flush_count", argc, args);
1346
1347 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
1348
1349 return JIM_OK;
1350 }
1351
1352
1353 COMMAND_HANDLER(handle_verify_ircapture_command)
1354 {
1355 if (argc > 1)
1356 return ERROR_COMMAND_SYNTAX_ERROR;
1357
1358 if (argc == 1)
1359 {
1360 if (strcmp(args[0], "enable") == 0)
1361 jtag_set_verify_capture_ir(true);
1362 else if (strcmp(args[0], "disable") == 0)
1363 jtag_set_verify_capture_ir(false);
1364 else
1365 return ERROR_COMMAND_SYNTAX_ERROR;
1366 }
1367
1368 const char *status = jtag_will_verify_capture_ir() ? "enabled": "disabled";
1369 command_print(cmd_ctx, "verify Capture-IR is %s", status);
1370
1371 return ERROR_OK;
1372 }
1373
1374 COMMAND_HANDLER(handle_verify_jtag_command)
1375 {
1376 if (argc > 1)
1377 return ERROR_COMMAND_SYNTAX_ERROR;
1378
1379 if (argc == 1)
1380 {
1381 if (strcmp(args[0], "enable") == 0)
1382 jtag_set_verify(true);
1383 else if (strcmp(args[0], "disable") == 0)
1384 jtag_set_verify(false);
1385 else
1386 return ERROR_COMMAND_SYNTAX_ERROR;
1387 }
1388
1389 const char *status = jtag_will_verify() ? "enabled": "disabled";
1390 command_print(cmd_ctx, "verify jtag capture is %s", status);
1391
1392 return ERROR_OK;
1393 }
1394
1395 COMMAND_HANDLER(handle_tms_sequence_command)
1396 {
1397 if (argc > 1)
1398 return ERROR_COMMAND_SYNTAX_ERROR;
1399
1400 if (argc == 1)
1401 {
1402 bool use_new_table;
1403 if (strcmp(args[0], "short") == 0)
1404 use_new_table = true;
1405 else if (strcmp(args[0], "long") == 0)
1406 use_new_table = false;
1407 else
1408 return ERROR_COMMAND_SYNTAX_ERROR;
1409
1410 tap_use_new_tms_table(use_new_table);
1411 }
1412
1413 command_print(cmd_ctx, "tms sequence is %s",
1414 tap_uses_new_tms_table() ? "short": "long");
1415
1416 return ERROR_OK;
1417 }
1418
1419 int jtag_register_commands(struct command_context_s *cmd_ctx)
1420 {
1421 register_jim(cmd_ctx, "jtag", jim_jtag_command,
1422 "perform jtag tap actions");
1423
1424 register_command(cmd_ctx, NULL, "interface",
1425 handle_interface_command, COMMAND_CONFIG,
1426 "try to configure interface");
1427 register_command(cmd_ctx, NULL, "interface_list",
1428 &handle_interface_list_command, COMMAND_ANY,
1429 "list all built-in interfaces");
1430
1431 register_command(cmd_ctx, NULL, "jtag_khz",
1432 handle_jtag_khz_command, COMMAND_ANY,
1433 "set maximum jtag speed (if supported); "
1434 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1435 register_command(cmd_ctx, NULL, "jtag_rclk",
1436 handle_jtag_rclk_command, COMMAND_ANY,
1437 "fallback_speed_khz - set JTAG speed to RCLK or use fallback speed");
1438 register_command(cmd_ctx, NULL, "reset_config",
1439 handle_reset_config_command, COMMAND_ANY,
1440 "reset_config "
1441 "[none|trst_only|srst_only|trst_and_srst] "
1442 "[srst_pulls_trst|trst_pulls_srst|combined|separate] "
1443 "[srst_gates_jtag|srst_nogate] "
1444 "[trst_push_pull|trst_open_drain] "
1445 "[srst_push_pull|srst_open_drain]");
1446
1447 register_command(cmd_ctx, NULL, "jtag_nsrst_delay",
1448 handle_jtag_nsrst_delay_command, COMMAND_ANY,
1449 "jtag_nsrst_delay <ms> "
1450 "- delay after deasserting srst in ms");
1451 register_command(cmd_ctx, NULL, "jtag_ntrst_delay",
1452 handle_jtag_ntrst_delay_command, COMMAND_ANY,
1453 "jtag_ntrst_delay <ms> "
1454 "- delay after deasserting trst in ms");
1455
1456 register_command(cmd_ctx, NULL, "jtag_nsrst_assert_width",
1457 handle_jtag_nsrst_assert_width_command, COMMAND_ANY,
1458 "jtag_nsrst_assert_width <ms> "
1459 "- delay after asserting srst in ms");
1460 register_command(cmd_ctx, NULL, "jtag_ntrst_assert_width",
1461 handle_jtag_ntrst_assert_width_command, COMMAND_ANY,
1462 "jtag_ntrst_assert_width <ms> "
1463 "- delay after asserting trst in ms");
1464
1465 register_command(cmd_ctx, NULL, "scan_chain",
1466 handle_scan_chain_command, COMMAND_EXEC,
1467 "print current scan chain configuration");
1468
1469 register_command(cmd_ctx, NULL, "jtag_reset",
1470 handle_jtag_reset_command, COMMAND_EXEC,
1471 "toggle reset lines <trst> <srst>");
1472 register_command(cmd_ctx, NULL, "runtest",
1473 handle_runtest_command, COMMAND_EXEC,
1474 "move to Run-Test/Idle, and execute <num_cycles>");
1475 register_command(cmd_ctx, NULL, "irscan",
1476 handle_irscan_command, COMMAND_EXEC,
1477 "execute IR scan <device> <instr> [dev2] [instr2] ...");
1478
1479 register_jim(cmd_ctx, "drscan", Jim_Command_drscan,
1480 "execute DR scan <device> "
1481 "<num_bits> <value> <num_bits1> <value2> ...");
1482
1483 register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count,
1484 "returns number of times the JTAG queue has been flushed");
1485
1486 register_jim(cmd_ctx, "pathmove", Jim_Command_pathmove,
1487 "<state1>,<state2>,<state3>... "
1488 "- move JTAG to state1 then to state2, state3, etc.");
1489
1490 register_command(cmd_ctx, NULL, "verify_ircapture",
1491 handle_verify_ircapture_command, COMMAND_ANY,
1492 "verify value captured during Capture-IR <enable | disable>");
1493 register_command(cmd_ctx, NULL, "verify_jtag",
1494 handle_verify_jtag_command, COMMAND_ANY,
1495 "verify value capture <enable | disable>");
1496
1497 register_command(cmd_ctx, NULL, "tms_sequence",
1498 handle_tms_sequence_command, COMMAND_ANY,
1499 "choose short(default) or long tms_sequence <short | long>");
1500
1501 return ERROR_OK;
1502 }
1503
1504

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)