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