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