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

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