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