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