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