topic: add reset functions for SWD
[openocd.git] / src / jtag / tcl.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007-2010 √ė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
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include "jtag.h"
36 #include "swd.h"
37 #include "minidriver.h"
38 #include "interface.h"
39 #include "interfaces.h"
40 #include "tcl.h"
41
42 #ifdef HAVE_STRINGS_H
43 #include <strings.h>
44 #endif
45
46 #include <helper/time_support.h>
47
48 /**
49 * @file
50 * Holds support for accessing JTAG-specific mechanisms from TCl scripts.
51 */
52
53 static const Jim_Nvp nvp_jtag_tap_event[] = {
54 { .value = JTAG_TRST_ASSERTED, .name = "post-reset" },
55 { .value = JTAG_TAP_EVENT_SETUP, .name = "setup" },
56 { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" },
57 { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" },
58
59 { .name = NULL, .value = -1 }
60 };
61
62 extern struct jtag_interface *jtag_interface;
63
64 struct jtag_tap *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o)
65 {
66 const char *cp = Jim_GetString(o, NULL);
67 struct jtag_tap *t = cp ? jtag_tap_by_string(cp) : NULL;
68 if (NULL == cp)
69 cp = "(unknown)";
70 if (NULL == t)
71 Jim_SetResultFormatted(interp, "Tap '%s' could not be found", cp);
72 return t;
73 }
74
75 static bool scan_is_safe(tap_state_t state)
76 {
77 switch (state) {
78 case TAP_RESET:
79 case TAP_IDLE:
80 case TAP_DRPAUSE:
81 case TAP_IRPAUSE:
82 return true;
83 default:
84 return false;
85 }
86 }
87
88 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
89 {
90 int retval;
91 struct scan_field *fields;
92 int num_fields;
93 int field_count = 0;
94 int i, e;
95 struct jtag_tap *tap;
96 tap_state_t endstate;
97
98 /* args[1] = device
99 * args[2] = num_bits
100 * args[3] = hex string
101 * ... repeat num bits and hex string ...
102 *
103 * .. optionally:
104 * args[N-2] = "-endstate"
105 * args[N-1] = statename
106 */
107 if ((argc < 4) || ((argc % 2) != 0)) {
108 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
109 return JIM_ERR;
110 }
111
112 endstate = TAP_IDLE;
113
114 script_debug(interp, "drscan", argc, args);
115
116 /* validate arguments as numbers */
117 e = JIM_OK;
118 for (i = 2; i < argc; i += 2) {
119 long bits;
120 const char *cp;
121
122 e = Jim_GetLong(interp, args[i], &bits);
123 /* If valid - try next arg */
124 if (e == JIM_OK)
125 continue;
126
127 /* Not valid.. are we at the end? */
128 if (((i + 2) != argc)) {
129 /* nope, then error */
130 return e;
131 }
132
133 /* it could be: "-endstate FOO"
134 * e.g. DRPAUSE so we can issue more instructions
135 * before entering RUN/IDLE and executing them.
136 */
137
138 /* get arg as a string. */
139 cp = Jim_GetString(args[i], NULL);
140 /* is it the magic? */
141 if (0 == strcmp("-endstate", cp)) {
142 /* is the statename valid? */
143 cp = Jim_GetString(args[i + 1], NULL);
144
145 /* see if it is a valid state name */
146 endstate = tap_state_by_name(cp);
147 if (endstate < 0) {
148 /* update the error message */
149 Jim_SetResultFormatted(interp, "endstate: %s invalid", cp);
150 } else {
151 if (!scan_is_safe(endstate))
152 LOG_WARNING("drscan with unsafe "
153 "endstate \"%s\"", cp);
154
155 /* valid - so clear the error */
156 e = JIM_OK;
157 /* and remove the last 2 args */
158 argc -= 2;
159 }
160 }
161
162 /* Still an error? */
163 if (e != JIM_OK)
164 return e; /* too bad */
165 } /* validate args */
166
167 assert(e == JIM_OK);
168
169 tap = jtag_tap_by_jim_obj(interp, args[1]);
170 if (tap == NULL)
171 return JIM_ERR;
172
173 num_fields = (argc-2)/2;
174 assert(num_fields > 0);
175 fields = malloc(sizeof(struct scan_field) * num_fields);
176 for (i = 2; i < argc; i += 2) {
177 long bits;
178 int len;
179 const char *str;
180
181 Jim_GetLong(interp, args[i], &bits);
182 str = Jim_GetString(args[i + 1], &len);
183
184 fields[field_count].num_bits = bits;
185 void *t = malloc(DIV_ROUND_UP(bits, 8));
186 fields[field_count].out_value = t;
187 str_to_buf(str, len, t, bits, 0);
188 fields[field_count].in_value = t;
189 field_count++;
190 }
191
192 jtag_add_dr_scan(tap, num_fields, fields, endstate);
193
194 retval = jtag_execute_queue();
195 if (retval != ERROR_OK) {
196 Jim_SetResultString(interp, "drscan: jtag execute failed", -1);
197 return JIM_ERR;
198 }
199
200 field_count = 0;
201 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
202 for (i = 2; i < argc; i += 2) {
203 long bits;
204 char *str;
205
206 Jim_GetLong(interp, args[i], &bits);
207 str = buf_to_str(fields[field_count].in_value, bits, 16);
208 free((void *)fields[field_count].out_value);
209
210 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
211 free(str);
212 field_count++;
213 }
214
215 Jim_SetResult(interp, list);
216
217 free(fields);
218
219 return JIM_OK;
220 }
221
222
223 static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
224 {
225 tap_state_t states[8];
226
227 if ((argc < 2) || ((size_t)argc > (ARRAY_SIZE(states) + 1))) {
228 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
229 return JIM_ERR;
230 }
231
232 script_debug(interp, "pathmove", argc, args);
233
234 int i;
235 for (i = 0; i < argc-1; i++) {
236 const char *cp;
237 cp = Jim_GetString(args[i + 1], NULL);
238 states[i] = tap_state_by_name(cp);
239 if (states[i] < 0) {
240 /* update the error message */
241 Jim_SetResultFormatted(interp, "endstate: %s invalid", cp);
242 return JIM_ERR;
243 }
244 }
245
246 if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue() != ERROR_OK)) {
247 Jim_SetResultString(interp, "pathmove: jtag execute failed", -1);
248 return JIM_ERR;
249 }
250
251 jtag_add_pathmove(argc - 2, states + 1);
252
253 if (jtag_execute_queue() != ERROR_OK) {
254 Jim_SetResultString(interp, "pathmove: failed", -1);
255 return JIM_ERR;
256 }
257
258 return JIM_OK;
259 }
260
261
262 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
263 {
264 script_debug(interp, "flush_count", argc, args);
265
266 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
267
268 return JIM_OK;
269 }
270
271 /* REVISIT Just what about these should "move" ... ?
272 * These registrations, into the main JTAG table?
273 *
274 * There's a minor compatibility issue, these all show up twice;
275 * that's not desirable:
276 * - jtag drscan ... NOT DOCUMENTED!
277 * - drscan ...
278 *
279 * The "irscan" command (for example) doesn't show twice.
280 */
281 static const struct command_registration jtag_command_handlers_to_move[] = {
282 {
283 .name = "drscan",
284 .mode = COMMAND_EXEC,
285 .jim_handler = Jim_Command_drscan,
286 .help = "Execute Data Register (DR) scan for one TAP. "
287 "Other TAPs must be in BYPASS mode.",
288 .usage = "tap_name [num_bits value]* ['-endstate' state_name]",
289 },
290 {
291 .name = "flush_count",
292 .mode = COMMAND_EXEC,
293 .jim_handler = Jim_Command_flush_count,
294 .help = "Returns the number of times the JTAG queue "
295 "has been flushed.",
296 },
297 {
298 .name = "pathmove",
299 .mode = COMMAND_EXEC,
300 .jim_handler = Jim_Command_pathmove,
301 .usage = "start_state state1 [state2 [state3 ...]]",
302 .help = "Move JTAG state machine from current state "
303 "(start_state) to state1, then state2, state3, etc.",
304 },
305 COMMAND_REGISTRATION_DONE
306 };
307
308
309 enum jtag_tap_cfg_param {
310 JCFG_EVENT
311 };
312
313 static Jim_Nvp nvp_config_opts[] = {
314 { .name = "-event", .value = JCFG_EVENT },
315
316 { .name = NULL, .value = -1 }
317 };
318
319 static int jtag_tap_configure_event(Jim_GetOptInfo *goi, struct jtag_tap *tap)
320 {
321 if (goi->argc == 0) {
322 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name> ...");
323 return JIM_ERR;
324 }
325
326 Jim_Nvp *n;
327 int e = Jim_GetOpt_Nvp(goi, nvp_jtag_tap_event, &n);
328 if (e != JIM_OK) {
329 Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
330 return e;
331 }
332
333 if (goi->isconfigure) {
334 if (goi->argc != 1) {
335 Jim_WrongNumArgs(goi->interp,
336 goi->argc,
337 goi->argv,
338 "-event <event-name> <event-body>");
339 return JIM_ERR;
340 }
341 } else {
342 if (goi->argc != 0) {
343 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event <event-name>");
344 return JIM_ERR;
345 }
346 }
347
348 struct jtag_tap_event_action *jteap = tap->event_action;
349 /* replace existing event body */
350 bool found = false;
351 while (jteap) {
352 if (jteap->event == (enum jtag_event)n->value) {
353 found = true;
354 break;
355 }
356 jteap = jteap->next;
357 }
358
359 Jim_SetEmptyResult(goi->interp);
360
361 if (goi->isconfigure) {
362 if (!found)
363 jteap = calloc(1, sizeof(*jteap));
364 else if (NULL != jteap->body)
365 Jim_DecrRefCount(goi->interp, jteap->body);
366
367 jteap->interp = goi->interp;
368 jteap->event = n->value;
369
370 Jim_Obj *o;
371 Jim_GetOpt_Obj(goi, &o);
372 jteap->body = Jim_DuplicateObj(goi->interp, o);
373 Jim_IncrRefCount(jteap->body);
374
375 if (!found) {
376 /* add to head of event list */
377 jteap->next = tap->event_action;
378 tap->event_action = jteap;
379 }
380 } else if (found) {
381 jteap->interp = goi->interp;
382 Jim_SetResult(goi->interp,
383 Jim_DuplicateObj(goi->interp, jteap->body));
384 }
385 return JIM_OK;
386 }
387
388 static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, struct jtag_tap *tap)
389 {
390 /* parse config or cget options */
391 while (goi->argc > 0) {
392 Jim_SetEmptyResult(goi->interp);
393
394 Jim_Nvp *n;
395 int e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
396 if (e != JIM_OK) {
397 Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
398 return e;
399 }
400
401 switch (n->value) {
402 case JCFG_EVENT:
403 e = jtag_tap_configure_event(goi, tap);
404 if (e != JIM_OK)
405 return e;
406 break;
407 default:
408 Jim_SetResultFormatted(goi->interp, "unknown event: %s", n->name);
409 return JIM_ERR;
410 }
411 }
412
413 return JIM_OK;
414 }
415
416 static int is_bad_irval(int ir_length, jim_wide w)
417 {
418 jim_wide v = 1;
419
420 v <<= ir_length;
421 v -= 1;
422 v = ~v;
423 return (w & v) != 0;
424 }
425
426 static int jim_newtap_expected_id(Jim_Nvp *n, Jim_GetOptInfo *goi,
427 struct jtag_tap *pTap)
428 {
429 jim_wide w;
430 int e = Jim_GetOpt_Wide(goi, &w);
431 if (e != JIM_OK) {
432 Jim_SetResultFormatted(goi->interp, "option: %s bad parameter", n->name);
433 return e;
434 }
435
436 unsigned expected_len = sizeof(uint32_t) * pTap->expected_ids_cnt;
437 uint32_t *new_expected_ids = malloc(expected_len + sizeof(uint32_t));
438 if (new_expected_ids == NULL) {
439 Jim_SetResultFormatted(goi->interp, "no memory");
440 return JIM_ERR;
441 }
442
443 memcpy(new_expected_ids, pTap->expected_ids, expected_len);
444
445 new_expected_ids[pTap->expected_ids_cnt] = w;
446
447 free(pTap->expected_ids);
448 pTap->expected_ids = new_expected_ids;
449 pTap->expected_ids_cnt++;
450
451 return JIM_OK;
452 }
453
454 #define NTAP_OPT_IRLEN 0
455 #define NTAP_OPT_IRMASK 1
456 #define NTAP_OPT_IRCAPTURE 2
457 #define NTAP_OPT_ENABLED 3
458 #define NTAP_OPT_DISABLED 4
459 #define NTAP_OPT_EXPECTED_ID 5
460 #define NTAP_OPT_VERSION 6
461
462 static int jim_newtap_ir_param(Jim_Nvp *n, Jim_GetOptInfo *goi,
463 struct jtag_tap *pTap)
464 {
465 jim_wide w;
466 int e = Jim_GetOpt_Wide(goi, &w);
467 if (e != JIM_OK) {
468 Jim_SetResultFormatted(goi->interp,
469 "option: %s bad parameter", n->name);
470 free((void *)pTap->dotted_name);
471 return e;
472 }
473 switch (n->value) {
474 case NTAP_OPT_IRLEN:
475 if (w > (jim_wide) (8 * sizeof(pTap->ir_capture_value))) {
476 LOG_WARNING("%s: huge IR length %d",
477 pTap->dotted_name, (int) w);
478 }
479 pTap->ir_length = w;
480 break;
481 case NTAP_OPT_IRMASK:
482 if (is_bad_irval(pTap->ir_length, w)) {
483 LOG_ERROR("%s: IR mask %x too big",
484 pTap->dotted_name,
485 (int) w);
486 return JIM_ERR;
487 }
488 if ((w & 3) != 3)
489 LOG_WARNING("%s: nonstandard IR mask", pTap->dotted_name);
490 pTap->ir_capture_mask = w;
491 break;
492 case NTAP_OPT_IRCAPTURE:
493 if (is_bad_irval(pTap->ir_length, w)) {
494 LOG_ERROR("%s: IR capture %x too big",
495 pTap->dotted_name, (int) w);
496 return JIM_ERR;
497 }
498 if ((w & 3) != 1)
499 LOG_WARNING("%s: nonstandard IR value",
500 pTap->dotted_name);
501 pTap->ir_capture_value = w;
502 break;
503 default:
504 return JIM_ERR;
505 }
506 return JIM_OK;
507 }
508
509 static int jim_newtap_cmd(Jim_GetOptInfo *goi)
510 {
511 struct jtag_tap *pTap;
512 int x;
513 int e;
514 Jim_Nvp *n;
515 char *cp;
516 const Jim_Nvp opts[] = {
517 { .name = "-irlen", .value = NTAP_OPT_IRLEN },
518 { .name = "-irmask", .value = NTAP_OPT_IRMASK },
519 { .name = "-ircapture", .value = NTAP_OPT_IRCAPTURE },
520 { .name = "-enable", .value = NTAP_OPT_ENABLED },
521 { .name = "-disable", .value = NTAP_OPT_DISABLED },
522 { .name = "-expected-id", .value = NTAP_OPT_EXPECTED_ID },
523 { .name = "-ignore-version", .value = NTAP_OPT_VERSION },
524 { .name = NULL, .value = -1 },
525 };
526
527 pTap = calloc(1, sizeof(struct jtag_tap));
528 if (!pTap) {
529 Jim_SetResultFormatted(goi->interp, "no memory");
530 return JIM_ERR;
531 }
532
533 /*
534 * we expect CHIP + TAP + OPTIONS
535 * */
536 if (goi->argc < 3) {
537 Jim_SetResultFormatted(goi->interp, "Missing CHIP TAP OPTIONS ....");
538 free(pTap);
539 return JIM_ERR;
540 }
541 Jim_GetOpt_String(goi, &cp, NULL);
542 pTap->chip = strdup(cp);
543
544 Jim_GetOpt_String(goi, &cp, NULL);
545 pTap->tapname = strdup(cp);
546
547 /* name + dot + name + null */
548 x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
549 cp = malloc(x);
550 sprintf(cp, "%s.%s", pTap->chip, pTap->tapname);
551 pTap->dotted_name = cp;
552
553 LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
554 pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
555
556 /* IEEE specifies that the two LSBs of an IR scan are 01, so make
557 * that the default. The "-irlen" and "-irmask" options are only
558 * needed to cope with nonstandard TAPs, or to specify more bits.
559 */
560 pTap->ir_capture_mask = 0x03;
561 pTap->ir_capture_value = 0x01;
562
563 while (goi->argc) {
564 e = Jim_GetOpt_Nvp(goi, opts, &n);
565 if (e != JIM_OK) {
566 Jim_GetOpt_NvpUnknown(goi, opts, 0);
567 free((void *)pTap->dotted_name);
568 free(pTap);
569 return e;
570 }
571 LOG_DEBUG("Processing option: %s", n->name);
572 switch (n->value) {
573 case NTAP_OPT_ENABLED:
574 pTap->disabled_after_reset = false;
575 break;
576 case NTAP_OPT_DISABLED:
577 pTap->disabled_after_reset = true;
578 break;
579 case NTAP_OPT_EXPECTED_ID:
580 e = jim_newtap_expected_id(n, goi, pTap);
581 if (JIM_OK != e) {
582 free((void *)pTap->dotted_name);
583 free(pTap);
584 return e;
585 }
586 break;
587 case NTAP_OPT_IRLEN:
588 case NTAP_OPT_IRMASK:
589 case NTAP_OPT_IRCAPTURE:
590 e = jim_newtap_ir_param(n, goi, pTap);
591 if (JIM_OK != e) {
592 free((void *)pTap->dotted_name);
593 free(pTap);
594 return e;
595 }
596 break;
597 case NTAP_OPT_VERSION:
598 pTap->ignore_version = true;
599 break;
600 } /* switch (n->value) */
601 } /* while (goi->argc) */
602
603 /* default is enabled-after-reset */
604 pTap->enabled = !pTap->disabled_after_reset;
605
606 /* Did all the required option bits get cleared? */
607 if (pTap->ir_length != 0) {
608 jtag_tap_init(pTap);
609 return JIM_OK;
610 }
611
612 Jim_SetResultFormatted(goi->interp,
613 "newtap: %s missing IR length",
614 pTap->dotted_name);
615 jtag_tap_free(pTap);
616 return JIM_ERR;
617 }
618
619 static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e)
620 {
621 struct jtag_tap_event_action *jteap;
622
623 for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next) {
624 if (jteap->event != e)
625 continue;
626
627 Jim_Nvp *nvp = Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e);
628 LOG_DEBUG("JTAG tap: %s event: %d (%s)\n\taction: %s",
629 tap->dotted_name, e, nvp->name,
630 Jim_GetString(jteap->body, NULL));
631
632 if (Jim_EvalObj(jteap->interp, jteap->body) != JIM_OK) {
633 Jim_MakeErrorMessage(jteap->interp);
634 LOG_USER("%s", Jim_GetString(Jim_GetResult(jteap->interp), NULL));
635 continue;
636 }
637
638 switch (e) {
639 case JTAG_TAP_EVENT_ENABLE:
640 case JTAG_TAP_EVENT_DISABLE:
641 /* NOTE: we currently assume the handlers
642 * can't fail. Right here is where we should
643 * really be verifying the scan chains ...
644 */
645 tap->enabled = (e == JTAG_TAP_EVENT_ENABLE);
646 LOG_INFO("JTAG tap: %s %s", tap->dotted_name,
647 tap->enabled ? "enabled" : "disabled");
648 break;
649 default:
650 break;
651 }
652 }
653 }
654
655 static int jim_jtag_arp_init(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
656 {
657 Jim_GetOptInfo goi;
658 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
659 if (goi.argc != 0) {
660 Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
661 return JIM_ERR;
662 }
663 struct command_context *context = current_command_context(interp);
664 int e = jtag_init_inner(context);
665 if (e != ERROR_OK) {
666 Jim_Obj *eObj = Jim_NewIntObj(goi.interp, e);
667 Jim_SetResultFormatted(goi.interp, "error: %#s", eObj);
668 Jim_FreeNewObj(goi.interp, eObj);
669 return JIM_ERR;
670 }
671 return JIM_OK;
672 }
673
674 static int jim_jtag_arp_init_reset(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
675 {
676 int e = ERROR_OK;
677 Jim_GetOptInfo goi;
678 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
679 if (goi.argc != 0) {
680 Jim_WrongNumArgs(goi.interp, 1, goi.argv-1, "(no params)");
681 return JIM_ERR;
682 }
683 struct command_context *context = current_command_context(interp);
684 if (transport_is_jtag())
685 e = jtag_init_reset(context);
686 else if (transport_is_swd())
687 e = swd_init_reset(context);
688
689 if (e != ERROR_OK) {
690 Jim_Obj *eObj = Jim_NewIntObj(goi.interp, e);
691 Jim_SetResultFormatted(goi.interp, "error: %#s", eObj);
692 Jim_FreeNewObj(goi.interp, eObj);
693 return JIM_ERR;
694 }
695 return JIM_OK;
696 }
697
698 int jim_jtag_newtap(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
699 {
700 Jim_GetOptInfo goi;
701 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
702 return jim_newtap_cmd(&goi);
703 }
704
705 static bool jtag_tap_enable(struct jtag_tap *t)
706 {
707 if (t->enabled)
708 return false;
709 jtag_tap_handle_event(t, JTAG_TAP_EVENT_ENABLE);
710 if (!t->enabled)
711 return false;
712
713 /* FIXME add JTAG sanity checks, w/o TLR
714 * - scan chain length grew by one (this)
715 * - IDs and IR lengths are as expected
716 */
717 jtag_call_event_callbacks(JTAG_TAP_EVENT_ENABLE);
718 return true;
719 }
720 static bool jtag_tap_disable(struct jtag_tap *t)
721 {
722 if (!t->enabled)
723 return false;
724 jtag_tap_handle_event(t, JTAG_TAP_EVENT_DISABLE);
725 if (t->enabled)
726 return false;
727
728 /* FIXME add JTAG sanity checks, w/o TLR
729 * - scan chain length shrank by one (this)
730 * - IDs and IR lengths are as expected
731 */
732 jtag_call_event_callbacks(JTAG_TAP_EVENT_DISABLE);
733 return true;
734 }
735
736 int jim_jtag_tap_enabler(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
737 {
738 const char *cmd_name = Jim_GetString(argv[0], NULL);
739 Jim_GetOptInfo goi;
740 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
741 if (goi.argc != 1) {
742 Jim_SetResultFormatted(goi.interp, "usage: %s <name>", cmd_name);
743 return JIM_ERR;
744 }
745
746 struct jtag_tap *t;
747
748 t = jtag_tap_by_jim_obj(goi.interp, goi.argv[0]);
749 if (t == NULL)
750 return JIM_ERR;
751
752 if (strcasecmp(cmd_name, "tapisenabled") == 0) {
753 /* do nothing, just return the value */
754 } else if (strcasecmp(cmd_name, "tapenable") == 0) {
755 if (!jtag_tap_enable(t)) {
756 LOG_WARNING("failed to enable tap %s", t->dotted_name);
757 return JIM_ERR;
758 }
759 } else if (strcasecmp(cmd_name, "tapdisable") == 0) {
760 if (!jtag_tap_disable(t)) {
761 LOG_WARNING("failed to disable tap %s", t->dotted_name);
762 return JIM_ERR;
763 }
764 } else {
765 LOG_ERROR("command '%s' unknown", cmd_name);
766 return JIM_ERR;
767 }
768 bool e = t->enabled;
769 Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, e));
770 return JIM_OK;
771 }
772
773 int jim_jtag_configure(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
774 {
775 const char *cmd_name = Jim_GetString(argv[0], NULL);
776 Jim_GetOptInfo goi;
777 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
778 goi.isconfigure = !strcmp(cmd_name, "configure");
779 if (goi.argc < 2 + goi.isconfigure) {
780 Jim_WrongNumArgs(goi.interp, 0, NULL,
781 "<tap_name> <attribute> ...");
782 return JIM_ERR;
783 }
784
785 struct jtag_tap *t;
786
787 Jim_Obj *o;
788 Jim_GetOpt_Obj(&goi, &o);
789 t = jtag_tap_by_jim_obj(goi.interp, o);
790 if (t == NULL)
791 return JIM_ERR;
792
793 return jtag_tap_configure_cmd(&goi, t);
794 }
795
796 static int jim_jtag_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
797 {
798 Jim_GetOptInfo goi;
799 Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
800 if (goi.argc != 0) {
801 Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
802 return JIM_ERR;
803 }
804 Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
805 struct jtag_tap *tap;
806
807 for (tap = jtag_all_taps(); tap; tap = tap->next_tap) {
808 Jim_ListAppendElement(goi.interp,
809 Jim_GetResult(goi.interp),
810 Jim_NewStringObj(goi.interp,
811 tap->dotted_name, -1));
812 }
813 return JIM_OK;
814 }
815
816 COMMAND_HANDLER(handle_jtag_init_command)
817 {
818 if (CMD_ARGC != 0)
819 return ERROR_COMMAND_SYNTAX_ERROR;
820
821 static bool jtag_initialized;
822 if (jtag_initialized) {
823 LOG_INFO("'jtag init' has already been called");
824 return ERROR_OK;
825 }
826 jtag_initialized = true;
827
828 LOG_DEBUG("Initializing jtag devices...");
829 return jtag_init(CMD_CTX);
830 }
831
832 static const struct command_registration jtag_subcommand_handlers[] = {
833 {
834 .name = "init",
835 .mode = COMMAND_ANY,
836 .handler = handle_jtag_init_command,
837 .help = "initialize jtag scan chain",
838 .usage = ""
839 },
840 {
841 .name = "arp_init",
842 .mode = COMMAND_ANY,
843 .jim_handler = jim_jtag_arp_init,
844 .help = "Validates JTAG scan chain against the list of "
845 "declared TAPs using just the four standard JTAG "
846 "signals.",
847 },
848 {
849 .name = "arp_init-reset",
850 .mode = COMMAND_ANY,
851 .jim_handler = jim_jtag_arp_init_reset,
852 .help = "Uses TRST and SRST to try resetting everything on "
853 "the JTAG scan chain, then performs 'jtag arp_init'."
854 },
855 {
856 .name = "newtap",
857 .mode = COMMAND_CONFIG,
858 .jim_handler = jim_jtag_newtap,
859 .help = "Create a new TAP instance named basename.tap_type, "
860 "and appends it to the scan chain.",
861 .usage = "basename tap_type '-irlen' count "
862 "['-enable'|'-disable'] "
863 "['-expected_id' number] "
864 "['-ignore-version'] "
865 "['-ircapture' number] "
866 "['-mask' number] ",
867 },
868 {
869 .name = "tapisenabled",
870 .mode = COMMAND_EXEC,
871 .jim_handler = jim_jtag_tap_enabler,
872 .help = "Returns a Tcl boolean (0/1) indicating whether "
873 "the TAP is enabled (1) or not (0).",
874 .usage = "tap_name",
875 },
876 {
877 .name = "tapenable",
878 .mode = COMMAND_EXEC,
879 .jim_handler = jim_jtag_tap_enabler,
880 .help = "Try to enable the specified TAP using the "
881 "'tap-enable' TAP event.",
882 .usage = "tap_name",
883 },
884 {
885 .name = "tapdisable",
886 .mode = COMMAND_EXEC,
887 .jim_handler = jim_jtag_tap_enabler,
888 .help = "Try to disable the specified TAP using the "
889 "'tap-disable' TAP event.",
890 .usage = "tap_name",
891 },
892 {
893 .name = "configure",
894 .mode = COMMAND_EXEC,
895 .jim_handler = jim_jtag_configure,
896 .help = "Provide a Tcl handler for the specified "
897 "TAP event.",
898 .usage = "tap_name '-event' event_name handler",
899 },
900 {
901 .name = "cget",
902 .mode = COMMAND_EXEC,
903 .jim_handler = jim_jtag_configure,
904 .help = "Return any Tcl handler for the specified "
905 "TAP event.",
906 .usage = "tap_name '-event' event_name",
907 },
908 {
909 .name = "names",
910 .mode = COMMAND_ANY,
911 .jim_handler = jim_jtag_names,
912 .help = "Returns list of all JTAG tap names.",
913 },
914 {
915 .chain = jtag_command_handlers_to_move,
916 },
917 COMMAND_REGISTRATION_DONE
918 };
919
920 void jtag_notify_event(enum jtag_event event)
921 {
922 struct jtag_tap *tap;
923
924 for (tap = jtag_all_taps(); tap; tap = tap->next_tap)
925 jtag_tap_handle_event(tap, event);
926 }
927
928
929 COMMAND_HANDLER(handle_scan_chain_command)
930 {
931 struct jtag_tap *tap;
932 char expected_id[12];
933
934 tap = jtag_all_taps();
935 command_print(CMD_CTX,
936 " TapName Enabled IdCode Expected IrLen IrCap IrMask");
937 command_print(CMD_CTX,
938 "-- ------------------- -------- ---------- ---------- ----- ----- ------");
939
940 while (tap) {
941 uint32_t expected, expected_mask, ii;
942
943 snprintf(expected_id, sizeof expected_id, "0x%08x",
944 (unsigned)((tap->expected_ids_cnt > 0)
945 ? tap->expected_ids[0]
946 : 0));
947 if (tap->ignore_version)
948 expected_id[2] = '*';
949
950 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
951 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
952
953 command_print(CMD_CTX,
954 "%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x",
955 tap->abs_chain_position,
956 tap->dotted_name,
957 tap->enabled ? 'Y' : 'n',
958 (unsigned int)(tap->idcode),
959 expected_id,
960 (unsigned int)(tap->ir_length),
961 (unsigned int)(expected),
962 (unsigned int)(expected_mask));
963
964 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
965 snprintf(expected_id, sizeof expected_id, "0x%08x",
966 (unsigned) tap->expected_ids[ii]);
967 if (tap->ignore_version)
968 expected_id[2] = '*';
969
970 command_print(CMD_CTX,
971 " %s",
972 expected_id);
973 }
974
975 tap = tap->next_tap;
976 }
977
978 return ERROR_OK;
979 }
980
981 COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
982 {
983 if (CMD_ARGC > 1)
984 return ERROR_COMMAND_SYNTAX_ERROR;
985 if (CMD_ARGC == 1) {
986 unsigned delay;
987 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
988
989 jtag_set_ntrst_delay(delay);
990 }
991 command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
992 return ERROR_OK;
993 }
994
995 COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
996 {
997 if (CMD_ARGC > 1)
998 return ERROR_COMMAND_SYNTAX_ERROR;
999 if (CMD_ARGC == 1) {
1000 unsigned delay;
1001 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
1002
1003 jtag_set_ntrst_assert_width(delay);
1004 }
1005 command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
1006 return ERROR_OK;
1007 }
1008
1009 COMMAND_HANDLER(handle_jtag_rclk_command)
1010 {
1011 if (CMD_ARGC > 1)
1012 return ERROR_COMMAND_SYNTAX_ERROR;
1013
1014 int retval = ERROR_OK;
1015 if (CMD_ARGC == 1) {
1016 unsigned khz = 0;
1017 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
1018
1019 retval = jtag_config_rclk(khz);
1020 if (ERROR_OK != retval)
1021 return retval;
1022 }
1023
1024 int cur_khz = jtag_get_speed_khz();
1025 retval = jtag_get_speed_readable(&cur_khz);
1026 if (ERROR_OK != retval)
1027 return retval;
1028
1029 if (cur_khz)
1030 command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz);
1031 else
1032 command_print(CMD_CTX, "RCLK - adaptive");
1033
1034 return retval;
1035 }
1036
1037 COMMAND_HANDLER(handle_jtag_reset_command)
1038 {
1039 if (CMD_ARGC != 2)
1040 return ERROR_COMMAND_SYNTAX_ERROR;
1041
1042 int trst = -1;
1043 if (CMD_ARGV[0][0] == '1')
1044 trst = 1;
1045 else if (CMD_ARGV[0][0] == '0')
1046 trst = 0;
1047 else
1048 return ERROR_COMMAND_SYNTAX_ERROR;
1049
1050 int srst = -1;
1051 if (CMD_ARGV[1][0] == '1')
1052 srst = 1;
1053 else if (CMD_ARGV[1][0] == '0')
1054 srst = 0;
1055 else
1056 return ERROR_COMMAND_SYNTAX_ERROR;
1057
1058 if (adapter_init(CMD_CTX) != ERROR_OK)
1059 return ERROR_JTAG_INIT_FAILED;
1060
1061 jtag_add_reset(trst, srst);
1062 return jtag_execute_queue();
1063 }
1064
1065 COMMAND_HANDLER(handle_runtest_command)
1066 {
1067 if (CMD_ARGC != 1)
1068 return ERROR_COMMAND_SYNTAX_ERROR;
1069
1070 unsigned num_clocks;
1071 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num_clocks);
1072
1073 jtag_add_runtest(num_clocks, TAP_IDLE);
1074 return jtag_execute_queue();
1075 }
1076
1077 /*
1078 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1079 * should be stable ... and *NOT* a shift state, otherwise free-running
1080 * jtag clocks could change the values latched by the update state.
1081 * Not surprisingly, this is the same constraint as SVF; the "irscan"
1082 * and "drscan" commands are a write-only subset of what SVF provides.
1083 */
1084
1085 COMMAND_HANDLER(handle_irscan_command)
1086 {
1087 int i;
1088 struct scan_field *fields;
1089 struct jtag_tap *tap = NULL;
1090 tap_state_t endstate;
1091
1092 if ((CMD_ARGC < 2) || (CMD_ARGC % 2))
1093 return ERROR_COMMAND_SYNTAX_ERROR;
1094
1095 /* optional "-endstate" "statename" at the end of the arguments,
1096 * so that e.g. IRPAUSE can let us load the data register before
1097 * entering RUN/IDLE to execute the instruction we load here.
1098 */
1099 endstate = TAP_IDLE;
1100
1101 if (CMD_ARGC >= 4) {
1102 /* have at least one pair of numbers.
1103 * is last pair the magic text? */
1104 if (strcmp("-endstate", CMD_ARGV[CMD_ARGC - 2]) == 0) {
1105 endstate = tap_state_by_name(CMD_ARGV[CMD_ARGC - 1]);
1106 if (endstate == TAP_INVALID)
1107 return ERROR_COMMAND_SYNTAX_ERROR;
1108 if (!scan_is_safe(endstate))
1109 LOG_WARNING("unstable irscan endstate \"%s\"",
1110 CMD_ARGV[CMD_ARGC - 1]);
1111 CMD_ARGC -= 2;
1112 }
1113 }
1114
1115 int num_fields = CMD_ARGC / 2;
1116 if (num_fields > 1) {
1117 /* we really should be looking at plain_ir_scan if we want
1118 * anything more fancy.
1119 */
1120 LOG_ERROR("Specify a single value for tap");
1121 return ERROR_COMMAND_SYNTAX_ERROR;
1122 }
1123
1124 size_t fields_len = sizeof(struct scan_field) * num_fields;
1125 fields = malloc(fields_len);
1126 memset(fields, 0, fields_len);
1127
1128 int retval;
1129 for (i = 0; i < num_fields; i++) {
1130 tap = jtag_tap_by_string(CMD_ARGV[i*2]);
1131 if (tap == NULL) {
1132 int j;
1133 for (j = 0; j < i; j++)
1134 free((void *)fields[j].out_value);
1135 free(fields);
1136 command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]);
1137
1138 return ERROR_FAIL;
1139 }
1140 int field_size = tap->ir_length;
1141 fields[i].num_bits = field_size;
1142 fields[i].out_value = malloc(DIV_ROUND_UP(field_size, 8));
1143
1144 uint32_t value;
1145 retval = parse_u32(CMD_ARGV[i * 2 + 1], &value);
1146 if (ERROR_OK != retval)
1147 goto error_return;
1148 void *v = (void *)fields[i].out_value;
1149 buf_set_u32(v, 0, field_size, value);
1150 fields[i].in_value = NULL;
1151 }
1152
1153 /* did we have an endstate? */
1154 jtag_add_ir_scan(tap, fields, endstate);
1155
1156 retval = jtag_execute_queue();
1157
1158 error_return:
1159 for (i = 0; i < num_fields; i++) {
1160 if (NULL != fields[i].out_value)
1161 free((void *)fields[i].out_value);
1162 }
1163
1164 free(fields);
1165
1166 return retval;
1167 }
1168
1169 COMMAND_HANDLER(handle_verify_ircapture_command)
1170 {
1171 if (CMD_ARGC > 1)
1172 return ERROR_COMMAND_SYNTAX_ERROR;
1173
1174 if (CMD_ARGC == 1) {
1175 bool enable;
1176 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
1177 jtag_set_verify_capture_ir(enable);
1178 }
1179
1180 const char *status = jtag_will_verify_capture_ir() ? "enabled" : "disabled";
1181 command_print(CMD_CTX, "verify Capture-IR is %s", status);
1182
1183 return ERROR_OK;
1184 }
1185
1186 COMMAND_HANDLER(handle_verify_jtag_command)
1187 {
1188 if (CMD_ARGC > 1)
1189 return ERROR_COMMAND_SYNTAX_ERROR;
1190
1191 if (CMD_ARGC == 1) {
1192 bool enable;
1193 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
1194 jtag_set_verify(enable);
1195 }
1196
1197 const char *status = jtag_will_verify() ? "enabled" : "disabled";
1198 command_print(CMD_CTX, "verify jtag capture is %s", status);
1199
1200 return ERROR_OK;
1201 }
1202
1203 COMMAND_HANDLER(handle_tms_sequence_command)
1204 {
1205 if (CMD_ARGC > 1)
1206 return ERROR_COMMAND_SYNTAX_ERROR;
1207
1208 if (CMD_ARGC == 1) {
1209 bool use_new_table;
1210 if (strcmp(CMD_ARGV[0], "short") == 0)
1211 use_new_table = true;
1212 else if (strcmp(CMD_ARGV[0], "long") == 0)
1213 use_new_table = false;
1214 else
1215 return ERROR_COMMAND_SYNTAX_ERROR;
1216
1217 tap_use_new_tms_table(use_new_table);
1218 }
1219
1220 command_print(CMD_CTX, "tms sequence is %s",
1221 tap_uses_new_tms_table() ? "short" : "long");
1222
1223 return ERROR_OK;
1224 }
1225
1226 COMMAND_HANDLER(handle_jtag_flush_queue_sleep)
1227 {
1228 if (CMD_ARGC != 1)
1229 return ERROR_COMMAND_SYNTAX_ERROR;
1230
1231 int sleep_ms;
1232 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], sleep_ms);
1233
1234 jtag_set_flush_queue_sleep(sleep_ms);
1235
1236 return ERROR_OK;
1237 }
1238
1239 COMMAND_HANDLER(handle_wait_srst_deassert)
1240 {
1241 if (CMD_ARGC != 1)
1242 return ERROR_COMMAND_SYNTAX_ERROR;
1243
1244 int timeout_ms;
1245 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], timeout_ms);
1246 if ((timeout_ms <= 0) || (timeout_ms > 100000)) {
1247 LOG_ERROR("Timeout must be an integer between 0 and 100000");
1248 return ERROR_FAIL;
1249 }
1250
1251 LOG_USER("Waiting for srst assert + deassert for at most %dms", timeout_ms);
1252 int asserted_yet;
1253 long long then = timeval_ms();
1254 while (jtag_srst_asserted(&asserted_yet) == ERROR_OK) {
1255 if ((timeval_ms() - then) > timeout_ms) {
1256 LOG_ERROR("Timed out");
1257 return ERROR_FAIL;
1258 }
1259 if (asserted_yet)
1260 break;
1261 }
1262 while (jtag_srst_asserted(&asserted_yet) == ERROR_OK) {
1263 if ((timeval_ms() - then) > timeout_ms) {
1264 LOG_ERROR("Timed out");
1265 return ERROR_FAIL;
1266 }
1267 if (!asserted_yet)
1268 break;
1269 }
1270
1271 return ERROR_OK;
1272 }
1273
1274 static const struct command_registration jtag_command_handlers[] = {
1275
1276 {
1277 .name = "jtag_flush_queue_sleep",
1278 .handler = handle_jtag_flush_queue_sleep,
1279 .mode = COMMAND_ANY,
1280 .help = "For debug purposes(simulate long delays of interface) "
1281 "to test performance or change in behavior. Default 0ms.",
1282 .usage = "[sleep in ms]",
1283 },
1284 {
1285 .name = "jtag_rclk",
1286 .handler = handle_jtag_rclk_command,
1287 .mode = COMMAND_ANY,
1288 .help = "With an argument, change to to use adaptive clocking "
1289 "if possible; else to use the fallback speed. "
1290 "With or without argument, display current setting.",
1291 .usage = "[fallback_speed_khz]",
1292 },
1293 {
1294 .name = "jtag_ntrst_delay",
1295 .handler = handle_jtag_ntrst_delay_command,
1296 .mode = COMMAND_ANY,
1297 .help = "delay after deasserting trst in ms",
1298 .usage = "[milliseconds]",
1299 },
1300 {
1301 .name = "jtag_ntrst_assert_width",
1302 .handler = handle_jtag_ntrst_assert_width_command,
1303 .mode = COMMAND_ANY,
1304 .help = "delay after asserting trst in ms",
1305 .usage = "[milliseconds]",
1306 },
1307 {
1308 .name = "scan_chain",
1309 .handler = handle_scan_chain_command,
1310 .mode = COMMAND_ANY,
1311 .help = "print current scan chain configuration",
1312 .usage = ""
1313 },
1314 {
1315 .name = "jtag_reset",
1316 .handler = handle_jtag_reset_command,
1317 .mode = COMMAND_EXEC,
1318 .help = "Set reset line values. Value '1' is active, "
1319 "value '0' is inactive.",
1320 .usage = "trst_active srst_active",
1321 },
1322 {
1323 .name = "runtest",
1324 .handler = handle_runtest_command,
1325 .mode = COMMAND_EXEC,
1326 .help = "Move to Run-Test/Idle, and issue TCK for num_cycles.",
1327 .usage = "num_cycles"
1328 },
1329 {
1330 .name = "irscan",
1331 .handler = handle_irscan_command,
1332 .mode = COMMAND_EXEC,
1333 .help = "Execute Instruction Register (DR) scan. The "
1334 "specified opcodes are put into each TAP's IR, "
1335 "and other TAPs are put in BYPASS.",
1336 .usage = "[tap_name instruction]* ['-endstate' state_name]",
1337 },
1338 {
1339 .name = "verify_ircapture",
1340 .handler = handle_verify_ircapture_command,
1341 .mode = COMMAND_ANY,
1342 .help = "Display or assign flag controlling whether to "
1343 "verify values captured during Capture-IR.",
1344 .usage = "['enable'|'disable']",
1345 },
1346 {
1347 .name = "verify_jtag",
1348 .handler = handle_verify_jtag_command,
1349 .mode = COMMAND_ANY,
1350 .help = "Display or assign flag controlling whether to "
1351 "verify values captured during IR and DR scans.",
1352 .usage = "['enable'|'disable']",
1353 },
1354 {
1355 .name = "tms_sequence",
1356 .handler = handle_tms_sequence_command,
1357 .mode = COMMAND_ANY,
1358 .help = "Display or change what style TMS sequences to use "
1359 "for JTAG state transitions: short (default) or "
1360 "long. Only for working around JTAG bugs.",
1361 /* Specifically for working around DRIVER bugs... */
1362 .usage = "['short'|'long']",
1363 },
1364 {
1365 .name = "wait_srst_deassert",
1366 .handler = handle_wait_srst_deassert,
1367 .mode = COMMAND_ANY,
1368 .help = "Wait for an SRST deassert. "
1369 "Useful for cases where you need something to happen within ms "
1370 "of an srst deassert. Timeout in ms ",
1371 .usage = "ms",
1372 },
1373 {
1374 .name = "jtag",
1375 .mode = COMMAND_ANY,
1376 .help = "perform jtag tap actions",
1377 .usage = "",
1378
1379 .chain = jtag_subcommand_handlers,
1380 },
1381 {
1382 .chain = jtag_command_handlers_to_move,
1383 },
1384 COMMAND_REGISTRATION_DONE
1385 };
1386
1387 int jtag_register_commands(struct command_context *cmd_ctx)
1388 {
1389 return register_commands(cmd_ctx, NULL, jtag_command_handlers);
1390 }

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)