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