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