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