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

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