git.sur5r.net Git - openocd/blob - src/jtag/jtag.c

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2009 SoftPLC Corporation                                *
   9  *       http://softplc.com                                                    *
  10  *   dick@softplc.com                                                      *
  11  *                                                                         *
  12  *   This program is free software; you can redistribute it and/or modify  *
  13  *   it under the terms of the GNU General Public License as published by  *
  14  *   the Free Software Foundation; either version 2 of the License, or     *
  15  *   (at your option) any later version.                                   *
  16  *                                                                         *
  17  *   This program is distributed in the hope that it will be useful,       *
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  20  *   GNU General Public License for more details.                          *
  21  *                                                                         *
  22  *   You should have received a copy of the GNU General Public License     *
  23  *   along with this program; if not, write to the                         *
  24  *   Free Software Foundation, Inc.,                                       *
  25  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  26  ***************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include "jtag.h"
  32
  33 #ifdef HAVE_STRINGS_H
  34 #include <strings.h>
  35 #endif
  36
  37
  38 int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
  39
  40 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
  41                 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
  42
  43 /* note that this is not marked as static as it must be available from outside jtag.c for those
  44    that implement the jtag_xxx() minidriver layer
  45 */
  46 int jtag_error=ERROR_OK;
  47
  48 typedef struct cmd_queue_page_s
  49 {
  50         void *address;
  51         size_t used;
  52         struct cmd_queue_page_s *next;
  53 } cmd_queue_page_t;
  54
  55 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
  56 static cmd_queue_page_t *cmd_queue_pages = NULL;
  57
  58 char* jtag_event_strings[] =
  59 {
  60         "JTAG controller reset (RESET or TRST)"
  61 };
  62
  63 const Jim_Nvp nvp_jtag_tap_event[] = {
  64         { .value = JTAG_TAP_EVENT_ENABLE,       .name = "tap-enable" },
  65         { .value = JTAG_TAP_EVENT_DISABLE,      .name = "tap-disable" },
  66
  67         { .name = NULL, .value = -1 }
  68 };
  69
  70 int jtag_trst = 0;
  71 int jtag_srst = 0;
  72
  73 #ifndef HAVE_JTAG_MINIDRIVER_H
  74 struct jtag_callback_entry
  75 {
  76         struct jtag_callback_entry *next;
  77
  78         jtag_callback_t callback;
  79         u8 *in;
  80         jtag_callback_data_t data1;
  81         jtag_callback_data_t data2;
  82         jtag_callback_data_t data3;
  83 };
  84
  85
  86 static struct jtag_callback_entry *jtag_callback_queue_head = NULL;
  87 static struct jtag_callback_entry *jtag_callback_queue_tail = NULL;
  88 #endif
  89
  90
  91 jtag_command_t *jtag_command_queue = NULL;
  92 jtag_command_t **last_command_pointer = &jtag_command_queue;
  93 static jtag_tap_t *jtag_all_taps = NULL;
  94
  95 enum reset_types jtag_reset_config = RESET_NONE;
  96 tap_state_t cmd_queue_end_state = TAP_RESET;
  97 tap_state_t cmd_queue_cur_state = TAP_RESET;
  98
  99 int jtag_verify_capture_ir = 1;
 100 int jtag_verify = 1;
 101
 102 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
 103 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
 104 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
 105
 106 /* maximum number of JTAG devices expected in the chain
 107  */
 108 #define JTAG_MAX_CHAIN_SIZE 20
 109
 110 /* callbacks to inform high-level handlers about JTAG state changes */
 111 jtag_event_callback_t *jtag_event_callbacks;
 112
 113 /* speed in kHz*/
 114 static int speed_khz = 0;
 115 /* flag if the kHz speed was defined */
 116 static int hasKHz = 0;
 117
 118 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
 119  */
 120
 121 #if BUILD_ECOSBOARD == 1
 122         extern jtag_interface_t zy1000_interface;
 123 #endif
 124
 125 #if BUILD_PARPORT == 1
 126         extern jtag_interface_t parport_interface;
 127 #endif
 128
 129 #if BUILD_DUMMY == 1
 130         extern jtag_interface_t dummy_interface;
 131 #endif
 132
 133 #if BUILD_FT2232_FTD2XX == 1
 134         extern jtag_interface_t ft2232_interface;
 135 #endif
 136
 137 #if BUILD_FT2232_LIBFTDI == 1
 138         extern jtag_interface_t ft2232_interface;
 139 #endif
 140
 141 #if BUILD_AMTJTAGACCEL == 1
 142         extern jtag_interface_t amt_jtagaccel_interface;
 143 #endif
 144
 145 #if BUILD_EP93XX == 1
 146         extern jtag_interface_t ep93xx_interface;
 147 #endif
 148
 149 #if BUILD_AT91RM9200 == 1
 150         extern jtag_interface_t at91rm9200_interface;
 151 #endif
 152
 153 #if BUILD_GW16012 == 1
 154         extern jtag_interface_t gw16012_interface;
 155 #endif
 156
 157 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 158         extern jtag_interface_t presto_interface;
 159 #endif
 160
 161 #if BUILD_USBPROG == 1
 162         extern jtag_interface_t usbprog_interface;
 163 #endif
 164
 165 #if BUILD_JLINK == 1
 166         extern jtag_interface_t jlink_interface;
 167 #endif
 168
 169 #if BUILD_VSLLINK == 1
 170         extern jtag_interface_t vsllink_interface;
 171 #endif
 172
 173 #if BUILD_RLINK == 1
 174         extern jtag_interface_t rlink_interface;
 175 #endif
 176
 177 #if BUILD_ARMJTAGEW == 1
 178         extern jtag_interface_t armjtagew_interface;
 179 #endif
 180
 181 jtag_interface_t *jtag_interfaces[] = {
 182 #if BUILD_ECOSBOARD == 1
 183         &zy1000_interface,
 184 #endif
 185 #if BUILD_PARPORT == 1
 186         &parport_interface,
 187 #endif
 188 #if BUILD_DUMMY == 1
 189         &dummy_interface,
 190 #endif
 191 #if BUILD_FT2232_FTD2XX == 1
 192         &ft2232_interface,
 193 #endif
 194 #if BUILD_FT2232_LIBFTDI == 1
 195         &ft2232_interface,
 196 #endif
 197 #if BUILD_AMTJTAGACCEL == 1
 198         &amt_jtagaccel_interface,
 199 #endif
 200 #if BUILD_EP93XX == 1
 201         &ep93xx_interface,
 202 #endif
 203 #if BUILD_AT91RM9200 == 1
 204         &at91rm9200_interface,
 205 #endif
 206 #if BUILD_GW16012 == 1
 207         &gw16012_interface,
 208 #endif
 209 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 210         &presto_interface,
 211 #endif
 212 #if BUILD_USBPROG == 1
 213         &usbprog_interface,
 214 #endif
 215 #if BUILD_JLINK == 1
 216         &jlink_interface,
 217 #endif
 218 #if BUILD_VSLLINK == 1
 219         &vsllink_interface,
 220 #endif
 221 #if BUILD_RLINK == 1
 222         &rlink_interface,
 223 #endif
 224 #if BUILD_ARMJTAGEW == 1
 225         &armjtagew_interface,
 226 #endif
 227         NULL,
 228 };
 229
 230 jtag_interface_t *jtag = NULL;
 231
 232 /* configuration */
 233 static jtag_interface_t *jtag_interface = NULL;
 234 int jtag_speed = 0;
 235
 236 /* forward declarations */
 237 //void jtag_add_pathmove(int num_states, tap_state_t *path);
 238 //void jtag_add_runtest(int num_cycles, tap_state_t endstate);
 239 //void jtag_add_end_state(tap_state_t endstate);
 240 //void jtag_add_sleep(u32 us);
 241 //int jtag_execute_queue(void);
 242 static tap_state_t tap_state_by_name(const char *name);
 243
 244 /* jtag commands */
 245 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 246 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 247 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 248 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 249 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 250 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 251 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 252
 253 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 254
 255 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 256 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 257 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 258 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 259 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 260 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
 261
 262 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 263 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 264 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 265
 266 jtag_tap_t *jtag_AllTaps(void)
 267 {
 268         return jtag_all_taps;
 269 };
 270
 271 int jtag_NumTotalTaps(void)
 272 {
 273         jtag_tap_t *t;
 274         int n;
 275
 276         n = 0;
 277         t = jtag_AllTaps();
 278         while(t){
 279                 n++;
 280                 t = t->next_tap;
 281         }
 282         return n;
 283 }
 284
 285 int jtag_NumEnabledTaps(void)
 286 {
 287         jtag_tap_t *t;
 288         int n;
 289
 290         n = 0;
 291         t = jtag_AllTaps();
 292         while(t){
 293                 if( t->enabled ){
 294                         n++;
 295                 }
 296                 t = t->next_tap;
 297         }
 298         return n;
 299 }
 300
 301 jtag_tap_t *jtag_TapByString( const char *s )
 302 {
 303         jtag_tap_t *t;
 304         char *cp;
 305
 306         t = jtag_AllTaps();
 307         /* try name first */
 308         while(t){
 309                 if( 0 == strcmp( t->dotted_name, s ) ){
 310                         break;
 311                 } else {
 312                         t = t->next_tap;
 313                 }
 314         }
 315         /* backup plan is by number */
 316         if( t == NULL ){
 317                 /* ok - is "s" a number? */
 318                 int n;
 319                 n = strtol( s, &cp, 0 );
 320                 if( (s != cp) && (*cp == 0) ){
 321                         /* Then it is... */
 322                         t = jtag_TapByAbsPosition(n);
 323                 }
 324         }
 325         return t;
 326 }
 327
 328 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
 329 {
 330         jtag_tap_t *t;
 331         const char *cp;
 332
 333         cp = Jim_GetString( o, NULL );
 334         if(cp == NULL){
 335                 cp = "(unknown)";
 336                 t = NULL;
 337         }  else {
 338                 t = jtag_TapByString( cp );
 339         }
 340         if( t == NULL ){
 341                 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
 342         }
 343         return t;
 344 }
 345
 346 /* returns a pointer to the n-th device in the scan chain */
 347 jtag_tap_t * jtag_TapByAbsPosition( int n )
 348 {
 349         int orig_n;
 350         jtag_tap_t *t;
 351
 352         orig_n = n;
 353         t = jtag_AllTaps();
 354
 355         while( t && (n > 0)) {
 356                 n--;
 357                 t = t->next_tap;
 358         }
 359         return t;
 360 }
 361
 362 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
 363 {
 364         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 365
 366         if (callback == NULL)
 367         {
 368                 return ERROR_INVALID_ARGUMENTS;
 369         }
 370
 371         if (*callbacks_p)
 372         {
 373                 while ((*callbacks_p)->next)
 374                         callbacks_p = &((*callbacks_p)->next);
 375                 callbacks_p = &((*callbacks_p)->next);
 376         }
 377
 378         (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
 379         (*callbacks_p)->callback = callback;
 380         (*callbacks_p)->priv = priv;
 381         (*callbacks_p)->next = NULL;
 382
 383         return ERROR_OK;
 384 }
 385
 386 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
 387 {
 388         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 389
 390         if (callback == NULL)
 391         {
 392                 return ERROR_INVALID_ARGUMENTS;
 393         }
 394
 395         while (*callbacks_p)
 396         {
 397                 jtag_event_callback_t **next = &((*callbacks_p)->next);
 398                 if ((*callbacks_p)->callback == callback)
 399                 {
 400                         free(*callbacks_p);
 401                         *callbacks_p = *next;
 402                 }
 403                 callbacks_p = next;
 404         }
 405
 406         return ERROR_OK;
 407 }
 408
 409 int jtag_call_event_callbacks(enum jtag_event event)
 410 {
 411         jtag_event_callback_t *callback = jtag_event_callbacks;
 412
 413         LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
 414
 415         while (callback)
 416         {
 417                 callback->callback(event, callback->priv);
 418                 callback = callback->next;
 419         }
 420
 421         return ERROR_OK;
 422 }
 423
 424 /* returns a pointer to the pointer of the last command in queue
 425  * this may be a pointer to the root pointer (jtag_command_queue)
 426  * or to the next member of the last but one command
 427  */
 428 jtag_command_t** jtag_get_last_command_p(void)
 429 {
 430 /*      jtag_command_t *cmd = jtag_command_queue;
 431
 432         if (cmd)
 433                 while (cmd->next)
 434                         cmd = cmd->next;
 435         else
 436                 return &jtag_command_queue;
 437
 438         return &cmd->next;*/
 439
 440         return last_command_pointer;
 441 }
 442
 443
 444 void jtag_queue_command(jtag_command_t * cmd)
 445 {
 446         jtag_command_t **last_cmd;
 447
 448         last_cmd = jtag_get_last_command_p();
 449
 450         *last_cmd = cmd;
 451
 452         (*last_cmd)->next = NULL;
 453
 454         last_command_pointer = &((*last_cmd)->next);
 455 }
 456
 457
 458 void* cmd_queue_alloc(size_t size)
 459 {
 460         cmd_queue_page_t **p_page = &cmd_queue_pages;
 461         int offset;
 462         u8 *t;
 463
 464         /*
 465          * WARNING:
 466          *    We align/round the *SIZE* per below
 467          *    so that all pointers returned by
 468          *    this function are reasonably well
 469          *    aligned.
 470          *
 471          * If we did not, then an "odd-length" request would cause the
 472          * *next* allocation to be at an *odd* address, and because
 473          * this function has the same type of api as malloc() - we
 474          * must also return pointers that have the same type of
 475          * alignment.
 476          *
 477          * What I do not/have is a reasonable portable means
 478          * to align by...
 479          *
 480          * The solution here, is based on these suggestions.
 481          * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
 482          *
 483          */
 484         union worse_case_align {
 485                 int i;
 486                 long l;
 487                 float f;
 488                 void *v;
 489         };
 490 #define ALIGN_SIZE  (sizeof(union worse_case_align))
 491
 492         /* The alignment process. */
 493         size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
 494         /* Done... */
 495
 496         if (*p_page)
 497         {
 498                 while ((*p_page)->next)
 499                         p_page = &((*p_page)->next);
 500                 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
 501                         p_page = &((*p_page)->next);
 502         }
 503
 504         if (!*p_page)
 505         {
 506                 *p_page = malloc(sizeof(cmd_queue_page_t));
 507                 (*p_page)->used = 0;
 508                 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
 509                 (*p_page)->next = NULL;
 510         }
 511
 512         offset = (*p_page)->used;
 513         (*p_page)->used += size;
 514
 515         t=(u8 *)((*p_page)->address);
 516         return t + offset;
 517 }
 518
 519 void cmd_queue_free(void)
 520 {
 521         cmd_queue_page_t *page = cmd_queue_pages;
 522
 523         while (page)
 524         {
 525                 cmd_queue_page_t *last = page;
 526                 free(page->address);
 527                 page = page->next;
 528                 free(last);
 529         }
 530
 531         cmd_queue_pages = NULL;
 532 }
 533
 534 static void jtag_prelude1(void)
 535 {
 536         if (jtag_trst == 1)
 537         {
 538                 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
 539                 jtag_error=ERROR_JTAG_TRST_ASSERTED;
 540                 return;
 541         }
 542
 543         if (cmd_queue_end_state == TAP_RESET)
 544                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 545 }
 546
 547 static void jtag_prelude(tap_state_t state)
 548 {
 549         jtag_prelude1();
 550
 551         if (state != TAP_INVALID)
 552                 jtag_add_end_state(state);
 553
 554         cmd_queue_cur_state = cmd_queue_end_state;
 555 }
 556
 557 void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 558 {
 559         int retval;
 560         jtag_prelude(state);
 561
 562         retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 563         if (retval!=ERROR_OK)
 564                 jtag_error=retval;
 565
 566 }
 567
 568
 569 /**
 570  * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
 571  *
 572  * If the input field list contains an instruction value for a TAP then that is used
 573  * otherwise the TAP is set to bypass.
 574  *
 575  * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
 576  *
 577  */
 578 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 579 {
 580         if (jtag_verify&&jtag_verify_capture_ir)
 581         {
 582                 /* 8 x 32 bit id's is enough for all invoations */
 583
 584                 for (int j = 0; j < in_num_fields; j++)
 585                 {
 586                         in_fields[j].check_value=NULL;
 587                         in_fields[j].check_mask=NULL;
 588                         /* if we are to run a verification of the ir scan, we need to get the input back.
 589                          * We may have to allocate space if the caller didn't ask for the input back.
 590                          */
 591                         in_fields[j].check_value=in_fields[j].tap->expected;
 592                         in_fields[j].check_mask=in_fields[j].tap->expected_mask;
 593                 }
 594                 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
 595         } else
 596         {
 597                 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
 598         }
 599 }
 600
 601 /**
 602  * see jtag_add_ir_scan()
 603  *
 604  */
 605 int MINIDRIVER(interface_jtag_add_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 606 {
 607         int nth_tap;
 608
 609         int num_taps = jtag_NumEnabledTaps();
 610
 611         jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
 612         scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
 613         scan_field_t * out_fields       = cmd_queue_alloc(num_taps  * sizeof(scan_field_t));
 614
 615         jtag_queue_command(cmd);
 616
 617         cmd->type                               = JTAG_SCAN;
 618         cmd->cmd.scan                   = scan;
 619
 620         scan->ir_scan                   = true;
 621         scan->num_fields                = num_taps;     /* one field per device */
 622         scan->fields                    = out_fields;
 623         scan->end_state                 = state;
 624
 625         nth_tap = -1;
 626
 627         for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
 628         {
 629                 int found = 0;
 630
 631                 nth_tap++;
 632
 633                 assert(nth_tap < num_taps);
 634
 635                 size_t scan_size                                = tap->ir_length;
 636                 scan->fields[nth_tap].tap               = tap;
 637                 scan->fields[nth_tap].num_bits  = scan_size;
 638                 scan->fields[nth_tap].in_value  = NULL; /* do not collect input for tap's in bypass */
 639
 640                 /* search the list */
 641                 for (int j = 0; j < in_num_fields; j++)
 642                 {
 643                         if (tap == in_fields[j].tap)
 644                         {
 645                                 found = 1;
 646                                 scan->fields[nth_tap].in_value  = in_fields[j].in_value;
 647                                 scan->fields[nth_tap].out_value = buf_cpy(in_fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 648
 649                                 tap->bypass = 0;
 650                                 break;
 651                         }
 652                 }
 653
 654                 if (!found)
 655                 {
 656                         /* if a tap isn't listed, set it to BYPASS */
 657                         scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 658                         tap->bypass = 1;
 659                 }
 660
 661                 /* update device information */
 662                 buf_cpy(scan->fields[nth_tap].out_value, tap->cur_instr, scan_size);
 663         }
 664
 665         assert(nth_tap == (num_taps - 1));
 666
 667         return ERROR_OK;
 668 }
 669
 670 /**
 671  * Duplicate the scan fields passed into the function into an IR SCAN command
 672  *
 673  * This function assumes that the caller handles extra fields for bypassed TAPs
 674  *
 675  */
 676 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 677 {
 678         int retval;
 679
 680         jtag_prelude(state);
 681
 682         retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 683         if (retval!=ERROR_OK)
 684                 jtag_error=retval;
 685 }
 686
 687
 688 /**
 689  * see jtag_add_plain_ir_scan()
 690  *
 691  */
 692 int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 693 {
 694
 695         jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
 696         scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
 697         scan_field_t * out_fields       = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t));
 698
 699         jtag_queue_command(cmd);
 700
 701         cmd->type                               = JTAG_SCAN;
 702         cmd->cmd.scan                   = scan;
 703
 704         scan->ir_scan                   = true;
 705         scan->num_fields                = in_num_fields;
 706         scan->fields                    = out_fields;
 707         scan->end_state                 = state;
 708
 709         for (int i = 0; i < in_num_fields; i++)
 710         {
 711                 int num_bits = in_fields[i].num_bits;
 712                 int num_bytes = CEIL(in_fields[i].num_bits, 8);
 713                 scan->fields[i].tap = in_fields[i].tap;
 714                 scan->fields[i].num_bits = num_bits;
 715                 scan->fields[i].out_value = buf_cpy(in_fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
 716                 scan->fields[i].in_value = in_fields[i].in_value;
 717         }
 718
 719         return ERROR_OK;
 720 }
 721
 722
 723
 724 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
 725
 726 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
 727 {
 728         return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
 729 }
 730
 731 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
 732                 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 733 {
 734         for (int i = 0; i < in_num_fields; i++)
 735         {
 736                 in_fields[i].allocated = 0;
 737                 in_fields[i].modified = 0;
 738                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value == NULL))
 739                 {
 740                         in_fields[i].modified = 1;
 741                         /* we need storage space... */
 742 #ifdef HAVE_JTAG_MINIDRIVER_H
 743                         if (in_fields[i].num_bits <= 32)
 744                         {
 745                                 /* This is enough space and we're executing this synchronously */
 746                                 in_fields[i].in_value = in_fields[i].intmp;
 747                         } else
 748                         {
 749                                 in_fields[i].in_value = (u8 *)malloc(CEIL(in_fields[i].num_bits, 8));
 750                                 in_fields[i].allocated = 1;
 751                         }
 752 #else
 753                         in_fields[i].in_value = (u8 *)cmd_queue_alloc(CEIL(in_fields[i].num_bits, 8));
 754 #endif
 755                 }
 756         }
 757
 758         jtag_add_scan(in_num_fields, in_fields, state);
 759
 760         for (int i = 0; i < in_num_fields; i++)
 761         {
 762                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
 763                 {
 764                         /* this is synchronous for a minidriver */
 765                         jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
 766                                 (jtag_callback_data_t)in_fields[i].check_value,
 767                                 (jtag_callback_data_t)in_fields[i].check_mask,
 768                                 (jtag_callback_data_t)in_fields[i].num_bits);
 769                 }
 770                 if (in_fields[i].allocated)
 771                 {
 772                         free(in_fields[i].in_value);
 773                 }
 774                 if (in_fields[i].modified)
 775                 {
 776                         in_fields[i].in_value = NULL;
 777                 }
 778         }
 779 }
 780
 781 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 782 {
 783         if (jtag_verify)
 784         {
 785                 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
 786         } else
 787         {
 788                 jtag_add_dr_scan(in_num_fields, in_fields, state);
 789         }
 790 }
 791
 792
 793 /**
 794  * Generate a DR SCAN using the fields passed to the function
 795  *
 796  * For not bypassed TAPs the function checks in_fields and uses fields specified there.
 797  * For bypassed TAPs the function generates a dummy 1bit field.
 798  *
 799  * The bypass status of TAPs is set by jtag_add_ir_scan().
 800  *
 801  */
 802 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 803 {
 804         int retval;
 805
 806         jtag_prelude(state);
 807
 808         retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
 809         if (retval!=ERROR_OK)
 810                 jtag_error=retval;
 811 }
 812
 813
 814 /**
 815  * see jtag_add_dr_scan()
 816  *
 817  */
 818 int MINIDRIVER(interface_jtag_add_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 819 {
 820         int j;
 821         int field_count = 0;
 822
 823         /* count devices in bypass */
 824
 825         size_t bypass_devices = 0;
 826
 827         for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
 828         {
 829                 if (tap->bypass)
 830                         bypass_devices++;
 831         }
 832
 833         jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
 834         scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
 835         scan_field_t * out_fields       = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t));
 836
 837         jtag_queue_command(cmd);
 838
 839         cmd->type                               = JTAG_SCAN;
 840         cmd->cmd.scan                   = scan;
 841
 842         scan->ir_scan                   = false;
 843         scan->num_fields                = in_num_fields + bypass_devices;
 844         scan->fields                    = out_fields;
 845         scan->end_state                 = state;
 846
 847         for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
 848         {
 849                 int found = 0;
 850                 scan->fields[field_count].tap = tap;
 851
 852                 for (j = 0; j < in_num_fields; j++)
 853                 {
 854                         if (tap == in_fields[j].tap)
 855                         {
 856                                 found = 1;
 857                                 size_t scan_size = in_fields[j].num_bits;
 858                                 scan->fields[field_count].num_bits      = scan_size;
 859                                 scan->fields[field_count].out_value     = buf_cpy(in_fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 860                                 scan->fields[field_count].in_value      = in_fields[j].in_value;
 861                                 field_count++;
 862                         }
 863                 }
 864                 if (!found)
 865                 {
 866 #ifdef _DEBUG_JTAG_IO_
 867                         /* if a device isn't listed, the BYPASS register should be selected */
 868                         if (! tap->bypass)
 869                         {
 870                                 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
 871                                 exit(-1);
 872                         }
 873 #endif
 874                         /* program the scan field to 1 bit length, and ignore it's value */
 875                         scan->fields[field_count].num_bits              = 1;
 876                         scan->fields[field_count].out_value             = NULL;
 877                         scan->fields[field_count].in_value              = NULL;
 878                         field_count++;
 879                 }
 880                 else
 881                 {
 882 #ifdef _DEBUG_JTAG_IO_
 883                         /* if a device is listed, the BYPASS register must not be selected */
 884                         if (tap->bypass)
 885                         {
 886                                 LOG_ERROR("BUG: scan data for a device in BYPASS");
 887                                 exit(-1);
 888                         }
 889 #endif
 890                 }
 891         }
 892
 893         /* field_count represents the true number of fields setup*/
 894         scan->num_fields = field_count;
 895         return ERROR_OK;
 896 }
 897
 898
 899
 900 /**
 901  * Generate a DR SCAN using the array of output values passed to the function
 902  *
 903  * This function assumes that the parameter target_tap specifies the one TAP
 904  * that is not bypassed. All other TAPs must be bypassed and the function will
 905  * generate a dummy 1bit field for them.
 906  *
 907  * For the target_tap a sequence of output-only fields will be generated where
 908  * each field has the size num_bits and the field's values are taken from
 909  * the array value.
 910  *
 911  * The bypass status of TAPs is set by jtag_add_ir_scan().
 912  *
 913  */
 914 void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap,
 915                 int in_num_fields,
 916                 const int *num_bits,
 917                 const u32 *value,
 918                 tap_state_t end_state)
 919 {
 920         int field_count = 0;
 921
 922         /* count devices in bypass */
 923
 924         size_t bypass_devices = 0;
 925
 926         for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
 927         {
 928                 if (tap->bypass)
 929                         bypass_devices++;
 930         }
 931
 932
 933         jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
 934         scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
 935         scan_field_t * out_fields       = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t));
 936
 937         jtag_queue_command(cmd);
 938
 939         cmd->type                               = JTAG_SCAN;
 940         cmd->cmd.scan                   = scan;
 941
 942         scan->ir_scan                   = false;
 943         scan->num_fields                = in_num_fields + bypass_devices;
 944         scan->fields                    = out_fields;
 945         scan->end_state                 = end_state;
 946
 947         for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap))
 948         {
 949                 scan->fields[field_count].tap = tap;
 950
 951                 if (tap == target_tap)
 952                 {
 953 #ifdef _DEBUG_JTAG_IO_
 954                         /* if a device is listed, the BYPASS register must not be selected */
 955                         if (tap->bypass)
 956                         {
 957                                 LOG_ERROR("BUG: scan data for a device in BYPASS");
 958                                 exit(-1);
 959                         }
 960 #endif
 961                         for (int j = 0; j < in_num_fields; j++)
 962                         {
 963                                 u8 out_value[4];
 964                                 size_t scan_size = num_bits[j];
 965                                 buf_set_u32(out_value, 0, scan_size, value[j]);
 966                                 scan->fields[field_count].num_bits              = scan_size;
 967                                 scan->fields[field_count].out_value             = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size);
 968                                 scan->fields[field_count].in_value              = NULL;
 969                                 field_count++;
 970                         }
 971                 } else
 972                 {
 973 #ifdef _DEBUG_JTAG_IO_
 974                         /* if a device isn't listed, the BYPASS register should be selected */
 975                         if (! tap->bypass)
 976                         {
 977                                 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
 978                                 exit(-1);
 979                         }
 980 #endif
 981                         /* program the scan field to 1 bit length, and ignore it's value */
 982                         scan->fields[field_count].num_bits                      = 1;
 983                         scan->fields[field_count].out_value                     = NULL;
 984                         scan->fields[field_count].in_value                      = NULL;
 985                         field_count++;
 986                 }
 987         }
 988 }
 989
 990
 991 /**
 992  * Duplicate the scan fields passed into the function into a DR SCAN command
 993  *
 994  * This function assumes that the caller handles extra fields for bypassed TAPs
 995  *
 996  */
 997 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 998 {
 999         int retval;
1000
1001         jtag_prelude(state);
1002
1003         retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
1004         if (retval!=ERROR_OK)
1005                 jtag_error=retval;
1006 }
1007
1008
1009 /**
1010  * see jtag_add_plain_dr_scan()
1011  *
1012  */
1013 int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
1014 {
1015         jtag_command_t * cmd            = cmd_queue_alloc(sizeof(jtag_command_t));
1016         scan_command_t * scan           = cmd_queue_alloc(sizeof(scan_command_t));
1017         scan_field_t * out_fields       = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t));
1018
1019         jtag_queue_command(cmd);
1020
1021         cmd->type                               = JTAG_SCAN;
1022         cmd->cmd.scan                   = scan;
1023
1024         scan->ir_scan                   = false;
1025         scan->num_fields                = in_num_fields;
1026         scan->fields                    = out_fields;
1027         scan->end_state                 = state;
1028
1029         for (int i = 0; i < in_num_fields; i++)
1030         {
1031                 int num_bits = in_fields[i].num_bits;
1032                 int num_bytes = CEIL(in_fields[i].num_bits, 8);
1033                 scan->fields[i].tap = in_fields[i].tap;
1034                 scan->fields[i].num_bits = num_bits;
1035                 scan->fields[i].out_value = buf_cpy(in_fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits);
1036                 scan->fields[i].in_value = in_fields[i].in_value;
1037         }
1038
1039         return ERROR_OK;
1040 }
1041
1042
1043 void jtag_add_tlr(void)
1044 {
1045         jtag_prelude(TAP_RESET);
1046
1047         int retval;
1048         retval=interface_jtag_add_tlr();
1049         if (retval!=ERROR_OK)
1050                 jtag_error=retval;
1051 }
1052
1053 int MINIDRIVER(interface_jtag_add_tlr)(void)
1054 {
1055         tap_state_t state = TAP_RESET;
1056
1057         /* allocate memory for a new list member */
1058         jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1059
1060         jtag_queue_command(cmd);
1061
1062         cmd->type = JTAG_STATEMOVE;
1063
1064         cmd->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t));
1065         cmd->cmd.statemove->end_state = state;
1066
1067         return ERROR_OK;
1068 }
1069
1070 void jtag_add_pathmove(int num_states, const tap_state_t *path)
1071 {
1072         tap_state_t cur_state = cmd_queue_cur_state;
1073         int i;
1074         int retval;
1075
1076         /* the last state has to be a stable state */
1077         if (!tap_is_state_stable(path[num_states - 1]))
1078         {
1079                 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
1080                 exit(-1);
1081         }
1082
1083         for (i=0; i<num_states; i++)
1084         {
1085                 if (path[i] == TAP_RESET)
1086                 {
1087                         LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
1088                         exit(-1);
1089                 }
1090
1091                 if ( tap_state_transition(cur_state, true)  != path[i]
1092                   && tap_state_transition(cur_state, false) != path[i])
1093                 {
1094                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
1095                         exit(-1);
1096                 }
1097                 cur_state = path[i];
1098         }
1099
1100         jtag_prelude1();
1101
1102         retval = interface_jtag_add_pathmove(num_states, path);
1103         cmd_queue_cur_state = path[num_states - 1];
1104         if (retval!=ERROR_OK)
1105                 jtag_error=retval;
1106 }
1107
1108 int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, const tap_state_t *path)
1109 {
1110         /* allocate memory for a new list member */
1111         jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1112
1113         jtag_queue_command(cmd);
1114
1115         cmd->type = JTAG_PATHMOVE;
1116
1117         cmd->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t));
1118         cmd->cmd.pathmove->num_states = num_states;
1119         cmd->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states);
1120
1121         for (int i = 0; i < num_states; i++)
1122                 cmd->cmd.pathmove->path[i] = path[i];
1123
1124         return ERROR_OK;
1125 }
1126
1127 int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state)
1128 {
1129         /* allocate memory for a new list member */
1130         jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1131
1132         jtag_queue_command(cmd);
1133
1134         cmd->type = JTAG_RUNTEST;
1135
1136         cmd->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t));
1137         cmd->cmd.runtest->num_cycles = num_cycles;
1138         cmd->cmd.runtest->end_state = state;
1139
1140         return ERROR_OK;
1141 }
1142
1143 void jtag_add_runtest(int num_cycles, tap_state_t state)
1144 {
1145         int retval;
1146
1147         jtag_prelude(state);
1148
1149         /* executed by sw or hw fifo */
1150         retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
1151         if (retval!=ERROR_OK)
1152                 jtag_error=retval;
1153 }
1154
1155
1156 int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles )
1157 {
1158         /* allocate memory for a new list member */
1159         jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t));
1160
1161         jtag_queue_command(cmd);
1162
1163         cmd->type = JTAG_STABLECLOCKS;
1164
1165         cmd->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t));
1166         cmd->cmd.stableclocks->num_cycles = num_cycles;
1167
1168         return ERROR_OK;
1169 }
1170
1171 void jtag_add_clocks( int num_cycles )
1172 {
1173         int retval;
1174
1175         if( !tap_is_state_stable(cmd_queue_cur_state) )
1176         {
1177                  LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
1178                                  tap_state_name(cmd_queue_cur_state) );
1179                  jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
1180                  return;
1181         }
1182
1183         if( num_cycles > 0 )
1184         {
1185                 jtag_prelude1();
1186
1187                 retval = interface_jtag_add_clocks(num_cycles);
1188                 if (retval != ERROR_OK)
1189                         jtag_error=retval;
1190         }
1191 }
1192
1193 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
1194 {
1195         int trst_with_tlr = 0;
1196         int retval;
1197
1198         /* FIX!!! there are *many* different cases here. A better
1199          * approach is needed for legal combinations of transitions...
1200          */
1201         if ((jtag_reset_config & RESET_HAS_SRST)&&
1202                         (jtag_reset_config & RESET_HAS_TRST)&&
1203                         ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
1204         {
1205                 if (((req_tlr_or_trst&&!jtag_trst)||
1206                                 (!req_tlr_or_trst&&jtag_trst))&&
1207                                 ((req_srst&&!jtag_srst)||
1208                                                 (!req_srst&&jtag_srst)))
1209                 {
1210                         /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
1211                         //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
1212                 }
1213         }
1214
1215         /* Make sure that jtag_reset_config allows the requested reset */
1216         /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
1217         if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
1218         {
1219                 LOG_ERROR("BUG: requested reset would assert trst");
1220                 jtag_error=ERROR_FAIL;
1221                 return;
1222         }
1223
1224         /* if TRST pulls SRST, we reset with TAP T-L-R */
1225         if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
1226         {
1227                 trst_with_tlr = 1;
1228         }
1229
1230         if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
1231         {
1232                 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
1233                 jtag_error=ERROR_FAIL;
1234                 return;
1235         }
1236
1237         if (req_tlr_or_trst)
1238         {
1239                 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
1240                 {
1241                         jtag_trst = 1;
1242                 } else
1243                 {
1244                         trst_with_tlr = 1;
1245                 }
1246         } else
1247         {
1248                 jtag_trst = 0;
1249         }
1250
1251         jtag_srst = req_srst;
1252
1253         retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
1254         if (retval!=ERROR_OK)
1255         {
1256                 jtag_error=retval;
1257                 return;
1258         }
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                 cmd_queue_cur_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, "set jtag speed (if supported)");
2321         register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
2322                 COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK.");
2323         register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
2324                 COMMAND_CONFIG, "jtag_device <ir_length> <ir_expected> <ir_mask>");
2325         register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
2326                 COMMAND_ANY,
2327                 "[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]");
2328         register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
2329                 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
2330         register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
2331                 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
2332
2333         register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
2334                 COMMAND_EXEC, "print current scan chain configuration");
2335
2336         register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
2337                 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
2338         register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
2339                 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
2340         register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
2341                 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
2342         register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
2343                 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
2344         register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
2345         register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
2346
2347         register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
2348                 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
2349         register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
2350                 COMMAND_ANY, "verify value capture <enable|disable>");
2351         register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
2352                 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
2353         return ERROR_OK;
2354 }
2355
2356 int jtag_interface_init(struct command_context_s *cmd_ctx)
2357 {
2358         if (jtag)
2359                 return ERROR_OK;
2360
2361         if (!jtag_interface)
2362         {
2363                 /* nothing was previously specified by "interface" command */
2364                 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
2365                 return ERROR_JTAG_INVALID_INTERFACE;
2366         }
2367         if(hasKHz)
2368         {
2369                 jtag_interface->khz(speed_khz, &jtag_speed);
2370                 hasKHz = 0;
2371         }
2372
2373         if (jtag_interface->init() != ERROR_OK)
2374                 return ERROR_JTAG_INIT_FAILED;
2375
2376         jtag = jtag_interface;
2377         return ERROR_OK;
2378 }
2379
2380 static int jtag_init_inner(struct command_context_s *cmd_ctx)
2381 {
2382         jtag_tap_t *tap;
2383         int retval;
2384
2385         LOG_DEBUG("Init JTAG chain");
2386
2387         tap = jtag_NextEnabledTap(NULL);
2388         if( tap == NULL ){
2389                 LOG_ERROR("There are no enabled taps?");
2390                 return ERROR_JTAG_INIT_FAILED;
2391         }
2392
2393         jtag_add_tlr();
2394         if ((retval=jtag_execute_queue())!=ERROR_OK)
2395                 return retval;
2396
2397         /* examine chain first, as this could discover the real chain layout */
2398         if (jtag_examine_chain() != ERROR_OK)
2399         {
2400                 LOG_ERROR("trying to validate configured JTAG chain anyway...");
2401         }
2402
2403         if (jtag_validate_chain() != ERROR_OK)
2404         {
2405                 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
2406         }
2407
2408         return ERROR_OK;
2409 }
2410
2411 int jtag_init_reset(struct command_context_s *cmd_ctx)
2412 {
2413         int retval;
2414
2415         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2416                 return retval;
2417
2418         LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
2419
2420         /* Reset can happen after a power cycle.
2421          *
2422          * Ideally we would only assert TRST or run RESET before the target reset.
2423          *
2424          * However w/srst_pulls_trst, trst is asserted together with the target
2425          * reset whether we want it or not.
2426          *
2427          * NB! Some targets have JTAG circuitry disabled until a
2428          * trst & srst has been asserted.
2429          *
2430          * NB! here we assume nsrst/ntrst delay are sufficient!
2431          *
2432          * NB! order matters!!!! srst *can* disconnect JTAG circuitry
2433          *
2434          */
2435         jtag_add_reset(1, 0); /* RESET or TRST */
2436         if (jtag_reset_config & RESET_HAS_SRST)
2437         {
2438                 jtag_add_reset(1, 1);
2439                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
2440                         jtag_add_reset(0, 1);
2441         }
2442         jtag_add_reset(0, 0);
2443         if ((retval = jtag_execute_queue()) != ERROR_OK)
2444                 return retval;
2445
2446         /* Check that we can communication on the JTAG chain + eventually we want to
2447          * be able to perform enumeration only after OpenOCD has started
2448          * telnet and GDB server
2449          *
2450          * That would allow users to more easily perform any magic they need to before
2451          * reset happens.
2452          */
2453         return jtag_init_inner(cmd_ctx);
2454 }
2455
2456 int jtag_init(struct command_context_s *cmd_ctx)
2457 {
2458         int retval;
2459         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
2460                 return retval;
2461         if (jtag_init_inner(cmd_ctx)==ERROR_OK)
2462         {
2463                 return ERROR_OK;
2464         }
2465         return jtag_init_reset(cmd_ctx);
2466 }
2467
2468 static int default_khz(int khz, int *jtag_speed)
2469 {
2470         LOG_ERROR("Translation from khz to jtag_speed not implemented");
2471         return ERROR_FAIL;
2472 }
2473
2474 static int default_speed_div(int speed, int *khz)
2475 {
2476         LOG_ERROR("Translation from jtag_speed to khz not implemented");
2477         return ERROR_FAIL;
2478 }
2479
2480 static int default_power_dropout(int *dropout)
2481 {
2482         *dropout=0; /* by default we can't detect power dropout */
2483         return ERROR_OK;
2484 }
2485
2486 static int default_srst_asserted(int *srst_asserted)
2487 {
2488         *srst_asserted=0; /* by default we can't detect srst asserted */
2489         return ERROR_OK;
2490 }
2491
2492 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2493 {
2494         int i;
2495         int retval;
2496
2497         /* check whether the interface is already configured */
2498         if (jtag_interface)
2499         {
2500                 LOG_WARNING("Interface already configured, ignoring");
2501                 return ERROR_OK;
2502         }
2503
2504         /* interface name is a mandatory argument */
2505         if (argc < 1 || args[0][0] == '\0')
2506         {
2507                 return ERROR_COMMAND_SYNTAX_ERROR;
2508         }
2509
2510         for (i=0; jtag_interfaces[i]; i++)
2511         {
2512                 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2513                 {
2514                         if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2515                         {
2516                                 return retval;
2517                         }
2518
2519                         jtag_interface = jtag_interfaces[i];
2520
2521                         if (jtag_interface->khz == NULL)
2522                         {
2523                                 jtag_interface->khz = default_khz;
2524                         }
2525                         if (jtag_interface->speed_div == NULL)
2526                         {
2527                                 jtag_interface->speed_div = default_speed_div;
2528                         }
2529                         if (jtag_interface->power_dropout == NULL)
2530                         {
2531                                 jtag_interface->power_dropout = default_power_dropout;
2532                         }
2533                         if (jtag_interface->srst_asserted == NULL)
2534                         {
2535                                 jtag_interface->srst_asserted = default_srst_asserted;
2536                         }
2537
2538                         return ERROR_OK;
2539                 }
2540         }
2541
2542         /* no valid interface was found (i.e. the configuration option,
2543          * didn't match one of the compiled-in interfaces
2544          */
2545         LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2546         LOG_ERROR("compiled-in jtag interfaces:");
2547         for (i = 0; jtag_interfaces[i]; i++)
2548         {
2549                 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2550         }
2551
2552         return ERROR_JTAG_INVALID_INTERFACE;
2553 }
2554
2555 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2556 {
2557         int e;
2558         char buf[1024];
2559         Jim_Obj *newargs[ 10 ];
2560         /*
2561          * CONVERT SYNTAX
2562          * argv[-1] = command
2563          * argv[ 0] = ir length
2564          * argv[ 1] = ir capture
2565          * argv[ 2] = ir mask
2566          * argv[ 3] = not actually used by anything but in the docs
2567          */
2568
2569         if( argc < 4 ){
2570                 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2571                 return ERROR_OK;
2572         }
2573         command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2574         command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2575                                    args[0],
2576                                    args[1],
2577                                    args[2] );
2578         command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2579         command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2580         command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2581         command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2582
2583         newargs[0] = Jim_NewStringObj( interp, "jtag", -1   );
2584         newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2585         sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2586         newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2587         sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2588         newargs[3] = Jim_NewStringObj( interp, buf, -1  );
2589         newargs[4] = Jim_NewStringObj( interp, "-irlen", -1  );
2590         newargs[5] = Jim_NewStringObj( interp, args[0], -1  );
2591         newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1  );
2592         newargs[7] = Jim_NewStringObj( interp, args[1], -1  );
2593         newargs[8] = Jim_NewStringObj( interp, "-irmask", -1  );
2594         newargs[9] = Jim_NewStringObj( interp, args[2], -1  );
2595
2596         command_print( cmd_ctx, "NEW COMMAND:");
2597         sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2598                          Jim_GetString( newargs[0], NULL ),
2599                          Jim_GetString( newargs[1], NULL ),
2600                          Jim_GetString( newargs[2], NULL ),
2601                          Jim_GetString( newargs[3], NULL ),
2602                          Jim_GetString( newargs[4], NULL ),
2603                          Jim_GetString( newargs[5], NULL ),
2604                          Jim_GetString( newargs[6], NULL ),
2605                          Jim_GetString( newargs[7], NULL ),
2606                          Jim_GetString( newargs[8], NULL ),
2607                          Jim_GetString( newargs[9], NULL ) );
2608
2609         e = jim_jtag_command( interp, 10, newargs );
2610         if( e != JIM_OK ){
2611                 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2612         }
2613         return e;
2614 }
2615
2616 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2617 {
2618         jtag_tap_t *tap;
2619
2620         tap = jtag_all_taps;
2621         command_print(cmd_ctx, "     TapName            | Enabled |   IdCode      Expected    IrLen IrCap  IrMask Instr     ");
2622         command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2623
2624         while( tap ){
2625                 u32 expected, expected_mask, cur_instr, ii;
2626                 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2627                 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2628                 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2629
2630                 command_print(cmd_ctx,
2631                                           "%2d | %-18s |    %c    | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2632                                           tap->abs_chain_position,
2633                                           tap->dotted_name,
2634                                           tap->enabled ? 'Y' : 'n',
2635                                           tap->idcode,
2636                                           (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2637                                           tap->ir_length,
2638                                           expected,
2639                                           expected_mask,
2640                                           cur_instr);
2641
2642                 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2643                         command_print(cmd_ctx, "   |                    |         |            | 0x%08x |      |      |      |         ",
2644                                                   tap->expected_ids[ii]);
2645                 }
2646
2647                 tap = tap->next_tap;
2648         }
2649
2650         return ERROR_OK;
2651 }
2652
2653 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2654 {
2655         if (argc < 1)
2656                 return ERROR_COMMAND_SYNTAX_ERROR;
2657
2658         if (argc >= 1)
2659         {
2660                 if (strcmp(args[0], "none") == 0)
2661                         jtag_reset_config = RESET_NONE;
2662                 else if (strcmp(args[0], "trst_only") == 0)
2663                         jtag_reset_config = RESET_HAS_TRST;
2664                 else if (strcmp(args[0], "srst_only") == 0)
2665                         jtag_reset_config = RESET_HAS_SRST;
2666                 else if (strcmp(args[0], "trst_and_srst") == 0)
2667                         jtag_reset_config = RESET_TRST_AND_SRST;
2668                 else
2669                 {
2670                         LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]);
2671                         jtag_reset_config = RESET_NONE;
2672                         return ERROR_INVALID_ARGUMENTS;
2673                 }
2674         }
2675
2676         if (argc >= 2)
2677         {
2678                 if (strcmp(args[1], "separate") == 0)
2679                 {
2680                         /* seperate reset lines - default */
2681                 } else
2682                 {
2683                         if (strcmp(args[1], "srst_pulls_trst") == 0)
2684                                 jtag_reset_config |= RESET_SRST_PULLS_TRST;
2685                         else if (strcmp(args[1], "trst_pulls_srst") == 0)
2686                                 jtag_reset_config |= RESET_TRST_PULLS_SRST;
2687                         else if (strcmp(args[1], "combined") == 0)
2688                                 jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2689                         else
2690                         {
2691                                 LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]);
2692                                 jtag_reset_config = RESET_NONE;
2693                                 return ERROR_INVALID_ARGUMENTS;
2694                         }
2695                 }
2696         }
2697
2698         if (argc >= 3)
2699         {
2700                 if (strcmp(args[2], "trst_open_drain") == 0)
2701                         jtag_reset_config |= RESET_TRST_OPEN_DRAIN;
2702                 else if (strcmp(args[2], "trst_push_pull") == 0)
2703                         jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN;
2704                 else
2705                 {
2706                         LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] );
2707                         jtag_reset_config = RESET_NONE;
2708                         return ERROR_INVALID_ARGUMENTS;
2709                 }
2710         }
2711
2712         if (argc >= 4)
2713         {
2714                 if (strcmp(args[3], "srst_push_pull") == 0)
2715                         jtag_reset_config |= RESET_SRST_PUSH_PULL;
2716                 else if (strcmp(args[3], "srst_open_drain") == 0)
2717                         jtag_reset_config &= ~RESET_SRST_PUSH_PULL;
2718                 else
2719                 {
2720                         LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]);
2721                         jtag_reset_config = RESET_NONE;
2722                         return ERROR_INVALID_ARGUMENTS;
2723                 }
2724         }
2725
2726         return ERROR_OK;
2727 }
2728
2729 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2730 {
2731         if (argc < 1)
2732         {
2733                 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2734                 exit(-1);
2735         }
2736         else
2737         {
2738                 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2739         }
2740
2741         return ERROR_OK;
2742 }
2743
2744 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2745 {
2746         if (argc < 1)
2747         {
2748                 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2749                 exit(-1);
2750         }
2751         else
2752         {
2753                 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2754         }
2755
2756         return ERROR_OK;
2757 }
2758
2759 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2760 {
2761         int retval=ERROR_OK;
2762
2763         if (argc == 1)
2764         {
2765                 LOG_DEBUG("handle jtag speed");
2766
2767                 int cur_speed = 0;
2768                 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2769
2770                 /* this command can be called during CONFIG,
2771                  * in which case jtag isn't initialized */
2772                 if (jtag)
2773                 {
2774                         retval=jtag->speed(cur_speed);
2775                 }
2776         } else if (argc == 0)
2777         {
2778         } else
2779         {
2780                 return ERROR_COMMAND_SYNTAX_ERROR;
2781         }
2782         command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2783
2784         return retval;
2785 }
2786
2787 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2788 {
2789         int retval=ERROR_OK;
2790         LOG_DEBUG("handle jtag khz");
2791
2792         if(argc == 1)
2793         {
2794                 speed_khz = strtoul(args[0], NULL, 0);
2795                 if (jtag != NULL)
2796                 {
2797                         int cur_speed = 0;
2798                         LOG_DEBUG("have interface set up");
2799                         int speed_div1;
2800                         if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2801                         {
2802                                 speed_khz = 0;
2803                                 return retval;
2804                         }
2805
2806                         cur_speed = jtag_speed = speed_div1;
2807
2808                         retval=jtag->speed(cur_speed);
2809                 } else
2810                 {
2811                         hasKHz = 1;
2812                 }
2813         } else if (argc==0)
2814         {
2815         } else
2816         {
2817                 return ERROR_COMMAND_SYNTAX_ERROR;
2818         }
2819
2820         if (jtag!=NULL)
2821         {
2822                 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2823                         return retval;
2824         }
2825
2826         if (speed_khz==0)
2827         {
2828                 command_print(cmd_ctx, "RCLK - adaptive");
2829         } else
2830         {
2831                 command_print(cmd_ctx, "%d kHz", speed_khz);
2832         }
2833         return retval;
2834
2835 }
2836
2837 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2838 {
2839         tap_state_t state;
2840
2841         if (argc < 1)
2842         {
2843                 return ERROR_COMMAND_SYNTAX_ERROR;
2844         }
2845         else
2846         {
2847                 state = tap_state_by_name( args[0] );
2848                 if( state < 0 ){
2849                         command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2850                         return ERROR_COMMAND_SYNTAX_ERROR;
2851                 }
2852                 jtag_add_end_state(state);
2853                 jtag_execute_queue();
2854         }
2855         command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2856
2857         return ERROR_OK;
2858 }
2859
2860 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2861 {
2862         int trst = -1;
2863         int srst = -1;
2864
2865         if (argc < 2)
2866         {
2867                 return ERROR_COMMAND_SYNTAX_ERROR;
2868         }
2869
2870         if (args[0][0] == '1')
2871                 trst = 1;
2872         else if (args[0][0] == '0')
2873                 trst = 0;
2874         else
2875         {
2876                 return ERROR_COMMAND_SYNTAX_ERROR;
2877         }
2878
2879         if (args[1][0] == '1')
2880                 srst = 1;
2881         else if (args[1][0] == '0')
2882                 srst = 0;
2883         else
2884         {
2885                 return ERROR_COMMAND_SYNTAX_ERROR;
2886         }
2887
2888         if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2889                 return ERROR_JTAG_INIT_FAILED;
2890
2891         jtag_add_reset(trst, srst);
2892         jtag_execute_queue();
2893
2894         return ERROR_OK;
2895 }
2896
2897 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2898 {
2899         if (argc < 1)
2900         {
2901                 return ERROR_COMMAND_SYNTAX_ERROR;
2902         }
2903
2904         jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2905         jtag_execute_queue();
2906
2907         return ERROR_OK;
2908
2909 }
2910
2911 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2912 {
2913         int i;
2914         scan_field_t *fields;
2915         jtag_tap_t *tap;
2916         tap_state_t endstate;
2917
2918         if ((argc < 2) || (argc % 2))
2919         {
2920                 return ERROR_COMMAND_SYNTAX_ERROR;
2921         }
2922
2923         /* optional "-endstate" */
2924         /*          "statename" */
2925         /* at the end of the arguments. */
2926         /* assume none. */
2927         endstate = cmd_queue_end_state;
2928         if( argc >= 4 ){
2929                 /* have at least one pair of numbers. */
2930                 /* is last pair the magic text? */
2931                 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2932                         const char *cpA;
2933                         const char *cpS;
2934                         cpA = args[ argc-1 ];
2935                         for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2936                                 cpS = tap_state_name( endstate );
2937                                 if( 0 == strcmp( cpA, cpS ) ){
2938                                         break;
2939                                 }
2940                         }
2941                         if( endstate >= TAP_NUM_STATES ){
2942                                 return ERROR_COMMAND_SYNTAX_ERROR;
2943                         } else {
2944                                 /* found - remove the last 2 args */
2945                                 argc -= 2;
2946                         }
2947                 }
2948         }
2949
2950         int num_fields = argc / 2;
2951
2952         fields = malloc(sizeof(scan_field_t) * num_fields);
2953
2954         for (i = 0; i < num_fields; i++)
2955         {
2956                 tap = jtag_TapByString( args[i*2] );
2957                 if (tap==NULL)
2958                 {
2959                         command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2960                         return ERROR_FAIL;
2961                 }
2962                 int field_size = tap->ir_length;
2963                 fields[i].tap = tap;
2964                 fields[i].num_bits = field_size;
2965                 fields[i].out_value = malloc(CEIL(field_size, 8));
2966                 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2967                 fields[i].in_value = NULL;
2968         }
2969
2970         /* did we have an endstate? */
2971         jtag_add_ir_scan(num_fields, fields, endstate);
2972
2973         int retval=jtag_execute_queue();
2974
2975         for (i = 0; i < num_fields; i++)
2976                 free(fields[i].out_value);
2977
2978         free (fields);
2979
2980         return retval;
2981 }
2982
2983 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2984 {
2985         int retval;
2986         scan_field_t *fields;
2987         int num_fields;
2988         int field_count = 0;
2989         int i, e;
2990         jtag_tap_t *tap;
2991         tap_state_t endstate;
2992
2993         /* args[1] = device
2994          * args[2] = num_bits
2995          * args[3] = hex string
2996          * ... repeat num bits and hex string ...
2997          *
2998          * .. optionally:
2999         *     args[N-2] = "-endstate"
3000          *     args[N-1] = statename
3001          */
3002         if ((argc < 4) || ((argc % 2)!=0))
3003         {
3004                 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
3005                 return JIM_ERR;
3006         }
3007
3008         /* assume no endstate */
3009         endstate = cmd_queue_end_state;
3010         /* validate arguments as numbers */
3011         e = JIM_OK;
3012         for (i = 2; i < argc; i+=2)
3013         {
3014                 long bits;
3015                 const char *cp;
3016
3017                 e = Jim_GetLong(interp, args[i], &bits);
3018                 /* If valid - try next arg */
3019                 if( e == JIM_OK ){
3020                         continue;
3021                 }
3022
3023                 /* Not valid.. are we at the end? */
3024                 if ( ((i+2) != argc) ){
3025                         /* nope, then error */
3026                         return e;
3027                 }
3028
3029                 /* it could be: "-endstate FOO" */
3030
3031                 /* get arg as a string. */
3032                 cp = Jim_GetString( args[i], NULL );
3033                 /* is it the magic? */
3034                 if( 0 == strcmp( "-endstate", cp ) ){
3035                         /* is the statename valid? */
3036                         cp = Jim_GetString( args[i+1], NULL );
3037
3038                         /* see if it is a valid state name */
3039                         endstate = tap_state_by_name(cp);
3040                         if( endstate < 0 ){
3041                                 /* update the error message */
3042                                 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
3043                         } else {
3044                                 /* valid - so clear the error */
3045                                 e = JIM_OK;
3046                                 /* and remove the last 2 args */
3047                                 argc -= 2;
3048                         }
3049                 }
3050
3051                 /* Still an error? */
3052                 if( e != JIM_OK ){
3053                         return e; /* too bad */
3054                 }
3055         } /* validate args */
3056
3057         tap = jtag_TapByJimObj( interp, args[1] );
3058         if( tap == NULL ){
3059                 return JIM_ERR;
3060         }
3061
3062         num_fields=(argc-2)/2;
3063         fields = malloc(sizeof(scan_field_t) * num_fields);
3064         for (i = 2; i < argc; i+=2)
3065         {
3066                 long bits;
3067                 int len;
3068                 const char *str;
3069
3070                 Jim_GetLong(interp, args[i], &bits);
3071                 str = Jim_GetString(args[i+1], &len);
3072
3073                 fields[field_count].tap = tap;
3074                 fields[field_count].num_bits = bits;
3075                 fields[field_count].out_value = malloc(CEIL(bits, 8));
3076                 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
3077                 fields[field_count].in_value = fields[field_count].out_value;
3078                 field_count++;
3079         }
3080
3081         jtag_add_dr_scan(num_fields, fields, endstate);
3082
3083         retval = jtag_execute_queue();
3084         if (retval != ERROR_OK)
3085         {
3086                 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
3087                 return JIM_ERR;
3088         }
3089
3090         field_count=0;
3091         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
3092         for (i = 2; i < argc; i+=2)
3093         {
3094                 long bits;
3095                 char *str;
3096
3097                 Jim_GetLong(interp, args[i], &bits);
3098                 str = buf_to_str(fields[field_count].in_value, bits, 16);
3099                 free(fields[field_count].out_value);
3100
3101                 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
3102                 free(str);
3103                 field_count++;
3104         }
3105
3106         Jim_SetResult(interp, list);
3107
3108         free(fields);
3109
3110         return JIM_OK;
3111 }
3112
3113
3114 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
3115 {
3116         Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count));
3117
3118         return JIM_OK;
3119 }
3120
3121
3122 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3123 {
3124         if (argc == 1)
3125         {
3126                 if (strcmp(args[0], "enable") == 0)
3127                 {
3128                         jtag_verify_capture_ir = 1;
3129                 }
3130                 else if (strcmp(args[0], "disable") == 0)
3131                 {
3132                         jtag_verify_capture_ir = 0;
3133                 } else
3134                 {
3135                         return ERROR_COMMAND_SYNTAX_ERROR;
3136                 }
3137         } else if (argc != 0)
3138         {
3139                 return ERROR_COMMAND_SYNTAX_ERROR;
3140         }
3141
3142         command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
3143
3144         return ERROR_OK;
3145 }
3146
3147 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3148 {
3149         if (argc == 1)
3150         {
3151                 if (strcmp(args[0], "enable") == 0)
3152                 {
3153                         jtag_verify = 1;
3154                 }
3155                 else if (strcmp(args[0], "disable") == 0)
3156                 {
3157                         jtag_verify = 0;
3158                 } else
3159                 {
3160                         return ERROR_COMMAND_SYNTAX_ERROR;
3161                 }
3162         } else if (argc != 0)
3163         {
3164                 return ERROR_COMMAND_SYNTAX_ERROR;
3165         }
3166
3167         command_print(cmd_ctx, "verify jtag capture is %s", (jtag_verify) ? "enabled": "disabled");
3168
3169         return ERROR_OK;
3170 }
3171
3172
3173 int jtag_power_dropout(int *dropout)
3174 {
3175         return jtag->power_dropout(dropout);
3176 }
3177
3178 int jtag_srst_asserted(int *srst_asserted)
3179 {
3180         return jtag->srst_asserted(srst_asserted);
3181 }
3182
3183 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
3184 {
3185         jtag_tap_event_action_t * jteap;
3186         int done;
3187
3188         jteap = tap->event_action;
3189
3190         done = 0;
3191         while (jteap) {
3192                 if (jteap->event == e) {
3193                         done = 1;
3194                         LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
3195                                         tap->dotted_name,
3196                                         e,
3197                                         Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
3198                                         Jim_GetString(jteap->body, NULL) );
3199                         if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
3200                                 Jim_PrintErrorMessage(interp);
3201                         }
3202                 }
3203
3204                 jteap = jteap->next;
3205         }
3206
3207         if (!done) {
3208                 LOG_DEBUG( "event %d %s - no action",
3209                                 e,
3210                                 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
3211         }
3212 }
3213
3214 /*-----<Cable Helper API>---------------------------------------*/
3215
3216 /*  these Cable Helper API functions are all documented in the jtag.h header file,
3217         using a Doxygen format.  And since Doxygen's configuration file "Doxyfile",
3218         is setup to prefer its docs in the header file, no documentation is here, for
3219         if it were, it would have to be doubly maintained.
3220 */
3221
3222 /**
3223  * @see tap_set_state() and tap_get_state() accessors.
3224  * Actual name is not important since accessors hide it.
3225  */
3226 static tap_state_t state_follower = TAP_RESET;
3227
3228 void tap_set_state_impl( tap_state_t new_state )
3229 {
3230         /* this is the state we think the TAPs are in now, was cur_state */
3231         state_follower = new_state;
3232 }
3233
3234 tap_state_t tap_get_state()
3235 {
3236         return state_follower;
3237 }
3238
3239 /**
3240  * @see tap_set_end_state() and tap_get_end_state() accessors.
3241  * Actual name is not important because accessors hide it.
3242  */
3243 static tap_state_t end_state_follower = TAP_RESET;
3244
3245 void tap_set_end_state( tap_state_t new_end_state )
3246 {
3247         /* this is the state we think the TAPs will be in at completion of the
3248            current TAP operation, was end_state
3249         */
3250         end_state_follower = new_end_state;
3251 }
3252
3253 tap_state_t tap_get_end_state()
3254 {
3255         return end_state_follower;
3256 }
3257
3258
3259 int tap_move_ndx( tap_state_t astate )
3260 {
3261         /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */
3262
3263         int ndx;
3264
3265         switch( astate )
3266         {
3267         case TAP_RESET:         ndx = 0;                        break;
3268         case TAP_DRSHIFT:       ndx = 2;                        break;
3269         case TAP_DRPAUSE:       ndx = 3;                        break;
3270         case TAP_IDLE:          ndx = 1;                        break;
3271         case TAP_IRSHIFT:       ndx = 4;                        break;
3272         case TAP_IRPAUSE:       ndx = 5;                        break;
3273         default:
3274                 LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) );
3275                 exit(1);
3276         }
3277
3278         return ndx;
3279 }
3280
3281
3282 /* tap_move[i][j]: tap movement command to go from state i to state j
3283  * 0: Test-Logic-Reset
3284  * 1: Run-Test/Idle
3285  * 2: Shift-DR
3286  * 3: Pause-DR
3287  * 4: Shift-IR
3288  * 5: Pause-IR
3289  *
3290  * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
3291  */
3292 struct tms_sequences
3293 {
3294         u8      bits;
3295         u8      bit_count;
3296
3297 };
3298
3299 /*
3300  * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
3301  * Read the bits from LSBit first to MSBit last (right-to-left).
3302  */
3303 #define HEX__(n) 0x##n##LU
3304
3305 #define B8__(x) \
3306          (((x) & 0x0000000FLU)?(1<<0):0) \
3307         +(((x) & 0x000000F0LU)?(1<<1):0) \
3308         +(((x) & 0x00000F00LU)?(1<<2):0) \
3309         +(((x) & 0x0000F000LU)?(1<<3):0) \
3310         +(((x) & 0x000F0000LU)?(1<<4):0) \
3311         +(((x) & 0x00F00000LU)?(1<<5):0) \
3312         +(((x) & 0x0F000000LU)?(1<<6):0) \
3313         +(((x) & 0xF0000000LU)?(1<<7):0)
3314
3315 #define B8(bits,count)          { ((u8)B8__(HEX__(bits))), (count) }
3316
3317 static const struct tms_sequences old_tms_seqs[6][6] =          /*  [from_state_ndx][to_state_ndx] */
3318 {
3319         /* value clocked to TMS to move from one of six stable states to another.
3320          * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
3321          * N.B. These values are tightly bound to the table in tap_get_tms_path_len().
3322          * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
3323          *              These extra ones cause no TAP state problem, because we go into reset and stay in reset.
3324          */
3325
3326
3327
3328         /* to state: */
3329         /*      RESET                   IDLE                    DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE         */              /* from state: */
3330         {       B8(1111111,7),  B8(0000000,7),  B8(0010111,7),  B8(0001010,7),  B8(0011011,7),  B8(0010110,7) },        /* RESET */
3331         {       B8(1111111,7),  B8(0000000,7),  B8(0100101,7),  B8(0000101,7),  B8(0101011,7),  B8(0001011,7) },        /* IDLE */
3332         {       B8(1111111,7),  B8(0110001,7),  B8(0000000,7),  B8(0000001,7),  B8(0001111,7),  B8(0101111,7) },        /* DRSHIFT */
3333         {       B8(1111111,7),  B8(0110000,7),  B8(0100000,7),  B8(0010111,7),  B8(0011110,7),  B8(0101111,7) },        /* DRPAUSE */
3334         {       B8(1111111,7),  B8(0110001,7),  B8(0000111,7),  B8(0010111,7),  B8(0000000,7),  B8(0000001,7) },        /* IRSHIFT */
3335         {       B8(1111111,7),  B8(0110000,7),  B8(0011100,7),  B8(0010111,7),  B8(0011110,7),  B8(0101111,7) },        /* IRPAUSE */
3336 };
3337
3338
3339
3340 static const struct tms_sequences short_tms_seqs[6][6] =                /*  [from_state_ndx][to_state_ndx] */
3341 {
3342         /*      this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
3343
3344                 OK, I added Peter's version of the state table, and it works OK for
3345                 me on MC1322x. I've recreated the jlink portion of patch with this
3346                 new state table. His changes to my state table are pretty minor in
3347                 terms of total transitions, but Peter feels that his version fixes
3348                 some long-standing problems.
3349                 Jeff
3350
3351                 I added the bit count into the table, reduced RESET column to 7 bits from 8.
3352                 Dick
3353
3354                 state specific comments:
3355                 ------------------------
3356                 *->RESET                   tried the 5 bit reset and it gave me problems, 7 bits seems to
3357                                            work better on ARM9 with ft2232 driver.  (Dick)
3358
3359                 RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3360                                                 needed on ARM9 with ft2232 driver.  (Dick)
3361
3362                 RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
3363                                                 needed on ARM9 with ft2232 driver.  (Dick)
3364         */
3365
3366         /* to state: */
3367         /*      RESET                   IDLE                            DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE */                      /* from state: */
3368         {       B8(1111111,7),  B8(0000000,7),  B8(0010111,7),          B8(0001010,7),  B8(0011011,7),  B8(0010110,7) },        /* RESET */
3369         {       B8(1111111,7),  B8(0000000,7),  B8(001,3),                      B8(0101,4),             B8(0011,4),     B8(01011,5) },          /* IDLE */
3370         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(01,2),               B8(001111,6),   B8(0101111,7) },        /* DRSHIFT */
3371         {       B8(1111111,7),  B8(011,3),              B8(01,2),               B8(0,1),                B8(001111,6),   B8(0101111,7) },        /* DRPAUSE */
3372         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(010111,6),   B8(001111,6),   B8(01,2) },                     /* IRSHIFT */
3373         {       B8(1111111,7),  B8(011,3),              B8(00111,5),            B8(010111,6),   B8(01,2),               B8(0,1) }                       /* IRPAUSE */
3374
3375 };
3376
3377 typedef const struct tms_sequences tms_table[6][6];
3378
3379 static tms_table *tms_seqs=&short_tms_seqs;
3380
3381 int tap_get_tms_path( tap_state_t from, tap_state_t to )
3382 {
3383         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bits;
3384 }
3385
3386
3387 int tap_get_tms_path_len( tap_state_t from, tap_state_t to )
3388 {
3389         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
3390 }
3391
3392
3393 bool tap_is_state_stable(tap_state_t astate)
3394 {
3395         bool is_stable;
3396
3397         /*      A switch() is used because it is symbol dependent
3398                 (not value dependent like an array), and can also check bounds.
3399         */
3400         switch( astate )
3401         {
3402         case TAP_RESET:
3403         case TAP_IDLE:
3404         case TAP_DRSHIFT:
3405         case TAP_DRPAUSE:
3406         case TAP_IRSHIFT:
3407         case TAP_IRPAUSE:
3408                 is_stable = true;
3409                 break;
3410         default:
3411                 is_stable = false;
3412         }
3413
3414         return is_stable;
3415 }
3416
3417 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
3418 {
3419         tap_state_t new_state;
3420
3421         /*      A switch is used because it is symbol dependent and not value dependent
3422                 like an array.  Also it can check for out of range conditions.
3423         */
3424
3425         if (tms)
3426         {
3427                 switch (cur_state)
3428                 {
3429                 case TAP_RESET:
3430                         new_state = cur_state;
3431                         break;
3432                 case TAP_IDLE:
3433                 case TAP_DRUPDATE:
3434                 case TAP_IRUPDATE:
3435                         new_state = TAP_DRSELECT;
3436                         break;
3437                 case TAP_DRSELECT:
3438                         new_state = TAP_IRSELECT;
3439                         break;
3440                 case TAP_DRCAPTURE:
3441                 case TAP_DRSHIFT:
3442                         new_state = TAP_DREXIT1;
3443                         break;
3444                 case TAP_DREXIT1:
3445                 case TAP_DREXIT2:
3446                         new_state = TAP_DRUPDATE;
3447                         break;
3448                 case TAP_DRPAUSE:
3449                         new_state = TAP_DREXIT2;
3450                         break;
3451                 case TAP_IRSELECT:
3452                         new_state = TAP_RESET;
3453                         break;
3454                 case TAP_IRCAPTURE:
3455                 case TAP_IRSHIFT:
3456                         new_state = TAP_IREXIT1;
3457                         break;
3458                 case TAP_IREXIT1:
3459                 case TAP_IREXIT2:
3460                         new_state = TAP_IRUPDATE;
3461                         break;
3462                 case TAP_IRPAUSE:
3463                         new_state = TAP_IREXIT2;
3464                         break;
3465                 default:
3466                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3467                         exit(1);
3468                         break;
3469                 }
3470         }
3471         else
3472         {
3473                 switch (cur_state)
3474                 {
3475                 case TAP_RESET:
3476                 case TAP_IDLE:
3477                 case TAP_DRUPDATE:
3478                 case TAP_IRUPDATE:
3479                         new_state = TAP_IDLE;
3480                         break;
3481                 case TAP_DRSELECT:
3482                         new_state = TAP_DRCAPTURE;
3483                         break;
3484                 case TAP_DRCAPTURE:
3485                 case TAP_DRSHIFT:
3486                 case TAP_DREXIT2:
3487                         new_state = TAP_DRSHIFT;
3488                         break;
3489                 case TAP_DREXIT1:
3490                 case TAP_DRPAUSE:
3491                         new_state = TAP_DRPAUSE;
3492                         break;
3493                 case TAP_IRSELECT:
3494                         new_state = TAP_IRCAPTURE;
3495                         break;
3496                 case TAP_IRCAPTURE:
3497                 case TAP_IRSHIFT:
3498                 case TAP_IREXIT2:
3499                         new_state = TAP_IRSHIFT;
3500                         break;
3501                 case TAP_IREXIT1:
3502                 case TAP_IRPAUSE:
3503                         new_state = TAP_IRPAUSE;
3504                         break;
3505                 default:
3506                         LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state );
3507                         exit(1);
3508                         break;
3509                 }
3510         }
3511
3512         return new_state;
3513 }
3514
3515 const char* tap_state_name(tap_state_t state)
3516 {
3517         const char* ret;
3518
3519         switch( state )
3520         {
3521         case TAP_RESET:         ret = "RESET";                  break;
3522         case TAP_IDLE:          ret = "RUN/IDLE";               break;
3523         case TAP_DRSELECT:      ret = "DRSELECT";               break;
3524         case TAP_DRCAPTURE: ret = "DRCAPTURE";          break;
3525         case TAP_DRSHIFT:       ret = "DRSHIFT";                        break;
3526         case TAP_DREXIT1:       ret = "DREXIT1";                        break;
3527         case TAP_DRPAUSE:       ret = "DRPAUSE";                        break;
3528         case TAP_DREXIT2:       ret = "DREXIT2";                        break;
3529         case TAP_DRUPDATE:      ret = "DRUPDATE";               break;
3530         case TAP_IRSELECT:      ret = "IRSELECT";               break;
3531         case TAP_IRCAPTURE: ret = "IRCAPTURE";          break;
3532         case TAP_IRSHIFT:       ret = "IRSHIFT";                        break;
3533         case TAP_IREXIT1:       ret = "IREXIT1";                        break;
3534         case TAP_IRPAUSE:       ret = "IRPAUSE";                        break;
3535         case TAP_IREXIT2:       ret = "IREXIT2";                        break;
3536         case TAP_IRUPDATE:      ret = "IRUPDATE";               break;
3537         default:                                ret = "???";
3538         }
3539
3540         return ret;
3541 }
3542
3543 static tap_state_t tap_state_by_name( const char *name )
3544 {
3545         tap_state_t x;
3546
3547         for( x = 0 ; x < TAP_NUM_STATES ; x++ ){
3548                 /* be nice to the human */
3549                 if( 0 == strcasecmp( name, tap_state_name(x) ) ){
3550                         return x;
3551                 }
3552         }
3553         /* not found */
3554         return TAP_INVALID;
3555 }
3556
3557 #ifdef _DEBUG_JTAG_IO_
3558
3559 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
3560                 do { buf[len] = bit ? '1' : '0'; } while(0)
3561 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
3562                 DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
3563                         tap_state_name(a), tap_state_name(b), astr, bstr)
3564
3565 tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf,
3566                 unsigned tap_bits, tap_state_t next_state)
3567 {
3568         const u8 *tms_buffer;
3569         const u8 *tdi_buffer;
3570         unsigned tap_bytes;
3571         unsigned cur_byte;
3572         unsigned cur_bit;
3573
3574         unsigned tap_out_bits;
3575         char tms_str[33];
3576         char tdi_str[33];
3577
3578         tap_state_t last_state;
3579
3580         // set startstate (and possibly last, if tap_bits == 0)
3581         last_state = next_state;
3582         DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
3583
3584         tms_buffer = (const u8 *)tms_buf;
3585         tdi_buffer = (const u8 *)tdi_buf;
3586
3587         tap_bytes = TAP_SCAN_BYTES(tap_bits);
3588         DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
3589
3590         tap_out_bits = 0;
3591         for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++)
3592         {
3593                 for(cur_bit = 0; cur_bit < 8; cur_bit++)
3594                 {
3595                         // make sure we do not run off the end of the buffers
3596                         unsigned tap_bit = cur_byte * 8 + cur_bit;
3597                         if (tap_bit == tap_bits)
3598                                 break;
3599
3600                         // check and save TMS bit
3601                         tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
3602                         JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
3603
3604                         // use TMS bit to find the next TAP state
3605                         next_state = tap_state_transition(last_state, tap_bit);
3606
3607                         // check and store TDI bit
3608                         tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
3609                         JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
3610
3611                         // increment TAP bits
3612                         tap_out_bits++;
3613
3614                         // Only show TDO bits on state transitions, or
3615                         // after some number of bits in the same state.
3616                         if ((next_state == last_state) && (tap_out_bits < 32))
3617                                 continue;
3618
3619                         // terminate strings and display state transition
3620                         tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3621                         JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3622
3623                         // reset state
3624                         last_state = next_state;
3625                         tap_out_bits = 0;
3626                 }
3627         }
3628
3629         if (tap_out_bits)
3630         {
3631                 // terminate strings and display state transition
3632                 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
3633                 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
3634         }
3635
3636         DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
3637
3638         return next_state;
3639 }
3640 #endif // _DEBUG_JTAG_IO_
3641
3642 #ifndef HAVE_JTAG_MINIDRIVER_H
3643 void jtag_alloc_in_value32(scan_field_t *field)
3644 {
3645         field->in_value=(u8 *)cmd_queue_alloc(4);
3646 }
3647 #endif
3648
3649 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
3650 {
3651         if (argc == 1)
3652         {
3653                 if (strcmp(args[0], "short") == 0)
3654                 {
3655                         tms_seqs=&short_tms_seqs;
3656                 }
3657                 else if (strcmp(args[0], "long") == 0)
3658                 {
3659                         tms_seqs=&old_tms_seqs;
3660                 } else
3661                 {
3662                         return ERROR_COMMAND_SYNTAX_ERROR;
3663                 }
3664         } else if (argc != 0)
3665         {
3666                 return ERROR_COMMAND_SYNTAX_ERROR;
3667         }
3668
3669         command_print(cmd_ctx, "tms sequence is  %s", (tms_seqs==&short_tms_seqs) ? "short": "long");
3670
3671         return ERROR_OK;
3672 }
3673
3674 /*-----</Cable Helper API>--------------------------------------*/