Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
srst_gates_jtag option. at91sam9260 needs retesting, and possibly srst_gates_jtag...
[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 m = RESET_SRST_GATES_JTAG;
849 tmp = 0;
850 if (strcmp(*args, "srst_gates_jtag") == 0)
851 {
852 tmp = RESET_SRST_GATES_JTAG;
853 goto next;
854 }
855
856 /* signals */
857 m = RESET_HAS_TRST | RESET_HAS_SRST;
858 if (strcmp(*args, "none") == 0)
859 tmp = RESET_NONE;
860 else if (strcmp(*args, "trst_only") == 0)
861 tmp = RESET_HAS_TRST;
862 else if (strcmp(*args, "srst_only") == 0)
863 tmp = RESET_HAS_SRST;
864 else if (strcmp(*args, "trst_and_srst") == 0)
865 tmp = RESET_HAS_TRST | RESET_HAS_SRST;
866 else
867 m = 0;
868 if (mask & m) {
869 LOG_ERROR("extra reset_config %s spec (%s)",
870 "signal", *args);
871 return ERROR_INVALID_ARGUMENTS;
872 }
873 if (m)
874 goto next;
875
876 /* combination (options for broken wiring) */
877 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
878 if (strcmp(*args, "separate") == 0)
879 /* separate reset lines - default */;
880 else if (strcmp(*args, "srst_pulls_trst") == 0)
881 tmp |= RESET_SRST_PULLS_TRST;
882 else if (strcmp(*args, "trst_pulls_srst") == 0)
883 tmp |= RESET_TRST_PULLS_SRST;
884 else if (strcmp(*args, "combined") == 0)
885 tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
886 else
887 m = 0;
888 if (mask & m) {
889 LOG_ERROR("extra reset_config %s spec (%s)",
890 "combination", *args);
891 return ERROR_INVALID_ARGUMENTS;
892 }
893 if (m)
894 goto next;
895
896 /* trst_type (NOP without HAS_TRST) */
897 m = RESET_TRST_OPEN_DRAIN;
898 if (strcmp(*args, "trst_open_drain") == 0)
899 tmp |= RESET_TRST_OPEN_DRAIN;
900 else if (strcmp(*args, "trst_push_pull") == 0)
901 /* push/pull from adapter - default */;
902 else
903 m = 0;
904 if (mask & m) {
905 LOG_ERROR("extra reset_config %s spec (%s)",
906 "trst_type", *args);
907 return ERROR_INVALID_ARGUMENTS;
908 }
909 if (m)
910 goto next;
911
912 /* srst_type (NOP without HAS_SRST) */
913 m |= RESET_SRST_PUSH_PULL;
914 if (strcmp(*args, "srst_push_pull") == 0)
915 tmp |= RESET_SRST_PUSH_PULL;
916 else if (strcmp(*args, "srst_open_drain") == 0)
917 /* open drain from adapter - default */;
918 else
919 m = 0;
920 if (mask & m) {
921 LOG_ERROR("extra reset_config %s spec (%s)",
922 "srst_type", *args);
923 return ERROR_INVALID_ARGUMENTS;
924 }
925 if (m)
926 goto next;
927
928 /* caller provided nonsense; fail */
929 LOG_ERROR("unknown reset_config flag (%s)", *args);
930 return ERROR_INVALID_ARGUMENTS;
931
932 next:
933 /* Remember the bits which were specified (mask)
934 * and their new values (new_cfg).
935 */
936 mask |= m;
937 new_cfg |= tmp;
938 }
939
940 /* clear previous values of those bits, save new values */
941 enum reset_types old_cfg = jtag_get_reset_config();
942 old_cfg &= ~mask;
943 new_cfg |= old_cfg;
944 jtag_set_reset_config(new_cfg);
945
946 return ERROR_OK;
947 }
948
949 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx,
950 char *cmd, char **args, int argc)
951 {
952 if (argc > 1)
953 return ERROR_COMMAND_SYNTAX_ERROR;
954 if (argc == 1)
955 {
956 unsigned delay;
957 int retval = parse_uint(args[0], &delay);
958 if (ERROR_OK != retval)
959 return retval;
960 jtag_set_nsrst_delay(delay);
961 }
962 command_print(cmd_ctx, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
963 return ERROR_OK;
964 }
965
966 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx,
967 char *cmd, char **args, int argc)
968 {
969 if (argc > 1)
970 return ERROR_COMMAND_SYNTAX_ERROR;
971 if (argc == 1)
972 {
973 unsigned delay;
974 int retval = parse_uint(args[0], &delay);
975 if (ERROR_OK != retval)
976 return retval;
977 jtag_set_ntrst_delay(delay);
978 }
979 command_print(cmd_ctx, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
980 return ERROR_OK;
981 }
982
983 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
984 {
985 int retval = ERROR_OK;
986
987 command_print(cmd_ctx, "OLD SYNTAX: DEPRECATED - "
988 "use jtag_khz, not jtag_speed");
989
990 if (argc > 1)
991 return ERROR_COMMAND_SYNTAX_ERROR;
992 if (argc == 1)
993 {
994 LOG_DEBUG("handle jtag speed");
995
996 unsigned cur_speed = 0;
997 int retval = parse_uint(args[0], &cur_speed);
998 if (ERROR_OK != retval)
999 return retval;
1000 retval = jtag_config_speed(cur_speed);
1001
1002 }
1003 command_print(cmd_ctx, "jtag_speed: %d", jtag_get_speed());
1004
1005 return retval;
1006 }
1007
1008 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1009 {
1010 if (argc > 1)
1011 return ERROR_COMMAND_SYNTAX_ERROR;
1012
1013 int retval = ERROR_OK;
1014 if (argc == 1)
1015 {
1016 unsigned khz = 0;
1017 int retval = parse_uint(args[0], &khz);
1018 if (ERROR_OK != retval)
1019 return retval;
1020 retval = jtag_config_khz(khz);
1021 if (ERROR_OK != retval)
1022 return retval;
1023 }
1024
1025 int cur_speed = jtag_get_speed_khz();
1026 retval = jtag_get_speed_readable(&cur_speed);
1027 if (ERROR_OK != retval)
1028 return retval;
1029
1030 if (cur_speed)
1031 command_print(cmd_ctx, "%d kHz", cur_speed);
1032 else
1033 command_print(cmd_ctx, "RCLK - adaptive");
1034
1035 return retval;
1036 }
1037
1038 static int handle_jtag_rclk_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1039 {
1040 if (argc > 1)
1041 return ERROR_COMMAND_SYNTAX_ERROR;
1042
1043 int retval = ERROR_OK;
1044 if (argc == 1)
1045 {
1046 unsigned khz = 0;
1047 int retval = parse_uint(args[0], &khz);
1048 if (ERROR_OK != retval)
1049 return retval;
1050 retval = jtag_config_rclk(khz);
1051 if (ERROR_OK != retval)
1052 return retval;
1053 }
1054
1055 int cur_khz = jtag_get_speed_khz();
1056 retval = jtag_get_speed_readable(&cur_khz);
1057 if (ERROR_OK != retval)
1058 return retval;
1059
1060 if (cur_khz)
1061 command_print(cmd_ctx, "RCLK not supported - fallback to %d kHz", cur_khz);
1062 else
1063 command_print(cmd_ctx, "RCLK - adaptive");
1064
1065 return retval;
1066 }
1067
1068 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx,
1069 char *cmd, char **args, int argc)
1070 {
1071 if (argc != 2)
1072 return ERROR_COMMAND_SYNTAX_ERROR;
1073
1074 int trst = -1;
1075 if (args[0][0] == '1')
1076 trst = 1;
1077 else if (args[0][0] == '0')
1078 trst = 0;
1079 else
1080 return ERROR_COMMAND_SYNTAX_ERROR;
1081
1082 int srst = -1;
1083 if (args[1][0] == '1')
1084 srst = 1;
1085 else if (args[1][0] == '0')
1086 srst = 0;
1087 else
1088 return ERROR_COMMAND_SYNTAX_ERROR;
1089
1090 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1091 return ERROR_JTAG_INIT_FAILED;
1092
1093 jtag_add_reset(trst, srst);
1094 return jtag_execute_queue();
1095 }
1096
1097 static int handle_runtest_command(struct command_context_s *cmd_ctx,
1098 char *cmd, char **args, int argc)
1099 {
1100 if (argc != 1)
1101 return ERROR_COMMAND_SYNTAX_ERROR;
1102
1103 unsigned num_clocks;
1104 int retval = parse_uint(args[0], &num_clocks);
1105 if (ERROR_OK != retval)
1106 return retval;
1107
1108 jtag_add_runtest(num_clocks, TAP_IDLE);
1109 return jtag_execute_queue();
1110 }
1111
1112 /*
1113 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1114 * should be stable ... and *NOT* a shift state, otherwise free-running
1115 * jtag clocks could change the values latched by the update state.
1116 */
1117 static bool scan_is_safe(tap_state_t state)
1118 {
1119 switch (state)
1120 {
1121 case TAP_RESET:
1122 case TAP_IDLE:
1123 case TAP_DRPAUSE:
1124 case TAP_IRPAUSE:
1125 return true;
1126 default:
1127 return false;
1128 }
1129 }
1130
1131
1132 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1133 {
1134 int i;
1135 scan_field_t *fields;
1136 jtag_tap_t *tap;
1137 tap_state_t endstate;
1138
1139 if ((argc < 2) || (argc % 2))
1140 {
1141 return ERROR_COMMAND_SYNTAX_ERROR;
1142 }
1143
1144 /* optional "-endstate" "statename" at the end of the arguments,
1145 * so that e.g. IRPAUSE can let us load the data register before
1146 * entering RUN/IDLE to execute the instruction we load here.
1147 */
1148 endstate = TAP_IDLE;
1149
1150 if (argc >= 4) {
1151 /* have at least one pair of numbers. */
1152 /* is last pair the magic text? */
1153 if (0 == strcmp("-endstate", args[ argc - 2 ])) {
1154 const char *cpA;
1155 const char *cpS;
1156 cpA = args[ argc-1 ];
1157 for (endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++) {
1158 cpS = tap_state_name(endstate);
1159 if (0 == strcmp(cpA, cpS)) {
1160 break;
1161 }
1162 }
1163 if (endstate >= TAP_NUM_STATES) {
1164 return ERROR_COMMAND_SYNTAX_ERROR;
1165 } else {
1166 if (!scan_is_safe(endstate))
1167 LOG_WARNING("irscan with unsafe "
1168 "endstate \"%s\"", cpA);
1169 /* found - remove the last 2 args */
1170 argc -= 2;
1171 }
1172 }
1173 }
1174
1175 int num_fields = argc / 2;
1176 size_t fields_len = sizeof(scan_field_t) * num_fields;
1177 fields = malloc(fields_len);
1178 memset(fields, 0, fields_len);
1179
1180 int retval;
1181 for (i = 0; i < num_fields; i++)
1182 {
1183 tap = jtag_tap_by_string(args[i*2]);
1184 if (tap == NULL)
1185 {
1186 int j;
1187 for (j = 0; j < i; j++)
1188 free(fields[j].out_value);
1189 free(fields);
1190 command_print(cmd_ctx, "Tap: %s unknown", args[i*2]);
1191
1192 return ERROR_FAIL;
1193 }
1194 int field_size = tap->ir_length;
1195 fields[i].tap = tap;
1196 fields[i].num_bits = field_size;
1197 fields[i].out_value = malloc(CEIL(field_size, 8));
1198
1199 uint32_t value;
1200 retval = parse_u32(args[i * 2 + 1], &value);
1201 if (ERROR_OK != retval)
1202 goto error_return;
1203 buf_set_u32(fields[i].out_value, 0, field_size, value);
1204 fields[i].in_value = NULL;
1205 }
1206
1207 /* did we have an endstate? */
1208 jtag_add_ir_scan(num_fields, fields, endstate);
1209
1210 retval = jtag_execute_queue();
1211
1212 error_return:
1213 for (i = 0; i < num_fields; i++)
1214 {
1215 if (NULL != fields[i].out_value)
1216 free(fields[i].out_value);
1217 }
1218
1219 free (fields);
1220
1221 return retval;
1222 }
1223
1224 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1225 {
1226 int retval;
1227 scan_field_t *fields;
1228 int num_fields;
1229 int field_count = 0;
1230 int i, e;
1231 jtag_tap_t *tap;
1232 tap_state_t endstate;
1233
1234 /* args[1] = device
1235 * args[2] = num_bits
1236 * args[3] = hex string
1237 * ... repeat num bits and hex string ...
1238 *
1239 * .. optionally:
1240 * args[N-2] = "-endstate"
1241 * args[N-1] = statename
1242 */
1243 if ((argc < 4) || ((argc % 2) != 0))
1244 {
1245 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1246 return JIM_ERR;
1247 }
1248
1249 endstate = TAP_IDLE;
1250
1251 script_debug(interp, "drscan", argc, args);
1252
1253 /* validate arguments as numbers */
1254 e = JIM_OK;
1255 for (i = 2; i < argc; i += 2)
1256 {
1257 long bits;
1258 const char *cp;
1259
1260 e = Jim_GetLong(interp, args[i], &bits);
1261 /* If valid - try next arg */
1262 if (e == JIM_OK) {
1263 continue;
1264 }
1265
1266 /* Not valid.. are we at the end? */
1267 if (((i + 2) != argc)) {
1268 /* nope, then error */
1269 return e;
1270 }
1271
1272 /* it could be: "-endstate FOO"
1273 * e.g. DRPAUSE so we can issue more instructions
1274 * before entering RUN/IDLE and executing them.
1275 */
1276
1277 /* get arg as a string. */
1278 cp = Jim_GetString(args[i], NULL);
1279 /* is it the magic? */
1280 if (0 == strcmp("-endstate", cp)) {
1281 /* is the statename valid? */
1282 cp = Jim_GetString(args[i + 1], NULL);
1283
1284 /* see if it is a valid state name */
1285 endstate = tap_state_by_name(cp);
1286 if (endstate < 0) {
1287 /* update the error message */
1288 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1289 } else {
1290 if (!scan_is_safe(endstate))
1291 LOG_WARNING("drscan with unsafe "
1292 "endstate \"%s\"", cp);
1293
1294 /* valid - so clear the error */
1295 e = JIM_OK;
1296 /* and remove the last 2 args */
1297 argc -= 2;
1298 }
1299 }
1300
1301 /* Still an error? */
1302 if (e != JIM_OK) {
1303 return e; /* too bad */
1304 }
1305 } /* validate args */
1306
1307 tap = jtag_tap_by_jim_obj(interp, args[1]);
1308 if (tap == NULL) {
1309 return JIM_ERR;
1310 }
1311
1312 num_fields = (argc-2)/2;
1313 fields = malloc(sizeof(scan_field_t) * num_fields);
1314 for (i = 2; i < argc; i += 2)
1315 {
1316 long bits;
1317 int len;
1318 const char *str;
1319
1320 Jim_GetLong(interp, args[i], &bits);
1321 str = Jim_GetString(args[i + 1], &len);
1322
1323 fields[field_count].tap = tap;
1324 fields[field_count].num_bits = bits;
1325 fields[field_count].out_value = malloc(CEIL(bits, 8));
1326 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
1327 fields[field_count].in_value = fields[field_count].out_value;
1328 field_count++;
1329 }
1330
1331 jtag_add_dr_scan(num_fields, fields, endstate);
1332
1333 retval = jtag_execute_queue();
1334 if (retval != ERROR_OK)
1335 {
1336 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
1337 return JIM_ERR;
1338 }
1339
1340 field_count = 0;
1341 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1342 for (i = 2; i < argc; i += 2)
1343 {
1344 long bits;
1345 char *str;
1346
1347 Jim_GetLong(interp, args[i], &bits);
1348 str = buf_to_str(fields[field_count].in_value, bits, 16);
1349 free(fields[field_count].out_value);
1350
1351 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
1352 free(str);
1353 field_count++;
1354 }
1355
1356 Jim_SetResult(interp, list);
1357
1358 free(fields);
1359
1360 return JIM_OK;
1361 }
1362
1363
1364 static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1365 {
1366 tap_state_t states[8];
1367
1368 if ((argc < 2) || ((size_t)argc > (sizeof(states)/sizeof(*states) + 1)))
1369 {
1370 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1371 return JIM_ERR;
1372 }
1373
1374 script_debug(interp, "pathmove", argc, args);
1375
1376 int i;
1377 for (i = 0; i < argc-1; i++)
1378 {
1379 const char *cp;
1380 cp = Jim_GetString(args[i + 1], NULL);
1381 states[i] = tap_state_by_name(cp);
1382 if (states[i] < 0)
1383 {
1384 /* update the error message */
1385 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp);
1386 return JIM_ERR;
1387 }
1388 }
1389
1390 if ((jtag_add_statemove(states[0]) != ERROR_OK) || (jtag_execute_queue()!= ERROR_OK))
1391 {
1392 Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
1393 return JIM_ERR;
1394 }
1395
1396 jtag_add_pathmove(argc-2, states + 1);
1397
1398 if (jtag_execute_queue()!= ERROR_OK)
1399 {
1400 Jim_SetResultString(interp, "pathmove: failed",-1);
1401 return JIM_ERR;
1402 }
1403
1404 return JIM_OK;
1405 }
1406
1407
1408 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1409 {
1410 script_debug(interp, "flush_count", argc, args);
1411
1412 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
1413
1414 return JIM_OK;
1415 }
1416
1417
1418 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1419 {
1420 if (argc > 1)
1421 return ERROR_COMMAND_SYNTAX_ERROR;
1422
1423 if (argc == 1)
1424 {
1425 if (strcmp(args[0], "enable") == 0)
1426 jtag_set_verify_capture_ir(true);
1427 else if (strcmp(args[0], "disable") == 0)
1428 jtag_set_verify_capture_ir(false);
1429 else
1430 return ERROR_COMMAND_SYNTAX_ERROR;
1431 }
1432
1433 const char *status = jtag_will_verify_capture_ir() ? "enabled": "disabled";
1434 command_print(cmd_ctx, "verify Capture-IR is %s", status);
1435
1436 return ERROR_OK;
1437 }
1438
1439 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1440 {
1441 if (argc > 1)
1442 return ERROR_COMMAND_SYNTAX_ERROR;
1443
1444 if (argc == 1)
1445 {
1446 if (strcmp(args[0], "enable") == 0)
1447 jtag_set_verify(true);
1448 else if (strcmp(args[0], "disable") == 0)
1449 jtag_set_verify(false);
1450 else
1451 return ERROR_COMMAND_SYNTAX_ERROR;
1452 }
1453
1454 const char *status = jtag_will_verify() ? "enabled": "disabled";
1455 command_print(cmd_ctx, "verify jtag capture is %s", status);
1456
1457 return ERROR_OK;
1458 }
1459
1460 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1461 {
1462 if (argc > 1)
1463 return ERROR_COMMAND_SYNTAX_ERROR;
1464
1465 if (argc == 1)
1466 {
1467 bool use_new_table;
1468 if (strcmp(args[0], "short") == 0)
1469 use_new_table = true;
1470 else if (strcmp(args[0], "long") == 0)
1471 use_new_table = false;
1472 else
1473 return ERROR_COMMAND_SYNTAX_ERROR;
1474
1475 tap_use_new_tms_table(use_new_table);
1476 }
1477
1478 command_print(cmd_ctx, "tms sequence is %s",
1479 tap_uses_new_tms_table() ? "short": "long");
1480
1481 return ERROR_OK;
1482 }
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)