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