git.gag.com Git - fw/openocd/blob - src/jtag/jtag.c

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