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

   1 /***************************************************************************
   2 *   Copyright (C) 2009 by Øyvind Harboe                                   *
   3 *       Øyvind Harboe <oyvind.harboe@zylin.com>                               *
   4 *                                                                         *
   5 *   Copyright (C) 2009 by SoftPLC Corporation.  http://softplc.com        *
   6 *       Dick Hollenbeck <dick@softplc.com>                                    *
   7 *                                                                         *
   8 *   Copyright (C) 2004, 2006 by Dominic Rath                              *
   9 *   Dominic.Rath@gmx.de                                                   *
  10 *                                                                         *
  11 *   Copyright (C) 2008 by Spencer Oliver                                  *
  12 *   spen@spen-soft.co.uk                                                  *
  13 *                                                                         *
  14 *   This program is free software; you can redistribute it and/or modify  *
  15 *   it under the terms of the GNU General Public License as published by  *
  16 *   the Free Software Foundation; either version 2 of the License, or     *
  17 *   (at your option) any later version.                                   *
  18 *                                                                         *
  19 *   This program is distributed in the hope that it will be useful,       *
  20 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  21 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  22 *   GNU General Public License for more details.                          *
  23 *                                                                         *
  24 *   You should have received a copy of the GNU General Public License     *
  25 *   along with this program; if not, write to the                         *
  26 *   Free Software Foundation, Inc.,                                       *
  27 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  28 ***************************************************************************/
  29
  30 /**
  31  * @file
  32  * JTAG adapters based on the FT2232 full and high speed USB parts are
  33  * popular low cost JTAG debug solutions.  Many FT2232 based JTAG adapters
  34  * are discrete, but development boards may integrate them as alternatives
  35  * to more capable (and expensive) third party JTAG pods.
  36  *
  37  * JTAG uses only one of the two communications channels ("MPSSE engines")
  38  * on these devices.  Adapters based on FT4232 parts have four ports/channels
  39  * (A/B/C/D), instead of just two (A/B).
  40  *
  41  * Especially on development boards integrating one of these chips (as
  42  * opposed to discrete pods/dongles), the additional channels can be used
  43  * for a variety of purposes, but OpenOCD only uses one channel at a time.
  44  *
  45  *  - As a USB-to-serial adapter for the target's console UART ...
  46  *    which may be able to support ROM boot loaders that load initial
  47  *    firmware images to flash (or SRAM).
  48  *
  49  *  - On systems which support ARM's SWD in addition to JTAG, or instead
  50  *    of it, that second port can be used for reading SWV/SWO trace data.
  51  *
  52  *  - Additional JTAG links, e.g. to a CPLD or * FPGA.
  53  *
  54  * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
  55  * request/response interactions involve round trips over the USB link.
  56  * A "smart" JTAG adapter has intelligence close to the scan chain, so it
  57  * can for example poll quickly for a status change (usually taking on the
  58  * order of microseconds not milliseconds) before beginning a queued
  59  * transaction which require the previous one to have completed.
  60  *
  61  * There are dozens of adapters of this type, differing in details which
  62  * this driver needs to understand.  Those "layout" details are required
  63  * as part of FT2232 driver configuration.
  64  *
  65  * This code uses information contained in the MPSSE specification which was
  66  * found here:
  67  * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
  68  * Hereafter this is called the "MPSSE Spec".
  69  *
  70  * The datasheet for the ftdichip.com's FT2232D part is here:
  71  * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
  72  *
  73  * Also note the issue with code 0x4b (clock data to TMS) noted in
  74  * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
  75  * which can affect longer JTAG state paths.
  76  */
  77
  78 #ifdef HAVE_CONFIG_H
  79 #include "config.h"
  80 #endif
  81
  82 /* project specific includes */
  83 #include <jtag/interface.h>
  84 #include <transport/transport.h>
  85 #include <helper/time_support.h>
  86
  87 #if IS_CYGWIN == 1
  88 #include <windows.h>
  89 #endif
  90
  91 #include <assert.h>
  92
  93 #if (BUILD_FT2232_FTD2XX == 1 && BUILD_FT2232_LIBFTDI == 1)
  94 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
  95 #elif (BUILD_FT2232_FTD2XX != 1 && BUILD_FT2232_LIBFTDI != 1)
  96 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
  97 #endif
  98
  99 /* FT2232 access library includes */
 100 #if BUILD_FT2232_FTD2XX == 1
 101 #include <ftd2xx.h>
 102 #include "ftd2xx_common.h"
 103
 104 enum ftdi_interface {
 105         INTERFACE_ANY = 0,
 106         INTERFACE_A   = 1,
 107         INTERFACE_B   = 2,
 108         INTERFACE_C   = 3,
 109         INTERFACE_D   = 4
 110 };
 111
 112 #elif BUILD_FT2232_LIBFTDI == 1
 113 #include <ftdi.h>
 114 #endif
 115
 116 /* max TCK for the high speed devices 30000 kHz */
 117 #define FTDI_x232H_MAX_TCK      30000
 118 /* max TCK for the full speed devices 6000 kHz */
 119 #define FTDI_2232C_MAX_TCK 6000
 120 /* this speed value tells that RTCK is requested */
 121 #define RTCK_SPEED -1
 122
 123 /*
 124  * On my Athlon XP 1900+ EHCI host with FT2232H JTAG dongle I get read timeout
 125  * errors with a retry count of 100. Increasing it solves the problem for me.
 126  *      - Dimitar
 127  *
 128  * FIXME There's likely an issue with the usb_read_timeout from libftdi.
 129  * Fix that (libusb? kernel? libftdi? here?) and restore the retry count
 130  * to something sane.
 131  */
 132 #define LIBFTDI_READ_RETRY_COUNT                2000
 133
 134 #ifndef BUILD_FT2232_HIGHSPEED
 135  #if BUILD_FT2232_FTD2XX == 1
 136         enum { FT_DEVICE_2232H = 6, FT_DEVICE_4232H, FT_DEVICE_232H };
 137  #elif BUILD_FT2232_LIBFTDI == 1
 138         enum ftdi_chip_type { TYPE_2232H = 4, TYPE_4232H = 5, TYPE_232H = 6 };
 139  #endif
 140 #endif
 141
 142 /**
 143  * Send out \a num_cycles on the TCK line while the TAP(s) are in a
 144  * stable state.  Calling code must ensure that current state is stable,
 145  * that verification is not done in here.
 146  *
 147  * @param num_cycles The number of clocks cycles to send.
 148  * @param cmd The command to send.
 149  *
 150  * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
 151  */
 152 static int ft2232_stableclocks(int num_cycles, struct jtag_command *cmd);
 153
 154 static char *ft2232_device_desc_A;
 155 static char *ft2232_device_desc;
 156 static char *ft2232_serial;
 157 static uint8_t ft2232_latency = 2;
 158 static unsigned ft2232_max_tck = FTDI_2232C_MAX_TCK;
 159 static int ft2232_channel = INTERFACE_ANY;
 160
 161 #define MAX_USB_IDS 8
 162 /* vid = pid = 0 marks the end of the list */
 163 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
 164 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
 165
 166 struct ft2232_layout {
 167         char *name;
 168         int (*init)(void);
 169         void (*reset)(int trst, int srst);
 170         void (*blink)(void);
 171         int channel;
 172 };
 173
 174 /* init procedures for supported layouts */
 175 static int usbjtag_init(void);
 176 static int jtagkey_init(void);
 177 static int lm3s811_jtag_init(void);
 178 static int icdi_jtag_init(void);
 179 static int olimex_jtag_init(void);
 180 static int flyswatter1_init(void);
 181 static int flyswatter2_init(void);
 182 static int minimodule_init(void);
 183 static int turtle_init(void);
 184 static int comstick_init(void);
 185 static int stm32stick_init(void);
 186 static int axm0432_jtag_init(void);
 187 static int sheevaplug_init(void);
 188 static int icebear_jtag_init(void);
 189 static int cortino_jtag_init(void);
 190 static int signalyzer_init(void);
 191 static int signalyzer_h_init(void);
 192 static int ktlink_init(void);
 193 static int redbee_init(void);
 194 static int lisa_l_init(void);
 195 static int flossjtag_init(void);
 196 static int xds100v2_init(void);
 197 static int digilent_hs1_init(void);
 198
 199 /* reset procedures for supported layouts */
 200 static void ftx23_reset(int trst, int srst);
 201 static void jtagkey_reset(int trst, int srst);
 202 static void olimex_jtag_reset(int trst, int srst);
 203 static void flyswatter1_reset(int trst, int srst);
 204 static void flyswatter2_reset(int trst, int srst);
 205 static void minimodule_reset(int trst, int srst);
 206 static void turtle_reset(int trst, int srst);
 207 static void comstick_reset(int trst, int srst);
 208 static void stm32stick_reset(int trst, int srst);
 209 static void axm0432_jtag_reset(int trst, int srst);
 210 static void sheevaplug_reset(int trst, int srst);
 211 static void icebear_jtag_reset(int trst, int srst);
 212 static void signalyzer_h_reset(int trst, int srst);
 213 static void ktlink_reset(int trst, int srst);
 214 static void redbee_reset(int trst, int srst);
 215 static void xds100v2_reset(int trst, int srst);
 216 static void digilent_hs1_reset(int trst, int srst);
 217
 218 /* blink procedures for layouts that support a blinking led */
 219 static void olimex_jtag_blink(void);
 220 static void flyswatter1_jtag_blink(void);
 221 static void flyswatter2_jtag_blink(void);
 222 static void turtle_jtag_blink(void);
 223 static void signalyzer_h_blink(void);
 224 static void ktlink_blink(void);
 225 static void lisa_l_blink(void);
 226 static void flossjtag_blink(void);
 227
 228 /* common transport support options */
 229
 230 /* static const char *jtag_and_swd[] = { "jtag", "swd", NULL }; */
 231
 232 static const struct ft2232_layout  ft2232_layouts[] = {
 233         { .name = "usbjtag",
 234                 .init = usbjtag_init,
 235                 .reset = ftx23_reset,
 236         },
 237         { .name = "jtagkey",
 238                 .init = jtagkey_init,
 239                 .reset = jtagkey_reset,
 240         },
 241         { .name = "jtagkey_prototype_v1",
 242                 .init = jtagkey_init,
 243                 .reset = jtagkey_reset,
 244         },
 245         { .name = "oocdlink",
 246                 .init = jtagkey_init,
 247                 .reset = jtagkey_reset,
 248         },
 249         { .name = "signalyzer",
 250                 .init = signalyzer_init,
 251                 .reset = ftx23_reset,
 252         },
 253         { .name = "evb_lm3s811",
 254                 .init = lm3s811_jtag_init,
 255                 .reset = ftx23_reset,
 256         },
 257         { .name = "luminary_icdi",
 258                 .init = icdi_jtag_init,
 259                 .reset = ftx23_reset,
 260         },
 261         { .name = "olimex-jtag",
 262                 .init = olimex_jtag_init,
 263                 .reset = olimex_jtag_reset,
 264                 .blink = olimex_jtag_blink
 265         },
 266         { .name = "flyswatter",
 267                 .init = flyswatter1_init,
 268                 .reset = flyswatter1_reset,
 269                 .blink = flyswatter1_jtag_blink
 270         },
 271         { .name = "flyswatter2",
 272                 .init = flyswatter2_init,
 273                 .reset = flyswatter2_reset,
 274                 .blink = flyswatter2_jtag_blink
 275         },
 276         { .name = "minimodule",
 277                 .init = minimodule_init,
 278                 .reset = minimodule_reset,
 279         },
 280         { .name = "turtelizer2",
 281                 .init = turtle_init,
 282                 .reset = turtle_reset,
 283                 .blink = turtle_jtag_blink
 284         },
 285         { .name = "comstick",
 286                 .init = comstick_init,
 287                 .reset = comstick_reset,
 288         },
 289         { .name = "stm32stick",
 290                 .init = stm32stick_init,
 291                 .reset = stm32stick_reset,
 292         },
 293         { .name = "axm0432_jtag",
 294                 .init = axm0432_jtag_init,
 295                 .reset = axm0432_jtag_reset,
 296         },
 297         { .name = "sheevaplug",
 298                 .init = sheevaplug_init,
 299                 .reset = sheevaplug_reset,
 300         },
 301         { .name = "icebear",
 302                 .init = icebear_jtag_init,
 303                 .reset = icebear_jtag_reset,
 304         },
 305         { .name = "cortino",
 306                 .init = cortino_jtag_init,
 307                 .reset = comstick_reset,
 308         },
 309         { .name = "signalyzer-h",
 310                 .init = signalyzer_h_init,
 311                 .reset = signalyzer_h_reset,
 312                 .blink = signalyzer_h_blink
 313         },
 314         { .name = "ktlink",
 315                 .init = ktlink_init,
 316                 .reset = ktlink_reset,
 317                 .blink = ktlink_blink
 318         },
 319         { .name = "redbee-econotag",
 320                 .init = redbee_init,
 321                 .reset = redbee_reset,
 322         },
 323         { .name = "redbee-usb",
 324                 .init = redbee_init,
 325                 .reset = redbee_reset,
 326                 .channel = INTERFACE_B,
 327         },
 328         { .name = "lisa-l",
 329                 .init = lisa_l_init,
 330                 .reset = ftx23_reset,
 331                 .blink = lisa_l_blink,
 332                 .channel = INTERFACE_B,
 333         },
 334         { .name = "flossjtag",
 335                 .init = flossjtag_init,
 336                 .reset = ftx23_reset,
 337                 .blink = flossjtag_blink,
 338         },
 339         { .name = "xds100v2",
 340                 .init = xds100v2_init,
 341                 .reset = xds100v2_reset,
 342         },
 343         { .name = "digilent-hs1",
 344                 .init = digilent_hs1_init,
 345                 .reset = digilent_hs1_reset,
 346                 .channel = INTERFACE_A,
 347         },
 348         { .name = NULL, /* END OF TABLE */ },
 349 };
 350
 351 /* bitmask used to drive nTRST; usually a GPIOLx signal */
 352 static uint8_t nTRST;
 353 static uint8_t nTRSTnOE;
 354 /* bitmask used to drive nSRST; usually a GPIOLx signal */
 355 static uint8_t nSRST;
 356 static uint8_t nSRSTnOE;
 357
 358 /** the layout being used with this debug session */
 359 static const struct ft2232_layout *layout;
 360
 361 /** default bitmask values driven on DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
 362 static uint8_t low_output;
 363
 364 /* note that direction bit == 1 means that signal is an output */
 365
 366 /** default direction bitmask for DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
 367 static uint8_t low_direction;
 368 /** default value bitmask for CBUS GPIOH(0..4) */
 369 static uint8_t high_output;
 370 /** default direction bitmask for CBUS GPIOH(0..4) */
 371 static uint8_t high_direction;
 372
 373 #if BUILD_FT2232_FTD2XX == 1
 374 static FT_HANDLE ftdih;
 375 static FT_DEVICE ftdi_device;
 376 #elif BUILD_FT2232_LIBFTDI == 1
 377 static struct ftdi_context ftdic;
 378 static enum ftdi_chip_type ftdi_device;
 379 #endif
 380
 381 static struct jtag_command *first_unsent;       /* next command that has to be sent */
 382 static int require_send;
 383
 384 /*      http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
 385
 386         "There is a significant difference between libftdi and libftd2xx. The latter
 387         one allows to schedule up to 64*64 bytes of result data while libftdi fails
 388         with more than 4*64. As a consequence, the FT2232 driver is forced to
 389         perform around 16x more USB transactions for long command streams with TDO
 390         capture when running with libftdi."
 391
 392         No idea how we get
 393         #define FT2232_BUFFER_SIZE 131072
 394         a comment would have been nice.
 395 */
 396
 397 #if BUILD_FT2232_FTD2XX == 1
 398 #define FT2232_BUFFER_READ_QUEUE_SIZE (64*64)
 399 #else
 400 #define FT2232_BUFFER_READ_QUEUE_SIZE (64*4)
 401 #endif
 402
 403 #define FT2232_BUFFER_SIZE 131072
 404
 405 static uint8_t *ft2232_buffer;
 406 static int ft2232_buffer_size;
 407 static int ft2232_read_pointer;
 408 static int ft2232_expect_read;
 409
 410 /**
 411  * Function buffer_write
 412  * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
 413  * @param val is the byte to send.
 414  */
 415 static inline void buffer_write(uint8_t val)
 416 {
 417         assert(ft2232_buffer);
 418         assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
 419         ft2232_buffer[ft2232_buffer_size++] = val;
 420 }
 421
 422 /**
 423  * Function buffer_read
 424  * returns a byte from the byte buffer.
 425  */
 426 static inline uint8_t buffer_read(void)
 427 {
 428         assert(ft2232_buffer);
 429         assert(ft2232_read_pointer < ft2232_buffer_size);
 430         return ft2232_buffer[ft2232_read_pointer++];
 431 }
 432
 433 /**
 434  * Clocks out \a bit_count bits on the TMS line, starting with the least
 435  * significant bit of tms_bits and progressing to more significant bits.
 436  * Rigorous state transition logging is done here via tap_set_state().
 437  *
 438  * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
 439  *      0x4b or 0x6b.  See the MPSSE spec referenced above for their
 440  *      functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
 441  *      is often used for this, 0x4b.
 442  *
 443  * @param tms_bits Holds the sequence of bits to send.
 444  * @param tms_count Tells how many bits in the sequence.
 445  * @param tdi_bit A single bit to pass on to TDI before the first TCK
 446  *      cycle and held static for the duration of TMS clocking.
 447  *
 448  * See the MPSSE spec referenced above.
 449  */
 450 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
 451 {
 452         uint8_t tms_byte;
 453         int i;
 454         int tms_ndx;    /* bit index into tms_byte */
 455
 456         assert(tms_count > 0);
 457
 458         DEBUG_JTAG_IO("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d",
 459                 mpsse_cmd, tms_bits, tms_count);
 460
 461         for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits >>= 1) {
 462                 bool bit = tms_bits & 1;
 463
 464                 if (bit)
 465                         tms_byte |= (1 << tms_ndx);
 466
 467                 /* always do state transitions in public view */
 468                 tap_set_state(tap_state_transition(tap_get_state(), bit));
 469
 470                 /*      we wrote a bit to tms_byte just above, increment bit index.  if bit was zero
 471                  * also increment.
 472                 */
 473                 ++tms_ndx;
 474
 475                 if (tms_ndx == 7 || i == tms_count-1) {
 476                         buffer_write(mpsse_cmd);
 477                         buffer_write(tms_ndx - 1);
 478
 479                         /*      Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
 480                          * TMS/CS and is held static for the duration of TMS/CS clocking.
 481                         */
 482                         buffer_write(tms_byte | (tdi_bit << 7));
 483                 }
 484         }
 485 }
 486
 487 /**
 488  * Function get_tms_buffer_requirements
 489  * returns what clock_tms() will consume if called with
 490  * same \a bit_count.
 491  */
 492 static inline int get_tms_buffer_requirements(int bit_count)
 493 {
 494         return ((bit_count + 6)/7) * 3;
 495 }
 496
 497 /**
 498  * Function move_to_state
 499  * moves the TAP controller from the current state to a
 500  * \a goal_state through a path given by tap_get_tms_path().  State transition
 501  * logging is performed by delegation to clock_tms().
 502  *
 503  * @param goal_state is the destination state for the move.
 504  */
 505 static void move_to_state(tap_state_t goal_state)
 506 {
 507         tap_state_t start_state = tap_get_state();
 508
 509         /*      goal_state is 1/2 of a tuple/pair of states which allow convenient
 510          * lookup of the required TMS pattern to move to this state from the start state.
 511         */
 512
 513         /* do the 2 lookups */
 514         int tms_bits  = tap_get_tms_path(start_state, goal_state);
 515         int tms_count = tap_get_tms_path_len(start_state, goal_state);
 516
 517         DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
 518
 519         clock_tms(0x4b,  tms_bits, tms_count, 0);
 520 }
 521
 522 static int ft2232_write(uint8_t *buf, int size, uint32_t *bytes_written)
 523 {
 524 #if BUILD_FT2232_FTD2XX == 1
 525         FT_STATUS status;
 526         DWORD dw_bytes_written = 0;
 527         status = FT_Write(ftdih, buf, size, &dw_bytes_written);
 528         if (status != FT_OK) {
 529                 *bytes_written = dw_bytes_written;
 530                 LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(status));
 531                 return ERROR_JTAG_DEVICE_ERROR;
 532         } else
 533                 *bytes_written = dw_bytes_written;
 534
 535 #elif BUILD_FT2232_LIBFTDI == 1
 536         int retval = ftdi_write_data(&ftdic, buf, size);
 537         if (retval < 0) {
 538                 *bytes_written = 0;
 539                 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
 540                 return ERROR_JTAG_DEVICE_ERROR;
 541         } else
 542                 *bytes_written = retval;
 543
 544 #endif
 545
 546         if (*bytes_written != (uint32_t)size)
 547                 return ERROR_JTAG_DEVICE_ERROR;
 548
 549         return ERROR_OK;
 550 }
 551
 552 static int ft2232_read(uint8_t *buf, uint32_t size, uint32_t *bytes_read)
 553 {
 554 #if BUILD_FT2232_FTD2XX == 1
 555         DWORD dw_bytes_read;
 556         FT_STATUS status;
 557         int timeout = 5;
 558         *bytes_read = 0;
 559
 560         while ((*bytes_read < size) && timeout--) {
 561                 status = FT_Read(ftdih, buf + *bytes_read, size -
 562                                 *bytes_read, &dw_bytes_read);
 563                 if (status != FT_OK) {
 564                         *bytes_read = 0;
 565                         LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(status));
 566                         return ERROR_JTAG_DEVICE_ERROR;
 567                 }
 568                 *bytes_read += dw_bytes_read;
 569         }
 570
 571 #elif BUILD_FT2232_LIBFTDI == 1
 572         int retval;
 573         int timeout = LIBFTDI_READ_RETRY_COUNT;
 574         *bytes_read = 0;
 575
 576         while ((*bytes_read < size) && timeout--) {
 577                 retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read);
 578                 if (retval < 0) {
 579                         *bytes_read = 0;
 580                         LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
 581                         return ERROR_JTAG_DEVICE_ERROR;
 582                 }
 583                 *bytes_read += retval;
 584         }
 585
 586 #endif
 587
 588         if (*bytes_read < size) {
 589                 LOG_ERROR("couldn't read enough bytes from "
 590                         "FT2232 device (%i < %i)",
 591                         (unsigned)*bytes_read,
 592                         (unsigned)size);
 593                 return ERROR_JTAG_DEVICE_ERROR;
 594         }
 595
 596         return ERROR_OK;
 597 }
 598
 599 static bool ft2232_device_is_highspeed(void)
 600 {
 601 #if BUILD_FT2232_FTD2XX == 1
 602         return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H)
 603  #ifdef HAS_ENUM_FT232H
 604                 || (ftdi_device == FT_DEVICE_232H)
 605  #endif
 606         ;
 607 #elif BUILD_FT2232_LIBFTDI == 1
 608         return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H
 609  #ifdef HAS_ENUM_FT232H
 610                 || ftdi_device == TYPE_232H
 611  #endif
 612         );
 613 #endif
 614 }
 615
 616 /*
 617  * Commands that only apply to the highspeed FTx232H devices (FT2232H, FT4232H, FT232H).
 618  * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
 619  * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
 620  */
 621
 622 static int ftx232h_adaptive_clocking(bool enable)
 623 {
 624         uint8_t buf = enable ? 0x96 : 0x97;
 625         LOG_DEBUG("%2.2x", buf);
 626
 627         uint32_t bytes_written;
 628         int retval;
 629
 630         retval = ft2232_write(&buf, sizeof(buf), &bytes_written);
 631         if (retval != ERROR_OK) {
 632                 LOG_ERROR("couldn't write command to %s adaptive clocking"
 633                         , enable ? "enable" : "disable");
 634                 return retval;
 635         }
 636
 637         return ERROR_OK;
 638 }
 639
 640 /**
 641  * Enable/disable the clk divide by 5 of the 60MHz master clock.
 642  * This result in a JTAG clock speed range of 91.553Hz-6MHz
 643  * respective 457.763Hz-30MHz.
 644  */
 645 static int ftx232h_clk_divide_by_5(bool enable)
 646 {
 647         uint32_t bytes_written;
 648         uint8_t buf = enable ?  0x8b : 0x8a;
 649
 650         if (ft2232_write(&buf, sizeof(buf), &bytes_written) != ERROR_OK) {
 651                 LOG_ERROR("couldn't write command to %s clk divide by 5"
 652                         , enable ? "enable" : "disable");
 653                 return ERROR_JTAG_INIT_FAILED;
 654         }
 655         ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_x232H_MAX_TCK;
 656         LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
 657
 658         return ERROR_OK;
 659 }
 660
 661 static int ft2232_speed(int speed)
 662 {
 663         uint8_t buf[3];
 664         int retval;
 665         uint32_t bytes_written;
 666
 667         retval = ERROR_OK;
 668         bool enable_adaptive_clocking = (RTCK_SPEED == speed);
 669         if (ft2232_device_is_highspeed())
 670                 retval = ftx232h_adaptive_clocking(enable_adaptive_clocking);
 671         else if (enable_adaptive_clocking) {
 672                 LOG_ERROR("ft2232 device %lu does not support RTCK"
 673                         , (long unsigned int)ftdi_device);
 674                 return ERROR_FAIL;
 675         }
 676
 677         if ((enable_adaptive_clocking) || (ERROR_OK != retval))
 678                 return retval;
 679
 680         buf[0] = 0x86;                                  /* command "set divisor" */
 681         buf[1] = speed & 0xff;                  /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
 682         buf[2] = (speed >> 8) & 0xff;   /* valueH */
 683
 684         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
 685         retval = ft2232_write(buf, sizeof(buf), &bytes_written);
 686         if (retval != ERROR_OK) {
 687                 LOG_ERROR("couldn't set FT2232 TCK speed");
 688                 return retval;
 689         }
 690
 691         return ERROR_OK;
 692 }
 693
 694 static int ft2232_speed_div(int speed, int *khz)
 695 {
 696         /* Take a look in the FT2232 manual,
 697          * AN2232C-01 Command Processor for
 698          * MPSSE and MCU Host Bus. Chapter 3.8 */
 699
 700         *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
 701
 702         return ERROR_OK;
 703 }
 704
 705 static int ft2232_khz(int khz, int *jtag_speed)
 706 {
 707         if (khz == 0) {
 708                 if (ft2232_device_is_highspeed()) {
 709                         *jtag_speed = RTCK_SPEED;
 710                         return ERROR_OK;
 711                 } else {
 712                         LOG_DEBUG("RCLK not supported");
 713                         return ERROR_FAIL;
 714                 }
 715         }
 716
 717         /* Take a look in the FT2232 manual,
 718          * AN2232C-01 Command Processor for
 719          * MPSSE and MCU Host Bus. Chapter 3.8
 720          *
 721          * We will calc here with a multiplier
 722          * of 10 for better rounding later. */
 723
 724         /* Calc speed, (ft2232_max_tck / khz) - 1
 725          * Use 65000 for better rounding */
 726         *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
 727
 728         /* Add 0.9 for rounding */
 729         *jtag_speed += 9;
 730
 731         /* Calc real speed */
 732         *jtag_speed = *jtag_speed / 10;
 733
 734         /* Check if speed is greater than 0 */
 735         if (*jtag_speed < 0)
 736                 *jtag_speed = 0;
 737
 738         /* Check max value */
 739         if (*jtag_speed > 0xFFFF)
 740                 *jtag_speed = 0xFFFF;
 741
 742         return ERROR_OK;
 743 }
 744
 745 static void ft2232_end_state(tap_state_t state)
 746 {
 747         if (tap_is_state_stable(state))
 748                 tap_set_end_state(state);
 749         else {
 750                 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
 751                 exit(-1);
 752         }
 753 }
 754
 755 static void ft2232_read_scan(enum scan_type type, uint8_t *buffer, int scan_size)
 756 {
 757         int num_bytes = (scan_size + 7) / 8;
 758         int bits_left = scan_size;
 759         int cur_byte  = 0;
 760
 761         while (num_bytes-- > 1) {
 762                 buffer[cur_byte++] = buffer_read();
 763                 bits_left -= 8;
 764         }
 765
 766         buffer[cur_byte] = 0x0;
 767
 768         /* There is one more partial byte left from the clock data in/out instructions */
 769         if (bits_left > 1)
 770                 buffer[cur_byte] = buffer_read() >> 1;
 771         /* This shift depends on the length of the
 772          *clock data to tms instruction, insterted
 773          *at end of the scan, now fixed to a two
 774          *step transition in ft2232_add_scan */
 775         buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
 776 }
 777
 778 static void ft2232_debug_dump_buffer(void)
 779 {
 780         int i;
 781         char line[256];
 782         char *line_p = line;
 783
 784         for (i = 0; i < ft2232_buffer_size; i++) {
 785                 line_p += snprintf(line_p,
 786                                 sizeof(line) - (line_p - line),
 787                                 "%2.2x ",
 788                                 ft2232_buffer[i]);
 789                 if (i % 16 == 15) {
 790                         LOG_DEBUG("%s", line);
 791                         line_p = line;
 792                 }
 793         }
 794
 795         if (line_p != line)
 796                 LOG_DEBUG("%s", line);
 797 }
 798
 799 static int ft2232_send_and_recv(struct jtag_command *first, struct jtag_command *last)
 800 {
 801         struct jtag_command *cmd;
 802         uint8_t *buffer;
 803         int scan_size;
 804         enum scan_type type;
 805         int retval;
 806         uint32_t bytes_written = 0;
 807         uint32_t bytes_read = 0;
 808
 809 #ifdef _DEBUG_USB_IO_
 810         struct timeval start, inter, inter2, end;
 811         struct timeval d_inter, d_inter2, d_end;
 812 #endif
 813
 814 #ifdef _DEBUG_USB_COMMS_
 815         LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
 816         ft2232_debug_dump_buffer();
 817 #endif
 818
 819 #ifdef _DEBUG_USB_IO_
 820         gettimeofday(&start, NULL);
 821 #endif
 822
 823         retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
 824         if (retval != ERROR_OK) {
 825                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
 826                 return retval;
 827         }
 828
 829 #ifdef _DEBUG_USB_IO_
 830         gettimeofday(&inter, NULL);
 831 #endif
 832
 833         if (ft2232_expect_read) {
 834                 /* FIXME this "timeout" is never changed ... */
 835                 int timeout = LIBFTDI_READ_RETRY_COUNT;
 836                 ft2232_buffer_size = 0;
 837
 838 #ifdef _DEBUG_USB_IO_
 839                 gettimeofday(&inter2, NULL);
 840 #endif
 841
 842                 retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read);
 843                 if (retval != ERROR_OK) {
 844                         LOG_ERROR("couldn't read from FT2232");
 845                         return retval;
 846                 }
 847
 848 #ifdef _DEBUG_USB_IO_
 849                 gettimeofday(&end, NULL);
 850
 851                 timeval_subtract(&d_inter, &inter, &start);
 852                 timeval_subtract(&d_inter2, &inter2, &start);
 853                 timeval_subtract(&d_end, &end, &start);
 854
 855                 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
 856                         (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
 857                         (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
 858                         (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
 859 #endif
 860
 861                 ft2232_buffer_size = bytes_read;
 862
 863                 if (ft2232_expect_read != ft2232_buffer_size) {
 864                         LOG_ERROR("ft2232_expect_read (%i) != "
 865                                 "ft2232_buffer_size (%i) "
 866                                 "(%i retries)",
 867                                 ft2232_expect_read,
 868                                 ft2232_buffer_size,
 869                                 LIBFTDI_READ_RETRY_COUNT - timeout);
 870                         ft2232_debug_dump_buffer();
 871
 872                         exit(-1);
 873                 }
 874
 875 #ifdef _DEBUG_USB_COMMS_
 876                 LOG_DEBUG("read buffer (%i retries): %i bytes",
 877                         LIBFTDI_READ_RETRY_COUNT - timeout,
 878                         ft2232_buffer_size);
 879                 ft2232_debug_dump_buffer();
 880 #endif
 881         }
 882
 883         ft2232_expect_read  = 0;
 884         ft2232_read_pointer = 0;
 885
 886         /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
 887          * that wasn't handled by a caller-provided error handler
 888          */
 889         retval = ERROR_OK;
 890
 891         cmd = first;
 892         while (cmd != last) {
 893                 switch (cmd->type) {
 894                         case JTAG_SCAN:
 895                                 type = jtag_scan_type(cmd->cmd.scan);
 896                                 if (type != SCAN_OUT) {
 897                                         scan_size = jtag_scan_size(cmd->cmd.scan);
 898                                         buffer = calloc(DIV_ROUND_UP(scan_size, 8), 1);
 899                                         ft2232_read_scan(type, buffer, scan_size);
 900                                         if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
 901                                                 retval = ERROR_JTAG_QUEUE_FAILED;
 902                                         free(buffer);
 903                                 }
 904                                 break;
 905
 906                         default:
 907                                 break;
 908                 }
 909
 910                 cmd = cmd->next;
 911         }
 912
 913         ft2232_buffer_size = 0;
 914
 915         return retval;
 916 }
 917
 918 /**
 919  * Function ft2232_add_pathmove
 920  * moves the TAP controller from the current state to a new state through the
 921  * given path, where path is an array of tap_state_t's.
 922  *
 923  * @param path is an array of tap_stat_t which gives the states to traverse through
 924  *   ending with the last state at path[num_states-1]
 925  * @param num_states is the count of state steps to move through
 926  */
 927 static void ft2232_add_pathmove(tap_state_t *path, int num_states)
 928 {
 929         int state_count = 0;
 930
 931         assert((unsigned) num_states <= 32u);           /* tms_bits only holds 32 bits */
 932
 933         DEBUG_JTAG_IO("-");
 934
 935         /* this loop verifies that the path is legal and logs each state in the path */
 936         while (num_states) {
 937                 unsigned char tms_byte = 0;             /* zero this on each MPSSE batch */
 938                 int bit_count = 0;
 939                 int num_states_batch = num_states > 7 ? 7 : num_states;
 940
 941                 /* command "Clock Data to TMS/CS Pin (no Read)" */
 942                 buffer_write(0x4b);
 943
 944                 /* number of states remaining */
 945                 buffer_write(num_states_batch - 1);
 946
 947                 while (num_states_batch--) {
 948                         /* either TMS=0 or TMS=1 must work ... */
 949                         if (tap_state_transition(tap_get_state(), false) == path[state_count])
 950                                 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
 951                         else if (tap_state_transition(tap_get_state(), true) == path[state_count])
 952                                 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
 953
 954                         /* ... or else the caller goofed BADLY */
 955                         else {
 956                                 LOG_ERROR("BUG: %s -> %s isn't a valid "
 957                                         "TAP state transition",
 958                                         tap_state_name(tap_get_state()),
 959                                         tap_state_name(path[state_count]));
 960                                 exit(-1);
 961                         }
 962
 963                         tap_set_state(path[state_count]);
 964                         state_count++;
 965                         num_states--;
 966                 }
 967
 968                 buffer_write(tms_byte);
 969         }
 970         tap_set_end_state(tap_get_state());
 971 }
 972
 973 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
 974 {
 975         int num_bytes = (scan_size + 7) / 8;
 976         int bits_left = scan_size;
 977         int cur_byte  = 0;
 978         int last_bit;
 979
 980         if (!ir_scan) {
 981                 if (tap_get_state() != TAP_DRSHIFT)
 982                         move_to_state(TAP_DRSHIFT);
 983         } else {
 984                 if (tap_get_state() != TAP_IRSHIFT)
 985                         move_to_state(TAP_IRSHIFT);
 986         }
 987
 988         /* add command for complete bytes */
 989         while (num_bytes > 1) {
 990                 int thisrun_bytes;
 991                 if (type == SCAN_IO) {
 992                         /* Clock Data Bytes In and Out LSB First */
 993                         buffer_write(0x39);
 994                         /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
 995                 } else if (type == SCAN_OUT) {
 996                         /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
 997                         buffer_write(0x19);
 998                         /* LOG_DEBUG("added TDI bytes (o)"); */
 999                 } else if (type == SCAN_IN) {
1000                         /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1001                         buffer_write(0x28);
1002                         /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1003                 }
1004
1005                 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1006                 num_bytes -= thisrun_bytes;
1007
1008                 buffer_write((uint8_t) (thisrun_bytes - 1));
1009                 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1010
1011                 if (type != SCAN_IN) {
1012                         /* add complete bytes */
1013                         while (thisrun_bytes-- > 0) {
1014                                 buffer_write(buffer[cur_byte++]);
1015                                 bits_left -= 8;
1016                         }
1017                 } else /* (type == SCAN_IN) */
1018                         bits_left -= 8 * (thisrun_bytes);
1019         }
1020
1021         /* the most signifcant bit is scanned during TAP movement */
1022         if (type != SCAN_IN)
1023                 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1024         else
1025                 last_bit = 0;
1026
1027         /* process remaining bits but the last one */
1028         if (bits_left > 1) {
1029                 if (type == SCAN_IO) {
1030                         /* Clock Data Bits In and Out LSB First */
1031                         buffer_write(0x3b);
1032                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1033                 } else if (type == SCAN_OUT) {
1034                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1035                         buffer_write(0x1b);
1036                         /* LOG_DEBUG("added TDI bits (o)"); */
1037                 } else if (type == SCAN_IN) {
1038                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1039                         buffer_write(0x2a);
1040                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1041                 }
1042
1043                 buffer_write(bits_left - 2);
1044                 if (type != SCAN_IN)
1045                         buffer_write(buffer[cur_byte]);
1046         }
1047
1048         if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
1049                         || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT))) {
1050                 if (type == SCAN_IO) {
1051                         /* Clock Data Bits In and Out LSB First */
1052                         buffer_write(0x3b);
1053                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1054                 } else if (type == SCAN_OUT) {
1055                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1056                         buffer_write(0x1b);
1057                         /* LOG_DEBUG("added TDI bits (o)"); */
1058                 } else if (type == SCAN_IN) {
1059                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1060                         buffer_write(0x2a);
1061                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1062                 }
1063                 buffer_write(0x0);
1064                 if (type != SCAN_IN)
1065                         buffer_write(last_bit);
1066         } else {
1067                 int tms_bits;
1068                 int tms_count;
1069                 uint8_t mpsse_cmd;
1070
1071                 /* move from Shift-IR/DR to end state */
1072                 if (type != SCAN_OUT) {
1073                         /* We always go to the PAUSE state in two step at the end of an IN or IO
1074                          *scan
1075                          * This must be coordinated with the bit shifts in ft2232_read_scan    */
1076                         tms_bits  = 0x01;
1077                         tms_count = 2;
1078                         /* Clock Data to TMS/CS Pin with Read */
1079                         mpsse_cmd = 0x6b;
1080                 } else {
1081                         tms_bits  = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1082                         tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1083                         /* Clock Data to TMS/CS Pin (no Read) */
1084                         mpsse_cmd = 0x4b;
1085                 }
1086
1087                 DEBUG_JTAG_IO("finish %s", (type == SCAN_OUT) ? "without read" : "via PAUSE");
1088                 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1089         }
1090
1091         if (tap_get_state() != tap_get_end_state())
1092                 move_to_state(tap_get_end_state());
1093 }
1094
1095 static int ft2232_large_scan(struct scan_command *cmd,
1096         enum scan_type type,
1097         uint8_t *buffer,
1098         int scan_size)
1099 {
1100         int num_bytes = (scan_size + 7) / 8;
1101         int bits_left = scan_size;
1102         int cur_byte  = 0;
1103         int last_bit;
1104         uint8_t *receive_buffer  = malloc(DIV_ROUND_UP(scan_size, 8));
1105         uint8_t *receive_pointer = receive_buffer;
1106         uint32_t bytes_written;
1107         uint32_t bytes_read;
1108         int retval;
1109         int thisrun_read = 0;
1110
1111         if (!receive_buffer) {
1112                 LOG_ERROR("failed to allocate memory");
1113                 exit(-1);
1114         }
1115
1116         if (cmd->ir_scan) {
1117                 LOG_ERROR("BUG: large IR scans are not supported");
1118                 exit(-1);
1119         }
1120
1121         if (tap_get_state() != TAP_DRSHIFT)
1122                 move_to_state(TAP_DRSHIFT);
1123
1124         retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1125         if (retval != ERROR_OK) {
1126                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1127                 exit(-1);
1128         }
1129         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1130                 ft2232_buffer_size, (int)bytes_written);
1131         ft2232_buffer_size = 0;
1132
1133         /* add command for complete bytes */
1134         while (num_bytes > 1) {
1135                 int thisrun_bytes;
1136
1137                 if (type == SCAN_IO) {
1138                         /* Clock Data Bytes In and Out LSB First */
1139                         buffer_write(0x39);
1140                         /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1141                 } else if (type == SCAN_OUT) {
1142                         /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1143                         buffer_write(0x19);
1144                         /* LOG_DEBUG("added TDI bytes (o)"); */
1145                 } else if (type == SCAN_IN) {
1146                         /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1147                         buffer_write(0x28);
1148                         /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1149                 }
1150
1151                 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1152                 thisrun_read  = thisrun_bytes;
1153                 num_bytes    -= thisrun_bytes;
1154                 buffer_write((uint8_t) (thisrun_bytes - 1));
1155                 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1156
1157                 if (type != SCAN_IN) {
1158                         /* add complete bytes */
1159                         while (thisrun_bytes-- > 0) {
1160                                 buffer_write(buffer[cur_byte]);
1161                                 cur_byte++;
1162                                 bits_left -= 8;
1163                         }
1164                 } else /* (type == SCAN_IN) */
1165                         bits_left -= 8 * (thisrun_bytes);
1166
1167                 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1168                 if (retval != ERROR_OK) {
1169                         LOG_ERROR("couldn't write MPSSE commands to FT2232");
1170                         exit(-1);
1171                 }
1172                 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1173                         ft2232_buffer_size,
1174                         (int)bytes_written);
1175                 ft2232_buffer_size = 0;
1176
1177                 if (type != SCAN_OUT) {
1178                         retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1179                         if (retval != ERROR_OK) {
1180                                 LOG_ERROR("couldn't read from FT2232");
1181                                 exit(-1);
1182                         }
1183                         LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1184                                 thisrun_read,
1185                                 (int)bytes_read);
1186                         receive_pointer += bytes_read;
1187                 }
1188         }
1189
1190         thisrun_read = 0;
1191
1192         /* the most signifcant bit is scanned during TAP movement */
1193         if (type != SCAN_IN)
1194                 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1195         else
1196                 last_bit = 0;
1197
1198         /* process remaining bits but the last one */
1199         if (bits_left > 1) {
1200                 if (type == SCAN_IO) {
1201                         /* Clock Data Bits In and Out LSB First */
1202                         buffer_write(0x3b);
1203                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1204                 } else if (type == SCAN_OUT) {
1205                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1206                         buffer_write(0x1b);
1207                         /* LOG_DEBUG("added TDI bits (o)"); */
1208                 } else if (type == SCAN_IN) {
1209                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1210                         buffer_write(0x2a);
1211                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1212                 }
1213                 buffer_write(bits_left - 2);
1214                 if (type != SCAN_IN)
1215                         buffer_write(buffer[cur_byte]);
1216
1217                 if (type != SCAN_OUT)
1218                         thisrun_read += 2;
1219         }
1220
1221         if (tap_get_end_state() == TAP_DRSHIFT) {
1222                 if (type == SCAN_IO) {
1223                         /* Clock Data Bits In and Out LSB First */
1224                         buffer_write(0x3b);
1225                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1226                 } else if (type == SCAN_OUT) {
1227                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1228                         buffer_write(0x1b);
1229                         /* LOG_DEBUG("added TDI bits (o)"); */
1230                 } else if (type == SCAN_IN) {
1231                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1232                         buffer_write(0x2a);
1233                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1234                 }
1235                 buffer_write(0x0);
1236                 buffer_write(last_bit);
1237         } else {
1238                 int tms_bits  = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1239                 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1240                 uint8_t mpsse_cmd;
1241
1242                 /* move from Shift-IR/DR to end state */
1243                 if (type != SCAN_OUT) {
1244                         /* Clock Data to TMS/CS Pin with Read */
1245                         mpsse_cmd = 0x6b;
1246                         /* LOG_DEBUG("added TMS scan (read)"); */
1247                 } else {
1248                         /* Clock Data to TMS/CS Pin (no Read) */
1249                         mpsse_cmd = 0x4b;
1250                         /* LOG_DEBUG("added TMS scan (no read)"); */
1251                 }
1252
1253                 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1254                 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1255         }
1256
1257         if (type != SCAN_OUT)
1258                 thisrun_read += 1;
1259
1260         retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1261         if (retval != ERROR_OK) {
1262                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1263                 exit(-1);
1264         }
1265         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1266                 ft2232_buffer_size,
1267                 (int)bytes_written);
1268         ft2232_buffer_size = 0;
1269
1270         if (type != SCAN_OUT) {
1271                 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1272                 if (retval != ERROR_OK) {
1273                         LOG_ERROR("couldn't read from FT2232");
1274                         exit(-1);
1275                 }
1276                 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1277                         thisrun_read,
1278                         (int)bytes_read);
1279         }
1280
1281         free(receive_buffer);
1282
1283         return ERROR_OK;
1284 }
1285
1286 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1287 {
1288         int predicted_size = 3;
1289         int num_bytes = (scan_size - 1) / 8;
1290
1291         if (tap_get_state() != TAP_DRSHIFT)
1292                 predicted_size += get_tms_buffer_requirements(
1293                                 tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1294
1295         if (type == SCAN_IN) {  /* only from device to host */
1296                 /* complete bytes */
1297                 predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
1298
1299                 /* remaining bits - 1 (up to 7) */
1300                 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1301         } else {/* host to device, or bidirectional
1302                  * complete bytes */
1303                 predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
1304
1305                 /* remaining bits -1 (up to 7) */
1306                 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1307         }
1308
1309         return predicted_size;
1310 }
1311
1312 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1313 {
1314         int predicted_size = 0;
1315
1316         if (type != SCAN_OUT) {
1317                 /* complete bytes */
1318                 predicted_size +=
1319                         (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
1320
1321                 /* remaining bits - 1 */
1322                 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1323
1324                 /* last bit (from TMS scan) */
1325                 predicted_size += 1;
1326         }
1327
1328         /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1329
1330         return predicted_size;
1331 }
1332
1333 /* semi-generic FT2232/FT4232 reset code */
1334 static void ftx23_reset(int trst, int srst)
1335 {
1336         enum reset_types jtag_reset_config = jtag_get_reset_config();
1337         if (trst == 1) {
1338                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1339                         low_direction |= nTRSTnOE;      /* switch to output pin (output is low) */
1340                 else
1341                         low_output &= ~nTRST;           /* switch output low */
1342         } else if (trst == 0) {
1343                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1344                         low_direction &= ~nTRSTnOE;     /* switch to input pin (high-Z + internal
1345                                                          *and external pullup) */
1346                 else
1347                         low_output |= nTRST;            /* switch output high */
1348         }
1349
1350         if (srst == 1) {
1351                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1352                         low_output &= ~nSRST;           /* switch output low */
1353                 else
1354                         low_direction |= nSRSTnOE;      /* switch to output pin (output is low) */
1355         } else if (srst == 0) {
1356                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1357                         low_output |= nSRST;            /* switch output high */
1358                 else
1359                         low_direction &= ~nSRSTnOE;     /* switch to input pin (high-Z) */
1360         }
1361
1362         /* command "set data bits low byte" */
1363         buffer_write(0x80);
1364         buffer_write(low_output);
1365         buffer_write(low_direction);
1366 }
1367
1368 static void jtagkey_reset(int trst, int srst)
1369 {
1370         enum reset_types jtag_reset_config = jtag_get_reset_config();
1371         if (trst == 1) {
1372                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1373                         high_output &= ~nTRSTnOE;
1374                 else
1375                         high_output &= ~nTRST;
1376         } else if (trst == 0) {
1377                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1378                         high_output |= nTRSTnOE;
1379                 else
1380                         high_output |= nTRST;
1381         }
1382
1383         if (srst == 1) {
1384                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1385                         high_output &= ~nSRST;
1386                 else
1387                         high_output &= ~nSRSTnOE;
1388         } else if (srst == 0) {
1389                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1390                         high_output |= nSRST;
1391                 else
1392                         high_output |= nSRSTnOE;
1393         }
1394
1395         /* command "set data bits high byte" */
1396         buffer_write(0x82);
1397         buffer_write(high_output);
1398         buffer_write(high_direction);
1399         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1400                 trst,
1401                 srst,
1402                 high_output,
1403                 high_direction);
1404 }
1405
1406 static void olimex_jtag_reset(int trst, int srst)
1407 {
1408         enum reset_types jtag_reset_config = jtag_get_reset_config();
1409         if (trst == 1) {
1410                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1411                         high_output &= ~nTRSTnOE;
1412                 else
1413                         high_output &= ~nTRST;
1414         } else if (trst == 0) {
1415                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1416                         high_output |= nTRSTnOE;
1417                 else
1418                         high_output |= nTRST;
1419         }
1420
1421         if (srst == 1)
1422                 high_output |= nSRST;
1423         else if (srst == 0)
1424                 high_output &= ~nSRST;
1425
1426         /* command "set data bits high byte" */
1427         buffer_write(0x82);
1428         buffer_write(high_output);
1429         buffer_write(high_direction);
1430         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1431                 trst,
1432                 srst,
1433                 high_output,
1434                 high_direction);
1435 }
1436
1437 static void axm0432_jtag_reset(int trst, int srst)
1438 {
1439         if (trst == 1) {
1440                 tap_set_state(TAP_RESET);
1441                 high_output &= ~nTRST;
1442         } else if (trst == 0)
1443                 high_output |= nTRST;
1444
1445         if (srst == 1)
1446                 high_output &= ~nSRST;
1447         else if (srst == 0)
1448                 high_output |= nSRST;
1449
1450         /* command "set data bits low byte" */
1451         buffer_write(0x82);
1452         buffer_write(high_output);
1453         buffer_write(high_direction);
1454         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1455                 trst,
1456                 srst,
1457                 high_output,
1458                 high_direction);
1459 }
1460
1461 static void flyswatter_reset(int trst, int srst)
1462 {
1463         if (trst == 1)
1464                 low_output &= ~nTRST;
1465         else if (trst == 0)
1466                 low_output |= nTRST;
1467
1468         if (srst == 1)
1469                 low_output |= nSRST;
1470         else if (srst == 0)
1471                 low_output &= ~nSRST;
1472
1473         /* command "set data bits low byte" */
1474         buffer_write(0x80);
1475         buffer_write(low_output);
1476         buffer_write(low_direction);
1477         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1478                 trst,
1479                 srst,
1480                 low_output,
1481                 low_direction);
1482 }
1483
1484 static void flyswatter1_reset(int trst, int srst)
1485 {
1486         flyswatter_reset(trst, srst);
1487 }
1488
1489 static void flyswatter2_reset(int trst, int srst)
1490 {
1491         flyswatter_reset(trst, !srst);
1492 }
1493
1494 static void minimodule_reset(int trst, int srst)
1495 {
1496         if (srst == 1)
1497                 low_output &= ~nSRST;
1498         else if (srst == 0)
1499                 low_output |= nSRST;
1500
1501         /* command "set data bits low byte" */
1502         buffer_write(0x80);
1503         buffer_write(low_output);
1504         buffer_write(low_direction);
1505         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1506                 trst,
1507                 srst,
1508                 low_output,
1509                 low_direction);
1510 }
1511
1512 static void turtle_reset(int trst, int srst)
1513 {
1514         trst = trst;
1515
1516         if (srst == 1)
1517                 low_output |= nSRST;
1518         else if (srst == 0)
1519                 low_output &= ~nSRST;
1520
1521         /* command "set data bits low byte" */
1522         buffer_write(0x80);
1523         buffer_write(low_output);
1524         buffer_write(low_direction);
1525         LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1526                 srst,
1527                 low_output,
1528                 low_direction);
1529 }
1530
1531 static void comstick_reset(int trst, int srst)
1532 {
1533         if (trst == 1)
1534                 high_output &= ~nTRST;
1535         else if (trst == 0)
1536                 high_output |= nTRST;
1537
1538         if (srst == 1)
1539                 high_output &= ~nSRST;
1540         else if (srst == 0)
1541                 high_output |= nSRST;
1542
1543         /* command "set data bits high byte" */
1544         buffer_write(0x82);
1545         buffer_write(high_output);
1546         buffer_write(high_direction);
1547         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1548                 trst,
1549                 srst,
1550                 high_output,
1551                 high_direction);
1552 }
1553
1554 static void stm32stick_reset(int trst, int srst)
1555 {
1556         if (trst == 1)
1557                 high_output &= ~nTRST;
1558         else if (trst == 0)
1559                 high_output |= nTRST;
1560
1561         if (srst == 1)
1562                 low_output &= ~nSRST;
1563         else if (srst == 0)
1564                 low_output |= nSRST;
1565
1566         /* command "set data bits low byte" */
1567         buffer_write(0x80);
1568         buffer_write(low_output);
1569         buffer_write(low_direction);
1570
1571         /* command "set data bits high byte" */
1572         buffer_write(0x82);
1573         buffer_write(high_output);
1574         buffer_write(high_direction);
1575         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1576                 trst,
1577                 srst,
1578                 high_output,
1579                 high_direction);
1580 }
1581
1582 static void sheevaplug_reset(int trst, int srst)
1583 {
1584         if (trst == 1)
1585                 high_output &= ~nTRST;
1586         else if (trst == 0)
1587                 high_output |= nTRST;
1588
1589         if (srst == 1)
1590                 high_output &= ~nSRSTnOE;
1591         else if (srst == 0)
1592                 high_output |= nSRSTnOE;
1593
1594         /* command "set data bits high byte" */
1595         buffer_write(0x82);
1596         buffer_write(high_output);
1597         buffer_write(high_direction);
1598         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1599                 trst,
1600                 srst,
1601                 high_output,
1602                 high_direction);
1603 }
1604
1605 static void redbee_reset(int trst, int srst)
1606 {
1607         if (trst == 1) {
1608                 tap_set_state(TAP_RESET);
1609                 high_output &= ~nTRST;
1610         } else if (trst == 0)
1611                 high_output |= nTRST;
1612
1613         if (srst == 1)
1614                 high_output &= ~nSRST;
1615         else if (srst == 0)
1616                 high_output |= nSRST;
1617
1618         /* command "set data bits low byte" */
1619         buffer_write(0x82);
1620         buffer_write(high_output);
1621         buffer_write(high_direction);
1622         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1623                 "high_direction: 0x%2.2x", trst, srst, high_output,
1624                 high_direction);
1625 }
1626
1627 static void xds100v2_reset(int trst, int srst)
1628 {
1629         if (trst == 1) {
1630                 tap_set_state(TAP_RESET);
1631                 high_output &= ~nTRST;
1632         } else if (trst == 0)
1633                 high_output |= nTRST;
1634
1635         if (srst == 1)
1636                 high_output |= nSRST;
1637         else if (srst == 0)
1638                 high_output &= ~nSRST;
1639
1640         /* command "set data bits low byte" */
1641         buffer_write(0x82);
1642         buffer_write(high_output);
1643         buffer_write(high_direction);
1644         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1645                 "high_direction: 0x%2.2x", trst, srst, high_output,
1646                 high_direction);
1647 }
1648
1649 static int ft2232_execute_runtest(struct jtag_command *cmd)
1650 {
1651         int retval;
1652         int i;
1653         int predicted_size = 0;
1654         retval = ERROR_OK;
1655
1656         DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1657                 cmd->cmd.runtest->num_cycles,
1658                 tap_state_name(cmd->cmd.runtest->end_state));
1659
1660         /* only send the maximum buffer size that FT2232C can handle */
1661         predicted_size = 0;
1662         if (tap_get_state() != TAP_IDLE)
1663                 predicted_size += 3;
1664         predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
1665         if (cmd->cmd.runtest->end_state != TAP_IDLE)
1666                 predicted_size += 3;
1667         if (tap_get_end_state() != TAP_IDLE)
1668                 predicted_size += 3;
1669         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1670                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1671                         retval = ERROR_JTAG_QUEUE_FAILED;
1672                 require_send = 0;
1673                 first_unsent = cmd;
1674         }
1675         if (tap_get_state() != TAP_IDLE) {
1676                 move_to_state(TAP_IDLE);
1677                 require_send = 1;
1678         }
1679         i = cmd->cmd.runtest->num_cycles;
1680         while (i > 0) {
1681                 /* there are no state transitions in this code, so omit state tracking */
1682
1683                 /* command "Clock Data to TMS/CS Pin (no Read)" */
1684                 buffer_write(0x4b);
1685
1686                 /* scan 7 bits */
1687                 buffer_write((i > 7) ? 6 : (i - 1));
1688
1689                 /* TMS data bits */
1690                 buffer_write(0x0);
1691
1692                 i -= (i > 7) ? 7 : i;
1693                 /* LOG_DEBUG("added TMS scan (no read)"); */
1694         }
1695
1696         ft2232_end_state(cmd->cmd.runtest->end_state);
1697
1698         if (tap_get_state() != tap_get_end_state())
1699                 move_to_state(tap_get_end_state());
1700
1701         require_send = 1;
1702         DEBUG_JTAG_IO("runtest: %i, end in %s",
1703                 cmd->cmd.runtest->num_cycles,
1704                 tap_state_name(tap_get_end_state()));
1705         return retval;
1706 }
1707
1708 static int ft2232_execute_statemove(struct jtag_command *cmd)
1709 {
1710         int predicted_size = 0;
1711         int retval = ERROR_OK;
1712
1713         DEBUG_JTAG_IO("statemove end in %s",
1714                 tap_state_name(cmd->cmd.statemove->end_state));
1715
1716         /* only send the maximum buffer size that FT2232C can handle */
1717         predicted_size = 3;
1718         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1719                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1720                         retval = ERROR_JTAG_QUEUE_FAILED;
1721                 require_send = 0;
1722                 first_unsent = cmd;
1723         }
1724         ft2232_end_state(cmd->cmd.statemove->end_state);
1725
1726         /* For TAP_RESET, ignore the current recorded state.  It's often
1727          * wrong at server startup, and this transation is critical whenever
1728          * it's requested.
1729          */
1730         if (tap_get_end_state() == TAP_RESET) {
1731                 clock_tms(0x4b,  0xff, 5, 0);
1732                 require_send = 1;
1733
1734                 /* shortest-path move to desired end state */
1735         } else if (tap_get_state() != tap_get_end_state()) {
1736                 move_to_state(tap_get_end_state());
1737                 require_send = 1;
1738         }
1739
1740         return retval;
1741 }
1742
1743 /**
1744  * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
1745  * (or SWD) state machine.
1746  */
1747 static int ft2232_execute_tms(struct jtag_command *cmd)
1748 {
1749         int retval = ERROR_OK;
1750         unsigned num_bits = cmd->cmd.tms->num_bits;
1751         const uint8_t *bits = cmd->cmd.tms->bits;
1752         unsigned count;
1753
1754         DEBUG_JTAG_IO("TMS: %d bits", num_bits);
1755
1756         /* only send the maximum buffer size that FT2232C can handle */
1757         count = 3 * DIV_ROUND_UP(num_bits, 4);
1758         if (ft2232_buffer_size + 3*count + 1 > FT2232_BUFFER_SIZE) {
1759                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1760                         retval = ERROR_JTAG_QUEUE_FAILED;
1761
1762                 require_send = 0;
1763                 first_unsent = cmd;
1764         }
1765
1766         /* Shift out in batches of at most 6 bits; there's a report of an
1767          * FT2232 bug in this area, where shifting exactly 7 bits can make
1768          * problems with TMS signaling for the last clock cycle:
1769          *
1770          *    http://developer.intra2net.com/mailarchive/html/
1771          *              libftdi/2009/msg00292.html
1772          *
1773          * Command 0x4b is: "Clock Data to TMS/CS Pin (no Read)"
1774          *
1775          * Note that pathmoves in JTAG are not often seven bits, so that
1776          * isn't a particularly likely situation outside of "special"
1777          * signaling such as switching between JTAG and SWD modes.
1778          */
1779         while (num_bits) {
1780                 if (num_bits <= 6) {
1781                         buffer_write(0x4b);
1782                         buffer_write(num_bits - 1);
1783                         buffer_write(*bits & 0x3f);
1784                         break;
1785                 }
1786
1787                 /* Yes, this is lazy ... we COULD shift out more data
1788                  * bits per operation, but doing it in nybbles is easy
1789                  */
1790                 buffer_write(0x4b);
1791                 buffer_write(3);
1792                 buffer_write(*bits & 0xf);
1793                 num_bits -= 4;
1794
1795                 count  = (num_bits > 4) ? 4 : num_bits;
1796
1797                 buffer_write(0x4b);
1798                 buffer_write(count - 1);
1799                 buffer_write((*bits >> 4) & 0xf);
1800                 num_bits -= count;
1801
1802                 bits++;
1803         }
1804
1805         require_send = 1;
1806         return retval;
1807 }
1808
1809 static int ft2232_execute_pathmove(struct jtag_command *cmd)
1810 {
1811         int predicted_size = 0;
1812         int retval = ERROR_OK;
1813
1814         tap_state_t *path = cmd->cmd.pathmove->path;
1815         int num_states    = cmd->cmd.pathmove->num_states;
1816
1817         DEBUG_JTAG_IO("pathmove: %i states, current: %s  end: %s", num_states,
1818                 tap_state_name(tap_get_state()),
1819                 tap_state_name(path[num_states-1]));
1820
1821         /* only send the maximum buffer size that FT2232C can handle */
1822         predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
1823         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1824                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1825                         retval = ERROR_JTAG_QUEUE_FAILED;
1826
1827                 require_send = 0;
1828                 first_unsent = cmd;
1829         }
1830
1831         ft2232_add_pathmove(path, num_states);
1832         require_send = 1;
1833
1834         return retval;
1835 }
1836
1837 static int ft2232_execute_scan(struct jtag_command *cmd)
1838 {
1839         uint8_t *buffer;
1840         int scan_size;                          /* size of IR or DR scan */
1841         int predicted_size = 0;
1842         int retval = ERROR_OK;
1843
1844         enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1845
1846         DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1847
1848         scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1849
1850         predicted_size = ft2232_predict_scan_out(scan_size, type);
1851         if ((predicted_size + 1) > FT2232_BUFFER_SIZE) {
1852                 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1853                 /* unsent commands before this */
1854                 if (first_unsent != cmd)
1855                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1856                                 retval = ERROR_JTAG_QUEUE_FAILED;
1857
1858                 /* current command */
1859                 ft2232_end_state(cmd->cmd.scan->end_state);
1860                 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1861                 require_send = 0;
1862                 first_unsent = cmd->next;
1863                 if (buffer)
1864                         free(buffer);
1865                 return retval;
1866         } else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1867                 LOG_DEBUG(
1868                         "ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1869                         first_unsent,
1870                         cmd);
1871                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1872                         retval = ERROR_JTAG_QUEUE_FAILED;
1873                 require_send = 0;
1874                 first_unsent = cmd;
1875         }
1876         ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1877         /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1878         ft2232_end_state(cmd->cmd.scan->end_state);
1879         ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1880         require_send = 1;
1881         if (buffer)
1882                 free(buffer);
1883         DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1884                 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1885                 tap_state_name(tap_get_end_state()));
1886         return retval;
1887
1888 }
1889
1890 static int ft2232_execute_reset(struct jtag_command *cmd)
1891 {
1892         int retval;
1893         int predicted_size = 0;
1894         retval = ERROR_OK;
1895
1896         DEBUG_JTAG_IO("reset trst: %i srst %i",
1897                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1898
1899         /* only send the maximum buffer size that FT2232C can handle */
1900         predicted_size = 3;
1901         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1902                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1903                         retval = ERROR_JTAG_QUEUE_FAILED;
1904                 require_send = 0;
1905                 first_unsent = cmd;
1906         }
1907
1908         if ((cmd->cmd.reset->trst == 1) ||
1909             (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1910                 tap_set_state(TAP_RESET);
1911
1912         layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1913         require_send = 1;
1914
1915         DEBUG_JTAG_IO("trst: %i, srst: %i",
1916                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1917         return retval;
1918 }
1919
1920 static int ft2232_execute_sleep(struct jtag_command *cmd)
1921 {
1922         int retval;
1923         retval = ERROR_OK;
1924
1925         DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
1926
1927         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1928                 retval = ERROR_JTAG_QUEUE_FAILED;
1929         first_unsent = cmd->next;
1930         jtag_sleep(cmd->cmd.sleep->us);
1931         DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
1932                 cmd->cmd.sleep->us,
1933                 tap_state_name(tap_get_state()));
1934         return retval;
1935 }
1936
1937 static int ft2232_execute_stableclocks(struct jtag_command *cmd)
1938 {
1939         int retval;
1940         retval = ERROR_OK;
1941
1942         /* this is only allowed while in a stable state.  A check for a stable
1943          * state was done in jtag_add_clocks()
1944          */
1945         if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1946                 retval = ERROR_JTAG_QUEUE_FAILED;
1947         DEBUG_JTAG_IO("clocks %i while in %s",
1948                 cmd->cmd.stableclocks->num_cycles,
1949                 tap_state_name(tap_get_state()));
1950         return retval;
1951 }
1952
1953 static int ft2232_execute_command(struct jtag_command *cmd)
1954 {
1955         int retval;
1956
1957         switch (cmd->type) {
1958                 case JTAG_RESET:
1959                         retval = ft2232_execute_reset(cmd);
1960                         break;
1961                 case JTAG_RUNTEST:
1962                         retval = ft2232_execute_runtest(cmd);
1963                         break;
1964                 case JTAG_TLR_RESET:
1965                         retval = ft2232_execute_statemove(cmd);
1966                         break;
1967                 case JTAG_PATHMOVE:
1968                         retval = ft2232_execute_pathmove(cmd);
1969                         break;
1970                 case JTAG_SCAN:
1971                         retval = ft2232_execute_scan(cmd);
1972                         break;
1973                 case JTAG_SLEEP:
1974                         retval = ft2232_execute_sleep(cmd);
1975                         break;
1976                 case JTAG_STABLECLOCKS:
1977                         retval = ft2232_execute_stableclocks(cmd);
1978                         break;
1979                 case JTAG_TMS:
1980                         retval = ft2232_execute_tms(cmd);
1981                         break;
1982                 default:
1983                         LOG_ERROR("BUG: unknown JTAG command type encountered");
1984                         retval = ERROR_JTAG_QUEUE_FAILED;
1985                         break;
1986         }
1987         return retval;
1988 }
1989
1990 static int ft2232_execute_queue(void)
1991 {
1992         struct jtag_command *cmd = jtag_command_queue;  /* currently processed command */
1993         int retval;
1994
1995         first_unsent = cmd;             /* next command that has to be sent */
1996         require_send = 0;
1997
1998         /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1999          * that wasn't handled by a caller-provided error handler
2000          */
2001         retval = ERROR_OK;
2002
2003         ft2232_buffer_size = 0;
2004         ft2232_expect_read = 0;
2005
2006         /* blink, if the current layout has that feature */
2007         if (layout->blink)
2008                 layout->blink();
2009
2010         while (cmd) {
2011                 /* fill the write buffer with the desired command */
2012                 if (ft2232_execute_command(cmd) != ERROR_OK)
2013                         retval = ERROR_JTAG_QUEUE_FAILED;
2014                 /* Start reading input before FT2232 TX buffer fills up.
2015                  * Sometimes this happens because we don't know the
2016                  * length of the last command before we execute it. So
2017                  * we simple inform the user.
2018                  */
2019                 cmd = cmd->next;
2020
2021                 if (ft2232_expect_read >= FT2232_BUFFER_READ_QUEUE_SIZE) {
2022                         if (ft2232_expect_read > (FT2232_BUFFER_READ_QUEUE_SIZE+1))
2023                                 LOG_DEBUG("read buffer size looks too high %d/%d",
2024                                         ft2232_expect_read,
2025                                         (FT2232_BUFFER_READ_QUEUE_SIZE+1));
2026                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2027                                 retval = ERROR_JTAG_QUEUE_FAILED;
2028                         first_unsent = cmd;
2029                 }
2030         }
2031
2032         if (require_send > 0)
2033                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2034                         retval = ERROR_JTAG_QUEUE_FAILED;
2035
2036         return retval;
2037 }
2038
2039 #if BUILD_FT2232_FTD2XX == 1
2040 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int *try_more)
2041 {
2042         FT_STATUS status;
2043         DWORD deviceID;
2044         char SerialNumber[16];
2045         char Description[64];
2046         DWORD openex_flags  = 0;
2047         char *openex_string = NULL;
2048         uint8_t latency_timer;
2049
2050         if (layout == NULL) {
2051                 LOG_WARNING("No ft2232 layout specified'");
2052                 return ERROR_JTAG_INIT_FAILED;
2053         }
2054
2055         LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)",
2056                         layout->name, vid, pid);
2057
2058 #if IS_WIN32 == 0
2059         /* Add non-standard Vid/Pid to the linux driver */
2060         status = FT_SetVIDPID(vid, pid);
2061         if (status != FT_OK)
2062                 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
2063
2064 #endif
2065
2066         if (ft2232_device_desc && ft2232_serial) {
2067                 LOG_WARNING(
2068                         "can't open by device description and serial number, giving precedence to serial");
2069                 ft2232_device_desc = NULL;
2070         }
2071
2072         if (ft2232_device_desc) {
2073                 openex_string = ft2232_device_desc;
2074                 openex_flags  = FT_OPEN_BY_DESCRIPTION;
2075         } else if (ft2232_serial) {
2076                 openex_string = ft2232_serial;
2077                 openex_flags  = FT_OPEN_BY_SERIAL_NUMBER;
2078         } else {
2079                 LOG_ERROR("neither device description nor serial number specified");
2080                 LOG_ERROR(
2081                         "please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
2082
2083                 return ERROR_JTAG_INIT_FAILED;
2084         }
2085
2086         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2087         if (status != FT_OK) {
2088                 /* under Win32, the FTD2XX driver appends an "A" to the end
2089                  * of the description, if we tried by the desc, then
2090                  * try by the alternate "A" description. */
2091                 if (openex_string == ft2232_device_desc) {
2092                         /* Try the alternate method. */
2093                         openex_string = ft2232_device_desc_A;
2094                         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2095                         if (status == FT_OK) {
2096                                 /* yea, the "alternate" method worked! */
2097                         } else {
2098                                 /* drat, give the user a meaningfull message.
2099                                  * telling the use we tried *BOTH* methods. */
2100                                 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'",
2101                                         ft2232_device_desc,
2102                                         ft2232_device_desc_A);
2103                         }
2104                 }
2105         }
2106
2107         if (status != FT_OK) {
2108                 DWORD num_devices;
2109
2110                 if (more) {
2111                         LOG_WARNING("unable to open ftdi device (trying more): %s",
2112                                 ftd2xx_status_string(status));
2113                         *try_more = 1;
2114                         return ERROR_JTAG_INIT_FAILED;
2115                 }
2116                 LOG_ERROR("unable to open ftdi device: %s",
2117                         ftd2xx_status_string(status));
2118                 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
2119                 if (status == FT_OK) {
2120                         char **desc_array = malloc(sizeof(char *) * (num_devices + 1));
2121                         uint32_t i;
2122
2123                         for (i = 0; i < num_devices; i++)
2124                                 desc_array[i] = malloc(64);
2125
2126                         desc_array[num_devices] = NULL;
2127
2128                         status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
2129
2130                         if (status == FT_OK) {
2131                                 LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
2132                                 for (i = 0; i < num_devices; i++)
2133                                         LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
2134                         }
2135
2136                         for (i = 0; i < num_devices; i++)
2137                                 free(desc_array[i]);
2138
2139                         free(desc_array);
2140                 } else
2141                         LOG_ERROR("ListDevices: NONE");
2142                 return ERROR_JTAG_INIT_FAILED;
2143         }
2144
2145         status = FT_SetLatencyTimer(ftdih, ft2232_latency);
2146         if (status != FT_OK) {
2147                 LOG_ERROR("unable to set latency timer: %s",
2148                         ftd2xx_status_string(status));
2149                 return ERROR_JTAG_INIT_FAILED;
2150         }
2151
2152         status = FT_GetLatencyTimer(ftdih, &latency_timer);
2153         if (status != FT_OK) {
2154                 /* ftd2xx 1.04 (linux) has a bug when calling FT_GetLatencyTimer
2155                  * so ignore errors if using this driver version */
2156                 DWORD dw_version;
2157
2158                 status = FT_GetDriverVersion(ftdih, &dw_version);
2159                 LOG_ERROR("unable to get latency timer: %s",
2160                         ftd2xx_status_string(status));
2161
2162                 if ((status == FT_OK) && (dw_version == 0x10004)) {
2163                         LOG_ERROR("ftd2xx 1.04 detected - this has known issues " \
2164                                 "with FT_GetLatencyTimer, upgrade to a newer version");
2165                 } else
2166                         return ERROR_JTAG_INIT_FAILED;
2167         } else
2168                 LOG_DEBUG("current latency timer: %i", latency_timer);
2169
2170         status = FT_SetTimeouts(ftdih, 5000, 5000);
2171         if (status != FT_OK) {
2172                 LOG_ERROR("unable to set timeouts: %s",
2173                         ftd2xx_status_string(status));
2174                 return ERROR_JTAG_INIT_FAILED;
2175         }
2176
2177         status = FT_SetBitMode(ftdih, 0x0b, 2);
2178         if (status != FT_OK) {
2179                 LOG_ERROR("unable to enable bit i/o mode: %s",
2180                         ftd2xx_status_string(status));
2181                 return ERROR_JTAG_INIT_FAILED;
2182         }
2183
2184         status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID,
2185                         SerialNumber, Description, NULL);
2186         if (status != FT_OK) {
2187                 LOG_ERROR("unable to get FT_GetDeviceInfo: %s",
2188                         ftd2xx_status_string(status));
2189                 return ERROR_JTAG_INIT_FAILED;
2190         } else {
2191                 static const char *type_str[] = {
2192                         "BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H", "232H"
2193                 };
2194                 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2195                 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
2196                         ? ftdi_device : FT_DEVICE_UNKNOWN;
2197                 LOG_INFO("device: %" PRIu32 " \"%s\"", (uint32_t)ftdi_device, type_str[type_index]);
2198                 LOG_INFO("deviceID: %" PRIu32, (uint32_t)deviceID);
2199                 LOG_INFO("SerialNumber: %s", SerialNumber);
2200                 LOG_INFO("Description: %s", Description);
2201         }
2202
2203         return ERROR_OK;
2204 }
2205
2206 static int ft2232_purge_ftd2xx(void)
2207 {
2208         FT_STATUS status;
2209
2210         status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
2211         if (status != FT_OK) {
2212                 LOG_ERROR("error purging ftd2xx device: %s",
2213                         ftd2xx_status_string(status));
2214                 return ERROR_JTAG_INIT_FAILED;
2215         }
2216
2217         return ERROR_OK;
2218 }
2219
2220 #endif  /* BUILD_FT2232_FTD2XX == 1 */
2221
2222 #if BUILD_FT2232_LIBFTDI == 1
2223 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int *try_more, int channel)
2224 {
2225         uint8_t latency_timer;
2226
2227         if (layout == NULL) {
2228                 LOG_WARNING("No ft2232 layout specified'");
2229                 return ERROR_JTAG_INIT_FAILED;
2230         }
2231
2232         LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2233                 layout->name, vid, pid);
2234
2235         if (ftdi_init(&ftdic) < 0)
2236                 return ERROR_JTAG_INIT_FAILED;
2237
2238         /* default to INTERFACE_A */
2239         if (channel == INTERFACE_ANY)
2240                 channel = INTERFACE_A;
2241         if (ftdi_set_interface(&ftdic, channel) < 0) {
2242                 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2243                 return ERROR_JTAG_INIT_FAILED;
2244         }
2245
2246         /* context, vendor id, product id */
2247         if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc, ft2232_serial) < 0) {
2248                 if (more)
2249                         LOG_WARNING("unable to open ftdi device (trying more): %s",
2250                                 ftdic.error_str);
2251                 else
2252                         LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2253                 *try_more = 1;
2254                 return ERROR_JTAG_INIT_FAILED;
2255         }
2256
2257         /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2258         if (ftdi_usb_reset(&ftdic) < 0) {
2259                 LOG_ERROR("unable to reset ftdi device");
2260                 return ERROR_JTAG_INIT_FAILED;
2261         }
2262
2263         if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0) {
2264                 LOG_ERROR("unable to set latency timer");
2265                 return ERROR_JTAG_INIT_FAILED;
2266         }
2267
2268         if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
2269                 LOG_ERROR("unable to get latency timer");
2270                 return ERROR_JTAG_INIT_FAILED;
2271         } else
2272                 LOG_DEBUG("current latency timer: %i", latency_timer);
2273
2274         ftdi_set_bitmode(&ftdic, 0x0b, 2);      /* ctx, JTAG I/O mask */
2275
2276         ftdi_device = ftdic.type;
2277         static const char *type_str[] = {
2278                 "AM", "BM", "2232C", "R", "2232H", "4232H", "232H", "Unknown"
2279         };
2280         unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2281         unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2282                 ? ftdi_device : no_of_known_types;
2283         LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2284         return ERROR_OK;
2285 }
2286
2287 static int ft2232_purge_libftdi(void)
2288 {
2289         if (ftdi_usb_purge_buffers(&ftdic) < 0) {
2290                 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2291                 return ERROR_JTAG_INIT_FAILED;
2292         }
2293
2294         return ERROR_OK;
2295 }
2296
2297 #endif  /* BUILD_FT2232_LIBFTDI == 1 */
2298
2299 static int ft2232_set_data_bits_low_byte(uint8_t value, uint8_t direction)
2300 {
2301         uint8_t buf[3];
2302         uint32_t bytes_written;
2303
2304         buf[0] = 0x80;          /* command "set data bits low byte" */
2305         buf[1] = value;         /* value */
2306         buf[2] = direction;     /* direction */
2307
2308         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2309
2310         if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2311                 LOG_ERROR("couldn't initialize data bits low byte");
2312                 return ERROR_JTAG_INIT_FAILED;
2313         }
2314
2315         return ERROR_OK;
2316 }
2317
2318 static int ft2232_set_data_bits_high_byte(uint8_t value, uint8_t direction)
2319 {
2320         uint8_t buf[3];
2321         uint32_t bytes_written;
2322
2323         buf[0] = 0x82;          /* command "set data bits high byte" */
2324         buf[1] = value;         /* value */
2325         buf[2] = direction;     /* direction */
2326
2327         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2328
2329         if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2330                 LOG_ERROR("couldn't initialize data bits high byte");
2331                 return ERROR_JTAG_INIT_FAILED;
2332         }
2333
2334         return ERROR_OK;
2335 }
2336
2337 static int ft2232_init(void)
2338 {
2339         uint8_t buf[1];
2340         int retval;
2341         uint32_t bytes_written;
2342
2343         if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
2344                 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2345         else
2346                 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2347         if (layout == NULL) {
2348                 LOG_WARNING("No ft2232 layout specified'");
2349                 return ERROR_JTAG_INIT_FAILED;
2350         }
2351
2352         for (int i = 0; 1; i++) {
2353                 /*
2354                  * "more indicates that there are more IDs to try, so we should
2355                  * not print an error for an ID mismatch (but for anything
2356                  * else, we should).
2357                  *
2358                  * try_more indicates that the error code returned indicates an
2359                  * ID mismatch (and nothing else) and that we should proceeed
2360                  * with the next ID pair.
2361                  */
2362                 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2363                 int try_more = 0;
2364
2365 #if BUILD_FT2232_FTD2XX == 1
2366                 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2367                                 more, &try_more);
2368 #elif BUILD_FT2232_LIBFTDI == 1
2369                 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2370                                 more, &try_more, ft2232_channel);
2371 #endif
2372                 if (retval >= 0)
2373                         break;
2374                 if (!more || !try_more)
2375                         return retval;
2376         }
2377
2378         ft2232_buffer_size = 0;
2379         ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2380
2381         if (layout->init() != ERROR_OK)
2382                 return ERROR_JTAG_INIT_FAILED;
2383
2384         if (ft2232_device_is_highspeed()) {
2385 #ifndef BUILD_FT2232_HIGHSPEED
2386  #if BUILD_FT2232_FTD2XX == 1
2387                 LOG_WARNING(
2388                         "High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2389  #elif BUILD_FT2232_LIBFTDI == 1
2390                 LOG_WARNING(
2391                         "High Speed device found - You need a newer libftdi version (0.16 or later)");
2392  #endif
2393 #endif
2394                 /* make sure the legacy mode is disabled */
2395                 if (ftx232h_clk_divide_by_5(false) != ERROR_OK)
2396                         return ERROR_JTAG_INIT_FAILED;
2397         }
2398
2399         buf[0] = 0x85;  /* Disconnect TDI/DO to TDO/DI for Loopback */
2400         retval = ft2232_write(buf, 1, &bytes_written);
2401         if (retval != ERROR_OK) {
2402                 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2403                 return ERROR_JTAG_INIT_FAILED;
2404         }
2405
2406 #if BUILD_FT2232_FTD2XX == 1
2407         return ft2232_purge_ftd2xx();
2408 #elif BUILD_FT2232_LIBFTDI == 1
2409         return ft2232_purge_libftdi();
2410 #endif
2411
2412         return ERROR_OK;
2413 }
2414
2415 /** Updates defaults for DBUS signals:  the four JTAG signals
2416  * (TCK, TDI, TDO, TMS) and * the four GPIOL signals.
2417  */
2418 static inline void ftx232_dbus_init(void)
2419 {
2420         low_output    = 0x08;
2421         low_direction = 0x0b;
2422 }
2423
2424 /** Initializes DBUS signals:  the four JTAG signals (TCK, TDI, TDO, TMS),
2425  * the four GPIOL signals.  Initialization covers value and direction,
2426  * as customized for each layout.
2427  */
2428 static int ftx232_dbus_write(void)
2429 {
2430         enum reset_types jtag_reset_config = jtag_get_reset_config();
2431         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2432                 low_direction &= ~nTRSTnOE;     /* nTRST input */
2433                 low_output &= ~nTRST;   /* nTRST = 0 */
2434         } else {
2435                 low_direction |= nTRSTnOE;      /* nTRST output */
2436                 low_output |= nTRST;            /* nTRST = 1 */
2437         }
2438
2439         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2440                 low_direction |= nSRSTnOE;      /* nSRST output */
2441                 low_output |= nSRST;            /* nSRST = 1 */
2442         } else {
2443                 low_direction &= ~nSRSTnOE;     /* nSRST input */
2444                 low_output &= ~nSRST;   /* nSRST = 0 */
2445         }
2446
2447         /* initialize low byte for jtag */
2448         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2449                 LOG_ERROR("couldn't initialize FT2232 DBUS");
2450                 return ERROR_JTAG_INIT_FAILED;
2451         }
2452
2453         return ERROR_OK;
2454 }
2455
2456 static int usbjtag_init(void)
2457 {
2458         /*
2459          * NOTE:  This is now _specific_ to the "usbjtag" layout.
2460          * Don't try cram any more layouts into this.
2461          */
2462         ftx232_dbus_init();
2463
2464         nTRST    = 0x10;
2465         nTRSTnOE = 0x10;
2466         nSRST    = 0x40;
2467         nSRSTnOE = 0x40;
2468
2469         return ftx232_dbus_write();
2470 }
2471
2472 static int lm3s811_jtag_init(void)
2473 {
2474         ftx232_dbus_init();
2475
2476         /* There are multiple revisions of LM3S811 eval boards:
2477          * - Rev B (and older?) boards have no SWO trace support.
2478          * - Rev C boards add ADBUS_6 DBG_ENn and BDBUS_4 SWO_EN;
2479          *   they should use the "luminary_icdi" layout instead.
2480          */
2481         nTRST = 0x0;
2482         nTRSTnOE = 0x00;
2483         nSRST = 0x20;
2484         nSRSTnOE = 0x20;
2485         low_output    = 0x88;
2486         low_direction = 0x8b;
2487
2488         return ftx232_dbus_write();
2489 }
2490
2491 static int icdi_jtag_init(void)
2492 {
2493         ftx232_dbus_init();
2494
2495         /* Most Luminary eval boards support SWO trace output,
2496          * and should use this "luminary_icdi" layout.
2497          *
2498          * ADBUS 0..3 are used for JTAG as usual.  GPIOs are used
2499          * to switch between JTAG and SWD, or switch the ft2232 UART
2500          * on the second MPSSE channel/interface (BDBUS)
2501          * between (i) the stellaris UART (on Luminary boards)
2502          * or (ii) SWO trace data (generic).
2503          *
2504          * We come up in JTAG mode and may switch to SWD later (with
2505          * SWO/trace option if SWD is active).
2506          *
2507          * DBUS == GPIO-Lx
2508          * CBUS == GPIO-Hx
2509          */
2510
2511
2512 #define ICDI_JTAG_EN (1 << 7)           /* ADBUS 7 (a.k.a. DBGMOD) */
2513 #define ICDI_DBG_ENn (1 << 6)           /* ADBUS 6 */
2514 #define ICDI_SRST (1 << 5)              /* ADBUS 5 */
2515
2516
2517         /* GPIOs on second channel/interface (UART) ... */
2518 #define ICDI_SWO_EN (1 << 4)            /* BDBUS 4 */
2519 #define ICDI_TX_SWO (1 << 1)            /* BDBUS 1 */
2520 #define ICDI_VCP_RX (1 << 0)            /* BDBUS 0 (to stellaris UART) */
2521
2522         nTRST = 0x0;
2523         nTRSTnOE = 0x00;
2524         nSRST = ICDI_SRST;
2525         nSRSTnOE = ICDI_SRST;
2526
2527         low_direction |= ICDI_JTAG_EN | ICDI_DBG_ENn;
2528         low_output    |= ICDI_JTAG_EN;
2529         low_output    &= ~ICDI_DBG_ENn;
2530
2531         return ftx232_dbus_write();
2532 }
2533
2534 static int signalyzer_init(void)
2535 {
2536         ftx232_dbus_init();
2537
2538         nTRST    = 0x10;
2539         nTRSTnOE = 0x10;
2540         nSRST    = 0x20;
2541         nSRSTnOE = 0x20;
2542         return ftx232_dbus_write();
2543 }
2544
2545 static int axm0432_jtag_init(void)
2546 {
2547         low_output    = 0x08;
2548         low_direction = 0x2b;
2549
2550         /* initialize low byte for jtag */
2551         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2552                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2553                 return ERROR_JTAG_INIT_FAILED;
2554         }
2555
2556         if (strcmp(layout->name, "axm0432_jtag") == 0) {
2557                 nTRST    = 0x08;
2558                 nTRSTnOE = 0x0;         /* No output enable for TRST*/
2559                 nSRST    = 0x04;
2560                 nSRSTnOE = 0x0;         /* No output enable for SRST*/
2561         } else {
2562                 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2563                 exit(-1);
2564         }
2565
2566         high_output    = 0x0;
2567         high_direction = 0x0c;
2568
2569         enum reset_types jtag_reset_config = jtag_get_reset_config();
2570         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2571                 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2572         else
2573                 high_output |= nTRST;
2574
2575         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2576                 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2577         else
2578                 high_output |= nSRST;
2579
2580         /* initialize high byte for jtag */
2581         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2582                 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2583                 return ERROR_JTAG_INIT_FAILED;
2584         }
2585
2586         return ERROR_OK;
2587 }
2588
2589 static int redbee_init(void)
2590 {
2591         low_output    = 0x08;
2592         low_direction = 0x2b;
2593
2594         /* initialize low byte for jtag */
2595         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2596                 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2597                 return ERROR_JTAG_INIT_FAILED;
2598         }
2599
2600         nTRST    = 0x08;
2601         nTRSTnOE = 0x0;         /* No output enable for TRST*/
2602         nSRST    = 0x04;
2603         nSRSTnOE = 0x0;         /* No output enable for SRST*/
2604
2605         high_output    = 0x0;
2606         high_direction = 0x0c;
2607
2608         enum reset_types jtag_reset_config = jtag_get_reset_config();
2609         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2610                 LOG_ERROR("can't set nTRSTOE to push-pull on redbee");
2611         else
2612                 high_output |= nTRST;
2613
2614         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2615                 LOG_ERROR("can't set nSRST to push-pull on redbee");
2616         else
2617                 high_output |= nSRST;
2618
2619         /* initialize high byte for jtag */
2620         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2621                 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2622                 return ERROR_JTAG_INIT_FAILED;
2623         }
2624
2625         return ERROR_OK;
2626 }
2627
2628 static int jtagkey_init(void)
2629 {
2630         low_output    = 0x08;
2631         low_direction = 0x1b;
2632
2633         /* initialize low byte for jtag */
2634         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2635                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2636                 return ERROR_JTAG_INIT_FAILED;
2637         }
2638
2639         if (strcmp(layout->name, "jtagkey") == 0) {
2640                 nTRST    = 0x01;
2641                 nTRSTnOE = 0x4;
2642                 nSRST    = 0x02;
2643                 nSRSTnOE = 0x08;
2644         } else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2645                    || (strcmp(layout->name, "oocdlink") == 0)) {
2646                 nTRST    = 0x02;
2647                 nTRSTnOE = 0x1;
2648                 nSRST    = 0x08;
2649                 nSRSTnOE = 0x04;
2650         } else {
2651                 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2652                 exit(-1);
2653         }
2654
2655         high_output    = 0x0;
2656         high_direction = 0x0f;
2657
2658         enum reset_types jtag_reset_config = jtag_get_reset_config();
2659         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2660                 high_output |= nTRSTnOE;
2661                 high_output &= ~nTRST;
2662         } else {
2663                 high_output &= ~nTRSTnOE;
2664                 high_output |= nTRST;
2665         }
2666
2667         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2668                 high_output &= ~nSRSTnOE;
2669                 high_output |= nSRST;
2670         } else {
2671                 high_output |= nSRSTnOE;
2672                 high_output &= ~nSRST;
2673         }
2674
2675         /* initialize high byte for jtag */
2676         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2677                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2678                 return ERROR_JTAG_INIT_FAILED;
2679         }
2680
2681         return ERROR_OK;
2682 }
2683
2684 static int olimex_jtag_init(void)
2685 {
2686         low_output    = 0x08;
2687         low_direction = 0x1b;
2688
2689         /* initialize low byte for jtag */
2690         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2691                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2692                 return ERROR_JTAG_INIT_FAILED;
2693         }
2694
2695         nTRST    = 0x01;
2696         nTRSTnOE = 0x4;
2697         nSRST    = 0x02;
2698         nSRSTnOE = 0x00;/* no output enable for nSRST */
2699
2700         high_output    = 0x0;
2701         high_direction = 0x0f;
2702
2703         enum reset_types jtag_reset_config = jtag_get_reset_config();
2704         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2705                 high_output |= nTRSTnOE;
2706                 high_output &= ~nTRST;
2707         } else {
2708                 high_output &= ~nTRSTnOE;
2709                 high_output |= nTRST;
2710         }
2711
2712         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2713                 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2714         else
2715                 high_output &= ~nSRST;
2716
2717         /* turn red LED on */
2718         high_output |= 0x08;
2719
2720         /* initialize high byte for jtag */
2721         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2722                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2723                 return ERROR_JTAG_INIT_FAILED;
2724         }
2725
2726         return ERROR_OK;
2727 }
2728
2729 static int flyswatter_init(int rev)
2730 {
2731         low_output    = 0x18;
2732         low_direction = 0x7b;
2733
2734         if ((rev < 0) || (rev > 3)) {
2735                 LOG_ERROR("bogus 'flyswatter' revision supplied (%i)", rev);
2736                 return ERROR_JTAG_INIT_FAILED;
2737         }
2738
2739         if (rev == 1)
2740                 low_direction |= 1 << 7;
2741
2742         /* initialize low byte for jtag */
2743         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2744                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2745                 return ERROR_JTAG_INIT_FAILED;
2746         }
2747
2748         nTRST    = 0x10;
2749         nTRSTnOE = 0x0;         /* not output enable for nTRST */
2750         nSRST    = 0x20;
2751         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2752
2753         high_output    = 0x00;
2754
2755         if (rev == 1)
2756                 high_direction = 0x0c;
2757         else
2758                 high_direction = 0x01;
2759
2760         /* turn red LED3 on, LED2 off */
2761         high_output |= 0x08;
2762
2763         /* initialize high byte for jtag */
2764         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2765                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2766                 return ERROR_JTAG_INIT_FAILED;
2767         }
2768
2769         return ERROR_OK;
2770 }
2771
2772 static int flyswatter1_init(void)
2773 {
2774         return flyswatter_init(1);
2775 }
2776
2777 static int flyswatter2_init(void)
2778 {
2779         return flyswatter_init(2);
2780 }
2781
2782 static int minimodule_init(void)
2783 {
2784         low_output    = 0x18;   /* check if srst should be 1 or 0 initially. (0x08) (flyswatter was
2785                                  * 0x18) */
2786         low_direction = 0xfb;   /* 0xfb; */
2787
2788         /* initialize low byte for jtag */
2789         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2790                 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2791                 return ERROR_JTAG_INIT_FAILED;
2792         }
2793
2794
2795         nSRST    = 0x20;
2796
2797         high_output    = 0x00;
2798         high_direction = 0x05;
2799
2800         /* turn red LED3 on, LED2 off */
2801         /* high_output |= 0x08; */
2802
2803         /* initialize high byte for jtag */
2804         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2805                 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2806                 return ERROR_JTAG_INIT_FAILED;
2807         }
2808
2809         return ERROR_OK;
2810 }
2811
2812 static int turtle_init(void)
2813 {
2814         low_output    = 0x08;
2815         low_direction = 0x5b;
2816
2817         /* initialize low byte for jtag */
2818         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2819                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2820                 return ERROR_JTAG_INIT_FAILED;
2821         }
2822
2823         nSRST = 0x40;
2824
2825         high_output    = 0x00;
2826         high_direction = 0x0C;
2827
2828         /* initialize high byte for jtag */
2829         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2830                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2831                 return ERROR_JTAG_INIT_FAILED;
2832         }
2833
2834         return ERROR_OK;
2835 }
2836
2837 static int comstick_init(void)
2838 {
2839         low_output    = 0x08;
2840         low_direction = 0x0b;
2841
2842         /* initialize low byte for jtag */
2843         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2844                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2845                 return ERROR_JTAG_INIT_FAILED;
2846         }
2847
2848         nTRST    = 0x01;
2849         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2850         nSRST    = 0x02;
2851         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2852
2853         high_output    = 0x03;
2854         high_direction = 0x03;
2855
2856         /* initialize high byte for jtag */
2857         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2858                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2859                 return ERROR_JTAG_INIT_FAILED;
2860         }
2861
2862         return ERROR_OK;
2863 }
2864
2865 static int stm32stick_init(void)
2866 {
2867         low_output    = 0x88;
2868         low_direction = 0x8b;
2869
2870         /* initialize low byte for jtag */
2871         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2872                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2873                 return ERROR_JTAG_INIT_FAILED;
2874         }
2875
2876         nTRST    = 0x01;
2877         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2878         nSRST    = 0x80;
2879         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2880
2881         high_output    = 0x01;
2882         high_direction = 0x03;
2883
2884         /* initialize high byte for jtag */
2885         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2886                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2887                 return ERROR_JTAG_INIT_FAILED;
2888         }
2889
2890         return ERROR_OK;
2891 }
2892
2893 static int sheevaplug_init(void)
2894 {
2895         low_output = 0x08;
2896         low_direction = 0x1b;
2897
2898         /* initialize low byte for jtag */
2899         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2900                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2901                 return ERROR_JTAG_INIT_FAILED;
2902         }
2903
2904         nTRSTnOE = 0x1;
2905         nTRST = 0x02;
2906         nSRSTnOE = 0x4;
2907         nSRST = 0x08;
2908
2909         high_output = 0x0;
2910         high_direction = 0x0f;
2911
2912         /* nTRST is always push-pull */
2913         high_output &= ~nTRSTnOE;
2914         high_output |= nTRST;
2915
2916         /* nSRST is always open-drain */
2917         high_output |= nSRSTnOE;
2918         high_output &= ~nSRST;
2919
2920         /* initialize high byte for jtag */
2921         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2922                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2923                 return ERROR_JTAG_INIT_FAILED;
2924         }
2925
2926         return ERROR_OK;
2927 }
2928
2929 static int cortino_jtag_init(void)
2930 {
2931         low_output    = 0x08;
2932         low_direction = 0x1b;
2933
2934         /* initialize low byte for jtag */
2935         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2936                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2937                 return ERROR_JTAG_INIT_FAILED;
2938         }
2939
2940         nTRST    = 0x01;
2941         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2942         nSRST    = 0x02;
2943         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2944
2945         high_output    = 0x03;
2946         high_direction = 0x03;
2947
2948         /* initialize high byte for jtag */
2949         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2950                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2951                 return ERROR_JTAG_INIT_FAILED;
2952         }
2953
2954         return ERROR_OK;
2955 }
2956
2957 static int lisa_l_init(void)
2958 {
2959         ftx232_dbus_init();
2960
2961         nTRST    = 0x10;
2962         nTRSTnOE = 0x10;
2963         nSRST    = 0x40;
2964         nSRSTnOE = 0x40;
2965
2966         high_output = 0x00;
2967         high_direction = 0x18;
2968
2969         /* initialize high byte for jtag */
2970         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2971                 LOG_ERROR("couldn't initialize FT2232 with 'lisa_l' layout");
2972                 return ERROR_JTAG_INIT_FAILED;
2973         }
2974
2975         return ftx232_dbus_write();
2976 }
2977
2978 static int flossjtag_init(void)
2979 {
2980         ftx232_dbus_init();
2981
2982         nTRST    = 0x10;
2983         nTRSTnOE = 0x10;
2984         nSRST    = 0x40;
2985         nSRSTnOE = 0x40;
2986
2987         high_output = 0x00;
2988         high_direction = 0x18;
2989
2990         /* initialize high byte for jtag */
2991         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2992                 LOG_ERROR("couldn't initialize FT2232 with 'Floss-JTAG' layout");
2993                 return ERROR_JTAG_INIT_FAILED;
2994         }
2995
2996         return ftx232_dbus_write();
2997 }
2998
2999 /*
3000  * The reference schematic from TI for the XDS100v2 has a CPLD on which opens
3001  * the door for a number of different configurations
3002  *
3003  * Known Implementations:
3004  * http://processors.wiki.ti.com/images/9/93/TMS570LS20216_USB_STICK_Schematic.pdf
3005  *
3006  * http://processors.wiki.ti.com/index.php/XDS100 (rev2)
3007  *      * CLPD logic: Rising edge to enable outputs (XDS100_PWR_RST)
3008  *              * ACBUS3 to transition 0->1 (OE rising edge)
3009  *      * CPLD logic: Put the EMU0/1 pins in Hi-Z:
3010  *              * ADBUS5/GPIOL1 = EMU_EN = 1
3011  *              * ADBUS6/GPIOL2 = EMU0 = 0
3012  *              * ACBUS4/SPARE0 = EMU1 = 0
3013  *      * CPLD logic: Disable loopback
3014  *              * ACBUS6/SPARE2 = LOOPBACK = 0
3015  */
3016 #define XDS100_nEMU_EN  (1<<5)
3017 #define XDS100_nEMU0    (1<<6)
3018
3019 #define XDS100_PWR_RST  (1<<3)
3020 #define XDS100_nEMU1    (1<<4)
3021 #define XDS100_LOOPBACK (1<<6)
3022 static int xds100v2_init(void)
3023 {
3024         /* These are in the lower byte */
3025         nTRST    = 0x10;
3026         nTRSTnOE = 0x10;
3027
3028         /* These aren't actually used on 14 pin connectors
3029          * These are in the upper byte */
3030         nSRST    = 0x01;
3031         nSRSTnOE = 0x01;
3032
3033         low_output    = 0x08 | nTRST | XDS100_nEMU_EN;
3034         low_direction = 0x0b | nTRSTnOE | XDS100_nEMU_EN | XDS100_nEMU0;
3035
3036         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3037                 LOG_ERROR("couldn't initialize FT2232 with 'xds100v2' layout");
3038                 return ERROR_JTAG_INIT_FAILED;
3039         }
3040
3041         high_output = 0;
3042         high_direction = nSRSTnOE | XDS100_LOOPBACK | XDS100_PWR_RST | XDS100_nEMU1;
3043
3044         /* initialize high byte for jtag */
3045         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3046                 LOG_ERROR("couldn't put CPLD in to reset with 'xds100v2' layout");
3047                 return ERROR_JTAG_INIT_FAILED;
3048         }
3049
3050         high_output |= XDS100_PWR_RST;
3051
3052         /* initialize high byte for jtag */
3053         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3054                 LOG_ERROR("couldn't bring CPLD out of reset with 'xds100v2' layout");
3055                 return ERROR_JTAG_INIT_FAILED;
3056         }
3057
3058         return ERROR_OK;
3059 }
3060
3061 static void olimex_jtag_blink(void)
3062 {
3063         /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
3064          * ACBUS3 is bit 3 of the GPIOH port
3065          */
3066         high_output ^= 0x08;
3067
3068         buffer_write(0x82);
3069         buffer_write(high_output);
3070         buffer_write(high_direction);
3071 }
3072
3073 static void flyswatter_jtag_blink(unsigned char led)
3074 {
3075         buffer_write(0x82);
3076         buffer_write(high_output ^ led);
3077         buffer_write(high_direction);
3078 }
3079
3080 static void flyswatter1_jtag_blink(void)
3081 {
3082         /*
3083          * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
3084          */
3085         flyswatter_jtag_blink(0xc);
3086 }
3087
3088 static void flyswatter2_jtag_blink(void)
3089 {
3090         /*
3091          * Flyswatter2 only has one LED connected to ACBUS2
3092          */
3093         flyswatter_jtag_blink(0x4);
3094 }
3095
3096 static void turtle_jtag_blink(void)
3097 {
3098         /*
3099          * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
3100          */
3101         if (high_output & 0x08)
3102                 high_output = 0x04;
3103         else
3104                 high_output = 0x08;
3105
3106         buffer_write(0x82);
3107         buffer_write(high_output);
3108         buffer_write(high_direction);
3109 }
3110
3111 static void lisa_l_blink(void)
3112 {
3113         /*
3114          * Lisa/L has two LEDs connected to BCBUS3 and BCBUS4
3115          */
3116         if (high_output & 0x10)
3117                 high_output = 0x08;
3118         else
3119                 high_output = 0x10;
3120
3121         buffer_write(0x82);
3122         buffer_write(high_output);
3123         buffer_write(high_direction);
3124 }
3125
3126 static void flossjtag_blink(void)
3127 {
3128         /*
3129          * Floss-JTAG has two LEDs connected to ACBUS3 and ACBUS4
3130          */
3131         if (high_output & 0x10)
3132                 high_output = 0x08;
3133         else
3134                 high_output = 0x10;
3135
3136         buffer_write(0x82);
3137         buffer_write(high_output);
3138         buffer_write(high_direction);
3139 }
3140
3141 static int ft2232_quit(void)
3142 {
3143 #if BUILD_FT2232_FTD2XX == 1
3144         FT_STATUS status;
3145
3146         status = FT_Close(ftdih);
3147 #elif BUILD_FT2232_LIBFTDI == 1
3148         ftdi_usb_close(&ftdic);
3149
3150         ftdi_deinit(&ftdic);
3151 #endif
3152
3153         free(ft2232_buffer);
3154         ft2232_buffer = NULL;
3155
3156         return ERROR_OK;
3157 }
3158
3159 COMMAND_HANDLER(ft2232_handle_device_desc_command)
3160 {
3161         char *cp;
3162         char buf[200];
3163         if (CMD_ARGC == 1) {
3164                 ft2232_device_desc = strdup(CMD_ARGV[0]);
3165                 cp = strchr(ft2232_device_desc, 0);
3166                 /* under Win32, the FTD2XX driver appends an "A" to the end
3167                  * of the description, this examines the given desc
3168                  * and creates the 'missing' _A or non_A variable. */
3169                 if ((cp[-1] == 'A') && (cp[-2] == ' ')) {
3170                         /* it was, so make this the "A" version. */
3171                         ft2232_device_desc_A = ft2232_device_desc;
3172                         /* and *CREATE* the non-A version. */
3173                         strcpy(buf, ft2232_device_desc);
3174                         cp = strchr(buf, 0);
3175                         cp[-2] = 0;
3176                         ft2232_device_desc = strdup(buf);
3177                 } else {
3178                         /* <space > A not defined
3179                          * so create it */
3180                         sprintf(buf, "%s A", ft2232_device_desc);
3181                         ft2232_device_desc_A = strdup(buf);
3182                 }
3183         } else
3184                 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
3185
3186         return ERROR_OK;
3187 }
3188
3189 COMMAND_HANDLER(ft2232_handle_serial_command)
3190 {
3191         if (CMD_ARGC == 1)
3192                 ft2232_serial = strdup(CMD_ARGV[0]);
3193         else
3194                 return ERROR_COMMAND_SYNTAX_ERROR;
3195
3196         return ERROR_OK;
3197 }
3198
3199 COMMAND_HANDLER(ft2232_handle_layout_command)
3200 {
3201         if (CMD_ARGC != 1)
3202                 return ERROR_COMMAND_SYNTAX_ERROR;
3203
3204         if (layout) {
3205                 LOG_ERROR("already specified ft2232_layout %s",
3206                         layout->name);
3207                 return (strcmp(layout->name, CMD_ARGV[0]) != 0)
3208                        ? ERROR_FAIL
3209                        : ERROR_OK;
3210         }
3211
3212         for (const struct ft2232_layout *l = ft2232_layouts; l->name; l++) {
3213                 if (strcmp(l->name, CMD_ARGV[0]) == 0) {
3214                         layout = l;
3215                         ft2232_channel = l->channel;
3216                         return ERROR_OK;
3217                 }
3218         }
3219
3220         LOG_ERROR("No FT2232 layout '%s' found", CMD_ARGV[0]);
3221         return ERROR_FAIL;
3222 }
3223
3224 COMMAND_HANDLER(ft2232_handle_vid_pid_command)
3225 {
3226         if (CMD_ARGC > MAX_USB_IDS * 2) {
3227                 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
3228                         "(maximum is %d pairs)", MAX_USB_IDS);
3229                 CMD_ARGC = MAX_USB_IDS * 2;
3230         }
3231         if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
3232                 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
3233                 if (CMD_ARGC < 2)
3234                         return ERROR_COMMAND_SYNTAX_ERROR;
3235                 /* remove the incomplete trailing id */
3236                 CMD_ARGC -= 1;
3237         }
3238
3239         unsigned i;
3240         for (i = 0; i < CMD_ARGC; i += 2) {
3241                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ft2232_vid[i >> 1]);
3242                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ft2232_pid[i >> 1]);
3243         }
3244
3245         /*
3246          * Explicitly terminate, in case there are multiples instances of
3247          * ft2232_vid_pid.
3248          */
3249         ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
3250
3251         return ERROR_OK;
3252 }
3253
3254 COMMAND_HANDLER(ft2232_handle_latency_command)
3255 {
3256         if (CMD_ARGC == 1)
3257                 ft2232_latency = atoi(CMD_ARGV[0]);
3258         else
3259                 return ERROR_COMMAND_SYNTAX_ERROR;
3260
3261         return ERROR_OK;
3262 }
3263
3264 COMMAND_HANDLER(ft2232_handle_channel_command)
3265 {
3266         if (CMD_ARGC == 1) {
3267                 ft2232_channel = atoi(CMD_ARGV[0]);
3268                 if (ft2232_channel < 0 || ft2232_channel > 4)
3269                         LOG_ERROR("ft2232_channel must be in the 0 to 4 range");
3270         } else
3271                 LOG_ERROR("expected exactly one argument to ft2232_channel <ch>");
3272
3273         return ERROR_OK;
3274 }
3275
3276 static int ft2232_stableclocks(int num_cycles, struct jtag_command *cmd)
3277 {
3278         int retval = 0;
3279
3280         /* 7 bits of either ones or zeros. */
3281         uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
3282
3283         while (num_cycles > 0) {
3284                 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
3285                  * at most 7 bits per invocation.  Here we invoke it potentially
3286                  * several times.
3287                  */
3288                 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
3289
3290                 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE) {
3291                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
3292                                 retval = ERROR_JTAG_QUEUE_FAILED;
3293
3294                         first_unsent = cmd;
3295                 }
3296
3297                 /* there are no state transitions in this code, so omit state tracking */
3298
3299                 /* command "Clock Data to TMS/CS Pin (no Read)" */
3300                 buffer_write(0x4b);
3301
3302                 /* scan 7 bit */
3303                 buffer_write(bitcount_per_command - 1);
3304
3305                 /* TMS data bits are either all zeros or ones to stay in the current stable state */
3306                 buffer_write(tms);
3307
3308                 require_send = 1;
3309
3310                 num_cycles -= bitcount_per_command;
3311         }
3312
3313         return retval;
3314 }
3315
3316 /* ---------------------------------------------------------------------
3317  * Support for IceBear JTAG adapter from Section5:
3318  *      http://section5.ch/icebear
3319  *
3320  * Author: Sten, debian@sansys-electronic.com
3321  */
3322
3323 /* Icebear pin layout
3324  *
3325  * ADBUS5 (nEMU) nSRST  | 2   1|        GND (10k->VCC)
3326  * GND GND              | 4   3|        n.c.
3327  * ADBUS3 TMS           | 6   5|        ADBUS6 VCC
3328  * ADBUS0 TCK           | 8   7|        ADBUS7 (GND)
3329  * ADBUS4 nTRST         |10   9|        ACBUS0 (GND)
3330  * ADBUS1 TDI           |12  11|        ACBUS1 (GND)
3331  * ADBUS2 TDO           |14  13|        GND GND
3332  *
3333  * ADBUS0 O L TCK               ACBUS0 GND
3334  * ADBUS1 O L TDI               ACBUS1 GND
3335  * ADBUS2 I   TDO               ACBUS2 n.c.
3336  * ADBUS3 O H TMS               ACBUS3 n.c.
3337  * ADBUS4 O H nTRST
3338  * ADBUS5 O H nSRST
3339  * ADBUS6 -   VCC
3340  * ADBUS7 -   GND
3341  */
3342 static int icebear_jtag_init(void)
3343 {
3344         low_direction   = 0x0b; /* output: TCK TDI TMS; input: TDO */
3345         low_output      = 0x08; /* high: TMS; low: TCK TDI */
3346         nTRST           = 0x10;
3347         nSRST           = 0x20;
3348
3349         enum reset_types jtag_reset_config = jtag_get_reset_config();
3350         if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3351                 low_direction   &= ~nTRST;      /* nTRST high impedance */
3352         else {
3353                 low_direction   |= nTRST;
3354                 low_output      |= nTRST;
3355         }
3356
3357         low_direction   |= nSRST;
3358         low_output      |= nSRST;
3359
3360         /* initialize low byte for jtag */
3361         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3362                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3363                 return ERROR_JTAG_INIT_FAILED;
3364         }
3365
3366         high_output    = 0x0;
3367         high_direction = 0x00;
3368
3369         /* initialize high byte for jtag */
3370         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3371                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3372                 return ERROR_JTAG_INIT_FAILED;
3373         }
3374
3375         return ERROR_OK;
3376 }
3377
3378 static void icebear_jtag_reset(int trst, int srst)
3379 {
3380         if (trst == 1) {
3381                 low_direction   |= nTRST;
3382                 low_output      &= ~nTRST;
3383         } else if (trst == 0) {
3384                 enum reset_types jtag_reset_config = jtag_get_reset_config();
3385                 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3386                         low_direction   &= ~nTRST;
3387                 else
3388                         low_output      |= nTRST;
3389         }
3390
3391         if (srst == 1)
3392                 low_output &= ~nSRST;
3393         else if (srst == 0)
3394                 low_output |= nSRST;
3395
3396         /* command "set data bits low byte" */
3397         buffer_write(0x80);
3398         buffer_write(low_output);
3399         buffer_write(low_direction);
3400
3401         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
3402                 trst,
3403                 srst,
3404                 low_output,
3405                 low_direction);
3406 }
3407
3408 /* ---------------------------------------------------------------------
3409  * Support for Signalyzer H2 and Signalyzer H4
3410  * JTAG adapter from Xverve Technologies Inc.
3411  * http://www.signalyzer.com or http://www.xverve.com
3412  *
3413  * Author: Oleg Seiljus, oleg@signalyzer.com
3414  */
3415 static unsigned char signalyzer_h_side;
3416 static unsigned int signalyzer_h_adapter_type;
3417
3418 static int signalyzer_h_ctrl_write(int address, unsigned short value);
3419
3420 #if BUILD_FT2232_FTD2XX == 1
3421 static int signalyzer_h_ctrl_read(int address, unsigned short *value);
3422 #endif
3423
3424 #define SIGNALYZER_COMMAND_ADDR                                 128
3425 #define SIGNALYZER_DATA_BUFFER_ADDR                             129
3426
3427 #define SIGNALYZER_COMMAND_VERSION                              0x41
3428 #define SIGNALYZER_COMMAND_RESET                                0x42
3429 #define SIGNALYZER_COMMAND_POWERCONTROL_GET             0x50
3430 #define SIGNALYZER_COMMAND_POWERCONTROL_SET             0x51
3431 #define SIGNALYZER_COMMAND_PWM_SET                              0x52
3432 #define SIGNALYZER_COMMAND_LED_SET                              0x53
3433 #define SIGNALYZER_COMMAND_ADC                                  0x54
3434 #define SIGNALYZER_COMMAND_GPIO_STATE                   0x55
3435 #define SIGNALYZER_COMMAND_GPIO_MODE                    0x56
3436 #define SIGNALYZER_COMMAND_GPIO_PORT                    0x57
3437 #define SIGNALYZER_COMMAND_I2C                                  0x58
3438
3439 #define SIGNALYZER_CHAN_A                                               1
3440 #define SIGNALYZER_CHAN_B                                               2
3441 /* LEDS use channel C */
3442 #define SIGNALYZER_CHAN_C                                               4
3443
3444 #define SIGNALYZER_LED_GREEN                                    1
3445 #define SIGNALYZER_LED_RED                                              2
3446
3447 #define SIGNALYZER_MODULE_TYPE_EM_LT16_A                0x0301
3448 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG              0x0302
3449 #define SIGNALYZER_MODULE_TYPE_EM_JTAG                  0x0303
3450 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P    0x0304
3451 #define SIGNALYZER_MODULE_TYPE_EM_JTAG_P                0x0305
3452
3453
3454 static int signalyzer_h_ctrl_write(int address, unsigned short value)
3455 {
3456 #if BUILD_FT2232_FTD2XX == 1
3457         return FT_WriteEE(ftdih, address, value);
3458 #elif BUILD_FT2232_LIBFTDI == 1
3459         return 0;
3460 #endif
3461 }
3462
3463 #if BUILD_FT2232_FTD2XX == 1
3464 static int signalyzer_h_ctrl_read(int address, unsigned short *value)
3465 {
3466         return FT_ReadEE(ftdih, address, value);
3467 }
3468 #endif
3469
3470 static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
3471         int on_time_ms, int off_time_ms, unsigned char cycles)
3472 {
3473         unsigned char on_time;
3474         unsigned char off_time;
3475
3476         if (on_time_ms < 0xFFFF)
3477                 on_time = (unsigned char)(on_time_ms / 62);
3478         else
3479                 on_time = 0xFF;
3480
3481         off_time = (unsigned char)(off_time_ms / 62);
3482
3483 #if BUILD_FT2232_FTD2XX == 1
3484         FT_STATUS status;
3485
3486         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3487                         ((uint32_t)(channel << 8) | led));
3488         if (status != FT_OK) {
3489                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3490                         ftd2xx_status_string(status));
3491                 return ERROR_JTAG_DEVICE_ERROR;
3492         }
3493
3494         status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3495                         ((uint32_t)(on_time << 8) | off_time));
3496         if (status != FT_OK) {
3497                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3498                         ftd2xx_status_string(status));
3499                 return ERROR_JTAG_DEVICE_ERROR;
3500         }
3501
3502         status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3503                         ((uint32_t)cycles));
3504         if (status != FT_OK) {
3505                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3506                         ftd2xx_status_string(status));
3507                 return ERROR_JTAG_DEVICE_ERROR;
3508         }
3509
3510         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3511                                 SIGNALYZER_COMMAND_LED_SET);
3512         if (status != FT_OK) {
3513                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3514                         ftd2xx_status_string(status));
3515                 return ERROR_JTAG_DEVICE_ERROR;
3516         }
3517
3518         return ERROR_OK;
3519 #elif BUILD_FT2232_LIBFTDI == 1
3520         int retval;
3521
3522         retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3523                                 ((uint32_t)(channel << 8) | led));
3524         if (retval < 0) {
3525                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3526                         ftdi_get_error_string(&ftdic));
3527                 return ERROR_JTAG_DEVICE_ERROR;
3528         }
3529
3530         retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3531                         ((uint32_t)(on_time << 8) | off_time));
3532         if (retval < 0) {
3533                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3534                         ftdi_get_error_string(&ftdic));
3535                 return ERROR_JTAG_DEVICE_ERROR;
3536         }
3537
3538         retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3539                         (uint32_t)cycles);
3540         if (retval < 0) {
3541                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3542                         ftdi_get_error_string(&ftdic));
3543                 return ERROR_JTAG_DEVICE_ERROR;
3544         }
3545
3546         retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3547                         SIGNALYZER_COMMAND_LED_SET);
3548         if (retval < 0) {
3549                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3550                         ftdi_get_error_string(&ftdic));
3551                 return ERROR_JTAG_DEVICE_ERROR;
3552         }
3553
3554         return ERROR_OK;
3555 #endif
3556 }
3557
3558 static int signalyzer_h_init(void)
3559 {
3560 #if BUILD_FT2232_FTD2XX == 1
3561         FT_STATUS status;
3562         int i;
3563 #endif
3564
3565         char *end_of_desc;
3566
3567         uint16_t read_buf[12] = { 0 };
3568
3569         /* turn on center green led */
3570         signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
3571                 0xFFFF, 0x00, 0x00);
3572
3573         /* determine what channel config wants to open
3574          * TODO: change me... current implementation is made to work
3575          * with openocd description parsing.
3576          */
3577         end_of_desc = strrchr(ft2232_device_desc, 0x00);
3578
3579         if (end_of_desc) {
3580                 signalyzer_h_side = *(end_of_desc - 1);
3581                 if (signalyzer_h_side == 'B')
3582                         signalyzer_h_side = SIGNALYZER_CHAN_B;
3583                 else
3584                         signalyzer_h_side = SIGNALYZER_CHAN_A;
3585         } else {
3586                 LOG_ERROR("No Channel was specified");
3587                 return ERROR_FAIL;
3588         }
3589
3590         signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
3591                 1000, 1000, 0xFF);
3592
3593 #if BUILD_FT2232_FTD2XX == 1
3594         /* read signalyzer versionining information */
3595         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3596                         SIGNALYZER_COMMAND_VERSION);
3597         if (status != FT_OK) {
3598                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3599                         ftd2xx_status_string(status));
3600                 return ERROR_JTAG_DEVICE_ERROR;
3601         }
3602
3603         for (i = 0; i < 10; i++) {
3604                 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i),
3605                                 &read_buf[i]);
3606                 if (status != FT_OK) {
3607                         LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3608                                 ftd2xx_status_string(status));
3609                         return ERROR_JTAG_DEVICE_ERROR;
3610                 }
3611         }
3612
3613         LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
3614                 read_buf[0], read_buf[1], read_buf[2], read_buf[3],
3615                 read_buf[4], read_buf[5], read_buf[6]);
3616
3617         /* set gpio register */
3618         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3619                         (uint32_t)(signalyzer_h_side << 8));
3620         if (status != FT_OK) {
3621                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3622                         ftd2xx_status_string(status));
3623                 return ERROR_JTAG_DEVICE_ERROR;
3624         }
3625
3626         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0404);
3627         if (status != FT_OK) {
3628                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3629                         ftd2xx_status_string(status));
3630                 return ERROR_JTAG_DEVICE_ERROR;
3631         }
3632
3633         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3634                         SIGNALYZER_COMMAND_GPIO_STATE);
3635         if (status != FT_OK) {
3636                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3637                         ftd2xx_status_string(status));
3638                 return ERROR_JTAG_DEVICE_ERROR;
3639         }
3640
3641         /* read adapter type information */
3642         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3643                         ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3644         if (status != FT_OK) {
3645                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3646                         ftd2xx_status_string(status));
3647                 return ERROR_JTAG_DEVICE_ERROR;
3648         }
3649
3650         status = signalyzer_h_ctrl_write(
3651                         (SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000);
3652         if (status != FT_OK) {
3653                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3654                         ftd2xx_status_string(status));
3655                 return ERROR_JTAG_DEVICE_ERROR;
3656         }
3657
3658         status = signalyzer_h_ctrl_write(
3659                         (SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008);
3660         if (status != FT_OK) {
3661                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3662                         ftd2xx_status_string(status));
3663                 return ERROR_JTAG_DEVICE_ERROR;
3664         }
3665
3666         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3667                         SIGNALYZER_COMMAND_I2C);
3668         if (status != FT_OK) {
3669                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3670                         ftd2xx_status_string(status));
3671                 return ERROR_JTAG_DEVICE_ERROR;
3672         }
3673
3674         usleep(100000);
3675
3676         status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR, &read_buf[0]);
3677         if (status != FT_OK) {
3678                 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3679                         ftd2xx_status_string(status));
3680                 return ERROR_JTAG_DEVICE_ERROR;
3681         }
3682
3683         if (read_buf[0] != 0x0498)
3684                 signalyzer_h_adapter_type = 0x0000;
3685         else {
3686                 for (i = 0; i < 4; i++) {
3687                         status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i), &read_buf[i]);
3688                         if (status != FT_OK) {
3689                                 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3690                                         ftd2xx_status_string(status));
3691                                 return ERROR_JTAG_DEVICE_ERROR;
3692                         }
3693                 }
3694
3695                 signalyzer_h_adapter_type = read_buf[0];
3696         }
3697
3698 #elif BUILD_FT2232_LIBFTDI == 1
3699         /* currently libftdi does not allow reading individual eeprom
3700          * locations, therefore adapter type cannot be detected.
3701          * override with most common type
3702          */
3703         signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
3704 #endif
3705
3706         enum reset_types jtag_reset_config = jtag_get_reset_config();
3707
3708         /* ADAPTOR: EM_LT16_A */
3709         if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3710                 LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
3711                         "detected. (HW: %2x).", (read_buf[1] >> 8));
3712
3713                 nTRST    = 0x10;
3714                 nTRSTnOE = 0x10;
3715                 nSRST    = 0x20;
3716                 nSRSTnOE = 0x20;
3717
3718                 low_output     = 0x08;
3719                 low_direction  = 0x1b;
3720
3721                 high_output    = 0x0;
3722                 high_direction = 0x0;
3723
3724                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3725                         low_direction &= ~nTRSTnOE;     /* nTRST input */
3726                         low_output    &= ~nTRST;        /* nTRST = 0 */
3727                 } else {
3728                         low_direction |= nTRSTnOE;      /* nTRST output */
3729                         low_output    |= nTRST;         /* nTRST = 1 */
3730                 }
3731
3732                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3733                         low_direction |= nSRSTnOE;      /* nSRST output */
3734                         low_output    |= nSRST;         /* nSRST = 1 */
3735                 } else {
3736                         low_direction &= ~nSRSTnOE;     /* nSRST input */
3737                         low_output    &= ~nSRST;        /* nSRST = 0 */
3738                 }
3739
3740 #if BUILD_FT2232_FTD2XX == 1
3741                 /* enable power to the module */
3742                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3743                                 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3744                 if (status != FT_OK) {
3745                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3746                                 ftd2xx_status_string(status));
3747                         return ERROR_JTAG_DEVICE_ERROR;
3748                 }
3749
3750                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3751                                 SIGNALYZER_COMMAND_POWERCONTROL_SET);
3752                 if (status != FT_OK) {
3753                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3754                                 ftd2xx_status_string(status));
3755                         return ERROR_JTAG_DEVICE_ERROR;
3756                 }
3757
3758                 /* set gpio mode register */
3759                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3760                                 (uint32_t)(signalyzer_h_side << 8));
3761                 if (status != FT_OK) {
3762                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3763                                 ftd2xx_status_string(status));
3764                         return ERROR_JTAG_DEVICE_ERROR;
3765                 }
3766
3767                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000);
3768                 if (status != FT_OK) {
3769                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3770                                 ftd2xx_status_string(status));
3771                         return ERROR_JTAG_DEVICE_ERROR;
3772                 }
3773
3774                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_MODE);
3775                 if (status != FT_OK) {
3776                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3777                                 ftd2xx_status_string(status));
3778                         return ERROR_JTAG_DEVICE_ERROR;
3779                 }
3780
3781                 /* set gpio register */
3782                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3783                                 (uint32_t)(signalyzer_h_side << 8));
3784                 if (status != FT_OK) {
3785                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3786                                 ftd2xx_status_string(status));
3787                         return ERROR_JTAG_DEVICE_ERROR;
3788                 }
3789
3790                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x4040);
3791                 if (status != FT_OK) {
3792                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3793                                 ftd2xx_status_string(status));
3794                         return ERROR_JTAG_DEVICE_ERROR;
3795                 }
3796
3797                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3798                                 SIGNALYZER_COMMAND_GPIO_STATE);
3799                 if (status != FT_OK) {
3800                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3801                                 ftd2xx_status_string(status));
3802                         return ERROR_JTAG_DEVICE_ERROR;
3803                 }
3804 #endif
3805         }
3806         /* ADAPTOR: EM_ARM_JTAG, EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
3807         else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
3808                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
3809                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
3810                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)) {
3811                 if (signalyzer_h_adapter_type
3812                     == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG)
3813                         LOG_INFO("Signalyzer: EM-ARM-JTAG (ARM JTAG) "
3814                                 "detected. (HW: %2x).", (read_buf[1] >> 8));
3815                 else if (signalyzer_h_adapter_type
3816                          == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P)
3817                         LOG_INFO("Signalyzer: EM-ARM-JTAG_P "
3818                                 "(ARM JTAG with PSU) detected. (HW: %2x).",
3819                                 (read_buf[1] >> 8));
3820                 else if (signalyzer_h_adapter_type
3821                          == SIGNALYZER_MODULE_TYPE_EM_JTAG)
3822                         LOG_INFO("Signalyzer: EM-JTAG (Generic JTAG) "
3823                                 "detected. (HW: %2x).", (read_buf[1] >> 8));
3824                 else if (signalyzer_h_adapter_type
3825                          == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)
3826                         LOG_INFO("Signalyzer: EM-JTAG-P "
3827                                 "(Generic JTAG with PSU) detected. (HW: %2x).",
3828                                 (read_buf[1] >> 8));
3829
3830                 nTRST          = 0x02;
3831                 nTRSTnOE       = 0x04;
3832                 nSRST          = 0x08;
3833                 nSRSTnOE       = 0x10;
3834
3835                 low_output     = 0x08;
3836                 low_direction  = 0x1b;
3837
3838                 high_output    = 0x0;
3839                 high_direction = 0x1f;
3840
3841                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3842                         high_output |= nTRSTnOE;
3843                         high_output &= ~nTRST;
3844                 } else {
3845                         high_output &= ~nTRSTnOE;
3846                         high_output |= nTRST;
3847                 }
3848
3849                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3850                         high_output &= ~nSRSTnOE;
3851                         high_output |= nSRST;
3852                 } else {
3853                         high_output |= nSRSTnOE;
3854                         high_output &= ~nSRST;
3855                 }
3856
3857 #if BUILD_FT2232_FTD2XX == 1
3858                 /* enable power to the module */
3859                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3860                                 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3861                 if (status != FT_OK) {
3862                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3863                                 ftd2xx_status_string(status));
3864                         return ERROR_JTAG_DEVICE_ERROR;
3865                 }
3866
3867                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3868                                 SIGNALYZER_COMMAND_POWERCONTROL_SET);
3869                 if (status != FT_OK) {
3870                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3871                                 ftd2xx_status_string(status));
3872                         return ERROR_JTAG_DEVICE_ERROR;
3873                 }
3874
3875                 /* set gpio mode register (IO_16 and IO_17 set as analog
3876                  * inputs, other is gpio)
3877                  */
3878                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3879                                 (uint32_t)(signalyzer_h_side << 8));
3880                 if (status != FT_OK) {
3881                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3882                                 ftd2xx_status_string(status));
3883                         return ERROR_JTAG_DEVICE_ERROR;
3884                 }
3885
3886                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0060);
3887                 if (status != FT_OK) {
3888                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3889                                 ftd2xx_status_string(status));
3890                         return ERROR_JTAG_DEVICE_ERROR;
3891                 }
3892
3893                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_MODE);
3894                 if (status != FT_OK) {
3895                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3896                                 ftd2xx_status_string(status));
3897                         return ERROR_JTAG_DEVICE_ERROR;
3898                 }
3899
3900                 /* set gpio register (all inputs, for -P modules,
3901                  * PSU will be turned off)
3902                  */
3903                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3904                                 (uint32_t)(signalyzer_h_side << 8));
3905                 if (status != FT_OK) {
3906                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3907                                 ftd2xx_status_string(status));
3908                         return ERROR_JTAG_DEVICE_ERROR;
3909                 }
3910
3911                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000);
3912                 if (status != FT_OK) {
3913                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3914                                 ftd2xx_status_string(status));
3915                         return ERROR_JTAG_DEVICE_ERROR;
3916                 }
3917
3918                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_STATE);
3919                 if (status != FT_OK) {
3920                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3921                                 ftd2xx_status_string(status));
3922                         return ERROR_JTAG_DEVICE_ERROR;
3923                 }
3924 #endif
3925         } else if (signalyzer_h_adapter_type == 0x0000) {
3926                 LOG_INFO("Signalyzer: No external modules were detected.");
3927
3928                 nTRST    = 0x10;
3929                 nTRSTnOE = 0x10;
3930                 nSRST    = 0x20;
3931                 nSRSTnOE = 0x20;
3932
3933                 low_output     = 0x08;
3934                 low_direction  = 0x1b;
3935
3936                 high_output    = 0x0;
3937                 high_direction = 0x0;
3938
3939                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3940                         low_direction &= ~nTRSTnOE;     /* nTRST input */
3941                         low_output    &= ~nTRST;        /* nTRST = 0 */
3942                 } else {
3943                         low_direction |= nTRSTnOE;      /* nTRST output */
3944                         low_output    |= nTRST;         /* nTRST = 1 */
3945                 }
3946
3947                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3948                         low_direction |= nSRSTnOE;      /* nSRST output */
3949                         low_output    |= nSRST;         /* nSRST = 1 */
3950                 } else {
3951                         low_direction &= ~nSRSTnOE;     /* nSRST input */
3952                         low_output    &= ~nSRST;        /* nSRST = 0 */
3953                 }
3954         } else {
3955                 LOG_ERROR("Unknown module type is detected: %.4x",
3956                         signalyzer_h_adapter_type);
3957                 return ERROR_JTAG_DEVICE_ERROR;
3958         }
3959
3960         /* initialize low byte of controller for jtag operation */
3961         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3962                 LOG_ERROR("couldn't initialize Signalyzer-H layout");
3963                 return ERROR_JTAG_INIT_FAILED;
3964         }
3965
3966 #if BUILD_FT2232_FTD2XX == 1
3967         if (ftdi_device == FT_DEVICE_2232H) {
3968                 /* initialize high byte of controller for jtag operation */
3969                 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3970                         LOG_ERROR("couldn't initialize Signalyzer-H layout");
3971                         return ERROR_JTAG_INIT_FAILED;
3972                 }
3973         }
3974 #elif BUILD_FT2232_LIBFTDI == 1
3975         if (ftdi_device == TYPE_2232H) {
3976                 /* initialize high byte of controller for jtag operation */
3977                 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3978                         LOG_ERROR("couldn't initialize Signalyzer-H layout");
3979                         return ERROR_JTAG_INIT_FAILED;
3980                 }
3981         }
3982 #endif
3983         return ERROR_OK;
3984 }
3985
3986 static void signalyzer_h_reset(int trst, int srst)
3987 {
3988         enum reset_types jtag_reset_config = jtag_get_reset_config();
3989
3990         /* ADAPTOR: EM_LT16_A */
3991         if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3992                 if (trst == 1) {
3993                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3994                                 /* switch to output pin (output is low) */
3995                                 low_direction |= nTRSTnOE;
3996                         else
3997                                 /* switch output low */
3998                                 low_output &= ~nTRST;
3999                 } else if (trst == 0) {
4000                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4001                                 /* switch to input pin (high-Z + internal
4002                                  * and external pullup) */
4003                                 low_direction &= ~nTRSTnOE;
4004                         else
4005                                 /* switch output high */
4006                                 low_output |= nTRST;
4007                 }
4008
4009                 if (srst == 1) {
4010                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4011                                 /* switch output low */
4012                                 low_output &= ~nSRST;
4013                         else
4014                                 /* switch to output pin (output is low) */
4015                                 low_direction |= nSRSTnOE;
4016                 } else if (srst == 0) {
4017                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4018                                 /* switch output high */
4019                                 low_output |= nSRST;
4020                         else
4021                                 /* switch to input pin (high-Z) */
4022                                 low_direction &= ~nSRSTnOE;
4023                 }
4024
4025                 /* command "set data bits low byte" */
4026                 buffer_write(0x80);
4027                 buffer_write(low_output);
4028                 buffer_write(low_direction);
4029                 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
4030                         "low_direction: 0x%2.2x",
4031                         trst, srst, low_output, low_direction);
4032         }
4033         /* ADAPTOR: EM_ARM_JTAG,  EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
4034         else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
4035                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
4036                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
4037                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)) {
4038                 if (trst == 1) {
4039                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4040                                 high_output &= ~nTRSTnOE;
4041                         else
4042                                 high_output &= ~nTRST;
4043                 } else if (trst == 0) {
4044                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4045                                 high_output |= nTRSTnOE;
4046                         else
4047                                 high_output |= nTRST;
4048                 }
4049
4050                 if (srst == 1) {
4051                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4052                                 high_output &= ~nSRST;
4053                         else
4054                                 high_output &= ~nSRSTnOE;
4055                 } else if (srst == 0) {
4056                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4057                                 high_output |= nSRST;
4058                         else
4059                                 high_output |= nSRSTnOE;
4060                 }
4061
4062                 /* command "set data bits high byte" */
4063                 buffer_write(0x82);
4064                 buffer_write(high_output);
4065                 buffer_write(high_direction);
4066                 LOG_INFO("trst: %i, srst: %i, high_output: 0x%2.2x, "
4067                         "high_direction: 0x%2.2x",
4068                         trst, srst, high_output, high_direction);
4069         } else if (signalyzer_h_adapter_type == 0x0000) {
4070                 if (trst == 1) {
4071                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4072                                 /* switch to output pin (output is low) */
4073                                 low_direction |= nTRSTnOE;
4074                         else
4075                                 /* switch output low */
4076                                 low_output &= ~nTRST;
4077                 } else if (trst == 0) {
4078                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4079                                 /* switch to input pin (high-Z + internal
4080                                  * and external pullup) */
4081                                 low_direction &= ~nTRSTnOE;
4082                         else
4083                                 /* switch output high */
4084                                 low_output |= nTRST;
4085                 }
4086
4087                 if (srst == 1) {
4088                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4089                                 /* switch output low */
4090                                 low_output &= ~nSRST;
4091                         else
4092                                 /* switch to output pin (output is low) */
4093                                 low_direction |= nSRSTnOE;
4094                 } else if (srst == 0) {
4095                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4096                                 /* switch output high */
4097                                 low_output |= nSRST;
4098                         else
4099                                 /* switch to input pin (high-Z) */
4100                                 low_direction &= ~nSRSTnOE;
4101                 }
4102
4103                 /* command "set data bits low byte" */
4104                 buffer_write(0x80);
4105                 buffer_write(low_output);
4106                 buffer_write(low_direction);
4107                 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
4108                         "low_direction: 0x%2.2x",
4109                         trst, srst, low_output, low_direction);
4110         }
4111 }
4112
4113 static void signalyzer_h_blink(void)
4114 {
4115         signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_RED, 100, 0, 1);
4116 }
4117
4118 /********************************************************************
4119  * Support for KT-LINK
4120  * JTAG adapter from KRISTECH
4121  * http://www.kristech.eu
4122  *******************************************************************/
4123 static int ktlink_init(void)
4124 {
4125         uint8_t swd_en = 0x20;  /* 0x20 SWD disable, 0x00 SWD enable (ADBUS5) */
4126
4127         low_output    = 0x08 | swd_en;  /* value; TMS=1,TCK=0,TDI=0,SWD=swd_en */
4128         low_direction = 0x3B;           /* out=1; TCK/TDI/TMS=out,TDO=in,SWD=out,RTCK=in,SRSTIN=in */
4129
4130         /* initialize low byte for jtag */
4131         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
4132                 LOG_ERROR("couldn't initialize FT2232 with 'ktlink' layout");
4133                 return ERROR_JTAG_INIT_FAILED;
4134         }
4135
4136         nTRST    = 0x01;
4137         nSRST    = 0x02;
4138         nTRSTnOE = 0x04;
4139         nSRSTnOE = 0x08;
4140
4141         high_output    = 0x80;  /* turn LED on */
4142         high_direction = 0xFF;  /* all outputs */
4143
4144         enum reset_types jtag_reset_config = jtag_get_reset_config();
4145
4146         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
4147                 high_output |= nTRSTnOE;
4148                 high_output &= ~nTRST;
4149         } else {
4150                 high_output &= ~nTRSTnOE;
4151                 high_output |= nTRST;
4152         }
4153
4154         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
4155                 high_output &= ~nSRSTnOE;
4156                 high_output |= nSRST;
4157         } else {
4158                 high_output |= nSRSTnOE;
4159                 high_output &= ~nSRST;
4160         }
4161
4162         /* initialize high byte for jtag */
4163         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
4164                 LOG_ERROR("couldn't initialize FT2232 with 'ktlink' layout");
4165                 return ERROR_JTAG_INIT_FAILED;
4166         }
4167
4168         return ERROR_OK;
4169 }
4170
4171 static void ktlink_reset(int trst, int srst)
4172 {
4173         enum reset_types jtag_reset_config = jtag_get_reset_config();
4174
4175         if (trst == 1) {
4176                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4177                         high_output &= ~nTRSTnOE;
4178                 else
4179                         high_output &= ~nTRST;
4180         } else if (trst == 0) {
4181                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4182                         high_output |= nTRSTnOE;
4183                 else
4184                         high_output |= nTRST;
4185         }
4186
4187         if (srst == 1) {
4188                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4189                         high_output &= ~nSRST;
4190                 else
4191                         high_output &= ~nSRSTnOE;
4192         } else if (srst == 0) {
4193                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4194                         high_output |= nSRST;
4195                 else
4196                         high_output |= nSRSTnOE;
4197         }
4198
4199         buffer_write(0x82);     /* command "set data bits high byte" */
4200         buffer_write(high_output);
4201         buffer_write(high_direction);
4202         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
4203                 trst,
4204                 srst,
4205                 high_output,
4206                 high_direction);
4207 }
4208
4209 static void ktlink_blink(void)
4210 {
4211         /* LED connected to ACBUS7 */
4212         high_output ^= 0x80;
4213
4214         buffer_write(0x82);     /* command "set data bits high byte" */
4215         buffer_write(high_output);
4216         buffer_write(high_direction);
4217 }
4218
4219 /********************************************************************
4220  * Support for Digilent HS-1
4221  * JTAG adapter from Digilent
4222  * http://www.digilent.com
4223  * Author: Stephane Bonnet bonnetst@hds.utc.fr
4224  *******************************************************************/
4225
4226 static int digilent_hs1_init(void)
4227 {
4228         /* the adapter only supports the base JTAG signals, no nTRST
4229            nor nSRST */
4230         low_output      = 0x88;
4231         low_direction   = 0x8b;
4232
4233         /* initialize low byte for jtag */
4234         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
4235                 LOG_ERROR("couldn't initialize FT2232 with 'digilent_hs1' layout");
4236                 return ERROR_JTAG_INIT_FAILED;
4237         }
4238         return ERROR_OK;
4239 }
4240
4241 static void digilent_hs1_reset(int trst, int srst)
4242 {
4243         /* Dummy function, no reset signals supported. */
4244 }
4245
4246 static const struct command_registration ft2232_command_handlers[] = {
4247         {
4248                 .name = "ft2232_device_desc",
4249                 .handler = &ft2232_handle_device_desc_command,
4250                 .mode = COMMAND_CONFIG,
4251                 .help = "set the USB device description of the FTDI FT2232 device",
4252                 .usage = "description_string",
4253         },
4254         {
4255                 .name = "ft2232_serial",
4256                 .handler = &ft2232_handle_serial_command,
4257                 .mode = COMMAND_CONFIG,
4258                 .help = "set the serial number of the FTDI FT2232 device",
4259                 .usage = "serial_string",
4260         },
4261         {
4262                 .name = "ft2232_layout",
4263                 .handler = &ft2232_handle_layout_command,
4264                 .mode = COMMAND_CONFIG,
4265                 .help = "set the layout of the FT2232 GPIO signals used "
4266                         "to control output-enables and reset signals",
4267                 .usage = "layout_name",
4268         },
4269         {
4270                 .name = "ft2232_vid_pid",
4271                 .handler = &ft2232_handle_vid_pid_command,
4272                 .mode = COMMAND_CONFIG,
4273                 .help = "the vendor ID and product ID of the FTDI FT2232 device",
4274                 .usage = "(vid pid)* ",
4275         },
4276         {
4277                 .name = "ft2232_latency",
4278                 .handler = &ft2232_handle_latency_command,
4279                 .mode = COMMAND_CONFIG,
4280                 .help = "set the FT2232 latency timer to a new value",
4281                 .usage = "value",
4282         },
4283         {
4284                 .name = "ft2232_channel",
4285                 .handler = &ft2232_handle_channel_command,
4286                 .mode = COMMAND_CONFIG,
4287                 .help = "set the FT2232 channel to a new value",
4288                 .usage = "value",
4289         },
4290         COMMAND_REGISTRATION_DONE
4291 };
4292
4293 struct jtag_interface ft2232_interface = {
4294         .name = "ft2232",
4295         .supported = DEBUG_CAP_TMS_SEQ,
4296         .commands = ft2232_command_handlers,
4297         .transports = jtag_only,
4298
4299         .init = ft2232_init,
4300         .quit = ft2232_quit,
4301         .speed = ft2232_speed,
4302         .speed_div = ft2232_speed_div,
4303         .khz = ft2232_khz,
4304         .execute_queue = ft2232_execute_queue,
4305 };