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