git.gag.com Git - fw/openocd/blob - src/jtag/jtag.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  *   This program is free software; you can redistribute it and/or modify  *
  13  *   it under the terms of the GNU General Public License as published by  *
  14  *   the Free Software Foundation; either version 2 of the License, or     *
  15  *   (at your option) any later version.                                   *
  16  *                                                                         *
  17  *   This program is distributed in the hope that it will be useful,       *
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  20  *   GNU General Public License for more details.                          *
  21  *                                                                         *
  22  *   You should have received a copy of the GNU General Public License     *
  23  *   along with this program; if not, write to the                         *
  24  *   Free Software Foundation, Inc.,                                       *
  25  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  26  ***************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "jtag.h"
  32 #include "minidriver.h"
  33 #include "interface.h"
  34
  35 #ifdef HAVE_STRINGS_H
  36 #include <strings.h>
  37 #endif
  38
  39
  40 /// The number of JTAG queue flushes (for profiling and debugging purposes).
  41 static int jtag_flush_queue_count;
  42
  43 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
  44                 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
  45
  46 /* note that this is not marked as static as it must be available from outside jtag.c for those
  47    that implement the jtag_xxx() minidriver layer
  48 */
  49 int jtag_error=ERROR_OK;
  50
  51 char* jtag_event_strings[] =
  52 {
  53         "JTAG controller reset (RESET or TRST)"
  54 };
  55
  56 const Jim_Nvp nvp_jtag_tap_event[] = {
  57         { .value = JTAG_TAP_EVENT_ENABLE,       .name = "tap-enable" },
  58         { .value = JTAG_TAP_EVENT_DISABLE,      .name = "tap-disable" },
  59
  60         { .name = NULL, .value = -1 }
  61 };
  62
  63 int jtag_trst = 0;
  64 int jtag_srst = 0;
  65
  66 /**
  67  * List all TAPs that have been created.
  68  */
  69 static jtag_tap_t *__jtag_all_taps = NULL;
  70 /**
  71  * The number of TAPs in the __jtag_all_taps list, used to track the
  72  * assigned chain position to new TAPs
  73  */
  74 static int jtag_num_taps = 0;
  75
  76 enum reset_types jtag_reset_config = RESET_NONE;
  77 tap_state_t cmd_queue_end_state = TAP_RESET;
  78 tap_state_t cmd_queue_cur_state = TAP_RESET;
  79
  80 int jtag_verify_capture_ir = 1;
  81 int jtag_verify = 1;
  82
  83 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
  84 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
  85 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
  86
  87 /* maximum number of JTAG devices expected in the chain
  88  */
  89 #define JTAG_MAX_CHAIN_SIZE 20
  90
  91 /* callbacks to inform high-level handlers about JTAG state changes */
  92 jtag_event_callback_t *jtag_event_callbacks;
  93
  94 /* speed in kHz*/
  95 static int speed_khz = 0;
  96 /* flag if the kHz speed was defined */
  97 static bool hasKHz = false;
  98
  99 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
 100  */
 101
 102 #if BUILD_ECOSBOARD == 1
 103         extern jtag_interface_t zy1000_interface;
 104 #endif
 105
 106 #if BUILD_PARPORT == 1
 107         extern jtag_interface_t parport_interface;
 108 #endif
 109
 110 #if BUILD_DUMMY == 1
 111         extern jtag_interface_t dummy_interface;
 112 #endif
 113
 114 #if BUILD_FT2232_FTD2XX == 1
 115         extern jtag_interface_t ft2232_interface;
 116 #endif
 117
 118 #if BUILD_FT2232_LIBFTDI == 1
 119         extern jtag_interface_t ft2232_interface;
 120 #endif
 121
 122 #if BUILD_AMTJTAGACCEL == 1
 123         extern jtag_interface_t amt_jtagaccel_interface;
 124 #endif
 125
 126 #if BUILD_EP93XX == 1
 127         extern jtag_interface_t ep93xx_interface;
 128 #endif
 129
 130 #if BUILD_AT91RM9200 == 1
 131         extern jtag_interface_t at91rm9200_interface;
 132 #endif
 133
 134 #if BUILD_GW16012 == 1
 135         extern jtag_interface_t gw16012_interface;
 136 #endif
 137
 138 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 139         extern jtag_interface_t presto_interface;
 140 #endif
 141
 142 #if BUILD_USBPROG == 1
 143         extern jtag_interface_t usbprog_interface;
 144 #endif
 145
 146 #if BUILD_JLINK == 1
 147         extern jtag_interface_t jlink_interface;
 148 #endif
 149
 150 #if BUILD_VSLLINK == 1
 151         extern jtag_interface_t vsllink_interface;
 152 #endif
 153
 154 #if BUILD_RLINK == 1
 155         extern jtag_interface_t rlink_interface;
 156 #endif
 157
 158 #if BUILD_ARMJTAGEW == 1
 159         extern jtag_interface_t armjtagew_interface;
 160 #endif
 161
 162 jtag_interface_t *jtag_interfaces[] = {
 163 #if BUILD_ECOSBOARD == 1
 164         &zy1000_interface,
 165 #endif
 166 #if BUILD_PARPORT == 1
 167         &parport_interface,
 168 #endif
 169 #if BUILD_DUMMY == 1
 170         &dummy_interface,
 171 #endif
 172 #if BUILD_FT2232_FTD2XX == 1
 173         &ft2232_interface,
 174 #endif
 175 #if BUILD_FT2232_LIBFTDI == 1
 176         &ft2232_interface,
 177 #endif
 178 #if BUILD_AMTJTAGACCEL == 1
 179         &amt_jtagaccel_interface,
 180 #endif
 181 #if BUILD_EP93XX == 1
 182         &ep93xx_interface,
 183 #endif
 184 #if BUILD_AT91RM9200 == 1
 185         &at91rm9200_interface,
 186 #endif
 187 #if BUILD_GW16012 == 1
 188         &gw16012_interface,
 189 #endif
 190 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 191         &presto_interface,
 192 #endif
 193 #if BUILD_USBPROG == 1
 194         &usbprog_interface,
 195 #endif
 196 #if BUILD_JLINK == 1
 197         &jlink_interface,
 198 #endif
 199 #if BUILD_VSLLINK == 1
 200         &vsllink_interface,
 201 #endif
 202 #if BUILD_RLINK == 1
 203         &rlink_interface,
 204 #endif
 205 #if BUILD_ARMJTAGEW == 1
 206         &armjtagew_interface,
 207 #endif
 208         NULL,
 209 };
 210
 211 struct jtag_interface_s *jtag = NULL;
 212
 213 /* configuration */
 214 static jtag_interface_t *jtag_interface = NULL;
 215 int jtag_speed = 0;
 216
 217 /* jtag commands */
 218 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 219 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 220 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 221 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 222 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 223 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 224 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 225
 226 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 227
 228 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 229 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 230 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 231 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 232 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 233 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
 234
 235 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 236 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 237 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 238
 239 jtag_tap_t *jtag_all_taps(void)
 240 {
 241         return __jtag_all_taps;
 242 };
 243
 244 int jtag_NumTotalTaps(void)
 245 {
 246         return jtag_num_taps;
 247 }
 248
 249 int jtag_NumEnabledTaps(void)
 250 {
 251         jtag_tap_t *t;
 252         int n;
 253
 254         n = 0;
 255         t = jtag_all_taps();
 256         while(t){
 257                 if( t->enabled ){
 258                         n++;
 259                 }
 260                 t = t->next_tap;
 261         }
 262         return n;
 263 }
 264
 265 /// Append a new TAP to the chain of all taps.
 266 static void jtag_tap_add(struct jtag_tap_s *t)
 267 {
 268         t->abs_chain_position = jtag_num_taps++;
 269
 270         jtag_tap_t **tap = &__jtag_all_taps;
 271         while(*tap != NULL)
 272                 tap = &(*tap)->next_tap;
 273         *tap = t;
 274 }
 275
 276 jtag_tap_t *jtag_tap_by_string( const char *s )
 277 {
 278         jtag_tap_t *t;
 279         char *cp;
 280
 281         t = jtag_all_taps();
 282         /* try name first */
 283         while(t){
 284                 if( 0 == strcmp( t->dotted_name, s ) ){
 285                         break;
 286                 } else {
 287                         t = t->next_tap;
 288                 }
 289         }
 290         /* backup plan is by number */
 291         if( t == NULL ){
 292                 /* ok - is "s" a number? */
 293                 int n;
 294                 n = strtol( s, &cp, 0 );
 295                 if( (s != cp) && (*cp == 0) ){
 296                         /* Then it is... */
 297                         t = jtag_tap_by_abs_position(n);
 298                 }
 299         }
 300         return t;
 301 }
 302
 303 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
 304 {
 305         jtag_tap_t *t;
 306         const char *cp;
 307
 308         cp = Jim_GetString( o, NULL );
 309         if(cp == NULL){
 310                 cp = "(unknown)";
 311                 t = NULL;
 312         }  else {
 313                 t = jtag_tap_by_string( cp );
 314         }
 315         if( t == NULL ){
 316                 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
 317         }
 318         return t;
 319 }
 320
 321 /* returns a pointer to the n-th device in the scan chain */
 322 jtag_tap_t * jtag_tap_by_abs_position( int n )
 323 {
 324         int orig_n;
 325         jtag_tap_t *t;
 326
 327         orig_n = n;
 328         t = jtag_all_taps();
 329
 330         while( t && (n > 0)) {
 331                 n--;
 332                 t = t->next_tap;
 333         }
 334         return t;
 335 }
 336
 337 const char *jtag_tap_name(const jtag_tap_t *tap)
 338 {
 339         return (tap == NULL) ? "(unknown)" : tap->dotted_name;
 340 }
 341
 342
 343 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
 344 {
 345         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 346
 347         if (callback == NULL)
 348         {
 349                 return ERROR_INVALID_ARGUMENTS;
 350         }
 351
 352         if (*callbacks_p)
 353         {
 354                 while ((*callbacks_p)->next)
 355                         callbacks_p = &((*callbacks_p)->next);
 356                 callbacks_p = &((*callbacks_p)->next);
 357         }
 358
 359         (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
 360         (*callbacks_p)->callback = callback;
 361         (*callbacks_p)->priv = priv;
 362         (*callbacks_p)->next = NULL;
 363
 364         return ERROR_OK;
 365 }
 366
 367 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
 368 {
 369         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 370
 371         if (callback == NULL)
 372         {
 373                 return ERROR_INVALID_ARGUMENTS;
 374         }
 375
 376         while (*callbacks_p)
 377         {
 378                 jtag_event_callback_t **next = &((*callbacks_p)->next);
 379                 if ((*callbacks_p)->callback == callback)
 380                 {
 381                         free(*callbacks_p);
 382                         *callbacks_p = *next;
 383                 }
 384                 callbacks_p = next;
 385         }
 386
 387         return ERROR_OK;
 388 }
 389
 390 int jtag_call_event_callbacks(enum jtag_event event)
 391 {
 392         jtag_event_callback_t *callback = jtag_event_callbacks;
 393
 394         LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
 395
 396         while (callback)
 397         {
 398                 callback->callback(event, callback->priv);
 399                 callback = callback->next;
 400         }
 401
 402         return ERROR_OK;
 403 }
 404
 405 static void jtag_checks(void)
 406 {
 407         assert(jtag_trst == 0);
 408 }
 409
 410 static void jtag_prelude(tap_state_t state)
 411 {
 412         jtag_checks();
 413
 414         assert(state!=TAP_INVALID);
 415
 416         cmd_queue_cur_state = state;
 417 }
 418
 419 void jtag_alloc_in_value32(scan_field_t *field)
 420 {
 421         interface_jtag_alloc_in_value32(field);
 422 }
 423
 424 void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 425 {
 426         int retval;
 427         jtag_prelude(state);
 428
 429         retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, state);
 430         if (retval!=ERROR_OK)
 431                 jtag_error=retval;
 432
 433 }
 434
 435
 436 /**
 437  * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
 438  *
 439  * If the input field list contains an instruction value for a TAP then that is used
 440  * otherwise the TAP is set to bypass.
 441  *
 442  * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
 443  *
 444  */
 445 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 446 {
 447         if (jtag_verify&&jtag_verify_capture_ir)
 448         {
 449                 /* 8 x 32 bit id's is enough for all invocations */
 450
 451                 for (int j = 0; j < in_num_fields; j++)
 452                 {
 453                         /* if we are to run a verification of the ir scan, we need to get the input back.
 454                          * We may have to allocate space if the caller didn't ask for the input back.
 455                          */
 456                         in_fields[j].check_value=in_fields[j].tap->expected;
 457                         in_fields[j].check_mask=in_fields[j].tap->expected_mask;
 458                 }
 459                 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
 460         } else
 461         {
 462                 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
 463         }
 464 }
 465
 466 /**
 467  * Duplicate the scan fields passed into the function into an IR SCAN command
 468  *
 469  * This function assumes that the caller handles extra fields for bypassed TAPs
 470  *
 471  */
 472 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 473 {
 474         int retval;
 475
 476         jtag_prelude(state);
 477
 478         retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, state);
 479         if (retval!=ERROR_OK)
 480                 jtag_error=retval;
 481 }
 482
 483 void jtag_add_callback(jtag_callback1_t f, u8 *in)
 484 {
 485         interface_jtag_add_callback(f, in);
 486 }
 487
 488 void jtag_add_callback4(jtag_callback_t f, u8 *in,
 489                 jtag_callback_data_t data1, jtag_callback_data_t data2,
 490                 jtag_callback_data_t data3)
 491 {
 492         interface_jtag_add_callback4(f, in, data1, data2, data3);
 493 }
 494
 495 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
 496
 497 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
 498 {
 499         return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
 500 }
 501
 502 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
 503                 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 504 {
 505         for (int i = 0; i < in_num_fields; i++)
 506         {
 507                 struct scan_field_s *field = &in_fields[i];
 508                 field->allocated = 0;
 509                 field->modified = 0;
 510                 if (field->check_value || field->in_value)
 511                         continue;
 512                 interface_jtag_add_scan_check_alloc(field);
 513                 field->modified = 1;
 514         }
 515
 516         jtag_add_scan(in_num_fields, in_fields, state);
 517
 518         for (int i = 0; i < in_num_fields; i++)
 519         {
 520                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
 521                 {
 522                         /* this is synchronous for a minidriver */
 523                         jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
 524                                 (jtag_callback_data_t)in_fields[i].check_value,
 525                                 (jtag_callback_data_t)in_fields[i].check_mask,
 526                                 (jtag_callback_data_t)in_fields[i].num_bits);
 527                 }
 528                 if (in_fields[i].allocated)
 529                 {
 530                         free(in_fields[i].in_value);
 531                 }
 532                 if (in_fields[i].modified)
 533                 {
 534                         in_fields[i].in_value = NULL;
 535                 }
 536         }
 537 }
 538
 539 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 540 {
 541         if (jtag_verify)
 542         {
 543                 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
 544         } else
 545         {
 546                 jtag_add_dr_scan(in_num_fields, in_fields, state);
 547         }
 548 }
 549
 550
 551 /**
 552  * Generate a DR SCAN using the fields passed to the function
 553  *
 554  * For not bypassed TAPs the function checks in_fields and uses fields specified there.
 555  * For bypassed TAPs the function generates a dummy 1bit field.
 556  *
 557  * The bypass status of TAPs is set by jtag_add_ir_scan().
 558  *
 559  */
 560 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 561 {
 562         int retval;
 563
 564         jtag_prelude(state);
 565
 566         retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, state);
 567         if (retval!=ERROR_OK)
 568                 jtag_error=retval;
 569 }
 570
 571
 572
 573 /**
 574  * Duplicate the scan fields passed into the function into a DR SCAN command
 575  *
 576  * This function assumes that the caller handles extra fields for bypassed TAPs
 577  *
 578  */
 579 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 580 {
 581         int retval;
 582
 583         jtag_prelude(state);
 584
 585         retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, state);
 586         if (retval!=ERROR_OK)
 587                 jtag_error=retval;
 588 }
 589
 590 void jtag_add_dr_out(jtag_tap_t* tap,
 591                 int num_fields, const int* num_bits, const u32* value,
 592                 tap_state_t end_state)
 593 {
 594         assert(end_state != TAP_INVALID);
 595
 596         cmd_queue_cur_state = end_state;
 597
 598         interface_jtag_add_dr_out(tap,
 599                         num_fields, num_bits, value,
 600                         end_state);
 601 }
 602
 603 void jtag_add_tlr(void)
 604 {
 605         jtag_prelude(TAP_RESET);
 606
 607         int retval;
 608         retval=interface_jtag_add_tlr();
 609         if (retval!=ERROR_OK)
 610                 jtag_error=retval;
 611
 612         jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 613 }
 614
 615 void jtag_add_pathmove(int num_states, const tap_state_t *path)
 616 {
 617         tap_state_t cur_state = cmd_queue_cur_state;
 618         int i;
 619         int retval;
 620
 621         /* the last state has to be a stable state */
 622         if (!tap_is_state_stable(path[num_states - 1]))
 623         {
 624                 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
 625                 exit(-1);
 626         }
 627
 628         for (i=0; i<num_states; i++)
 629         {
 630                 if (path[i] == TAP_RESET)
 631                 {
 632                         LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
 633                         exit(-1);
 634                 }
 635
 636                 if ( tap_state_transition(cur_state, true)  != path[i]
 637                   && tap_state_transition(cur_state, false) != path[i])
 638                 {
 639                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
 640                         exit(-1);
 641                 }
 642                 cur_state = path[i];
 643         }
 644
 645         jtag_checks();
 646
 647         retval = interface_jtag_add_pathmove(num_states, path);
 648         cmd_queue_cur_state = path[num_states - 1];
 649         if (retval!=ERROR_OK)
 650                 jtag_error=retval;
 651 }
 652
 653 void jtag_add_runtest(int num_cycles, tap_state_t state)
 654 {
 655         int retval;
 656
 657         jtag_prelude(state);
 658
 659         /* executed by sw or hw fifo */
 660         retval=interface_jtag_add_runtest(num_cycles, state);
 661         if (retval!=ERROR_OK)
 662                 jtag_error=retval;
 663 }
 664
 665
 666 void jtag_add_clocks( int num_cycles )
 667 {
 668         int retval;
 669
 670         if( !tap_is_state_stable(cmd_queue_cur_state) )
 671         {
 672                  LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
 673                                  tap_state_name(cmd_queue_cur_state) );
 674                  jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
 675                  return;
 676         }
 677
 678         if( num_cycles > 0 )
 679         {
 680                 jtag_checks();
 681
 682                 retval = interface_jtag_add_clocks(num_cycles);
 683                 if (retval != ERROR_OK)
 684                         jtag_error=retval;
 685         }
 686 }
 687
 688 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
 689 {
 690         int trst_with_tlr = 0;
 691         int retval;
 692
 693         /* FIX!!! there are *many* different cases here. A better
 694          * approach is needed for legal combinations of transitions...
 695          */
 696         if ((jtag_reset_config & RESET_HAS_SRST)&&
 697                         (jtag_reset_config & RESET_HAS_TRST)&&
 698                         ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
 699         {
 700                 if (((req_tlr_or_trst&&!jtag_trst)||
 701                                 (!req_tlr_or_trst&&jtag_trst))&&
 702                                 ((req_srst&&!jtag_srst)||
 703                                                 (!req_srst&&jtag_srst)))
 704                 {
 705                         /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
 706                         //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
 707                 }
 708         }
 709
 710         /* Make sure that jtag_reset_config allows the requested reset */
 711         /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
 712         if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
 713         {
 714                 LOG_ERROR("BUG: requested reset would assert trst");
 715                 jtag_error=ERROR_FAIL;
 716                 return;
 717         }
 718
 719         /* if TRST pulls SRST, we reset with TAP T-L-R */
 720         if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
 721         {
 722                 trst_with_tlr = 1;
 723         }
 724
 725         if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
 726         {
 727                 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
 728                 jtag_error=ERROR_FAIL;
 729                 return;
 730         }
 731
 732         if (req_tlr_or_trst)
 733         {
 734                 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
 735                 {
 736                         jtag_trst = 1;
 737                 } else
 738                 {
 739                         trst_with_tlr = 1;
 740                 }
 741         } else
 742         {
 743                 jtag_trst = 0;
 744         }
 745
 746         jtag_srst = req_srst;
 747
 748         retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
 749         if (retval!=ERROR_OK)
 750         {
 751                 jtag_error=retval;
 752                 return;
 753         }
 754         jtag_execute_queue();
 755
 756         if (jtag_srst)
 757         {
 758                 LOG_DEBUG("SRST line asserted");
 759         }
 760         else
 761         {
 762                 LOG_DEBUG("SRST line released");
 763                 if (jtag_nsrst_delay)
 764                         jtag_add_sleep(jtag_nsrst_delay * 1000);
 765         }
 766
 767         if (trst_with_tlr)
 768         {
 769                 LOG_DEBUG("JTAG reset with RESET instead of TRST");
 770                 jtag_set_end_state(TAP_RESET);
 771                 jtag_add_tlr();
 772                 return;
 773         }
 774
 775         if (jtag_trst)
 776         {
 777                 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
 778                  * and inform possible listeners about this
 779                  */
 780                 LOG_DEBUG("TRST line asserted");
 781                 tap_set_state(TAP_RESET);
 782                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 783         }
 784         else
 785         {
 786                 if (jtag_ntrst_delay)
 787                         jtag_add_sleep(jtag_ntrst_delay * 1000);
 788         }
 789 }
 790
 791 tap_state_t jtag_set_end_state(tap_state_t state)
 792 {
 793         if ((state == TAP_DRSHIFT)||(state == TAP_IRSHIFT))
 794         {
 795                 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
 796         }
 797
 798         if (state!=TAP_INVALID)
 799                 cmd_queue_end_state = state;
 800         return cmd_queue_end_state;
 801 }
 802
 803 tap_state_t jtag_get_end_state(void)
 804 {
 805         return cmd_queue_end_state;
 806 }
 807
 808 void jtag_add_sleep(u32 us)
 809 {
 810         keep_alive(); /* we might be running on a very slow JTAG clk */
 811         int retval=interface_jtag_add_sleep(us);
 812         if (retval!=ERROR_OK)
 813                 jtag_error=retval;
 814         return;
 815 }
 816
 817 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits)
 818 {
 819         int retval = ERROR_OK;
 820
 821         int compare_failed = 0;
 822
 823         if (in_check_mask)
 824                 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
 825         else
 826                 compare_failed = buf_cmp(captured, in_check_value, num_bits);
 827
 828         if (compare_failed){
 829                 /* An error handler could have caught the failing check
 830                  * only report a problem when there wasn't a handler, or if the handler
 831                  * acknowledged the error
 832                  */
 833                 /*
 834                 LOG_WARNING("TAP %s:",
 835                                         jtag_tap_name(field->tap));
 836                                         */
 837                 if (compare_failed)
 838                 {
 839                         char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
 840                         char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
 841
 842                         if (in_check_mask)
 843                         {
 844                                 char *in_check_mask_char;
 845                                 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
 846                                 LOG_WARNING("value captured during scan didn't pass the requested check:");
 847                                 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
 848                                                         captured_char, in_check_value_char, in_check_mask_char);
 849                                 free(in_check_mask_char);
 850                         }
 851                         else
 852                         {
 853                                 LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char);
 854                         }
 855
 856                         free(captured_char);
 857                         free(in_check_value_char);
 858
 859                         retval = ERROR_JTAG_QUEUE_FAILED;
 860                 }
 861
 862         }
 863         return retval;
 864 }
 865
 866 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
 867 {
 868         assert(field->in_value != NULL);
 869
 870         if (value==NULL)
 871         {
 872                 /* no checking to do */
 873                 return;
 874         }
 875
 876         jtag_execute_queue_noclear();
 877
 878         int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
 879         jtag_set_error(retval);
 880 }
 881
 882
 883
 884 int default_interface_jtag_execute_queue(void)
 885 {
 886         if (NULL == jtag)
 887         {
 888                 LOG_ERROR("No JTAG interface configured yet.  "
 889                         "Issue 'init' command in startup scripts "
 890                         "before communicating with targets.");
 891                 return ERROR_FAIL;
 892         }
 893
 894         return jtag->execute_queue();
 895 }
 896
 897 void jtag_execute_queue_noclear(void)
 898 {
 899         /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
 900          * E.g. a JTAG over TCP/IP or USB....
 901          */
 902         jtag_flush_queue_count++;
 903
 904         int retval=interface_jtag_execute_queue();
 905         /* we keep the first error */
 906         if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
 907         {
 908                 jtag_error=retval;
 909         }
 910 }
 911
 912 int jtag_get_flush_queue_count(void)
 913 {
 914         return jtag_flush_queue_count;
 915 }
 916
 917 int jtag_execute_queue(void)
 918 {
 919         int retval;
 920         jtag_execute_queue_noclear();
 921         retval=jtag_error;
 922         jtag_error=ERROR_OK;
 923         return retval;
 924 }
 925
 926 static int jtag_reset_callback(enum jtag_event event, void *priv)
 927 {
 928         jtag_tap_t *tap = priv;
 929
 930         LOG_DEBUG("-");
 931
 932         if (event == JTAG_TRST_ASSERTED)
 933         {
 934                 buf_set_ones(tap->cur_instr, tap->ir_length);
 935                 tap->bypass = 1;
 936         }
 937
 938         return ERROR_OK;
 939 }
 940
 941 void jtag_sleep(u32 us)
 942 {
 943         alive_sleep(us/1000);
 944 }
 945
 946 /* Try to examine chain layout according to IEEE 1149.1 §12
 947  */
 948 static int jtag_examine_chain(void)
 949 {
 950         jtag_tap_t *tap;
 951         scan_field_t field;
 952         u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
 953         int i;
 954         int bit_count;
 955         int device_count = 0;
 956         u8 zero_check = 0x0;
 957         u8 one_check = 0xff;
 958
 959         field.tap = NULL;
 960         field.num_bits = sizeof(idcode_buffer) * 8;
 961         field.out_value = idcode_buffer;
 962
 963         field.in_value = idcode_buffer;
 964
 965
 966
 967
 968         for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
 969         {
 970                 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
 971         }
 972
 973         jtag_add_plain_dr_scan(1, &field, TAP_RESET);
 974         jtag_execute_queue();
 975
 976         for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
 977         {
 978                 zero_check |= idcode_buffer[i];
 979                 one_check &= idcode_buffer[i];
 980         }
 981
 982         /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
 983         if ((zero_check == 0x00) || (one_check == 0xff))
 984         {
 985                 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
 986                 return ERROR_JTAG_INIT_FAILED;
 987         }
 988
 989         /* point at the 1st tap */
 990         tap = jtag_NextEnabledTap(NULL);
 991         if( tap == NULL ){
 992                 LOG_ERROR("JTAG: No taps enabled?");
 993                 return ERROR_JTAG_INIT_FAILED;
 994         }
 995
 996         for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
 997         {
 998                 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
 999                 if ((idcode & 1) == 0)
1000                 {
1001                         /* LSB must not be 0, this indicates a device in bypass */
1002                         LOG_WARNING("Tap/Device does not have IDCODE");
1003                         idcode=0;
1004
1005                         bit_count += 1;
1006                 }
1007                 else
1008                 {
1009                         u32 manufacturer;
1010                         u32 part;
1011                         u32 version;
1012
1013                         /* some devices, such as AVR will output all 1's instead of TDI
1014                         input value at end of chain. */
1015                         if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1016                         {
1017                                 int unexpected=0;
1018                                 /* End of chain (invalid manufacturer ID)
1019                                  *
1020                                  * The JTAG examine is the very first thing that happens
1021                                  *
1022                                  * A single JTAG device requires only 64 bits to be read back correctly.
1023                                  *
1024                                  * The code below adds a check that the rest of the data scanned (640 bits)
1025                                  * are all as expected. This helps diagnose/catch problems with the JTAG chain
1026                                  *
1027                                  * earlier and gives more helpful/explicit error messages.
1028                                  */
1029                                 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1030                                 {
1031                                         idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1032                                         if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1033                                         {
1034                                                 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1035                                                 unexpected = 1;
1036                                         }
1037                                 }
1038
1039                                 break;
1040                         }
1041
1042 #define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
1043                         manufacturer = EXTRACT_MFG(idcode);
1044 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1045                         part = EXTRACT_PART(idcode);
1046 #define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)
1047                         version = EXTRACT_VER(idcode);
1048
1049                         LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1050                                          ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1051                                 idcode, manufacturer, part, version);
1052
1053                         bit_count += 32;
1054                 }
1055                 if (tap)
1056                 {
1057                         tap->idcode = idcode;
1058
1059                         if (tap->expected_ids_cnt > 0) {
1060                                 /* Loop over the expected identification codes and test for a match */
1061                                 u8 ii;
1062                                 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1063                                         if( tap->idcode == tap->expected_ids[ii] ){
1064                                                 break;
1065                                         }
1066                                 }
1067
1068                                 /* If none of the expected ids matched, log an error */
1069                                 if (ii == tap->expected_ids_cnt) {
1070                                         LOG_ERROR("JTAG tap: %s             got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1071                                                           tap->dotted_name,
1072                                                           idcode,
1073                                                           EXTRACT_MFG( tap->idcode ),
1074                                                           EXTRACT_PART( tap->idcode ),
1075                                                           EXTRACT_VER( tap->idcode ) );
1076                                         for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1077                                                 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1078                                                                   tap->dotted_name,
1079                                                                   ii + 1,
1080                                                                   tap->expected_ids_cnt,
1081                                                                   tap->expected_ids[ii],
1082                                                                   EXTRACT_MFG( tap->expected_ids[ii] ),
1083                                                                   EXTRACT_PART( tap->expected_ids[ii] ),
1084                                                                   EXTRACT_VER( tap->expected_ids[ii] ) );
1085                                         }
1086
1087                                         return ERROR_JTAG_INIT_FAILED;
1088                                 } else {
1089                                         LOG_INFO("JTAG Tap/device matched");
1090                                 }
1091                         } else {
1092 #if 0
1093                                 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1094                                                  tap->idcode);
1095 #endif
1096                         }
1097                         tap = jtag_NextEnabledTap(tap);
1098                 }
1099                 device_count++;
1100         }
1101
1102         /* see if number of discovered devices matches configuration */
1103         if (device_count != jtag_NumEnabledTaps())
1104         {
1105                 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1106                                   device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1107                 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1108                 return ERROR_JTAG_INIT_FAILED;
1109         }
1110
1111         return ERROR_OK;
1112 }
1113
1114 static int jtag_validate_chain(void)
1115 {
1116         jtag_tap_t *tap;
1117         int total_ir_length = 0;
1118         u8 *ir_test = NULL;
1119         scan_field_t field;
1120         int chain_pos = 0;
1121
1122         tap = NULL;
1123         total_ir_length = 0;
1124         for(;;){
1125                 tap = jtag_NextEnabledTap(tap);
1126                 if( tap == NULL ){
1127                         break;
1128                 }
1129                 total_ir_length += tap->ir_length;
1130         }
1131
1132         total_ir_length += 2;
1133         ir_test = malloc(CEIL(total_ir_length, 8));
1134         buf_set_ones(ir_test, total_ir_length);
1135
1136         field.tap = NULL;
1137         field.num_bits = total_ir_length;
1138         field.out_value = ir_test;
1139         field.in_value = ir_test;
1140
1141
1142         jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1143         jtag_execute_queue();
1144
1145         tap = NULL;
1146         chain_pos = 0;
1147         int val;
1148         for(;;){
1149                 tap = jtag_NextEnabledTap(tap);
1150                 if( tap == NULL ){
1151                         break;
1152                 }
1153
1154                 val = buf_get_u32(ir_test, chain_pos, 2);
1155                 if (val != 0x1)
1156                 {
1157                         char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1158                         LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf, jtag_tap_name(tap), chain_pos, val);
1159                         free(cbuf);
1160                         free(ir_test);
1161                         return ERROR_JTAG_INIT_FAILED;
1162                 }
1163                 chain_pos += tap->ir_length;
1164         }
1165
1166         val = buf_get_u32(ir_test, chain_pos, 2);
1167         if (val != 0x3)
1168         {
1169                 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1170                 LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf, chain_pos, val);
1171                 free(cbuf);
1172                 free(ir_test);
1173                 return ERROR_JTAG_INIT_FAILED;
1174         }
1175
1176         free(ir_test);
1177
1178         return ERROR_OK;
1179 }
1180
1181 enum jtag_tap_cfg_param {
1182         JCFG_EVENT
1183 };
1184
1185 static Jim_Nvp nvp_config_opts[] = {
1186         { .name = "-event",      .value = JCFG_EVENT },
1187
1188         { .name = NULL,          .value = -1 }
1189 };
1190
1191 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1192 {
1193         Jim_Nvp *n;
1194         Jim_Obj *o;
1195         int e;
1196
1197         /* parse config or cget options */
1198         while (goi->argc > 0) {
1199                 Jim_SetEmptyResult (goi->interp);
1200
1201                 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1202                 if (e != JIM_OK) {
1203                         Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1204                         return e;
1205                 }
1206
1207                 switch (n->value) {
1208                         case JCFG_EVENT:
1209                                 if (goi->argc == 0) {
1210                                         Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1211                                         return JIM_ERR;
1212                                 }
1213
1214                                 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1215                                 if (e != JIM_OK) {
1216                                         Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1217                                         return e;
1218                                 }
1219
1220                                 if (goi->isconfigure) {
1221                                         if (goi->argc != 1) {
1222                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1223                                                 return JIM_ERR;
1224                                         }
1225                                 } else {
1226                                         if (goi->argc != 0) {
1227                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1228                                                 return JIM_ERR;
1229                                         }
1230                                 }
1231
1232                                 {
1233                                         jtag_tap_event_action_t *jteap;
1234
1235                                         jteap = tap->event_action;
1236                                         /* replace existing? */
1237                                         while (jteap) {
1238                                                 if (jteap->event == (enum jtag_tap_event)n->value) {
1239                                                         break;
1240                                                 }
1241                                                 jteap = jteap->next;
1242                                         }
1243
1244                                         if (goi->isconfigure) {
1245                                                 if (jteap == NULL) {
1246                                                         /* create new */
1247                                                         jteap = calloc(1, sizeof (*jteap));
1248                                                 }
1249                                                 jteap->event = n->value;
1250                                                 Jim_GetOpt_Obj( goi, &o);
1251                                                 if (jteap->body) {
1252                                                         Jim_DecrRefCount(interp, jteap->body);
1253                                                 }
1254                                                 jteap->body = Jim_DuplicateObj(goi->interp, o);
1255                                                 Jim_IncrRefCount(jteap->body);
1256
1257                                                 /* add to head of event list */
1258                                                 jteap->next = tap->event_action;
1259                                                 tap->event_action = jteap;
1260                                                 Jim_SetEmptyResult(goi->interp);
1261                                         } else {
1262                                                 /* get */
1263                                                 if (jteap == NULL) {
1264                                                         Jim_SetEmptyResult(goi->interp);
1265                                                 } else {
1266                                                         Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1267                                                 }
1268                                         }
1269                                 }
1270                                 /* loop for more */
1271                                 break;
1272                 }
1273         } /* while (goi->argc) */
1274
1275         return JIM_OK;
1276 }
1277
1278
1279 static void jtag_tap_init(jtag_tap_t *tap)
1280 {
1281         assert(0 != tap->ir_length);
1282
1283         tap->expected = malloc(tap->ir_length);
1284         tap->expected_mask = malloc(tap->ir_length);
1285         tap->cur_instr = malloc(tap->ir_length);
1286
1287         buf_set_u32(tap->expected, 0, tap->ir_length, tap->ir_capture_value);
1288         buf_set_u32(tap->expected_mask, 0, tap->ir_length, tap->ir_capture_mask);
1289         buf_set_ones(tap->cur_instr, tap->ir_length);
1290
1291         // place TAP in bypass mode
1292         tap->bypass = 1;
1293         // register the reset callback for the TAP
1294         jtag_register_event_callback(&jtag_reset_callback, tap);
1295
1296         LOG_DEBUG("Created Tap: %s @ abs position %d, "
1297                         "irlen %d, capture: 0x%x mask: 0x%x", tap->dotted_name,
1298                                 tap->abs_chain_position, tap->ir_length,
1299                                 tap->ir_capture_value, tap->ir_capture_mask);
1300         jtag_tap_add(tap);
1301 }
1302
1303 static void jtag_tap_free(jtag_tap_t *tap)
1304 {
1305         /// @todo is anything missing? no memory leaks please
1306         free((void *)tap->expected_ids);
1307         free((void *)tap->chip);
1308         free((void *)tap->tapname);
1309         free((void *)tap->dotted_name);
1310         free(tap);
1311 }
1312
1313 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1314 {
1315         jtag_tap_t *pTap;
1316         jim_wide w;
1317         int x;
1318         int e;
1319         int reqbits;
1320         Jim_Nvp *n;
1321         char *cp;
1322         const Jim_Nvp opts[] = {
1323 #define NTAP_OPT_IRLEN     0
1324                 { .name = "-irlen"                      ,       .value = NTAP_OPT_IRLEN },
1325 #define NTAP_OPT_IRMASK    1
1326                 { .name = "-irmask"                     ,       .value = NTAP_OPT_IRMASK },
1327 #define NTAP_OPT_IRCAPTURE 2
1328                 { .name = "-ircapture"          ,       .value = NTAP_OPT_IRCAPTURE },
1329 #define NTAP_OPT_ENABLED   3
1330                 { .name = "-enable"                     ,       .value = NTAP_OPT_ENABLED },
1331 #define NTAP_OPT_DISABLED  4
1332                 { .name = "-disable"            ,       .value = NTAP_OPT_DISABLED },
1333 #define NTAP_OPT_EXPECTED_ID 5
1334                 { .name = "-expected-id"        ,       .value = NTAP_OPT_EXPECTED_ID },
1335                 { .name = NULL                          ,       .value = -1 },
1336         };
1337
1338         pTap = malloc( sizeof(jtag_tap_t) );
1339         memset( pTap, 0, sizeof(*pTap) );
1340         if( !pTap ){
1341                 Jim_SetResult_sprintf( goi->interp, "no memory");
1342                 return JIM_ERR;
1343         }
1344         /*
1345          * we expect CHIP + TAP + OPTIONS
1346          * */
1347         if( goi->argc < 3 ){
1348                 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1349                 return JIM_ERR;
1350         }
1351         Jim_GetOpt_String( goi, &cp, NULL );
1352         pTap->chip = strdup(cp);
1353
1354         Jim_GetOpt_String( goi, &cp, NULL );
1355         pTap->tapname = strdup(cp);
1356
1357         /* name + dot + name + null */
1358         x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1359         cp = malloc( x );
1360         sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1361         pTap->dotted_name = cp;
1362
1363         LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1364                           pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1365
1366         /* default is enabled */
1367         pTap->enabled = 1;
1368
1369         /* deal with options */
1370 #define NTREQ_IRLEN      1
1371 #define NTREQ_IRCAPTURE  2
1372 #define NTREQ_IRMASK     4
1373
1374         /* clear them as we find them */
1375         reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1376
1377         while( goi->argc ){
1378                 e = Jim_GetOpt_Nvp( goi, opts, &n );
1379                 if( e != JIM_OK ){
1380                         Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1381                         return e;
1382                 }
1383                 LOG_DEBUG("Processing option: %s", n->name );
1384                 switch( n->value ){
1385                 case NTAP_OPT_ENABLED:
1386                         pTap->enabled = 1;
1387                         break;
1388                 case NTAP_OPT_DISABLED:
1389                         pTap->enabled = 0;
1390                         break;
1391                 case NTAP_OPT_EXPECTED_ID:
1392                 {
1393                         u32 *new_expected_ids;
1394
1395                         e = Jim_GetOpt_Wide( goi, &w );
1396                         if( e != JIM_OK) {
1397                                 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1398                                 return e;
1399                         }
1400
1401                         new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1402                         if (new_expected_ids == NULL) {
1403                                 Jim_SetResult_sprintf( goi->interp, "no memory");
1404                                 return JIM_ERR;
1405                         }
1406
1407                         memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1408
1409                         new_expected_ids[pTap->expected_ids_cnt] = w;
1410
1411                         free(pTap->expected_ids);
1412                         pTap->expected_ids = new_expected_ids;
1413                         pTap->expected_ids_cnt++;
1414                         break;
1415                 }
1416                 case NTAP_OPT_IRLEN:
1417                 case NTAP_OPT_IRMASK:
1418                 case NTAP_OPT_IRCAPTURE:
1419                         e = Jim_GetOpt_Wide( goi, &w );
1420                         if( e != JIM_OK ){
1421                                 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1422                                 return e;
1423                         }
1424                         if( (w < 0) || (w > 0xffff) ){
1425                                 /* wacky value */
1426                                 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1427                                                                            n->name, (int)(w), (int)(w));
1428                                 return JIM_ERR;
1429                         }
1430                         switch(n->value){
1431                         case NTAP_OPT_IRLEN:
1432                                 pTap->ir_length = w;
1433                                 reqbits &= (~(NTREQ_IRLEN));
1434                                 break;
1435                         case NTAP_OPT_IRMASK:
1436                                 pTap->ir_capture_mask = w;
1437                                 reqbits &= (~(NTREQ_IRMASK));
1438                                 break;
1439                         case NTAP_OPT_IRCAPTURE:
1440                                 pTap->ir_capture_value = w;
1441                                 reqbits &= (~(NTREQ_IRCAPTURE));
1442                                 break;
1443                         }
1444                 } /* switch(n->value) */
1445         } /* while( goi->argc ) */
1446
1447         /* Did all the required option bits get cleared? */
1448         if (0 == reqbits)
1449         {
1450                 jtag_tap_init(pTap);
1451                 return ERROR_OK;
1452         }
1453
1454         Jim_SetResult_sprintf(goi->interp,
1455                         "newtap: %s missing required parameters",
1456                         pTap->dotted_name);
1457         jtag_tap_free(pTap);
1458         return JIM_ERR;
1459 }
1460
1461 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1462 {
1463         Jim_GetOptInfo goi;
1464         int e;
1465         Jim_Nvp *n;
1466         Jim_Obj *o;
1467         struct command_context_s *context;
1468
1469         enum {
1470                 JTAG_CMD_INTERFACE,
1471                 JTAG_CMD_INIT_RESET,
1472                 JTAG_CMD_NEWTAP,
1473                 JTAG_CMD_TAPENABLE,
1474                 JTAG_CMD_TAPDISABLE,
1475                 JTAG_CMD_TAPISENABLED,
1476                 JTAG_CMD_CONFIGURE,
1477                 JTAG_CMD_CGET
1478         };
1479
1480         const Jim_Nvp jtag_cmds[] = {
1481                 { .name = "interface"     , .value = JTAG_CMD_INTERFACE },
1482                 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
1483                 { .name = "newtap"        , .value = JTAG_CMD_NEWTAP },
1484                 { .name = "tapisenabled"     , .value = JTAG_CMD_TAPISENABLED },
1485                 { .name = "tapenable"     , .value = JTAG_CMD_TAPENABLE },
1486                 { .name = "tapdisable"    , .value = JTAG_CMD_TAPDISABLE },
1487                 { .name = "configure"     , .value = JTAG_CMD_CONFIGURE },
1488                 { .name = "cget"          , .value = JTAG_CMD_CGET },
1489
1490                 { .name = NULL, .value = -1 },
1491         };
1492
1493         context = Jim_GetAssocData(interp, "context");
1494         /* go past the command */
1495         Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
1496
1497         e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
1498         if( e != JIM_OK ){
1499                 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
1500                 return e;
1501         }
1502                 Jim_SetEmptyResult( goi.interp );
1503         switch( n->value ){
1504         case JTAG_CMD_INTERFACE:
1505                 /* return the name of the interface */
1506                 /* TCL code might need to know the exact type... */
1507                 /* FUTURE: we allow this as a means to "set" the interface. */
1508                 if( goi.argc != 0 ){
1509                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1510                         return JIM_ERR;
1511                 }
1512                 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
1513                 return JIM_OK;
1514         case JTAG_CMD_INIT_RESET:
1515                 if( goi.argc != 0 ){
1516                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1517                         return JIM_ERR;
1518                 }
1519                 e = jtag_init_reset(context);
1520                 if( e != ERROR_OK ){
1521                         Jim_SetResult_sprintf( goi.interp, "error: %d", e);
1522                         return JIM_ERR;
1523                 }
1524                 return JIM_OK;
1525         case JTAG_CMD_NEWTAP:
1526                 return jim_newtap_cmd( &goi );
1527                 break;
1528         case JTAG_CMD_TAPISENABLED:
1529         case JTAG_CMD_TAPENABLE:
1530         case JTAG_CMD_TAPDISABLE:
1531                 if( goi.argc != 1 ){
1532                         Jim_SetResultString( goi.interp, "Too many parameters",-1 );
1533                         return JIM_ERR;
1534                 }
1535
1536                 {
1537                         jtag_tap_t *t;
1538                         t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
1539                         if( t == NULL ){
1540                                 return JIM_ERR;
1541                         }
1542                         switch( n->value ){
1543                         case JTAG_CMD_TAPISENABLED:
1544                                 e = t->enabled;
1545                                 break;
1546                         case JTAG_CMD_TAPENABLE:
1547                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
1548                                 e = 1;
1549                                 t->enabled = e;
1550                                 break;
1551                         case JTAG_CMD_TAPDISABLE:
1552                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
1553                                 e = 0;
1554                                 t->enabled = e;
1555                                 break;
1556                         }
1557                         Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
1558                         return JIM_OK;
1559                 }
1560                 break;
1561
1562         case JTAG_CMD_CGET:
1563                 if( goi.argc < 2 ){
1564                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
1565                         return JIM_ERR;
1566                 }
1567
1568                 {
1569                         jtag_tap_t *t;
1570
1571                         Jim_GetOpt_Obj(&goi, &o);
1572                         t = jtag_TapByJimObj( goi.interp, o );
1573                         if( t == NULL ){
1574                                 return JIM_ERR;
1575                         }
1576
1577                         goi.isconfigure = 0;
1578                         return jtag_tap_configure_cmd( &goi, t);
1579                 }
1580                 break;
1581
1582         case JTAG_CMD_CONFIGURE:
1583                 if( goi.argc < 3 ){
1584                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
1585                         return JIM_ERR;
1586                 }
1587
1588                 {
1589                         jtag_tap_t *t;
1590
1591                         Jim_GetOpt_Obj(&goi, &o);
1592                         t = jtag_TapByJimObj( goi.interp, o );
1593                         if( t == NULL ){
1594                                 return JIM_ERR;
1595                         }
1596
1597                         goi.isconfigure = 1;
1598                         return jtag_tap_configure_cmd( &goi, t);
1599                 }
1600         }
1601
1602         return JIM_ERR;
1603 }
1604
1605 int jtag_register_commands(struct command_context_s *cmd_ctx)
1606 {
1607         register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
1608
1609         register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1610                 COMMAND_CONFIG, "try to configure interface");
1611         register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1612                 COMMAND_ANY, "(DEPRECATED) set jtag speed (if supported)");
1613         register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1614                 COMMAND_ANY, "set maximum jtag speed (if supported); "
1615                 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1616         register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1617                 COMMAND_CONFIG, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1618         register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1619                 COMMAND_ANY,
1620                 "[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]");
1621         register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1622                 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1623         register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1624                 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1625
1626         register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1627                 COMMAND_EXEC, "print current scan chain configuration");
1628
1629         register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1630                 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1631         register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1632                 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1633         register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1634                 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1635         register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1636                 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1637         register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1638         register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
1639
1640         register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1641                 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1642         register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
1643                 COMMAND_ANY, "verify value capture <enable|disable>");
1644         register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
1645                 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
1646         return ERROR_OK;
1647 }
1648
1649 int jtag_interface_init(struct command_context_s *cmd_ctx)
1650 {
1651         if (jtag)
1652                 return ERROR_OK;
1653
1654         if (!jtag_interface)
1655         {
1656                 /* nothing was previously specified by "interface" command */
1657                 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1658                 return ERROR_JTAG_INVALID_INTERFACE;
1659         }
1660         if(hasKHz)
1661         {
1662                 jtag_interface->khz(jtag_get_speed_khz(), &jtag_speed);
1663                 hasKHz = false;
1664         }
1665
1666         if (jtag_interface->init() != ERROR_OK)
1667                 return ERROR_JTAG_INIT_FAILED;
1668
1669         jtag = jtag_interface;
1670         return ERROR_OK;
1671 }
1672
1673 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1674 {
1675         jtag_tap_t *tap;
1676         int retval;
1677
1678         LOG_DEBUG("Init JTAG chain");
1679
1680         tap = jtag_NextEnabledTap(NULL);
1681         if( tap == NULL ){
1682                 LOG_ERROR("There are no enabled taps?");
1683                 return ERROR_JTAG_INIT_FAILED;
1684         }
1685
1686         jtag_add_tlr();
1687         if ((retval=jtag_execute_queue())!=ERROR_OK)
1688                 return retval;
1689
1690         /* examine chain first, as this could discover the real chain layout */
1691         if (jtag_examine_chain() != ERROR_OK)
1692         {
1693                 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1694         }
1695
1696         if (jtag_validate_chain() != ERROR_OK)
1697         {
1698                 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1699         }
1700
1701         return ERROR_OK;
1702 }
1703
1704 int jtag_interface_quit(void)
1705 {
1706         if (!jtag || !jtag->quit)
1707                 return ERROR_OK;
1708
1709         // close the JTAG interface
1710         int result = jtag->quit();
1711         if (ERROR_OK != result)
1712                 LOG_ERROR("failed: %d", result);
1713
1714         return ERROR_OK;
1715 }
1716
1717
1718 int jtag_init_reset(struct command_context_s *cmd_ctx)
1719 {
1720         int retval;
1721
1722         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1723                 return retval;
1724
1725         LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1726
1727         /* Reset can happen after a power cycle.
1728          *
1729          * Ideally we would only assert TRST or run RESET before the target reset.
1730          *
1731          * However w/srst_pulls_trst, trst is asserted together with the target
1732          * reset whether we want it or not.
1733          *
1734          * NB! Some targets have JTAG circuitry disabled until a
1735          * trst & srst has been asserted.
1736          *
1737          * NB! here we assume nsrst/ntrst delay are sufficient!
1738          *
1739          * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1740          *
1741          */
1742         jtag_add_reset(1, 0); /* RESET or TRST */
1743         if (jtag_reset_config & RESET_HAS_SRST)
1744         {
1745                 jtag_add_reset(1, 1);
1746                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1747                         jtag_add_reset(0, 1);
1748         }
1749         jtag_add_reset(0, 0);
1750         if ((retval = jtag_execute_queue()) != ERROR_OK)
1751                 return retval;
1752
1753         /* Check that we can communication on the JTAG chain + eventually we want to
1754          * be able to perform enumeration only after OpenOCD has started
1755          * telnet and GDB server
1756          *
1757          * That would allow users to more easily perform any magic they need to before
1758          * reset happens.
1759          */
1760         return jtag_init_inner(cmd_ctx);
1761 }
1762
1763 int jtag_init(struct command_context_s *cmd_ctx)
1764 {
1765         int retval;
1766         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1767                 return retval;
1768         if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1769         {
1770                 return ERROR_OK;
1771         }
1772         return jtag_init_reset(cmd_ctx);
1773 }
1774
1775 void jtag_set_speed_khz(unsigned khz)
1776 {
1777         speed_khz = khz;
1778 }
1779 unsigned jtag_get_speed_khz(void)
1780 {
1781         return speed_khz;
1782 }
1783
1784 static int default_khz(int khz, int *jtag_speed)
1785 {
1786         LOG_ERROR("Translation from khz to jtag_speed not implemented");
1787         return ERROR_FAIL;
1788 }
1789
1790 static int default_speed_div(int speed, int *khz)
1791 {
1792         LOG_ERROR("Translation from jtag_speed to khz not implemented");
1793         return ERROR_FAIL;
1794 }
1795
1796 static int default_power_dropout(int *dropout)
1797 {
1798         *dropout=0; /* by default we can't detect power dropout */
1799         return ERROR_OK;
1800 }
1801
1802 static int default_srst_asserted(int *srst_asserted)
1803 {
1804         *srst_asserted=0; /* by default we can't detect srst asserted */
1805         return ERROR_OK;
1806 }
1807
1808 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1809 {
1810         int i;
1811         int retval;
1812
1813         /* check whether the interface is already configured */
1814         if (jtag_interface)
1815         {
1816                 LOG_WARNING("Interface already configured, ignoring");
1817                 return ERROR_OK;
1818         }
1819
1820         /* interface name is a mandatory argument */
1821         if (argc < 1 || args[0][0] == '\0')
1822         {
1823                 return ERROR_COMMAND_SYNTAX_ERROR;
1824         }
1825
1826         for (i=0; jtag_interfaces[i]; i++)
1827         {
1828                 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
1829                 {
1830                         if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
1831                         {
1832                                 return retval;
1833                         }
1834
1835                         jtag_interface = jtag_interfaces[i];
1836
1837                         if (jtag_interface->khz == NULL)
1838                         {
1839                                 jtag_interface->khz = default_khz;
1840                         }
1841                         if (jtag_interface->speed_div == NULL)
1842                         {
1843                                 jtag_interface->speed_div = default_speed_div;
1844                         }
1845                         if (jtag_interface->power_dropout == NULL)
1846                         {
1847                                 jtag_interface->power_dropout = default_power_dropout;
1848                         }
1849                         if (jtag_interface->srst_asserted == NULL)
1850                         {
1851                                 jtag_interface->srst_asserted = default_srst_asserted;
1852                         }
1853
1854                         return ERROR_OK;
1855                 }
1856         }
1857
1858         /* no valid interface was found (i.e. the configuration option,
1859          * didn't match one of the compiled-in interfaces
1860          */
1861         LOG_ERROR("No valid jtag interface found (%s)", args[0]);
1862         LOG_ERROR("compiled-in jtag interfaces:");
1863         for (i = 0; jtag_interfaces[i]; i++)
1864         {
1865                 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
1866         }
1867
1868         return ERROR_JTAG_INVALID_INTERFACE;
1869 }
1870
1871 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1872 {
1873         int e;
1874         char buf[1024];
1875         Jim_Obj *newargs[ 10 ];
1876         /*
1877          * CONVERT SYNTAX
1878          * argv[-1] = command
1879          * argv[ 0] = ir length
1880          * argv[ 1] = ir capture
1881          * argv[ 2] = ir mask
1882          * argv[ 3] = not actually used by anything but in the docs
1883          */
1884
1885         if( argc < 4 ){
1886                 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
1887                 return ERROR_OK;
1888         }
1889         command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
1890         command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
1891                                    args[0],
1892                                    args[1],
1893                                    args[2] );
1894         command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
1895         command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
1896         command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
1897         command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
1898
1899         newargs[0] = Jim_NewStringObj( interp, "jtag", -1   );
1900         newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
1901         sprintf( buf, "chip%d", jtag_NumTotalTaps() );
1902         newargs[2] = Jim_NewStringObj( interp, buf, -1 );
1903         sprintf( buf, "tap%d", jtag_NumTotalTaps() );
1904         newargs[3] = Jim_NewStringObj( interp, buf, -1  );
1905         newargs[4] = Jim_NewStringObj( interp, "-irlen", -1  );
1906         newargs[5] = Jim_NewStringObj( interp, args[0], -1  );
1907         newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1  );
1908         newargs[7] = Jim_NewStringObj( interp, args[1], -1  );
1909         newargs[8] = Jim_NewStringObj( interp, "-irmask", -1  );
1910         newargs[9] = Jim_NewStringObj( interp, args[2], -1  );
1911
1912         command_print( cmd_ctx, "NEW COMMAND:");
1913         sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
1914                          Jim_GetString( newargs[0], NULL ),
1915                          Jim_GetString( newargs[1], NULL ),
1916                          Jim_GetString( newargs[2], NULL ),
1917                          Jim_GetString( newargs[3], NULL ),
1918                          Jim_GetString( newargs[4], NULL ),
1919                          Jim_GetString( newargs[5], NULL ),
1920                          Jim_GetString( newargs[6], NULL ),
1921                          Jim_GetString( newargs[7], NULL ),
1922                          Jim_GetString( newargs[8], NULL ),
1923                          Jim_GetString( newargs[9], NULL ) );
1924
1925         e = jim_jtag_command( interp, 10, newargs );
1926         if( e != JIM_OK ){
1927                 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
1928         }
1929         return e;
1930 }
1931
1932 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1933 {
1934         jtag_tap_t *tap;
1935
1936         tap = jtag_all_taps();
1937         command_print(cmd_ctx, "     TapName            | Enabled |   IdCode      Expected    IrLen IrCap  IrMask Instr     ");
1938         command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
1939
1940         while( tap ){
1941                 u32 expected, expected_mask, cur_instr, ii;
1942                 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
1943                 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
1944                 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
1945
1946                 command_print(cmd_ctx,
1947                                           "%2d | %-18s |    %c    | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
1948                                           tap->abs_chain_position,
1949                                           tap->dotted_name,
1950                                           tap->enabled ? 'Y' : 'n',
1951                                           tap->idcode,
1952                                           (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
1953                                           tap->ir_length,
1954                                           expected,
1955                                           expected_mask,
1956                                           cur_instr);
1957
1958                 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
1959                         command_print(cmd_ctx, "   |                    |         |            | 0x%08x |      |      |      |         ",
1960                                                   tap->expected_ids[ii]);
1961                 }
1962
1963                 tap = tap->next_tap;
1964         }
1965
1966         return ERROR_OK;
1967 }
1968
1969 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1970 {
1971         int new_cfg = 0;
1972         int mask = 0;
1973
1974         if (argc < 1)
1975                 return ERROR_COMMAND_SYNTAX_ERROR;
1976
1977         /* Original versions cared about the order of these tokens:
1978          *   reset_config signals [combination [trst_type [srst_type]]]
1979          * They also clobbered the previous configuration even on error.
1980          *
1981          * Here we don't care about the order, and only change values
1982          * which have been explicitly specified.
1983          */
1984         for (; argc; argc--, args++) {
1985                 int tmp = 0;
1986                 int m;
1987
1988                 /* signals */
1989                 m = RESET_HAS_TRST | RESET_HAS_SRST;
1990                 if (strcmp(*args, "none") == 0)
1991                         tmp = RESET_NONE;
1992                 else if (strcmp(*args, "trst_only") == 0)
1993                         tmp = RESET_HAS_TRST;
1994                 else if (strcmp(*args, "srst_only") == 0)
1995                         tmp = RESET_HAS_SRST;
1996                 else if (strcmp(*args, "trst_and_srst") == 0)
1997                         tmp = RESET_HAS_TRST | RESET_HAS_SRST;
1998                 else
1999                         m = 0;
2000                 if (mask & m) {
2001                         LOG_ERROR("extra reset_config %s spec (%s)",
2002                                         "signal", *args);
2003                         return ERROR_INVALID_ARGUMENTS;
2004                 }
2005                 if (m)
2006                         goto next;
2007
2008                 /* combination (options for broken wiring) */
2009                 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2010                 if (strcmp(*args, "separate") == 0)
2011                         /* separate reset lines - default */;
2012                 else if (strcmp(*args, "srst_pulls_trst") == 0)
2013                         tmp |= RESET_SRST_PULLS_TRST;
2014                 else if (strcmp(*args, "trst_pulls_srst") == 0)
2015                         tmp |= RESET_TRST_PULLS_SRST;
2016                 else if (strcmp(*args, "combined") == 0)
2017                         tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2018                 else
2019                         m = 0;
2020                 if (mask & m) {
2021                         LOG_ERROR("extra reset_config %s spec (%s)",
2022                                         "combination", *args);
2023                         return ERROR_INVALID_ARGUMENTS;
2024                 }
2025                 if (m)
2026                         goto next;
2027
2028                 /* trst_type (NOP without HAS_TRST) */
2029                 m = RESET_TRST_OPEN_DRAIN;
2030                 if (strcmp(*args, "trst_open_drain") == 0)
2031                         tmp |= RESET_TRST_OPEN_DRAIN;
2032                 else if (strcmp(*args, "trst_push_pull") == 0)
2033                         /* push/pull from adapter - default */;
2034                 else
2035                         m = 0;
2036                 if (mask & m) {
2037                         LOG_ERROR("extra reset_config %s spec (%s)",
2038                                         "trst_type", *args);
2039                         return ERROR_INVALID_ARGUMENTS;
2040                 }
2041                 if (m)
2042                         goto next;
2043
2044                 /* srst_type (NOP without HAS_SRST) */
2045                 m |= RESET_SRST_PUSH_PULL;
2046                 if (strcmp(*args, "srst_push_pull") == 0)
2047                         tmp |= RESET_SRST_PUSH_PULL;
2048                 else if (strcmp(*args, "srst_open_drain") == 0)
2049                         /* open drain from adapter - default */;
2050                 else
2051                         m = 0;
2052                 if (mask & m) {
2053                         LOG_ERROR("extra reset_config %s spec (%s)",
2054                                         "srst_type", *args);
2055                         return ERROR_INVALID_ARGUMENTS;
2056                 }
2057                 if (m)
2058                         goto next;
2059
2060                 /* caller provided nonsense; fail */
2061                 LOG_ERROR("unknown reset_config flag (%s)", *args);
2062                 return ERROR_INVALID_ARGUMENTS;
2063
2064 next:
2065                 /* Remember the bits which were specified (mask)
2066                  * and their new values (new_cfg).
2067                  */
2068                 mask |= m;
2069                 new_cfg |= tmp;
2070         }
2071
2072         /* clear previous values of those bits, save new values */
2073         jtag_reset_config &= ~mask;
2074         jtag_reset_config |= new_cfg;
2075
2076         return ERROR_OK;
2077 }
2078
2079 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2080 {
2081         if (argc < 1)
2082         {
2083                 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2084                 exit(-1);
2085         }
2086         else
2087         {
2088                 jtag_set_nsrst_delay(strtoul(args[0], NULL, 0));
2089         }
2090
2091         return ERROR_OK;
2092 }
2093
2094 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2095 {
2096         if (argc < 1)
2097         {
2098                 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2099                 exit(-1);
2100         }
2101         else
2102         {
2103                 jtag_set_ntrst_delay(strtoul(args[0], NULL, 0));
2104         }
2105
2106         return ERROR_OK;
2107 }
2108
2109
2110 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2111 {
2112         int retval=ERROR_OK;
2113
2114         if (argc == 1)
2115         {
2116                 LOG_DEBUG("handle jtag speed");
2117
2118                 int cur_speed = 0;
2119                 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2120
2121                 /* this command can be called during CONFIG,
2122                  * in which case jtag isn't initialized */
2123                 if (jtag)
2124                 {
2125                         retval=jtag->speed(cur_speed);
2126                 }
2127         } else if (argc == 0)
2128         {
2129         } else
2130         {
2131                 return ERROR_COMMAND_SYNTAX_ERROR;
2132         }
2133         command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2134
2135         return retval;
2136 }
2137
2138 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2139 {
2140         int retval=ERROR_OK;
2141         LOG_DEBUG("handle jtag khz");
2142
2143         int cur_speed = 0;
2144         if(argc == 1)
2145         {
2146                 jtag_set_speed_khz(strtoul(args[0], NULL, 0));
2147                 if (jtag != NULL)
2148                 {
2149                         LOG_DEBUG("have interface set up");
2150                         int speed_div1;
2151                         if ((retval=jtag->khz(jtag_get_speed_khz(), &speed_div1))!=ERROR_OK)
2152                         {
2153                                 jtag_set_speed_khz(0);
2154                                 return retval;
2155                         }
2156
2157                         cur_speed = jtag_speed = speed_div1;
2158
2159                         retval=jtag->speed(cur_speed);
2160                 } else
2161                 {
2162                         hasKHz = true;
2163                 }
2164         } else if (argc==0)
2165         {
2166         } else
2167         {
2168                 return ERROR_COMMAND_SYNTAX_ERROR;
2169         }
2170         cur_speed = jtag_get_speed_khz();
2171
2172         if (jtag!=NULL)
2173         {
2174                 if ((retval=jtag->speed_div(jtag_speed, &cur_speed))!=ERROR_OK)
2175                         return retval;
2176         }
2177
2178         if (cur_speed)
2179                 command_print(cmd_ctx, "%d kHz", cur_speed);
2180         else
2181                 command_print(cmd_ctx, "RCLK - adaptive");
2182         return retval;
2183
2184 }
2185
2186 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2187 {
2188         tap_state_t state;
2189
2190         if (argc < 1)
2191         {
2192                 return ERROR_COMMAND_SYNTAX_ERROR;
2193         }
2194         else
2195         {
2196                 state = tap_state_by_name( args[0] );
2197                 if( state < 0 ){
2198                         command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2199                         return ERROR_COMMAND_SYNTAX_ERROR;
2200                 }
2201                 jtag_set_end_state(state);
2202                 jtag_execute_queue();
2203         }
2204         command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2205
2206         return ERROR_OK;
2207 }
2208
2209 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2210 {
2211         int trst = -1;
2212         int srst = -1;
2213
2214         if (argc < 2)
2215         {
2216                 return ERROR_COMMAND_SYNTAX_ERROR;
2217         }
2218
2219         if (args[0][0] == '1')
2220                 trst = 1;
2221         else if (args[0][0] == '0')
2222                 trst = 0;
2223         else
2224         {
2225                 return ERROR_COMMAND_SYNTAX_ERROR;
2226         }
2227
2228         if (args[1][0] == '1')
2229                 srst = 1;
2230         else if (args[1][0] == '0')
2231                 srst = 0;
2232         else
2233         {
2234                 return ERROR_COMMAND_SYNTAX_ERROR;
2235         }
2236
2237         if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2238                 return ERROR_JTAG_INIT_FAILED;
2239
2240         jtag_add_reset(trst, srst);
2241         jtag_execute_queue();
2242
2243         return ERROR_OK;
2244 }
2245
2246 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2247 {
2248         if (argc < 1)
2249         {
2250                 return ERROR_COMMAND_SYNTAX_ERROR;
2251         }
2252
2253         jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state());
2254         jtag_execute_queue();
2255
2256         return ERROR_OK;
2257
2258 }
2259
2260 /*
2261  * For "irscan" or "drscan" commands, the "end" (really, "next") state
2262  * should be stable ... and *NOT* a shift state, otherwise free-running
2263  * jtag clocks could change the values latched by the update state.
2264  */
2265 static bool scan_is_safe(tap_state_t state)
2266 {
2267         switch (state)
2268         {
2269         case TAP_RESET:
2270         case TAP_IDLE:
2271         case TAP_DRPAUSE:
2272         case TAP_IRPAUSE:
2273                 return true;
2274         default:
2275                 return false;
2276         }
2277 }
2278
2279
2280 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2281 {
2282         int i;
2283         scan_field_t *fields;
2284         jtag_tap_t *tap;
2285         tap_state_t endstate;
2286
2287         if ((argc < 2) || (argc % 2))
2288         {
2289                 return ERROR_COMMAND_SYNTAX_ERROR;
2290         }
2291
2292         /* optional "-endstate" "statename" at the end of the arguments,
2293          * so that e.g. IRPAUSE can let us load the data register before
2294          * entering RUN/IDLE to execute the instruction we load here.
2295          */
2296         endstate = TAP_IDLE;
2297
2298         if( argc >= 4 ){
2299                 /* have at least one pair of numbers. */
2300                 /* is last pair the magic text? */
2301                 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2302                         const char *cpA;
2303                         const char *cpS;
2304                         cpA = args[ argc-1 ];
2305                         for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2306                                 cpS = tap_state_name( endstate );
2307                                 if( 0 == strcmp( cpA, cpS ) ){
2308                                         break;
2309                                 }
2310                         }
2311                         if( endstate >= TAP_NUM_STATES ){
2312                                 return ERROR_COMMAND_SYNTAX_ERROR;
2313                         } else {
2314                                 if (!scan_is_safe(endstate))
2315                                         LOG_WARNING("irscan with unsafe "
2316                                                         "endstate \"%s\"", cpA);
2317                                 /* found - remove the last 2 args */
2318                                 argc -= 2;
2319                         }
2320                 }
2321         }
2322
2323         int num_fields = argc / 2;
2324
2325         fields = malloc(sizeof(scan_field_t) * num_fields);
2326
2327         for (i = 0; i < num_fields; i++)
2328         {
2329                 tap = jtag_tap_by_string( args[i*2] );
2330                 if (tap==NULL)
2331                 {
2332                         command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2333                         return ERROR_FAIL;
2334                 }
2335                 int field_size = tap->ir_length;
2336                 fields[i].tap = tap;
2337                 fields[i].num_bits = field_size;
2338                 fields[i].out_value = malloc(CEIL(field_size, 8));
2339                 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2340                 fields[i].in_value = NULL;
2341         }
2342
2343         /* did we have an endstate? */
2344         jtag_add_ir_scan(num_fields, fields, endstate);
2345
2346         int retval=jtag_execute_queue();
2347
2348         for (i = 0; i < num_fields; i++)
2349                 free(fields[i].out_value);
2350
2351         free (fields);
2352
2353         return retval;
2354 }
2355
2356 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2357 {
2358         int retval;
2359         scan_field_t *fields;
2360         int num_fields;
2361         int field_count = 0;
2362         int i, e;
2363         jtag_tap_t *tap;
2364         tap_state_t endstate;
2365
2366         /* args[1] = device
2367          * args[2] = num_bits
2368          * args[3] = hex string
2369          * ... repeat num bits and hex string ...
2370          *
2371          * .. optionally:
2372         *     args[N-2] = "-endstate"
2373          *     args[N-1] = statename
2374          */
2375         if ((argc < 4) || ((argc % 2)!=0))
2376         {
2377                 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2378                 return JIM_ERR;
2379         }
2380
2381         endstate = TAP_IDLE;
2382
2383         /* validate arguments as numbers */
2384         e = JIM_OK;
2385         for (i = 2; i < argc; i+=2)
2386         {
2387                 long bits;
2388                 const char *cp;
2389
2390                 e = Jim_GetLong(interp, args[i], &bits);
2391                 /* If valid - try next arg */
2392                 if( e == JIM_OK ){
2393                         continue;
2394                 }
2395
2396                 /* Not valid.. are we at the end? */
2397                 if ( ((i+2) != argc) ){
2398                         /* nope, then error */
2399                         return e;
2400                 }
2401
2402                 /* it could be: "-endstate FOO"
2403                  * e.g. DRPAUSE so we can issue more instructions
2404                  * before entering RUN/IDLE and executing them.
2405                  */
2406
2407                 /* get arg as a string. */
2408                 cp = Jim_GetString( args[i], NULL );
2409                 /* is it the magic? */
2410                 if( 0 == strcmp( "-endstate", cp ) ){
2411                         /* is the statename valid? */
2412                         cp = Jim_GetString( args[i+1], NULL );
2413
2414                         /* see if it is a valid state name */
2415                         endstate = tap_state_by_name(cp);
2416                         if( endstate < 0 ){
2417                                 /* update the error message */
2418                                 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2419                         } else {
2420                                 if (!scan_is_safe(endstate))
2421                                         LOG_WARNING("drscan with unsafe "
2422                                                         "endstate \"%s\"", cp);
2423
2424                                 /* valid - so clear the error */
2425                                 e = JIM_OK;
2426                                 /* and remove the last 2 args */
2427                                 argc -= 2;
2428                         }
2429                 }
2430
2431                 /* Still an error? */
2432                 if( e != JIM_OK ){
2433                         return e; /* too bad */
2434                 }
2435         } /* validate args */
2436
2437         tap = jtag_TapByJimObj( interp, args[1] );
2438         if( tap == NULL ){
2439                 return JIM_ERR;
2440         }
2441
2442         num_fields=(argc-2)/2;
2443         fields = malloc(sizeof(scan_field_t) * num_fields);
2444         for (i = 2; i < argc; i+=2)
2445         {
2446                 long bits;
2447                 int len;
2448                 const char *str;
2449
2450                 Jim_GetLong(interp, args[i], &bits);
2451                 str = Jim_GetString(args[i+1], &len);
2452
2453                 fields[field_count].tap = tap;
2454                 fields[field_count].num_bits = bits;
2455                 fields[field_count].out_value = malloc(CEIL(bits, 8));
2456                 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2457                 fields[field_count].in_value = fields[field_count].out_value;
2458                 field_count++;
2459         }
2460
2461         jtag_add_dr_scan(num_fields, fields, endstate);
2462
2463         retval = jtag_execute_queue();
2464         if (retval != ERROR_OK)
2465         {
2466                 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2467                 return JIM_ERR;
2468         }
2469
2470         field_count=0;
2471         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2472         for (i = 2; i < argc; i+=2)
2473         {
2474                 long bits;
2475                 char *str;
2476
2477                 Jim_GetLong(interp, args[i], &bits);
2478                 str = buf_to_str(fields[field_count].in_value, bits, 16);
2479                 free(fields[field_count].out_value);
2480
2481                 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2482                 free(str);
2483                 field_count++;
2484         }
2485
2486         Jim_SetResult(interp, list);
2487
2488         free(fields);
2489
2490         return JIM_OK;
2491 }
2492
2493
2494 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2495 {
2496         Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_get_flush_queue_count()));
2497
2498         return JIM_OK;
2499 }
2500
2501
2502 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2503 {
2504         if (argc == 1)
2505         {
2506                 if (strcmp(args[0], "enable") == 0)
2507                 {
2508                         jtag_verify_capture_ir = 1;
2509                 }
2510                 else if (strcmp(args[0], "disable") == 0)
2511                 {
2512                         jtag_verify_capture_ir = 0;
2513                 } else
2514                 {
2515                         return ERROR_COMMAND_SYNTAX_ERROR;
2516                 }
2517         } else if (argc != 0)
2518         {
2519                 return ERROR_COMMAND_SYNTAX_ERROR;
2520         }
2521
2522         command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2523
2524         return ERROR_OK;
2525 }
2526
2527 void jtag_set_verify(bool enable)
2528 {
2529         jtag_verify = enable;
2530 }
2531
2532 bool jtag_will_verify()
2533 {
2534         return jtag_verify;
2535 }
2536
2537 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2538 {
2539         if (argc > 1)
2540                 return ERROR_COMMAND_SYNTAX_ERROR;
2541
2542         if (argc == 1)
2543         {
2544                 if (strcmp(args[0], "enable") == 0)
2545                         jtag_set_verify(true);
2546                 else if (strcmp(args[0], "disable") == 0)
2547                         jtag_set_verify(false);
2548                 else
2549                         return ERROR_COMMAND_SYNTAX_ERROR;
2550         }
2551
2552         const char *status = jtag_will_verify() ? "enabled": "disabled";
2553         command_print(cmd_ctx, "verify jtag capture is %s", status);
2554
2555         return ERROR_OK;
2556 }
2557
2558
2559 int jtag_power_dropout(int *dropout)
2560 {
2561         return jtag->power_dropout(dropout);
2562 }
2563
2564 int jtag_srst_asserted(int *srst_asserted)
2565 {
2566         return jtag->srst_asserted(srst_asserted);
2567 }
2568
2569 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2570 {
2571         jtag_tap_event_action_t * jteap;
2572         int done;
2573
2574         jteap = tap->event_action;
2575
2576         done = 0;
2577         while (jteap) {
2578                 if (jteap->event == e) {
2579                         done = 1;
2580                         LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2581                                         tap->dotted_name,
2582                                         e,
2583                                         Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2584                                         Jim_GetString(jteap->body, NULL) );
2585                         if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2586                                 Jim_PrintErrorMessage(interp);
2587                         }
2588                 }
2589
2590                 jteap = jteap->next;
2591         }
2592
2593         if (!done) {
2594                 LOG_DEBUG( "event %d %s - no action",
2595                                 e,
2596                                 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
2597         }
2598 }
2599
2600 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2601 {
2602         if (argc > 1)
2603                 return ERROR_COMMAND_SYNTAX_ERROR;
2604
2605         if (argc == 1)
2606         {
2607                 bool use_new_table;
2608                 if (strcmp(args[0], "short") == 0)
2609                         use_new_table = true;
2610                 else if (strcmp(args[0], "long") == 0)
2611                         use_new_table = false;
2612                 else
2613                         return ERROR_COMMAND_SYNTAX_ERROR;
2614
2615                 tap_use_new_tms_table(use_new_table);
2616         }
2617
2618         command_print(cmd_ctx, "tms sequence is  %s",
2619                         tap_uses_new_tms_table() ? "short": "long");
2620
2621         return ERROR_OK;
2622 }
2623
2624 /**
2625  * Function jtag_add_statemove
2626  * moves from the current state to the goal \a state. This needs
2627  * to be handled according to the xsvf spec, see the XSTATE command
2628  * description.
2629  */
2630 int jtag_add_statemove(tap_state_t goal_state)
2631 {
2632         int retval = ERROR_OK;
2633
2634         tap_state_t moves[8];
2635         tap_state_t cur_state = cmd_queue_cur_state;
2636         int i;
2637         int tms_bits;
2638         int     tms_count;
2639
2640         LOG_DEBUG( "cur_state=%s goal_state=%s",
2641                 tap_state_name(cur_state),
2642                 tap_state_name(goal_state) );
2643
2644
2645         /*      From the XSVF spec, pertaining to XSTATE:
2646
2647                 For special states known as stable states (Test-Logic-Reset,
2648                 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2649                 predefined TAP state paths when the starting state is a stable state and
2650                 when the XSTATE specifies a new stable state (see the STATE command in
2651                 the [Ref 5] for the TAP state paths between stable states). For
2652                 non-stable states, XSTATE should specify a state that is only one TAP
2653                 state transition distance from the current TAP state to avoid undefined
2654                 TAP state paths. A sequence of multiple XSTATE commands can be issued to
2655                 transition the TAP through a specific state path.
2656         */
2657
2658         if (goal_state==cur_state )
2659                 ;       /* nothing to do */
2660
2661         else if( goal_state==TAP_RESET )
2662         {
2663                 jtag_add_tlr();
2664         }
2665
2666         else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
2667         {
2668                 /*      note: unless tms_bits holds a path that agrees with [Ref 5] in above
2669                         spec, then this code is not fully conformant to the xsvf spec.  This
2670                         puts a burden on tap_get_tms_path() function from the xsvf spec.
2671                         If in doubt, you should confirm that that burden is being met.
2672                 */
2673
2674                 tms_bits  = tap_get_tms_path(cur_state, goal_state);
2675                 tms_count = tap_get_tms_path_len(cur_state, goal_state);
2676
2677                 assert( (unsigned) tms_count < DIM(moves) );
2678
2679                 for (i=0;   i<tms_count;   i++, tms_bits>>=1)
2680                 {
2681                         bool bit = tms_bits & 1;
2682
2683                         cur_state = tap_state_transition(cur_state, bit);
2684                         moves[i] = cur_state;
2685                 }
2686
2687                 jtag_add_pathmove(tms_count, moves);
2688         }
2689
2690         /*      else state must be immediately reachable in one clock cycle, and does not
2691                 need to be a stable state.
2692         */
2693         else if( tap_state_transition(cur_state, true)  == goal_state
2694                 ||   tap_state_transition(cur_state, false) == goal_state )
2695         {
2696                 /* move a single state */
2697                 moves[0] = goal_state;
2698                 jtag_add_pathmove( 1, moves );
2699         }
2700
2701         else
2702         {
2703                 retval = ERROR_FAIL;
2704         }
2705
2706         return retval;
2707 }
2708
2709 void jtag_set_nsrst_delay(unsigned delay)
2710 {
2711         jtag_nsrst_delay = delay;
2712 }
2713 void jtag_set_ntrst_delay(unsigned delay)
2714 {
2715         jtag_ntrst_delay = delay;
2716 }
2717
2718