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

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)