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

   1 /***************************************************************************
   2  *   Copyright (C) 2009 Zachary T Welch                                    *
   3  *   zw@superlucidity.net                                                  *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008,2009 Øyvind Harboe                            *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2009 SoftPLC Corporation                                *
   9  *       http://softplc.com                                                *
  10  *   dick@softplc.com                                                      *
  11  *                                                                         *
  12  *   Copyright (C) 2005 by Dominic Rath                                    *
  13  *   Dominic.Rath@gmx.de                                                   *
  14  *                                                                         *
  15  *   This program is free software; you can redistribute it and/or modify  *
  16  *   it under the terms of the GNU General Public License as published by  *
  17  *   the Free Software Foundation; either version 2 of the License, or     *
  18  *   (at your option) any later version.                                   *
  19  *                                                                         *
  20  *   This program is distributed in the hope that it will be useful,       *
  21  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  22  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  23  *   GNU General Public License for more details.                          *
  24  *                                                                         *
  25  *   You should have received a copy of the GNU General Public License     *
  26  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  27  ***************************************************************************/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include "jtag.h"
  34 #include "swd.h"
  35 #include "interface.h"
  36 #include <transport/transport.h>
  37 #include <helper/jep106.h>
  38
  39 #ifdef HAVE_STRINGS_H
  40 #include <strings.h>
  41 #endif
  42
  43 /* SVF and XSVF are higher level JTAG command sets (for boundary scan) */
  44 #include "svf/svf.h"
  45 #include "xsvf/xsvf.h"
  46
  47 /** The number of JTAG queue flushes (for profiling and debugging purposes). */
  48 static int jtag_flush_queue_count;
  49
  50 /* Sleep this # of ms after flushing the queue */
  51 static int jtag_flush_queue_sleep;
  52
  53 static void jtag_add_scan_check(struct jtag_tap *active,
  54                 void (*jtag_add_scan)(struct jtag_tap *active,
  55                 int in_num_fields,
  56                 const struct scan_field *in_fields,
  57                 tap_state_t state),
  58                 int in_num_fields, struct scan_field *in_fields, tap_state_t state);
  59
  60 /**
  61  * The jtag_error variable is set when an error occurs while executing
  62  * the queue.  Application code may set this using jtag_set_error(),
  63  * when an error occurs during processing that should be reported during
  64  * jtag_execute_queue().
  65  *
  66  * The value is set and cleared, but never read by normal application code.
  67  *
  68  * This value is returned (and cleared) by jtag_execute_queue().
  69  */
  70 static int jtag_error = ERROR_OK;
  71
  72 static const char *jtag_event_strings[] = {
  73         [JTAG_TRST_ASSERTED] = "TAP reset",
  74         [JTAG_TAP_EVENT_SETUP] = "TAP setup",
  75         [JTAG_TAP_EVENT_ENABLE] = "TAP enabled",
  76         [JTAG_TAP_EVENT_DISABLE] = "TAP disabled",
  77 };
  78
  79 /*
  80  * JTAG adapters must initialize with TRST and SRST de-asserted
  81  * (they're negative logic, so that means *high*).  But some
  82  * hardware doesn't necessarily work that way ... so set things
  83  * up so that jtag_init() always forces that state.
  84  */
  85 static int jtag_trst = -1;
  86 static int jtag_srst = -1;
  87
  88 /**
  89  * List all TAPs that have been created.
  90  */
  91 static struct jtag_tap *__jtag_all_taps;
  92
  93 static enum reset_types jtag_reset_config = RESET_NONE;
  94 tap_state_t cmd_queue_cur_state = TAP_RESET;
  95
  96 static bool jtag_verify_capture_ir = true;
  97 static int jtag_verify = 1;
  98
  99 /* how long the OpenOCD should wait before attempting JTAG communication after reset lines
 100  *deasserted (in ms) */
 101 static int adapter_nsrst_delay; /* default to no nSRST delay */
 102 static int jtag_ntrst_delay;/* default to no nTRST delay */
 103 static int adapter_nsrst_assert_width;  /* width of assertion */
 104 static int jtag_ntrst_assert_width;     /* width of assertion */
 105
 106 /**
 107  * Contains a single callback along with a pointer that will be passed
 108  * when an event occurs.
 109  */
 110 struct jtag_event_callback {
 111         /** a event callback */
 112         jtag_event_handler_t callback;
 113         /** the private data to pass to the callback */
 114         void *priv;
 115         /** the next callback */
 116         struct jtag_event_callback *next;
 117 };
 118
 119 /* callbacks to inform high-level handlers about JTAG state changes */
 120 static struct jtag_event_callback *jtag_event_callbacks;
 121
 122 /* speed in kHz*/
 123 static int speed_khz;
 124 /* speed to fallback to when RCLK is requested but not supported */
 125 static int rclk_fallback_speed_khz;
 126 static enum {CLOCK_MODE_UNSELECTED, CLOCK_MODE_KHZ, CLOCK_MODE_RCLK} clock_mode;
 127 static int jtag_speed;
 128
 129 /* FIXME: change name to this variable, it is not anymore JTAG only */
 130 static struct adapter_driver *jtag;
 131
 132 extern struct adapter_driver *adapter_driver;
 133
 134 void jtag_set_flush_queue_sleep(int ms)
 135 {
 136         jtag_flush_queue_sleep = ms;
 137 }
 138
 139 void jtag_set_error(int error)
 140 {
 141         if ((error == ERROR_OK) || (jtag_error != ERROR_OK))
 142                 return;
 143         jtag_error = error;
 144 }
 145
 146 int jtag_error_clear(void)
 147 {
 148         int temp = jtag_error;
 149         jtag_error = ERROR_OK;
 150         return temp;
 151 }
 152
 153 /************/
 154
 155 static bool jtag_poll = 1;
 156
 157 bool is_jtag_poll_safe(void)
 158 {
 159         /* Polling can be disabled explicitly with set_enabled(false).
 160          * It is also implicitly disabled while TRST is active and
 161          * while SRST is gating the JTAG clock.
 162          */
 163         if (!transport_is_jtag())
 164                 return jtag_poll;
 165
 166         if (!jtag_poll || jtag_trst != 0)
 167                 return false;
 168         return jtag_srst == 0 || (jtag_reset_config & RESET_SRST_NO_GATING);
 169 }
 170
 171 bool jtag_poll_get_enabled(void)
 172 {
 173         return jtag_poll;
 174 }
 175
 176 void jtag_poll_set_enabled(bool value)
 177 {
 178         jtag_poll = value;
 179 }
 180
 181 /************/
 182
 183 struct jtag_tap *jtag_all_taps(void)
 184 {
 185         return __jtag_all_taps;
 186 };
 187
 188 unsigned jtag_tap_count(void)
 189 {
 190         struct jtag_tap *t = jtag_all_taps();
 191         unsigned n = 0;
 192         while (t) {
 193                 n++;
 194                 t = t->next_tap;
 195         }
 196         return n;
 197 }
 198
 199 unsigned jtag_tap_count_enabled(void)
 200 {
 201         struct jtag_tap *t = jtag_all_taps();
 202         unsigned n = 0;
 203         while (t) {
 204                 if (t->enabled)
 205                         n++;
 206                 t = t->next_tap;
 207         }
 208         return n;
 209 }
 210
 211 /** Append a new TAP to the chain of all taps. */
 212 void jtag_tap_add(struct jtag_tap *t)
 213 {
 214         unsigned jtag_num_taps = 0;
 215
 216         struct jtag_tap **tap = &__jtag_all_taps;
 217         while (*tap != NULL) {
 218                 jtag_num_taps++;
 219                 tap = &(*tap)->next_tap;
 220         }
 221         *tap = t;
 222         t->abs_chain_position = jtag_num_taps;
 223 }
 224
 225 /* returns a pointer to the n-th device in the scan chain */
 226 struct jtag_tap *jtag_tap_by_position(unsigned n)
 227 {
 228         struct jtag_tap *t = jtag_all_taps();
 229
 230         while (t && n-- > 0)
 231                 t = t->next_tap;
 232
 233         return t;
 234 }
 235
 236 struct jtag_tap *jtag_tap_by_string(const char *s)
 237 {
 238         /* try by name first */
 239         struct jtag_tap *t = jtag_all_taps();
 240
 241         while (t) {
 242                 if (0 == strcmp(t->dotted_name, s))
 243                         return t;
 244                 t = t->next_tap;
 245         }
 246
 247         /* no tap found by name, so try to parse the name as a number */
 248         unsigned n;
 249         if (parse_uint(s, &n) != ERROR_OK)
 250                 return NULL;
 251
 252         /* FIXME remove this numeric fallback code late June 2010, along
 253          * with all info in the User's Guide that TAPs have numeric IDs.
 254          * Also update "scan_chain" output to not display the numbers.
 255          */
 256         t = jtag_tap_by_position(n);
 257         if (t)
 258                 LOG_WARNING("Specify TAP '%s' by name, not number %u",
 259                         t->dotted_name, n);
 260
 261         return t;
 262 }
 263
 264 struct jtag_tap *jtag_tap_next_enabled(struct jtag_tap *p)
 265 {
 266         p = p ? p->next_tap : jtag_all_taps();
 267         while (p) {
 268                 if (p->enabled)
 269                         return p;
 270                 p = p->next_tap;
 271         }
 272         return NULL;
 273 }
 274
 275 const char *jtag_tap_name(const struct jtag_tap *tap)
 276 {
 277         return (tap == NULL) ? "(unknown)" : tap->dotted_name;
 278 }
 279
 280
 281 int jtag_register_event_callback(jtag_event_handler_t callback, void *priv)
 282 {
 283         struct jtag_event_callback **callbacks_p = &jtag_event_callbacks;
 284
 285         if (callback == NULL)
 286                 return ERROR_COMMAND_SYNTAX_ERROR;
 287
 288         if (*callbacks_p) {
 289                 while ((*callbacks_p)->next)
 290                         callbacks_p = &((*callbacks_p)->next);
 291                 callbacks_p = &((*callbacks_p)->next);
 292         }
 293
 294         (*callbacks_p) = malloc(sizeof(struct jtag_event_callback));
 295         (*callbacks_p)->callback = callback;
 296         (*callbacks_p)->priv = priv;
 297         (*callbacks_p)->next = NULL;
 298
 299         return ERROR_OK;
 300 }
 301
 302 int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv)
 303 {
 304         struct jtag_event_callback **p = &jtag_event_callbacks, *temp;
 305
 306         if (callback == NULL)
 307                 return ERROR_COMMAND_SYNTAX_ERROR;
 308
 309         while (*p) {
 310                 if (((*p)->priv != priv) || ((*p)->callback != callback)) {
 311                         p = &(*p)->next;
 312                         continue;
 313                 }
 314
 315                 temp = *p;
 316                 *p = (*p)->next;
 317                 free(temp);
 318         }
 319
 320         return ERROR_OK;
 321 }
 322
 323 int jtag_call_event_callbacks(enum jtag_event event)
 324 {
 325         struct jtag_event_callback *callback = jtag_event_callbacks;
 326
 327         LOG_DEBUG("jtag event: %s", jtag_event_strings[event]);
 328
 329         while (callback) {
 330                 struct jtag_event_callback *next;
 331
 332                 /* callback may remove itself */
 333                 next = callback->next;
 334                 callback->callback(event, callback->priv);
 335                 callback = next;
 336         }
 337
 338         return ERROR_OK;
 339 }
 340
 341 static void jtag_checks(void)
 342 {
 343         assert(jtag_trst == 0);
 344 }
 345
 346 static void jtag_prelude(tap_state_t state)
 347 {
 348         jtag_checks();
 349
 350         assert(state != TAP_INVALID);
 351
 352         cmd_queue_cur_state = state;
 353 }
 354
 355 void jtag_add_ir_scan_noverify(struct jtag_tap *active, const struct scan_field *in_fields,
 356         tap_state_t state)
 357 {
 358         jtag_prelude(state);
 359
 360         int retval = interface_jtag_add_ir_scan(active, in_fields, state);
 361         jtag_set_error(retval);
 362 }
 363
 364 static void jtag_add_ir_scan_noverify_callback(struct jtag_tap *active,
 365         int dummy,
 366         const struct scan_field *in_fields,
 367         tap_state_t state)
 368 {
 369         jtag_add_ir_scan_noverify(active, in_fields, state);
 370 }
 371
 372 /* If fields->in_value is filled out, then the captured IR value will be checked */
 373 void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap_state_t state)
 374 {
 375         assert(state != TAP_RESET);
 376
 377         if (jtag_verify && jtag_verify_capture_ir) {
 378                 /* 8 x 32 bit id's is enough for all invocations */
 379
 380                 /* if we are to run a verification of the ir scan, we need to get the input back.
 381                  * We may have to allocate space if the caller didn't ask for the input back.
 382                  */
 383                 in_fields->check_value = active->expected;
 384                 in_fields->check_mask = active->expected_mask;
 385                 jtag_add_scan_check(active, jtag_add_ir_scan_noverify_callback, 1, in_fields,
 386                         state);
 387         } else
 388                 jtag_add_ir_scan_noverify(active, in_fields, state);
 389 }
 390
 391 void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits,
 392         tap_state_t state)
 393 {
 394         assert(out_bits != NULL);
 395         assert(state != TAP_RESET);
 396
 397         jtag_prelude(state);
 398
 399         int retval = interface_jtag_add_plain_ir_scan(
 400                         num_bits, out_bits, in_bits, state);
 401         jtag_set_error(retval);
 402 }
 403
 404 static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
 405                                   uint8_t *in_check_mask, int num_bits);
 406
 407 static int jtag_check_value_mask_callback(jtag_callback_data_t data0,
 408         jtag_callback_data_t data1,
 409         jtag_callback_data_t data2,
 410         jtag_callback_data_t data3)
 411 {
 412         return jtag_check_value_inner((uint8_t *)data0,
 413                 (uint8_t *)data1,
 414                 (uint8_t *)data2,
 415                 (int)data3);
 416 }
 417
 418 static void jtag_add_scan_check(struct jtag_tap *active, void (*jtag_add_scan)(
 419                 struct jtag_tap *active,
 420                 int in_num_fields,
 421                 const struct scan_field *in_fields,
 422                 tap_state_t state),
 423         int in_num_fields, struct scan_field *in_fields, tap_state_t state)
 424 {
 425         jtag_add_scan(active, in_num_fields, in_fields, state);
 426
 427         for (int i = 0; i < in_num_fields; i++) {
 428                 if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL)) {
 429                         /* this is synchronous for a minidriver */
 430                         jtag_add_callback4(jtag_check_value_mask_callback,
 431                                 (jtag_callback_data_t)in_fields[i].in_value,
 432                                 (jtag_callback_data_t)in_fields[i].check_value,
 433                                 (jtag_callback_data_t)in_fields[i].check_mask,
 434                                 (jtag_callback_data_t)in_fields[i].num_bits);
 435                 }
 436         }
 437 }
 438
 439 void jtag_add_dr_scan_check(struct jtag_tap *active,
 440         int in_num_fields,
 441         struct scan_field *in_fields,
 442         tap_state_t state)
 443 {
 444         if (jtag_verify)
 445                 jtag_add_scan_check(active, jtag_add_dr_scan, in_num_fields, in_fields, state);
 446         else
 447                 jtag_add_dr_scan(active, in_num_fields, in_fields, state);
 448 }
 449
 450
 451 void jtag_add_dr_scan(struct jtag_tap *active,
 452         int in_num_fields,
 453         const struct scan_field *in_fields,
 454         tap_state_t state)
 455 {
 456         assert(state != TAP_RESET);
 457
 458         jtag_prelude(state);
 459
 460         int retval;
 461         retval = interface_jtag_add_dr_scan(active, in_num_fields, in_fields, state);
 462         jtag_set_error(retval);
 463 }
 464
 465 void jtag_add_plain_dr_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits,
 466         tap_state_t state)
 467 {
 468         assert(out_bits != NULL);
 469         assert(state != TAP_RESET);
 470
 471         jtag_prelude(state);
 472
 473         int retval;
 474         retval = interface_jtag_add_plain_dr_scan(num_bits, out_bits, in_bits, state);
 475         jtag_set_error(retval);
 476 }
 477
 478 void jtag_add_tlr(void)
 479 {
 480         jtag_prelude(TAP_RESET);
 481         jtag_set_error(interface_jtag_add_tlr());
 482
 483         /* NOTE: order here matches TRST path in jtag_add_reset() */
 484         jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 485         jtag_notify_event(JTAG_TRST_ASSERTED);
 486 }
 487
 488 /**
 489  * If supported by the underlying adapter, this clocks a raw bit sequence
 490  * onto TMS for switching betwen JTAG and SWD modes.
 491  *
 492  * DO NOT use this to bypass the integrity checks and logging provided
 493  * by the jtag_add_pathmove() and jtag_add_statemove() calls.
 494  *
 495  * @param nbits How many bits to clock out.
 496  * @param seq The bit sequence.  The LSB is bit 0 of seq[0].
 497  * @param state The JTAG tap state to record on completion.  Use
 498  *      TAP_INVALID to represent being in in SWD mode.
 499  *
 500  * @todo Update naming conventions to stop assuming everything is JTAG.
 501  */
 502 int jtag_add_tms_seq(unsigned nbits, const uint8_t *seq, enum tap_state state)
 503 {
 504         int retval;
 505
 506         if (!(jtag->jtag_ops->supported & DEBUG_CAP_TMS_SEQ))
 507                 return ERROR_JTAG_NOT_IMPLEMENTED;
 508
 509         jtag_checks();
 510         cmd_queue_cur_state = state;
 511
 512         retval = interface_add_tms_seq(nbits, seq, state);
 513         jtag_set_error(retval);
 514         return retval;
 515 }
 516
 517 void jtag_add_pathmove(int num_states, const tap_state_t *path)
 518 {
 519         tap_state_t cur_state = cmd_queue_cur_state;
 520
 521         /* the last state has to be a stable state */
 522         if (!tap_is_state_stable(path[num_states - 1])) {
 523                 LOG_ERROR("BUG: TAP path doesn't finish in a stable state");
 524                 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
 525                 return;
 526         }
 527
 528         for (int i = 0; i < num_states; i++) {
 529                 if (path[i] == TAP_RESET) {
 530                         LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences");
 531                         jtag_set_error(ERROR_JTAG_STATE_INVALID);
 532                         return;
 533                 }
 534
 535                 if (tap_state_transition(cur_state, true) != path[i] &&
 536                                 tap_state_transition(cur_state, false) != path[i]) {
 537                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
 538                                 tap_state_name(cur_state), tap_state_name(path[i]));
 539                         jtag_set_error(ERROR_JTAG_TRANSITION_INVALID);
 540                         return;
 541                 }
 542                 cur_state = path[i];
 543         }
 544
 545         jtag_checks();
 546
 547         jtag_set_error(interface_jtag_add_pathmove(num_states, path));
 548         cmd_queue_cur_state = path[num_states - 1];
 549 }
 550
 551 int jtag_add_statemove(tap_state_t goal_state)
 552 {
 553         tap_state_t cur_state = cmd_queue_cur_state;
 554
 555         if (goal_state != cur_state) {
 556                 LOG_DEBUG("cur_state=%s goal_state=%s",
 557                         tap_state_name(cur_state),
 558                         tap_state_name(goal_state));
 559         }
 560
 561         /* If goal is RESET, be paranoid and force that that transition
 562          * (e.g. five TCK cycles, TMS high).  Else trust "cur_state".
 563          */
 564         if (goal_state == TAP_RESET)
 565                 jtag_add_tlr();
 566         else if (goal_state == cur_state)
 567                 /* nothing to do */;
 568
 569         else if (tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state)) {
 570                 unsigned tms_bits  = tap_get_tms_path(cur_state, goal_state);
 571                 unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state);
 572                 tap_state_t moves[8];
 573                 assert(tms_count < ARRAY_SIZE(moves));
 574
 575                 for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) {
 576                         bool bit = tms_bits & 1;
 577
 578                         cur_state = tap_state_transition(cur_state, bit);
 579                         moves[i] = cur_state;
 580                 }
 581
 582                 jtag_add_pathmove(tms_count, moves);
 583         } else if (tap_state_transition(cur_state, true)  == goal_state
 584                         || tap_state_transition(cur_state, false) == goal_state)
 585                 jtag_add_pathmove(1, &goal_state);
 586         else
 587                 return ERROR_FAIL;
 588
 589         return ERROR_OK;
 590 }
 591
 592 void jtag_add_runtest(int num_cycles, tap_state_t state)
 593 {
 594         jtag_prelude(state);
 595         jtag_set_error(interface_jtag_add_runtest(num_cycles, state));
 596 }
 597
 598
 599 void jtag_add_clocks(int num_cycles)
 600 {
 601         if (!tap_is_state_stable(cmd_queue_cur_state)) {
 602                 LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"",
 603                         tap_state_name(cmd_queue_cur_state));
 604                 jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE);
 605                 return;
 606         }
 607
 608         if (num_cycles > 0) {
 609                 jtag_checks();
 610                 jtag_set_error(interface_jtag_add_clocks(num_cycles));
 611         }
 612 }
 613
 614 static int adapter_system_reset(int req_srst)
 615 {
 616         int retval;
 617
 618         if (req_srst) {
 619                 if (!(jtag_reset_config & RESET_HAS_SRST)) {
 620                         LOG_ERROR("BUG: can't assert SRST");
 621                         return ERROR_FAIL;
 622                 }
 623                 req_srst = 1;
 624         }
 625
 626         /* Maybe change SRST signal state */
 627         if (jtag_srst != req_srst) {
 628                 retval = jtag->reset(0, req_srst);
 629                 if (retval != ERROR_OK) {
 630                         LOG_ERROR("SRST error");
 631                         return ERROR_FAIL;
 632                 }
 633                 jtag_srst = req_srst;
 634
 635                 if (req_srst) {
 636                         LOG_DEBUG("SRST line asserted");
 637                         if (adapter_nsrst_assert_width)
 638                                 jtag_sleep(adapter_nsrst_assert_width * 1000);
 639                 } else {
 640                         LOG_DEBUG("SRST line released");
 641                         if (adapter_nsrst_delay)
 642                                 jtag_sleep(adapter_nsrst_delay * 1000);
 643                 }
 644         }
 645
 646         return ERROR_OK;
 647 }
 648
 649 static void legacy_jtag_add_reset(int req_tlr_or_trst, int req_srst)
 650 {
 651         int trst_with_tlr = 0;
 652         int new_srst = 0;
 653         int new_trst = 0;
 654
 655         /* Without SRST, we must use target-specific JTAG operations
 656          * on each target; callers should not be requesting SRST when
 657          * that signal doesn't exist.
 658          *
 659          * RESET_SRST_PULLS_TRST is a board or chip level quirk, which
 660          * can kick in even if the JTAG adapter can't drive TRST.
 661          */
 662         if (req_srst) {
 663                 if (!(jtag_reset_config & RESET_HAS_SRST)) {
 664                         LOG_ERROR("BUG: can't assert SRST");
 665                         jtag_set_error(ERROR_FAIL);
 666                         return;
 667                 }
 668                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) != 0
 669                                 && !req_tlr_or_trst) {
 670                         LOG_ERROR("BUG: can't assert only SRST");
 671                         jtag_set_error(ERROR_FAIL);
 672                         return;
 673                 }
 674                 new_srst = 1;
 675         }
 676
 677         /* JTAG reset (entry to TAP_RESET state) can always be achieved
 678          * using TCK and TMS; that may go through a TAP_{IR,DR}UPDATE
 679          * state first.  TRST accelerates it, and bypasses those states.
 680          *
 681          * RESET_TRST_PULLS_SRST is a board or chip level quirk, which
 682          * can kick in even if the JTAG adapter can't drive SRST.
 683          */
 684         if (req_tlr_or_trst) {
 685                 if (!(jtag_reset_config & RESET_HAS_TRST))
 686                         trst_with_tlr = 1;
 687                 else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0
 688                          && !req_srst)
 689                         trst_with_tlr = 1;
 690                 else
 691                         new_trst = 1;
 692         }
 693
 694         /* Maybe change TRST and/or SRST signal state */
 695         if (jtag_srst != new_srst || jtag_trst != new_trst) {
 696                 int retval;
 697
 698                 retval = interface_jtag_add_reset(new_trst, new_srst);
 699                 if (retval != ERROR_OK)
 700                         jtag_set_error(retval);
 701                 else
 702                         retval = jtag_execute_queue();
 703
 704                 if (retval != ERROR_OK) {
 705                         LOG_ERROR("TRST/SRST error");
 706                         return;
 707                 }
 708         }
 709
 710         /* SRST resets everything hooked up to that signal */
 711         if (jtag_srst != new_srst) {
 712                 jtag_srst = new_srst;
 713                 if (jtag_srst) {
 714                         LOG_DEBUG("SRST line asserted");
 715                         if (adapter_nsrst_assert_width)
 716                                 jtag_add_sleep(adapter_nsrst_assert_width * 1000);
 717                 } else {
 718                         LOG_DEBUG("SRST line released");
 719                         if (adapter_nsrst_delay)
 720                                 jtag_add_sleep(adapter_nsrst_delay * 1000);
 721                 }
 722         }
 723
 724         /* Maybe enter the JTAG TAP_RESET state ...
 725          *  - using only TMS, TCK, and the JTAG state machine
 726          *  - or else more directly, using TRST
 727          *
 728          * TAP_RESET should be invisible to non-debug parts of the system.
 729          */
 730         if (trst_with_tlr) {
 731                 LOG_DEBUG("JTAG reset with TLR instead of TRST");
 732                 jtag_add_tlr();
 733
 734         } else if (jtag_trst != new_trst) {
 735                 jtag_trst = new_trst;
 736                 if (jtag_trst) {
 737                         LOG_DEBUG("TRST line asserted");
 738                         tap_set_state(TAP_RESET);
 739                         if (jtag_ntrst_assert_width)
 740                                 jtag_add_sleep(jtag_ntrst_assert_width * 1000);
 741                 } else {
 742                         LOG_DEBUG("TRST line released");
 743                         if (jtag_ntrst_delay)
 744                                 jtag_add_sleep(jtag_ntrst_delay * 1000);
 745
 746                         /* We just asserted nTRST, so we're now in TAP_RESET.
 747                          * Inform possible listeners about this, now that
 748                          * JTAG instructions and data can be shifted.  This
 749                          * sequence must match jtag_add_tlr().
 750                          */
 751                         jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 752                         jtag_notify_event(JTAG_TRST_ASSERTED);
 753                 }
 754         }
 755 }
 756
 757 /* FIXME: name is misleading; we do not plan to "add" reset into jtag queue */
 758 void jtag_add_reset(int req_tlr_or_trst, int req_srst)
 759 {
 760         int retval;
 761         int trst_with_tlr = 0;
 762         int new_srst = 0;
 763         int new_trst = 0;
 764
 765         if (!jtag->reset) {
 766                 legacy_jtag_add_reset(req_tlr_or_trst, req_srst);
 767                 return;
 768         }
 769
 770         /* Without SRST, we must use target-specific JTAG operations
 771          * on each target; callers should not be requesting SRST when
 772          * that signal doesn't exist.
 773          *
 774          * RESET_SRST_PULLS_TRST is a board or chip level quirk, which
 775          * can kick in even if the JTAG adapter can't drive TRST.
 776          */
 777         if (req_srst) {
 778                 if (!(jtag_reset_config & RESET_HAS_SRST)) {
 779                         LOG_ERROR("BUG: can't assert SRST");
 780                         jtag_set_error(ERROR_FAIL);
 781                         return;
 782                 }
 783                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) != 0
 784                                 && !req_tlr_or_trst) {
 785                         LOG_ERROR("BUG: can't assert only SRST");
 786                         jtag_set_error(ERROR_FAIL);
 787                         return;
 788                 }
 789                 new_srst = 1;
 790         }
 791
 792         /* JTAG reset (entry to TAP_RESET state) can always be achieved
 793          * using TCK and TMS; that may go through a TAP_{IR,DR}UPDATE
 794          * state first.  TRST accelerates it, and bypasses those states.
 795          *
 796          * RESET_TRST_PULLS_SRST is a board or chip level quirk, which
 797          * can kick in even if the JTAG adapter can't drive SRST.
 798          */
 799         if (req_tlr_or_trst) {
 800                 if (!(jtag_reset_config & RESET_HAS_TRST))
 801                         trst_with_tlr = 1;
 802                 else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0
 803                          && !req_srst)
 804                         trst_with_tlr = 1;
 805                 else
 806                         new_trst = 1;
 807         }
 808
 809         /* Maybe change TRST and/or SRST signal state */
 810         if (jtag_srst != new_srst || jtag_trst != new_trst) {
 811                 /* guarantee jtag queue empty before changing reset status */
 812                 jtag_execute_queue();
 813
 814                 retval = jtag->reset(new_trst, new_srst);
 815                 if (retval != ERROR_OK) {
 816                         jtag_set_error(retval);
 817                         LOG_ERROR("TRST/SRST error");
 818                         return;
 819                 }
 820         }
 821
 822         /* SRST resets everything hooked up to that signal */
 823         if (jtag_srst != new_srst) {
 824                 jtag_srst = new_srst;
 825                 if (jtag_srst) {
 826                         LOG_DEBUG("SRST line asserted");
 827                         if (adapter_nsrst_assert_width)
 828                                 jtag_add_sleep(adapter_nsrst_assert_width * 1000);
 829                 } else {
 830                         LOG_DEBUG("SRST line released");
 831                         if (adapter_nsrst_delay)
 832                                 jtag_add_sleep(adapter_nsrst_delay * 1000);
 833                 }
 834         }
 835
 836         /* Maybe enter the JTAG TAP_RESET state ...
 837          *  - using only TMS, TCK, and the JTAG state machine
 838          *  - or else more directly, using TRST
 839          *
 840          * TAP_RESET should be invisible to non-debug parts of the system.
 841          */
 842         if (trst_with_tlr) {
 843                 LOG_DEBUG("JTAG reset with TLR instead of TRST");
 844                 jtag_add_tlr();
 845                 jtag_execute_queue();
 846
 847         } else if (jtag_trst != new_trst) {
 848                 jtag_trst = new_trst;
 849                 if (jtag_trst) {
 850                         LOG_DEBUG("TRST line asserted");
 851                         tap_set_state(TAP_RESET);
 852                         if (jtag_ntrst_assert_width)
 853                                 jtag_add_sleep(jtag_ntrst_assert_width * 1000);
 854                 } else {
 855                         LOG_DEBUG("TRST line released");
 856                         if (jtag_ntrst_delay)
 857                                 jtag_add_sleep(jtag_ntrst_delay * 1000);
 858
 859                         /* We just asserted nTRST, so we're now in TAP_RESET.
 860                          * Inform possible listeners about this, now that
 861                          * JTAG instructions and data can be shifted.  This
 862                          * sequence must match jtag_add_tlr().
 863                          */
 864                         jtag_call_event_callbacks(JTAG_TRST_ASSERTED);
 865                         jtag_notify_event(JTAG_TRST_ASSERTED);
 866                 }
 867         }
 868 }
 869
 870 void jtag_add_sleep(uint32_t us)
 871 {
 872         /** @todo Here, keep_alive() appears to be a layering violation!!! */
 873         keep_alive();
 874         jtag_set_error(interface_jtag_add_sleep(us));
 875 }
 876
 877 static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value,
 878         uint8_t *in_check_mask, int num_bits)
 879 {
 880         int retval = ERROR_OK;
 881         int compare_failed;
 882
 883         if (in_check_mask)
 884                 compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits);
 885         else
 886                 compare_failed = buf_cmp(captured, in_check_value, num_bits);
 887
 888         if (compare_failed) {
 889                 char *captured_str, *in_check_value_str;
 890                 int bits = (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits;
 891
 892                 /* NOTE:  we've lost diagnostic context here -- 'which tap' */
 893
 894                 captured_str = buf_to_str(captured, bits, 16);
 895                 in_check_value_str = buf_to_str(in_check_value, bits, 16);
 896
 897                 LOG_WARNING("Bad value '%s' captured during DR or IR scan:",
 898                         captured_str);
 899                 LOG_WARNING(" check_value: 0x%s", in_check_value_str);
 900
 901                 free(captured_str);
 902                 free(in_check_value_str);
 903
 904                 if (in_check_mask) {
 905                         char *in_check_mask_str;
 906
 907                         in_check_mask_str = buf_to_str(in_check_mask, bits, 16);
 908                         LOG_WARNING(" check_mask: 0x%s", in_check_mask_str);
 909                         free(in_check_mask_str);
 910                 }
 911
 912                 retval = ERROR_JTAG_QUEUE_FAILED;
 913         }
 914         return retval;
 915 }
 916
 917 void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask)
 918 {
 919         assert(field->in_value != NULL);
 920
 921         if (value == NULL) {
 922                 /* no checking to do */
 923                 return;
 924         }
 925
 926         jtag_execute_queue_noclear();
 927
 928         int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits);
 929         jtag_set_error(retval);
 930 }
 931
 932 int default_interface_jtag_execute_queue(void)
 933 {
 934         if (NULL == jtag) {
 935                 LOG_ERROR("No JTAG interface configured yet.  "
 936                         "Issue 'init' command in startup scripts "
 937                         "before communicating with targets.");
 938                 return ERROR_FAIL;
 939         }
 940
 941         if (!transport_is_jtag()) {
 942                 /*
 943                  * FIXME: This should not happen!
 944                  * There could be old code that queues jtag commands with non jtag interfaces so, for
 945                  * the moment simply highlight it by log an error and return on empty execute_queue.
 946                  * We should fix it quitting with assert(0) because it is an internal error.
 947                  * The fix can be applied immediately after next release (v0.11.0 ?)
 948                  */
 949                 LOG_ERROR("JTAG API jtag_execute_queue() called on non JTAG interface");
 950                 if (!jtag->jtag_ops || !jtag->jtag_ops->execute_queue)
 951                         return ERROR_OK;
 952         }
 953
 954         int result = jtag->jtag_ops->execute_queue();
 955
 956 #if !BUILD_ZY1000
 957         /* Only build this if we use a regular driver with a command queue.
 958          * Otherwise jtag_command_queue won't be found at compile/link time. Its
 959          * definition is in jtag/commands.c, which is only built/linked by
 960          * jtag/Makefile.am if MINIDRIVER_DUMMY || !MINIDRIVER, but those variables
 961          * aren't accessible here. */
 962         struct jtag_command *cmd = jtag_command_queue;
 963         while (debug_level >= LOG_LVL_DEBUG && cmd) {
 964                 switch (cmd->type) {
 965                         case JTAG_SCAN:
 966                                 LOG_DEBUG_IO("JTAG %s SCAN to %s",
 967                                                 cmd->cmd.scan->ir_scan ? "IR" : "DR",
 968                                                 tap_state_name(cmd->cmd.scan->end_state));
 969                                 for (int i = 0; i < cmd->cmd.scan->num_fields; i++) {
 970                                         struct scan_field *field = cmd->cmd.scan->fields + i;
 971                                         if (field->out_value) {
 972                                                 char *str = buf_to_str(field->out_value, field->num_bits, 16);
 973                                                 LOG_DEBUG_IO("  %db out: %s", field->num_bits, str);
 974                                                 free(str);
 975                                         }
 976                                         if (field->in_value) {
 977                                                 char *str = buf_to_str(field->in_value, field->num_bits, 16);
 978                                                 LOG_DEBUG_IO("  %db  in: %s", field->num_bits, str);
 979                                                 free(str);
 980                                         }
 981                                 }
 982                                 break;
 983                         case JTAG_TLR_RESET:
 984                                 LOG_DEBUG_IO("JTAG TLR RESET to %s",
 985                                                 tap_state_name(cmd->cmd.statemove->end_state));
 986                                 break;
 987                         case JTAG_RUNTEST:
 988                                 LOG_DEBUG_IO("JTAG RUNTEST %d cycles to %s",
 989                                                 cmd->cmd.runtest->num_cycles,
 990                                                 tap_state_name(cmd->cmd.runtest->end_state));
 991                                 break;
 992                         case JTAG_RESET:
 993                                 {
 994                                         const char *reset_str[3] = {
 995                                                 "leave", "deassert", "assert"
 996                                         };
 997                                         LOG_DEBUG_IO("JTAG RESET %s TRST, %s SRST",
 998                                                         reset_str[cmd->cmd.reset->trst + 1],
 999                                                         reset_str[cmd->cmd.reset->srst + 1]);
1000                                 }
1001                                 break;
1002                         case JTAG_PATHMOVE:
1003                                 LOG_DEBUG_IO("JTAG PATHMOVE (TODO)");
1004                                 break;
1005                         case JTAG_SLEEP:
1006                                 LOG_DEBUG_IO("JTAG SLEEP (TODO)");
1007                                 break;
1008                         case JTAG_STABLECLOCKS:
1009                                 LOG_DEBUG_IO("JTAG STABLECLOCKS (TODO)");
1010                                 break;
1011                         case JTAG_TMS:
1012                                 LOG_DEBUG_IO("JTAG TMS (TODO)");
1013                                 break;
1014                         default:
1015                                 LOG_ERROR("Unknown JTAG command: %d", cmd->type);
1016                                 break;
1017                 }
1018                 cmd = cmd->next;
1019         }
1020 #endif
1021
1022         return result;
1023 }
1024
1025 void jtag_execute_queue_noclear(void)
1026 {
1027         jtag_flush_queue_count++;
1028         jtag_set_error(interface_jtag_execute_queue());
1029
1030         if (jtag_flush_queue_sleep > 0) {
1031                 /* For debug purposes it can be useful to test performance
1032                  * or behavior when delaying after flushing the queue,
1033                  * e.g. to simulate long roundtrip times.
1034                  */
1035                 usleep(jtag_flush_queue_sleep * 1000);
1036         }
1037 }
1038
1039 int jtag_get_flush_queue_count(void)
1040 {
1041         return jtag_flush_queue_count;
1042 }
1043
1044 int jtag_execute_queue(void)
1045 {
1046         jtag_execute_queue_noclear();
1047         return jtag_error_clear();
1048 }
1049
1050 static int jtag_reset_callback(enum jtag_event event, void *priv)
1051 {
1052         struct jtag_tap *tap = priv;
1053
1054         if (event == JTAG_TRST_ASSERTED) {
1055                 tap->enabled = !tap->disabled_after_reset;
1056
1057                 /* current instruction is either BYPASS or IDCODE */
1058                 buf_set_ones(tap->cur_instr, tap->ir_length);
1059                 tap->bypass = 1;
1060         }
1061
1062         return ERROR_OK;
1063 }
1064
1065 /* sleep at least us microseconds. When we sleep more than 1000ms we
1066  * do an alive sleep, i.e. keep GDB alive. Note that we could starve
1067  * GDB if we slept for <1000ms many times.
1068  */
1069 void jtag_sleep(uint32_t us)
1070 {
1071         if (us < 1000)
1072                 usleep(us);
1073         else
1074                 alive_sleep((us+999)/1000);
1075 }
1076
1077 #define JTAG_MAX_AUTO_TAPS 20
1078
1079 #define EXTRACT_JEP106_BANK(X) (((X) & 0xf00) >> 8)
1080 #define EXTRACT_JEP106_ID(X)   (((X) & 0xfe) >> 1)
1081 #define EXTRACT_MFG(X)  (((X) & 0xffe) >> 1)
1082 #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12)
1083 #define EXTRACT_VER(X)  (((X) & 0xf0000000) >> 28)
1084
1085 /* A reserved manufacturer ID is used in END_OF_CHAIN_FLAG, so we
1086  * know that no valid TAP will have it as an IDCODE value.
1087  */
1088 #define END_OF_CHAIN_FLAG       0xffffffff
1089
1090 /* a larger IR length than we ever expect to autoprobe */
1091 #define JTAG_IRLEN_MAX          60
1092
1093 static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode)
1094 {
1095         struct scan_field field = {
1096                 .num_bits = num_idcode * 32,
1097                 .out_value = idcode_buffer,
1098                 .in_value = idcode_buffer,
1099         };
1100
1101         /* initialize to the end of chain ID value */
1102         for (unsigned i = 0; i < num_idcode; i++)
1103                 buf_set_u32(idcode_buffer, i * 32, 32, END_OF_CHAIN_FLAG);
1104
1105         jtag_add_plain_dr_scan(field.num_bits, field.out_value, field.in_value, TAP_DRPAUSE);
1106         jtag_add_tlr();
1107         return jtag_execute_queue();
1108 }
1109
1110 static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count)
1111 {
1112         uint8_t zero_check = 0x0;
1113         uint8_t one_check = 0xff;
1114
1115         for (unsigned i = 0; i < count * 4; i++) {
1116                 zero_check |= idcodes[i];
1117                 one_check &= idcodes[i];
1118         }
1119
1120         /* if there wasn't a single non-zero bit or if all bits were one,
1121          * the scan is not valid.  We wrote a mix of both values; either
1122          *
1123          *  - There's a hardware issue (almost certainly):
1124          *     + all-zeroes can mean a target stuck in JTAG reset
1125          *     + all-ones tends to mean no target
1126          *  - The scan chain is WAY longer than we can handle, *AND* either
1127          *     + there are several hundreds of TAPs in bypass, or
1128          *     + at least a few dozen TAPs all have an all-ones IDCODE
1129          */
1130         if (zero_check == 0x00 || one_check == 0xff) {
1131                 LOG_ERROR("JTAG scan chain interrogation failed: all %s",
1132                         (zero_check == 0x00) ? "zeroes" : "ones");
1133                 LOG_ERROR("Check JTAG interface, timings, target power, etc.");
1134                 return false;
1135         }
1136         return true;
1137 }
1138
1139 static void jtag_examine_chain_display(enum log_levels level, const char *msg,
1140         const char *name, uint32_t idcode)
1141 {
1142         log_printf_lf(level, __FILE__, __LINE__, __func__,
1143                 "JTAG tap: %s %16.16s: 0x%08x "
1144                 "(mfg: 0x%3.3x (%s), part: 0x%4.4x, ver: 0x%1.1x)",
1145                 name, msg,
1146                 (unsigned int)idcode,
1147                 (unsigned int)EXTRACT_MFG(idcode),
1148                 jep106_manufacturer(EXTRACT_JEP106_BANK(idcode), EXTRACT_JEP106_ID(idcode)),
1149                 (unsigned int)EXTRACT_PART(idcode),
1150                 (unsigned int)EXTRACT_VER(idcode));
1151 }
1152
1153 static bool jtag_idcode_is_final(uint32_t idcode)
1154 {
1155         /*
1156          * Some devices, such as AVR8, will output all 1's instead
1157          * of TDI input value at end of chain. Allow those values
1158          * instead of failing.
1159          */
1160         return idcode == END_OF_CHAIN_FLAG;
1161 }
1162
1163 /**
1164  * This helper checks that remaining bits in the examined chain data are
1165  * all as expected, but a single JTAG device requires only 64 bits to be
1166  * read back correctly.  This can help identify and diagnose problems
1167  * with the JTAG chain earlier, gives more helpful/explicit error messages.
1168  * Returns TRUE iff garbage was found.
1169  */
1170 static bool jtag_examine_chain_end(uint8_t *idcodes, unsigned count, unsigned max)
1171 {
1172         bool triggered = false;
1173         for (; count < max - 31; count += 32) {
1174                 uint32_t idcode = buf_get_u32(idcodes, count, 32);
1175
1176                 /* do not trigger the warning if the data looks good */
1177                 if (jtag_idcode_is_final(idcode))
1178                         continue;
1179                 LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x",
1180                         count, (unsigned int)idcode);
1181                 triggered = true;
1182         }
1183         return triggered;
1184 }
1185
1186 static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap)
1187 {
1188
1189         if (tap->expected_ids_cnt == 0 || !tap->hasidcode)
1190                 return true;
1191
1192         /* optionally ignore the JTAG version field - bits 28-31 of IDCODE */
1193         uint32_t mask = tap->ignore_version ? ~(0xfU << 28) : ~0U;
1194         uint32_t idcode = tap->idcode & mask;
1195
1196         /* Loop over the expected identification codes and test for a match */
1197         for (unsigned ii = 0; ii < tap->expected_ids_cnt; ii++) {
1198                 uint32_t expected = tap->expected_ids[ii] & mask;
1199
1200                 if (idcode == expected)
1201                         return true;
1202
1203                 /* treat "-expected-id 0" as a "don't-warn" wildcard */
1204                 if (0 == tap->expected_ids[ii])
1205                         return true;
1206         }
1207
1208         /* If none of the expected ids matched, warn */
1209         jtag_examine_chain_display(LOG_LVL_WARNING, "UNEXPECTED",
1210                 tap->dotted_name, tap->idcode);
1211         for (unsigned ii = 0; ii < tap->expected_ids_cnt; ii++) {
1212                 char msg[32];
1213
1214                 snprintf(msg, sizeof(msg), "expected %u of %u", ii + 1, tap->expected_ids_cnt);
1215                 jtag_examine_chain_display(LOG_LVL_ERROR, msg,
1216                         tap->dotted_name, tap->expected_ids[ii]);
1217         }
1218         return false;
1219 }
1220
1221 /* Try to examine chain layout according to IEEE 1149.1 §12
1222  * This is called a "blind interrogation" of the scan chain.
1223  */
1224 static int jtag_examine_chain(void)
1225 {
1226         int retval;
1227         unsigned max_taps = jtag_tap_count();
1228
1229         /* Autoprobe up to this many. */
1230         if (max_taps < JTAG_MAX_AUTO_TAPS)
1231                 max_taps = JTAG_MAX_AUTO_TAPS;
1232
1233         /* Add room for end-of-chain marker. */
1234         max_taps++;
1235
1236         uint8_t *idcode_buffer = calloc(4, max_taps);
1237         if (idcode_buffer == NULL)
1238                 return ERROR_JTAG_INIT_FAILED;
1239
1240         /* DR scan to collect BYPASS or IDCODE register contents.
1241          * Then make sure the scan data has both ones and zeroes.
1242          */
1243         LOG_DEBUG("DR scan interrogation for IDCODE/BYPASS");
1244         retval = jtag_examine_chain_execute(idcode_buffer, max_taps);
1245         if (retval != ERROR_OK)
1246                 goto out;
1247         if (!jtag_examine_chain_check(idcode_buffer, max_taps)) {
1248                 retval = ERROR_JTAG_INIT_FAILED;
1249                 goto out;
1250         }
1251
1252         /* Point at the 1st predefined tap, if any */
1253         struct jtag_tap *tap = jtag_tap_next_enabled(NULL);
1254
1255         unsigned bit_count = 0;
1256         unsigned autocount = 0;
1257         for (unsigned i = 0; i < max_taps; i++) {
1258                 assert(bit_count < max_taps * 32);
1259                 uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32);
1260
1261                 /* No predefined TAP? Auto-probe. */
1262                 if (tap == NULL) {
1263                         /* Is there another TAP? */
1264                         if (jtag_idcode_is_final(idcode))
1265                                 break;
1266
1267                         /* Default everything in this TAP except IR length.
1268                          *
1269                          * REVISIT create a jtag_alloc(chip, tap) routine, and
1270                          * share it with jim_newtap_cmd().
1271                          */
1272                         tap = calloc(1, sizeof(*tap));
1273                         if (!tap) {
1274                                 retval = ERROR_FAIL;
1275                                 goto out;
1276                         }
1277
1278                         tap->chip = alloc_printf("auto%u", autocount++);
1279                         tap->tapname = strdup("tap");
1280                         tap->dotted_name = alloc_printf("%s.%s", tap->chip, tap->tapname);
1281
1282                         tap->ir_length = 0; /* ... signifying irlen autoprobe */
1283                         tap->ir_capture_mask = 0x03;
1284                         tap->ir_capture_value = 0x01;
1285
1286                         tap->enabled = true;
1287
1288                         jtag_tap_init(tap);
1289                 }
1290
1291                 if ((idcode & 1) == 0) {
1292                         /* Zero for LSB indicates a device in bypass */
1293                         LOG_INFO("TAP %s does not have valid IDCODE (idcode=0x%x)",
1294                                         tap->dotted_name, idcode);
1295                         tap->hasidcode = false;
1296                         tap->idcode = 0;
1297
1298                         bit_count += 1;
1299                 } else {
1300                         /* Friendly devices support IDCODE */
1301                         tap->hasidcode = true;
1302                         tap->idcode = idcode;
1303                         jtag_examine_chain_display(LOG_LVL_INFO, "tap/device found", tap->dotted_name, idcode);
1304
1305                         bit_count += 32;
1306                 }
1307
1308                 /* ensure the TAP ID matches what was expected */
1309                 if (!jtag_examine_chain_match_tap(tap))
1310                         retval = ERROR_JTAG_INIT_SOFT_FAIL;
1311
1312                 tap = jtag_tap_next_enabled(tap);
1313         }
1314
1315         /* After those IDCODE or BYPASS register values should be
1316          * only the data we fed into the scan chain.
1317          */
1318         if (jtag_examine_chain_end(idcode_buffer, bit_count, max_taps * 32)) {
1319                 LOG_ERROR("double-check your JTAG setup (interface, speed, ...)");
1320                 retval = ERROR_JTAG_INIT_FAILED;
1321                 goto out;
1322         }
1323
1324         /* Return success or, for backwards compatibility if only
1325          * some IDCODE values mismatched, a soft/continuable fault.
1326          */
1327 out:
1328         free(idcode_buffer);
1329         return retval;
1330 }
1331
1332 /*
1333  * Validate the date loaded by entry to the Capture-IR state, to help
1334  * find errors related to scan chain configuration (wrong IR lengths)
1335  * or communication.
1336  *
1337  * Entry state can be anything.  On non-error exit, all TAPs are in
1338  * bypass mode.  On error exits, the scan chain is reset.
1339  */
1340 static int jtag_validate_ircapture(void)
1341 {
1342         struct jtag_tap *tap;
1343         int total_ir_length = 0;
1344         uint8_t *ir_test = NULL;
1345         struct scan_field field;
1346         uint64_t val;
1347         int chain_pos = 0;
1348         int retval;
1349
1350         /* when autoprobing, accomodate huge IR lengths */
1351         for (tap = NULL, total_ir_length = 0;
1352                         (tap = jtag_tap_next_enabled(tap)) != NULL;
1353                         total_ir_length += tap->ir_length) {
1354                 if (tap->ir_length == 0)
1355                         total_ir_length += JTAG_IRLEN_MAX;
1356         }
1357
1358         /* increase length to add 2 bit sentinel after scan */
1359         total_ir_length += 2;
1360
1361         ir_test = malloc(DIV_ROUND_UP(total_ir_length, 8));
1362         if (ir_test == NULL)
1363                 return ERROR_FAIL;
1364
1365         /* after this scan, all TAPs will capture BYPASS instructions */
1366         buf_set_ones(ir_test, total_ir_length);
1367
1368         field.num_bits = total_ir_length;
1369         field.out_value = ir_test;
1370         field.in_value = ir_test;
1371
1372         jtag_add_plain_ir_scan(field.num_bits, field.out_value, field.in_value, TAP_IDLE);
1373
1374         LOG_DEBUG("IR capture validation scan");
1375         retval = jtag_execute_queue();
1376         if (retval != ERROR_OK)
1377                 goto done;
1378
1379         tap = NULL;
1380         chain_pos = 0;
1381
1382         for (;; ) {
1383                 tap = jtag_tap_next_enabled(tap);
1384                 if (tap == NULL)
1385                         break;
1386
1387                 /* If we're autoprobing, guess IR lengths.  They must be at
1388                  * least two bits.  Guessing will fail if (a) any TAP does
1389                  * not conform to the JTAG spec; or (b) when the upper bits
1390                  * captured from some conforming TAP are nonzero.  Or if
1391                  * (c) an IR length is longer than JTAG_IRLEN_MAX bits,
1392                  * an implementation limit, which could someday be raised.
1393                  *
1394                  * REVISIT optimization:  if there's a *single* TAP we can
1395                  * lift restrictions (a) and (b) by scanning a recognizable
1396                  * pattern before the all-ones BYPASS.  Check for where the
1397                  * pattern starts in the result, instead of an 0...01 value.
1398                  *
1399                  * REVISIT alternative approach: escape to some tcl code
1400                  * which could provide more knowledge, based on IDCODE; and
1401                  * only guess when that has no success.
1402                  */
1403                 if (tap->ir_length == 0) {
1404                         tap->ir_length = 2;
1405                         while ((val = buf_get_u64(ir_test, chain_pos, tap->ir_length + 1)) == 1
1406                                         && tap->ir_length < JTAG_IRLEN_MAX) {
1407                                 tap->ir_length++;
1408                         }
1409                         LOG_WARNING("AUTO %s - use \"jtag newtap %s %s -irlen %d "
1410                                         "-expected-id 0x%08" PRIx32 "\"",
1411                                         tap->dotted_name, tap->chip, tap->tapname, tap->ir_length, tap->idcode);
1412                 }
1413
1414                 /* Validate the two LSBs, which must be 01 per JTAG spec.
1415                  *
1416                  * Or ... more bits could be provided by TAP declaration.
1417                  * Plus, some taps (notably in i.MX series chips) violate
1418                  * this part of the JTAG spec, so their capture mask/value
1419                  * attributes might disable this test.
1420                  */
1421                 val = buf_get_u64(ir_test, chain_pos, tap->ir_length);
1422                 if ((val & tap->ir_capture_mask) != tap->ir_capture_value) {
1423                         LOG_ERROR("%s: IR capture error; saw 0x%0*" PRIx64 " not 0x%0*" PRIx32,
1424                                 jtag_tap_name(tap),
1425                                 (tap->ir_length + 7) / tap->ir_length, val,
1426                                 (tap->ir_length + 7) / tap->ir_length, tap->ir_capture_value);
1427
1428                         retval = ERROR_JTAG_INIT_FAILED;
1429                         goto done;
1430                 }
1431                 LOG_DEBUG("%s: IR capture 0x%0*" PRIx64, jtag_tap_name(tap),
1432                         (tap->ir_length + 7) / tap->ir_length, val);
1433                 chain_pos += tap->ir_length;
1434         }
1435
1436         /* verify the '11' sentinel we wrote is returned at the end */
1437         val = buf_get_u64(ir_test, chain_pos, 2);
1438         if (val != 0x3) {
1439                 char *cbuf = buf_to_str(ir_test, total_ir_length, 16);
1440
1441                 LOG_ERROR("IR capture error at bit %d, saw 0x%s not 0x...3",
1442                         chain_pos, cbuf);
1443                 free(cbuf);
1444                 retval = ERROR_JTAG_INIT_FAILED;
1445         }
1446
1447 done:
1448         free(ir_test);
1449         if (retval != ERROR_OK) {
1450                 jtag_add_tlr();
1451                 jtag_execute_queue();
1452         }
1453         return retval;
1454 }
1455
1456 void jtag_tap_init(struct jtag_tap *tap)
1457 {
1458         unsigned ir_len_bits;
1459         unsigned ir_len_bytes;
1460
1461         /* if we're autoprobing, cope with potentially huge ir_length */
1462         ir_len_bits = tap->ir_length ? : JTAG_IRLEN_MAX;
1463         ir_len_bytes = DIV_ROUND_UP(ir_len_bits, 8);
1464
1465         tap->expected = calloc(1, ir_len_bytes);
1466         tap->expected_mask = calloc(1, ir_len_bytes);
1467         tap->cur_instr = malloc(ir_len_bytes);
1468
1469         /** @todo cope better with ir_length bigger than 32 bits */
1470         if (ir_len_bits > 32)
1471                 ir_len_bits = 32;
1472
1473         buf_set_u32(tap->expected, 0, ir_len_bits, tap->ir_capture_value);
1474         buf_set_u32(tap->expected_mask, 0, ir_len_bits, tap->ir_capture_mask);
1475
1476         /* TAP will be in bypass mode after jtag_validate_ircapture() */
1477         tap->bypass = 1;
1478         buf_set_ones(tap->cur_instr, tap->ir_length);
1479
1480         /* register the reset callback for the TAP */
1481         jtag_register_event_callback(&jtag_reset_callback, tap);
1482         jtag_tap_add(tap);
1483
1484         LOG_DEBUG("Created Tap: %s @ abs position %d, "
1485                         "irlen %d, capture: 0x%x mask: 0x%x", tap->dotted_name,
1486                         tap->abs_chain_position, tap->ir_length,
1487                         (unsigned) tap->ir_capture_value,
1488                         (unsigned) tap->ir_capture_mask);
1489 }
1490
1491 void jtag_tap_free(struct jtag_tap *tap)
1492 {
1493         jtag_unregister_event_callback(&jtag_reset_callback, tap);
1494
1495         struct jtag_tap_event_action *jteap = tap->event_action;
1496         while (jteap) {
1497                 struct jtag_tap_event_action *next = jteap->next;
1498                 Jim_DecrRefCount(jteap->interp, jteap->body);
1499                 free(jteap);
1500                 jteap = next;
1501         }
1502
1503         free(tap->expected);
1504         free(tap->expected_mask);
1505         free(tap->expected_ids);
1506         free(tap->cur_instr);
1507         free(tap->chip);
1508         free(tap->tapname);
1509         free(tap->dotted_name);
1510         free(tap);
1511 }
1512
1513 /**
1514  * Do low-level setup like initializing registers, output signals,
1515  * and clocking.
1516  */
1517 int adapter_init(struct command_context *cmd_ctx)
1518 {
1519         if (jtag)
1520                 return ERROR_OK;
1521
1522         if (!adapter_driver) {
1523                 /* nothing was previously specified by "adapter driver" command */
1524                 LOG_ERROR("Debug Adapter has to be specified, "
1525                         "see \"adapter driver\" command");
1526                 return ERROR_JTAG_INVALID_INTERFACE;
1527         }
1528
1529         int retval;
1530         retval = adapter_driver->init();
1531         if (retval != ERROR_OK)
1532                 return retval;
1533         jtag = adapter_driver;
1534
1535         if (jtag->speed == NULL) {
1536                 LOG_INFO("This adapter doesn't support configurable speed");
1537                 return ERROR_OK;
1538         }
1539
1540         if (CLOCK_MODE_UNSELECTED == clock_mode) {
1541                 LOG_ERROR("An adapter speed is not selected in the init script."
1542                         " Insert a call to \"adapter speed\" or \"jtag_rclk\" to proceed.");
1543                 return ERROR_JTAG_INIT_FAILED;
1544         }
1545
1546         int requested_khz = jtag_get_speed_khz();
1547         int actual_khz = requested_khz;
1548         int jtag_speed_var = 0;
1549         retval = jtag_get_speed(&jtag_speed_var);
1550         if (retval != ERROR_OK)
1551                 return retval;
1552         retval = jtag->speed(jtag_speed_var);
1553         if (retval != ERROR_OK)
1554                 return retval;
1555         retval = jtag_get_speed_readable(&actual_khz);
1556         if (ERROR_OK != retval)
1557                 LOG_INFO("adapter-specific clock speed value %d", jtag_speed_var);
1558         else if (actual_khz) {
1559                 /* Adaptive clocking -- JTAG-specific */
1560                 if ((CLOCK_MODE_RCLK == clock_mode)
1561                                 || ((CLOCK_MODE_KHZ == clock_mode) && !requested_khz)) {
1562                         LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz"
1563                         , actual_khz);
1564                 } else
1565                         LOG_INFO("clock speed %d kHz", actual_khz);
1566         } else
1567                 LOG_INFO("RCLK (adaptive clock speed)");
1568
1569         return ERROR_OK;
1570 }
1571
1572 int jtag_init_inner(struct command_context *cmd_ctx)
1573 {
1574         struct jtag_tap *tap;
1575         int retval;
1576         bool issue_setup = true;
1577
1578         LOG_DEBUG("Init JTAG chain");
1579
1580         tap = jtag_tap_next_enabled(NULL);
1581         if (tap == NULL) {
1582                 /* Once JTAG itself is properly set up, and the scan chain
1583                  * isn't absurdly large, IDCODE autoprobe should work fine.
1584                  *
1585                  * But ... IRLEN autoprobe can fail even on systems which
1586                  * are fully conformant to JTAG.  Also, JTAG setup can be
1587                  * quite finicky on some systems.
1588                  *
1589                  * REVISIT: if TAP autoprobe works OK, then in many cases
1590                  * we could escape to tcl code and set up targets based on
1591                  * the TAP's IDCODE values.
1592                  */
1593                 LOG_WARNING("There are no enabled taps.  "
1594                         "AUTO PROBING MIGHT NOT WORK!!");
1595
1596                 /* REVISIT default clock will often be too fast ... */
1597         }
1598
1599         jtag_add_tlr();
1600         retval = jtag_execute_queue();
1601         if (retval != ERROR_OK)
1602                 return retval;
1603
1604         /* Examine DR values first.  This discovers problems which will
1605          * prevent communication ... hardware issues like TDO stuck, or
1606          * configuring the wrong number of (enabled) TAPs.
1607          */
1608         retval = jtag_examine_chain();
1609         switch (retval) {
1610                 case ERROR_OK:
1611                         /* complete success */
1612                         break;
1613                 default:
1614                         /* For backward compatibility reasons, try coping with
1615                          * configuration errors involving only ID mismatches.
1616                          * We might be able to talk to the devices.
1617                          *
1618                          * Also the device might be powered down during startup.
1619                          *
1620                          * After OpenOCD starts, we can try to power on the device
1621                          * and run a reset.
1622                          */
1623                         LOG_ERROR("Trying to use configured scan chain anyway...");
1624                         issue_setup = false;
1625                         break;
1626         }
1627
1628         /* Now look at IR values.  Problems here will prevent real
1629          * communication.  They mostly mean that the IR length is
1630          * wrong ... or that the IR capture value is wrong.  (The
1631          * latter is uncommon, but easily worked around:  provide
1632          * ircapture/irmask values during TAP setup.)
1633          */
1634         retval = jtag_validate_ircapture();
1635         if (retval != ERROR_OK) {
1636                 /* The target might be powered down. The user
1637                  * can power it up and reset it after firing
1638                  * up OpenOCD.
1639                  */
1640                 issue_setup = false;
1641         }
1642
1643         if (issue_setup)
1644                 jtag_notify_event(JTAG_TAP_EVENT_SETUP);
1645         else
1646                 LOG_WARNING("Bypassing JTAG setup events due to errors");
1647
1648
1649         return ERROR_OK;
1650 }
1651
1652 int adapter_quit(void)
1653 {
1654         if (jtag && jtag->quit) {
1655                 /* close the JTAG interface */
1656                 int result = jtag->quit();
1657                 if (ERROR_OK != result)
1658                         LOG_ERROR("failed: %d", result);
1659         }
1660
1661         struct jtag_tap *t = jtag_all_taps();
1662         while (t) {
1663                 struct jtag_tap *n = t->next_tap;
1664                 jtag_tap_free(t);
1665                 t = n;
1666         }
1667
1668         return ERROR_OK;
1669 }
1670
1671 int swd_init_reset(struct command_context *cmd_ctx)
1672 {
1673         int retval, retval1;
1674
1675         retval = adapter_init(cmd_ctx);
1676         if (retval != ERROR_OK)
1677                 return retval;
1678
1679         LOG_DEBUG("Initializing with hard SRST reset");
1680
1681         if (jtag_reset_config & RESET_HAS_SRST)
1682                 retval = adapter_system_reset(1);
1683         retval1 = adapter_system_reset(0);
1684
1685         return (retval == ERROR_OK) ? retval1 : retval;
1686 }
1687
1688 int jtag_init_reset(struct command_context *cmd_ctx)
1689 {
1690         int retval = adapter_init(cmd_ctx);
1691         if (retval != ERROR_OK)
1692                 return retval;
1693
1694         LOG_DEBUG("Initializing with hard TRST+SRST reset");
1695
1696         /*
1697          * This procedure is used by default when OpenOCD triggers a reset.
1698          * It's now done through an overridable Tcl "init_reset" wrapper.
1699          *
1700          * This started out as a more powerful "get JTAG working" reset than
1701          * jtag_init_inner(), applying TRST because some chips won't activate
1702          * JTAG without a TRST cycle (presumed to be async, though some of
1703          * those chips synchronize JTAG activation using TCK).
1704          *
1705          * But some chips only activate JTAG as part of an SRST cycle; SRST
1706          * got mixed in.  So it became a hard reset routine, which got used
1707          * in more places, and which coped with JTAG reset being forced as
1708          * part of SRST (srst_pulls_trst).
1709          *
1710          * And even more corner cases started to surface:  TRST and/or SRST
1711          * assertion timings matter; some chips need other JTAG operations;
1712          * TRST/SRST sequences can need to be different from these, etc.
1713          *
1714          * Systems should override that wrapper to support system-specific
1715          * requirements that this not-fully-generic code doesn't handle.
1716          *
1717          * REVISIT once Tcl code can read the reset_config modes, this won't
1718          * need to be a C routine at all...
1719          */
1720         if (jtag_reset_config & RESET_HAS_SRST) {
1721                 jtag_add_reset(1, 1);
1722                 if ((jtag_reset_config & RESET_SRST_PULLS_TRST) == 0)
1723                         jtag_add_reset(0, 1);
1724         } else {
1725                 jtag_add_reset(1, 0);   /* TAP_RESET, using TMS+TCK or TRST */
1726         }
1727
1728         /* some targets enable us to connect with srst asserted */
1729         if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1730                 if (jtag_reset_config & RESET_SRST_NO_GATING)
1731                         jtag_add_reset(0, 1);
1732                 else {
1733                         LOG_WARNING("\'srst_nogate\' reset_config option is required");
1734                         jtag_add_reset(0, 0);
1735                 }
1736         } else
1737                 jtag_add_reset(0, 0);
1738         retval = jtag_execute_queue();
1739         if (retval != ERROR_OK)
1740                 return retval;
1741
1742         /* Check that we can communication on the JTAG chain + eventually we want to
1743          * be able to perform enumeration only after OpenOCD has started
1744          * telnet and GDB server
1745          *
1746          * That would allow users to more easily perform any magic they need to before
1747          * reset happens.
1748          */
1749         return jtag_init_inner(cmd_ctx);
1750 }
1751
1752 int jtag_init(struct command_context *cmd_ctx)
1753 {
1754         int retval = adapter_init(cmd_ctx);
1755         if (retval != ERROR_OK)
1756                 return retval;
1757
1758         /* guard against oddball hardware: force resets to be inactive */
1759         jtag_add_reset(0, 0);
1760
1761         /* some targets enable us to connect with srst asserted */
1762         if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1763                 if (jtag_reset_config & RESET_SRST_NO_GATING)
1764                         jtag_add_reset(0, 1);
1765                 else
1766                         LOG_WARNING("\'srst_nogate\' reset_config option is required");
1767         }
1768         retval = jtag_execute_queue();
1769         if (retval != ERROR_OK)
1770                 return retval;
1771
1772         if (Jim_Eval_Named(cmd_ctx->interp, "jtag_init", __FILE__, __LINE__) != JIM_OK)
1773                 return ERROR_FAIL;
1774
1775         return ERROR_OK;
1776 }
1777
1778 unsigned jtag_get_speed_khz(void)
1779 {
1780         return speed_khz;
1781 }
1782
1783 static int adapter_khz_to_speed(unsigned khz, int *speed)
1784 {
1785         LOG_DEBUG("convert khz to interface specific speed value");
1786         speed_khz = khz;
1787         if (!jtag)
1788                 return ERROR_OK;
1789         LOG_DEBUG("have interface set up");
1790         if (!jtag->khz) {
1791                 LOG_ERROR("Translation from khz to jtag_speed not implemented");
1792                 return ERROR_FAIL;
1793         }
1794         int speed_div1;
1795         int retval = jtag->khz(jtag_get_speed_khz(), &speed_div1);
1796         if (ERROR_OK != retval)
1797                 return retval;
1798         *speed = speed_div1;
1799         return ERROR_OK;
1800 }
1801
1802 static int jtag_rclk_to_speed(unsigned fallback_speed_khz, int *speed)
1803 {
1804         int retval = adapter_khz_to_speed(0, speed);
1805         if ((ERROR_OK != retval) && fallback_speed_khz) {
1806                 LOG_DEBUG("trying fallback speed...");
1807                 retval = adapter_khz_to_speed(fallback_speed_khz, speed);
1808         }
1809         return retval;
1810 }
1811
1812 static int jtag_set_speed(int speed)
1813 {
1814         jtag_speed = speed;
1815         /* this command can be called during CONFIG,
1816          * in which case jtag isn't initialized */
1817         return jtag ? jtag->speed(speed) : ERROR_OK;
1818 }
1819
1820 int jtag_config_khz(unsigned khz)
1821 {
1822         LOG_DEBUG("handle jtag khz");
1823         clock_mode = CLOCK_MODE_KHZ;
1824         int speed = 0;
1825         int retval = adapter_khz_to_speed(khz, &speed);
1826         return (ERROR_OK != retval) ? retval : jtag_set_speed(speed);
1827 }
1828
1829 int jtag_config_rclk(unsigned fallback_speed_khz)
1830 {
1831         LOG_DEBUG("handle jtag rclk");
1832         clock_mode = CLOCK_MODE_RCLK;
1833         rclk_fallback_speed_khz = fallback_speed_khz;
1834         int speed = 0;
1835         int retval = jtag_rclk_to_speed(fallback_speed_khz, &speed);
1836         return (ERROR_OK != retval) ? retval : jtag_set_speed(speed);
1837 }
1838
1839 int jtag_get_speed(int *speed)
1840 {
1841         switch (clock_mode) {
1842                 case CLOCK_MODE_KHZ:
1843                         adapter_khz_to_speed(jtag_get_speed_khz(), speed);
1844                         break;
1845                 case CLOCK_MODE_RCLK:
1846                         jtag_rclk_to_speed(rclk_fallback_speed_khz, speed);
1847                         break;
1848                 default:
1849                         LOG_ERROR("BUG: unknown jtag clock mode");
1850                         return ERROR_FAIL;
1851         }
1852         return ERROR_OK;
1853 }
1854
1855 int jtag_get_speed_readable(int *khz)
1856 {
1857         int jtag_speed_var = 0;
1858         int retval = jtag_get_speed(&jtag_speed_var);
1859         if (retval != ERROR_OK)
1860                 return retval;
1861         if (!jtag)
1862                 return ERROR_OK;
1863         if (!jtag->speed_div) {
1864                 LOG_ERROR("Translation from jtag_speed to khz not implemented");
1865                 return ERROR_FAIL;
1866         }
1867         return jtag->speed_div(jtag_speed_var, khz);
1868 }
1869
1870 void jtag_set_verify(bool enable)
1871 {
1872         jtag_verify = enable;
1873 }
1874
1875 bool jtag_will_verify(void)
1876 {
1877         return jtag_verify;
1878 }
1879
1880 void jtag_set_verify_capture_ir(bool enable)
1881 {
1882         jtag_verify_capture_ir = enable;
1883 }
1884
1885 bool jtag_will_verify_capture_ir(void)
1886 {
1887         return jtag_verify_capture_ir;
1888 }
1889
1890 int jtag_power_dropout(int *dropout)
1891 {
1892         if (jtag == NULL) {
1893                 /* TODO: as the jtag interface is not valid all
1894                  * we can do at the moment is exit OpenOCD */
1895                 LOG_ERROR("No Valid JTAG Interface Configured.");
1896                 exit(-1);
1897         }
1898         if (jtag->power_dropout)
1899                 return jtag->power_dropout(dropout);
1900
1901         *dropout = 0; /* by default we can't detect power dropout */
1902         return ERROR_OK;
1903 }
1904
1905 int jtag_srst_asserted(int *srst_asserted)
1906 {
1907         if (jtag->srst_asserted)
1908                 return jtag->srst_asserted(srst_asserted);
1909
1910         *srst_asserted = 0; /* by default we can't detect srst asserted */
1911         return ERROR_OK;
1912 }
1913
1914 enum reset_types jtag_get_reset_config(void)
1915 {
1916         return jtag_reset_config;
1917 }
1918 void jtag_set_reset_config(enum reset_types type)
1919 {
1920         jtag_reset_config = type;
1921 }
1922
1923 int jtag_get_trst(void)
1924 {
1925         return jtag_trst == 1;
1926 }
1927 int jtag_get_srst(void)
1928 {
1929         return jtag_srst == 1;
1930 }
1931
1932 void jtag_set_nsrst_delay(unsigned delay)
1933 {
1934         adapter_nsrst_delay = delay;
1935 }
1936 unsigned jtag_get_nsrst_delay(void)
1937 {
1938         return adapter_nsrst_delay;
1939 }
1940 void jtag_set_ntrst_delay(unsigned delay)
1941 {
1942         jtag_ntrst_delay = delay;
1943 }
1944 unsigned jtag_get_ntrst_delay(void)
1945 {
1946         return jtag_ntrst_delay;
1947 }
1948
1949
1950 void jtag_set_nsrst_assert_width(unsigned delay)
1951 {
1952         adapter_nsrst_assert_width = delay;
1953 }
1954 unsigned jtag_get_nsrst_assert_width(void)
1955 {
1956         return adapter_nsrst_assert_width;
1957 }
1958 void jtag_set_ntrst_assert_width(unsigned delay)
1959 {
1960         jtag_ntrst_assert_width = delay;
1961 }
1962 unsigned jtag_get_ntrst_assert_width(void)
1963 {
1964         return jtag_ntrst_assert_width;
1965 }
1966
1967 static int jtag_select(struct command_context *ctx)
1968 {
1969         int retval;
1970
1971         /* NOTE:  interface init must already have been done.
1972          * That works with only C code ... no Tcl glue required.
1973          */
1974
1975         retval = jtag_register_commands(ctx);
1976
1977         if (retval != ERROR_OK)
1978                 return retval;
1979
1980         retval = svf_register_commands(ctx);
1981
1982         if (retval != ERROR_OK)
1983                 return retval;
1984
1985         return xsvf_register_commands(ctx);
1986 }
1987
1988 static struct transport jtag_transport = {
1989         .name = "jtag",
1990         .select = jtag_select,
1991         .init = jtag_init,
1992 };
1993
1994 static void jtag_constructor(void) __attribute__((constructor));
1995 static void jtag_constructor(void)
1996 {
1997         transport_register(&jtag_transport);
1998 }
1999
2000 /** Returns true if the current debug session
2001  * is using JTAG as its transport.
2002  */
2003 bool transport_is_jtag(void)
2004 {
2005         return get_current_transport() == &jtag_transport;
2006 }
2007
2008 int adapter_resets(int trst, int srst)
2009 {
2010         if (get_current_transport() == NULL) {
2011                 LOG_ERROR("transport is not selected");
2012                 return ERROR_FAIL;
2013         }
2014
2015         if (transport_is_jtag()) {
2016                 if (srst == SRST_ASSERT && !(jtag_reset_config & RESET_HAS_SRST)) {
2017                         LOG_ERROR("adapter has no srst signal");
2018                         return ERROR_FAIL;
2019                 }
2020
2021                 /* adapters without trst signal will eventually use tlr sequence */
2022                 jtag_add_reset(trst, srst);
2023                 /*
2024                  * The jtag queue is still used for reset by some adapter. Flush it!
2025                  * FIXME: To be removed when all adapter drivers will be updated!
2026                  */
2027                 jtag_execute_queue();
2028                 return ERROR_OK;
2029         } else if (transport_is_swd() || transport_is_hla() ||
2030                            transport_is_dapdirect_swd() || transport_is_dapdirect_jtag()) {
2031                 if (trst == TRST_ASSERT) {
2032                         LOG_ERROR("transport %s has no trst signal",
2033                                 get_current_transport()->name);
2034                         return ERROR_FAIL;
2035                 }
2036
2037                 if (srst == SRST_ASSERT && !(jtag_reset_config & RESET_HAS_SRST)) {
2038                         LOG_ERROR("adapter has no srst signal");
2039                         return ERROR_FAIL;
2040                 }
2041                 adapter_system_reset(srst);
2042                 return ERROR_OK;
2043         }
2044
2045         if (trst == TRST_DEASSERT && srst == SRST_DEASSERT)
2046                 return ERROR_OK;
2047
2048         LOG_ERROR("reset is not supported on transport %s",
2049                 get_current_transport()->name);
2050
2051         return ERROR_FAIL;
2052 }
2053
2054 int adapter_assert_reset(void)
2055 {
2056         if (transport_is_jtag()) {
2057                 if (jtag_reset_config & RESET_SRST_PULLS_TRST)
2058                         jtag_add_reset(1, 1);
2059                 else
2060                         jtag_add_reset(0, 1);
2061                 return ERROR_OK;
2062         } else if (transport_is_swd() || transport_is_hla() ||
2063                            transport_is_dapdirect_jtag() || transport_is_dapdirect_swd())
2064                 return adapter_system_reset(1);
2065         else if (get_current_transport() != NULL)
2066                 LOG_ERROR("reset is not supported on %s",
2067                         get_current_transport()->name);
2068         else
2069                 LOG_ERROR("transport is not selected");
2070         return ERROR_FAIL;
2071 }
2072
2073 int adapter_deassert_reset(void)
2074 {
2075         if (transport_is_jtag()) {
2076                 jtag_add_reset(0, 0);
2077                 return ERROR_OK;
2078         } else if (transport_is_swd() || transport_is_hla() ||
2079                          transport_is_dapdirect_jtag() || transport_is_dapdirect_swd())
2080                 return adapter_system_reset(0);
2081         else if (get_current_transport() != NULL)
2082                 LOG_ERROR("reset is not supported on %s",
2083                         get_current_transport()->name);
2084         else
2085                 LOG_ERROR("transport is not selected");
2086         return ERROR_FAIL;
2087 }
2088
2089 int adapter_config_trace(bool enabled, enum tpiu_pin_protocol pin_protocol,
2090                 uint32_t port_size, unsigned int *trace_freq,
2091                 unsigned int traceclkin_freq, uint16_t *prescaler)
2092 {
2093         if (jtag->config_trace) {
2094                 return jtag->config_trace(enabled, pin_protocol, port_size, trace_freq,
2095                         traceclkin_freq, prescaler);
2096         } else if (enabled) {
2097                 LOG_ERROR("The selected interface does not support tracing");
2098                 return ERROR_FAIL;
2099         }
2100
2101         return ERROR_OK;
2102 }
2103
2104 int adapter_poll_trace(uint8_t *buf, size_t *size)
2105 {
2106         if (jtag->poll_trace)
2107                 return jtag->poll_trace(buf, size);
2108
2109         return ERROR_FAIL;
2110 }