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

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