Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
use COMMAND_REGISTER macro
[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 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, struct jtag_tap * 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 struct jtag_tap_event_action *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 struct jtag_tap *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(struct jtag_tap));
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(struct jtag_tap *tap, enum jtag_event e)
339 {
340 struct jtag_tap_event_action * 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 *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 struct jtag_tap *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 struct jtag_tap *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 struct jtag_tap *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 struct jtag_tap *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 struct jtag_tap *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 && CMD_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 (CMD_ARGC != 1 || CMD_ARGV[0][0] == '\0')
632 return ERROR_COMMAND_SYNTAX_ERROR;
633
634 for (unsigned i = 0; NULL != jtag_interfaces[i]; i++)
635 {
636 if (strcmp(CMD_ARGV[0], jtag_interfaces[i]->name) != 0)
637 continue;
638
639 if (NULL != jtag_interfaces[i]->register_commands)
640 {
641 int retval = jtag_interfaces[i]->register_commands(CMD_CTX);
642 if (ERROR_OK != retval)
643 return retval;
644 }
645
646 jtag_interface = jtag_interfaces[i];
647
648 if (jtag_interface->khz == NULL)
649 jtag_interface->khz = default_khz;
650 if (jtag_interface->speed_div == NULL)
651 jtag_interface->speed_div = default_speed_div;
652 if (jtag_interface->power_dropout == NULL)
653 jtag_interface->power_dropout = default_power_dropout;
654 if (jtag_interface->srst_asserted == NULL)
655 jtag_interface->srst_asserted = default_srst_asserted;
656
657 return ERROR_OK;
658 }
659
660 /* no valid interface was found (i.e. the configuration option,
661 * didn't match one of the compiled-in interfaces
662 */
663 LOG_ERROR("The specified JTAG interface was not found (%s)", CMD_ARGV[0]);
664 CALL_COMMAND_HANDLER(handle_interface_list_command);
665 return ERROR_JTAG_INVALID_INTERFACE;
666 }
667
668 COMMAND_HANDLER(handle_scan_chain_command)
669 {
670 struct jtag_tap *tap;
671
672 tap = jtag_all_taps();
673 command_print(CMD_CTX, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr ");
674 command_print(CMD_CTX, "---|--------------------|---------|------------|------------|------|------|------|---------");
675
676 while (tap) {
677 uint32_t expected, expected_mask, cur_instr, ii;
678 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
679 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
680 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
681
682 command_print(CMD_CTX,
683 "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
684 tap->abs_chain_position,
685 tap->dotted_name,
686 tap->enabled ? 'Y' : 'n',
687 (unsigned int)(tap->idcode),
688 (unsigned int)(tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
689 (unsigned int)(tap->ir_length),
690 (unsigned int)(expected),
691 (unsigned int)(expected_mask),
692 (unsigned int)(cur_instr));
693
694 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
695 command_print(CMD_CTX, " | | | | 0x%08x | | | | ",
696 (unsigned int)(tap->expected_ids[ii]));
697 }
698
699 tap = tap->next_tap;
700 }
701
702 return ERROR_OK;
703 }
704
705 COMMAND_HANDLER(handle_reset_config_command)
706 {
707 int new_cfg = 0;
708 int mask = 0;
709
710 /* Original versions cared about the order of these tokens:
711 * reset_config signals [combination [trst_type [srst_type]]]
712 * They also clobbered the previous configuration even on error.
713 *
714 * Here we don't care about the order, and only change values
715 * which have been explicitly specified.
716 */
717 for (; CMD_ARGC; CMD_ARGC--, CMD_ARGV++) {
718 int tmp = 0;
719 int m;
720
721 /* gating */
722 m = RESET_SRST_NO_GATING;
723 if (strcmp(*CMD_ARGV, "srst_gates_jtag") == 0)
724 /* default: don't use JTAG while SRST asserted */;
725 else if (strcmp(*CMD_ARGV, "srst_nogate") == 0)
726 tmp = RESET_SRST_NO_GATING;
727 else
728 m = 0;
729 if (mask & m) {
730 LOG_ERROR("extra reset_config %s spec (%s)",
731 "gating", *CMD_ARGV);
732 return ERROR_INVALID_ARGUMENTS;
733 }
734 if (m)
735 goto next;
736
737 /* signals */
738 m = RESET_HAS_TRST | RESET_HAS_SRST;
739 if (strcmp(*CMD_ARGV, "none") == 0)
740 tmp = RESET_NONE;
741 else if (strcmp(*CMD_ARGV, "trst_only") == 0)
742 tmp = RESET_HAS_TRST;
743 else if (strcmp(*CMD_ARGV, "srst_only") == 0)
744 tmp = RESET_HAS_SRST;
745 else if (strcmp(*CMD_ARGV, "trst_and_srst") == 0)
746 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
747 else
748 m = 0;
749 if (mask & m) {
750 LOG_ERROR("extra reset_config %s spec (%s)",
751 "signal", *CMD_ARGV);
752 return ERROR_INVALID_ARGUMENTS;
753 }
754 if (m)
755 goto next;
756
757 /* combination (options for broken wiring) */
758 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
759 if (strcmp(*CMD_ARGV, "separate") == 0)
760 /* separate reset lines - default */;
761 else if (strcmp(*CMD_ARGV, "srst_pulls_trst") == 0)
762 tmp |= RESET_SRST_PULLS_TRST;
763 else if (strcmp(*CMD_ARGV, "trst_pulls_srst") == 0)
764 tmp |= RESET_TRST_PULLS_SRST;
765 else if (strcmp(*CMD_ARGV, "combined") == 0)
766 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
767 else
768 m = 0;
769 if (mask & m) {
770 LOG_ERROR("extra reset_config %s spec (%s)",
771 "combination", *CMD_ARGV);
772 return ERROR_INVALID_ARGUMENTS;
773 }
774 if (m)
775 goto next;
776
777 /* trst_type (NOP without HAS_TRST) */
778 m = RESET_TRST_OPEN_DRAIN;
779 if (strcmp(*CMD_ARGV, "trst_open_drain") == 0)
780 tmp |= RESET_TRST_OPEN_DRAIN;
781 else if (strcmp(*CMD_ARGV, "trst_push_pull") == 0)
782 /* push/pull from adapter - default */;
783 else
784 m = 0;
785 if (mask & m) {
786 LOG_ERROR("extra reset_config %s spec (%s)",
787 "trst_type", *CMD_ARGV);
788 return ERROR_INVALID_ARGUMENTS;
789 }
790 if (m)
791 goto next;
792
793 /* srst_type (NOP without HAS_SRST) */
794 m |= RESET_SRST_PUSH_PULL;
795 if (strcmp(*CMD_ARGV, "srst_push_pull") == 0)
796 tmp |= RESET_SRST_PUSH_PULL;
797 else if (strcmp(*CMD_ARGV, "srst_open_drain") == 0)
798 /* open drain from adapter - default */;
799 else
800 m = 0;
801 if (mask & m) {
802 LOG_ERROR("extra reset_config %s spec (%s)",
803 "srst_type", *CMD_ARGV);
804 return ERROR_INVALID_ARGUMENTS;
805 }
806 if (m)
807 goto next;
808
809 /* caller provided nonsense; fail */
810 LOG_ERROR("unknown reset_config flag (%s)", *CMD_ARGV);
811 return ERROR_INVALID_ARGUMENTS;
812
813 next:
814 /* Remember the bits which were specified (mask)
815 * and their new values (new_cfg).
816 */
817 mask |= m;
818 new_cfg |= tmp;
819 }
820
821 /* clear previous values of those bits, save new values */
822 if (mask) {
823 int old_cfg = jtag_get_reset_config();
824
825 old_cfg &= ~mask;
826 new_cfg |= old_cfg;
827 jtag_set_reset_config(new_cfg);
828 } else
829 new_cfg = jtag_get_reset_config();
830
831
832 /*
833 * Display the (now-)current reset mode
834 */
835 char *modes[5];
836
837 /* minimal JTAG has neither SRST nor TRST (so that's the default) */
838 switch (new_cfg & (RESET_HAS_TRST | RESET_HAS_SRST)) {
839 case RESET_HAS_SRST:
840 modes[0] = "srst_only";
841 break;
842 case RESET_HAS_TRST:
843 modes[0] = "trst_only";
844 break;
845 case RESET_TRST_AND_SRST:
846 modes[0] = "trst_and_srst";
847 break;
848 default:
849 modes[0] = "none";
850 break;
851 }
852
853 /* normally SRST and TRST are decoupled; but bugs happen ... */
854 switch (new_cfg & (RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST)) {
855 case RESET_SRST_PULLS_TRST:
856 modes[1] = "srst_pulls_trst";
857 break;
858 case RESET_TRST_PULLS_SRST:
859 modes[1] = "trst_pulls_srst";
860 break;
861 case RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST:
862 modes[1] = "combined";
863 break;
864 default:
865 modes[1] = "separate";
866 break;
867 }
868
869 /* TRST-less connectors include Altera, Xilinx, and minimal JTAG */
870 if (new_cfg & RESET_HAS_TRST) {
871 if (new_cfg & RESET_TRST_OPEN_DRAIN)
872 modes[3] = " trst_open_drain";
873 else
874 modes[3] = " trst_push_pull";
875 } else
876 modes[3] = "";
877
878 /* SRST-less connectors include TI-14, Xilinx, and minimal JTAG */
879 if (new_cfg & RESET_HAS_SRST) {
880 if (new_cfg & RESET_SRST_NO_GATING)
881 modes[2] = " srst_nogate";
882 else
883 modes[2] = " srst_gates_jtag";
884
885 if (new_cfg & RESET_SRST_PUSH_PULL)
886 modes[4] = " srst_push_pull";
887 else
888 modes[4] = " srst_open_drain";
889 } else {
890 modes[2] = "";
891 modes[4] = "";
892 }
893
894 command_print(CMD_CTX, "%s %s%s%s%s",
895 modes[0], modes[1],
896 modes[2], modes[3], modes[4]);
897
898 return ERROR_OK;
899 }
900
901 COMMAND_HANDLER(handle_jtag_nsrst_delay_command)
902 {
903 if (CMD_ARGC > 1)
904 return ERROR_COMMAND_SYNTAX_ERROR;
905 if (CMD_ARGC == 1)
906 {
907 unsigned delay;
908 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
909
910 jtag_set_nsrst_delay(delay);
911 }
912 command_print(CMD_CTX, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
913 return ERROR_OK;
914 }
915
916 COMMAND_HANDLER(handle_jtag_ntrst_delay_command)
917 {
918 if (CMD_ARGC > 1)
919 return ERROR_COMMAND_SYNTAX_ERROR;
920 if (CMD_ARGC == 1)
921 {
922 unsigned delay;
923 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
924
925 jtag_set_ntrst_delay(delay);
926 }
927 command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
928 return ERROR_OK;
929 }
930
931 COMMAND_HANDLER(handle_jtag_nsrst_assert_width_command)
932 {
933 if (CMD_ARGC > 1)
934 return ERROR_COMMAND_SYNTAX_ERROR;
935 if (CMD_ARGC == 1)
936 {
937 unsigned delay;
938 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
939
940 jtag_set_nsrst_assert_width(delay);
941 }
942 command_print(CMD_CTX, "jtag_nsrst_assert_width: %u", jtag_get_nsrst_assert_width());
943 return ERROR_OK;
944 }
945
946 COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command)
947 {
948 if (CMD_ARGC > 1)
949 return ERROR_COMMAND_SYNTAX_ERROR;
950 if (CMD_ARGC == 1)
951 {
952 unsigned delay;
953 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], delay);
954
955 jtag_set_ntrst_assert_width(delay);
956 }
957 command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width());
958 return ERROR_OK;
959 }
960
961 COMMAND_HANDLER(handle_jtag_khz_command)
962 {
963 if (CMD_ARGC > 1)
964 return ERROR_COMMAND_SYNTAX_ERROR;
965
966 int retval = ERROR_OK;
967 if (CMD_ARGC == 1)
968 {
969 unsigned khz = 0;
970 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
971
972 retval = jtag_config_khz(khz);
973 if (ERROR_OK != retval)
974 return retval;
975 }
976
977 int cur_speed = jtag_get_speed_khz();
978 retval = jtag_get_speed_readable(&cur_speed);
979 if (ERROR_OK != retval)
980 return retval;
981
982 if (cur_speed)
983 command_print(CMD_CTX, "%d kHz", cur_speed);
984 else
985 command_print(CMD_CTX, "RCLK - adaptive");
986
987 return retval;
988 }
989
990 COMMAND_HANDLER(handle_jtag_rclk_command)
991 {
992 if (CMD_ARGC > 1)
993 return ERROR_COMMAND_SYNTAX_ERROR;
994
995 int retval = ERROR_OK;
996 if (CMD_ARGC == 1)
997 {
998 unsigned khz = 0;
999 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], khz);
1000
1001 retval = jtag_config_rclk(khz);
1002 if (ERROR_OK != retval)
1003 return retval;
1004 }
1005
1006 int cur_khz = jtag_get_speed_khz();
1007 retval = jtag_get_speed_readable(&cur_khz);
1008 if (ERROR_OK != retval)
1009 return retval;
1010
1011 if (cur_khz)
1012 command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz);
1013 else
1014 command_print(CMD_CTX, "RCLK - adaptive");
1015
1016 return retval;
1017 }
1018
1019 COMMAND_HANDLER(handle_jtag_reset_command)
1020 {
1021 if (CMD_ARGC != 2)
1022 return ERROR_COMMAND_SYNTAX_ERROR;
1023
1024 int trst = -1;
1025 if (CMD_ARGV[0][0] == '1')
1026 trst = 1;
1027 else if (CMD_ARGV[0][0] == '0')
1028 trst = 0;
1029 else
1030 return ERROR_COMMAND_SYNTAX_ERROR;
1031
1032 int srst = -1;
1033 if (CMD_ARGV[1][0] == '1')
1034 srst = 1;
1035 else if (CMD_ARGV[1][0] == '0')
1036 srst = 0;
1037 else
1038 return ERROR_COMMAND_SYNTAX_ERROR;
1039
1040 if (jtag_interface_init(CMD_CTX) != ERROR_OK)
1041 return ERROR_JTAG_INIT_FAILED;
1042
1043 jtag_add_reset(trst, srst);
1044 return jtag_execute_queue();
1045 }
1046
1047 COMMAND_HANDLER(handle_runtest_command)
1048 {
1049 if (CMD_ARGC != 1)
1050 return ERROR_COMMAND_SYNTAX_ERROR;
1051
1052 unsigned num_clocks;
1053 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num_clocks);
1054
1055 jtag_add_runtest(num_clocks, TAP_IDLE);
1056 return jtag_execute_queue();
1057 }
1058
1059 /*
1060 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1061 * should be stable ... and *NOT* a shift state, otherwise free-running
1062 * jtag clocks could change the values latched by the update state.
1063 * Not surprisingly, this is the same constraint as SVF; the "irscan"
1064 * and "drscan" commands are a write-only subset of what SVF provides.
1065 */
1066 static bool scan_is_safe(tap_state_t state)
1067 {
1068 switch (state)
1069 {
1070 case TAP_RESET:
1071 case TAP_IDLE:
1072 case TAP_DRPAUSE:
1073 case TAP_IRPAUSE:
1074 return true;
1075 default:
1076 return false;
1077 }
1078 }
1079
1080
1081 COMMAND_HANDLER(handle_irscan_command)
1082 {
1083 int i;
1084 struct scan_field *fields;
1085 struct jtag_tap *tap;
1086 tap_state_t endstate;
1087
1088 if ((CMD_ARGC < 2) || (CMD_ARGC % 2))
1089 {
1090 return ERROR_COMMAND_SYNTAX_ERROR;
1091 }
1092
1093 /* optional "-endstate" "statename" at the end of the arguments,
1094 * so that e.g. IRPAUSE can let us load the data register before
1095 * entering RUN/IDLE to execute the instruction we load here.
1096 */
1097 endstate = TAP_IDLE;
1098
1099 if (CMD_ARGC >= 4) {
1100 /* have at least one pair of numbers. */
1101 /* is last pair the magic text? */
1102 if (strcmp("-endstate", CMD_ARGV[CMD_ARGC - 2]) == 0) {
1103 endstate = tap_state_by_name(CMD_ARGV[CMD_ARGC - 1]);
1104 if (endstate == TAP_INVALID)
1105 return ERROR_COMMAND_SYNTAX_ERROR;
1106 if (!scan_is_safe(endstate))
1107 LOG_WARNING("unstable irscan endstate \"%s\"",
1108 CMD_ARGV[CMD_ARGC - 1]);
1109 CMD_ARGC -= 2;
1110 }
1111 }
1112
1113 int num_fields = CMD_ARGC / 2;
1114 size_t fields_len = sizeof(struct scan_field) * num_fields;
1115 fields = malloc(fields_len);
1116 memset(fields, 0, fields_len);
1117
1118 int retval;
1119 for (i = 0; i < num_fields; i++)
1120 {
1121 tap = jtag_tap_by_string(CMD_ARGV[i*2]);
1122 if (tap == NULL)
1123 {
1124 int j;
1125 for (j = 0; j < i; j++)
1126 free(fields[j].out_value);
1127 free(fields);
1128 command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]);
1129
1130 return ERROR_FAIL;
1131 }
1132 int field_size = tap->ir_length;
1133 fields[i].tap = tap;
1134 fields[i].num_bits = field_size;
1135 fields[i].out_value = malloc(DIV_ROUND_UP(field_size, 8));
1136
1137 uint32_t value;
1138 retval = parse_u32(CMD_ARGV[i * 2 + 1], &value);
1139 if (ERROR_OK != retval)
1140 goto error_return;
1141 buf_set_u32(fields[i].out_value, 0, field_size, value);
1142 fields[i].in_value = NULL;
1143 }
1144
1145 /* did we have an endstate? */
1146 jtag_add_ir_scan(num_fields, fields, endstate);
1147
1148 retval = jtag_execute_queue();
1149
1150 error_return:
1151 for (i = 0; i < num_fields; i++)
1152 {
1153 if (NULL != fields[i].out_value)
1154 free(fields[i].out_value);
1155 }
1156
1157 free (fields);
1158
1159 return retval;
1160 }
1161
1162 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1163 {
1164 int retval;
1165 struct scan_field *fields;
1166 int num_fields;
1167 int field_count = 0;
1168 int i, e;
1169 struct jtag_tap *tap;
1170 tap_state_t endstate;
1171
1172 /* args[1] = device
1173 * args[2] = num_bits
1174 * args[3] = hex string
1175 * ... repeat num bits and hex string ...
1176 *
1177 * .. optionally:
1178 * args[N-2] = "-endstate"
1179 * args[N-1] = statename
1180 */
1181 if ((argc < 4) || ((argc % 2) != 0))
1182 {
1183 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1184 return JIM_ERR;
1185 }
1186
1187 endstate = TAP_IDLE;
1188
1189 script_debug(interp, "drscan", argc, args);
1190
1191 /* validate arguments as numbers */
1192 e = JIM_OK;
1193 for (i = 2; i < argc; i += 2)
1194 {
1195 long bits;
1196 const char *cp;
1197
1198 e = Jim_GetLong(interp, args[i], &bits);
1199 /* If valid - try next arg */
1200 if (e == JIM_OK) {
1201 continue;
1202 }
1203
1204 /* Not valid.. are we at the end? */
1205 if (((i + 2) != argc)) {
1206 /* nope, then error */
1207 return e;
1208 }
1209
1210 /* it could be: "-endstate FOO"
1211 * e.g. DRPAUSE so we can issue more instructions
1212 * before entering RUN/IDLE and executing them.
1213 */
1214
1215 /* get arg as a string. */
1216 cp = Jim_GetString(args[i], NULL);
1217 /* is it the magic? */
1218 if (0 == strcmp("-endstate", cp)) {
1219 /* is the statename valid? */
1220 cp = Jim_GetString(args[i + 1], NULL);
1221
1222 /* see if it is a valid state name */
1223 endstate = tap_state_by_name(cp);
1224 if (endstate < 0) {
1225 /* update the error message */
1226 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1227 } else {
1228 if (!scan_is_safe(endstate))
1229 LOG_WARNING("drscan with unsafe "
1230 "endstate \"%s\"", cp);
1231
1232 /* valid - so clear the error */
1233 e = JIM_OK;
1234 /* and remove the last 2 args */
1235 argc -= 2;
1236 }
1237 }
1238
1239 /* Still an error? */
1240 if (e != JIM_OK) {
1241 return e; /* too bad */
1242 }
1243 } /* validate args */
1244
1245 tap = jtag_tap_by_jim_obj(interp, args[1]);
1246 if (tap == NULL) {
1247 return JIM_ERR;
1248 }
1249
1250 num_fields = (argc-2)/2;
1251 fields = malloc(sizeof(struct scan_field) * num_fields);
1252 for (i = 2; i < argc; i += 2)
1253 {
1254 long bits;
1255 int len;
1256 const char *str;
1257
1258 Jim_GetLong(interp, args[i], &bits);
1259 str = Jim_GetString(args[i + 1], &len);
1260
1261 fields[field_count].tap = tap;
1262 fields[field_count].num_bits = bits;
1263 fields[field_count].out_value = malloc(DIV_ROUND_UP(bits, 8));
1264 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
1265 fields[field_count].in_value = fields[field_count].out_value;
1266 field_count++;
1267 }
1268
1269 jtag_add_dr_scan(num_fields, fields, endstate);
1270
1271 retval = jtag_execute_queue();
1272 if (retval != ERROR_OK)
1273 {
1274 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
1275 return JIM_ERR;
1276 }
1277
1278 field_count = 0;
1279 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1280 for (i = 2; i < argc; i += 2)
1281 {
1282 long bits;
1283 char *str;
1284
1285 Jim_GetLong(interp, args[i], &bits);
1286 str = buf_to_str(fields[field_count].in_value, bits, 16);
1287 free(fields[field_count].out_value);
1288
1289 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
1290 free(str);
1291 field_count++;
1292 }
1293
1294 Jim_SetResult(interp, list);
1295
1296 free(fields);
1297
1298 return JIM_OK;
1299 }
1300
1301
1302 static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1303 {
1304 tap_state_t states[8];
1305
1306 if ((argc < 2) || ((size_t)argc > (sizeof(states)/sizeof(*states) + 1)))
1307 {
1308 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1309 return JIM_ERR;
1310 }
1311
1312 script_debug(interp, "pathmove", argc, args);
1313
1314 int i;
1315 for (i = 0; i < argc-1; i++)
1316 {
1317 const char *cp;
1318 cp = Jim_GetString(args[i + 1], NULL);
1319 states[i] = tap_state_by_name(cp);
1320 if (states[i] < 0)
1321 {
1322 /* update the error message */
1323 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1324 return JIM_ERR;
1325 }
1326 }
1327
1328 if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
1329 {
1330 Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
1331 return JIM_ERR;
1332 }
1333
1334 jtag_add_pathmove(argc-2, states + 1);
1335
1336 if (jtag_execute_queue()!= ERROR_OK)
1337 {
1338 Jim_SetResultString(interp, "pathmove: failed",-1);
1339 return JIM_ERR;
1340 }
1341
1342 return JIM_OK;
1343 }
1344
1345
1346 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1347 {
1348 script_debug(interp, "flush_count", argc, args);
1349
1350 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
1351
1352 return JIM_OK;
1353 }
1354
1355
1356 COMMAND_HANDLER(handle_verify_ircapture_command)
1357 {
1358 if (CMD_ARGC > 1)
1359 return ERROR_COMMAND_SYNTAX_ERROR;
1360
1361 if (CMD_ARGC == 1)
1362 {
1363 bool enable;
1364 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
1365 jtag_set_verify_capture_ir(enable);
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 (CMD_ARGC > 1)
1377 return ERROR_COMMAND_SYNTAX_ERROR;
1378
1379 if (CMD_ARGC == 1)
1380 {
1381 bool enable;
1382 COMMAND_PARSE_ENABLE(CMD_ARGV[0], enable);
1383 jtag_set_verify(enable);
1384 }
1385
1386 const char *status = jtag_will_verify() ? "enabled": "disabled";
1387 command_print(CMD_CTX, "verify jtag capture is %s", status);
1388
1389 return ERROR_OK;
1390 }
1391
1392 COMMAND_HANDLER(handle_tms_sequence_command)
1393 {
1394 if (CMD_ARGC > 1)
1395 return ERROR_COMMAND_SYNTAX_ERROR;
1396
1397 if (CMD_ARGC == 1)
1398 {
1399 bool use_new_table;
1400 if (strcmp(CMD_ARGV[0], "short") == 0)
1401 use_new_table = true;
1402 else if (strcmp(CMD_ARGV[0], "long") == 0)
1403 use_new_table = false;
1404 else
1405 return ERROR_COMMAND_SYNTAX_ERROR;
1406
1407 tap_use_new_tms_table(use_new_table);
1408 }
1409
1410 command_print(CMD_CTX, "tms sequence is %s",
1411 tap_uses_new_tms_table() ? "short": "long");
1412
1413 return ERROR_OK;
1414 }
1415
1416 int jtag_register_commands(struct command_context *cmd_ctx)
1417 {
1418 register_jim(cmd_ctx, "jtag", jim_jtag_command,
1419 "perform jtag tap actions");
1420
1421 COMMAND_REGISTER(cmd_ctx, NULL, "interface",
1422 handle_interface_command, COMMAND_CONFIG,
1423 "try to configure interface");
1424 COMMAND_REGISTER(cmd_ctx, NULL, "interface_list",
1425 &handle_interface_list_command, COMMAND_ANY,
1426 "list all built-in interfaces");
1427
1428 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_khz",
1429 handle_jtag_khz_command, COMMAND_ANY,
1430 "set maximum jtag speed (if supported); "
1431 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1432 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_rclk",
1433 handle_jtag_rclk_command, COMMAND_ANY,
1434 "fallback_speed_khz - set JTAG speed to RCLK or use fallback speed");
1435 COMMAND_REGISTER(cmd_ctx, NULL, "reset_config",
1436 handle_reset_config_command, COMMAND_ANY,
1437 "reset_config "
1438 "[none|trst_only|srst_only|trst_and_srst] "
1439 "[srst_pulls_trst|trst_pulls_srst|combined|separate] "
1440 "[srst_gates_jtag|srst_nogate] "
1441 "[trst_push_pull|trst_open_drain] "
1442 "[srst_push_pull|srst_open_drain]");
1443
1444 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_nsrst_delay",
1445 handle_jtag_nsrst_delay_command, COMMAND_ANY,
1446 "jtag_nsrst_delay <ms> "
1447 "- delay after deasserting srst in ms");
1448 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_ntrst_delay",
1449 handle_jtag_ntrst_delay_command, COMMAND_ANY,
1450 "jtag_ntrst_delay <ms> "
1451 "- delay after deasserting trst in ms");
1452
1453 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_nsrst_assert_width",
1454 handle_jtag_nsrst_assert_width_command, COMMAND_ANY,
1455 "jtag_nsrst_assert_width <ms> "
1456 "- delay after asserting srst in ms");
1457 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_ntrst_assert_width",
1458 handle_jtag_ntrst_assert_width_command, COMMAND_ANY,
1459 "jtag_ntrst_assert_width <ms> "
1460 "- delay after asserting trst in ms");
1461
1462 COMMAND_REGISTER(cmd_ctx, NULL, "scan_chain",
1463 handle_scan_chain_command, COMMAND_EXEC,
1464 "print current scan chain configuration");
1465
1466 COMMAND_REGISTER(cmd_ctx, NULL, "jtag_reset",
1467 handle_jtag_reset_command, COMMAND_EXEC,
1468 "toggle reset lines <trst> <srst>");
1469 COMMAND_REGISTER(cmd_ctx, NULL, "runtest",
1470 handle_runtest_command, COMMAND_EXEC,
1471 "move to Run-Test/Idle, and execute <num_cycles>");
1472 COMMAND_REGISTER(cmd_ctx, NULL, "irscan",
1473 handle_irscan_command, COMMAND_EXEC,
1474 "execute IR scan <device> <instr> [dev2] [instr2] ...");
1475
1476 register_jim(cmd_ctx, "drscan", Jim_Command_drscan,
1477 "execute DR scan <device> "
1478 "<num_bits> <value> <num_bits1> <value2> ...");
1479
1480 register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count,
1481 "returns number of times the JTAG queue has been flushed");
1482
1483 register_jim(cmd_ctx, "pathmove", Jim_Command_pathmove,
1484 "<state1>,<state2>,<state3>... "
1485 "- move JTAG to state1 then to state2, state3, etc.");
1486
1487 COMMAND_REGISTER(cmd_ctx, NULL, "verify_ircapture",
1488 handle_verify_ircapture_command, COMMAND_ANY,
1489 "verify value captured during Capture-IR <enable | disable>");
1490 COMMAND_REGISTER(cmd_ctx, NULL, "verify_jtag",
1491 handle_verify_jtag_command, COMMAND_ANY,
1492 "verify value capture <enable | disable>");
1493
1494 COMMAND_REGISTER(cmd_ctx, NULL, "tms_sequence",
1495 handle_tms_sequence_command, COMMAND_ANY,
1496 "choose short(default) or long tms_sequence <short | long>");
1497
1498 return ERROR_OK;
1499 }
1500
1501
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)