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