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 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