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