git.gag.com Git - fw/openocd/blob - src/jtag/jtag.c

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