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