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

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