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