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

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