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

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