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