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