git.gag.com Git - fw/openocd/blob - 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 const Jim_Nvp nvp_jtag_tap_event[];
  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         enum reset_types old_cfg = jtag_get_reset_config();
 923         old_cfg &= ~mask;
 924         new_cfg |= old_cfg;
 925         jtag_set_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
 999         cur_speed = jtag_get_speed_khz();
1000         if (jtag != NULL)
1001         {
1002                 retval = jtag->speed_div(jtag_get_speed(), &cur_speed);
1003                 if (ERROR_OK != retval)
1004                         return retval;
1005         }
1006
1007         if (cur_speed)
1008                 command_print(cmd_ctx, "%d kHz", cur_speed);
1009         else
1010                 command_print(cmd_ctx, "RCLK - adaptive");
1011         return retval;
1012
1013 }
1014
1015 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx,
1016                 char *cmd, char **args, int argc)
1017 {
1018         if (argc != 2)
1019                 return ERROR_COMMAND_SYNTAX_ERROR;
1020
1021         int trst = -1;
1022         if (args[0][0] == '1')
1023                 trst = 1;
1024         else if (args[0][0] == '0')
1025                 trst = 0;
1026         else
1027                 return ERROR_COMMAND_SYNTAX_ERROR;
1028
1029         int srst = -1;
1030         if (args[1][0] == '1')
1031                 srst = 1;
1032         else if (args[1][0] == '0')
1033                 srst = 0;
1034         else
1035                 return ERROR_COMMAND_SYNTAX_ERROR;
1036
1037         if (jtag_interface_init(cmd_ctx) != ERROR_OK)
1038                 return ERROR_JTAG_INIT_FAILED;
1039
1040         jtag_add_reset(trst, srst);
1041         jtag_execute_queue();
1042
1043         return ERROR_OK;
1044 }
1045
1046 static int handle_runtest_command(struct command_context_s *cmd_ctx,
1047                 char *cmd, char **args, int argc)
1048 {
1049         if (argc != 1)
1050                 return ERROR_COMMAND_SYNTAX_ERROR;
1051
1052         jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state());
1053         jtag_execute_queue();
1054
1055         return ERROR_OK;
1056 }
1057
1058 /*
1059  * For "irscan" or "drscan" commands, the "end" (really, "next") state
1060  * should be stable ... and *NOT* a shift state, otherwise free-running
1061  * jtag clocks could change the values latched by the update state.
1062  */
1063 static bool scan_is_safe(tap_state_t state)
1064 {
1065         switch (state)
1066         {
1067         case TAP_RESET:
1068         case TAP_IDLE:
1069         case TAP_DRPAUSE:
1070         case TAP_IRPAUSE:
1071                 return true;
1072         default:
1073                 return false;
1074         }
1075 }
1076
1077
1078 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1079 {
1080         int i;
1081         scan_field_t *fields;
1082         jtag_tap_t *tap;
1083         tap_state_t endstate;
1084
1085         if ((argc < 2) || (argc % 2))
1086         {
1087                 return ERROR_COMMAND_SYNTAX_ERROR;
1088         }
1089
1090         /* optional "-endstate" "statename" at the end of the arguments,
1091          * so that e.g. IRPAUSE can let us load the data register before
1092          * entering RUN/IDLE to execute the instruction we load here.
1093          */
1094         endstate = TAP_IDLE;
1095
1096         if( argc >= 4 ){
1097                 /* have at least one pair of numbers. */
1098                 /* is last pair the magic text? */
1099                 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
1100                         const char *cpA;
1101                         const char *cpS;
1102                         cpA = args[ argc-1 ];
1103                         for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
1104                                 cpS = tap_state_name( endstate );
1105                                 if( 0 == strcmp( cpA, cpS ) ){
1106                                         break;
1107                                 }
1108                         }
1109                         if( endstate >= TAP_NUM_STATES ){
1110                                 return ERROR_COMMAND_SYNTAX_ERROR;
1111                         } else {
1112                                 if (!scan_is_safe(endstate))
1113                                         LOG_WARNING("irscan with unsafe "
1114                                                         "endstate \"%s\"", cpA);
1115                                 /* found - remove the last 2 args */
1116                                 argc -= 2;
1117                         }
1118                 }
1119         }
1120
1121         int num_fields = argc / 2;
1122
1123         fields = malloc(sizeof(scan_field_t) * num_fields);
1124
1125         for (i = 0; i < num_fields; i++)
1126         {
1127                 tap = jtag_tap_by_string( args[i*2] );
1128                 if (tap==NULL)
1129                 {
1130                         command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
1131                         return ERROR_FAIL;
1132                 }
1133                 int field_size = tap->ir_length;
1134                 fields[i].tap = tap;
1135                 fields[i].num_bits = field_size;
1136                 fields[i].out_value = malloc(CEIL(field_size, 8));
1137                 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
1138                 fields[i].in_value = NULL;
1139         }
1140
1141         /* did we have an endstate? */
1142         jtag_add_ir_scan(num_fields, fields, endstate);
1143
1144         int retval=jtag_execute_queue();
1145
1146         for (i = 0; i < num_fields; i++)
1147                 free(fields[i].out_value);
1148
1149         free (fields);
1150
1151         return retval;
1152 }
1153
1154 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1155 {
1156         int retval;
1157         scan_field_t *fields;
1158         int num_fields;
1159         int field_count = 0;
1160         int i, e;
1161         jtag_tap_t *tap;
1162         tap_state_t endstate;
1163
1164         /* args[1] = device
1165          * args[2] = num_bits
1166          * args[3] = hex string
1167          * ... repeat num bits and hex string ...
1168          *
1169          * .. optionally:
1170         *     args[N-2] = "-endstate"
1171          *     args[N-1] = statename
1172          */
1173         if ((argc < 4) || ((argc % 2)!=0))
1174         {
1175                 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
1176                 return JIM_ERR;
1177         }
1178
1179         endstate = TAP_IDLE;
1180
1181         /* validate arguments as numbers */
1182         e = JIM_OK;
1183         for (i = 2; i < argc; i+=2)
1184         {
1185                 long bits;
1186                 const char *cp;
1187
1188                 e = Jim_GetLong(interp, args[i], &bits);
1189                 /* If valid - try next arg */
1190                 if( e == JIM_OK ){
1191                         continue;
1192                 }
1193
1194                 /* Not valid.. are we at the end? */
1195                 if ( ((i+2) != argc) ){
1196                         /* nope, then error */
1197                         return e;
1198                 }
1199
1200                 /* it could be: "-endstate FOO"
1201                  * e.g. DRPAUSE so we can issue more instructions
1202                  * before entering RUN/IDLE and executing them.
1203                  */
1204
1205                 /* get arg as a string. */
1206                 cp = Jim_GetString( args[i], NULL );
1207                 /* is it the magic? */
1208                 if( 0 == strcmp( "-endstate", cp ) ){
1209                         /* is the statename valid? */
1210                         cp = Jim_GetString( args[i+1], NULL );
1211
1212                         /* see if it is a valid state name */
1213                         endstate = tap_state_by_name(cp);
1214                         if( endstate < 0 ){
1215                                 /* update the error message */
1216                                 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
1217                         } else {
1218                                 if (!scan_is_safe(endstate))
1219                                         LOG_WARNING("drscan with unsafe "
1220                                                         "endstate \"%s\"", cp);
1221
1222                                 /* valid - so clear the error */
1223                                 e = JIM_OK;
1224                                 /* and remove the last 2 args */
1225                                 argc -= 2;
1226                         }
1227                 }
1228
1229                 /* Still an error? */
1230                 if( e != JIM_OK ){
1231                         return e; /* too bad */
1232                 }
1233         } /* validate args */
1234
1235         tap = jtag_tap_by_jim_obj( interp, args[1] );
1236         if( tap == NULL ){
1237                 return JIM_ERR;
1238         }
1239
1240         num_fields=(argc-2)/2;
1241         fields = malloc(sizeof(scan_field_t) * num_fields);
1242         for (i = 2; i < argc; i+=2)
1243         {
1244                 long bits;
1245                 int len;
1246                 const char *str;
1247
1248                 Jim_GetLong(interp, args[i], &bits);
1249                 str = Jim_GetString(args[i+1], &len);
1250
1251                 fields[field_count].tap = tap;
1252                 fields[field_count].num_bits = bits;
1253                 fields[field_count].out_value = malloc(CEIL(bits, 8));
1254                 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
1255                 fields[field_count].in_value = fields[field_count].out_value;
1256                 field_count++;
1257         }
1258
1259         jtag_add_dr_scan(num_fields, fields, endstate);
1260
1261         retval = jtag_execute_queue();
1262         if (retval != ERROR_OK)
1263         {
1264                 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
1265                 return JIM_ERR;
1266         }
1267
1268         field_count=0;
1269         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1270         for (i = 2; i < argc; i+=2)
1271         {
1272                 long bits;
1273                 char *str;
1274
1275                 Jim_GetLong(interp, args[i], &bits);
1276                 str = buf_to_str(fields[field_count].in_value, bits, 16);
1277                 free(fields[field_count].out_value);
1278
1279                 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
1280                 free(str);
1281                 field_count++;
1282         }
1283
1284         Jim_SetResult(interp, list);
1285
1286         free(fields);
1287
1288         return JIM_OK;
1289 }
1290
1291
1292 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
1293 {
1294         Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
1295
1296         return JIM_OK;
1297 }
1298
1299
1300 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1301 {
1302         if (argc > 1)
1303                 return ERROR_COMMAND_SYNTAX_ERROR;
1304
1305         if (argc == 1)
1306         {
1307                 if (strcmp(args[0], "enable") == 0)
1308                         jtag_set_verify_capture_ir(true);
1309                 else if (strcmp(args[0], "disable") == 0)
1310                         jtag_set_verify_capture_ir(false);
1311                 else
1312                         return ERROR_COMMAND_SYNTAX_ERROR;
1313         }
1314
1315         const char *status = jtag_will_verify_capture_ir() ? "enabled": "disabled";
1316         command_print(cmd_ctx, "verify Capture-IR is %s", status);
1317
1318         return ERROR_OK;
1319 }
1320
1321 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1322 {
1323         if (argc > 1)
1324                 return ERROR_COMMAND_SYNTAX_ERROR;
1325
1326         if (argc == 1)
1327         {
1328                 if (strcmp(args[0], "enable") == 0)
1329                         jtag_set_verify(true);
1330                 else if (strcmp(args[0], "disable") == 0)
1331                         jtag_set_verify(false);
1332                 else
1333                         return ERROR_COMMAND_SYNTAX_ERROR;
1334         }
1335
1336         const char *status = jtag_will_verify() ? "enabled": "disabled";
1337         command_print(cmd_ctx, "verify jtag capture is %s", status);
1338
1339         return ERROR_OK;
1340 }
1341
1342 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1343 {
1344         if (argc > 1)
1345                 return ERROR_COMMAND_SYNTAX_ERROR;
1346
1347         if (argc == 1)
1348         {
1349                 bool use_new_table;
1350                 if (strcmp(args[0], "short") == 0)
1351                         use_new_table = true;
1352                 else if (strcmp(args[0], "long") == 0)
1353                         use_new_table = false;
1354                 else
1355                         return ERROR_COMMAND_SYNTAX_ERROR;
1356
1357                 tap_use_new_tms_table(use_new_table);
1358         }
1359
1360         command_print(cmd_ctx, "tms sequence is  %s",
1361                         tap_uses_new_tms_table() ? "short": "long");
1362
1363         return ERROR_OK;
1364 }
1365