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