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