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

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