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