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