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

   1 /**************************************************************************
   2 *   Copyright (C) 2012 by Andreas Fritiofson                              *
   3 *   andreas.fritiofson@gmail.com                                          *
   4 *                                                                         *
   5 *   This program is free software; you can redistribute it and/or modify  *
   6 *   it under the terms of the GNU General Public License as published by  *
   7 *   the Free Software Foundation; either version 2 of the License, or     *
   8 *   (at your option) any later version.                                   *
   9 *                                                                         *
  10 *   This program is distributed in the hope that it will be useful,       *
  11 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13 *   GNU General Public License for more details.                          *
  14 *                                                                         *
  15 *   You should have received a copy of the GNU General Public License     *
  16 *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  17 ***************************************************************************/
  18
  19 /**
  20  * @file
  21  * JTAG adapters based on the FT2232 full and high speed USB parts are
  22  * popular low cost JTAG debug solutions.  Many FT2232 based JTAG adapters
  23  * are discrete, but development boards may integrate them as alternatives
  24  * to more capable (and expensive) third party JTAG pods.
  25  *
  26  * JTAG uses only one of the two communications channels ("MPSSE engines")
  27  * on these devices.  Adapters based on FT4232 parts have four ports/channels
  28  * (A/B/C/D), instead of just two (A/B).
  29  *
  30  * Especially on development boards integrating one of these chips (as
  31  * opposed to discrete pods/dongles), the additional channels can be used
  32  * for a variety of purposes, but OpenOCD only uses one channel at a time.
  33  *
  34  *  - As a USB-to-serial adapter for the target's console UART ...
  35  *    which may be able to support ROM boot loaders that load initial
  36  *    firmware images to flash (or SRAM).
  37  *
  38  *  - On systems which support ARM's SWD in addition to JTAG, or instead
  39  *    of it, that second port can be used for reading SWV/SWO trace data.
  40  *
  41  *  - Additional JTAG links, e.g. to a CPLD or * FPGA.
  42  *
  43  * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
  44  * request/response interactions involve round trips over the USB link.
  45  * A "smart" JTAG adapter has intelligence close to the scan chain, so it
  46  * can for example poll quickly for a status change (usually taking on the
  47  * order of microseconds not milliseconds) before beginning a queued
  48  * transaction which require the previous one to have completed.
  49  *
  50  * There are dozens of adapters of this type, differing in details which
  51  * this driver needs to understand.  Those "layout" details are required
  52  * as part of FT2232 driver configuration.
  53  *
  54  * This code uses information contained in the MPSSE specification which was
  55  * found here:
  56  * https://www.ftdichip.com/Support/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
  57  * Hereafter this is called the "MPSSE Spec".
  58  *
  59  * The datasheet for the ftdichip.com's FT2232H part is here:
  60  * https://www.ftdichip.com/Support/Documents/DataSheets/ICs/DS_FT2232H.pdf
  61  *
  62  * Also note the issue with code 0x4b (clock data to TMS) noted in
  63  * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
  64  * which can affect longer JTAG state paths.
  65  */
  66
  67 #ifdef HAVE_CONFIG_H
  68 #include "config.h"
  69 #endif
  70
  71 /* project specific includes */
  72 #include <jtag/adapter.h>
  73 #include <jtag/interface.h>
  74 #include <jtag/swd.h>
  75 #include <transport/transport.h>
  76 #include <helper/time_support.h>
  77 #include <helper/log.h>
  78
  79 #if IS_CYGWIN == 1
  80 #include <windows.h>
  81 #endif
  82
  83 #include <assert.h>
  84
  85 /* FTDI access library includes */
  86 #include "mpsse.h"
  87
  88 #define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
  89 #define JTAG_MODE_ALT (LSB_FIRST | NEG_EDGE_IN | NEG_EDGE_OUT)
  90 #define SWD_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
  91
  92 static char *ftdi_device_desc;
  93 static char *ftdi_serial;
  94 static uint8_t ftdi_channel;
  95 static uint8_t ftdi_jtag_mode = JTAG_MODE;
  96
  97 static bool swd_mode;
  98
  99 #define MAX_USB_IDS 8
 100 /* vid = pid = 0 marks the end of the list */
 101 static uint16_t ftdi_vid[MAX_USB_IDS + 1] = { 0 };
 102 static uint16_t ftdi_pid[MAX_USB_IDS + 1] = { 0 };
 103
 104 static struct mpsse_ctx *mpsse_ctx;
 105
 106 struct signal {
 107         const char *name;
 108         uint16_t data_mask;
 109         uint16_t input_mask;
 110         uint16_t oe_mask;
 111         bool invert_data;
 112         bool invert_input;
 113         bool invert_oe;
 114         struct signal *next;
 115 };
 116
 117 static struct signal *signals;
 118
 119 /* FIXME: Where to store per-instance data? We need an SWD context. */
 120 static struct swd_cmd_queue_entry {
 121         uint8_t cmd;
 122         uint32_t *dst;
 123         uint8_t trn_ack_data_parity_trn[DIV_ROUND_UP(4 + 3 + 32 + 1 + 4, 8)];
 124 } *swd_cmd_queue;
 125 static size_t swd_cmd_queue_length;
 126 static size_t swd_cmd_queue_alloced;
 127 static int queued_retval;
 128 static int freq;
 129
 130 static uint16_t output;
 131 static uint16_t direction;
 132 static uint16_t jtag_output_init;
 133 static uint16_t jtag_direction_init;
 134
 135 static int ftdi_swd_switch_seq(enum swd_special_seq seq);
 136
 137 static struct signal *find_signal_by_name(const char *name)
 138 {
 139         for (struct signal *sig = signals; sig; sig = sig->next) {
 140                 if (strcmp(name, sig->name) == 0)
 141                         return sig;
 142         }
 143         return NULL;
 144 }
 145
 146 static struct signal *create_signal(const char *name)
 147 {
 148         struct signal **psig = &signals;
 149         while (*psig)
 150                 psig = &(*psig)->next;
 151
 152         *psig = calloc(1, sizeof(**psig));
 153         if (!*psig)
 154                 return NULL;
 155
 156         (*psig)->name = strdup(name);
 157         if (!(*psig)->name) {
 158                 free(*psig);
 159                 *psig = NULL;
 160         }
 161         return *psig;
 162 }
 163
 164 static int ftdi_set_signal(const struct signal *s, char value)
 165 {
 166         bool data;
 167         bool oe;
 168
 169         if (s->data_mask == 0 && s->oe_mask == 0) {
 170                 LOG_ERROR("interface doesn't provide signal '%s'", s->name);
 171                 return ERROR_FAIL;
 172         }
 173         switch (value) {
 174         case '0':
 175                 data = s->invert_data;
 176                 oe = !s->invert_oe;
 177                 break;
 178         case '1':
 179                 if (s->data_mask == 0) {
 180                         LOG_ERROR("interface can't drive '%s' high", s->name);
 181                         return ERROR_FAIL;
 182                 }
 183                 data = !s->invert_data;
 184                 oe = !s->invert_oe;
 185                 break;
 186         case 'z':
 187         case 'Z':
 188                 if (s->oe_mask == 0) {
 189                         LOG_ERROR("interface can't tri-state '%s'", s->name);
 190                         return ERROR_FAIL;
 191                 }
 192                 data = s->invert_data;
 193                 oe = s->invert_oe;
 194                 break;
 195         default:
 196                 assert(0 && "invalid signal level specifier");
 197                 return ERROR_FAIL;
 198         }
 199
 200         uint16_t old_output = output;
 201         uint16_t old_direction = direction;
 202
 203         output = data ? output | s->data_mask : output & ~s->data_mask;
 204         if (s->oe_mask == s->data_mask)
 205                 direction = oe ? direction | s->oe_mask : direction & ~s->oe_mask;
 206         else
 207                 output = oe ? output | s->oe_mask : output & ~s->oe_mask;
 208
 209         if ((output & 0xff) != (old_output & 0xff) || (direction & 0xff) != (old_direction & 0xff))
 210                 mpsse_set_data_bits_low_byte(mpsse_ctx, output & 0xff, direction & 0xff);
 211         if ((output >> 8 != old_output >> 8) || (direction >> 8 != old_direction >> 8))
 212                 mpsse_set_data_bits_high_byte(mpsse_ctx, output >> 8, direction >> 8);
 213
 214         return ERROR_OK;
 215 }
 216
 217 static int ftdi_get_signal(const struct signal *s, uint16_t *value_out)
 218 {
 219         uint8_t data_low = 0;
 220         uint8_t data_high = 0;
 221
 222         if (s->input_mask == 0) {
 223                 LOG_ERROR("interface doesn't provide signal '%s'", s->name);
 224                 return ERROR_FAIL;
 225         }
 226
 227         if (s->input_mask & 0xff)
 228                 mpsse_read_data_bits_low_byte(mpsse_ctx, &data_low);
 229         if (s->input_mask >> 8)
 230                 mpsse_read_data_bits_high_byte(mpsse_ctx, &data_high);
 231
 232         mpsse_flush(mpsse_ctx);
 233
 234         *value_out = (((uint16_t)data_high) << 8) | data_low;
 235
 236         if (s->invert_input)
 237                 *value_out = ~(*value_out);
 238
 239         *value_out &= s->input_mask;
 240
 241         return ERROR_OK;
 242 }
 243
 244 /**
 245  * Function move_to_state
 246  * moves the TAP controller from the current state to a
 247  * \a goal_state through a path given by tap_get_tms_path().  State transition
 248  * logging is performed by delegation to clock_tms().
 249  *
 250  * @param goal_state is the destination state for the move.
 251  */
 252 static void move_to_state(tap_state_t goal_state)
 253 {
 254         tap_state_t start_state = tap_get_state();
 255
 256         /*      goal_state is 1/2 of a tuple/pair of states which allow convenient
 257                 lookup of the required TMS pattern to move to this state from the
 258                 start state.
 259         */
 260
 261         /* do the 2 lookups */
 262         uint8_t tms_bits  = tap_get_tms_path(start_state, goal_state);
 263         int tms_count = tap_get_tms_path_len(start_state, goal_state);
 264         assert(tms_count <= 8);
 265
 266         LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
 267
 268         /* Track state transitions step by step */
 269         for (int i = 0; i < tms_count; i++)
 270                 tap_set_state(tap_state_transition(tap_get_state(), (tms_bits >> i) & 1));
 271
 272         mpsse_clock_tms_cs_out(mpsse_ctx,
 273                 &tms_bits,
 274                 0,
 275                 tms_count,
 276                 false,
 277                 ftdi_jtag_mode);
 278 }
 279
 280 static int ftdi_speed(int speed)
 281 {
 282         int retval;
 283         retval = mpsse_set_frequency(mpsse_ctx, speed);
 284
 285         if (retval < 0) {
 286                 LOG_ERROR("couldn't set FTDI TCK speed");
 287                 return retval;
 288         }
 289
 290         if (!swd_mode && speed >= 10000000 && ftdi_jtag_mode != JTAG_MODE_ALT)
 291                 LOG_INFO("ftdi: if you experience problems at higher adapter clocks, try "
 292                          "the command \"ftdi tdo_sample_edge falling\"");
 293         return ERROR_OK;
 294 }
 295
 296 static int ftdi_speed_div(int speed, int *khz)
 297 {
 298         *khz = speed / 1000;
 299         return ERROR_OK;
 300 }
 301
 302 static int ftdi_khz(int khz, int *jtag_speed)
 303 {
 304         if (khz == 0 && !mpsse_is_high_speed(mpsse_ctx)) {
 305                 LOG_DEBUG("RCLK not supported");
 306                 return ERROR_FAIL;
 307         }
 308
 309         *jtag_speed = khz * 1000;
 310         return ERROR_OK;
 311 }
 312
 313 static void ftdi_end_state(tap_state_t state)
 314 {
 315         if (tap_is_state_stable(state))
 316                 tap_set_end_state(state);
 317         else {
 318                 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
 319                 exit(-1);
 320         }
 321 }
 322
 323 static void ftdi_execute_runtest(struct jtag_command *cmd)
 324 {
 325         int i;
 326         uint8_t zero = 0;
 327
 328         LOG_DEBUG_IO("runtest %i cycles, end in %s",
 329                 cmd->cmd.runtest->num_cycles,
 330                 tap_state_name(cmd->cmd.runtest->end_state));
 331
 332         if (tap_get_state() != TAP_IDLE)
 333                 move_to_state(TAP_IDLE);
 334
 335         /* TODO: Reuse ftdi_execute_stableclocks */
 336         i = cmd->cmd.runtest->num_cycles;
 337         while (i > 0) {
 338                 /* there are no state transitions in this code, so omit state tracking */
 339                 unsigned this_len = i > 7 ? 7 : i;
 340                 mpsse_clock_tms_cs_out(mpsse_ctx, &zero, 0, this_len, false, ftdi_jtag_mode);
 341                 i -= this_len;
 342         }
 343
 344         ftdi_end_state(cmd->cmd.runtest->end_state);
 345
 346         if (tap_get_state() != tap_get_end_state())
 347                 move_to_state(tap_get_end_state());
 348
 349         LOG_DEBUG_IO("runtest: %i, end in %s",
 350                 cmd->cmd.runtest->num_cycles,
 351                 tap_state_name(tap_get_end_state()));
 352 }
 353
 354 static void ftdi_execute_statemove(struct jtag_command *cmd)
 355 {
 356         LOG_DEBUG_IO("statemove end in %s",
 357                 tap_state_name(cmd->cmd.statemove->end_state));
 358
 359         ftdi_end_state(cmd->cmd.statemove->end_state);
 360
 361         /* shortest-path move to desired end state */
 362         if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET)
 363                 move_to_state(tap_get_end_state());
 364 }
 365
 366 /**
 367  * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
 368  * (or SWD) state machine. REVISIT: Not the best method, perhaps.
 369  */
 370 static void ftdi_execute_tms(struct jtag_command *cmd)
 371 {
 372         LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
 373
 374         /* TODO: Missing tap state tracking, also missing from ft2232.c! */
 375         mpsse_clock_tms_cs_out(mpsse_ctx,
 376                 cmd->cmd.tms->bits,
 377                 0,
 378                 cmd->cmd.tms->num_bits,
 379                 false,
 380                 ftdi_jtag_mode);
 381 }
 382
 383 static void ftdi_execute_pathmove(struct jtag_command *cmd)
 384 {
 385         tap_state_t *path = cmd->cmd.pathmove->path;
 386         int num_states  = cmd->cmd.pathmove->num_states;
 387
 388         LOG_DEBUG_IO("pathmove: %i states, current: %s  end: %s", num_states,
 389                 tap_state_name(tap_get_state()),
 390                 tap_state_name(path[num_states-1]));
 391
 392         int state_count = 0;
 393         unsigned bit_count = 0;
 394         uint8_t tms_byte = 0;
 395
 396         LOG_DEBUG_IO("-");
 397
 398         /* this loop verifies that the path is legal and logs each state in the path */
 399         while (num_states--) {
 400
 401                 /* either TMS=0 or TMS=1 must work ... */
 402                 if (tap_state_transition(tap_get_state(), false)
 403                     == path[state_count])
 404                         buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
 405                 else if (tap_state_transition(tap_get_state(), true)
 406                          == path[state_count]) {
 407                         buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
 408
 409                         /* ... or else the caller goofed BADLY */
 410                 } else {
 411                         LOG_ERROR("BUG: %s -> %s isn't a valid "
 412                                 "TAP state transition",
 413                                 tap_state_name(tap_get_state()),
 414                                 tap_state_name(path[state_count]));
 415                         exit(-1);
 416                 }
 417
 418                 tap_set_state(path[state_count]);
 419                 state_count++;
 420
 421                 if (bit_count == 7 || num_states == 0) {
 422                         mpsse_clock_tms_cs_out(mpsse_ctx,
 423                                         &tms_byte,
 424                                         0,
 425                                         bit_count,
 426                                         false,
 427                                         ftdi_jtag_mode);
 428                         bit_count = 0;
 429                 }
 430         }
 431         tap_set_end_state(tap_get_state());
 432 }
 433
 434 static void ftdi_execute_scan(struct jtag_command *cmd)
 435 {
 436         LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
 437                 jtag_scan_type(cmd->cmd.scan));
 438
 439         /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
 440         while (cmd->cmd.scan->num_fields > 0
 441                         && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
 442                 cmd->cmd.scan->num_fields--;
 443                 LOG_DEBUG_IO("discarding trailing empty field");
 444         }
 445
 446         if (cmd->cmd.scan->num_fields == 0) {
 447                 LOG_DEBUG_IO("empty scan, doing nothing");
 448                 return;
 449         }
 450
 451         if (cmd->cmd.scan->ir_scan) {
 452                 if (tap_get_state() != TAP_IRSHIFT)
 453                         move_to_state(TAP_IRSHIFT);
 454         } else {
 455                 if (tap_get_state() != TAP_DRSHIFT)
 456                         move_to_state(TAP_DRSHIFT);
 457         }
 458
 459         ftdi_end_state(cmd->cmd.scan->end_state);
 460
 461         struct scan_field *field = cmd->cmd.scan->fields;
 462         unsigned scan_size = 0;
 463
 464         for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
 465                 scan_size += field->num_bits;
 466                 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
 467                         field->in_value ? "in" : "",
 468                         field->out_value ? "out" : "",
 469                         i,
 470                         cmd->cmd.scan->num_fields,
 471                         field->num_bits);
 472
 473                 if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
 474                         /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
 475                          * movement. This last field can't have length zero, it was checked above. */
 476                         mpsse_clock_data(mpsse_ctx,
 477                                 field->out_value,
 478                                 0,
 479                                 field->in_value,
 480                                 0,
 481                                 field->num_bits - 1,
 482                                 ftdi_jtag_mode);
 483                         uint8_t last_bit = 0;
 484                         if (field->out_value)
 485                                 bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
 486
 487                         /* If endstate is TAP_IDLE, clock out 1-1-0 (->EXIT1 ->UPDATE ->IDLE)
 488                          * Otherwise, clock out 1-0 (->EXIT1 ->PAUSE)
 489                          */
 490                         uint8_t tms_bits = 0x03;
 491                         mpsse_clock_tms_cs(mpsse_ctx,
 492                                         &tms_bits,
 493                                         0,
 494                                         field->in_value,
 495                                         field->num_bits - 1,
 496                                         1,
 497                                         last_bit,
 498                                         ftdi_jtag_mode);
 499                         tap_set_state(tap_state_transition(tap_get_state(), 1));
 500                         if (tap_get_end_state() == TAP_IDLE) {
 501                                 mpsse_clock_tms_cs_out(mpsse_ctx,
 502                                                 &tms_bits,
 503                                                 1,
 504                                                 2,
 505                                                 last_bit,
 506                                                 ftdi_jtag_mode);
 507                                 tap_set_state(tap_state_transition(tap_get_state(), 1));
 508                                 tap_set_state(tap_state_transition(tap_get_state(), 0));
 509                         } else {
 510                                 mpsse_clock_tms_cs_out(mpsse_ctx,
 511                                                 &tms_bits,
 512                                                 2,
 513                                                 1,
 514                                                 last_bit,
 515                                                 ftdi_jtag_mode);
 516                                 tap_set_state(tap_state_transition(tap_get_state(), 0));
 517                         }
 518                 } else
 519                         mpsse_clock_data(mpsse_ctx,
 520                                 field->out_value,
 521                                 0,
 522                                 field->in_value,
 523                                 0,
 524                                 field->num_bits,
 525                                 ftdi_jtag_mode);
 526         }
 527
 528         if (tap_get_state() != tap_get_end_state())
 529                 move_to_state(tap_get_end_state());
 530
 531         LOG_DEBUG_IO("%s scan, %i bits, end in %s",
 532                 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
 533                 tap_state_name(tap_get_end_state()));
 534 }
 535
 536 static int ftdi_reset(int trst, int srst)
 537 {
 538         struct signal *sig_ntrst = find_signal_by_name("nTRST");
 539         struct signal *sig_nsrst = find_signal_by_name("nSRST");
 540
 541         LOG_DEBUG_IO("reset trst: %i srst %i", trst, srst);
 542
 543         if (!swd_mode) {
 544                 if (trst == 1) {
 545                         if (sig_ntrst)
 546                                 ftdi_set_signal(sig_ntrst, '0');
 547                         else
 548                                 LOG_ERROR("Can't assert TRST: nTRST signal is not defined");
 549                 } else if (sig_ntrst && jtag_get_reset_config() & RESET_HAS_TRST &&
 550                                 trst == 0) {
 551                         if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN)
 552                                 ftdi_set_signal(sig_ntrst, 'z');
 553                         else
 554                                 ftdi_set_signal(sig_ntrst, '1');
 555                 }
 556         }
 557
 558         if (srst == 1) {
 559                 if (sig_nsrst)
 560                         ftdi_set_signal(sig_nsrst, '0');
 561                 else
 562                         LOG_ERROR("Can't assert SRST: nSRST signal is not defined");
 563         } else if (sig_nsrst && jtag_get_reset_config() & RESET_HAS_SRST &&
 564                         srst == 0) {
 565                 if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL)
 566                         ftdi_set_signal(sig_nsrst, '1');
 567                 else
 568                         ftdi_set_signal(sig_nsrst, 'z');
 569         }
 570
 571         return mpsse_flush(mpsse_ctx);
 572 }
 573
 574 static void ftdi_execute_sleep(struct jtag_command *cmd)
 575 {
 576         LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us);
 577
 578         mpsse_flush(mpsse_ctx);
 579         jtag_sleep(cmd->cmd.sleep->us);
 580         LOG_DEBUG_IO("sleep %" PRIu32 " usec while in %s",
 581                 cmd->cmd.sleep->us,
 582                 tap_state_name(tap_get_state()));
 583 }
 584
 585 static void ftdi_execute_stableclocks(struct jtag_command *cmd)
 586 {
 587         /* this is only allowed while in a stable state.  A check for a stable
 588          * state was done in jtag_add_clocks()
 589          */
 590         int num_cycles = cmd->cmd.stableclocks->num_cycles;
 591
 592         /* 7 bits of either ones or zeros. */
 593         uint8_t tms = tap_get_state() == TAP_RESET ? 0x7f : 0x00;
 594
 595         /* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
 596          * the correct level and remain there during the scan */
 597         while (num_cycles > 0) {
 598                 /* there are no state transitions in this code, so omit state tracking */
 599                 unsigned this_len = num_cycles > 7 ? 7 : num_cycles;
 600                 mpsse_clock_tms_cs_out(mpsse_ctx, &tms, 0, this_len, false, ftdi_jtag_mode);
 601                 num_cycles -= this_len;
 602         }
 603
 604         LOG_DEBUG_IO("clocks %i while in %s",
 605                 cmd->cmd.stableclocks->num_cycles,
 606                 tap_state_name(tap_get_state()));
 607 }
 608
 609 static void ftdi_execute_command(struct jtag_command *cmd)
 610 {
 611         switch (cmd->type) {
 612                 case JTAG_RUNTEST:
 613                         ftdi_execute_runtest(cmd);
 614                         break;
 615                 case JTAG_TLR_RESET:
 616                         ftdi_execute_statemove(cmd);
 617                         break;
 618                 case JTAG_PATHMOVE:
 619                         ftdi_execute_pathmove(cmd);
 620                         break;
 621                 case JTAG_SCAN:
 622                         ftdi_execute_scan(cmd);
 623                         break;
 624                 case JTAG_SLEEP:
 625                         ftdi_execute_sleep(cmd);
 626                         break;
 627                 case JTAG_STABLECLOCKS:
 628                         ftdi_execute_stableclocks(cmd);
 629                         break;
 630                 case JTAG_TMS:
 631                         ftdi_execute_tms(cmd);
 632                         break;
 633                 default:
 634                         LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
 635                         break;
 636         }
 637 }
 638
 639 static int ftdi_execute_queue(void)
 640 {
 641         /* blink, if the current layout has that feature */
 642         struct signal *led = find_signal_by_name("LED");
 643         if (led)
 644                 ftdi_set_signal(led, '1');
 645
 646         for (struct jtag_command *cmd = jtag_command_queue; cmd; cmd = cmd->next) {
 647                 /* fill the write buffer with the desired command */
 648                 ftdi_execute_command(cmd);
 649         }
 650
 651         if (led)
 652                 ftdi_set_signal(led, '0');
 653
 654         int retval = mpsse_flush(mpsse_ctx);
 655         if (retval != ERROR_OK)
 656                 LOG_ERROR("error while flushing MPSSE queue: %d", retval);
 657
 658         return retval;
 659 }
 660
 661 static int ftdi_initialize(void)
 662 {
 663         if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
 664                 LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
 665         else
 666                 LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
 667
 668         if (!ftdi_vid[0] && !ftdi_pid[0]) {
 669                 LOG_ERROR("Please specify ftdi vid_pid");
 670                 return ERROR_JTAG_INIT_FAILED;
 671         }
 672
 673         for (int i = 0; ftdi_vid[i] || ftdi_pid[i]; i++) {
 674                 mpsse_ctx = mpsse_open(&ftdi_vid[i], &ftdi_pid[i], ftdi_device_desc,
 675                                 ftdi_serial, adapter_usb_get_location(), ftdi_channel);
 676                 if (mpsse_ctx)
 677                         break;
 678         }
 679
 680         if (!mpsse_ctx)
 681                 return ERROR_JTAG_INIT_FAILED;
 682
 683         output = jtag_output_init;
 684         direction = jtag_direction_init;
 685
 686         if (swd_mode) {
 687                 struct signal *sig = find_signal_by_name("SWD_EN");
 688                 if (!sig) {
 689                         LOG_ERROR("SWD mode is active but SWD_EN signal is not defined");
 690                         return ERROR_JTAG_INIT_FAILED;
 691                 }
 692                 /* A dummy SWD_EN would have zero mask */
 693                 if (sig->data_mask)
 694                         ftdi_set_signal(sig, '1');
 695         }
 696
 697         mpsse_set_data_bits_low_byte(mpsse_ctx, output & 0xff, direction & 0xff);
 698         mpsse_set_data_bits_high_byte(mpsse_ctx, output >> 8, direction >> 8);
 699
 700         mpsse_loopback_config(mpsse_ctx, false);
 701
 702         freq = mpsse_set_frequency(mpsse_ctx, adapter_get_speed_khz() * 1000);
 703
 704         return mpsse_flush(mpsse_ctx);
 705 }
 706
 707 static int ftdi_quit(void)
 708 {
 709         mpsse_close(mpsse_ctx);
 710
 711         struct signal *sig = signals;
 712         while (sig) {
 713                 struct signal *next = sig->next;
 714                 free((void *)sig->name);
 715                 free(sig);
 716                 sig = next;
 717         }
 718
 719         free(ftdi_device_desc);
 720         free(ftdi_serial);
 721
 722         free(swd_cmd_queue);
 723
 724         return ERROR_OK;
 725 }
 726
 727 COMMAND_HANDLER(ftdi_handle_device_desc_command)
 728 {
 729         if (CMD_ARGC == 1) {
 730                 free(ftdi_device_desc);
 731                 ftdi_device_desc = strdup(CMD_ARGV[0]);
 732         } else {
 733                 LOG_ERROR("expected exactly one argument to ftdi device_desc <description>");
 734         }
 735
 736         return ERROR_OK;
 737 }
 738
 739 COMMAND_HANDLER(ftdi_handle_serial_command)
 740 {
 741         if (CMD_ARGC == 1) {
 742                 free(ftdi_serial);
 743                 ftdi_serial = strdup(CMD_ARGV[0]);
 744         } else {
 745                 return ERROR_COMMAND_SYNTAX_ERROR;
 746         }
 747
 748         return ERROR_OK;
 749 }
 750
 751 COMMAND_HANDLER(ftdi_handle_channel_command)
 752 {
 753         if (CMD_ARGC == 1)
 754                 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], ftdi_channel);
 755         else
 756                 return ERROR_COMMAND_SYNTAX_ERROR;
 757
 758         return ERROR_OK;
 759 }
 760
 761 COMMAND_HANDLER(ftdi_handle_layout_init_command)
 762 {
 763         if (CMD_ARGC != 2)
 764                 return ERROR_COMMAND_SYNTAX_ERROR;
 765
 766         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], jtag_output_init);
 767         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], jtag_direction_init);
 768
 769         return ERROR_OK;
 770 }
 771
 772 COMMAND_HANDLER(ftdi_handle_layout_signal_command)
 773 {
 774         if (CMD_ARGC < 1)
 775                 return ERROR_COMMAND_SYNTAX_ERROR;
 776
 777         bool invert_data = false;
 778         uint16_t data_mask = 0;
 779         bool invert_input = false;
 780         uint16_t input_mask = 0;
 781         bool invert_oe = false;
 782         uint16_t oe_mask = 0;
 783         for (unsigned i = 1; i < CMD_ARGC; i += 2) {
 784                 if (strcmp("-data", CMD_ARGV[i]) == 0) {
 785                         invert_data = false;
 786                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], data_mask);
 787                 } else if (strcmp("-ndata", CMD_ARGV[i]) == 0) {
 788                         invert_data = true;
 789                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], data_mask);
 790                 } else if (strcmp("-input", CMD_ARGV[i]) == 0) {
 791                         invert_input = false;
 792                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], input_mask);
 793                 } else if (strcmp("-ninput", CMD_ARGV[i]) == 0) {
 794                         invert_input = true;
 795                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], input_mask);
 796                 } else if (strcmp("-oe", CMD_ARGV[i]) == 0) {
 797                         invert_oe = false;
 798                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
 799                 } else if (strcmp("-noe", CMD_ARGV[i]) == 0) {
 800                         invert_oe = true;
 801                         COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
 802                 } else if (!strcmp("-alias", CMD_ARGV[i]) ||
 803                            !strcmp("-nalias", CMD_ARGV[i])) {
 804                         if (!strcmp("-nalias", CMD_ARGV[i])) {
 805                                 invert_data = true;
 806                                 invert_input = true;
 807                         }
 808                         struct signal *sig = find_signal_by_name(CMD_ARGV[i + 1]);
 809                         if (!sig) {
 810                                 LOG_ERROR("signal %s is not defined", CMD_ARGV[i + 1]);
 811                                 return ERROR_FAIL;
 812                         }
 813                         data_mask = sig->data_mask;
 814                         input_mask = sig->input_mask;
 815                         oe_mask = sig->oe_mask;
 816                         invert_input ^= sig->invert_input;
 817                         invert_oe = sig->invert_oe;
 818                         invert_data ^= sig->invert_data;
 819                 } else {
 820                         LOG_ERROR("unknown option '%s'", CMD_ARGV[i]);
 821                         return ERROR_COMMAND_SYNTAX_ERROR;
 822                 }
 823         }
 824
 825         struct signal *sig;
 826         sig = find_signal_by_name(CMD_ARGV[0]);
 827         if (!sig)
 828                 sig = create_signal(CMD_ARGV[0]);
 829         if (!sig) {
 830                 LOG_ERROR("failed to create signal %s", CMD_ARGV[0]);
 831                 return ERROR_FAIL;
 832         }
 833
 834         sig->invert_data = invert_data;
 835         sig->data_mask = data_mask;
 836         sig->invert_input = invert_input;
 837         sig->input_mask = input_mask;
 838         sig->invert_oe = invert_oe;
 839         sig->oe_mask = oe_mask;
 840
 841         return ERROR_OK;
 842 }
 843
 844 COMMAND_HANDLER(ftdi_handle_set_signal_command)
 845 {
 846         if (CMD_ARGC < 2)
 847                 return ERROR_COMMAND_SYNTAX_ERROR;
 848
 849         struct signal *sig;
 850         sig = find_signal_by_name(CMD_ARGV[0]);
 851         if (!sig) {
 852                 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV[0]);
 853                 return ERROR_FAIL;
 854         }
 855
 856         switch (*CMD_ARGV[1]) {
 857         case '0':
 858         case '1':
 859         case 'z':
 860         case 'Z':
 861                 /* single character level specifier only */
 862                 if (CMD_ARGV[1][1] == '\0') {
 863                         ftdi_set_signal(sig, *CMD_ARGV[1]);
 864                         break;
 865                 }
 866                 /* fallthrough */
 867         default:
 868                 LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV[1]);
 869                 return ERROR_COMMAND_SYNTAX_ERROR;
 870         }
 871
 872         return mpsse_flush(mpsse_ctx);
 873 }
 874
 875 COMMAND_HANDLER(ftdi_handle_get_signal_command)
 876 {
 877         if (CMD_ARGC < 1)
 878                 return ERROR_COMMAND_SYNTAX_ERROR;
 879
 880         struct signal *sig;
 881         uint16_t sig_data = 0;
 882         sig = find_signal_by_name(CMD_ARGV[0]);
 883         if (!sig) {
 884                 LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV[0]);
 885                 return ERROR_FAIL;
 886         }
 887
 888         int ret = ftdi_get_signal(sig, &sig_data);
 889         if (ret != ERROR_OK)
 890                 return ret;
 891
 892         LOG_USER("Signal %s = %#06x", sig->name, sig_data);
 893
 894         return ERROR_OK;
 895 }
 896
 897 COMMAND_HANDLER(ftdi_handle_vid_pid_command)
 898 {
 899         if (CMD_ARGC > MAX_USB_IDS * 2) {
 900                 LOG_WARNING("ignoring extra IDs in ftdi vid_pid "
 901                         "(maximum is %d pairs)", MAX_USB_IDS);
 902                 CMD_ARGC = MAX_USB_IDS * 2;
 903         }
 904         if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
 905                 LOG_WARNING("incomplete ftdi vid_pid configuration directive");
 906                 if (CMD_ARGC < 2)
 907                         return ERROR_COMMAND_SYNTAX_ERROR;
 908                 /* remove the incomplete trailing id */
 909                 CMD_ARGC -= 1;
 910         }
 911
 912         unsigned i;
 913         for (i = 0; i < CMD_ARGC; i += 2) {
 914                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ftdi_vid[i >> 1]);
 915                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ftdi_pid[i >> 1]);
 916         }
 917
 918         /*
 919          * Explicitly terminate, in case there are multiples instances of
 920          * ftdi vid_pid.
 921          */
 922         ftdi_vid[i >> 1] = ftdi_pid[i >> 1] = 0;
 923
 924         return ERROR_OK;
 925 }
 926
 927 COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command)
 928 {
 929         struct jim_nvp *n;
 930         static const struct jim_nvp nvp_ftdi_jtag_modes[] = {
 931                 { .name = "rising", .value = JTAG_MODE },
 932                 { .name = "falling", .value = JTAG_MODE_ALT },
 933                 { .name = NULL, .value = -1 },
 934         };
 935
 936         if (CMD_ARGC > 0) {
 937                 n = jim_nvp_name2value_simple(nvp_ftdi_jtag_modes, CMD_ARGV[0]);
 938                 if (!n->name)
 939                         return ERROR_COMMAND_SYNTAX_ERROR;
 940                 ftdi_jtag_mode = n->value;
 941
 942         }
 943
 944         n = jim_nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode);
 945         command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name);
 946
 947         return ERROR_OK;
 948 }
 949
 950 static const struct command_registration ftdi_subcommand_handlers[] = {
 951         {
 952                 .name = "device_desc",
 953                 .handler = &ftdi_handle_device_desc_command,
 954                 .mode = COMMAND_CONFIG,
 955                 .help = "set the USB device description of the FTDI device",
 956                 .usage = "description_string",
 957         },
 958         {
 959                 .name = "serial",
 960                 .handler = &ftdi_handle_serial_command,
 961                 .mode = COMMAND_CONFIG,
 962                 .help = "set the serial number of the FTDI device",
 963                 .usage = "serial_string",
 964         },
 965         {
 966                 .name = "channel",
 967                 .handler = &ftdi_handle_channel_command,
 968                 .mode = COMMAND_CONFIG,
 969                 .help = "set the channel of the FTDI device that is used as JTAG",
 970                 .usage = "(0-3)",
 971         },
 972         {
 973                 .name = "layout_init",
 974                 .handler = &ftdi_handle_layout_init_command,
 975                 .mode = COMMAND_CONFIG,
 976                 .help = "initialize the FTDI GPIO signals used "
 977                         "to control output-enables and reset signals",
 978                 .usage = "data direction",
 979         },
 980         {
 981                 .name = "layout_signal",
 982                 .handler = &ftdi_handle_layout_signal_command,
 983                 .mode = COMMAND_ANY,
 984                 .help = "define a signal controlled by one or more FTDI GPIO as data "
 985                         "and/or output enable",
 986                 .usage = "name [-data mask|-ndata mask] [-oe mask|-noe mask] [-alias|-nalias name]",
 987         },
 988         {
 989                 .name = "set_signal",
 990                 .handler = &ftdi_handle_set_signal_command,
 991                 .mode = COMMAND_EXEC,
 992                 .help = "control a layout-specific signal",
 993                 .usage = "name (1|0|z)",
 994         },
 995         {
 996                 .name = "get_signal",
 997                 .handler = &ftdi_handle_get_signal_command,
 998                 .mode = COMMAND_EXEC,
 999                 .help = "read the value of a layout-specific signal",
1000                 .usage = "name",
1001         },
1002         {
1003                 .name = "vid_pid",
1004                 .handler = &ftdi_handle_vid_pid_command,
1005                 .mode = COMMAND_CONFIG,
1006                 .help = "the vendor ID and product ID of the FTDI device",
1007                 .usage = "(vid pid)*",
1008         },
1009         {
1010                 .name = "tdo_sample_edge",
1011                 .handler = &ftdi_handle_tdo_sample_edge_command,
1012                 .mode = COMMAND_ANY,
1013                 .help = "set which TCK clock edge is used for sampling TDO "
1014                         "- default is rising-edge (Setting to falling-edge may "
1015                         "allow signalling speed increase)",
1016                 .usage = "(rising|falling)",
1017         },
1018         COMMAND_REGISTRATION_DONE
1019 };
1020
1021 static const struct command_registration ftdi_command_handlers[] = {
1022         {
1023                 .name = "ftdi",
1024                 .mode = COMMAND_ANY,
1025                 .help = "perform ftdi management",
1026                 .chain = ftdi_subcommand_handlers,
1027                 .usage = "",
1028         },
1029         COMMAND_REGISTRATION_DONE
1030 };
1031
1032 static int create_default_signal(const char *name, uint16_t data_mask)
1033 {
1034         struct signal *sig = create_signal(name);
1035         if (!sig) {
1036                 LOG_ERROR("failed to create signal %s", name);
1037                 return ERROR_FAIL;
1038         }
1039         sig->invert_data = false;
1040         sig->data_mask = data_mask;
1041         sig->invert_oe = false;
1042         sig->oe_mask = 0;
1043
1044         return ERROR_OK;
1045 }
1046
1047 static int create_signals(void)
1048 {
1049         if (create_default_signal("TCK", 0x01) != ERROR_OK)
1050                 return ERROR_FAIL;
1051         if (create_default_signal("TDI", 0x02) != ERROR_OK)
1052                 return ERROR_FAIL;
1053         if (create_default_signal("TDO", 0x04) != ERROR_OK)
1054                 return ERROR_FAIL;
1055         if (create_default_signal("TMS", 0x08) != ERROR_OK)
1056                 return ERROR_FAIL;
1057         return ERROR_OK;
1058 }
1059
1060 static int ftdi_swd_init(void)
1061 {
1062         LOG_INFO("FTDI SWD mode enabled");
1063         swd_mode = true;
1064
1065         if (create_signals() != ERROR_OK)
1066                 return ERROR_FAIL;
1067
1068         swd_cmd_queue_alloced = 10;
1069         swd_cmd_queue = malloc(swd_cmd_queue_alloced * sizeof(*swd_cmd_queue));
1070
1071         return swd_cmd_queue ? ERROR_OK : ERROR_FAIL;
1072 }
1073
1074 static void ftdi_swd_swdio_en(bool enable)
1075 {
1076         struct signal *oe = find_signal_by_name("SWDIO_OE");
1077         if (oe) {
1078                 if (oe->data_mask)
1079                         ftdi_set_signal(oe, enable ? '1' : '0');
1080                 else {
1081                         /* Sets TDI/DO pin to input during rx when both pins are connected
1082                            to SWDIO */
1083                         if (enable)
1084                                 direction |= jtag_direction_init & 0x0002U;
1085                         else
1086                                 direction &= ~0x0002U;
1087                         mpsse_set_data_bits_low_byte(mpsse_ctx, output & 0xff, direction & 0xff);
1088                 }
1089         }
1090 }
1091
1092 /**
1093  * Flush the MPSSE queue and process the SWD transaction queue
1094  * @return
1095  */
1096 static int ftdi_swd_run_queue(void)
1097 {
1098         LOG_DEBUG_IO("Executing %zu queued transactions", swd_cmd_queue_length);
1099         int retval;
1100         struct signal *led = find_signal_by_name("LED");
1101
1102         if (queued_retval != ERROR_OK) {
1103                 LOG_DEBUG_IO("Skipping due to previous errors: %d", queued_retval);
1104                 goto skip;
1105         }
1106
1107         /* A transaction must be followed by another transaction or at least 8 idle cycles to
1108          * ensure that data is clocked through the AP. */
1109         mpsse_clock_data_out(mpsse_ctx, NULL, 0, 8, SWD_MODE);
1110
1111         /* Terminate the "blink", if the current layout has that feature */
1112         if (led)
1113                 ftdi_set_signal(led, '0');
1114
1115         queued_retval = mpsse_flush(mpsse_ctx);
1116         if (queued_retval != ERROR_OK) {
1117                 LOG_ERROR("MPSSE failed");
1118                 goto skip;
1119         }
1120
1121         for (size_t i = 0; i < swd_cmd_queue_length; i++) {
1122                 int ack = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1, 3);
1123
1124                 /* Devices do not reply to DP_TARGETSEL write cmd, ignore received ack */
1125                 bool check_ack = swd_cmd_returns_ack(swd_cmd_queue[i].cmd);
1126
1127                 LOG_DEBUG_IO("%s%s %s %s reg %X = %08"PRIx32,
1128                                 check_ack ? "" : "ack ignored ",
1129                                 ack == SWD_ACK_OK ? "OK" : ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK",
1130                                 swd_cmd_queue[i].cmd & SWD_CMD_APNDP ? "AP" : "DP",
1131                                 swd_cmd_queue[i].cmd & SWD_CMD_RNW ? "read" : "write",
1132                                 (swd_cmd_queue[i].cmd & SWD_CMD_A32) >> 1,
1133                                 buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn,
1134                                                 1 + 3 + (swd_cmd_queue[i].cmd & SWD_CMD_RNW ? 0 : 1), 32));
1135
1136                 if (ack != SWD_ACK_OK && check_ack) {
1137                         queued_retval = swd_ack_to_error_code(ack);
1138                         goto skip;
1139
1140                 } else if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
1141                         uint32_t data = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3, 32);
1142                         int parity = buf_get_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 32, 1);
1143
1144                         if (parity != parity_u32(data)) {
1145                                 LOG_ERROR("SWD Read data parity mismatch");
1146                                 queued_retval = ERROR_FAIL;
1147                                 goto skip;
1148                         }
1149
1150                         if (swd_cmd_queue[i].dst)
1151                                 *swd_cmd_queue[i].dst = data;
1152                 }
1153         }
1154
1155 skip:
1156         swd_cmd_queue_length = 0;
1157         retval = queued_retval;
1158         queued_retval = ERROR_OK;
1159
1160         /* Queue a new "blink" */
1161         if (led && retval == ERROR_OK)
1162                 ftdi_set_signal(led, '1');
1163
1164         return retval;
1165 }
1166
1167 static void ftdi_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
1168 {
1169         if (swd_cmd_queue_length >= swd_cmd_queue_alloced) {
1170                 /* Not enough room in the queue. Run the queue and increase its size for next time.
1171                  * Note that it's not possible to avoid running the queue here, because mpsse contains
1172                  * pointers into the queue which may be invalid after the realloc. */
1173                 queued_retval = ftdi_swd_run_queue();
1174                 struct swd_cmd_queue_entry *q = realloc(swd_cmd_queue, swd_cmd_queue_alloced * 2 * sizeof(*swd_cmd_queue));
1175                 if (q) {
1176                         swd_cmd_queue = q;
1177                         swd_cmd_queue_alloced *= 2;
1178                         LOG_DEBUG("Increased SWD command queue to %zu elements", swd_cmd_queue_alloced);
1179                 }
1180         }
1181
1182         if (queued_retval != ERROR_OK)
1183                 return;
1184
1185         size_t i = swd_cmd_queue_length++;
1186         swd_cmd_queue[i].cmd = cmd | SWD_CMD_START | SWD_CMD_PARK;
1187
1188         mpsse_clock_data_out(mpsse_ctx, &swd_cmd_queue[i].cmd, 0, 8, SWD_MODE);
1189
1190         if (swd_cmd_queue[i].cmd & SWD_CMD_RNW) {
1191                 /* Queue a read transaction */
1192                 swd_cmd_queue[i].dst = dst;
1193
1194                 ftdi_swd_swdio_en(false);
1195                 mpsse_clock_data_in(mpsse_ctx, swd_cmd_queue[i].trn_ack_data_parity_trn,
1196                                 0, 1 + 3 + 32 + 1 + 1, SWD_MODE);
1197                 ftdi_swd_swdio_en(true);
1198         } else {
1199                 /* Queue a write transaction */
1200                 ftdi_swd_swdio_en(false);
1201
1202                 mpsse_clock_data_in(mpsse_ctx, swd_cmd_queue[i].trn_ack_data_parity_trn,
1203                                 0, 1 + 3 + 1, SWD_MODE);
1204
1205                 ftdi_swd_swdio_en(true);
1206
1207                 buf_set_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 1, 32, data);
1208                 buf_set_u32(swd_cmd_queue[i].trn_ack_data_parity_trn, 1 + 3 + 1 + 32, 1, parity_u32(data));
1209
1210                 mpsse_clock_data_out(mpsse_ctx, swd_cmd_queue[i].trn_ack_data_parity_trn,
1211                                 1 + 3 + 1, 32 + 1, SWD_MODE);
1212         }
1213
1214         /* Insert idle cycles after AP accesses to avoid WAIT */
1215         if (cmd & SWD_CMD_APNDP)
1216                 mpsse_clock_data_out(mpsse_ctx, NULL, 0, ap_delay_clk, SWD_MODE);
1217
1218 }
1219
1220 static void ftdi_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1221 {
1222         assert(cmd & SWD_CMD_RNW);
1223         ftdi_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
1224 }
1225
1226 static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1227 {
1228         assert(!(cmd & SWD_CMD_RNW));
1229         ftdi_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
1230 }
1231
1232 static int ftdi_swd_switch_seq(enum swd_special_seq seq)
1233 {
1234         switch (seq) {
1235         case LINE_RESET:
1236                 LOG_DEBUG("SWD line reset");
1237                 ftdi_swd_swdio_en(true);
1238                 mpsse_clock_data_out(mpsse_ctx, swd_seq_line_reset, 0, swd_seq_line_reset_len, SWD_MODE);
1239                 break;
1240         case JTAG_TO_SWD:
1241                 LOG_DEBUG("JTAG-to-SWD");
1242                 ftdi_swd_swdio_en(true);
1243                 mpsse_clock_data_out(mpsse_ctx, swd_seq_jtag_to_swd, 0, swd_seq_jtag_to_swd_len, SWD_MODE);
1244                 break;
1245         case JTAG_TO_DORMANT:
1246                 LOG_DEBUG("JTAG-to-DORMANT");
1247                 ftdi_swd_swdio_en(true);
1248                 mpsse_clock_data_out(mpsse_ctx, swd_seq_jtag_to_dormant, 0, swd_seq_jtag_to_dormant_len, SWD_MODE);
1249                 break;
1250         case SWD_TO_JTAG:
1251                 LOG_DEBUG("SWD-to-JTAG");
1252                 ftdi_swd_swdio_en(true);
1253                 mpsse_clock_data_out(mpsse_ctx, swd_seq_swd_to_jtag, 0, swd_seq_swd_to_jtag_len, SWD_MODE);
1254                 break;
1255         case SWD_TO_DORMANT:
1256                 LOG_DEBUG("SWD-to-DORMANT");
1257                 ftdi_swd_swdio_en(true);
1258                 mpsse_clock_data_out(mpsse_ctx, swd_seq_swd_to_dormant, 0, swd_seq_swd_to_dormant_len, SWD_MODE);
1259                 break;
1260         case DORMANT_TO_SWD:
1261                 LOG_DEBUG("DORMANT-to-SWD");
1262                 ftdi_swd_swdio_en(true);
1263                 mpsse_clock_data_out(mpsse_ctx, swd_seq_dormant_to_swd, 0, swd_seq_dormant_to_swd_len, SWD_MODE);
1264                 break;
1265         case DORMANT_TO_JTAG:
1266                 LOG_DEBUG("DORMANT-to-JTAG");
1267                 ftdi_swd_swdio_en(true);
1268                 mpsse_clock_data_out(mpsse_ctx, swd_seq_dormant_to_jtag, 0, swd_seq_dormant_to_jtag_len, SWD_MODE);
1269                 break;
1270         default:
1271                 LOG_ERROR("Sequence %d not supported", seq);
1272                 return ERROR_FAIL;
1273         }
1274
1275         return ERROR_OK;
1276 }
1277
1278 static const struct swd_driver ftdi_swd = {
1279         .init = ftdi_swd_init,
1280         .switch_seq = ftdi_swd_switch_seq,
1281         .read_reg = ftdi_swd_read_reg,
1282         .write_reg = ftdi_swd_write_reg,
1283         .run = ftdi_swd_run_queue,
1284 };
1285
1286 static const char * const ftdi_transports[] = { "jtag", "swd", NULL };
1287
1288 static struct jtag_interface ftdi_interface = {
1289         .supported = DEBUG_CAP_TMS_SEQ,
1290         .execute_queue = ftdi_execute_queue,
1291 };
1292
1293 struct adapter_driver ftdi_adapter_driver = {
1294         .name = "ftdi",
1295         .transports = ftdi_transports,
1296         .commands = ftdi_command_handlers,
1297
1298         .init = ftdi_initialize,
1299         .quit = ftdi_quit,
1300         .reset = ftdi_reset,
1301         .speed = ftdi_speed,
1302         .khz = ftdi_khz,
1303         .speed_div = ftdi_speed_div,
1304
1305         .jtag_ops = &ftdi_interface,
1306         .swd_ops = &ftdi_swd,
1307 };