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