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