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