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