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