Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Improve JTAG reset, speed, and khz handlers to use parse_uint helper.
[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 {
975 unsigned delay;
976 int retval = parse_uint(args[0], &delay);
977 if (ERROR_OK != retval)
978 return retval;
979 jtag_set_nsrst_delay(delay);
980 }
981 command_print(cmd_ctx, "jtag_nsrst_delay: %u", jtag_get_nsrst_delay());
982 return ERROR_OK;
983 }
984
985 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx,
986 char *cmd, char **args, int argc)
987 {
988 if (argc > 1)
989 return ERROR_COMMAND_SYNTAX_ERROR;
990 if (argc == 1)
991 {
992 unsigned delay;
993 int retval = parse_uint(args[0], &delay);
994 if (ERROR_OK != retval)
995 return retval;
996 jtag_set_ntrst_delay(delay);
997 }
998 command_print(cmd_ctx, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay());
999 return ERROR_OK;
1000 }
1001
1002 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1003 {
1004 int retval = ERROR_OK;
1005
1006 if (argc > 1)
1007 return ERROR_COMMAND_SYNTAX_ERROR;
1008 if (argc == 1)
1009 {
1010 LOG_DEBUG("handle jtag speed");
1011
1012 unsigned cur_speed = 0;
1013 int retval = parse_uint(args[0], &cur_speed);
1014 if (ERROR_OK != retval)
1015 return retval;
1016 retval = jtag_set_speed(cur_speed);
1017
1018 }
1019 command_print(cmd_ctx, "jtag_speed: %d", jtag_get_speed());
1020
1021 return retval;
1022 }
1023
1024 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1025 {
1026 if (argc > 1)
1027 return ERROR_COMMAND_SYNTAX_ERROR;
1028
1029 int retval = ERROR_OK;
1030 if (argc == 1)
1031 {
1032 unsigned khz = 0;
1033 int retval = parse_uint(args[0], &khz);
1034 if (ERROR_OK != retval)
1035 return retval;
1036 retval = jtag_config_khz(khz);
1037 if (ERROR_OK != retval)
1038 return retval;
1039 }
1040
1041 int cur_speed;
1042 retval = jtag_get_speed_readable(&cur_speed);
1043 if (ERROR_OK != retval)
1044 return retval;
1045
1046 if (cur_speed)
1047 command_print(cmd_ctx, "%d kHz", cur_speed);
1048 else
1049 command_print(cmd_ctx, "RCLK - adaptive");
1050
1051 return retval;
1052 }
1053
1054 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx,
1055 char *cmd, char **args, int argc)
1056 {
1057 if (argc != 2)
1058 return ERROR_COMMAND_SYNTAX_ERROR;
1059
1060 int trst = -1;
1061 if (args[0][0] == '1')
1062 trst = 1;
1063 else if (args[0][0] == '0')
1064 trst = 0;
1065 else
1066 return ERROR_COMMAND_SYNTAX_ERROR;
1067
1068 int srst = -1;
1069 if (args[1][0] == '1')
1070 srst = 1;
1071 else if (args[1][0] == '0')
1072 srst = 0;
1073 else
1074 return ERROR_COMMAND_SYNTAX_ERROR;
1075
1076 if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1077 return ERROR_JTAG_INIT_FAILED;
1078
1079 jtag_add_reset(trst, srst);
1080 jtag_execute_queue();
1081
1082 return ERROR_OK;
1083 }
1084
1085 static int handle_runtest_command(struct command_context_s *cmd_ctx,
1086 char *cmd, char **args, int argc)
1087 {
1088 if (argc != 1)
1089 return ERROR_COMMAND_SYNTAX_ERROR;
1090
1091 jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state());
1092 jtag_execute_queue();
1093
1094 return ERROR_OK;
1095 }
1096
1097 /*
1098 * For "irscan" or "drscan" commands, the "end" (really, "next") state
1099 * should be stable ... and *NOT* a shift state, otherwise free-running
1100 * jtag clocks could change the values latched by the update state.
1101 */
1102 static bool scan_is_safe(tap_state_t state)
1103 {
1104 switch (state)
1105 {
1106 case TAP_RESET:
1107 case TAP_IDLE:
1108 case TAP_DRPAUSE:
1109 case TAP_IRPAUSE:
1110 return true;
1111 default:
1112 return false;
1113 }
1114 }
1115
1116
1117 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1118 {
1119 int i;
1120 scan_field_t *fields;
1121 jtag_tap_t *tap;
1122 tap_state_t endstate;
1123
1124 if ((argc < 2) || (argc % 2))
1125 {
1126 return ERROR_COMMAND_SYNTAX_ERROR;
1127 }
1128
1129 /* optional "-endstate" "statename" at the end of the arguments,
1130 * so that e.g. IRPAUSE can let us load the data register before
1131 * entering RUN/IDLE to execute the instruction we load here.
1132 */
1133 endstate = TAP_IDLE;
1134
1135 if( argc >= 4 ){
1136 /* have at least one pair of numbers. */
1137 /* is last pair the magic text? */
1138 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
1139 const char *cpA;
1140 const char *cpS;
1141 cpA = args[ argc-1 ];
1142 for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
1143 cpS = tap_state_name( endstate );
1144 if( 0 == strcmp( cpA, cpS ) ){
1145 break;
1146 }
1147 }
1148 if( endstate >= TAP_NUM_STATES ){
1149 return ERROR_COMMAND_SYNTAX_ERROR;
1150 } else {
1151 if (!scan_is_safe(endstate))
1152 LOG_WARNING("irscan with unsafe "
1153 "endstate \"%s\"", cpA);
1154 /* found - remove the last 2 args */
1155 argc -= 2;
1156 }
1157 }
1158 }
1159
1160 int num_fields = argc / 2;
1161
1162 fields = malloc(sizeof(scan_field_t) * num_fields);
1163
1164 for (i = 0; i < num_fields; i++)
1165 {
1166 tap = jtag_tap_by_string( args[i*2] );
1167 if (tap==NULL)
1168 {
1169 command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
1170 return ERROR_FAIL;
1171 }
1172 int field_size = tap->ir_length;
1173 fields[i].tap = tap;
1174 fields[i].num_bits = field_size;
1175 fields[i].out_value = malloc(CEIL(field_size, 8));
1176 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1177 fields[i].in_value = NULL;
1178 }
1179
1180 /* did we have an endstate? */
1181 jtag_add_ir_scan(num_fields, fields, endstate);
1182
1183 int retval=jtag_execute_queue();
1184
1185 for (i = 0; i < num_fields; i++)
1186 free(fields[i].out_value);
1187
1188 free (fields);
1189
1190 return retval;
1191 }
1192
1193 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1194 {
1195 int retval;
1196 scan_field_t *fields;
1197 int num_fields;
1198 int field_count = 0;
1199 int i, e;
1200 jtag_tap_t *tap;
1201 tap_state_t endstate;
1202
1203 /* args[1] = device
1204 * args[2] = num_bits
1205 * args[3] = hex string
1206 * ... repeat num bits and hex string ...
1207 *
1208 * .. optionally:
1209 * args[N-2] = "-endstate"
1210 * args[N-1] = statename
1211 */
1212 if ((argc < 4) || ((argc % 2)!=0))
1213 {
1214 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1215 return JIM_ERR;
1216 }
1217
1218 endstate = TAP_IDLE;
1219
1220 /* validate arguments as numbers */
1221 e = JIM_OK;
1222 for (i = 2; i < argc; i+=2)
1223 {
1224 long bits;
1225 const char *cp;
1226
1227 e = Jim_GetLong(interp, args[i], &bits);
1228 /* If valid - try next arg */
1229 if( e == JIM_OK ){
1230 continue;
1231 }
1232
1233 /* Not valid.. are we at the end? */
1234 if ( ((i+2) != argc) ){
1235 /* nope, then error */
1236 return e;
1237 }
1238
1239 /* it could be: "-endstate FOO"
1240 * e.g. DRPAUSE so we can issue more instructions
1241 * before entering RUN/IDLE and executing them.
1242 */
1243
1244 /* get arg as a string. */
1245 cp = Jim_GetString( args[i], NULL );
1246 /* is it the magic? */
1247 if( 0 == strcmp( "-endstate", cp ) ){
1248 /* is the statename valid? */
1249 cp = Jim_GetString( args[i+1], NULL );
1250
1251 /* see if it is a valid state name */
1252 endstate = tap_state_by_name(cp);
1253 if( endstate < 0 ){
1254 /* update the error message */
1255 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
1256 } else {
1257 if (!scan_is_safe(endstate))
1258 LOG_WARNING("drscan with unsafe "
1259 "endstate \"%s\"", cp);
1260
1261 /* valid - so clear the error */
1262 e = JIM_OK;
1263 /* and remove the last 2 args */
1264 argc -= 2;
1265 }
1266 }
1267
1268 /* Still an error? */
1269 if( e != JIM_OK ){
1270 return e; /* too bad */
1271 }
1272 } /* validate args */
1273
1274 tap = jtag_tap_by_jim_obj( interp, args[1] );
1275 if( tap == NULL ){
1276 return JIM_ERR;
1277 }
1278
1279 num_fields=(argc-2)/2;
1280 fields = malloc(sizeof(scan_field_t) * num_fields);
1281 for (i = 2; i < argc; i+=2)
1282 {
1283 long bits;
1284 int len;
1285 const char *str;
1286
1287 Jim_GetLong(interp, args[i], &bits);
1288 str = Jim_GetString(args[i+1], &len);
1289
1290 fields[field_count].tap = tap;
1291 fields[field_count].num_bits = bits;
1292 fields[field_count].out_value = malloc(CEIL(bits, 8));
1293 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
1294 fields[field_count].in_value = fields[field_count].out_value;
1295 field_count++;
1296 }
1297
1298 jtag_add_dr_scan(num_fields, fields, endstate);
1299
1300 retval = jtag_execute_queue();
1301 if (retval != ERROR_OK)
1302 {
1303 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
1304 return JIM_ERR;
1305 }
1306
1307 field_count=0;
1308 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1309 for (i = 2; i < argc; i+=2)
1310 {
1311 long bits;
1312 char *str;
1313
1314 Jim_GetLong(interp, args[i], &bits);
1315 str = buf_to_str(fields[field_count].in_value, bits, 16);
1316 free(fields[field_count].out_value);
1317
1318 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
1319 free(str);
1320 field_count++;
1321 }
1322
1323 Jim_SetResult(interp, list);
1324
1325 free(fields);
1326
1327 return JIM_OK;
1328 }
1329
1330
1331 static int Jim_Command_pathmove(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1332 {
1333 tap_state_t states[8];
1334
1335 if ((argc < 2) || ((size_t)argc > (sizeof(states)/sizeof(*states)+1)))
1336 {
1337 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1338 return JIM_ERR;
1339 }
1340
1341 int i;
1342 for (i=0; i<argc-1; i++)
1343 {
1344 const char *cp;
1345 cp = Jim_GetString( args[i+1], NULL );
1346 states[i] = tap_state_by_name(cp);
1347 if( states[i] < 0 )
1348 {
1349 /* update the error message */
1350 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
1351 return JIM_ERR;
1352 }
1353 }
1354
1355 if ((jtag_add_statemove(states[0]) != ERROR_OK) || ( jtag_execute_queue()!= ERROR_OK))
1356 {
1357 Jim_SetResultString(interp, "pathmove: jtag execute failed",-1);
1358 return JIM_ERR;
1359 }
1360
1361 jtag_add_pathmove(argc-2, states+1);
1362
1363 if (jtag_execute_queue()!= ERROR_OK)
1364 {
1365 Jim_SetResultString(interp, "pathmove: failed",-1);
1366 return JIM_ERR;
1367 }
1368
1369 return JIM_OK;
1370 }
1371
1372
1373 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1374 {
1375 Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
1376
1377 return JIM_OK;
1378 }
1379
1380
1381 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1382 {
1383 if (argc > 1)
1384 return ERROR_COMMAND_SYNTAX_ERROR;
1385
1386 if (argc == 1)
1387 {
1388 if (strcmp(args[0], "enable") == 0)
1389 jtag_set_verify_capture_ir(true);
1390 else if (strcmp(args[0], "disable") == 0)
1391 jtag_set_verify_capture_ir(false);
1392 else
1393 return ERROR_COMMAND_SYNTAX_ERROR;
1394 }
1395
1396 const char *status = jtag_will_verify_capture_ir() ? "enabled": "disabled";
1397 command_print(cmd_ctx, "verify Capture-IR is %s", status);
1398
1399 return ERROR_OK;
1400 }
1401
1402 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1403 {
1404 if (argc > 1)
1405 return ERROR_COMMAND_SYNTAX_ERROR;
1406
1407 if (argc == 1)
1408 {
1409 if (strcmp(args[0], "enable") == 0)
1410 jtag_set_verify(true);
1411 else if (strcmp(args[0], "disable") == 0)
1412 jtag_set_verify(false);
1413 else
1414 return ERROR_COMMAND_SYNTAX_ERROR;
1415 }
1416
1417 const char *status = jtag_will_verify() ? "enabled": "disabled";
1418 command_print(cmd_ctx, "verify jtag capture is %s", status);
1419
1420 return ERROR_OK;
1421 }
1422
1423 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1424 {
1425 if (argc > 1)
1426 return ERROR_COMMAND_SYNTAX_ERROR;
1427
1428 if (argc == 1)
1429 {
1430 bool use_new_table;
1431 if (strcmp(args[0], "short") == 0)
1432 use_new_table = true;
1433 else if (strcmp(args[0], "long") == 0)
1434 use_new_table = false;
1435 else
1436 return ERROR_COMMAND_SYNTAX_ERROR;
1437
1438 tap_use_new_tms_table(use_new_table);
1439 }
1440
1441 command_print(cmd_ctx, "tms sequence is %s",
1442 tap_uses_new_tms_table() ? "short": "long");
1443
1444 return ERROR_OK;
1445 }
1446
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)