git.sur5r.net Git - openocd/blob - src/jtag/jtag.c

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