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