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 #define INCLUDE_JTAG_MINIDRIVER_H
  32 #define INCLUDE_JTAG_INTERFACE_H
  33 #include "jtag.h"
  34
  35 #ifdef HAVE_STRINGS_H
  36 #include <strings.h>
  37 #endif
  38
  39
  40 int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
  41
  42 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
  43                 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
  44
  45 /* note that this is not marked as static as it must be available from outside jtag.c for those
  46    that implement the jtag_xxx() minidriver layer
  47 */
  48 int jtag_error=ERROR_OK;
  49
  50 typedef struct cmd_queue_page_s
  51 {
  52         void *address;
  53         size_t used;
  54         struct cmd_queue_page_s *next;
  55 } cmd_queue_page_t;
  56
  57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
  58 static cmd_queue_page_t *cmd_queue_pages = NULL;
  59
  60 char* jtag_event_strings[] =
  61 {
  62         "JTAG controller reset (RESET or TRST)"
  63 };
  64
  65 const Jim_Nvp nvp_jtag_tap_event[] = {
  66         { .value = JTAG_TAP_EVENT_ENABLE,       .name = "tap-enable" },
  67         { .value = JTAG_TAP_EVENT_DISABLE,      .name = "tap-disable" },
  68
  69         { .name = NULL, .value = -1 }
  70 };
  71
  72 int jtag_trst = 0;
  73 int jtag_srst = 0;
  74
  75 jtag_command_t *jtag_command_queue = NULL;
  76 static jtag_command_t **next_command_pointer = &jtag_command_queue;
  77 static jtag_tap_t *jtag_all_taps = NULL;
  78
  79 enum reset_types jtag_reset_config = RESET_NONE;
  80 tap_state_t cmd_queue_end_state = TAP_RESET;
  81 tap_state_t cmd_queue_cur_state = TAP_RESET;
  82
  83 int jtag_verify_capture_ir = 1;
  84 int jtag_verify = 1;
  85
  86 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
  87 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
  88 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
  89
  90 /* maximum number of JTAG devices expected in the chain
  91  */
  92 #define JTAG_MAX_CHAIN_SIZE 20
  93
  94 /* callbacks to inform high-level handlers about JTAG state changes */
  95 jtag_event_callback_t *jtag_event_callbacks;
  96
  97 /* speed in kHz*/
  98 static int speed_khz = 0;
  99 /* flag if the kHz speed was defined */
 100 static int hasKHz = 0;
 101
 102 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
 103  */
 104
 105 #if BUILD_ECOSBOARD == 1
 106         extern jtag_interface_t zy1000_interface;
 107 #endif
 108
 109 #if BUILD_PARPORT == 1
 110         extern jtag_interface_t parport_interface;
 111 #endif
 112
 113 #if BUILD_DUMMY == 1
 114         extern jtag_interface_t dummy_interface;
 115 #endif
 116
 117 #if BUILD_FT2232_FTD2XX == 1
 118         extern jtag_interface_t ft2232_interface;
 119 #endif
 120
 121 #if BUILD_FT2232_LIBFTDI == 1
 122         extern jtag_interface_t ft2232_interface;
 123 #endif
 124
 125 #if BUILD_AMTJTAGACCEL == 1
 126         extern jtag_interface_t amt_jtagaccel_interface;
 127 #endif
 128
 129 #if BUILD_EP93XX == 1
 130         extern jtag_interface_t ep93xx_interface;
 131 #endif
 132
 133 #if BUILD_AT91RM9200 == 1
 134         extern jtag_interface_t at91rm9200_interface;
 135 #endif
 136
 137 #if BUILD_GW16012 == 1
 138         extern jtag_interface_t gw16012_interface;
 139 #endif
 140
 141 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 142         extern jtag_interface_t presto_interface;
 143 #endif
 144
 145 #if BUILD_USBPROG == 1
 146         extern jtag_interface_t usbprog_interface;
 147 #endif
 148
 149 #if BUILD_JLINK == 1
 150         extern jtag_interface_t jlink_interface;
 151 #endif
 152
 153 #if BUILD_VSLLINK == 1
 154         extern jtag_interface_t vsllink_interface;
 155 #endif
 156
 157 #if BUILD_RLINK == 1
 158         extern jtag_interface_t rlink_interface;
 159 #endif
 160
 161 #if BUILD_ARMJTAGEW == 1
 162         extern jtag_interface_t armjtagew_interface;
 163 #endif
 164
 165 jtag_interface_t *jtag_interfaces[] = {
 166 #if BUILD_ECOSBOARD == 1
 167         &zy1000_interface,
 168 #endif
 169 #if BUILD_PARPORT == 1
 170         &parport_interface,
 171 #endif
 172 #if BUILD_DUMMY == 1
 173         &dummy_interface,
 174 #endif
 175 #if BUILD_FT2232_FTD2XX == 1
 176         &ft2232_interface,
 177 #endif
 178 #if BUILD_FT2232_LIBFTDI == 1
 179         &ft2232_interface,
 180 #endif
 181 #if BUILD_AMTJTAGACCEL == 1
 182         &amt_jtagaccel_interface,
 183 #endif
 184 #if BUILD_EP93XX == 1
 185         &ep93xx_interface,
 186 #endif
 187 #if BUILD_AT91RM9200 == 1
 188         &at91rm9200_interface,
 189 #endif
 190 #if BUILD_GW16012 == 1
 191         &gw16012_interface,
 192 #endif
 193 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 194         &presto_interface,
 195 #endif
 196 #if BUILD_USBPROG == 1
 197         &usbprog_interface,
 198 #endif
 199 #if BUILD_JLINK == 1
 200         &jlink_interface,
 201 #endif
 202 #if BUILD_VSLLINK == 1
 203         &vsllink_interface,
 204 #endif
 205 #if BUILD_RLINK == 1
 206         &rlink_interface,
 207 #endif
 208 #if BUILD_ARMJTAGEW == 1
 209         &armjtagew_interface,
 210 #endif
 211         NULL,
 212 };
 213
 214 struct jtag_interface_s *jtag = NULL;
 215
 216 /* configuration */
 217 static jtag_interface_t *jtag_interface = NULL;
 218 int jtag_speed = 0;
 219
 220 /* forward declarations */
 221 //void jtag_add_pathmove(int num_states, tap_state_t *path);
 222 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
 223 //void jtag_add_end_state(tap_state_t endstate);
 224 //void jtag_add_sleep(u32 us);
 225 //int jtag_execute_queue(void);
 226 static tap_state_t tap_state_by_name(const char *name);
 227
 228 /* jtag commands */
 229 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 230 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 231 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 232 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 233 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 234 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 235 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 236
 237 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 238
 239 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 240 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 241 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 242 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 243 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 244 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
 245
 246 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 247 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 248 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 249
 250 jtag_tap_t *jtag_AllTaps(void)
 251 {
 252         return jtag_all_taps;
 253 };
 254
 255 int jtag_NumTotalTaps(void)
 256 {
 257         jtag_tap_t *t;
 258         int n;
 259
 260         n = 0;
 261         t = jtag_AllTaps();
 262         while(t){
 263                 n++;
 264                 t = t->next_tap;
 265         }
 266         return n;
 267 }
 268
 269 int jtag_NumEnabledTaps(void)
 270 {
 271         jtag_tap_t *t;
 272         int n;
 273
 274         n = 0;
 275         t = jtag_AllTaps();
 276         while(t){
 277                 if( t->enabled ){
 278                         n++;
 279                 }
 280                 t = t->next_tap;
 281         }
 282         return n;
 283 }
 284
 285 jtag_tap_t *jtag_TapByString( const char *s )
 286 {
 287         jtag_tap_t *t;
 288         char *cp;
 289
 290         t = jtag_AllTaps();
 291         /* try name first */
 292         while(t){
 293                 if( 0 == strcmp( t->dotted_name, s ) ){
 294                         break;
 295                 } else {
 296                         t = t->next_tap;
 297                 }
 298         }
 299         /* backup plan is by number */
 300         if( t == NULL ){
 301                 /* ok - is "s" a number? */
 302                 int n;
 303                 n = strtol( s, &cp, 0 );
 304                 if( (s != cp) && (*cp == 0) ){
 305                         /* Then it is... */
 306                         t = jtag_TapByAbsPosition(n);
 307                 }
 308         }
 309         return t;
 310 }
 311
 312 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
 313 {
 314         jtag_tap_t *t;
 315         const char *cp;
 316
 317         cp = Jim_GetString( o, NULL );
 318         if(cp == NULL){
 319                 cp = "(unknown)";
 320                 t = NULL;
 321         }  else {
 322                 t = jtag_TapByString( cp );
 323         }
 324         if( t == NULL ){
 325                 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
 326         }
 327         return t;
 328 }
 329
 330 /* returns a pointer to the n-th device in the scan chain */
 331 jtag_tap_t * jtag_TapByAbsPosition( int n )
 332 {
 333         int orig_n;
 334         jtag_tap_t *t;
 335
 336         orig_n = n;
 337         t = jtag_AllTaps();
 338
 339         while( t && (n > 0)) {
 340                 n--;
 341                 t = t->next_tap;
 342         }
 343         return t;
 344 }
 345
 346 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
 347 {
 348         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 349
 350         if (callback == NULL)
 351         {
 352                 return ERROR_INVALID_ARGUMENTS;
 353         }
 354
 355         if (*callbacks_p)
 356         {
 357                 while ((*callbacks_p)->next)
 358                         callbacks_p = &((*callbacks_p)->next);
 359                 callbacks_p = &((*callbacks_p)->next);
 360         }
 361
 362         (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
 363         (*callbacks_p)->callback = callback;
 364         (*callbacks_p)->priv = priv;
 365         (*callbacks_p)->next = NULL;
 366
 367         return ERROR_OK;
 368 }
 369
 370 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
 371 {
 372         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 373
 374         if (callback == NULL)
 375         {
 376                 return ERROR_INVALID_ARGUMENTS;
 377         }
 378
 379         while (*callbacks_p)
 380         {
 381                 jtag_event_callback_t **next = &((*callbacks_p)->next);
 382                 if ((*callbacks_p)->callback == callback)
 383                 {
 384                         free(*callbacks_p);
 385                         *callbacks_p = *next;
 386                 }
 387                 callbacks_p = next;
 388         }
 389
 390         return ERROR_OK;
 391 }
 392
 393 int jtag_call_event_callbacks(enum jtag_event event)
 394 {
 395         jtag_event_callback_t *callback = jtag_event_callbacks;
 396
 397         LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
 398
 399         while (callback)
 400         {
 401                 callback->callback(event, callback->priv);
 402                 callback = callback->next;
 403         }
 404
 405         return ERROR_OK;
 406 }
 407
 408 void jtag_queue_command(jtag_command_t * cmd)
 409 {
 410         // this command goes on the end, so ensure the queue terminates
 411         cmd->next = NULL;
 412
 413         jtag_command_t **last_cmd = next_command_pointer;
 414         assert(NULL != last_cmd);
 415         assert(NULL == *last_cmd);
 416         *last_cmd = cmd;
 417
 418         // store location where the next command pointer will be stored
 419         next_command_pointer = &cmd->next;
 420 }
 421
 422 void* cmd_queue_alloc(size_t size)
 423 {
 424         cmd_queue_page_t **p_page = &cmd_queue_pages;
 425         int offset;
 426         u8 *t;
 427
 428         /*
 429          * WARNING:
 430          *    We align/round the *SIZE* per below
 431          *    so that all pointers returned by
 432          *    this function are reasonably well
 433          *    aligned.
 434          *
 435          * If we did not, then an "odd-length" request would cause the
 436          * *next* allocation to be at an *odd* address, and because
 437          * this function has the same type of api as malloc() - we
 438          * must also return pointers that have the same type of
 439          * alignment.
 440          *
 441          * What I do not/have is a reasonable portable means
 442          * to align by...
 443          *
 444          * The solution here, is based on these suggestions.
 445          * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
 446          *
 447          */
 448         union worse_case_align {
 449                 int i;
 450                 long l;
 451                 float f;
 452                 void *v;
 453         };
 454 #define ALIGN_SIZE  (sizeof(union worse_case_align))
 455
 456         /* The alignment process. */
 457         size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
 458         /* Done... */
 459
 460         if (*p_page)
 461         {
 462                 while ((*p_page)->next)
 463                         p_page = &((*p_page)->next);
 464                 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
 465                         p_page = &((*p_page)->next);
 466         }
 467
 468         if (!*p_page)
 469         {
 470                 *p_page = malloc(sizeof(cmd_queue_page_t));
 471                 (*p_page)->used = 0;
 472                 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
 473                 (*p_page)->next = NULL;
 474         }
 475
 476         offset = (*p_page)->used;
 477         (*p_page)->used += size;
 478
 479         t=(u8 *)((*p_page)->address);
 480         return t + offset;
 481 }
 482
 483 void cmd_queue_free(void)
 484 {
 485         cmd_queue_page_t *page = cmd_queue_pages;
 486
 487         while (page)
 488         {
 489                 cmd_queue_page_t *last = page;
 490                 free(page->address);
 491                 page = page->next;
 492                 free(last);
 493         }
 494
 495         cmd_queue_pages = NULL;
 496 }
 497
 498 void jtag_command_queue_reset(void)
 499 {
 500         cmd_queue_free();
 501
 502         jtag_command_queue = NULL;
 503         next_command_pointer = &jtag_command_queue;
 504 }
 505
 506 static void jtag_prelude1(void)
 507 {
 508         if (jtag_trst == 1)
 509         {
 510                 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
 511                 jtag_error=ERROR_JTAG_TRST_ASSERTED;
 512                 return;
 513         }
 514
 515         if (cmd_queue_end_state == TAP_RESET)
 516                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 517 }
 518
 519 static void jtag_prelude(tap_state_t state)
 520 {
 521         jtag_prelude1();
 522
 523         if (state != TAP_INVALID)
 524                 jtag_add_end_state(state);
 525
 526         cmd_queue_cur_state = cmd_queue_end_state;
 527 }
 528
 529 void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 530 {
 531         int retval;
 532         jtag_prelude(state);
 533
 534         retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 535         if (retval!=ERROR_OK)
 536                 jtag_error=retval;
 537
 538 }
 539
 540
 541 /**
 542  * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
 543  *
 544  * If the input field list contains an instruction value for a TAP then that is used
 545  * otherwise the TAP is set to bypass.
 546  *
 547  * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
 548  *
 549  */
 550 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 551 {
 552         if (jtag_verify&&jtag_verify_capture_ir)
 553         {
 554                 /* 8 x 32 bit id's is enough for all invocations */
 555
 556                 for (int j = 0; j < in_num_fields; j++)
 557                 {
 558                         /* if we are to run a verification of the ir scan, we need to get the input back.
 559                          * We may have to allocate space if the caller didn't ask for the input back.
 560                          */
 561                         in_fields[j].check_value=in_fields[j].tap->expected;
 562                         in_fields[j].check_mask=in_fields[j].tap->expected_mask;
 563                 }
 564                 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
 565         } else
 566         {
 567                 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
 568         }
 569 }
 570
 571 /**
 572  * Duplicate the scan fields passed into the function into an IR SCAN command
 573  *
 574  * This function assumes that the caller handles extra fields for bypassed TAPs
 575  *
 576  */
 577 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 578 {
 579         int retval;
 580
 581         jtag_prelude(state);
 582
 583         retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 584         if (retval!=ERROR_OK)
 585                 jtag_error=retval;
 586 }
 587
 588
 589
 590 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
 591
 592 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
 593 {
 594         return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
 595 }
 596
 597 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
 598                 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 599 {
 600         for (int i = 0; i < in_num_fields; i++)
 601         {
 602                 struct scan_field_s *field = &in_fields[i];
 603                 field->allocated = 0;
 604                 field->modified = 0;
 605                 if (field->check_value || field->in_value)
 606                         continue;
 607                 interface_jtag_add_scan_check_alloc(field);
 608                 field->modified = 1;
 609         }
 610
 611         jtag_add_scan(in_num_fields, in_fields, state);
 612
 613         for (int i = 0; i < in_num_fields; i++)
 614         {
 615                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
 616                 {
 617                         /* this is synchronous for a minidriver */
 618                         jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
 619                                 (jtag_callback_data_t)in_fields[i].check_value,
 620                                 (jtag_callback_data_t)in_fields[i].check_mask,
 621                                 (jtag_callback_data_t)in_fields[i].num_bits);
 622                 }
 623                 if (in_fields[i].allocated)
 624                 {
 625                         free(in_fields[i].in_value);
 626                 }
 627                 if (in_fields[i].modified)
 628                 {
 629                         in_fields[i].in_value = NULL;
 630                 }
 631         }
 632 }
 633
 634 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 635 {
 636         if (jtag_verify)
 637         {
 638                 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
 639         } else
 640         {
 641                 jtag_add_dr_scan(in_num_fields, in_fields, state);
 642         }
 643 }
 644
 645
 646 /**
 647  * Generate a DR SCAN using the fields passed to the function
 648  *
 649  * For not bypassed TAPs the function checks in_fields and uses fields specified there.
 650  * For bypassed TAPs the function generates a dummy 1bit field.
 651  *
 652  * The bypass status of TAPs is set by jtag_add_ir_scan().
 653  *
 654  */
 655 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 656 {
 657         int retval;
 658
 659         jtag_prelude(state);
 660
 661         retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
 662         if (retval!=ERROR_OK)
 663                 jtag_error=retval;
 664 }
 665
 666
 667
 668 /**
 669  * Duplicate the scan fields passed into the function into a DR SCAN command
 670  *
 671  * This function assumes that the caller handles extra fields for bypassed TAPs
 672  *
 673  */
 674 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 675 {
 676         int retval;
 677
 678         jtag_prelude(state);
 679
 680         retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
 681         if (retval!=ERROR_OK)
 682                 jtag_error=retval;
 683 }
 684
 685
 686
 687 void jtag_add_tlr(void)
 688 {
 689         jtag_prelude(TAP_RESET);
 690
 691         int retval;
 692         retval=interface_jtag_add_tlr();
 693         if (retval!=ERROR_OK)
 694                 jtag_error=retval;
 695 }
 696
 697 void jtag_add_pathmove(int num_states, const tap_state_t *path)
 698 {
 699         tap_state_t cur_state = cmd_queue_cur_state;
 700         int i;
 701         int retval;
 702
 703         /* the last state has to be a stable state */
 704         if (!tap_is_state_stable(path[num_states - 1]))
 705         {
 706                 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
 707                 exit(-1);
 708         }
 709
 710         for (i=0; i<num_states; i++)
 711         {
 712                 if (path[i] == TAP_RESET)
 713                 {
 714                         LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
 715                         exit(-1);
 716                 }
 717
 718                 if ( tap_state_transition(cur_state, true)  != path[i]
 719                   && tap_state_transition(cur_state, false) != path[i])
 720                 {
 721                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
 722                         exit(-1);
 723                 }
 724                 cur_state = path[i];
 725         }
 726
 727         jtag_prelude1();
 728
 729         retval = interface_jtag_add_pathmove(num_states, path);
 730         cmd_queue_cur_state = path[num_states - 1];
 731         if (retval!=ERROR_OK)
 732                 jtag_error=retval;
 733 }
 734
 735 void jtag_add_runtest(int num_cycles, tap_state_t state)
 736 {
 737         int retval;
 738
 739         jtag_prelude(state);
 740
 741         /* executed by sw or hw fifo */
 742         retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
 743         if (retval!=ERROR_OK)
 744                 jtag_error=retval;
 745 }
 746
 747
 748 void jtag_add_clocks( int num_cycles )
 749 {
 750         int retval;
 751
 752         if( !tap_is_state_stable(cmd_queue_cur_state) )
 753         {
 754                  LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
 755                                  tap_state_name(cmd_queue_cur_state) );
 756                  jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
 757                  return;
 758         }
 759
 760         if( num_cycles > 0 )
 761         {
 762                 jtag_prelude1();
 763
 764                 retval = interface_jtag_add_clocks(num_cycles);
 765                 if (retval != ERROR_OK)
 766                         jtag_error=retval;
 767         }
 768 }
 769
 770 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
 771 {
 772         int trst_with_tlr = 0;
 773         int retval;
 774
 775         /* FIX!!! there are *many* different cases here. A better
 776          * approach is needed for legal combinations of transitions...
 777          */
 778         if ((jtag_reset_config & RESET_HAS_SRST)&&
 779                         (jtag_reset_config & RESET_HAS_TRST)&&
 780                         ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
 781         {
 782                 if (((req_tlr_or_trst&&!jtag_trst)||
 783                                 (!req_tlr_or_trst&&jtag_trst))&&
 784                                 ((req_srst&&!jtag_srst)||
 785                                                 (!req_srst&&jtag_srst)))
 786                 {
 787                         /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
 788                         //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
 789                 }
 790         }
 791
 792         /* Make sure that jtag_reset_config allows the requested reset */
 793         /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
 794         if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
 795         {
 796                 LOG_ERROR("BUG: requested reset would assert trst");
 797                 jtag_error=ERROR_FAIL;
 798                 return;
 799         }
 800
 801         /* if TRST pulls SRST, we reset with TAP T-L-R */
 802         if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
 803         {
 804                 trst_with_tlr = 1;
 805         }
 806
 807         if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
 808         {
 809                 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
 810                 jtag_error=ERROR_FAIL;
 811                 return;
 812         }
 813
 814         if (req_tlr_or_trst)
 815         {
 816                 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
 817                 {
 818                         jtag_trst = 1;
 819                 } else
 820                 {
 821                         trst_with_tlr = 1;
 822                 }
 823         } else
 824         {
 825                 jtag_trst = 0;
 826         }
 827
 828         jtag_srst = req_srst;
 829
 830         retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
 831         if (retval!=ERROR_OK)
 832         {
 833                 jtag_error=retval;
 834                 return;
 835         }
 836         jtag_execute_queue();
 837
 838         if (jtag_srst)
 839         {
 840                 LOG_DEBUG("SRST line asserted");
 841         }
 842         else
 843         {
 844                 LOG_DEBUG("SRST line released");
 845                 if (jtag_nsrst_delay)
 846                         jtag_add_sleep(jtag_nsrst_delay * 1000);
 847         }
 848
 849         if (trst_with_tlr)
 850         {
 851                 LOG_DEBUG("JTAG reset with RESET instead of TRST");
 852                 jtag_add_end_state(TAP_RESET);
 853                 jtag_add_tlr();
 854                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 855                 return;
 856         }
 857
 858         if (jtag_trst)
 859         {
 860                 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
 861                  * and inform possible listeners about this
 862                  */
 863                 LOG_DEBUG("TRST line asserted");
 864                 tap_set_state(TAP_RESET);
 865                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 866         }
 867         else
 868         {
 869                 if (jtag_ntrst_delay)
 870                         jtag_add_sleep(jtag_ntrst_delay * 1000);
 871         }
 872 }
 873
 874 void jtag_add_end_state(tap_state_t state)
 875 {
 876         cmd_queue_end_state = state;
 877         if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
 878         {
 879                 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
 880         }
 881 }
 882
 883 void jtag_add_sleep(u32 us)
 884 {
 885         keep_alive(); /* we might be running on a very slow JTAG clk */
 886         int retval=interface_jtag_add_sleep(us);
 887         if (retval!=ERROR_OK)
 888                 jtag_error=retval;
 889         return;
 890 }
 891
 892 int jtag_scan_size(const scan_command_t *cmd)
 893 {
 894         int bit_count = 0;
 895         int i;
 896
 897         /* count bits in scan command */
 898         for (i = 0; i < cmd->num_fields; i++)
 899         {
 900                 bit_count += cmd->fields[i].num_bits;
 901         }
 902
 903         return bit_count;
 904 }
 905
 906 int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer)
 907 {
 908         int bit_count = 0;
 909         int i;
 910
 911         bit_count = jtag_scan_size(cmd);
 912         *buffer = calloc(1,CEIL(bit_count, 8));
 913
 914         bit_count = 0;
 915
 916 #ifdef _DEBUG_JTAG_IO_
 917         LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
 918 #endif
 919
 920         for (i = 0; i < cmd->num_fields; i++)
 921         {
 922                 if (cmd->fields[i].out_value)
 923                 {
 924 #ifdef _DEBUG_JTAG_IO_
 925                         char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16);
 926 #endif
 927                         buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
 928 #ifdef _DEBUG_JTAG_IO_
 929                         LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
 930                         free(char_buf);
 931 #endif
 932                 }
 933                 else
 934                 {
 935 #ifdef _DEBUG_JTAG_IO_
 936                         LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
 937 #endif
 938                 }
 939
 940                 bit_count += cmd->fields[i].num_bits;
 941         }
 942
 943 #ifdef _DEBUG_JTAG_IO_
 944         //LOG_DEBUG("bit_count totalling: %i",  bit_count );
 945 #endif
 946
 947         return bit_count;
 948 }
 949
 950 int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd)
 951 {
 952         int i;
 953         int bit_count = 0;
 954         int retval;
 955
 956         /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
 957         retval = ERROR_OK;
 958
 959         for (i = 0; i < cmd->num_fields; i++)
 960         {
 961                 /* if neither in_value nor in_handler
 962                  * are specified we don't have to examine this field
 963                  */
 964                 if (cmd->fields[i].in_value)
 965                 {
 966                         int num_bits = cmd->fields[i].num_bits;
 967                         u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
 968
 969 #ifdef _DEBUG_JTAG_IO_
 970                         char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
 971                         LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
 972                         free(char_buf);
 973 #endif
 974
 975                         if (cmd->fields[i].in_value)
 976                         {
 977                                 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
 978                         }
 979
 980                         free(captured);
 981                 }
 982                 bit_count += cmd->fields[i].num_bits;
 983         }
 984
 985         return retval;
 986 }
 987
 988 static const char *jtag_tap_name(const jtag_tap_t *tap)
 989 {
 990         return (tap == NULL) ? "(unknown)" : tap->dotted_name;
 991 }
 992
 993 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits)
 994 {
 995         int retval = ERROR_OK;
 996
 997         int compare_failed = 0;
 998
 999         if (in_check_mask)
1000                 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1001         else
1002                 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1003
1004         if (compare_failed){
1005                 /* An error handler could have caught the failing check
1006                  * only report a problem when there wasn't a handler, or if the handler
1007                  * acknowledged the error
1008                  */
1009                 /*
1010                 LOG_WARNING("TAP %s:",
1011                                         jtag_tap_name(field->tap));
1012                                         */
1013                 if (compare_failed)
1014                 {
1015                         char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1016                         char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1017
1018                         if (in_check_mask)
1019                         {
1020                                 char *in_check_mask_char;
1021                                 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1022                                 LOG_WARNING("value captured during scan didn't pass the requested check:");
1023                                 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1024                                                         captured_char, in_check_value_char, in_check_mask_char);
1025                                 free(in_check_mask_char);
1026                         }
1027                         else
1028                         {
1029                                 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);
1030                         }
1031
1032                         free(captured_char);
1033                         free(in_check_value_char);
1034
1035                         retval = ERROR_JTAG_QUEUE_FAILED;
1036                 }
1037
1038         }
1039         return retval;
1040 }
1041
1042 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1043 {
1044         assert(field->in_value != NULL);
1045
1046         if (value==NULL)
1047         {
1048                 /* no checking to do */
1049                 return;
1050         }
1051
1052         jtag_execute_queue_noclear();
1053
1054         int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
1055         jtag_set_error(retval);
1056 }
1057
1058
1059
1060 enum scan_type jtag_scan_type(const scan_command_t *cmd)
1061 {
1062         int i;
1063         int type = 0;
1064
1065         for (i = 0; i < cmd->num_fields; i++)
1066         {
1067                 if (cmd->fields[i].in_value)
1068                         type |= SCAN_IN;
1069                 if (cmd->fields[i].out_value)
1070                         type |= SCAN_OUT;
1071         }
1072
1073         return type;
1074 }
1075
1076 int default_interface_jtag_execute_queue(void)
1077 {
1078         if (NULL == jtag)
1079         {
1080                 LOG_ERROR("No JTAG interface configured yet.  "
1081                         "Issue 'init' command in startup scripts "
1082                         "before communicating with targets.");
1083                 return ERROR_FAIL;
1084         }
1085
1086         return jtag->execute_queue();
1087 }
1088
1089 void jtag_execute_queue_noclear(void)
1090 {
1091         /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1092          * E.g. a JTAG over TCP/IP or USB....
1093          */
1094         jtag_flush_queue_count++;
1095
1096         int retval=interface_jtag_execute_queue();
1097         /* we keep the first error */
1098         if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1099         {
1100                 jtag_error=retval;
1101         }
1102 }
1103
1104 int jtag_execute_queue(void)
1105 {
1106         int retval;
1107         jtag_execute_queue_noclear();
1108         retval=jtag_error;
1109         jtag_error=ERROR_OK;
1110         return retval;
1111 }
1112
1113 int jtag_reset_callback(enum jtag_event event, void *priv)
1114 {
1115         jtag_tap_t *tap = priv;
1116
1117         LOG_DEBUG("-");
1118
1119         if (event == JTAG_TRST_ASSERTED)
1120         {
1121                 buf_set_ones(tap->cur_instr, tap->ir_length);
1122                 tap->bypass = 1;
1123         }
1124
1125         return ERROR_OK;
1126 }
1127
1128 void jtag_sleep(u32 us)
1129 {
1130         alive_sleep(us/1000);
1131 }
1132
1133 /* Try to examine chain layout according to IEEE 1149.1 §12
1134  */
1135 int jtag_examine_chain(void)
1136 {
1137         jtag_tap_t *tap;
1138         scan_field_t field;
1139         u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1140         int i;
1141         int bit_count;
1142         int device_count = 0;
1143         u8 zero_check = 0x0;
1144         u8 one_check = 0xff;
1145
1146         field.tap = NULL;
1147         field.num_bits = sizeof(idcode_buffer) * 8;
1148         field.out_value = idcode_buffer;
1149
1150         field.in_value = idcode_buffer;
1151
1152
1153
1154
1155         for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1156         {
1157                 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1158         }
1159
1160         jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1161         jtag_execute_queue();
1162
1163         for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1164         {
1165                 zero_check |= idcode_buffer[i];
1166                 one_check &= idcode_buffer[i];
1167         }
1168
1169         /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1170         if ((zero_check == 0x00) || (one_check == 0xff))
1171         {
1172                 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1173                 return ERROR_JTAG_INIT_FAILED;
1174         }
1175
1176         /* point at the 1st tap */
1177         tap = jtag_NextEnabledTap(NULL);
1178         if( tap == NULL ){
1179                 LOG_ERROR("JTAG: No taps enabled?");
1180                 return ERROR_JTAG_INIT_FAILED;
1181         }
1182
1183         for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1184         {
1185                 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1186                 if ((idcode & 1) == 0)
1187                 {
1188                         /* LSB must not be 0, this indicates a device in bypass */
1189                         LOG_WARNING("Tap/Device does not have IDCODE");
1190                         idcode=0;
1191
1192                         bit_count += 1;
1193                 }
1194                 else
1195                 {
1196                         u32 manufacturer;
1197                         u32 part;
1198                         u32 version;
1199
1200                         /* some devices, such as AVR will output all 1's instead of TDI
1201                         input value at end of chain. */
1202                         if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1203                         {
1204                                 int unexpected=0;
1205                                 /* End of chain (invalid manufacturer ID)
1206                                  *
1207                                  * The JTAG examine is the very first thing that happens
1208                                  *
1209                                  * A single JTAG device requires only 64 bits to be read back correctly.
1210                                  *
1211                                  * The code below adds a check that the rest of the data scanned (640 bits)
1212                                  * are all as expected. This helps diagnose/catch problems with the JTAG chain
1213                                  *
1214                                  * earlier and gives more helpful/explicit error messages.
1215                                  */
1216                                 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1217                                 {
1218                                         idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1219                                         if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1220                                         {
1221                                                 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1222                                                 unexpected = 1;
1223                                         }
1224                                 }
1225
1226                                 break;
1227                         }
1228
1229 #define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
1230                         manufacturer = EXTRACT_MFG(idcode);
1231 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1232                         part = EXTRACT_PART(idcode);
1233 #define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)
1234                         version = EXTRACT_VER(idcode);
1235
1236                         LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1237                                          ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1238                                 idcode, manufacturer, part, version);
1239
1240                         bit_count += 32;
1241                 }
1242                 if (tap)
1243                 {
1244                         tap->idcode = idcode;
1245
1246                         if (tap->expected_ids_cnt > 0) {
1247                                 /* Loop over the expected identification codes and test for a match */
1248                                 u8 ii;
1249                                 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1250                                         if( tap->idcode == tap->expected_ids[ii] ){
1251                                                 break;
1252                                         }
1253                                 }
1254
1255                                 /* If none of the expected ids matched, log an error */
1256                                 if (ii == tap->expected_ids_cnt) {
1257                                         LOG_ERROR("JTAG tap: %s             got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1258                                                           tap->dotted_name,
1259                                                           idcode,
1260                                                           EXTRACT_MFG( tap->idcode ),
1261                                                           EXTRACT_PART( tap->idcode ),
1262                                                           EXTRACT_VER( tap->idcode ) );
1263                                         for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1264                                                 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1265                                                                   tap->dotted_name,
1266                                                                   ii + 1,
1267                                                                   tap->expected_ids_cnt,
1268                                                                   tap->expected_ids[ii],
1269                                                                   EXTRACT_MFG( tap->expected_ids[ii] ),
1270                                                                   EXTRACT_PART( tap->expected_ids[ii] ),
1271                                                                   EXTRACT_VER( tap->expected_ids[ii] ) );
1272                                         }
1273
1274                                         return ERROR_JTAG_INIT_FAILED;
1275                                 } else {
1276                                         LOG_INFO("JTAG Tap/device matched");
1277                                 }
1278                         } else {
1279 #if 0
1280                                 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1281                                                  tap->idcode);
1282 #endif
1283                         }
1284                         tap = jtag_NextEnabledTap(tap);
1285                 }
1286                 device_count++;
1287         }
1288
1289         /* see if number of discovered devices matches configuration */
1290         if (device_count != jtag_NumEnabledTaps())
1291         {
1292                 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1293                                   device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1294                 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1295                 return ERROR_JTAG_INIT_FAILED;
1296         }
1297
1298         return ERROR_OK;
1299 }
1300
1301 int jtag_validate_chain(void)
1302 {
1303         jtag_tap_t *tap;
1304         int total_ir_length = 0;
1305         u8 *ir_test = NULL;
1306         scan_field_t field;
1307         int chain_pos = 0;
1308
1309         tap = NULL;
1310         total_ir_length = 0;
1311         for(;;){
1312                 tap = jtag_NextEnabledTap(tap);
1313                 if( tap == NULL ){
1314                         break;
1315                 }
1316                 total_ir_length += tap->ir_length;
1317         }
1318
1319         total_ir_length += 2;
1320         ir_test = malloc(CEIL(total_ir_length, 8));
1321         buf_set_ones(ir_test, total_ir_length);
1322
1323         field.tap = NULL;
1324         field.num_bits = total_ir_length;
1325         field.out_value = ir_test;
1326         field.in_value = ir_test;
1327
1328
1329         jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1330         jtag_execute_queue();
1331
1332         tap = NULL;
1333         chain_pos = 0;
1334         int val;
1335         for(;;){
1336                 tap = jtag_NextEnabledTap(tap);
1337                 if( tap == NULL ){
1338                         break;
1339                 }
1340
1341                 val = buf_get_u32(ir_test, chain_pos, 2);
1342                 if (val != 0x1)
1343                 {
1344                         char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1345                         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);
1346                         free(cbuf);
1347                         free(ir_test);
1348                         return ERROR_JTAG_INIT_FAILED;
1349                 }
1350                 chain_pos += tap->ir_length;
1351         }
1352
1353         val = buf_get_u32(ir_test, chain_pos, 2);
1354         if (val != 0x3)
1355         {
1356                 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1357                 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);
1358                 free(cbuf);
1359                 free(ir_test);
1360                 return ERROR_JTAG_INIT_FAILED;
1361         }
1362
1363         free(ir_test);
1364
1365         return ERROR_OK;
1366 }
1367
1368 enum jtag_tap_cfg_param {
1369         JCFG_EVENT
1370 };
1371
1372 static Jim_Nvp nvp_config_opts[] = {
1373         { .name = "-event",      .value = JCFG_EVENT },
1374
1375         { .name = NULL,          .value = -1 }
1376 };
1377
1378 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1379 {
1380         Jim_Nvp *n;
1381         Jim_Obj *o;
1382         int e;
1383
1384         /* parse config or cget options */
1385         while (goi->argc > 0) {
1386                 Jim_SetEmptyResult (goi->interp);
1387
1388                 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1389                 if (e != JIM_OK) {
1390                         Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1391                         return e;
1392                 }
1393
1394                 switch (n->value) {
1395                         case JCFG_EVENT:
1396                                 if (goi->argc == 0) {
1397                                         Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1398                                         return JIM_ERR;
1399                                 }
1400
1401                                 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1402                                 if (e != JIM_OK) {
1403                                         Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1404                                         return e;
1405                                 }
1406
1407                                 if (goi->isconfigure) {
1408                                         if (goi->argc != 1) {
1409                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1410                                                 return JIM_ERR;
1411                                         }
1412                                 } else {
1413                                         if (goi->argc != 0) {
1414                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1415                                                 return JIM_ERR;
1416                                         }
1417                                 }
1418
1419                                 {
1420                                         jtag_tap_event_action_t *jteap;
1421
1422                                         jteap = tap->event_action;
1423                                         /* replace existing? */
1424                                         while (jteap) {
1425                                                 if (jteap->event == (enum jtag_tap_event)n->value) {
1426                                                         break;
1427                                                 }
1428                                                 jteap = jteap->next;
1429                                         }
1430
1431                                         if (goi->isconfigure) {
1432                                                 if (jteap == NULL) {
1433                                                         /* create new */
1434                                                         jteap = calloc(1, sizeof (*jteap));
1435                                                 }
1436                                                 jteap->event = n->value;
1437                                                 Jim_GetOpt_Obj( goi, &o);
1438                                                 if (jteap->body) {
1439                                                         Jim_DecrRefCount(interp, jteap->body);
1440                                                 }
1441                                                 jteap->body = Jim_DuplicateObj(goi->interp, o);
1442                                                 Jim_IncrRefCount(jteap->body);
1443
1444                                                 /* add to head of event list */
1445                                                 jteap->next = tap->event_action;
1446                                                 tap->event_action = jteap;
1447                                                 Jim_SetEmptyResult(goi->interp);
1448                                         } else {
1449                                                 /* get */
1450                                                 if (jteap == NULL) {
1451                                                         Jim_SetEmptyResult(goi->interp);
1452                                                 } else {
1453                                                         Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1454                                                 }
1455                                         }
1456                                 }
1457                                 /* loop for more */
1458                                 break;
1459                 }
1460         } /* while (goi->argc) */
1461
1462         return JIM_OK;
1463 }
1464
1465 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1466 {
1467         jtag_tap_t *pTap;
1468         jtag_tap_t **ppTap;
1469         jim_wide w;
1470         int x;
1471         int e;
1472         int reqbits;
1473         Jim_Nvp *n;
1474         char *cp;
1475         const Jim_Nvp opts[] = {
1476 #define NTAP_OPT_IRLEN     0
1477                 { .name = "-irlen"                      ,       .value = NTAP_OPT_IRLEN },
1478 #define NTAP_OPT_IRMASK    1
1479                 { .name = "-irmask"                     ,       .value = NTAP_OPT_IRMASK },
1480 #define NTAP_OPT_IRCAPTURE 2
1481                 { .name = "-ircapture"          ,       .value = NTAP_OPT_IRCAPTURE },
1482 #define NTAP_OPT_ENABLED   3
1483                 { .name = "-enable"                     ,       .value = NTAP_OPT_ENABLED },
1484 #define NTAP_OPT_DISABLED  4
1485                 { .name = "-disable"            ,       .value = NTAP_OPT_DISABLED },
1486 #define NTAP_OPT_EXPECTED_ID 5
1487                 { .name = "-expected-id"        ,       .value = NTAP_OPT_EXPECTED_ID },
1488                 { .name = NULL                          ,       .value = -1 },
1489         };
1490
1491         pTap = malloc( sizeof(jtag_tap_t) );
1492         memset( pTap, 0, sizeof(*pTap) );
1493         if( !pTap ){
1494                 Jim_SetResult_sprintf( goi->interp, "no memory");
1495                 return JIM_ERR;
1496         }
1497         /*
1498          * we expect CHIP + TAP + OPTIONS
1499          * */
1500         if( goi->argc < 3 ){
1501                 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1502                 return JIM_ERR;
1503         }
1504         Jim_GetOpt_String( goi, &cp, NULL );
1505         pTap->chip = strdup(cp);
1506
1507         Jim_GetOpt_String( goi, &cp, NULL );
1508         pTap->tapname = strdup(cp);
1509
1510         /* name + dot + name + null */
1511         x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1512         cp = malloc( x );
1513         sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1514         pTap->dotted_name = cp;
1515
1516         LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1517                           pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1518
1519         /* default is enabled */
1520         pTap->enabled = 1;
1521
1522         /* deal with options */
1523 #define NTREQ_IRLEN      1
1524 #define NTREQ_IRCAPTURE  2
1525 #define NTREQ_IRMASK     4
1526
1527         /* clear them as we find them */
1528         reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1529
1530         while( goi->argc ){
1531                 e = Jim_GetOpt_Nvp( goi, opts, &n );
1532                 if( e != JIM_OK ){
1533                         Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1534                         return e;
1535                 }
1536                 LOG_DEBUG("Processing option: %s", n->name );
1537                 switch( n->value ){
1538                 case NTAP_OPT_ENABLED:
1539                         pTap->enabled = 1;
1540                         break;
1541                 case NTAP_OPT_DISABLED:
1542                         pTap->enabled = 0;
1543                         break;
1544                 case NTAP_OPT_EXPECTED_ID:
1545                 {
1546                         u32 *new_expected_ids;
1547
1548                         e = Jim_GetOpt_Wide( goi, &w );
1549                         if( e != JIM_OK) {
1550                                 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1551                                 return e;
1552                         }
1553
1554                         new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1555                         if (new_expected_ids == NULL) {
1556                                 Jim_SetResult_sprintf( goi->interp, "no memory");
1557                                 return JIM_ERR;
1558                         }
1559
1560                         memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1561
1562                         new_expected_ids[pTap->expected_ids_cnt] = w;
1563
1564                         free(pTap->expected_ids);
1565                         pTap->expected_ids = new_expected_ids;
1566                         pTap->expected_ids_cnt++;
1567                         break;
1568                 }
1569                 case NTAP_OPT_IRLEN:
1570                 case NTAP_OPT_IRMASK:
1571                 case NTAP_OPT_IRCAPTURE:
1572                         e = Jim_GetOpt_Wide( goi, &w );
1573                         if( e != JIM_OK ){
1574                                 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1575                                 return e;
1576                         }
1577                         if( (w < 0) || (w > 0xffff) ){
1578                                 /* wacky value */
1579                                 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1580                                                                            n->name, (int)(w), (int)(w));
1581                                 return JIM_ERR;
1582                         }
1583                         switch(n->value){
1584                         case NTAP_OPT_IRLEN:
1585                                 pTap->ir_length = w;
1586                                 reqbits &= (~(NTREQ_IRLEN));
1587                                 break;
1588                         case NTAP_OPT_IRMASK:
1589                                 pTap->ir_capture_mask = w;
1590                                 reqbits &= (~(NTREQ_IRMASK));
1591                                 break;
1592                         case NTAP_OPT_IRCAPTURE:
1593                                 pTap->ir_capture_value = w;
1594                                 reqbits &= (~(NTREQ_IRCAPTURE));
1595                                 break;
1596                         }
1597                 } /* switch(n->value) */
1598         } /* while( goi->argc ) */
1599
1600         /* Did we get all the options? */
1601         if( reqbits ){
1602                 // no
1603                 Jim_SetResult_sprintf( goi->interp,
1604                                                            "newtap: %s missing required parameters",
1605                                                            pTap->dotted_name);
1606                 /* TODO: Tell user what is missing :-( */
1607                 /* no memory leaks pelase */
1608                 free(((void *)(pTap->expected_ids)));
1609                 free(((void *)(pTap->chip)));
1610                 free(((void *)(pTap->tapname)));
1611                 free(((void *)(pTap->dotted_name)));
1612                 free(((void *)(pTap)));
1613                 return JIM_ERR;
1614         }
1615
1616         pTap->expected      = malloc( pTap->ir_length );
1617         pTap->expected_mask = malloc( pTap->ir_length );
1618         pTap->cur_instr     = malloc( pTap->ir_length );
1619
1620         buf_set_u32( pTap->expected,
1621                                  0,
1622                                  pTap->ir_length,
1623                                  pTap->ir_capture_value );
1624         buf_set_u32( pTap->expected_mask,
1625                                  0,
1626                                  pTap->ir_length,
1627                                  pTap->ir_capture_mask );
1628         buf_set_ones( pTap->cur_instr,
1629                                   pTap->ir_length );
1630
1631         pTap->bypass = 1;
1632
1633         jtag_register_event_callback(jtag_reset_callback, pTap );
1634
1635         ppTap = &(jtag_all_taps);
1636         while( (*ppTap) != NULL ){
1637                 ppTap = &((*ppTap)->next_tap);
1638         }
1639         *ppTap = pTap;
1640         {
1641                 static int n_taps = 0;
1642                 pTap->abs_chain_position = n_taps++;
1643         }
1644         LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1645                                 (*ppTap)->dotted_name,
1646                                 (*ppTap)->abs_chain_position,
1647                                 (*ppTap)->ir_length,
1648                                 (*ppTap)->ir_capture_value,
1649                                 (*ppTap)->ir_capture_mask );
1650
1651         return ERROR_OK;
1652 }
1653
1654 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1655 {
1656         Jim_GetOptInfo goi;
1657         int e;
1658         Jim_Nvp *n;
1659         Jim_Obj *o;
1660         struct command_context_s *context;
1661
1662         enum {
1663                 JTAG_CMD_INTERFACE,
1664                 JTAG_CMD_INIT_RESET,
1665                 JTAG_CMD_NEWTAP,
1666                 JTAG_CMD_TAPENABLE,
1667                 JTAG_CMD_TAPDISABLE,
1668                 JTAG_CMD_TAPISENABLED,
1669                 JTAG_CMD_CONFIGURE,
1670                 JTAG_CMD_CGET
1671         };
1672
1673         const Jim_Nvp jtag_cmds[] = {
1674                 { .name = "interface"     , .value = JTAG_CMD_INTERFACE },
1675                 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
1676                 { .name = "newtap"        , .value = JTAG_CMD_NEWTAP },
1677                 { .name = "tapisenabled"     , .value = JTAG_CMD_TAPISENABLED },
1678                 { .name = "tapenable"     , .value = JTAG_CMD_TAPENABLE },
1679                 { .name = "tapdisable"    , .value = JTAG_CMD_TAPDISABLE },
1680                 { .name = "configure"     , .value = JTAG_CMD_CONFIGURE },
1681                 { .name = "cget"          , .value = JTAG_CMD_CGET },
1682
1683                 { .name = NULL, .value = -1 },
1684         };
1685
1686         context = Jim_GetAssocData(interp, "context");
1687         /* go past the command */
1688         Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
1689
1690         e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
1691         if( e != JIM_OK ){
1692                 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
1693                 return e;
1694         }
1695                 Jim_SetEmptyResult( goi.interp );
1696         switch( n->value ){
1697         case JTAG_CMD_INTERFACE:
1698                 /* return the name of the interface */
1699                 /* TCL code might need to know the exact type... */
1700                 /* FUTURE: we allow this as a means to "set" the interface. */
1701                 if( goi.argc != 0 ){
1702                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1703                         return JIM_ERR;
1704                 }
1705                 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
1706                 return JIM_OK;
1707         case JTAG_CMD_INIT_RESET:
1708                 if( goi.argc != 0 ){
1709                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1710                         return JIM_ERR;
1711                 }
1712                 e = jtag_init_reset(context);
1713                 if( e != ERROR_OK ){
1714                         Jim_SetResult_sprintf( goi.interp, "error: %d", e);
1715                         return JIM_ERR;
1716                 }
1717                 return JIM_OK;
1718         case JTAG_CMD_NEWTAP:
1719                 return jim_newtap_cmd( &goi );
1720                 break;
1721         case JTAG_CMD_TAPISENABLED:
1722         case JTAG_CMD_TAPENABLE:
1723         case JTAG_CMD_TAPDISABLE:
1724                 if( goi.argc != 1 ){
1725                         Jim_SetResultString( goi.interp, "Too many parameters",-1 );
1726                         return JIM_ERR;
1727                 }
1728
1729                 {
1730                         jtag_tap_t *t;
1731                         t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
1732                         if( t == NULL ){
1733                                 return JIM_ERR;
1734                         }
1735                         switch( n->value ){
1736                         case JTAG_CMD_TAPISENABLED:
1737                                 e = t->enabled;
1738                                 break;
1739                         case JTAG_CMD_TAPENABLE:
1740                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
1741                                 e = 1;
1742                                 t->enabled = e;
1743                                 break;
1744                         case JTAG_CMD_TAPDISABLE:
1745                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
1746                                 e = 0;
1747                                 t->enabled = e;
1748                                 break;
1749                         }
1750                         Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
1751                         return JIM_OK;
1752                 }
1753                 break;
1754
1755         case JTAG_CMD_CGET:
1756                 if( goi.argc < 2 ){
1757                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
1758                         return JIM_ERR;
1759                 }
1760
1761                 {
1762                         jtag_tap_t *t;
1763
1764                         Jim_GetOpt_Obj(&goi, &o);
1765                         t = jtag_TapByJimObj( goi.interp, o );
1766                         if( t == NULL ){
1767                                 return JIM_ERR;
1768                         }
1769
1770                         goi.isconfigure = 0;
1771                         return jtag_tap_configure_cmd( &goi, t);
1772                 }
1773                 break;
1774
1775         case JTAG_CMD_CONFIGURE:
1776                 if( goi.argc < 3 ){
1777                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
1778                         return JIM_ERR;
1779                 }
1780
1781                 {
1782                         jtag_tap_t *t;
1783
1784                         Jim_GetOpt_Obj(&goi, &o);
1785                         t = jtag_TapByJimObj( goi.interp, o );
1786                         if( t == NULL ){
1787                                 return JIM_ERR;
1788                         }
1789
1790                         goi.isconfigure = 1;
1791                         return jtag_tap_configure_cmd( &goi, t);
1792                 }
1793         }
1794
1795         return JIM_ERR;
1796 }
1797
1798 int jtag_register_commands(struct command_context_s *cmd_ctx)
1799 {
1800         register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
1801
1802         register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1803                 COMMAND_CONFIG, "try to configure interface");
1804         register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1805                 COMMAND_ANY, "(DEPRECATED) set jtag speed (if supported)");
1806         register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1807                 COMMAND_ANY, "set maximum jtag speed (if supported); "
1808                 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1809         register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1810                 COMMAND_CONFIG, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1811         register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1812                 COMMAND_ANY,
1813                 "[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]");
1814         register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1815                 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1816         register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1817                 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1818
1819         register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1820                 COMMAND_EXEC, "print current scan chain configuration");
1821
1822         register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1823                 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1824         register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1825                 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1826         register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1827                 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1828         register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1829                 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1830         register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1831         register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
1832
1833         register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1834                 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1835         register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
1836                 COMMAND_ANY, "verify value capture <enable|disable>");
1837         register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
1838                 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
1839         return ERROR_OK;
1840 }
1841
1842 int jtag_interface_init(struct command_context_s *cmd_ctx)
1843 {
1844         if (jtag)
1845                 return ERROR_OK;
1846
1847         if (!jtag_interface)
1848         {
1849                 /* nothing was previously specified by "interface" command */
1850                 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1851                 return ERROR_JTAG_INVALID_INTERFACE;
1852         }
1853         if(hasKHz)
1854         {
1855                 jtag_interface->khz(speed_khz, &jtag_speed);
1856                 hasKHz = 0;
1857         }
1858
1859         if (jtag_interface->init() != ERROR_OK)
1860                 return ERROR_JTAG_INIT_FAILED;
1861
1862         jtag = jtag_interface;
1863         return ERROR_OK;
1864 }
1865
1866 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1867 {
1868         jtag_tap_t *tap;
1869         int retval;
1870
1871         LOG_DEBUG("Init JTAG chain");
1872
1873         tap = jtag_NextEnabledTap(NULL);
1874         if( tap == NULL ){
1875                 LOG_ERROR("There are no enabled taps?");
1876                 return ERROR_JTAG_INIT_FAILED;
1877         }
1878
1879         jtag_add_tlr();
1880         if ((retval=jtag_execute_queue())!=ERROR_OK)
1881                 return retval;
1882
1883         /* examine chain first, as this could discover the real chain layout */
1884         if (jtag_examine_chain() != ERROR_OK)
1885         {
1886                 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1887         }
1888
1889         if (jtag_validate_chain() != ERROR_OK)
1890         {
1891                 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1892         }
1893
1894         return ERROR_OK;
1895 }
1896
1897 int jtag_interface_quit(void)
1898 {
1899         if (!jtag || !jtag->quit)
1900                 return ERROR_OK;
1901
1902         // close the JTAG interface
1903         int result = jtag->quit();
1904         if (ERROR_OK != result)
1905                 LOG_ERROR("failed: %d", result);
1906
1907         return ERROR_OK;
1908 }
1909
1910
1911 int jtag_init_reset(struct command_context_s *cmd_ctx)
1912 {
1913         int retval;
1914
1915         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1916                 return retval;
1917
1918         LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1919
1920         /* Reset can happen after a power cycle.
1921          *
1922          * Ideally we would only assert TRST or run RESET before the target reset.
1923          *
1924          * However w/srst_pulls_trst, trst is asserted together with the target
1925          * reset whether we want it or not.
1926          *
1927          * NB! Some targets have JTAG circuitry disabled until a
1928          * trst & srst has been asserted.
1929          *
1930          * NB! here we assume nsrst/ntrst delay are sufficient!
1931          *
1932          * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1933          *
1934          */
1935         jtag_add_reset(1, 0); /* RESET or TRST */
1936         if (jtag_reset_config & RESET_HAS_SRST)
1937         {
1938                 jtag_add_reset(1, 1);
1939                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1940                         jtag_add_reset(0, 1);
1941         }
1942         jtag_add_reset(0, 0);
1943         if ((retval = jtag_execute_queue()) != ERROR_OK)
1944                 return retval;
1945
1946         /* Check that we can communication on the JTAG chain + eventually we want to
1947          * be able to perform enumeration only after OpenOCD has started
1948          * telnet and GDB server
1949          *
1950          * That would allow users to more easily perform any magic they need to before
1951          * reset happens.
1952          */
1953         return jtag_init_inner(cmd_ctx);
1954 }
1955
1956 int jtag_init(struct command_context_s *cmd_ctx)
1957 {
1958         int retval;
1959         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1960                 return retval;
1961         if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1962         {
1963                 return ERROR_OK;
1964         }
1965         return jtag_init_reset(cmd_ctx);
1966 }
1967
1968 static int default_khz(int khz, int *jtag_speed)
1969 {
1970         LOG_ERROR("Translation from khz to jtag_speed not implemented");
1971         return ERROR_FAIL;
1972 }
1973
1974 static int default_speed_div(int speed, int *khz)
1975 {
1976         LOG_ERROR("Translation from jtag_speed to khz not implemented");
1977         return ERROR_FAIL;
1978 }
1979
1980 static int default_power_dropout(int *dropout)
1981 {
1982         *dropout=0; /* by default we can't detect power dropout */
1983         return ERROR_OK;
1984 }
1985
1986 static int default_srst_asserted(int *srst_asserted)
1987 {
1988         *srst_asserted=0; /* by default we can't detect srst asserted */
1989         return ERROR_OK;
1990 }
1991
1992 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1993 {
1994         int i;
1995         int retval;
1996
1997         /* check whether the interface is already configured */
1998         if (jtag_interface)
1999         {
2000                 LOG_WARNING("Interface already configured, ignoring");
2001                 return ERROR_OK;
2002         }
2003
2004         /* interface name is a mandatory argument */
2005         if (argc < 1 || args[0][0] == '\0')
2006         {
2007                 return ERROR_COMMAND_SYNTAX_ERROR;
2008         }
2009
2010         for (i=0; jtag_interfaces[i]; i++)
2011         {
2012                 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2013                 {
2014                         if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2015                         {
2016                                 return retval;
2017                         }
2018
2019                         jtag_interface = jtag_interfaces[i];
2020
2021                         if (jtag_interface->khz == NULL)
2022                         {
2023                                 jtag_interface->khz = default_khz;
2024                         }
2025                         if (jtag_interface->speed_div == NULL)
2026                         {
2027                                 jtag_interface->speed_div = default_speed_div;
2028                         }
2029                         if (jtag_interface->power_dropout == NULL)
2030                         {
2031                                 jtag_interface->power_dropout = default_power_dropout;
2032                         }
2033                         if (jtag_interface->srst_asserted == NULL)
2034                         {
2035                                 jtag_interface->srst_asserted = default_srst_asserted;
2036                         }
2037
2038                         return ERROR_OK;
2039                 }
2040         }
2041
2042         /* no valid interface was found (i.e. the configuration option,
2043          * didn't match one of the compiled-in interfaces
2044          */
2045         LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2046         LOG_ERROR("compiled-in jtag interfaces:");
2047         for (i = 0; jtag_interfaces[i]; i++)
2048         {
2049                 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2050         }
2051
2052         return ERROR_JTAG_INVALID_INTERFACE;
2053 }
2054
2055 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2056 {
2057         int e;
2058         char buf[1024];
2059         Jim_Obj *newargs[ 10 ];
2060         /*
2061          * CONVERT SYNTAX
2062          * argv[-1] = command
2063          * argv[ 0] = ir length
2064          * argv[ 1] = ir capture
2065          * argv[ 2] = ir mask
2066          * argv[ 3] = not actually used by anything but in the docs
2067          */
2068
2069         if( argc < 4 ){
2070                 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2071                 return ERROR_OK;
2072         }
2073         command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2074         command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2075                                    args[0],
2076                                    args[1],
2077                                    args[2] );
2078         command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2079         command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2080         command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2081         command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2082
2083         newargs[0] = Jim_NewStringObj( interp, "jtag", -1   );
2084         newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2085         sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2086         newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2087         sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2088         newargs[3] = Jim_NewStringObj( interp, buf, -1  );
2089         newargs[4] = Jim_NewStringObj( interp, "-irlen", -1  );
2090         newargs[5] = Jim_NewStringObj( interp, args[0], -1  );
2091         newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1  );
2092         newargs[7] = Jim_NewStringObj( interp, args[1], -1  );
2093         newargs[8] = Jim_NewStringObj( interp, "-irmask", -1  );
2094         newargs[9] = Jim_NewStringObj( interp, args[2], -1  );
2095
2096         command_print( cmd_ctx, "NEW COMMAND:");
2097         sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2098                          Jim_GetString( newargs[0], NULL ),
2099                          Jim_GetString( newargs[1], NULL ),
2100                          Jim_GetString( newargs[2], NULL ),
2101                          Jim_GetString( newargs[3], NULL ),
2102                          Jim_GetString( newargs[4], NULL ),
2103                          Jim_GetString( newargs[5], NULL ),
2104                          Jim_GetString( newargs[6], NULL ),
2105                          Jim_GetString( newargs[7], NULL ),
2106                          Jim_GetString( newargs[8], NULL ),
2107                          Jim_GetString( newargs[9], NULL ) );
2108
2109         e = jim_jtag_command( interp, 10, newargs );
2110         if( e != JIM_OK ){
2111                 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2112         }
2113         return e;
2114 }
2115
2116 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2117 {
2118         jtag_tap_t *tap;
2119
2120         tap = jtag_all_taps;
2121         command_print(cmd_ctx, "     TapName            | Enabled |   IdCode      Expected    IrLen IrCap  IrMask Instr     ");
2122         command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2123
2124         while( tap ){
2125                 u32 expected, expected_mask, cur_instr, ii;
2126                 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2127                 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2128                 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2129
2130                 command_print(cmd_ctx,
2131                                           "%2d | %-18s |    %c    | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2132                                           tap->abs_chain_position,
2133                                           tap->dotted_name,
2134                                           tap->enabled ? 'Y' : 'n',
2135                                           tap->idcode,
2136                                           (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2137                                           tap->ir_length,
2138                                           expected,
2139                                           expected_mask,
2140                                           cur_instr);
2141
2142                 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2143                         command_print(cmd_ctx, "   |                    |         |            | 0x%08x |      |      |      |         ",
2144                                                   tap->expected_ids[ii]);
2145                 }
2146
2147                 tap = tap->next_tap;
2148         }
2149
2150         return ERROR_OK;
2151 }
2152
2153 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2154 {
2155         int new_cfg = 0;
2156         int mask = 0;
2157
2158         if (argc < 1)
2159                 return ERROR_COMMAND_SYNTAX_ERROR;
2160
2161         /* Original versions cared about the order of these tokens:
2162          *   reset_config signals [combination [trst_type [srst_type]]]
2163          * They also clobbered the previous configuration even on error.
2164          *
2165          * Here we don't care about the order, and only change values
2166          * which have been explicitly specified.
2167          */
2168         for (; argc; argc--, args++) {
2169                 int tmp = 0;
2170                 int m;
2171
2172                 /* signals */
2173                 m = RESET_HAS_TRST | RESET_HAS_SRST;
2174                 if (strcmp(*args, "none") == 0)
2175                         tmp = RESET_NONE;
2176                 else if (strcmp(*args, "trst_only") == 0)
2177                         tmp = RESET_HAS_TRST;
2178                 else if (strcmp(*args, "srst_only") == 0)
2179                         tmp = RESET_HAS_SRST;
2180                 else if (strcmp(*args, "trst_and_srst") == 0)
2181                         tmp = RESET_HAS_TRST | RESET_HAS_SRST;
2182                 else
2183                         m = 0;
2184                 if (mask & m) {
2185                         LOG_ERROR("extra reset_config %s spec (%s)",
2186                                         "signal", *args);
2187                         return ERROR_INVALID_ARGUMENTS;
2188                 }
2189                 if (m)
2190                         goto next;
2191
2192                 /* combination (options for broken wiring) */
2193                 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2194                 if (strcmp(*args, "separate") == 0)
2195                         /* separate reset lines - default */;
2196                 else if (strcmp(*args, "srst_pulls_trst") == 0)
2197                         tmp |= RESET_SRST_PULLS_TRST;
2198                 else if (strcmp(*args, "trst_pulls_srst") == 0)
2199                         tmp |= RESET_TRST_PULLS_SRST;
2200                 else if (strcmp(*args, "combined") == 0)
2201                         tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2202                 else
2203                         m = 0;
2204                 if (mask & m) {
2205                         LOG_ERROR("extra reset_config %s spec (%s)",
2206                                         "combination", *args);
2207                         return ERROR_INVALID_ARGUMENTS;
2208                 }
2209                 if (m)
2210                         goto next;
2211
2212                 /* trst_type (NOP without HAS_TRST) */
2213                 m = RESET_TRST_OPEN_DRAIN;
2214                 if (strcmp(*args, "trst_open_drain") == 0)
2215                         tmp |= RESET_TRST_OPEN_DRAIN;
2216                 else if (strcmp(*args, "trst_push_pull") == 0)
2217                         /* push/pull from adapter - default */;
2218                 else
2219                         m = 0;
2220                 if (mask & m) {
2221                         LOG_ERROR("extra reset_config %s spec (%s)",
2222                                         "trst_type", *args);
2223                         return ERROR_INVALID_ARGUMENTS;
2224                 }
2225                 if (m)
2226                         goto next;
2227
2228                 /* srst_type (NOP without HAS_SRST) */
2229                 m |= RESET_SRST_PUSH_PULL;
2230                 if (strcmp(*args, "srst_push_pull") == 0)
2231                         tmp |= RESET_SRST_PUSH_PULL;
2232                 else if (strcmp(*args, "srst_open_drain") == 0)
2233                         /* open drain from adapter - default */;
2234                 else
2235                         m = 0;
2236                 if (mask & m) {
2237                         LOG_ERROR("extra reset_config %s spec (%s)",
2238                                         "srst_type", *args);
2239                         return ERROR_INVALID_ARGUMENTS;
2240                 }
2241                 if (m)
2242                         goto next;
2243
2244                 /* caller provided nonsense; fail */
2245                 LOG_ERROR("unknown reset_config flag (%s)", *args);
2246                 return ERROR_INVALID_ARGUMENTS;
2247
2248 next:
2249                 /* Remember the bits which were specified (mask)
2250                  * and their new values (new_cfg).
2251                  */
2252                 mask |= m;
2253                 new_cfg |= tmp;
2254         }
2255
2256         /* clear previous values of those bits, save new values */
2257         jtag_reset_config &= ~mask;
2258         jtag_reset_config |= new_cfg;
2259
2260         return ERROR_OK;
2261 }
2262
2263 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2264 {
2265         if (argc < 1)
2266         {
2267                 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2268                 exit(-1);
2269         }
2270         else
2271         {
2272                 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2273         }
2274
2275         return ERROR_OK;
2276 }
2277
2278 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2279 {
2280         if (argc < 1)
2281         {
2282                 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2283                 exit(-1);
2284         }
2285         else
2286         {
2287                 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2288         }
2289
2290         return ERROR_OK;
2291 }
2292
2293 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2294 {
2295         int retval=ERROR_OK;
2296
2297         if (argc == 1)
2298         {
2299                 LOG_DEBUG("handle jtag speed");
2300
2301                 int cur_speed = 0;
2302                 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2303
2304                 /* this command can be called during CONFIG,
2305                  * in which case jtag isn't initialized */
2306                 if (jtag)
2307                 {
2308                         retval=jtag->speed(cur_speed);
2309                 }
2310         } else if (argc == 0)
2311         {
2312         } else
2313         {
2314                 return ERROR_COMMAND_SYNTAX_ERROR;
2315         }
2316         command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2317
2318         return retval;
2319 }
2320
2321 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2322 {
2323         int retval=ERROR_OK;
2324         LOG_DEBUG("handle jtag khz");
2325
2326         if(argc == 1)
2327         {
2328                 speed_khz = strtoul(args[0], NULL, 0);
2329                 if (jtag != NULL)
2330                 {
2331                         int cur_speed = 0;
2332                         LOG_DEBUG("have interface set up");
2333                         int speed_div1;
2334                         if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2335                         {
2336                                 speed_khz = 0;
2337                                 return retval;
2338                         }
2339
2340                         cur_speed = jtag_speed = speed_div1;
2341
2342                         retval=jtag->speed(cur_speed);
2343                 } else
2344                 {
2345                         hasKHz = 1;
2346                 }
2347         } else if (argc==0)
2348         {
2349         } else
2350         {
2351                 return ERROR_COMMAND_SYNTAX_ERROR;
2352         }
2353
2354         if (jtag!=NULL)
2355         {
2356                 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2357                         return retval;
2358         }
2359
2360         if (speed_khz==0)
2361         {
2362                 command_print(cmd_ctx, "RCLK - adaptive");
2363         } else
2364         {
2365                 command_print(cmd_ctx, "%d kHz", speed_khz);
2366         }
2367         return retval;
2368
2369 }
2370
2371 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2372 {
2373         tap_state_t state;
2374
2375         if (argc < 1)
2376         {
2377                 return ERROR_COMMAND_SYNTAX_ERROR;
2378         }
2379         else
2380         {
2381                 state = tap_state_by_name( args[0] );
2382                 if( state < 0 ){
2383                         command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2384                         return ERROR_COMMAND_SYNTAX_ERROR;
2385                 }
2386                 jtag_add_end_state(state);
2387                 jtag_execute_queue();
2388         }
2389         command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2390
2391         return ERROR_OK;
2392 }
2393
2394 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2395 {
2396         int trst = -1;
2397         int srst = -1;
2398
2399         if (argc < 2)
2400         {
2401                 return ERROR_COMMAND_SYNTAX_ERROR;
2402         }
2403
2404         if (args[0][0] == '1')
2405                 trst = 1;
2406         else if (args[0][0] == '0')
2407                 trst = 0;
2408         else
2409         {
2410                 return ERROR_COMMAND_SYNTAX_ERROR;
2411         }
2412
2413         if (args[1][0] == '1')
2414                 srst = 1;
2415         else if (args[1][0] == '0')
2416                 srst = 0;
2417         else
2418         {
2419                 return ERROR_COMMAND_SYNTAX_ERROR;
2420         }
2421
2422         if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2423                 return ERROR_JTAG_INIT_FAILED;
2424
2425         jtag_add_reset(trst, srst);
2426         jtag_execute_queue();
2427
2428         return ERROR_OK;
2429 }
2430
2431 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2432 {
2433         if (argc < 1)
2434         {
2435                 return ERROR_COMMAND_SYNTAX_ERROR;
2436         }
2437
2438         jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2439         jtag_execute_queue();
2440
2441         return ERROR_OK;
2442
2443 }
2444
2445 /*
2446  * For "irscan" or "drscan" commands, the "end" (really, "next") state
2447  * should be stable ... and *NOT* a shift state, otherwise free-running
2448  * jtag clocks could change the values latched by the update state.
2449  */
2450 static bool scan_is_safe(tap_state_t state)
2451 {
2452         switch (state)
2453         {
2454         case TAP_RESET:
2455         case TAP_IDLE:
2456         case TAP_DRPAUSE:
2457         case TAP_IRPAUSE:
2458                 return true;
2459         default:
2460                 return false;
2461         }
2462 }
2463
2464
2465 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2466 {
2467         int i;
2468         scan_field_t *fields;
2469         jtag_tap_t *tap;
2470         tap_state_t endstate;
2471
2472         if ((argc < 2) || (argc % 2))
2473         {
2474                 return ERROR_COMMAND_SYNTAX_ERROR;
2475         }
2476
2477         /* optional "-endstate" "statename" at the end of the arguments,
2478          * so that e.g. IRPAUSE can let us load the data register before
2479          * entering RUN/IDLE to execute the instruction we load here.
2480          */
2481         endstate = TAP_IDLE;
2482
2483         if( argc >= 4 ){
2484                 /* have at least one pair of numbers. */
2485                 /* is last pair the magic text? */
2486                 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2487                         const char *cpA;
2488                         const char *cpS;
2489                         cpA = args[ argc-1 ];
2490                         for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2491                                 cpS = tap_state_name( endstate );
2492                                 if( 0 == strcmp( cpA, cpS ) ){
2493                                         break;
2494                                 }
2495                         }
2496                         if( endstate >= TAP_NUM_STATES ){
2497                                 return ERROR_COMMAND_SYNTAX_ERROR;
2498                         } else {
2499                                 if (!scan_is_safe(endstate))
2500                                         LOG_WARNING("irscan with unsafe "
2501                                                         "endstate \"%s\"", cpA);
2502                                 /* found - remove the last 2 args */
2503                                 argc -= 2;
2504                         }
2505                 }
2506         }
2507
2508         int num_fields = argc / 2;
2509
2510         fields = malloc(sizeof(scan_field_t) * num_fields);
2511
2512         for (i = 0; i < num_fields; i++)
2513         {
2514                 tap = jtag_TapByString( args[i*2] );
2515                 if (tap==NULL)
2516                 {
2517                         command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2518                         return ERROR_FAIL;
2519                 }
2520                 int field_size = tap->ir_length;
2521                 fields[i].tap = tap;
2522                 fields[i].num_bits = field_size;
2523                 fields[i].out_value = malloc(CEIL(field_size, 8));
2524                 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2525                 fields[i].in_value = NULL;
2526         }
2527
2528         /* did we have an endstate? */
2529         jtag_add_ir_scan(num_fields, fields, endstate);
2530
2531         int retval=jtag_execute_queue();
2532
2533         for (i = 0; i < num_fields; i++)
2534                 free(fields[i].out_value);
2535
2536         free (fields);
2537
2538         return retval;
2539 }
2540
2541 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2542 {
2543         int retval;
2544         scan_field_t *fields;
2545         int num_fields;
2546         int field_count = 0;
2547         int i, e;
2548         jtag_tap_t *tap;
2549         tap_state_t endstate;
2550
2551         /* args[1] = device
2552          * args[2] = num_bits
2553          * args[3] = hex string
2554          * ... repeat num bits and hex string ...
2555          *
2556          * .. optionally:
2557         *     args[N-2] = "-endstate"
2558          *     args[N-1] = statename
2559          */
2560         if ((argc < 4) || ((argc % 2)!=0))
2561         {
2562                 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2563                 return JIM_ERR;
2564         }
2565
2566         endstate = TAP_IDLE;
2567
2568         /* validate arguments as numbers */
2569         e = JIM_OK;
2570         for (i = 2; i < argc; i+=2)
2571         {
2572                 long bits;
2573                 const char *cp;
2574
2575                 e = Jim_GetLong(interp, args[i], &bits);
2576                 /* If valid - try next arg */
2577                 if( e == JIM_OK ){
2578                         continue;
2579                 }
2580
2581                 /* Not valid.. are we at the end? */
2582                 if ( ((i+2) != argc) ){
2583                         /* nope, then error */
2584                         return e;
2585                 }
2586
2587                 /* it could be: "-endstate FOO"
2588                  * e.g. DRPAUSE so we can issue more instructions
2589                  * before entering RUN/IDLE and executing them.
2590                  */
2591
2592                 /* get arg as a string. */
2593                 cp = Jim_GetString( args[i], NULL );
2594                 /* is it the magic? */
2595                 if( 0 == strcmp( "-endstate", cp ) ){
2596                         /* is the statename valid? */
2597                         cp = Jim_GetString( args[i+1], NULL );
2598
2599                         /* see if it is a valid state name */
2600                         endstate = tap_state_by_name(cp);
2601                         if( endstate < 0 ){
2602                                 /* update the error message */
2603                                 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2604                         } else {
2605                                 if (!scan_is_safe(endstate))
2606                                         LOG_WARNING("drscan with unsafe "
2607                                                         "endstate \"%s\"", cp);
2608
2609                                 /* valid - so clear the error */
2610                                 e = JIM_OK;
2611                                 /* and remove the last 2 args */
2612                                 argc -= 2;
2613                         }
2614                 }
2615
2616                 /* Still an error? */
2617                 if( e != JIM_OK ){
2618                         return e; /* too bad */
2619                 }
2620         } /* validate args */
2621
2622         tap = jtag_TapByJimObj( interp, args[1] );
2623         if( tap == NULL ){
2624                 return JIM_ERR;
2625         }
2626
2627         num_fields=(argc-2)/2;
2628         fields = malloc(sizeof(scan_field_t) * num_fields);
2629         for (i = 2; i < argc; i+=2)
2630         {
2631                 long bits;
2632                 int len;
2633                 const char *str;
2634
2635                 Jim_GetLong(interp, args[i], &bits);
2636                 str = Jim_GetString(args[i+1], &len);
2637
2638                 fields[field_count].tap = tap;
2639                 fields[field_count].num_bits = bits;
2640                 fields[field_count].out_value = malloc(CEIL(bits, 8));
2641                 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2642                 fields[field_count].in_value = fields[field_count].out_value;
2643                 field_count++;
2644         }
2645
2646         jtag_add_dr_scan(num_fields, fields, endstate);
2647
2648         retval = jtag_execute_queue();
2649         if (retval != ERROR_OK)
2650         {
2651                 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2652                 return JIM_ERR;
2653         }
2654
2655         field_count=0;
2656         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2657         for (i = 2; i < argc; i+=2)
2658         {
2659                 long bits;
2660                 char *str;
2661
2662                 Jim_GetLong(interp, args[i], &bits);
2663                 str = buf_to_str(fields[field_count].in_value, bits, 16);
2664                 free(fields[field_count].out_value);
2665
2666                 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2667                 free(str);
2668                 field_count++;
2669         }
2670
2671         Jim_SetResult(interp, list);
2672
2673         free(fields);
2674
2675         return JIM_OK;
2676 }
2677
2678
2679 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2680 {
2681         Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count));
2682
2683         return JIM_OK;
2684 }
2685
2686
2687 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2688 {
2689         if (argc == 1)
2690         {
2691                 if (strcmp(args[0], "enable") == 0)
2692                 {
2693                         jtag_verify_capture_ir = 1;
2694                 }
2695                 else if (strcmp(args[0], "disable") == 0)
2696                 {
2697                         jtag_verify_capture_ir = 0;
2698                 } else
2699                 {
2700                         return ERROR_COMMAND_SYNTAX_ERROR;
2701                 }
2702         } else if (argc != 0)
2703         {
2704                 return ERROR_COMMAND_SYNTAX_ERROR;
2705         }
2706
2707         command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2708
2709         return ERROR_OK;
2710 }
2711
2712 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2713 {
2714         if (argc == 1)
2715         {
2716                 if (strcmp(args[0], "enable") == 0)
2717                 {
2718                         jtag_verify = 1;
2719                 }
2720                 else if (strcmp(args[0], "disable") == 0)
2721                 {
2722                         jtag_verify = 0;
2723                 } else
2724                 {
2725                         return ERROR_COMMAND_SYNTAX_ERROR;
2726                 }
2727         } else if (argc != 0)
2728         {
2729                 return ERROR_COMMAND_SYNTAX_ERROR;
2730         }
2731
2732         command_print(cmd_ctx, "verify jtag capture is %s", (jtag_verify) ? "enabled": "disabled");
2733
2734         return ERROR_OK;
2735 }
2736
2737
2738 int jtag_power_dropout(int *dropout)
2739 {
2740         return jtag->power_dropout(dropout);
2741 }
2742
2743 int jtag_srst_asserted(int *srst_asserted)
2744 {
2745         return jtag->srst_asserted(srst_asserted);
2746 }
2747
2748 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2749 {
2750         jtag_tap_event_action_t * jteap;
2751         int done;
2752
2753         jteap = tap->event_action;
2754
2755         done = 0;
2756         while (jteap) {
2757                 if (jteap->event == e) {
2758                         done = 1;
2759                         LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2760                                         tap->dotted_name,
2761                                         e,
2762                                         Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2763                                         Jim_GetString(jteap->body, NULL) );
2764                         if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2765                                 Jim_PrintErrorMessage(interp);
2766                         }
2767                 }
2768
2769                 jteap = jteap->next;
2770         }
2771
2772         if (!done) {
2773                 LOG_DEBUG( "event %d %s - no action",
2774                                 e,
2775                                 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
2776         }
2777 }
2778
2779 /*-----<Cable Helper API>---------------------------------------*/
2780
2781 /*  these Cable Helper API functions are all documented in the jtag.h header file,
2782         using a Doxygen format.  And since Doxygen's configuration file "Doxyfile",
2783         is setup to prefer its docs in the header file, no documentation is here, for
2784         if it were, it would have to be doubly maintained.
2785 */
2786
2787 /**
2788  * @see tap_set_state() and tap_get_state() accessors.
2789  * Actual name is not important since accessors hide it.
2790  */
2791 static tap_state_t state_follower = TAP_RESET;
2792
2793 void tap_set_state_impl( tap_state_t new_state )
2794 {
2795         /* this is the state we think the TAPs are in now, was cur_state */
2796         state_follower = new_state;
2797 }
2798
2799 tap_state_t tap_get_state()
2800 {
2801         return state_follower;
2802 }
2803
2804 /**
2805  * @see tap_set_end_state() and tap_get_end_state() accessors.
2806  * Actual name is not important because accessors hide it.
2807  */
2808 static tap_state_t end_state_follower = TAP_RESET;
2809
2810 void tap_set_end_state( tap_state_t new_end_state )
2811 {
2812         /* this is the state we think the TAPs will be in at completion of the
2813            current TAP operation, was end_state
2814         */
2815         end_state_follower = new_end_state;
2816 }
2817
2818 tap_state_t tap_get_end_state()
2819 {
2820         return end_state_follower;
2821 }
2822
2823
2824 int tap_move_ndx( tap_state_t astate )
2825 {
2826         /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
2827
2828         int ndx;
2829
2830         switch( astate )
2831         {
2832         case TAP_RESET:         ndx = 0;                        break;
2833         case TAP_DRSHIFT:       ndx = 2;                        break;
2834         case TAP_DRPAUSE:       ndx = 3;                        break;
2835         case TAP_IDLE:          ndx = 1;                        break;
2836         case TAP_IRSHIFT:       ndx = 4;                        break;
2837         case TAP_IRPAUSE:       ndx = 5;                        break;
2838         default:
2839                 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
2840                 exit(1);
2841         }
2842
2843         return ndx;
2844 }
2845
2846
2847 /* tap_move[i][j]: tap movement command to go from state i to state j
2848  * 0: Test-Logic-Reset
2849  * 1: Run-Test/Idle
2850  * 2: Shift-DR
2851  * 3: Pause-DR
2852  * 4: Shift-IR
2853  * 5: Pause-IR
2854  *
2855  * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
2856  */
2857 struct tms_sequences
2858 {
2859         u8      bits;
2860         u8      bit_count;
2861
2862 };
2863
2864 /*
2865  * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
2866  * Read the bits from LSBit first to MSBit last (right-to-left).
2867  */
2868 #define HEX__(n) 0x##n##LU
2869
2870 #define B8__(x) \
2871          (((x) & 0x0000000FLU)?(1<<0):0) \
2872         +(((x) & 0x000000F0LU)?(1<<1):0) \
2873         +(((x) & 0x00000F00LU)?(1<<2):0) \
2874         +(((x) & 0x0000F000LU)?(1<<3):0) \
2875         +(((x) & 0x000F0000LU)?(1<<4):0) \
2876         +(((x) & 0x00F00000LU)?(1<<5):0) \
2877         +(((x) & 0x0F000000LU)?(1<<6):0) \
2878         +(((x) & 0xF0000000LU)?(1<<7):0)
2879
2880 #define B8(bits,count)          { ((u8)B8__(HEX__(bits))), (count) }
2881
2882 static const struct tms_sequences old_tms_seqs[6][6] =          /*  [from_state_ndx][to_state_ndx] */
2883 {
2884         /* value clocked to TMS to move from one of six stable states to another.
2885          * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
2886          * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
2887          * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
2888          * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
2889          */
2890
2891
2892
2893         /* to state: */
2894         /*      RESET                   IDLE                    DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE         */              /* from state: */
2895         {       B8(1111111,7),  B8(0000000,7),  B8(0010111,7),  B8(0001010,7),  B8(0011011,7),  B8(0010110,7) },        /* RESET */
2896         {       B8(1111111,7),  B8(0000000,7),  B8(0100101,7),  B8(0000101,7),  B8(0101011,7),  B8(0001011,7) },        /* IDLE */
2897         {       B8(1111111,7),  B8(0110001,7),  B8(0000000,7),  B8(0000001,7),  B8(0001111,7),  B8(0101111,7) },        /* DRSHIFT */
2898         {       B8(1111111,7),  B8(0110000,7),  B8(0100000,7),  B8(0010111,7),  B8(0011110,7),  B8(0101111,7) },        /* DRPAUSE */
2899         {       B8(1111111,7),  B8(0110001,7),  B8(0000111,7),  B8(0010111,7),  B8(0000000,7),  B8(0000001,7) },        /* IRSHIFT */
2900         {       B8(1111111,7),  B8(0110000,7),  B8(0011100,7),  B8(0010111,7),  B8(0011110,7),  B8(0101111,7) },        /* IRPAUSE */
2901 };
2902
2903
2904
2905 static const struct tms_sequences short_tms_seqs[6][6] =                /*  [from_state_ndx][to_state_ndx] */
2906 {
2907         /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
2908
2909                 OK, I added Peter's version of the state table, and it works OK for
2910                 me on MC1322x. I've recreated the jlink portion of patch with this
2911                 new state table. His changes to my state table are pretty minor in
2912                 terms of total transitions, but Peter feels that his version fixes
2913                 some long-standing problems.
2914                 Jeff
2915
2916                 I added the bit count into the table, reduced RESET column to 7 bits from 8.
2917                 Dick
2918
2919                 state specific comments:
2920                 ------------------------
2921                 *->RESET                   tried the 5 bit reset and it gave me problems, 7 bits seems to
2922                                            work better on ARM9 with ft2232 driver.  (Dick)
2923
2924                 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
2925                                                 needed on ARM9 with ft2232 driver.  (Dick)
2926
2927                 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
2928                                                 needed on ARM9 with ft2232 driver.  (Dick)
2929         */
2930
2931         /* to state: */
2932         /*      RESET                   IDLE                            DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE */                      /* from state: */
2933         {       B8(1111111,7),  B8(0000000,7),  B8(0010111,7),          B8(0001010,7),  B8(0011011,7),  B8(0010110,7) },        /* RESET */
2934         {       B8(1111111,7),  B8(0000000,7),  B8(001,3),                      B8(0101,4),             B8(0011,4),     B8(01011,5) },          /* IDLE */
2935         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(01,2),               B8(001111,6),   B8(0101111,7) },        /* DRSHIFT */
2936         {       B8(1111111,7),  B8(011,3),              B8(01,2),               B8(0,1),                B8(001111,6),   B8(0101111,7) },        /* DRPAUSE */
2937         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(010111,6),   B8(001111,6),   B8(01,2) },                     /* IRSHIFT */
2938         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(010111,6),   B8(01,2),               B8(0,1) }                       /* IRPAUSE */
2939
2940 };
2941
2942 typedef const struct tms_sequences tms_table[6][6];
2943
2944 static tms_table *tms_seqs=&short_tms_seqs;
2945
2946 int tap_get_tms_path( tap_state_t from, tap_state_t to )
2947 {
2948         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bits;
2949 }
2950
2951
2952 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
2953 {
2954         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
2955 }
2956
2957
2958 bool tap_is_state_stable(tap_state_t astate)
2959 {
2960         bool is_stable;
2961
2962         /*      A switch() is used because it is symbol dependent
2963                 (not value dependent like an array), and can also check bounds.
2964         */
2965         switch( astate )
2966         {
2967         case TAP_RESET:
2968         case TAP_IDLE:
2969         case TAP_DRSHIFT:
2970         case TAP_DRPAUSE:
2971         case TAP_IRSHIFT:
2972         case TAP_IRPAUSE:
2973                 is_stable = true;
2974                 break;
2975         default:
2976                 is_stable = false;
2977         }
2978
2979         return is_stable;
2980 }
2981
2982 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
2983 {
2984         tap_state_t new_state;
2985
2986         /*      A switch is used because it is symbol dependent and not value dependent
2987                 like an array.  Also it can check for out of range conditions.
2988         */
2989
2990         if (tms)
2991         {
2992                 switch (cur_state)
2993                 {
2994                 case TAP_RESET:
2995                         new_state = cur_state;
2996                         break;
2997                 case TAP_IDLE:
2998                 case TAP_DRUPDATE:
2999                 case TAP_IRUPDATE:
3000                         new_state = TAP_DRSELECT;
3001                         break;
3002                 case TAP_DRSELECT:
3003                         new_state = TAP_IRSELECT;
3004                         break;
3005                 case TAP_DRCAPTURE:
3006                 case TAP_DRSHIFT:
3007                         new_state = TAP_DREXIT1;
3008                         break;
3009                 case TAP_DREXIT1:
3010                 case TAP_DREXIT2:
3011                         new_state = TAP_DRUPDATE;
3012                         break;
3013                 case TAP_DRPAUSE:
3014                         new_state = TAP_DREXIT2;
3015                         break;
3016                 case TAP_IRSELECT:
3017                         new_state = TAP_RESET;
3018                         break;
3019                 case TAP_IRCAPTURE:
3020                 case TAP_IRSHIFT:
3021                         new_state = TAP_IREXIT1;
3022                         break;
3023                 case TAP_IREXIT1:
3024                 case TAP_IREXIT2:
3025                         new_state = TAP_IRUPDATE;
3026                         break;
3027                 case TAP_IRPAUSE:
3028                         new_state = TAP_IREXIT2;
3029                         break;
3030                 default:
3031                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3032                         exit(1);
3033                         break;
3034                 }
3035         }
3036         else
3037         {
3038                 switch (cur_state)
3039                 {
3040                 case TAP_RESET:
3041                 case TAP_IDLE:
3042                 case TAP_DRUPDATE:
3043                 case TAP_IRUPDATE:
3044                         new_state = TAP_IDLE;
3045                         break;
3046                 case TAP_DRSELECT:
3047                         new_state = TAP_DRCAPTURE;
3048                         break;
3049                 case TAP_DRCAPTURE:
3050                 case TAP_DRSHIFT:
3051                 case TAP_DREXIT2:
3052                         new_state = TAP_DRSHIFT;
3053                         break;
3054                 case TAP_DREXIT1:
3055                 case TAP_DRPAUSE:
3056                         new_state = TAP_DRPAUSE;
3057                         break;
3058                 case TAP_IRSELECT:
3059                         new_state = TAP_IRCAPTURE;
3060                         break;
3061                 case TAP_IRCAPTURE:
3062                 case TAP_IRSHIFT:
3063                 case TAP_IREXIT2:
3064                         new_state = TAP_IRSHIFT;
3065                         break;
3066                 case TAP_IREXIT1:
3067                 case TAP_IRPAUSE:
3068                         new_state = TAP_IRPAUSE;
3069                         break;
3070                 default:
3071                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3072                         exit(1);
3073                         break;
3074                 }
3075         }
3076
3077         return new_state;
3078 }
3079
3080 const char* tap_state_name(tap_state_t state)
3081 {
3082         const char* ret;
3083
3084         switch( state )
3085         {
3086         case TAP_RESET:         ret = "RESET";                  break;
3087         case TAP_IDLE:          ret = "RUN/IDLE";               break;
3088         case TAP_DRSELECT:      ret = "DRSELECT";               break;
3089         case TAP_DRCAPTURE: ret = "DRCAPTURE";          break;
3090         case TAP_DRSHIFT:       ret = "DRSHIFT";                        break;
3091         case TAP_DREXIT1:       ret = "DREXIT1";                        break;
3092         case TAP_DRPAUSE:       ret = "DRPAUSE";                        break;
3093         case TAP_DREXIT2:       ret = "DREXIT2";                        break;
3094         case TAP_DRUPDATE:      ret = "DRUPDATE";               break;
3095         case TAP_IRSELECT:      ret = "IRSELECT";               break;
3096         case TAP_IRCAPTURE: ret = "IRCAPTURE";          break;
3097         case TAP_IRSHIFT:       ret = "IRSHIFT";                        break;
3098         case TAP_IREXIT1:       ret = "IREXIT1";                        break;
3099         case TAP_IRPAUSE:       ret = "IRPAUSE";                        break;
3100         case TAP_IREXIT2:       ret = "IREXIT2";                        break;
3101         case TAP_IRUPDATE:      ret = "IRUPDATE";               break;
3102         default:                                ret = "???";
3103         }
3104
3105         return ret;
3106 }
3107
3108 static tap_state_t tap_state_by_name( const char *name )
3109 {
3110         tap_state_t x;
3111
3112         for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3113                 /* be nice to the human */
3114                 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3115                         return x;
3116                 }
3117         }
3118         /* not found */
3119         return TAP_INVALID;
3120 }
3121
3122 #ifdef _DEBUG_JTAG_IO_
3123
3124 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3125                 do { buf[len] = bit ? '1' : '0'; } while(0)
3126 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3127                 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3128                         tap_state_name(a), tap_state_name(b), astr, bstr)
3129
3130 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3131                 unsigned tap_bits, tap_state_t next_state)
3132 {
3133         const u8 *tms_buffer;
3134         const u8 *tdi_buffer;
3135         unsigned tap_bytes;
3136         unsigned cur_byte;
3137         unsigned cur_bit;
3138
3139         unsigned tap_out_bits;
3140         char tms_str[33];
3141         char tdi_str[33];
3142
3143         tap_state_t last_state;
3144
3145         // set startstate (and possibly last, if tap_bits == 0)
3146         last_state = next_state;
3147         DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3148
3149         tms_buffer = (const u8 *)tms_buf;
3150         tdi_buffer = (const u8 *)tdi_buf;
3151
3152         tap_bytes = TAP_SCAN_BYTES(tap_bits);
3153         DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3154
3155         tap_out_bits = 0;
3156         for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3157         {
3158                 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3159                 {
3160                         // make sure we do not run off the end of the buffers
3161                         unsigned tap_bit = cur_byte * 8 + cur_bit;
3162                         if (tap_bit == tap_bits)
3163                                 break;
3164
3165                         // check and save TMS bit
3166                         tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3167                         JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3168
3169                         // use TMS bit to find the next TAP state
3170                         next_state = tap_state_transition(last_state, tap_bit);
3171
3172                         // check and store TDI bit
3173                         tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3174                         JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3175
3176                         // increment TAP bits
3177                         tap_out_bits++;
3178
3179                         // Only show TDO bits on state transitions, or
3180                         // after some number of bits in the same state.
3181                         if ((next_state == last_state) && (tap_out_bits < 32))
3182                                 continue;
3183
3184                         // terminate strings and display state transition
3185                         tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3186                         JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3187
3188                         // reset state
3189                         last_state = next_state;
3190                         tap_out_bits = 0;
3191                 }
3192         }
3193
3194         if (tap_out_bits)
3195         {
3196                 // terminate strings and display state transition
3197                 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3198                 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3199         }
3200
3201         DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3202
3203         return next_state;
3204 }
3205 #endif // _DEBUG_JTAG_IO_
3206
3207 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3208 {
3209         if (argc == 1)
3210         {
3211                 if (strcmp(args[0], "short") == 0)
3212                 {
3213                         tms_seqs=&short_tms_seqs;
3214                 }
3215                 else if (strcmp(args[0], "long") == 0)
3216                 {
3217                         tms_seqs=&old_tms_seqs;
3218                 } else
3219                 {
3220                         return ERROR_COMMAND_SYNTAX_ERROR;
3221                 }
3222         } else if (argc != 0)
3223         {
3224                 return ERROR_COMMAND_SYNTAX_ERROR;
3225         }
3226
3227         command_print(cmd_ctx, "tms sequence is  %s", (tms_seqs==&short_tms_seqs) ? "short": "long");
3228
3229         return ERROR_OK;
3230 }
3231
3232 /*-----</Cable Helper API>--------------------------------------*/
3233
3234
3235 /**
3236  * Function jtag_add_statemove
3237  * moves from the current state to the goal \a state. This needs
3238  * to be handled according to the xsvf spec, see the XSTATE command
3239  * description.
3240  */
3241 int jtag_add_statemove(tap_state_t goal_state)
3242 {
3243         int retval = ERROR_OK;
3244
3245         tap_state_t moves[8];
3246         tap_state_t cur_state = cmd_queue_cur_state;
3247         int i;
3248         int tms_bits;
3249         int     tms_count;
3250
3251         LOG_DEBUG( "cur_state=%s goal_state=%s",
3252                 tap_state_name(cur_state),
3253                 tap_state_name(goal_state) );
3254
3255
3256         /*      From the XSVF spec, pertaining to XSTATE:
3257
3258                 For special states known as stable states (Test-Logic-Reset,
3259                 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
3260                 predefined TAP state paths when the starting state is a stable state and
3261                 when the XSTATE specifies a new stable state (see the STATE command in
3262                 the [Ref 5] for the TAP state paths between stable states). For
3263                 non-stable states, XSTATE should specify a state that is only one TAP
3264                 state transition distance from the current TAP state to avoid undefined
3265                 TAP state paths. A sequence of multiple XSTATE commands can be issued to
3266                 transition the TAP through a specific state path.
3267         */
3268
3269         if (goal_state==cur_state )
3270                 ;       /* nothing to do */
3271
3272         else if( goal_state==TAP_RESET )
3273         {
3274                 jtag_add_tlr();
3275         }
3276
3277         else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
3278         {
3279                 /*      note: unless tms_bits holds a path that agrees with [Ref 5] in above
3280                         spec, then this code is not fully conformant to the xsvf spec.  This
3281                         puts a burden on tap_get_tms_path() function from the xsvf spec.
3282                         If in doubt, you should confirm that that burden is being met.
3283                 */
3284
3285                 tms_bits  = tap_get_tms_path(cur_state, goal_state);
3286                 tms_count = tap_get_tms_path_len(cur_state, goal_state);
3287
3288                 assert( (unsigned) tms_count < DIM(moves) );
3289
3290                 for (i=0;   i<tms_count;   i++, tms_bits>>=1)
3291                 {
3292                         bool bit = tms_bits & 1;
3293
3294                         cur_state = tap_state_transition(cur_state, bit);
3295                         moves[i] = cur_state;
3296                 }
3297
3298                 jtag_add_pathmove(tms_count, moves);
3299         }
3300
3301         /*      else state must be immediately reachable in one clock cycle, and does not
3302                 need to be a stable state.
3303         */
3304         else if( tap_state_transition(cur_state, true)  == goal_state
3305                 ||   tap_state_transition(cur_state, false) == goal_state )
3306         {
3307                 /* move a single state */
3308                 moves[0] = goal_state;
3309                 jtag_add_pathmove( 1, moves );
3310         }
3311
3312         else
3313         {
3314                 retval = ERROR_FAIL;
3315         }
3316
3317         return retval;
3318 }
3319