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