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

   1 /***************************************************************************
   2  *   Copyright (C) 2005 by Dominic Rath                                    *
   3  *   Dominic.Rath@gmx.de                                                   *
   4  *                                                                         *
   5  *   Copyright (C) 2007,2008 Øyvind Harboe                                 *
   6  *   oyvind.harboe@zylin.com                                               *
   7  *                                                                         *
   8  *   Copyright (C) 2009 SoftPLC Corporation                                *
   9  *       http://softplc.com                                                *
  10  *   dick@softplc.com                                                      *
  11  *                                                                         *
  12  *   Copyright (C) 2009 Zachary T Welch                                    *
  13  *   zw@superlucidity.net                                                  *
  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 "interface.h"
  35
  36 /**
  37  * @see tap_set_state() and tap_get_state() accessors.
  38  * Actual name is not important since accessors hide it.
  39  */
  40 static tap_state_t state_follower = TAP_RESET;
  41
  42 void tap_set_state_impl(tap_state_t new_state)
  43 {
  44         /* this is the state we think the TAPs are in now, was cur_state */
  45         state_follower = new_state;
  46 }
  47
  48 tap_state_t tap_get_state()
  49 {
  50         return state_follower;
  51 }
  52
  53 /**
  54  * @see tap_set_end_state() and tap_get_end_state() accessors.
  55  * Actual name is not important because accessors hide it.
  56  */
  57 static tap_state_t end_state_follower = TAP_RESET;
  58
  59 void tap_set_end_state(tap_state_t new_end_state)
  60 {
  61         /* this is the state we think the TAPs will be in at completion of the
  62          * current TAP operation, was end_state
  63         */
  64         end_state_follower = new_end_state;
  65 }
  66
  67 tap_state_t tap_get_end_state()
  68 {
  69         return end_state_follower;
  70 }
  71
  72 int tap_move_ndx(tap_state_t astate)
  73 {
  74         /* given a stable state, return the index into the tms_seqs[]
  75          * array within tap_get_tms_path()
  76          */
  77
  78         int ndx;
  79
  80         switch (astate) {
  81                 case TAP_RESET:
  82                         ndx = 0;
  83                         break;
  84                 case TAP_IDLE:
  85                         ndx = 1;
  86                         break;
  87                 case TAP_DRSHIFT:
  88                         ndx = 2;
  89                         break;
  90                 case TAP_DRPAUSE:
  91                         ndx = 3;
  92                         break;
  93                 case TAP_IRSHIFT:
  94                         ndx = 4;
  95                         break;
  96                 case TAP_IRPAUSE:
  97                         ndx = 5;
  98                         break;
  99                 default:
 100                         LOG_ERROR("FATAL: unstable state \"%s\" in tap_move_ndx()",
 101                                         tap_state_name(astate));
 102                         exit(1);
 103         }
 104
 105         return ndx;
 106 }
 107
 108 /* tap_move[i][j]: tap movement command to go from state i to state j
 109  * encodings of i and j are what tap_move_ndx() reports.
 110  *
 111  * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code
 112  */
 113 struct tms_sequences {
 114         uint8_t bits;
 115         uint8_t bit_count;
 116 };
 117
 118 /*
 119  * These macros allow us to specify TMS state transitions by bits rather than hex bytes.
 120  * Read the bits from LSBit first to MSBit last (right-to-left).
 121  */
 122 #define HEX__(n) 0x##n##LU
 123
 124 #define B8__(x) \
 125         ((((x) & 0x0000000FLU) ? (1 << 0) : 0) \
 126         +(((x) & 0x000000F0LU) ? (1 << 1) : 0) \
 127         +(((x) & 0x00000F00LU) ? (1 << 2) : 0) \
 128         +(((x) & 0x0000F000LU) ? (1 << 3) : 0) \
 129         +(((x) & 0x000F0000LU) ? (1 << 4) : 0) \
 130         +(((x) & 0x00F00000LU) ? (1 << 5) : 0) \
 131         +(((x) & 0x0F000000LU) ? (1 << 6) : 0) \
 132         +(((x) & 0xF0000000LU) ? (1 << 7) : 0))
 133
 134 #define B8(bits, count) {((uint8_t)B8__(HEX__(bits))), (count)}
 135
 136 static const struct tms_sequences old_tms_seqs[6][6] = {        /* [from_state_ndx][to_state_ndx] */
 137         /* value clocked to TMS to move from one of six stable states to another.
 138          * N.B. OOCD clocks TMS from LSB first, so read these right-to-left.
 139          * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable.
 140          * These extra ones cause no TAP state problem, because we go into reset and stay in reset.
 141          */
 142
 143 /* to state: */
 144 /*      RESET            IDLE                   DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE         */      /* from state: */
 145 {B8(1111111, 7), B8(0000000, 7), B8(0010111, 7), B8(0001010, 7), B8(0011011, 7), B8(0010110, 7)},/* RESET */
 146 {B8(1111111, 7), B8(0000000, 7), B8(0100101, 7), B8(0000101, 7), B8(0101011, 7), B8(0001011, 7)},/* IDLE */
 147 {B8(1111111, 7), B8(0110001, 7), B8(0000000, 7), B8(0000001, 7), B8(0001111, 7), B8(0101111, 7)},/* DRSHIFT */
 148 {B8(1111111, 7), B8(0110000, 7), B8(0100000, 7), B8(0010111, 7), B8(0011110, 7), B8(0101111, 7)},/* DRPAUSE */
 149 {B8(1111111, 7), B8(0110001, 7), B8(0000111, 7), B8(0010111, 7), B8(0000000, 7), B8(0000001, 7)},/* IRSHIFT */
 150 {B8(1111111, 7), B8(0110000, 7), B8(0011100, 7), B8(0010111, 7), B8(0011110, 7), B8(0101111, 7)},/* IRPAUSE */
 151 };
 152
 153 static const struct tms_sequences short_tms_seqs[6][6] = { /* [from_state_ndx][to_state_ndx] */
 154         /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment:
 155
 156         OK, I added Peter's version of the state table, and it works OK for
 157         me on MC1322x. I've recreated the jlink portion of patch with this
 158         new state table. His changes to my state table are pretty minor in
 159         terms of total transitions, but Peter feels that his version fixes
 160         some long-standing problems.
 161         Jeff
 162
 163         I added the bit count into the table, reduced RESET column to 7 bits from 8.
 164         Dick
 165
 166         state specific comments:
 167         ------------------------
 168         *->RESET                tried the 5 bit reset and it gave me problems, 7 bits seems to
 169                                         work better on ARM9 with ft2232 driver.  (Dick)
 170
 171         RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing.
 172                                         needed on ARM9 with ft2232 driver.  (Dick)
 173                                         (For a total of *THREE* extra clocks in RESET; NOP.)
 174
 175         RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing.
 176                                         needed on ARM9 with ft2232 driver.  (Dick)
 177                                         (For a total of *TWO* extra clocks in RESET; NOP.)
 178
 179         RESET->*                always adds one or more clocks in the target state,
 180                                         which should be NOPS; except shift states which (as
 181                                         noted above) add those clocks in RESET.
 182
 183         The X-to-X transitions always add clocks; from *SHIFT, they go
 184         via IDLE and thus *DO HAVE SIDE EFFECTS* (capture and update).
 185 */
 186
 187 /* to state: */
 188 /*      RESET           IDLE                    DRSHIFT                 DRPAUSE                 IRSHIFT                 IRPAUSE */ /* from state: */
 189 {B8(1111111, 7), B8(0000000, 7), B8(0010111, 7), B8(0001010, 7), B8(0011011, 7), B8(0010110, 7)}, /* RESET */
 190 {B8(1111111, 7), B8(0000000, 7), B8(001, 3),     B8(0101, 4),    B8(0011, 4),    B8(01011, 5)}, /* IDLE */
 191 {B8(1111111, 7), B8(011, 3),     B8(00111, 5),   B8(01, 2),              B8(001111, 6),  B8(0101111, 7)}, /* DRSHIFT */
 192 {B8(1111111, 7), B8(011, 3),     B8(01, 2),              B8(0, 1),               B8(001111, 6),  B8(0101111, 7)}, /* DRPAUSE */
 193 {B8(1111111, 7), B8(011, 3),     B8(00111, 5),   B8(010111, 6),  B8(001111, 6),  B8(01, 2)}, /* IRSHIFT */
 194 {B8(1111111, 7), B8(011, 3),     B8(00111, 5),   B8(010111, 6),  B8(01, 2),              B8(0, 1)} /* IRPAUSE */
 195 };
 196
 197 typedef const struct tms_sequences tms_table[6][6];
 198
 199 static tms_table *tms_seqs = &short_tms_seqs;
 200
 201 int tap_get_tms_path(tap_state_t from, tap_state_t to)
 202 {
 203         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bits;
 204 }
 205
 206 int tap_get_tms_path_len(tap_state_t from, tap_state_t to)
 207 {
 208         return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bit_count;
 209 }
 210
 211 bool tap_is_state_stable(tap_state_t astate)
 212 {
 213         bool is_stable;
 214
 215         /*      A switch () is used because it is symbol dependent
 216          * (not value dependent like an array), and can also check bounds.
 217         */
 218         switch (astate) {
 219                 case TAP_RESET:
 220                 case TAP_IDLE:
 221                 case TAP_DRSHIFT:
 222                 case TAP_DRPAUSE:
 223                 case TAP_IRSHIFT:
 224                 case TAP_IRPAUSE:
 225                         is_stable = true;
 226                         break;
 227                 default:
 228                         is_stable = false;
 229         }
 230
 231         return is_stable;
 232 }
 233
 234 tap_state_t tap_state_transition(tap_state_t cur_state, bool tms)
 235 {
 236         tap_state_t new_state;
 237
 238         /*      A switch is used because it is symbol dependent and not value dependent
 239          * like an array.  Also it can check for out of range conditions.
 240         */
 241
 242         if (tms) {
 243                 switch (cur_state) {
 244                         case TAP_RESET:
 245                                 new_state = cur_state;
 246                                 break;
 247                         case TAP_IDLE:
 248                         case TAP_DRUPDATE:
 249                         case TAP_IRUPDATE:
 250                                 new_state = TAP_DRSELECT;
 251                                 break;
 252                         case TAP_DRSELECT:
 253                                 new_state = TAP_IRSELECT;
 254                                 break;
 255                         case TAP_DRCAPTURE:
 256                         case TAP_DRSHIFT:
 257                                 new_state = TAP_DREXIT1;
 258                                 break;
 259                         case TAP_DREXIT1:
 260                         case TAP_DREXIT2:
 261                                 new_state = TAP_DRUPDATE;
 262                                 break;
 263                         case TAP_DRPAUSE:
 264                                 new_state = TAP_DREXIT2;
 265                                 break;
 266                         case TAP_IRSELECT:
 267                                 new_state = TAP_RESET;
 268                                 break;
 269                         case TAP_IRCAPTURE:
 270                         case TAP_IRSHIFT:
 271                                 new_state = TAP_IREXIT1;
 272                                 break;
 273                         case TAP_IREXIT1:
 274                         case TAP_IREXIT2:
 275                                 new_state = TAP_IRUPDATE;
 276                                 break;
 277                         case TAP_IRPAUSE:
 278                                 new_state = TAP_IREXIT2;
 279                                 break;
 280                         default:
 281                                 LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
 282                                 exit(1);
 283                                 break;
 284                 }
 285         } else {
 286                 switch (cur_state) {
 287                         case TAP_RESET:
 288                         case TAP_IDLE:
 289                         case TAP_DRUPDATE:
 290                         case TAP_IRUPDATE:
 291                                 new_state = TAP_IDLE;
 292                                 break;
 293                         case TAP_DRSELECT:
 294                                 new_state = TAP_DRCAPTURE;
 295                                 break;
 296                         case TAP_DRCAPTURE:
 297                         case TAP_DRSHIFT:
 298                         case TAP_DREXIT2:
 299                                 new_state = TAP_DRSHIFT;
 300                                 break;
 301                         case TAP_DREXIT1:
 302                         case TAP_DRPAUSE:
 303                                 new_state = TAP_DRPAUSE;
 304                                 break;
 305                         case TAP_IRSELECT:
 306                                 new_state = TAP_IRCAPTURE;
 307                                 break;
 308                         case TAP_IRCAPTURE:
 309                         case TAP_IRSHIFT:
 310                         case TAP_IREXIT2:
 311                                 new_state = TAP_IRSHIFT;
 312                                 break;
 313                         case TAP_IREXIT1:
 314                         case TAP_IRPAUSE:
 315                                 new_state = TAP_IRPAUSE;
 316                                 break;
 317                         default:
 318                                 LOG_ERROR("fatal: invalid argument cur_state=%d", cur_state);
 319                                 exit(1);
 320                                 break;
 321                 }
 322         }
 323
 324         return new_state;
 325 }
 326
 327 /* NOTE:  do not change these state names.  They're documented,
 328  * and we rely on them to match SVF input (except for "RUN/IDLE").
 329  */
 330 static const struct name_mapping {
 331         enum tap_state symbol;
 332         const char *name;
 333 } tap_name_mapping[] = {
 334         { TAP_RESET, "RESET", },
 335         { TAP_IDLE, "RUN/IDLE", },
 336         { TAP_DRSELECT, "DRSELECT", },
 337         { TAP_DRCAPTURE, "DRCAPTURE", },
 338         { TAP_DRSHIFT, "DRSHIFT", },
 339         { TAP_DREXIT1, "DREXIT1", },
 340         { TAP_DRPAUSE, "DRPAUSE", },
 341         { TAP_DREXIT2, "DREXIT2", },
 342         { TAP_DRUPDATE, "DRUPDATE", },
 343         { TAP_IRSELECT, "IRSELECT", },
 344         { TAP_IRCAPTURE, "IRCAPTURE", },
 345         { TAP_IRSHIFT, "IRSHIFT", },
 346         { TAP_IREXIT1, "IREXIT1", },
 347         { TAP_IRPAUSE, "IRPAUSE", },
 348         { TAP_IREXIT2, "IREXIT2", },
 349         { TAP_IRUPDATE, "IRUPDATE", },
 350
 351         /* only for input:  accept standard SVF name */
 352         { TAP_IDLE, "IDLE", },
 353 };
 354
 355 const char *tap_state_name(tap_state_t state)
 356 {
 357         unsigned i;
 358
 359         for (i = 0; i < ARRAY_SIZE(tap_name_mapping); i++) {
 360                 if (tap_name_mapping[i].symbol == state)
 361                         return tap_name_mapping[i].name;
 362         }
 363         return "???";
 364 }
 365
 366 tap_state_t tap_state_by_name(const char *name)
 367 {
 368         unsigned i;
 369
 370         for (i = 0; i < ARRAY_SIZE(tap_name_mapping); i++) {
 371                 /* be nice to the human */
 372                 if (strcasecmp(name, tap_name_mapping[i].name) == 0)
 373                         return tap_name_mapping[i].symbol;
 374         }
 375         /* not found */
 376         return TAP_INVALID;
 377 }
 378
 379 #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \
 380         do { buf[len] = bit ? '1' : '0'; } while (0)
 381 #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \
 382         LOG_DEBUG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \
 383         tap_state_name(a), tap_state_name(b), astr, bstr)
 384
 385 tap_state_t jtag_debug_state_machine_(const void *tms_buf, const void *tdi_buf,
 386         unsigned tap_bits, tap_state_t next_state)
 387 {
 388         const uint8_t *tms_buffer;
 389         const uint8_t *tdi_buffer;
 390         unsigned tap_bytes;
 391         unsigned cur_byte;
 392         unsigned cur_bit;
 393
 394         unsigned tap_out_bits;
 395         char tms_str[33];
 396         char tdi_str[33];
 397
 398         tap_state_t last_state;
 399
 400         /* set startstate (and possibly last, if tap_bits == 0) */
 401         last_state = next_state;
 402         LOG_DEBUG_IO("TAP/SM: START state: %s", tap_state_name(next_state));
 403
 404         tms_buffer = (const uint8_t *)tms_buf;
 405         tdi_buffer = (const uint8_t *)tdi_buf;
 406
 407         tap_bytes = DIV_ROUND_UP(tap_bits, 8);
 408         LOG_DEBUG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes);
 409
 410         tap_out_bits = 0;
 411         for (cur_byte = 0; cur_byte < tap_bytes; cur_byte++) {
 412                 for (cur_bit = 0; cur_bit < 8; cur_bit++) {
 413                         /* make sure we do not run off the end of the buffers */
 414                         unsigned tap_bit = cur_byte * 8 + cur_bit;
 415                         if (tap_bit == tap_bits)
 416                                 break;
 417
 418                         /* check and save TMS bit */
 419                         tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit));
 420                         JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit);
 421
 422                         /* use TMS bit to find the next TAP state */
 423                         next_state = tap_state_transition(last_state, tap_bit);
 424
 425                         /* check and store TDI bit */
 426                         tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit));
 427                         JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit);
 428
 429                         /* increment TAP bits */
 430                         tap_out_bits++;
 431
 432                         /* Only show TDO bits on state transitions, or */
 433                         /* after some number of bits in the same state. */
 434                         if ((next_state == last_state) && (tap_out_bits < 32))
 435                                 continue;
 436
 437                         /* terminate strings and display state transition */
 438                         tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
 439                         JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
 440
 441                         /* reset state */
 442                         last_state = next_state;
 443                         tap_out_bits = 0;
 444                 }
 445         }
 446
 447         if (tap_out_bits) {
 448                 /* terminate strings and display state transition */
 449                 tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0;
 450                 JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str);
 451         }
 452
 453         LOG_DEBUG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state));
 454
 455         return next_state;
 456 }
 457
 458 void tap_use_new_tms_table(bool use_new)
 459 {
 460         tms_seqs = use_new ? &short_tms_seqs : &old_tms_seqs;
 461 }
 462 bool tap_uses_new_tms_table(void)
 463 {
 464         return tms_seqs == &short_tms_seqs;
 465 }