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