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