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

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2009 SoftPLC Corporation                                *
   9  *       http://softplc.com                                                *
  10  *   dick@softplc.com                                                      *
  11  *                                                                         *
  12  *   This program is free software; you can redistribute it and/or modify  *
  13  *   it under the terms of the GNU General Public License as published by  *
  14  *   the Free Software Foundation; either version 2 of the License, or     *
  15  *   (at your option) any later version.                                   *
  16  *                                                                         *
  17  *   This program is distributed in the hope that it will be useful,       *
  18  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  19  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  20  *   GNU General Public License for more details.                          *
  21  *                                                                         *
  22  *   You should have received a copy of the GNU General Public License     *
  23  *   along with this program; if not, write to the                         *
  24  *   Free Software Foundation, Inc.,                                       *
  25  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  26  ***************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #define INCLUDE_JTAG_INTERFACE_H
  32 #include "jtag.h"
  33 #include "minidriver.h"
  34
  35 #ifdef HAVE_STRINGS_H
  36 #include <strings.h>
  37 #endif
  38
  39
  40 int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */
  41
  42 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
  43                 int in_num_fields, scan_field_t *in_fields, tap_state_t state);
  44
  45 /* note that this is not marked as static as it must be available from outside jtag.c for those
  46    that implement the jtag_xxx() minidriver layer
  47 */
  48 int jtag_error=ERROR_OK;
  49
  50 typedef struct cmd_queue_page_s
  51 {
  52         void *address;
  53         size_t used;
  54         struct cmd_queue_page_s *next;
  55 } cmd_queue_page_t;
  56
  57 #define CMD_QUEUE_PAGE_SIZE (1024 * 1024)
  58 static cmd_queue_page_t *cmd_queue_pages = NULL;
  59
  60 char* jtag_event_strings[] =
  61 {
  62         "JTAG controller reset (RESET or TRST)"
  63 };
  64
  65 const Jim_Nvp nvp_jtag_tap_event[] = {
  66         { .value = JTAG_TAP_EVENT_ENABLE,       .name = "tap-enable" },
  67         { .value = JTAG_TAP_EVENT_DISABLE,      .name = "tap-disable" },
  68
  69         { .name = NULL, .value = -1 }
  70 };
  71
  72 int jtag_trst = 0;
  73 int jtag_srst = 0;
  74
  75 jtag_command_t *jtag_command_queue = NULL;
  76 static jtag_command_t **next_command_pointer = &jtag_command_queue;
  77 static jtag_tap_t *jtag_all_taps = NULL;
  78
  79 enum reset_types jtag_reset_config = RESET_NONE;
  80 tap_state_t cmd_queue_end_state = TAP_RESET;
  81 tap_state_t cmd_queue_cur_state = TAP_RESET;
  82
  83 int jtag_verify_capture_ir = 1;
  84 int jtag_verify = 1;
  85
  86 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */
  87 static int jtag_nsrst_delay = 0; /* default to no nSRST delay */
  88 static int jtag_ntrst_delay = 0; /* default to no nTRST delay */
  89
  90 /* maximum number of JTAG devices expected in the chain
  91  */
  92 #define JTAG_MAX_CHAIN_SIZE 20
  93
  94 /* callbacks to inform high-level handlers about JTAG state changes */
  95 jtag_event_callback_t *jtag_event_callbacks;
  96
  97 /* speed in kHz*/
  98 static int speed_khz = 0;
  99 /* flag if the kHz speed was defined */
 100 static int hasKHz = 0;
 101
 102 /* jtag interfaces (parport, FTDI-USB, TI-USB, ...)
 103  */
 104
 105 #if BUILD_ECOSBOARD == 1
 106         extern jtag_interface_t zy1000_interface;
 107 #endif
 108
 109 #if BUILD_PARPORT == 1
 110         extern jtag_interface_t parport_interface;
 111 #endif
 112
 113 #if BUILD_DUMMY == 1
 114         extern jtag_interface_t dummy_interface;
 115 #endif
 116
 117 #if BUILD_FT2232_FTD2XX == 1
 118         extern jtag_interface_t ft2232_interface;
 119 #endif
 120
 121 #if BUILD_FT2232_LIBFTDI == 1
 122         extern jtag_interface_t ft2232_interface;
 123 #endif
 124
 125 #if BUILD_AMTJTAGACCEL == 1
 126         extern jtag_interface_t amt_jtagaccel_interface;
 127 #endif
 128
 129 #if BUILD_EP93XX == 1
 130         extern jtag_interface_t ep93xx_interface;
 131 #endif
 132
 133 #if BUILD_AT91RM9200 == 1
 134         extern jtag_interface_t at91rm9200_interface;
 135 #endif
 136
 137 #if BUILD_GW16012 == 1
 138         extern jtag_interface_t gw16012_interface;
 139 #endif
 140
 141 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 142         extern jtag_interface_t presto_interface;
 143 #endif
 144
 145 #if BUILD_USBPROG == 1
 146         extern jtag_interface_t usbprog_interface;
 147 #endif
 148
 149 #if BUILD_JLINK == 1
 150         extern jtag_interface_t jlink_interface;
 151 #endif
 152
 153 #if BUILD_VSLLINK == 1
 154         extern jtag_interface_t vsllink_interface;
 155 #endif
 156
 157 #if BUILD_RLINK == 1
 158         extern jtag_interface_t rlink_interface;
 159 #endif
 160
 161 #if BUILD_ARMJTAGEW == 1
 162         extern jtag_interface_t armjtagew_interface;
 163 #endif
 164
 165 jtag_interface_t *jtag_interfaces[] = {
 166 #if BUILD_ECOSBOARD == 1
 167         &zy1000_interface,
 168 #endif
 169 #if BUILD_PARPORT == 1
 170         &parport_interface,
 171 #endif
 172 #if BUILD_DUMMY == 1
 173         &dummy_interface,
 174 #endif
 175 #if BUILD_FT2232_FTD2XX == 1
 176         &ft2232_interface,
 177 #endif
 178 #if BUILD_FT2232_LIBFTDI == 1
 179         &ft2232_interface,
 180 #endif
 181 #if BUILD_AMTJTAGACCEL == 1
 182         &amt_jtagaccel_interface,
 183 #endif
 184 #if BUILD_EP93XX == 1
 185         &ep93xx_interface,
 186 #endif
 187 #if BUILD_AT91RM9200 == 1
 188         &at91rm9200_interface,
 189 #endif
 190 #if BUILD_GW16012 == 1
 191         &gw16012_interface,
 192 #endif
 193 #if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1
 194         &presto_interface,
 195 #endif
 196 #if BUILD_USBPROG == 1
 197         &usbprog_interface,
 198 #endif
 199 #if BUILD_JLINK == 1
 200         &jlink_interface,
 201 #endif
 202 #if BUILD_VSLLINK == 1
 203         &vsllink_interface,
 204 #endif
 205 #if BUILD_RLINK == 1
 206         &rlink_interface,
 207 #endif
 208 #if BUILD_ARMJTAGEW == 1
 209         &armjtagew_interface,
 210 #endif
 211         NULL,
 212 };
 213
 214 struct jtag_interface_s *jtag = NULL;
 215
 216 /* configuration */
 217 static jtag_interface_t *jtag_interface = NULL;
 218 int jtag_speed = 0;
 219
 220 /* jtag commands */
 221 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 222 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 223 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 224 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 225 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 226 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 227 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 228
 229 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 230
 231 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 232 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 233 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 234 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 235 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv);
 236 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args);
 237
 238 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 239 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 240 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 241
 242 jtag_tap_t *jtag_AllTaps(void)
 243 {
 244         return jtag_all_taps;
 245 };
 246
 247 int jtag_NumTotalTaps(void)
 248 {
 249         jtag_tap_t *t;
 250         int n;
 251
 252         n = 0;
 253         t = jtag_AllTaps();
 254         while(t){
 255                 n++;
 256                 t = t->next_tap;
 257         }
 258         return n;
 259 }
 260
 261 int jtag_NumEnabledTaps(void)
 262 {
 263         jtag_tap_t *t;
 264         int n;
 265
 266         n = 0;
 267         t = jtag_AllTaps();
 268         while(t){
 269                 if( t->enabled ){
 270                         n++;
 271                 }
 272                 t = t->next_tap;
 273         }
 274         return n;
 275 }
 276
 277 jtag_tap_t *jtag_TapByString( const char *s )
 278 {
 279         jtag_tap_t *t;
 280         char *cp;
 281
 282         t = jtag_AllTaps();
 283         /* try name first */
 284         while(t){
 285                 if( 0 == strcmp( t->dotted_name, s ) ){
 286                         break;
 287                 } else {
 288                         t = t->next_tap;
 289                 }
 290         }
 291         /* backup plan is by number */
 292         if( t == NULL ){
 293                 /* ok - is "s" a number? */
 294                 int n;
 295                 n = strtol( s, &cp, 0 );
 296                 if( (s != cp) && (*cp == 0) ){
 297                         /* Then it is... */
 298                         t = jtag_TapByAbsPosition(n);
 299                 }
 300         }
 301         return t;
 302 }
 303
 304 jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o )
 305 {
 306         jtag_tap_t *t;
 307         const char *cp;
 308
 309         cp = Jim_GetString( o, NULL );
 310         if(cp == NULL){
 311                 cp = "(unknown)";
 312                 t = NULL;
 313         }  else {
 314                 t = jtag_TapByString( cp );
 315         }
 316         if( t == NULL ){
 317                 Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp );
 318         }
 319         return t;
 320 }
 321
 322 /* returns a pointer to the n-th device in the scan chain */
 323 jtag_tap_t * jtag_TapByAbsPosition( int n )
 324 {
 325         int orig_n;
 326         jtag_tap_t *t;
 327
 328         orig_n = n;
 329         t = jtag_AllTaps();
 330
 331         while( t && (n > 0)) {
 332                 n--;
 333                 t = t->next_tap;
 334         }
 335         return t;
 336 }
 337
 338 int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv)
 339 {
 340         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 341
 342         if (callback == NULL)
 343         {
 344                 return ERROR_INVALID_ARGUMENTS;
 345         }
 346
 347         if (*callbacks_p)
 348         {
 349                 while ((*callbacks_p)->next)
 350                         callbacks_p = &((*callbacks_p)->next);
 351                 callbacks_p = &((*callbacks_p)->next);
 352         }
 353
 354         (*callbacks_p) = malloc(sizeof(jtag_event_callback_t));
 355         (*callbacks_p)->callback = callback;
 356         (*callbacks_p)->priv = priv;
 357         (*callbacks_p)->next = NULL;
 358
 359         return ERROR_OK;
 360 }
 361
 362 int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv))
 363 {
 364         jtag_event_callback_t **callbacks_p = &jtag_event_callbacks;
 365
 366         if (callback == NULL)
 367         {
 368                 return ERROR_INVALID_ARGUMENTS;
 369         }
 370
 371         while (*callbacks_p)
 372         {
 373                 jtag_event_callback_t **next = &((*callbacks_p)->next);
 374                 if ((*callbacks_p)->callback == callback)
 375                 {
 376                         free(*callbacks_p);
 377                         *callbacks_p = *next;
 378                 }
 379                 callbacks_p = next;
 380         }
 381
 382         return ERROR_OK;
 383 }
 384
 385 int jtag_call_event_callbacks(enum jtag_event event)
 386 {
 387         jtag_event_callback_t *callback = jtag_event_callbacks;
 388
 389         LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
 390
 391         while (callback)
 392         {
 393                 callback->callback(event, callback->priv);
 394                 callback = callback->next;
 395         }
 396
 397         return ERROR_OK;
 398 }
 399
 400 void jtag_queue_command(jtag_command_t * cmd)
 401 {
 402         // this command goes on the end, so ensure the queue terminates
 403         cmd->next = NULL;
 404
 405         jtag_command_t **last_cmd = next_command_pointer;
 406         assert(NULL != last_cmd);
 407         assert(NULL == *last_cmd);
 408         *last_cmd = cmd;
 409
 410         // store location where the next command pointer will be stored
 411         next_command_pointer = &cmd->next;
 412 }
 413
 414 void* cmd_queue_alloc(size_t size)
 415 {
 416         cmd_queue_page_t **p_page = &cmd_queue_pages;
 417         int offset;
 418         u8 *t;
 419
 420         /*
 421          * WARNING:
 422          *    We align/round the *SIZE* per below
 423          *    so that all pointers returned by
 424          *    this function are reasonably well
 425          *    aligned.
 426          *
 427          * If we did not, then an "odd-length" request would cause the
 428          * *next* allocation to be at an *odd* address, and because
 429          * this function has the same type of api as malloc() - we
 430          * must also return pointers that have the same type of
 431          * alignment.
 432          *
 433          * What I do not/have is a reasonable portable means
 434          * to align by...
 435          *
 436          * The solution here, is based on these suggestions.
 437          * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html
 438          *
 439          */
 440         union worse_case_align {
 441                 int i;
 442                 long l;
 443                 float f;
 444                 void *v;
 445         };
 446 #define ALIGN_SIZE  (sizeof(union worse_case_align))
 447
 448         /* The alignment process. */
 449         size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1));
 450         /* Done... */
 451
 452         if (*p_page)
 453         {
 454                 while ((*p_page)->next)
 455                         p_page = &((*p_page)->next);
 456                 if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size)
 457                         p_page = &((*p_page)->next);
 458         }
 459
 460         if (!*p_page)
 461         {
 462                 *p_page = malloc(sizeof(cmd_queue_page_t));
 463                 (*p_page)->used = 0;
 464                 (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE);
 465                 (*p_page)->next = NULL;
 466         }
 467
 468         offset = (*p_page)->used;
 469         (*p_page)->used += size;
 470
 471         t=(u8 *)((*p_page)->address);
 472         return t + offset;
 473 }
 474
 475 void cmd_queue_free(void)
 476 {
 477         cmd_queue_page_t *page = cmd_queue_pages;
 478
 479         while (page)
 480         {
 481                 cmd_queue_page_t *last = page;
 482                 free(page->address);
 483                 page = page->next;
 484                 free(last);
 485         }
 486
 487         cmd_queue_pages = NULL;
 488 }
 489
 490 void jtag_command_queue_reset(void)
 491 {
 492         cmd_queue_free();
 493
 494         jtag_command_queue = NULL;
 495         next_command_pointer = &jtag_command_queue;
 496 }
 497
 498 static void jtag_prelude1(void)
 499 {
 500         if (jtag_trst == 1)
 501         {
 502                 LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)");
 503                 jtag_error=ERROR_JTAG_TRST_ASSERTED;
 504                 return;
 505         }
 506
 507         if (cmd_queue_end_state == TAP_RESET)
 508                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 509 }
 510
 511 static void jtag_prelude(tap_state_t state)
 512 {
 513         jtag_prelude1();
 514
 515         if (state != TAP_INVALID)
 516                 jtag_add_end_state(state);
 517
 518         cmd_queue_cur_state = cmd_queue_end_state;
 519 }
 520
 521 void jtag_alloc_in_value32(scan_field_t *field)
 522 {
 523         interface_jtag_alloc_in_value32(field);
 524 }
 525
 526 void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 527 {
 528         int retval;
 529         jtag_prelude(state);
 530
 531         retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 532         if (retval!=ERROR_OK)
 533                 jtag_error=retval;
 534
 535 }
 536
 537
 538 /**
 539  * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP.
 540  *
 541  * If the input field list contains an instruction value for a TAP then that is used
 542  * otherwise the TAP is set to bypass.
 543  *
 544  * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs.
 545  *
 546  */
 547 void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 548 {
 549         if (jtag_verify&&jtag_verify_capture_ir)
 550         {
 551                 /* 8 x 32 bit id's is enough for all invocations */
 552
 553                 for (int j = 0; j < in_num_fields; j++)
 554                 {
 555                         /* if we are to run a verification of the ir scan, we need to get the input back.
 556                          * We may have to allocate space if the caller didn't ask for the input back.
 557                          */
 558                         in_fields[j].check_value=in_fields[j].tap->expected;
 559                         in_fields[j].check_mask=in_fields[j].tap->expected_mask;
 560                 }
 561                 jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state);
 562         } else
 563         {
 564                 jtag_add_ir_scan_noverify(in_num_fields, in_fields, state);
 565         }
 566 }
 567
 568 /**
 569  * Duplicate the scan fields passed into the function into an IR SCAN command
 570  *
 571  * This function assumes that the caller handles extra fields for bypassed TAPs
 572  *
 573  */
 574 void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 575 {
 576         int retval;
 577
 578         jtag_prelude(state);
 579
 580         retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state);
 581         if (retval!=ERROR_OK)
 582                 jtag_error=retval;
 583 }
 584
 585 void jtag_add_callback(jtag_callback1_t f, u8 *in)
 586 {
 587         interface_jtag_add_callback(f, in);
 588 }
 589
 590 void jtag_add_callback4(jtag_callback_t f, u8 *in,
 591                 jtag_callback_data_t data1, jtag_callback_data_t data2,
 592                 jtag_callback_data_t data3)
 593 {
 594         interface_jtag_add_callback4(f, in, data1, data2, data3);
 595 }
 596
 597 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits);
 598
 599 static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3)
 600 {
 601         return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3);
 602 }
 603
 604 static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state),
 605                 int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 606 {
 607         for (int i = 0; i < in_num_fields; i++)
 608         {
 609                 struct scan_field_s *field = &in_fields[i];
 610                 field->allocated = 0;
 611                 field->modified = 0;
 612                 if (field->check_value || field->in_value)
 613                         continue;
 614                 interface_jtag_add_scan_check_alloc(field);
 615                 field->modified = 1;
 616         }
 617
 618         jtag_add_scan(in_num_fields, in_fields, state);
 619
 620         for (int i = 0; i < in_num_fields; i++)
 621         {
 622                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL))
 623                 {
 624                         /* this is synchronous for a minidriver */
 625                         jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value,
 626                                 (jtag_callback_data_t)in_fields[i].check_value,
 627                                 (jtag_callback_data_t)in_fields[i].check_mask,
 628                                 (jtag_callback_data_t)in_fields[i].num_bits);
 629                 }
 630                 if (in_fields[i].allocated)
 631                 {
 632                         free(in_fields[i].in_value);
 633                 }
 634                 if (in_fields[i].modified)
 635                 {
 636                         in_fields[i].in_value = NULL;
 637                 }
 638         }
 639 }
 640
 641 void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state)
 642 {
 643         if (jtag_verify)
 644         {
 645                 jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state);
 646         } else
 647         {
 648                 jtag_add_dr_scan(in_num_fields, in_fields, state);
 649         }
 650 }
 651
 652
 653 /**
 654  * Generate a DR SCAN using the fields passed to the function
 655  *
 656  * For not bypassed TAPs the function checks in_fields and uses fields specified there.
 657  * For bypassed TAPs the function generates a dummy 1bit field.
 658  *
 659  * The bypass status of TAPs is set by jtag_add_ir_scan().
 660  *
 661  */
 662 void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 663 {
 664         int retval;
 665
 666         jtag_prelude(state);
 667
 668         retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
 669         if (retval!=ERROR_OK)
 670                 jtag_error=retval;
 671 }
 672
 673
 674
 675 /**
 676  * Duplicate the scan fields passed into the function into a DR SCAN command
 677  *
 678  * This function assumes that the caller handles extra fields for bypassed TAPs
 679  *
 680  */
 681 void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state)
 682 {
 683         int retval;
 684
 685         jtag_prelude(state);
 686
 687         retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state);
 688         if (retval!=ERROR_OK)
 689                 jtag_error=retval;
 690 }
 691
 692 void jtag_add_dr_out(jtag_tap_t* tap,
 693                 int num_fields, const int* num_bits, const u32* value,
 694                 tap_state_t end_state)
 695 {
 696         if (end_state != TAP_INVALID)
 697                 cmd_queue_end_state = end_state;
 698
 699         cmd_queue_cur_state = cmd_queue_end_state;
 700
 701         interface_jtag_add_dr_out(tap,
 702                         num_fields, num_bits, value,
 703                         cmd_queue_end_state);
 704 }
 705
 706 void jtag_add_tlr(void)
 707 {
 708         jtag_prelude(TAP_RESET);
 709
 710         int retval;
 711         retval=interface_jtag_add_tlr();
 712         if (retval!=ERROR_OK)
 713                 jtag_error=retval;
 714 }
 715
 716 void jtag_add_pathmove(int num_states, const tap_state_t *path)
 717 {
 718         tap_state_t cur_state = cmd_queue_cur_state;
 719         int i;
 720         int retval;
 721
 722         /* the last state has to be a stable state */
 723         if (!tap_is_state_stable(path[num_states - 1]))
 724         {
 725                 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
 726                 exit(-1);
 727         }
 728
 729         for (i=0; i<num_states; i++)
 730         {
 731                 if (path[i] == TAP_RESET)
 732                 {
 733                         LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
 734                         exit(-1);
 735                 }
 736
 737                 if ( tap_state_transition(cur_state, true)  != path[i]
 738                   && tap_state_transition(cur_state, false) != path[i])
 739                 {
 740                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[i]));
 741                         exit(-1);
 742                 }
 743                 cur_state = path[i];
 744         }
 745
 746         jtag_prelude1();
 747
 748         retval = interface_jtag_add_pathmove(num_states, path);
 749         cmd_queue_cur_state = path[num_states - 1];
 750         if (retval!=ERROR_OK)
 751                 jtag_error=retval;
 752 }
 753
 754 void jtag_add_runtest(int num_cycles, tap_state_t state)
 755 {
 756         int retval;
 757
 758         jtag_prelude(state);
 759
 760         /* executed by sw or hw fifo */
 761         retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state);
 762         if (retval!=ERROR_OK)
 763                 jtag_error=retval;
 764 }
 765
 766
 767 void jtag_add_clocks( int num_cycles )
 768 {
 769         int retval;
 770
 771         if( !tap_is_state_stable(cmd_queue_cur_state) )
 772         {
 773                  LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"",
 774                                  tap_state_name(cmd_queue_cur_state) );
 775                  jtag_error = ERROR_JTAG_NOT_STABLE_STATE;
 776                  return;
 777         }
 778
 779         if( num_cycles > 0 )
 780         {
 781                 jtag_prelude1();
 782
 783                 retval = interface_jtag_add_clocks(num_cycles);
 784                 if (retval != ERROR_OK)
 785                         jtag_error=retval;
 786         }
 787 }
 788
 789 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
 790 {
 791         int trst_with_tlr = 0;
 792         int retval;
 793
 794         /* FIX!!! there are *many* different cases here. A better
 795          * approach is needed for legal combinations of transitions...
 796          */
 797         if ((jtag_reset_config & RESET_HAS_SRST)&&
 798                         (jtag_reset_config & RESET_HAS_TRST)&&
 799                         ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0))
 800         {
 801                 if (((req_tlr_or_trst&&!jtag_trst)||
 802                                 (!req_tlr_or_trst&&jtag_trst))&&
 803                                 ((req_srst&&!jtag_srst)||
 804                                                 (!req_srst&&jtag_srst)))
 805                 {
 806                         /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */
 807                         //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined");
 808                 }
 809         }
 810
 811         /* Make sure that jtag_reset_config allows the requested reset */
 812         /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */
 813         if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst))
 814         {
 815                 LOG_ERROR("BUG: requested reset would assert trst");
 816                 jtag_error=ERROR_FAIL;
 817                 return;
 818         }
 819
 820         /* if TRST pulls SRST, we reset with TAP T-L-R */
 821         if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0))
 822         {
 823                 trst_with_tlr = 1;
 824         }
 825
 826         if (req_srst && !(jtag_reset_config & RESET_HAS_SRST))
 827         {
 828                 LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this");
 829                 jtag_error=ERROR_FAIL;
 830                 return;
 831         }
 832
 833         if (req_tlr_or_trst)
 834         {
 835                 if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST))
 836                 {
 837                         jtag_trst = 1;
 838                 } else
 839                 {
 840                         trst_with_tlr = 1;
 841                 }
 842         } else
 843         {
 844                 jtag_trst = 0;
 845         }
 846
 847         jtag_srst = req_srst;
 848
 849         retval = interface_jtag_add_reset(jtag_trst, jtag_srst);
 850         if (retval!=ERROR_OK)
 851         {
 852                 jtag_error=retval;
 853                 return;
 854         }
 855         jtag_execute_queue();
 856
 857         if (jtag_srst)
 858         {
 859                 LOG_DEBUG("SRST line asserted");
 860         }
 861         else
 862         {
 863                 LOG_DEBUG("SRST line released");
 864                 if (jtag_nsrst_delay)
 865                         jtag_add_sleep(jtag_nsrst_delay * 1000);
 866         }
 867
 868         if (trst_with_tlr)
 869         {
 870                 LOG_DEBUG("JTAG reset with RESET instead of TRST");
 871                 jtag_add_end_state(TAP_RESET);
 872                 jtag_add_tlr();
 873                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 874                 return;
 875         }
 876
 877         if (jtag_trst)
 878         {
 879                 /* we just asserted nTRST, so we're now in Test-Logic-Reset,
 880                  * and inform possible listeners about this
 881                  */
 882                 LOG_DEBUG("TRST line asserted");
 883                 tap_set_state(TAP_RESET);
 884                 jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 885         }
 886         else
 887         {
 888                 if (jtag_ntrst_delay)
 889                         jtag_add_sleep(jtag_ntrst_delay * 1000);
 890         }
 891 }
 892
 893 void jtag_add_end_state(tap_state_t state)
 894 {
 895         cmd_queue_end_state = state;
 896         if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT))
 897         {
 898                 LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field");
 899         }
 900 }
 901
 902 void jtag_add_sleep(u32 us)
 903 {
 904         keep_alive(); /* we might be running on a very slow JTAG clk */
 905         int retval=interface_jtag_add_sleep(us);
 906         if (retval!=ERROR_OK)
 907                 jtag_error=retval;
 908         return;
 909 }
 910
 911 int jtag_scan_size(const scan_command_t *cmd)
 912 {
 913         int bit_count = 0;
 914         int i;
 915
 916         /* count bits in scan command */
 917         for (i = 0; i < cmd->num_fields; i++)
 918         {
 919                 bit_count += cmd->fields[i].num_bits;
 920         }
 921
 922         return bit_count;
 923 }
 924
 925 int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer)
 926 {
 927         int bit_count = 0;
 928         int i;
 929
 930         bit_count = jtag_scan_size(cmd);
 931         *buffer = calloc(1,CEIL(bit_count, 8));
 932
 933         bit_count = 0;
 934
 935 #ifdef _DEBUG_JTAG_IO_
 936         LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields);
 937 #endif
 938
 939         for (i = 0; i < cmd->num_fields; i++)
 940         {
 941                 if (cmd->fields[i].out_value)
 942                 {
 943 #ifdef _DEBUG_JTAG_IO_
 944                         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);
 945 #endif
 946                         buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits);
 947 #ifdef _DEBUG_JTAG_IO_
 948                         LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf);
 949                         free(char_buf);
 950 #endif
 951                 }
 952                 else
 953                 {
 954 #ifdef _DEBUG_JTAG_IO_
 955                         LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits);
 956 #endif
 957                 }
 958
 959                 bit_count += cmd->fields[i].num_bits;
 960         }
 961
 962 #ifdef _DEBUG_JTAG_IO_
 963         //LOG_DEBUG("bit_count totalling: %i",  bit_count );
 964 #endif
 965
 966         return bit_count;
 967 }
 968
 969 int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd)
 970 {
 971         int i;
 972         int bit_count = 0;
 973         int retval;
 974
 975         /* we return ERROR_OK, unless a check fails, or a handler reports a problem */
 976         retval = ERROR_OK;
 977
 978         for (i = 0; i < cmd->num_fields; i++)
 979         {
 980                 /* if neither in_value nor in_handler
 981                  * are specified we don't have to examine this field
 982                  */
 983                 if (cmd->fields[i].in_value)
 984                 {
 985                         int num_bits = cmd->fields[i].num_bits;
 986                         u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits);
 987
 988 #ifdef _DEBUG_JTAG_IO_
 989                         char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
 990                         LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf);
 991                         free(char_buf);
 992 #endif
 993
 994                         if (cmd->fields[i].in_value)
 995                         {
 996                                 buf_cpy(captured, cmd->fields[i].in_value, num_bits);
 997                         }
 998
 999                         free(captured);
1000                 }
1001                 bit_count += cmd->fields[i].num_bits;
1002         }
1003
1004         return retval;
1005 }
1006
1007 static const char *jtag_tap_name(const jtag_tap_t *tap)
1008 {
1009         return (tap == NULL) ? "(unknown)" : tap->dotted_name;
1010 }
1011
1012 int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits)
1013 {
1014         int retval = ERROR_OK;
1015
1016         int compare_failed = 0;
1017
1018         if (in_check_mask)
1019                 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
1020         else
1021                 compare_failed = buf_cmp(captured, in_check_value, num_bits);
1022
1023         if (compare_failed){
1024                 /* An error handler could have caught the failing check
1025                  * only report a problem when there wasn't a handler, or if the handler
1026                  * acknowledged the error
1027                  */
1028                 /*
1029                 LOG_WARNING("TAP %s:",
1030                                         jtag_tap_name(field->tap));
1031                                         */
1032                 if (compare_failed)
1033                 {
1034                         char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1035                         char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1036
1037                         if (in_check_mask)
1038                         {
1039                                 char *in_check_mask_char;
1040                                 in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16);
1041                                 LOG_WARNING("value captured during scan didn't pass the requested check:");
1042                                 LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s",
1043                                                         captured_char, in_check_value_char, in_check_mask_char);
1044                                 free(in_check_mask_char);
1045                         }
1046                         else
1047                         {
1048                                 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);
1049                         }
1050
1051                         free(captured_char);
1052                         free(in_check_value_char);
1053
1054                         retval = ERROR_JTAG_QUEUE_FAILED;
1055                 }
1056
1057         }
1058         return retval;
1059 }
1060
1061 void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask)
1062 {
1063         assert(field->in_value != NULL);
1064
1065         if (value==NULL)
1066         {
1067                 /* no checking to do */
1068                 return;
1069         }
1070
1071         jtag_execute_queue_noclear();
1072
1073         int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
1074         jtag_set_error(retval);
1075 }
1076
1077
1078
1079 enum scan_type jtag_scan_type(const scan_command_t *cmd)
1080 {
1081         int i;
1082         int type = 0;
1083
1084         for (i = 0; i < cmd->num_fields; i++)
1085         {
1086                 if (cmd->fields[i].in_value)
1087                         type |= SCAN_IN;
1088                 if (cmd->fields[i].out_value)
1089                         type |= SCAN_OUT;
1090         }
1091
1092         return type;
1093 }
1094
1095 int default_interface_jtag_execute_queue(void)
1096 {
1097         if (NULL == jtag)
1098         {
1099                 LOG_ERROR("No JTAG interface configured yet.  "
1100                         "Issue 'init' command in startup scripts "
1101                         "before communicating with targets.");
1102                 return ERROR_FAIL;
1103         }
1104
1105         return jtag->execute_queue();
1106 }
1107
1108 void jtag_execute_queue_noclear(void)
1109 {
1110         /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces.
1111          * E.g. a JTAG over TCP/IP or USB....
1112          */
1113         jtag_flush_queue_count++;
1114
1115         int retval=interface_jtag_execute_queue();
1116         /* we keep the first error */
1117         if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK))
1118         {
1119                 jtag_error=retval;
1120         }
1121 }
1122
1123 int jtag_execute_queue(void)
1124 {
1125         int retval;
1126         jtag_execute_queue_noclear();
1127         retval=jtag_error;
1128         jtag_error=ERROR_OK;
1129         return retval;
1130 }
1131
1132 int jtag_reset_callback(enum jtag_event event, void *priv)
1133 {
1134         jtag_tap_t *tap = priv;
1135
1136         LOG_DEBUG("-");
1137
1138         if (event == JTAG_TRST_ASSERTED)
1139         {
1140                 buf_set_ones(tap->cur_instr, tap->ir_length);
1141                 tap->bypass = 1;
1142         }
1143
1144         return ERROR_OK;
1145 }
1146
1147 void jtag_sleep(u32 us)
1148 {
1149         alive_sleep(us/1000);
1150 }
1151
1152 /* Try to examine chain layout according to IEEE 1149.1 §12
1153  */
1154 int jtag_examine_chain(void)
1155 {
1156         jtag_tap_t *tap;
1157         scan_field_t field;
1158         u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4];
1159         int i;
1160         int bit_count;
1161         int device_count = 0;
1162         u8 zero_check = 0x0;
1163         u8 one_check = 0xff;
1164
1165         field.tap = NULL;
1166         field.num_bits = sizeof(idcode_buffer) * 8;
1167         field.out_value = idcode_buffer;
1168
1169         field.in_value = idcode_buffer;
1170
1171
1172
1173
1174         for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++)
1175         {
1176                 buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF);
1177         }
1178
1179         jtag_add_plain_dr_scan(1, &field, TAP_RESET);
1180         jtag_execute_queue();
1181
1182         for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++)
1183         {
1184                 zero_check |= idcode_buffer[i];
1185                 one_check &= idcode_buffer[i];
1186         }
1187
1188         /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */
1189         if ((zero_check == 0x00) || (one_check == 0xff))
1190         {
1191                 LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc.");
1192                 return ERROR_JTAG_INIT_FAILED;
1193         }
1194
1195         /* point at the 1st tap */
1196         tap = jtag_NextEnabledTap(NULL);
1197         if( tap == NULL ){
1198                 LOG_ERROR("JTAG: No taps enabled?");
1199                 return ERROR_JTAG_INIT_FAILED;
1200         }
1201
1202         for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;)
1203         {
1204                 u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1205                 if ((idcode & 1) == 0)
1206                 {
1207                         /* LSB must not be 0, this indicates a device in bypass */
1208                         LOG_WARNING("Tap/Device does not have IDCODE");
1209                         idcode=0;
1210
1211                         bit_count += 1;
1212                 }
1213                 else
1214                 {
1215                         u32 manufacturer;
1216                         u32 part;
1217                         u32 version;
1218
1219                         /* some devices, such as AVR will output all 1's instead of TDI
1220                         input value at end of chain. */
1221                         if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF))
1222                         {
1223                                 int unexpected=0;
1224                                 /* End of chain (invalid manufacturer ID)
1225                                  *
1226                                  * The JTAG examine is the very first thing that happens
1227                                  *
1228                                  * A single JTAG device requires only 64 bits to be read back correctly.
1229                                  *
1230                                  * The code below adds a check that the rest of the data scanned (640 bits)
1231                                  * are all as expected. This helps diagnose/catch problems with the JTAG chain
1232                                  *
1233                                  * earlier and gives more helpful/explicit error messages.
1234                                  */
1235                                 for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32)
1236                                 {
1237                                         idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1238                                         if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF)))
1239                                         {
1240                                                 LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode);
1241                                                 unexpected = 1;
1242                                         }
1243                                 }
1244
1245                                 break;
1246                         }
1247
1248 #define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
1249                         manufacturer = EXTRACT_MFG(idcode);
1250 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1251                         part = EXTRACT_PART(idcode);
1252 #define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)
1253                         version = EXTRACT_VER(idcode);
1254
1255                         LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)",
1256                                          ((tap != NULL) ? (tap->dotted_name) : "(not-named)"),
1257                                 idcode, manufacturer, part, version);
1258
1259                         bit_count += 32;
1260                 }
1261                 if (tap)
1262                 {
1263                         tap->idcode = idcode;
1264
1265                         if (tap->expected_ids_cnt > 0) {
1266                                 /* Loop over the expected identification codes and test for a match */
1267                                 u8 ii;
1268                                 for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1269                                         if( tap->idcode == tap->expected_ids[ii] ){
1270                                                 break;
1271                                         }
1272                                 }
1273
1274                                 /* If none of the expected ids matched, log an error */
1275                                 if (ii == tap->expected_ids_cnt) {
1276                                         LOG_ERROR("JTAG tap: %s             got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1277                                                           tap->dotted_name,
1278                                                           idcode,
1279                                                           EXTRACT_MFG( tap->idcode ),
1280                                                           EXTRACT_PART( tap->idcode ),
1281                                                           EXTRACT_VER( tap->idcode ) );
1282                                         for (ii = 0; ii < tap->expected_ids_cnt; ii++) {
1283                                                 LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)",
1284                                                                   tap->dotted_name,
1285                                                                   ii + 1,
1286                                                                   tap->expected_ids_cnt,
1287                                                                   tap->expected_ids[ii],
1288                                                                   EXTRACT_MFG( tap->expected_ids[ii] ),
1289                                                                   EXTRACT_PART( tap->expected_ids[ii] ),
1290                                                                   EXTRACT_VER( tap->expected_ids[ii] ) );
1291                                         }
1292
1293                                         return ERROR_JTAG_INIT_FAILED;
1294                                 } else {
1295                                         LOG_INFO("JTAG Tap/device matched");
1296                                 }
1297                         } else {
1298 #if 0
1299                                 LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project",
1300                                                  tap->idcode);
1301 #endif
1302                         }
1303                         tap = jtag_NextEnabledTap(tap);
1304                 }
1305                 device_count++;
1306         }
1307
1308         /* see if number of discovered devices matches configuration */
1309         if (device_count != jtag_NumEnabledTaps())
1310         {
1311                 LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d",
1312                                   device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps());
1313                 LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)");
1314                 return ERROR_JTAG_INIT_FAILED;
1315         }
1316
1317         return ERROR_OK;
1318 }
1319
1320 int jtag_validate_chain(void)
1321 {
1322         jtag_tap_t *tap;
1323         int total_ir_length = 0;
1324         u8 *ir_test = NULL;
1325         scan_field_t field;
1326         int chain_pos = 0;
1327
1328         tap = NULL;
1329         total_ir_length = 0;
1330         for(;;){
1331                 tap = jtag_NextEnabledTap(tap);
1332                 if( tap == NULL ){
1333                         break;
1334                 }
1335                 total_ir_length += tap->ir_length;
1336         }
1337
1338         total_ir_length += 2;
1339         ir_test = malloc(CEIL(total_ir_length, 8));
1340         buf_set_ones(ir_test, total_ir_length);
1341
1342         field.tap = NULL;
1343         field.num_bits = total_ir_length;
1344         field.out_value = ir_test;
1345         field.in_value = ir_test;
1346
1347
1348         jtag_add_plain_ir_scan(1, &field, TAP_RESET);
1349         jtag_execute_queue();
1350
1351         tap = NULL;
1352         chain_pos = 0;
1353         int val;
1354         for(;;){
1355                 tap = jtag_NextEnabledTap(tap);
1356                 if( tap == NULL ){
1357                         break;
1358                 }
1359
1360                 val = buf_get_u32(ir_test, chain_pos, 2);
1361                 if (val != 0x1)
1362                 {
1363                         char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1364                         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);
1365                         free(cbuf);
1366                         free(ir_test);
1367                         return ERROR_JTAG_INIT_FAILED;
1368                 }
1369                 chain_pos += tap->ir_length;
1370         }
1371
1372         val = buf_get_u32(ir_test, chain_pos, 2);
1373         if (val != 0x3)
1374         {
1375                 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1376                 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);
1377                 free(cbuf);
1378                 free(ir_test);
1379                 return ERROR_JTAG_INIT_FAILED;
1380         }
1381
1382         free(ir_test);
1383
1384         return ERROR_OK;
1385 }
1386
1387 enum jtag_tap_cfg_param {
1388         JCFG_EVENT
1389 };
1390
1391 static Jim_Nvp nvp_config_opts[] = {
1392         { .name = "-event",      .value = JCFG_EVENT },
1393
1394         { .name = NULL,          .value = -1 }
1395 };
1396
1397 static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap)
1398 {
1399         Jim_Nvp *n;
1400         Jim_Obj *o;
1401         int e;
1402
1403         /* parse config or cget options */
1404         while (goi->argc > 0) {
1405                 Jim_SetEmptyResult (goi->interp);
1406
1407                 e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n);
1408                 if (e != JIM_OK) {
1409                         Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0);
1410                         return e;
1411                 }
1412
1413                 switch (n->value) {
1414                         case JCFG_EVENT:
1415                                 if (goi->argc == 0) {
1416                                         Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." );
1417                                         return JIM_ERR;
1418                                 }
1419
1420                                 e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n );
1421                                 if (e != JIM_OK) {
1422                                         Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1);
1423                                         return e;
1424                                 }
1425
1426                                 if (goi->isconfigure) {
1427                                         if (goi->argc != 1) {
1428                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?");
1429                                                 return JIM_ERR;
1430                                         }
1431                                 } else {
1432                                         if (goi->argc != 0) {
1433                                                 Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?");
1434                                                 return JIM_ERR;
1435                                         }
1436                                 }
1437
1438                                 {
1439                                         jtag_tap_event_action_t *jteap;
1440
1441                                         jteap = tap->event_action;
1442                                         /* replace existing? */
1443                                         while (jteap) {
1444                                                 if (jteap->event == (enum jtag_tap_event)n->value) {
1445                                                         break;
1446                                                 }
1447                                                 jteap = jteap->next;
1448                                         }
1449
1450                                         if (goi->isconfigure) {
1451                                                 if (jteap == NULL) {
1452                                                         /* create new */
1453                                                         jteap = calloc(1, sizeof (*jteap));
1454                                                 }
1455                                                 jteap->event = n->value;
1456                                                 Jim_GetOpt_Obj( goi, &o);
1457                                                 if (jteap->body) {
1458                                                         Jim_DecrRefCount(interp, jteap->body);
1459                                                 }
1460                                                 jteap->body = Jim_DuplicateObj(goi->interp, o);
1461                                                 Jim_IncrRefCount(jteap->body);
1462
1463                                                 /* add to head of event list */
1464                                                 jteap->next = tap->event_action;
1465                                                 tap->event_action = jteap;
1466                                                 Jim_SetEmptyResult(goi->interp);
1467                                         } else {
1468                                                 /* get */
1469                                                 if (jteap == NULL) {
1470                                                         Jim_SetEmptyResult(goi->interp);
1471                                                 } else {
1472                                                         Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body));
1473                                                 }
1474                                         }
1475                                 }
1476                                 /* loop for more */
1477                                 break;
1478                 }
1479         } /* while (goi->argc) */
1480
1481         return JIM_OK;
1482 }
1483
1484 static int jim_newtap_cmd( Jim_GetOptInfo *goi )
1485 {
1486         jtag_tap_t *pTap;
1487         jtag_tap_t **ppTap;
1488         jim_wide w;
1489         int x;
1490         int e;
1491         int reqbits;
1492         Jim_Nvp *n;
1493         char *cp;
1494         const Jim_Nvp opts[] = {
1495 #define NTAP_OPT_IRLEN     0
1496                 { .name = "-irlen"                      ,       .value = NTAP_OPT_IRLEN },
1497 #define NTAP_OPT_IRMASK    1
1498                 { .name = "-irmask"                     ,       .value = NTAP_OPT_IRMASK },
1499 #define NTAP_OPT_IRCAPTURE 2
1500                 { .name = "-ircapture"          ,       .value = NTAP_OPT_IRCAPTURE },
1501 #define NTAP_OPT_ENABLED   3
1502                 { .name = "-enable"                     ,       .value = NTAP_OPT_ENABLED },
1503 #define NTAP_OPT_DISABLED  4
1504                 { .name = "-disable"            ,       .value = NTAP_OPT_DISABLED },
1505 #define NTAP_OPT_EXPECTED_ID 5
1506                 { .name = "-expected-id"        ,       .value = NTAP_OPT_EXPECTED_ID },
1507                 { .name = NULL                          ,       .value = -1 },
1508         };
1509
1510         pTap = malloc( sizeof(jtag_tap_t) );
1511         memset( pTap, 0, sizeof(*pTap) );
1512         if( !pTap ){
1513                 Jim_SetResult_sprintf( goi->interp, "no memory");
1514                 return JIM_ERR;
1515         }
1516         /*
1517          * we expect CHIP + TAP + OPTIONS
1518          * */
1519         if( goi->argc < 3 ){
1520                 Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ....");
1521                 return JIM_ERR;
1522         }
1523         Jim_GetOpt_String( goi, &cp, NULL );
1524         pTap->chip = strdup(cp);
1525
1526         Jim_GetOpt_String( goi, &cp, NULL );
1527         pTap->tapname = strdup(cp);
1528
1529         /* name + dot + name + null */
1530         x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1;
1531         cp = malloc( x );
1532         sprintf( cp, "%s.%s", pTap->chip, pTap->tapname );
1533         pTap->dotted_name = cp;
1534
1535         LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params",
1536                           pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc);
1537
1538         /* default is enabled */
1539         pTap->enabled = 1;
1540
1541         /* deal with options */
1542 #define NTREQ_IRLEN      1
1543 #define NTREQ_IRCAPTURE  2
1544 #define NTREQ_IRMASK     4
1545
1546         /* clear them as we find them */
1547         reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK);
1548
1549         while( goi->argc ){
1550                 e = Jim_GetOpt_Nvp( goi, opts, &n );
1551                 if( e != JIM_OK ){
1552                         Jim_GetOpt_NvpUnknown( goi, opts, 0 );
1553                         return e;
1554                 }
1555                 LOG_DEBUG("Processing option: %s", n->name );
1556                 switch( n->value ){
1557                 case NTAP_OPT_ENABLED:
1558                         pTap->enabled = 1;
1559                         break;
1560                 case NTAP_OPT_DISABLED:
1561                         pTap->enabled = 0;
1562                         break;
1563                 case NTAP_OPT_EXPECTED_ID:
1564                 {
1565                         u32 *new_expected_ids;
1566
1567                         e = Jim_GetOpt_Wide( goi, &w );
1568                         if( e != JIM_OK) {
1569                                 Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name);
1570                                 return e;
1571                         }
1572
1573                         new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1));
1574                         if (new_expected_ids == NULL) {
1575                                 Jim_SetResult_sprintf( goi->interp, "no memory");
1576                                 return JIM_ERR;
1577                         }
1578
1579                         memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt);
1580
1581                         new_expected_ids[pTap->expected_ids_cnt] = w;
1582
1583                         free(pTap->expected_ids);
1584                         pTap->expected_ids = new_expected_ids;
1585                         pTap->expected_ids_cnt++;
1586                         break;
1587                 }
1588                 case NTAP_OPT_IRLEN:
1589                 case NTAP_OPT_IRMASK:
1590                 case NTAP_OPT_IRCAPTURE:
1591                         e = Jim_GetOpt_Wide( goi, &w );
1592                         if( e != JIM_OK ){
1593                                 Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name );
1594                                 return e;
1595                         }
1596                         if( (w < 0) || (w > 0xffff) ){
1597                                 /* wacky value */
1598                                 Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)",
1599                                                                            n->name, (int)(w), (int)(w));
1600                                 return JIM_ERR;
1601                         }
1602                         switch(n->value){
1603                         case NTAP_OPT_IRLEN:
1604                                 pTap->ir_length = w;
1605                                 reqbits &= (~(NTREQ_IRLEN));
1606                                 break;
1607                         case NTAP_OPT_IRMASK:
1608                                 pTap->ir_capture_mask = w;
1609                                 reqbits &= (~(NTREQ_IRMASK));
1610                                 break;
1611                         case NTAP_OPT_IRCAPTURE:
1612                                 pTap->ir_capture_value = w;
1613                                 reqbits &= (~(NTREQ_IRCAPTURE));
1614                                 break;
1615                         }
1616                 } /* switch(n->value) */
1617         } /* while( goi->argc ) */
1618
1619         /* Did we get all the options? */
1620         if( reqbits ){
1621                 // no
1622                 Jim_SetResult_sprintf( goi->interp,
1623                                                            "newtap: %s missing required parameters",
1624                                                            pTap->dotted_name);
1625                 /* TODO: Tell user what is missing :-( */
1626                 /* no memory leaks pelase */
1627                 free(((void *)(pTap->expected_ids)));
1628                 free(((void *)(pTap->chip)));
1629                 free(((void *)(pTap->tapname)));
1630                 free(((void *)(pTap->dotted_name)));
1631                 free(((void *)(pTap)));
1632                 return JIM_ERR;
1633         }
1634
1635         pTap->expected      = malloc( pTap->ir_length );
1636         pTap->expected_mask = malloc( pTap->ir_length );
1637         pTap->cur_instr     = malloc( pTap->ir_length );
1638
1639         buf_set_u32( pTap->expected,
1640                                  0,
1641                                  pTap->ir_length,
1642                                  pTap->ir_capture_value );
1643         buf_set_u32( pTap->expected_mask,
1644                                  0,
1645                                  pTap->ir_length,
1646                                  pTap->ir_capture_mask );
1647         buf_set_ones( pTap->cur_instr,
1648                                   pTap->ir_length );
1649
1650         pTap->bypass = 1;
1651
1652         jtag_register_event_callback(jtag_reset_callback, pTap );
1653
1654         ppTap = &(jtag_all_taps);
1655         while( (*ppTap) != NULL ){
1656                 ppTap = &((*ppTap)->next_tap);
1657         }
1658         *ppTap = pTap;
1659         {
1660                 static int n_taps = 0;
1661                 pTap->abs_chain_position = n_taps++;
1662         }
1663         LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x",
1664                                 (*ppTap)->dotted_name,
1665                                 (*ppTap)->abs_chain_position,
1666                                 (*ppTap)->ir_length,
1667                                 (*ppTap)->ir_capture_value,
1668                                 (*ppTap)->ir_capture_mask );
1669
1670         return ERROR_OK;
1671 }
1672
1673 static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv )
1674 {
1675         Jim_GetOptInfo goi;
1676         int e;
1677         Jim_Nvp *n;
1678         Jim_Obj *o;
1679         struct command_context_s *context;
1680
1681         enum {
1682                 JTAG_CMD_INTERFACE,
1683                 JTAG_CMD_INIT_RESET,
1684                 JTAG_CMD_NEWTAP,
1685                 JTAG_CMD_TAPENABLE,
1686                 JTAG_CMD_TAPDISABLE,
1687                 JTAG_CMD_TAPISENABLED,
1688                 JTAG_CMD_CONFIGURE,
1689                 JTAG_CMD_CGET
1690         };
1691
1692         const Jim_Nvp jtag_cmds[] = {
1693                 { .name = "interface"     , .value = JTAG_CMD_INTERFACE },
1694                 { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET },
1695                 { .name = "newtap"        , .value = JTAG_CMD_NEWTAP },
1696                 { .name = "tapisenabled"     , .value = JTAG_CMD_TAPISENABLED },
1697                 { .name = "tapenable"     , .value = JTAG_CMD_TAPENABLE },
1698                 { .name = "tapdisable"    , .value = JTAG_CMD_TAPDISABLE },
1699                 { .name = "configure"     , .value = JTAG_CMD_CONFIGURE },
1700                 { .name = "cget"          , .value = JTAG_CMD_CGET },
1701
1702                 { .name = NULL, .value = -1 },
1703         };
1704
1705         context = Jim_GetAssocData(interp, "context");
1706         /* go past the command */
1707         Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 );
1708
1709         e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n );
1710         if( e != JIM_OK ){
1711                 Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 );
1712                 return e;
1713         }
1714                 Jim_SetEmptyResult( goi.interp );
1715         switch( n->value ){
1716         case JTAG_CMD_INTERFACE:
1717                 /* return the name of the interface */
1718                 /* TCL code might need to know the exact type... */
1719                 /* FUTURE: we allow this as a means to "set" the interface. */
1720                 if( goi.argc != 0 ){
1721                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1722                         return JIM_ERR;
1723                 }
1724                 Jim_SetResultString( goi.interp, jtag_interface->name, -1 );
1725                 return JIM_OK;
1726         case JTAG_CMD_INIT_RESET:
1727                 if( goi.argc != 0 ){
1728                         Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)");
1729                         return JIM_ERR;
1730                 }
1731                 e = jtag_init_reset(context);
1732                 if( e != ERROR_OK ){
1733                         Jim_SetResult_sprintf( goi.interp, "error: %d", e);
1734                         return JIM_ERR;
1735                 }
1736                 return JIM_OK;
1737         case JTAG_CMD_NEWTAP:
1738                 return jim_newtap_cmd( &goi );
1739                 break;
1740         case JTAG_CMD_TAPISENABLED:
1741         case JTAG_CMD_TAPENABLE:
1742         case JTAG_CMD_TAPDISABLE:
1743                 if( goi.argc != 1 ){
1744                         Jim_SetResultString( goi.interp, "Too many parameters",-1 );
1745                         return JIM_ERR;
1746                 }
1747
1748                 {
1749                         jtag_tap_t *t;
1750                         t = jtag_TapByJimObj( goi.interp, goi.argv[0] );
1751                         if( t == NULL ){
1752                                 return JIM_ERR;
1753                         }
1754                         switch( n->value ){
1755                         case JTAG_CMD_TAPISENABLED:
1756                                 e = t->enabled;
1757                                 break;
1758                         case JTAG_CMD_TAPENABLE:
1759                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE);
1760                                 e = 1;
1761                                 t->enabled = e;
1762                                 break;
1763                         case JTAG_CMD_TAPDISABLE:
1764                                 jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE);
1765                                 e = 0;
1766                                 t->enabled = e;
1767                                 break;
1768                         }
1769                         Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) );
1770                         return JIM_OK;
1771                 }
1772                 break;
1773
1774         case JTAG_CMD_CGET:
1775                 if( goi.argc < 2 ){
1776                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ...");
1777                         return JIM_ERR;
1778                 }
1779
1780                 {
1781                         jtag_tap_t *t;
1782
1783                         Jim_GetOpt_Obj(&goi, &o);
1784                         t = jtag_TapByJimObj( goi.interp, o );
1785                         if( t == NULL ){
1786                                 return JIM_ERR;
1787                         }
1788
1789                         goi.isconfigure = 0;
1790                         return jtag_tap_configure_cmd( &goi, t);
1791                 }
1792                 break;
1793
1794         case JTAG_CMD_CONFIGURE:
1795                 if( goi.argc < 3 ){
1796                         Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ...");
1797                         return JIM_ERR;
1798                 }
1799
1800                 {
1801                         jtag_tap_t *t;
1802
1803                         Jim_GetOpt_Obj(&goi, &o);
1804                         t = jtag_TapByJimObj( goi.interp, o );
1805                         if( t == NULL ){
1806                                 return JIM_ERR;
1807                         }
1808
1809                         goi.isconfigure = 1;
1810                         return jtag_tap_configure_cmd( &goi, t);
1811                 }
1812         }
1813
1814         return JIM_ERR;
1815 }
1816
1817 int jtag_register_commands(struct command_context_s *cmd_ctx)
1818 {
1819         register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions");
1820
1821         register_command(cmd_ctx, NULL, "interface", handle_interface_command,
1822                 COMMAND_CONFIG, "try to configure interface");
1823         register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command,
1824                 COMMAND_ANY, "(DEPRECATED) set jtag speed (if supported)");
1825         register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command,
1826                 COMMAND_ANY, "set maximum jtag speed (if supported); "
1827                 "parameter is maximum khz, or 0 for adaptive clocking (RTCK).");
1828         register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command,
1829                 COMMAND_CONFIG, "(DEPRECATED) jtag_device <ir_length> <ir_expected> <ir_mask>");
1830         register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command,
1831                 COMMAND_ANY,
1832                 "[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]");
1833         register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command,
1834                 COMMAND_ANY, "jtag_nsrst_delay <ms> - delay after deasserting srst in ms");
1835         register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command,
1836                 COMMAND_ANY, "jtag_ntrst_delay <ms> - delay after deasserting trst in ms");
1837
1838         register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command,
1839                 COMMAND_EXEC, "print current scan chain configuration");
1840
1841         register_command(cmd_ctx, NULL, "endstate", handle_endstate_command,
1842                 COMMAND_EXEC, "finish JTAG operations in <tap_state>");
1843         register_command(cmd_ctx, NULL, "jtag_reset", handle_jtag_reset_command,
1844                 COMMAND_EXEC, "toggle reset lines <trst> <srst>");
1845         register_command(cmd_ctx, NULL, "runtest", handle_runtest_command,
1846                 COMMAND_EXEC, "move to Run-Test/Idle, and execute <num_cycles>");
1847         register_command(cmd_ctx, NULL, "irscan", handle_irscan_command,
1848                 COMMAND_EXEC, "execute IR scan <device> <instr> [dev2] [instr2] ...");
1849         register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan <device> <num_bits> <value> <num_bits1> <value2> ...");
1850         register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed");
1851
1852         register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command,
1853                 COMMAND_ANY, "verify value captured during Capture-IR <enable|disable>");
1854         register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command,
1855                 COMMAND_ANY, "verify value capture <enable|disable>");
1856         register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command,
1857                 COMMAND_ANY, "choose short(default) or long tms_sequence <short|long>");
1858         return ERROR_OK;
1859 }
1860
1861 int jtag_interface_init(struct command_context_s *cmd_ctx)
1862 {
1863         if (jtag)
1864                 return ERROR_OK;
1865
1866         if (!jtag_interface)
1867         {
1868                 /* nothing was previously specified by "interface" command */
1869                 LOG_ERROR("JTAG interface has to be specified, see \"interface\" command");
1870                 return ERROR_JTAG_INVALID_INTERFACE;
1871         }
1872         if(hasKHz)
1873         {
1874                 jtag_interface->khz(speed_khz, &jtag_speed);
1875                 hasKHz = 0;
1876         }
1877
1878         if (jtag_interface->init() != ERROR_OK)
1879                 return ERROR_JTAG_INIT_FAILED;
1880
1881         jtag = jtag_interface;
1882         return ERROR_OK;
1883 }
1884
1885 static int jtag_init_inner(struct command_context_s *cmd_ctx)
1886 {
1887         jtag_tap_t *tap;
1888         int retval;
1889
1890         LOG_DEBUG("Init JTAG chain");
1891
1892         tap = jtag_NextEnabledTap(NULL);
1893         if( tap == NULL ){
1894                 LOG_ERROR("There are no enabled taps?");
1895                 return ERROR_JTAG_INIT_FAILED;
1896         }
1897
1898         jtag_add_tlr();
1899         if ((retval=jtag_execute_queue())!=ERROR_OK)
1900                 return retval;
1901
1902         /* examine chain first, as this could discover the real chain layout */
1903         if (jtag_examine_chain() != ERROR_OK)
1904         {
1905                 LOG_ERROR("trying to validate configured JTAG chain anyway...");
1906         }
1907
1908         if (jtag_validate_chain() != ERROR_OK)
1909         {
1910                 LOG_WARNING("Could not validate JTAG chain, continuing anyway...");
1911         }
1912
1913         return ERROR_OK;
1914 }
1915
1916 int jtag_interface_quit(void)
1917 {
1918         if (!jtag || !jtag->quit)
1919                 return ERROR_OK;
1920
1921         // close the JTAG interface
1922         int result = jtag->quit();
1923         if (ERROR_OK != result)
1924                 LOG_ERROR("failed: %d", result);
1925
1926         return ERROR_OK;
1927 }
1928
1929
1930 int jtag_init_reset(struct command_context_s *cmd_ctx)
1931 {
1932         int retval;
1933
1934         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1935                 return retval;
1936
1937         LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET");
1938
1939         /* Reset can happen after a power cycle.
1940          *
1941          * Ideally we would only assert TRST or run RESET before the target reset.
1942          *
1943          * However w/srst_pulls_trst, trst is asserted together with the target
1944          * reset whether we want it or not.
1945          *
1946          * NB! Some targets have JTAG circuitry disabled until a
1947          * trst & srst has been asserted.
1948          *
1949          * NB! here we assume nsrst/ntrst delay are sufficient!
1950          *
1951          * NB! order matters!!!! srst *can* disconnect JTAG circuitry
1952          *
1953          */
1954         jtag_add_reset(1, 0); /* RESET or TRST */
1955         if (jtag_reset_config & RESET_HAS_SRST)
1956         {
1957                 jtag_add_reset(1, 1);
1958                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)
1959                         jtag_add_reset(0, 1);
1960         }
1961         jtag_add_reset(0, 0);
1962         if ((retval = jtag_execute_queue()) != ERROR_OK)
1963                 return retval;
1964
1965         /* Check that we can communication on the JTAG chain + eventually we want to
1966          * be able to perform enumeration only after OpenOCD has started
1967          * telnet and GDB server
1968          *
1969          * That would allow users to more easily perform any magic they need to before
1970          * reset happens.
1971          */
1972         return jtag_init_inner(cmd_ctx);
1973 }
1974
1975 int jtag_init(struct command_context_s *cmd_ctx)
1976 {
1977         int retval;
1978         if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK)
1979                 return retval;
1980         if (jtag_init_inner(cmd_ctx)==ERROR_OK)
1981         {
1982                 return ERROR_OK;
1983         }
1984         return jtag_init_reset(cmd_ctx);
1985 }
1986
1987 static int default_khz(int khz, int *jtag_speed)
1988 {
1989         LOG_ERROR("Translation from khz to jtag_speed not implemented");
1990         return ERROR_FAIL;
1991 }
1992
1993 static int default_speed_div(int speed, int *khz)
1994 {
1995         LOG_ERROR("Translation from jtag_speed to khz not implemented");
1996         return ERROR_FAIL;
1997 }
1998
1999 static int default_power_dropout(int *dropout)
2000 {
2001         *dropout=0; /* by default we can't detect power dropout */
2002         return ERROR_OK;
2003 }
2004
2005 static int default_srst_asserted(int *srst_asserted)
2006 {
2007         *srst_asserted=0; /* by default we can't detect srst asserted */
2008         return ERROR_OK;
2009 }
2010
2011 static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2012 {
2013         int i;
2014         int retval;
2015
2016         /* check whether the interface is already configured */
2017         if (jtag_interface)
2018         {
2019                 LOG_WARNING("Interface already configured, ignoring");
2020                 return ERROR_OK;
2021         }
2022
2023         /* interface name is a mandatory argument */
2024         if (argc < 1 || args[0][0] == '\0')
2025         {
2026                 return ERROR_COMMAND_SYNTAX_ERROR;
2027         }
2028
2029         for (i=0; jtag_interfaces[i]; i++)
2030         {
2031                 if (strcmp(args[0], jtag_interfaces[i]->name) == 0)
2032                 {
2033                         if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK)
2034                         {
2035                                 return retval;
2036                         }
2037
2038                         jtag_interface = jtag_interfaces[i];
2039
2040                         if (jtag_interface->khz == NULL)
2041                         {
2042                                 jtag_interface->khz = default_khz;
2043                         }
2044                         if (jtag_interface->speed_div == NULL)
2045                         {
2046                                 jtag_interface->speed_div = default_speed_div;
2047                         }
2048                         if (jtag_interface->power_dropout == NULL)
2049                         {
2050                                 jtag_interface->power_dropout = default_power_dropout;
2051                         }
2052                         if (jtag_interface->srst_asserted == NULL)
2053                         {
2054                                 jtag_interface->srst_asserted = default_srst_asserted;
2055                         }
2056
2057                         return ERROR_OK;
2058                 }
2059         }
2060
2061         /* no valid interface was found (i.e. the configuration option,
2062          * didn't match one of the compiled-in interfaces
2063          */
2064         LOG_ERROR("No valid jtag interface found (%s)", args[0]);
2065         LOG_ERROR("compiled-in jtag interfaces:");
2066         for (i = 0; jtag_interfaces[i]; i++)
2067         {
2068                 LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name);
2069         }
2070
2071         return ERROR_JTAG_INVALID_INTERFACE;
2072 }
2073
2074 static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2075 {
2076         int e;
2077         char buf[1024];
2078         Jim_Obj *newargs[ 10 ];
2079         /*
2080          * CONVERT SYNTAX
2081          * argv[-1] = command
2082          * argv[ 0] = ir length
2083          * argv[ 1] = ir capture
2084          * argv[ 2] = ir mask
2085          * argv[ 3] = not actually used by anything but in the docs
2086          */
2087
2088         if( argc < 4 ){
2089                 command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax");
2090                 return ERROR_OK;
2091         }
2092         command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax");
2093         command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s",
2094                                    args[0],
2095                                    args[1],
2096                                    args[2] );
2097         command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundaryscan(len5)");
2098         command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\"");
2099         command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\"");
2100         command_print( cmd_ctx, "And then refer to the taps by the dotted name.");
2101
2102         newargs[0] = Jim_NewStringObj( interp, "jtag", -1   );
2103         newargs[1] = Jim_NewStringObj( interp, "newtap", -1 );
2104         sprintf( buf, "chip%d", jtag_NumTotalTaps() );
2105         newargs[2] = Jim_NewStringObj( interp, buf, -1 );
2106         sprintf( buf, "tap%d", jtag_NumTotalTaps() );
2107         newargs[3] = Jim_NewStringObj( interp, buf, -1  );
2108         newargs[4] = Jim_NewStringObj( interp, "-irlen", -1  );
2109         newargs[5] = Jim_NewStringObj( interp, args[0], -1  );
2110         newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1  );
2111         newargs[7] = Jim_NewStringObj( interp, args[1], -1  );
2112         newargs[8] = Jim_NewStringObj( interp, "-irmask", -1  );
2113         newargs[9] = Jim_NewStringObj( interp, args[2], -1  );
2114
2115         command_print( cmd_ctx, "NEW COMMAND:");
2116         sprintf( buf, "%s %s %s %s %s %s %s %s %s %s",
2117                          Jim_GetString( newargs[0], NULL ),
2118                          Jim_GetString( newargs[1], NULL ),
2119                          Jim_GetString( newargs[2], NULL ),
2120                          Jim_GetString( newargs[3], NULL ),
2121                          Jim_GetString( newargs[4], NULL ),
2122                          Jim_GetString( newargs[5], NULL ),
2123                          Jim_GetString( newargs[6], NULL ),
2124                          Jim_GetString( newargs[7], NULL ),
2125                          Jim_GetString( newargs[8], NULL ),
2126                          Jim_GetString( newargs[9], NULL ) );
2127
2128         e = jim_jtag_command( interp, 10, newargs );
2129         if( e != JIM_OK ){
2130                 command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) );
2131         }
2132         return e;
2133 }
2134
2135 static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2136 {
2137         jtag_tap_t *tap;
2138
2139         tap = jtag_all_taps;
2140         command_print(cmd_ctx, "     TapName            | Enabled |   IdCode      Expected    IrLen IrCap  IrMask Instr     ");
2141         command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------");
2142
2143         while( tap ){
2144                 u32 expected, expected_mask, cur_instr, ii;
2145                 expected = buf_get_u32(tap->expected, 0, tap->ir_length);
2146                 expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length);
2147                 cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length);
2148
2149                 command_print(cmd_ctx,
2150                                           "%2d | %-18s |    %c    | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x",
2151                                           tap->abs_chain_position,
2152                                           tap->dotted_name,
2153                                           tap->enabled ? 'Y' : 'n',
2154                                           tap->idcode,
2155                                           (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0),
2156                                           tap->ir_length,
2157                                           expected,
2158                                           expected_mask,
2159                                           cur_instr);
2160
2161                 for (ii = 1; ii < tap->expected_ids_cnt; ii++) {
2162                         command_print(cmd_ctx, "   |                    |         |            | 0x%08x |      |      |      |         ",
2163                                                   tap->expected_ids[ii]);
2164                 }
2165
2166                 tap = tap->next_tap;
2167         }
2168
2169         return ERROR_OK;
2170 }
2171
2172 static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2173 {
2174         int new_cfg = 0;
2175         int mask = 0;
2176
2177         if (argc < 1)
2178                 return ERROR_COMMAND_SYNTAX_ERROR;
2179
2180         /* Original versions cared about the order of these tokens:
2181          *   reset_config signals [combination [trst_type [srst_type]]]
2182          * They also clobbered the previous configuration even on error.
2183          *
2184          * Here we don't care about the order, and only change values
2185          * which have been explicitly specified.
2186          */
2187         for (; argc; argc--, args++) {
2188                 int tmp = 0;
2189                 int m;
2190
2191                 /* signals */
2192                 m = RESET_HAS_TRST | RESET_HAS_SRST;
2193                 if (strcmp(*args, "none") == 0)
2194                         tmp = RESET_NONE;
2195                 else if (strcmp(*args, "trst_only") == 0)
2196                         tmp = RESET_HAS_TRST;
2197                 else if (strcmp(*args, "srst_only") == 0)
2198                         tmp = RESET_HAS_SRST;
2199                 else if (strcmp(*args, "trst_and_srst") == 0)
2200                         tmp = RESET_HAS_TRST | RESET_HAS_SRST;
2201                 else
2202                         m = 0;
2203                 if (mask & m) {
2204                         LOG_ERROR("extra reset_config %s spec (%s)",
2205                                         "signal", *args);
2206                         return ERROR_INVALID_ARGUMENTS;
2207                 }
2208                 if (m)
2209                         goto next;
2210
2211                 /* combination (options for broken wiring) */
2212                 m = RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2213                 if (strcmp(*args, "separate") == 0)
2214                         /* separate reset lines - default */;
2215                 else if (strcmp(*args, "srst_pulls_trst") == 0)
2216                         tmp |= RESET_SRST_PULLS_TRST;
2217                 else if (strcmp(*args, "trst_pulls_srst") == 0)
2218                         tmp |= RESET_TRST_PULLS_SRST;
2219                 else if (strcmp(*args, "combined") == 0)
2220                         tmp |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST;
2221                 else
2222                         m = 0;
2223                 if (mask & m) {
2224                         LOG_ERROR("extra reset_config %s spec (%s)",
2225                                         "combination", *args);
2226                         return ERROR_INVALID_ARGUMENTS;
2227                 }
2228                 if (m)
2229                         goto next;
2230
2231                 /* trst_type (NOP without HAS_TRST) */
2232                 m = RESET_TRST_OPEN_DRAIN;
2233                 if (strcmp(*args, "trst_open_drain") == 0)
2234                         tmp |= RESET_TRST_OPEN_DRAIN;
2235                 else if (strcmp(*args, "trst_push_pull") == 0)
2236                         /* push/pull from adapter - default */;
2237                 else
2238                         m = 0;
2239                 if (mask & m) {
2240                         LOG_ERROR("extra reset_config %s spec (%s)",
2241                                         "trst_type", *args);
2242                         return ERROR_INVALID_ARGUMENTS;
2243                 }
2244                 if (m)
2245                         goto next;
2246
2247                 /* srst_type (NOP without HAS_SRST) */
2248                 m |= RESET_SRST_PUSH_PULL;
2249                 if (strcmp(*args, "srst_push_pull") == 0)
2250                         tmp |= RESET_SRST_PUSH_PULL;
2251                 else if (strcmp(*args, "srst_open_drain") == 0)
2252                         /* open drain from adapter - default */;
2253                 else
2254                         m = 0;
2255                 if (mask & m) {
2256                         LOG_ERROR("extra reset_config %s spec (%s)",
2257                                         "srst_type", *args);
2258                         return ERROR_INVALID_ARGUMENTS;
2259                 }
2260                 if (m)
2261                         goto next;
2262
2263                 /* caller provided nonsense; fail */
2264                 LOG_ERROR("unknown reset_config flag (%s)", *args);
2265                 return ERROR_INVALID_ARGUMENTS;
2266
2267 next:
2268                 /* Remember the bits which were specified (mask)
2269                  * and their new values (new_cfg).
2270                  */
2271                 mask |= m;
2272                 new_cfg |= tmp;
2273         }
2274
2275         /* clear previous values of those bits, save new values */
2276         jtag_reset_config &= ~mask;
2277         jtag_reset_config |= new_cfg;
2278
2279         return ERROR_OK;
2280 }
2281
2282 static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2283 {
2284         if (argc < 1)
2285         {
2286                 LOG_ERROR("jtag_nsrst_delay <ms> command takes one required argument");
2287                 exit(-1);
2288         }
2289         else
2290         {
2291                 jtag_nsrst_delay = strtoul(args[0], NULL, 0);
2292         }
2293
2294         return ERROR_OK;
2295 }
2296
2297 static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2298 {
2299         if (argc < 1)
2300         {
2301                 LOG_ERROR("jtag_ntrst_delay <ms> command takes one required argument");
2302                 exit(-1);
2303         }
2304         else
2305         {
2306                 jtag_ntrst_delay = strtoul(args[0], NULL, 0);
2307         }
2308
2309         return ERROR_OK;
2310 }
2311
2312 static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2313 {
2314         int retval=ERROR_OK;
2315
2316         if (argc == 1)
2317         {
2318                 LOG_DEBUG("handle jtag speed");
2319
2320                 int cur_speed = 0;
2321                 cur_speed = jtag_speed = strtoul(args[0], NULL, 0);
2322
2323                 /* this command can be called during CONFIG,
2324                  * in which case jtag isn't initialized */
2325                 if (jtag)
2326                 {
2327                         retval=jtag->speed(cur_speed);
2328                 }
2329         } else if (argc == 0)
2330         {
2331         } else
2332         {
2333                 return ERROR_COMMAND_SYNTAX_ERROR;
2334         }
2335         command_print(cmd_ctx, "jtag_speed: %d", jtag_speed);
2336
2337         return retval;
2338 }
2339
2340 static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2341 {
2342         int retval=ERROR_OK;
2343         LOG_DEBUG("handle jtag khz");
2344
2345         if(argc == 1)
2346         {
2347                 speed_khz = strtoul(args[0], NULL, 0);
2348                 if (jtag != NULL)
2349                 {
2350                         int cur_speed = 0;
2351                         LOG_DEBUG("have interface set up");
2352                         int speed_div1;
2353                         if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK)
2354                         {
2355                                 speed_khz = 0;
2356                                 return retval;
2357                         }
2358
2359                         cur_speed = jtag_speed = speed_div1;
2360
2361                         retval=jtag->speed(cur_speed);
2362                 } else
2363                 {
2364                         hasKHz = 1;
2365                 }
2366         } else if (argc==0)
2367         {
2368         } else
2369         {
2370                 return ERROR_COMMAND_SYNTAX_ERROR;
2371         }
2372
2373         if (jtag!=NULL)
2374         {
2375                 if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK)
2376                         return retval;
2377         }
2378
2379         if (speed_khz==0)
2380         {
2381                 command_print(cmd_ctx, "RCLK - adaptive");
2382         } else
2383         {
2384                 command_print(cmd_ctx, "%d kHz", speed_khz);
2385         }
2386         return retval;
2387
2388 }
2389
2390 static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2391 {
2392         tap_state_t state;
2393
2394         if (argc < 1)
2395         {
2396                 return ERROR_COMMAND_SYNTAX_ERROR;
2397         }
2398         else
2399         {
2400                 state = tap_state_by_name( args[0] );
2401                 if( state < 0 ){
2402                         command_print( cmd_ctx, "Invalid state name: %s\n", args[0] );
2403                         return ERROR_COMMAND_SYNTAX_ERROR;
2404                 }
2405                 jtag_add_end_state(state);
2406                 jtag_execute_queue();
2407         }
2408         command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state));
2409
2410         return ERROR_OK;
2411 }
2412
2413 static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2414 {
2415         int trst = -1;
2416         int srst = -1;
2417
2418         if (argc < 2)
2419         {
2420                 return ERROR_COMMAND_SYNTAX_ERROR;
2421         }
2422
2423         if (args[0][0] == '1')
2424                 trst = 1;
2425         else if (args[0][0] == '0')
2426                 trst = 0;
2427         else
2428         {
2429                 return ERROR_COMMAND_SYNTAX_ERROR;
2430         }
2431
2432         if (args[1][0] == '1')
2433                 srst = 1;
2434         else if (args[1][0] == '0')
2435                 srst = 0;
2436         else
2437         {
2438                 return ERROR_COMMAND_SYNTAX_ERROR;
2439         }
2440
2441         if (jtag_interface_init(cmd_ctx) != ERROR_OK)
2442                 return ERROR_JTAG_INIT_FAILED;
2443
2444         jtag_add_reset(trst, srst);
2445         jtag_execute_queue();
2446
2447         return ERROR_OK;
2448 }
2449
2450 static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2451 {
2452         if (argc < 1)
2453         {
2454                 return ERROR_COMMAND_SYNTAX_ERROR;
2455         }
2456
2457         jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID);
2458         jtag_execute_queue();
2459
2460         return ERROR_OK;
2461
2462 }
2463
2464 /*
2465  * For "irscan" or "drscan" commands, the "end" (really, "next") state
2466  * should be stable ... and *NOT* a shift state, otherwise free-running
2467  * jtag clocks could change the values latched by the update state.
2468  */
2469 static bool scan_is_safe(tap_state_t state)
2470 {
2471         switch (state)
2472         {
2473         case TAP_RESET:
2474         case TAP_IDLE:
2475         case TAP_DRPAUSE:
2476         case TAP_IRPAUSE:
2477                 return true;
2478         default:
2479                 return false;
2480         }
2481 }
2482
2483
2484 static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2485 {
2486         int i;
2487         scan_field_t *fields;
2488         jtag_tap_t *tap;
2489         tap_state_t endstate;
2490
2491         if ((argc < 2) || (argc % 2))
2492         {
2493                 return ERROR_COMMAND_SYNTAX_ERROR;
2494         }
2495
2496         /* optional "-endstate" "statename" at the end of the arguments,
2497          * so that e.g. IRPAUSE can let us load the data register before
2498          * entering RUN/IDLE to execute the instruction we load here.
2499          */
2500         endstate = TAP_IDLE;
2501
2502         if( argc >= 4 ){
2503                 /* have at least one pair of numbers. */
2504                 /* is last pair the magic text? */
2505                 if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){
2506                         const char *cpA;
2507                         const char *cpS;
2508                         cpA = args[ argc-1 ];
2509                         for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){
2510                                 cpS = tap_state_name( endstate );
2511                                 if( 0 == strcmp( cpA, cpS ) ){
2512                                         break;
2513                                 }
2514                         }
2515                         if( endstate >= TAP_NUM_STATES ){
2516                                 return ERROR_COMMAND_SYNTAX_ERROR;
2517                         } else {
2518                                 if (!scan_is_safe(endstate))
2519                                         LOG_WARNING("irscan with unsafe "
2520                                                         "endstate \"%s\"", cpA);
2521                                 /* found - remove the last 2 args */
2522                                 argc -= 2;
2523                         }
2524                 }
2525         }
2526
2527         int num_fields = argc / 2;
2528
2529         fields = malloc(sizeof(scan_field_t) * num_fields);
2530
2531         for (i = 0; i < num_fields; i++)
2532         {
2533                 tap = jtag_TapByString( args[i*2] );
2534                 if (tap==NULL)
2535                 {
2536                         command_print( cmd_ctx, "Tap: %s unknown", args[i*2] );
2537                         return ERROR_FAIL;
2538                 }
2539                 int field_size = tap->ir_length;
2540                 fields[i].tap = tap;
2541                 fields[i].num_bits = field_size;
2542                 fields[i].out_value = malloc(CEIL(field_size, 8));
2543                 buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0));
2544                 fields[i].in_value = NULL;
2545         }
2546
2547         /* did we have an endstate? */
2548         jtag_add_ir_scan(num_fields, fields, endstate);
2549
2550         int retval=jtag_execute_queue();
2551
2552         for (i = 0; i < num_fields; i++)
2553                 free(fields[i].out_value);
2554
2555         free (fields);
2556
2557         return retval;
2558 }
2559
2560 static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2561 {
2562         int retval;
2563         scan_field_t *fields;
2564         int num_fields;
2565         int field_count = 0;
2566         int i, e;
2567         jtag_tap_t *tap;
2568         tap_state_t endstate;
2569
2570         /* args[1] = device
2571          * args[2] = num_bits
2572          * args[3] = hex string
2573          * ... repeat num bits and hex string ...
2574          *
2575          * .. optionally:
2576         *     args[N-2] = "-endstate"
2577          *     args[N-1] = statename
2578          */
2579         if ((argc < 4) || ((argc % 2)!=0))
2580         {
2581                 Jim_WrongNumArgs(interp, 1, args, "wrong arguments");
2582                 return JIM_ERR;
2583         }
2584
2585         endstate = TAP_IDLE;
2586
2587         /* validate arguments as numbers */
2588         e = JIM_OK;
2589         for (i = 2; i < argc; i+=2)
2590         {
2591                 long bits;
2592                 const char *cp;
2593
2594                 e = Jim_GetLong(interp, args[i], &bits);
2595                 /* If valid - try next arg */
2596                 if( e == JIM_OK ){
2597                         continue;
2598                 }
2599
2600                 /* Not valid.. are we at the end? */
2601                 if ( ((i+2) != argc) ){
2602                         /* nope, then error */
2603                         return e;
2604                 }
2605
2606                 /* it could be: "-endstate FOO"
2607                  * e.g. DRPAUSE so we can issue more instructions
2608                  * before entering RUN/IDLE and executing them.
2609                  */
2610
2611                 /* get arg as a string. */
2612                 cp = Jim_GetString( args[i], NULL );
2613                 /* is it the magic? */
2614                 if( 0 == strcmp( "-endstate", cp ) ){
2615                         /* is the statename valid? */
2616                         cp = Jim_GetString( args[i+1], NULL );
2617
2618                         /* see if it is a valid state name */
2619                         endstate = tap_state_by_name(cp);
2620                         if( endstate < 0 ){
2621                                 /* update the error message */
2622                                 Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp );
2623                         } else {
2624                                 if (!scan_is_safe(endstate))
2625                                         LOG_WARNING("drscan with unsafe "
2626                                                         "endstate \"%s\"", cp);
2627
2628                                 /* valid - so clear the error */
2629                                 e = JIM_OK;
2630                                 /* and remove the last 2 args */
2631                                 argc -= 2;
2632                         }
2633                 }
2634
2635                 /* Still an error? */
2636                 if( e != JIM_OK ){
2637                         return e; /* too bad */
2638                 }
2639         } /* validate args */
2640
2641         tap = jtag_TapByJimObj( interp, args[1] );
2642         if( tap == NULL ){
2643                 return JIM_ERR;
2644         }
2645
2646         num_fields=(argc-2)/2;
2647         fields = malloc(sizeof(scan_field_t) * num_fields);
2648         for (i = 2; i < argc; i+=2)
2649         {
2650                 long bits;
2651                 int len;
2652                 const char *str;
2653
2654                 Jim_GetLong(interp, args[i], &bits);
2655                 str = Jim_GetString(args[i+1], &len);
2656
2657                 fields[field_count].tap = tap;
2658                 fields[field_count].num_bits = bits;
2659                 fields[field_count].out_value = malloc(CEIL(bits, 8));
2660                 str_to_buf(str, len, fields[field_count].out_value, bits, 0);
2661                 fields[field_count].in_value = fields[field_count].out_value;
2662                 field_count++;
2663         }
2664
2665         jtag_add_dr_scan(num_fields, fields, endstate);
2666
2667         retval = jtag_execute_queue();
2668         if (retval != ERROR_OK)
2669         {
2670                 Jim_SetResultString(interp, "drscan: jtag execute failed",-1);
2671                 return JIM_ERR;
2672         }
2673
2674         field_count=0;
2675         Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
2676         for (i = 2; i < argc; i+=2)
2677         {
2678                 long bits;
2679                 char *str;
2680
2681                 Jim_GetLong(interp, args[i], &bits);
2682                 str = buf_to_str(fields[field_count].in_value, bits, 16);
2683                 free(fields[field_count].out_value);
2684
2685                 Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str)));
2686                 free(str);
2687                 field_count++;
2688         }
2689
2690         Jim_SetResult(interp, list);
2691
2692         free(fields);
2693
2694         return JIM_OK;
2695 }
2696
2697
2698 static int Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args)
2699 {
2700         Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count));
2701
2702         return JIM_OK;
2703 }
2704
2705
2706 static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2707 {
2708         if (argc == 1)
2709         {
2710                 if (strcmp(args[0], "enable") == 0)
2711                 {
2712                         jtag_verify_capture_ir = 1;
2713                 }
2714                 else if (strcmp(args[0], "disable") == 0)
2715                 {
2716                         jtag_verify_capture_ir = 0;
2717                 } else
2718                 {
2719                         return ERROR_COMMAND_SYNTAX_ERROR;
2720                 }
2721         } else if (argc != 0)
2722         {
2723                 return ERROR_COMMAND_SYNTAX_ERROR;
2724         }
2725
2726         command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled");
2727
2728         return ERROR_OK;
2729 }
2730
2731 static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2732 {
2733         if (argc == 1)
2734         {
2735                 if (strcmp(args[0], "enable") == 0)
2736                 {
2737                         jtag_verify = 1;
2738                 }
2739                 else if (strcmp(args[0], "disable") == 0)
2740                 {
2741                         jtag_verify = 0;
2742                 } else
2743                 {
2744                         return ERROR_COMMAND_SYNTAX_ERROR;
2745                 }
2746         } else if (argc != 0)
2747         {
2748                 return ERROR_COMMAND_SYNTAX_ERROR;
2749         }
2750
2751         command_print(cmd_ctx, "verify jtag capture is %s", (jtag_verify) ? "enabled": "disabled");
2752
2753         return ERROR_OK;
2754 }
2755
2756
2757 int jtag_power_dropout(int *dropout)
2758 {
2759         return jtag->power_dropout(dropout);
2760 }
2761
2762 int jtag_srst_asserted(int *srst_asserted)
2763 {
2764         return jtag->srst_asserted(srst_asserted);
2765 }
2766
2767 void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e)
2768 {
2769         jtag_tap_event_action_t * jteap;
2770         int done;
2771
2772         jteap = tap->event_action;
2773
2774         done = 0;
2775         while (jteap) {
2776                 if (jteap->event == e) {
2777                         done = 1;
2778                         LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n",
2779                                         tap->dotted_name,
2780                                         e,
2781                                         Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name,
2782                                         Jim_GetString(jteap->body, NULL) );
2783                         if (Jim_EvalObj(interp, jteap->body) != JIM_OK) {
2784                                 Jim_PrintErrorMessage(interp);
2785                         }
2786                 }
2787
2788                 jteap = jteap->next;
2789         }
2790
2791         if (!done) {
2792                 LOG_DEBUG( "event %d %s - no action",
2793                                 e,
2794                                 Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name);
2795         }
2796 }
2797
2798 static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2799 {
2800         if (argc > 1)
2801                 return ERROR_COMMAND_SYNTAX_ERROR;
2802
2803         if (argc == 1)
2804         {
2805                 bool use_new_table;
2806                 if (strcmp(args[0], "short") == 0)
2807                         use_new_table = true;
2808                 else if (strcmp(args[0], "long") == 0)
2809                         use_new_table = false;
2810                 else
2811                         return ERROR_COMMAND_SYNTAX_ERROR;
2812
2813                 tap_use_new_tms_table(use_new_table);
2814         }
2815
2816         command_print(cmd_ctx, "tms sequence is  %s",
2817                         tap_uses_new_tms_table() ? "short": "long");
2818
2819         return ERROR_OK;
2820 }
2821
2822 /**
2823  * Function jtag_add_statemove
2824  * moves from the current state to the goal \a state. This needs
2825  * to be handled according to the xsvf spec, see the XSTATE command
2826  * description.
2827  */
2828 int jtag_add_statemove(tap_state_t goal_state)
2829 {
2830         int retval = ERROR_OK;
2831
2832         tap_state_t moves[8];
2833         tap_state_t cur_state = cmd_queue_cur_state;
2834         int i;
2835         int tms_bits;
2836         int     tms_count;
2837
2838         LOG_DEBUG( "cur_state=%s goal_state=%s",
2839                 tap_state_name(cur_state),
2840                 tap_state_name(goal_state) );
2841
2842
2843         /*      From the XSVF spec, pertaining to XSTATE:
2844
2845                 For special states known as stable states (Test-Logic-Reset,
2846                 Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
2847                 predefined TAP state paths when the starting state is a stable state and
2848                 when the XSTATE specifies a new stable state (see the STATE command in
2849                 the [Ref 5] for the TAP state paths between stable states). For
2850                 non-stable states, XSTATE should specify a state that is only one TAP
2851                 state transition distance from the current TAP state to avoid undefined
2852                 TAP state paths. A sequence of multiple XSTATE commands can be issued to
2853                 transition the TAP through a specific state path.
2854         */
2855
2856         if (goal_state==cur_state )
2857                 ;       /* nothing to do */
2858
2859         else if( goal_state==TAP_RESET )
2860         {
2861                 jtag_add_tlr();
2862         }
2863
2864         else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) )
2865         {
2866                 /*      note: unless tms_bits holds a path that agrees with [Ref 5] in above
2867                         spec, then this code is not fully conformant to the xsvf spec.  This
2868                         puts a burden on tap_get_tms_path() function from the xsvf spec.
2869                         If in doubt, you should confirm that that burden is being met.
2870                 */
2871
2872                 tms_bits  = tap_get_tms_path(cur_state, goal_state);
2873                 tms_count = tap_get_tms_path_len(cur_state, goal_state);
2874
2875                 assert( (unsigned) tms_count < DIM(moves) );
2876
2877                 for (i=0;   i<tms_count;   i++, tms_bits>>=1)
2878                 {
2879                         bool bit = tms_bits & 1;
2880
2881                         cur_state = tap_state_transition(cur_state, bit);
2882                         moves[i] = cur_state;
2883                 }
2884
2885                 jtag_add_pathmove(tms_count, moves);
2886         }
2887
2888         /*      else state must be immediately reachable in one clock cycle, and does not
2889                 need to be a stable state.
2890         */
2891         else if( tap_state_transition(cur_state, true)  == goal_state
2892                 ||   tap_state_transition(cur_state, false) == goal_state )
2893         {
2894                 /* move a single state */
2895                 moves[0] = goal_state;
2896                 jtag_add_pathmove( 1, moves );
2897         }
2898
2899         else
2900         {
2901                 retval = ERROR_FAIL;
2902         }
2903
2904         return retval;
2905 }
2906