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