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