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