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