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