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