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 (cmd->ir_scan) {
1112                 LOG_ERROR("BUG: large IR scans are not supported");
1113                 exit(-1);
1114         }
1115
1116         if (tap_get_state() != TAP_DRSHIFT)
1117                 move_to_state(TAP_DRSHIFT);
1118
1119         retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1120         if (retval != ERROR_OK) {
1121                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1122                 exit(-1);
1123         }
1124         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1125                 ft2232_buffer_size, (int)bytes_written);
1126         ft2232_buffer_size = 0;
1127
1128         /* add command for complete bytes */
1129         while (num_bytes > 1) {
1130                 int thisrun_bytes;
1131
1132                 if (type == SCAN_IO) {
1133                         /* Clock Data Bytes In and Out LSB First */
1134                         buffer_write(0x39);
1135                         /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1136                 } else if (type == SCAN_OUT) {
1137                         /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1138                         buffer_write(0x19);
1139                         /* LOG_DEBUG("added TDI bytes (o)"); */
1140                 } else if (type == SCAN_IN) {
1141                         /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1142                         buffer_write(0x28);
1143                         /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1144                 }
1145
1146                 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1147                 thisrun_read  = thisrun_bytes;
1148                 num_bytes    -= thisrun_bytes;
1149                 buffer_write((uint8_t) (thisrun_bytes - 1));
1150                 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1151
1152                 if (type != SCAN_IN) {
1153                         /* add complete bytes */
1154                         while (thisrun_bytes-- > 0) {
1155                                 buffer_write(buffer[cur_byte]);
1156                                 cur_byte++;
1157                                 bits_left -= 8;
1158                         }
1159                 } else /* (type == SCAN_IN) */
1160                         bits_left -= 8 * (thisrun_bytes);
1161
1162                 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1163                 if (retval != ERROR_OK) {
1164                         LOG_ERROR("couldn't write MPSSE commands to FT2232");
1165                         exit(-1);
1166                 }
1167                 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1168                         ft2232_buffer_size,
1169                         (int)bytes_written);
1170                 ft2232_buffer_size = 0;
1171
1172                 if (type != SCAN_OUT) {
1173                         retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1174                         if (retval != ERROR_OK) {
1175                                 LOG_ERROR("couldn't read from FT2232");
1176                                 exit(-1);
1177                         }
1178                         LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1179                                 thisrun_read,
1180                                 (int)bytes_read);
1181                         receive_pointer += bytes_read;
1182                 }
1183         }
1184
1185         thisrun_read = 0;
1186
1187         /* the most signifcant bit is scanned during TAP movement */
1188         if (type != SCAN_IN)
1189                 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1190         else
1191                 last_bit = 0;
1192
1193         /* process remaining bits but the last one */
1194         if (bits_left > 1) {
1195                 if (type == SCAN_IO) {
1196                         /* Clock Data Bits In and Out LSB First */
1197                         buffer_write(0x3b);
1198                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1199                 } else if (type == SCAN_OUT) {
1200                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1201                         buffer_write(0x1b);
1202                         /* LOG_DEBUG("added TDI bits (o)"); */
1203                 } else if (type == SCAN_IN) {
1204                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1205                         buffer_write(0x2a);
1206                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1207                 }
1208                 buffer_write(bits_left - 2);
1209                 if (type != SCAN_IN)
1210                         buffer_write(buffer[cur_byte]);
1211
1212                 if (type != SCAN_OUT)
1213                         thisrun_read += 2;
1214         }
1215
1216         if (tap_get_end_state() == TAP_DRSHIFT) {
1217                 if (type == SCAN_IO) {
1218                         /* Clock Data Bits In and Out LSB First */
1219                         buffer_write(0x3b);
1220                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1221                 } else if (type == SCAN_OUT) {
1222                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1223                         buffer_write(0x1b);
1224                         /* LOG_DEBUG("added TDI bits (o)"); */
1225                 } else if (type == SCAN_IN) {
1226                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1227                         buffer_write(0x2a);
1228                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1229                 }
1230                 buffer_write(0x0);
1231                 buffer_write(last_bit);
1232         } else {
1233                 int tms_bits  = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1234                 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1235                 uint8_t mpsse_cmd;
1236
1237                 /* move from Shift-IR/DR to end state */
1238                 if (type != SCAN_OUT) {
1239                         /* Clock Data to TMS/CS Pin with Read */
1240                         mpsse_cmd = 0x6b;
1241                         /* LOG_DEBUG("added TMS scan (read)"); */
1242                 } else {
1243                         /* Clock Data to TMS/CS Pin (no Read) */
1244                         mpsse_cmd = 0x4b;
1245                         /* LOG_DEBUG("added TMS scan (no read)"); */
1246                 }
1247
1248                 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1249                 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1250         }
1251
1252         if (type != SCAN_OUT)
1253                 thisrun_read += 1;
1254
1255         retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1256         if (retval != ERROR_OK) {
1257                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1258                 exit(-1);
1259         }
1260         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1261                 ft2232_buffer_size,
1262                 (int)bytes_written);
1263         ft2232_buffer_size = 0;
1264
1265         if (type != SCAN_OUT) {
1266                 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1267                 if (retval != ERROR_OK) {
1268                         LOG_ERROR("couldn't read from FT2232");
1269                         exit(-1);
1270                 }
1271                 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1272                         thisrun_read,
1273                         (int)bytes_read);
1274         }
1275
1276         return ERROR_OK;
1277 }
1278
1279 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1280 {
1281         int predicted_size = 3;
1282         int num_bytes = (scan_size - 1) / 8;
1283
1284         if (tap_get_state() != TAP_DRSHIFT)
1285                 predicted_size += get_tms_buffer_requirements(
1286                                 tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1287
1288         if (type == SCAN_IN) {  /* only from device to host */
1289                 /* complete bytes */
1290                 predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
1291
1292                 /* remaining bits - 1 (up to 7) */
1293                 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1294         } else {/* host to device, or bidirectional
1295                  * complete bytes */
1296                 predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
1297
1298                 /* remaining bits -1 (up to 7) */
1299                 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1300         }
1301
1302         return predicted_size;
1303 }
1304
1305 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1306 {
1307         int predicted_size = 0;
1308
1309         if (type != SCAN_OUT) {
1310                 /* complete bytes */
1311                 predicted_size +=
1312                         (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
1313
1314                 /* remaining bits - 1 */
1315                 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1316
1317                 /* last bit (from TMS scan) */
1318                 predicted_size += 1;
1319         }
1320
1321         /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1322
1323         return predicted_size;
1324 }
1325
1326 /* semi-generic FT2232/FT4232 reset code */
1327 static void ftx23_reset(int trst, int srst)
1328 {
1329         enum reset_types jtag_reset_config = jtag_get_reset_config();
1330         if (trst == 1) {
1331                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1332                         low_direction |= nTRSTnOE;      /* switch to output pin (output is low) */
1333                 else
1334                         low_output &= ~nTRST;           /* switch output low */
1335         } else if (trst == 0) {
1336                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1337                         low_direction &= ~nTRSTnOE;     /* switch to input pin (high-Z + internal
1338                                                          *and external pullup) */
1339                 else
1340                         low_output |= nTRST;            /* switch output high */
1341         }
1342
1343         if (srst == 1) {
1344                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1345                         low_output &= ~nSRST;           /* switch output low */
1346                 else
1347                         low_direction |= nSRSTnOE;      /* switch to output pin (output is low) */
1348         } else if (srst == 0) {
1349                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1350                         low_output |= nSRST;            /* switch output high */
1351                 else
1352                         low_direction &= ~nSRSTnOE;     /* switch to input pin (high-Z) */
1353         }
1354
1355         /* command "set data bits low byte" */
1356         buffer_write(0x80);
1357         buffer_write(low_output);
1358         buffer_write(low_direction);
1359 }
1360
1361 static void jtagkey_reset(int trst, int srst)
1362 {
1363         enum reset_types jtag_reset_config = jtag_get_reset_config();
1364         if (trst == 1) {
1365                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1366                         high_output &= ~nTRSTnOE;
1367                 else
1368                         high_output &= ~nTRST;
1369         } else if (trst == 0) {
1370                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1371                         high_output |= nTRSTnOE;
1372                 else
1373                         high_output |= nTRST;
1374         }
1375
1376         if (srst == 1) {
1377                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1378                         high_output &= ~nSRST;
1379                 else
1380                         high_output &= ~nSRSTnOE;
1381         } else if (srst == 0) {
1382                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1383                         high_output |= nSRST;
1384                 else
1385                         high_output |= nSRSTnOE;
1386         }
1387
1388         /* command "set data bits high byte" */
1389         buffer_write(0x82);
1390         buffer_write(high_output);
1391         buffer_write(high_direction);
1392         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1393                 trst,
1394                 srst,
1395                 high_output,
1396                 high_direction);
1397 }
1398
1399 static void olimex_jtag_reset(int trst, int srst)
1400 {
1401         enum reset_types jtag_reset_config = jtag_get_reset_config();
1402         if (trst == 1) {
1403                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1404                         high_output &= ~nTRSTnOE;
1405                 else
1406                         high_output &= ~nTRST;
1407         } else if (trst == 0) {
1408                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1409                         high_output |= nTRSTnOE;
1410                 else
1411                         high_output |= nTRST;
1412         }
1413
1414         if (srst == 1)
1415                 high_output |= nSRST;
1416         else if (srst == 0)
1417                 high_output &= ~nSRST;
1418
1419         /* command "set data bits high byte" */
1420         buffer_write(0x82);
1421         buffer_write(high_output);
1422         buffer_write(high_direction);
1423         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1424                 trst,
1425                 srst,
1426                 high_output,
1427                 high_direction);
1428 }
1429
1430 static void axm0432_jtag_reset(int trst, int srst)
1431 {
1432         if (trst == 1) {
1433                 tap_set_state(TAP_RESET);
1434                 high_output &= ~nTRST;
1435         } else if (trst == 0)
1436                 high_output |= nTRST;
1437
1438         if (srst == 1)
1439                 high_output &= ~nSRST;
1440         else if (srst == 0)
1441                 high_output |= nSRST;
1442
1443         /* command "set data bits low byte" */
1444         buffer_write(0x82);
1445         buffer_write(high_output);
1446         buffer_write(high_direction);
1447         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1448                 trst,
1449                 srst,
1450                 high_output,
1451                 high_direction);
1452 }
1453
1454 static void flyswatter_reset(int trst, int srst)
1455 {
1456         if (trst == 1)
1457                 low_output &= ~nTRST;
1458         else if (trst == 0)
1459                 low_output |= nTRST;
1460
1461         if (srst == 1)
1462                 low_output |= nSRST;
1463         else if (srst == 0)
1464                 low_output &= ~nSRST;
1465
1466         /* command "set data bits low byte" */
1467         buffer_write(0x80);
1468         buffer_write(low_output);
1469         buffer_write(low_direction);
1470         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1471                 trst,
1472                 srst,
1473                 low_output,
1474                 low_direction);
1475 }
1476
1477 static void flyswatter1_reset(int trst, int srst)
1478 {
1479         flyswatter_reset(trst, srst);
1480 }
1481
1482 static void flyswatter2_reset(int trst, int srst)
1483 {
1484         flyswatter_reset(trst, !srst);
1485 }
1486
1487 static void minimodule_reset(int trst, int srst)
1488 {
1489         if (srst == 1)
1490                 low_output &= ~nSRST;
1491         else if (srst == 0)
1492                 low_output |= nSRST;
1493
1494         /* command "set data bits low byte" */
1495         buffer_write(0x80);
1496         buffer_write(low_output);
1497         buffer_write(low_direction);
1498         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1499                 trst,
1500                 srst,
1501                 low_output,
1502                 low_direction);
1503 }
1504
1505 static void turtle_reset(int trst, int srst)
1506 {
1507         trst = trst;
1508
1509         if (srst == 1)
1510                 low_output |= nSRST;
1511         else if (srst == 0)
1512                 low_output &= ~nSRST;
1513
1514         /* command "set data bits low byte" */
1515         buffer_write(0x80);
1516         buffer_write(low_output);
1517         buffer_write(low_direction);
1518         LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1519                 srst,
1520                 low_output,
1521                 low_direction);
1522 }
1523
1524 static void comstick_reset(int trst, int srst)
1525 {
1526         if (trst == 1)
1527                 high_output &= ~nTRST;
1528         else if (trst == 0)
1529                 high_output |= nTRST;
1530
1531         if (srst == 1)
1532                 high_output &= ~nSRST;
1533         else if (srst == 0)
1534                 high_output |= nSRST;
1535
1536         /* command "set data bits high byte" */
1537         buffer_write(0x82);
1538         buffer_write(high_output);
1539         buffer_write(high_direction);
1540         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1541                 trst,
1542                 srst,
1543                 high_output,
1544                 high_direction);
1545 }
1546
1547 static void stm32stick_reset(int trst, int srst)
1548 {
1549         if (trst == 1)
1550                 high_output &= ~nTRST;
1551         else if (trst == 0)
1552                 high_output |= nTRST;
1553
1554         if (srst == 1)
1555                 low_output &= ~nSRST;
1556         else if (srst == 0)
1557                 low_output |= nSRST;
1558
1559         /* command "set data bits low byte" */
1560         buffer_write(0x80);
1561         buffer_write(low_output);
1562         buffer_write(low_direction);
1563
1564         /* command "set data bits high byte" */
1565         buffer_write(0x82);
1566         buffer_write(high_output);
1567         buffer_write(high_direction);
1568         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1569                 trst,
1570                 srst,
1571                 high_output,
1572                 high_direction);
1573 }
1574
1575 static void sheevaplug_reset(int trst, int srst)
1576 {
1577         if (trst == 1)
1578                 high_output &= ~nTRST;
1579         else if (trst == 0)
1580                 high_output |= nTRST;
1581
1582         if (srst == 1)
1583                 high_output &= ~nSRSTnOE;
1584         else if (srst == 0)
1585                 high_output |= nSRSTnOE;
1586
1587         /* command "set data bits high byte" */
1588         buffer_write(0x82);
1589         buffer_write(high_output);
1590         buffer_write(high_direction);
1591         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1592                 trst,
1593                 srst,
1594                 high_output,
1595                 high_direction);
1596 }
1597
1598 static void redbee_reset(int trst, int srst)
1599 {
1600         if (trst == 1) {
1601                 tap_set_state(TAP_RESET);
1602                 high_output &= ~nTRST;
1603         } else if (trst == 0)
1604                 high_output |= nTRST;
1605
1606         if (srst == 1)
1607                 high_output &= ~nSRST;
1608         else if (srst == 0)
1609                 high_output |= nSRST;
1610
1611         /* command "set data bits low byte" */
1612         buffer_write(0x82);
1613         buffer_write(high_output);
1614         buffer_write(high_direction);
1615         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1616                 "high_direction: 0x%2.2x", trst, srst, high_output,
1617                 high_direction);
1618 }
1619
1620 static void xds100v2_reset(int trst, int srst)
1621 {
1622         if (trst == 1) {
1623                 tap_set_state(TAP_RESET);
1624                 high_output &= ~nTRST;
1625         } else if (trst == 0)
1626                 high_output |= nTRST;
1627
1628         if (srst == 1)
1629                 high_output |= nSRST;
1630         else if (srst == 0)
1631                 high_output &= ~nSRST;
1632
1633         /* command "set data bits low byte" */
1634         buffer_write(0x82);
1635         buffer_write(high_output);
1636         buffer_write(high_direction);
1637         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1638                 "high_direction: 0x%2.2x", trst, srst, high_output,
1639                 high_direction);
1640 }
1641
1642 static int ft2232_execute_runtest(struct jtag_command *cmd)
1643 {
1644         int retval;
1645         int i;
1646         int predicted_size = 0;
1647         retval = ERROR_OK;
1648
1649         DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1650                 cmd->cmd.runtest->num_cycles,
1651                 tap_state_name(cmd->cmd.runtest->end_state));
1652
1653         /* only send the maximum buffer size that FT2232C can handle */
1654         predicted_size = 0;
1655         if (tap_get_state() != TAP_IDLE)
1656                 predicted_size += 3;
1657         predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
1658         if (cmd->cmd.runtest->end_state != TAP_IDLE)
1659                 predicted_size += 3;
1660         if (tap_get_end_state() != TAP_IDLE)
1661                 predicted_size += 3;
1662         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1663                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1664                         retval = ERROR_JTAG_QUEUE_FAILED;
1665                 require_send = 0;
1666                 first_unsent = cmd;
1667         }
1668         if (tap_get_state() != TAP_IDLE) {
1669                 move_to_state(TAP_IDLE);
1670                 require_send = 1;
1671         }
1672         i = cmd->cmd.runtest->num_cycles;
1673         while (i > 0) {
1674                 /* there are no state transitions in this code, so omit state tracking */
1675
1676                 /* command "Clock Data to TMS/CS Pin (no Read)" */
1677                 buffer_write(0x4b);
1678
1679                 /* scan 7 bits */
1680                 buffer_write((i > 7) ? 6 : (i - 1));
1681
1682                 /* TMS data bits */
1683                 buffer_write(0x0);
1684
1685                 i -= (i > 7) ? 7 : i;
1686                 /* LOG_DEBUG("added TMS scan (no read)"); */
1687         }
1688
1689         ft2232_end_state(cmd->cmd.runtest->end_state);
1690
1691         if (tap_get_state() != tap_get_end_state())
1692                 move_to_state(tap_get_end_state());
1693
1694         require_send = 1;
1695         DEBUG_JTAG_IO("runtest: %i, end in %s",
1696                 cmd->cmd.runtest->num_cycles,
1697                 tap_state_name(tap_get_end_state()));
1698         return retval;
1699 }
1700
1701 static int ft2232_execute_statemove(struct jtag_command *cmd)
1702 {
1703         int predicted_size = 0;
1704         int retval = ERROR_OK;
1705
1706         DEBUG_JTAG_IO("statemove end in %s",
1707                 tap_state_name(cmd->cmd.statemove->end_state));
1708
1709         /* only send the maximum buffer size that FT2232C can handle */
1710         predicted_size = 3;
1711         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1712                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1713                         retval = ERROR_JTAG_QUEUE_FAILED;
1714                 require_send = 0;
1715                 first_unsent = cmd;
1716         }
1717         ft2232_end_state(cmd->cmd.statemove->end_state);
1718
1719         /* For TAP_RESET, ignore the current recorded state.  It's often
1720          * wrong at server startup, and this transation is critical whenever
1721          * it's requested.
1722          */
1723         if (tap_get_end_state() == TAP_RESET) {
1724                 clock_tms(0x4b,  0xff, 5, 0);
1725                 require_send = 1;
1726
1727                 /* shortest-path move to desired end state */
1728         } else if (tap_get_state() != tap_get_end_state()) {
1729                 move_to_state(tap_get_end_state());
1730                 require_send = 1;
1731         }
1732
1733         return retval;
1734 }
1735
1736 /**
1737  * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
1738  * (or SWD) state machine.
1739  */
1740 static int ft2232_execute_tms(struct jtag_command *cmd)
1741 {
1742         int retval = ERROR_OK;
1743         unsigned num_bits = cmd->cmd.tms->num_bits;
1744         const uint8_t *bits = cmd->cmd.tms->bits;
1745         unsigned count;
1746
1747         DEBUG_JTAG_IO("TMS: %d bits", num_bits);
1748
1749         /* only send the maximum buffer size that FT2232C can handle */
1750         count = 3 * DIV_ROUND_UP(num_bits, 4);
1751         if (ft2232_buffer_size + 3*count + 1 > FT2232_BUFFER_SIZE) {
1752                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1753                         retval = ERROR_JTAG_QUEUE_FAILED;
1754
1755                 require_send = 0;
1756                 first_unsent = cmd;
1757         }
1758
1759         /* Shift out in batches of at most 6 bits; there's a report of an
1760          * FT2232 bug in this area, where shifting exactly 7 bits can make
1761          * problems with TMS signaling for the last clock cycle:
1762          *
1763          *    http://developer.intra2net.com/mailarchive/html/
1764          *              libftdi/2009/msg00292.html
1765          *
1766          * Command 0x4b is: "Clock Data to TMS/CS Pin (no Read)"
1767          *
1768          * Note that pathmoves in JTAG are not often seven bits, so that
1769          * isn't a particularly likely situation outside of "special"
1770          * signaling such as switching between JTAG and SWD modes.
1771          */
1772         while (num_bits) {
1773                 if (num_bits <= 6) {
1774                         buffer_write(0x4b);
1775                         buffer_write(num_bits - 1);
1776                         buffer_write(*bits & 0x3f);
1777                         break;
1778                 }
1779
1780                 /* Yes, this is lazy ... we COULD shift out more data
1781                  * bits per operation, but doing it in nybbles is easy
1782                  */
1783                 buffer_write(0x4b);
1784                 buffer_write(3);
1785                 buffer_write(*bits & 0xf);
1786                 num_bits -= 4;
1787
1788                 count  = (num_bits > 4) ? 4 : num_bits;
1789
1790                 buffer_write(0x4b);
1791                 buffer_write(count - 1);
1792                 buffer_write((*bits >> 4) & 0xf);
1793                 num_bits -= count;
1794
1795                 bits++;
1796         }
1797
1798         require_send = 1;
1799         return retval;
1800 }
1801
1802 static int ft2232_execute_pathmove(struct jtag_command *cmd)
1803 {
1804         int predicted_size = 0;
1805         int retval = ERROR_OK;
1806
1807         tap_state_t *path = cmd->cmd.pathmove->path;
1808         int num_states    = cmd->cmd.pathmove->num_states;
1809
1810         DEBUG_JTAG_IO("pathmove: %i states, current: %s  end: %s", num_states,
1811                 tap_state_name(tap_get_state()),
1812                 tap_state_name(path[num_states-1]));
1813
1814         /* only send the maximum buffer size that FT2232C can handle */
1815         predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
1816         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1817                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1818                         retval = ERROR_JTAG_QUEUE_FAILED;
1819
1820                 require_send = 0;
1821                 first_unsent = cmd;
1822         }
1823
1824         ft2232_add_pathmove(path, num_states);
1825         require_send = 1;
1826
1827         return retval;
1828 }
1829
1830 static int ft2232_execute_scan(struct jtag_command *cmd)
1831 {
1832         uint8_t *buffer;
1833         int scan_size;                          /* size of IR or DR scan */
1834         int predicted_size = 0;
1835         int retval = ERROR_OK;
1836
1837         enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1838
1839         DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1840
1841         scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1842
1843         predicted_size = ft2232_predict_scan_out(scan_size, type);
1844         if ((predicted_size + 1) > FT2232_BUFFER_SIZE) {
1845                 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1846                 /* unsent commands before this */
1847                 if (first_unsent != cmd)
1848                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1849                                 retval = ERROR_JTAG_QUEUE_FAILED;
1850
1851                 /* current command */
1852                 ft2232_end_state(cmd->cmd.scan->end_state);
1853                 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1854                 require_send = 0;
1855                 first_unsent = cmd->next;
1856                 if (buffer)
1857                         free(buffer);
1858                 return retval;
1859         } else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1860                 LOG_DEBUG(
1861                         "ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1862                         first_unsent,
1863                         cmd);
1864                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1865                         retval = ERROR_JTAG_QUEUE_FAILED;
1866                 require_send = 0;
1867                 first_unsent = cmd;
1868         }
1869         ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1870         /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1871         ft2232_end_state(cmd->cmd.scan->end_state);
1872         ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1873         require_send = 1;
1874         if (buffer)
1875                 free(buffer);
1876         DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1877                 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1878                 tap_state_name(tap_get_end_state()));
1879         return retval;
1880
1881 }
1882
1883 static int ft2232_execute_reset(struct jtag_command *cmd)
1884 {
1885         int retval;
1886         int predicted_size = 0;
1887         retval = ERROR_OK;
1888
1889         DEBUG_JTAG_IO("reset trst: %i srst %i",
1890                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1891
1892         /* only send the maximum buffer size that FT2232C can handle */
1893         predicted_size = 3;
1894         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1895                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1896                         retval = ERROR_JTAG_QUEUE_FAILED;
1897                 require_send = 0;
1898                 first_unsent = cmd;
1899         }
1900
1901         if ((cmd->cmd.reset->trst == 1) ||
1902             (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1903                 tap_set_state(TAP_RESET);
1904
1905         layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1906         require_send = 1;
1907
1908         DEBUG_JTAG_IO("trst: %i, srst: %i",
1909                 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1910         return retval;
1911 }
1912
1913 static int ft2232_execute_sleep(struct jtag_command *cmd)
1914 {
1915         int retval;
1916         retval = ERROR_OK;
1917
1918         DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
1919
1920         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1921                 retval = ERROR_JTAG_QUEUE_FAILED;
1922         first_unsent = cmd->next;
1923         jtag_sleep(cmd->cmd.sleep->us);
1924         DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
1925                 cmd->cmd.sleep->us,
1926                 tap_state_name(tap_get_state()));
1927         return retval;
1928 }
1929
1930 static int ft2232_execute_stableclocks(struct jtag_command *cmd)
1931 {
1932         int retval;
1933         retval = ERROR_OK;
1934
1935         /* this is only allowed while in a stable state.  A check for a stable
1936          * state was done in jtag_add_clocks()
1937          */
1938         if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1939                 retval = ERROR_JTAG_QUEUE_FAILED;
1940         DEBUG_JTAG_IO("clocks %i while in %s",
1941                 cmd->cmd.stableclocks->num_cycles,
1942                 tap_state_name(tap_get_state()));
1943         return retval;
1944 }
1945
1946 static int ft2232_execute_command(struct jtag_command *cmd)
1947 {
1948         int retval;
1949
1950         switch (cmd->type) {
1951                 case JTAG_RESET:
1952                         retval = ft2232_execute_reset(cmd);
1953                         break;
1954                 case JTAG_RUNTEST:
1955                         retval = ft2232_execute_runtest(cmd);
1956                         break;
1957                 case JTAG_TLR_RESET:
1958                         retval = ft2232_execute_statemove(cmd);
1959                         break;
1960                 case JTAG_PATHMOVE:
1961                         retval = ft2232_execute_pathmove(cmd);
1962                         break;
1963                 case JTAG_SCAN:
1964                         retval = ft2232_execute_scan(cmd);
1965                         break;
1966                 case JTAG_SLEEP:
1967                         retval = ft2232_execute_sleep(cmd);
1968                         break;
1969                 case JTAG_STABLECLOCKS:
1970                         retval = ft2232_execute_stableclocks(cmd);
1971                         break;
1972                 case JTAG_TMS:
1973                         retval = ft2232_execute_tms(cmd);
1974                         break;
1975                 default:
1976                         LOG_ERROR("BUG: unknown JTAG command type encountered");
1977                         retval = ERROR_JTAG_QUEUE_FAILED;
1978                         break;
1979         }
1980         return retval;
1981 }
1982
1983 static int ft2232_execute_queue(void)
1984 {
1985         struct jtag_command *cmd = jtag_command_queue;  /* currently processed command */
1986         int retval;
1987
1988         first_unsent = cmd;             /* next command that has to be sent */
1989         require_send = 0;
1990
1991         /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1992          * that wasn't handled by a caller-provided error handler
1993          */
1994         retval = ERROR_OK;
1995
1996         ft2232_buffer_size = 0;
1997         ft2232_expect_read = 0;
1998
1999         /* blink, if the current layout has that feature */
2000         if (layout->blink)
2001                 layout->blink();
2002
2003         while (cmd) {
2004                 /* fill the write buffer with the desired command */
2005                 if (ft2232_execute_command(cmd) != ERROR_OK)
2006                         retval = ERROR_JTAG_QUEUE_FAILED;
2007                 /* Start reading input before FT2232 TX buffer fills up.
2008                  * Sometimes this happens because we don't know the
2009                  * length of the last command before we execute it. So
2010                  * we simple inform the user.
2011                  */
2012                 cmd = cmd->next;
2013
2014                 if (ft2232_expect_read >= FT2232_BUFFER_READ_QUEUE_SIZE) {
2015                         if (ft2232_expect_read > (FT2232_BUFFER_READ_QUEUE_SIZE+1))
2016                                 LOG_DEBUG("read buffer size looks too high %d/%d",
2017                                         ft2232_expect_read,
2018                                         (FT2232_BUFFER_READ_QUEUE_SIZE+1));
2019                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2020                                 retval = ERROR_JTAG_QUEUE_FAILED;
2021                         first_unsent = cmd;
2022                 }
2023         }
2024
2025         if (require_send > 0)
2026                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2027                         retval = ERROR_JTAG_QUEUE_FAILED;
2028
2029         return retval;
2030 }
2031
2032 #if BUILD_FT2232_FTD2XX == 1
2033 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int *try_more)
2034 {
2035         FT_STATUS status;
2036         DWORD deviceID;
2037         char SerialNumber[16];
2038         char Description[64];
2039         DWORD openex_flags  = 0;
2040         char *openex_string = NULL;
2041         uint8_t latency_timer;
2042
2043         if (layout == NULL) {
2044                 LOG_WARNING("No ft2232 layout specified'");
2045                 return ERROR_JTAG_INIT_FAILED;
2046         }
2047
2048         LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)",
2049                         layout->name, vid, pid);
2050
2051 #if IS_WIN32 == 0
2052         /* Add non-standard Vid/Pid to the linux driver */
2053         status = FT_SetVIDPID(vid, pid);
2054         if (status != FT_OK)
2055                 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
2056
2057 #endif
2058
2059         if (ft2232_device_desc && ft2232_serial) {
2060                 LOG_WARNING(
2061                         "can't open by device description and serial number, giving precedence to serial");
2062                 ft2232_device_desc = NULL;
2063         }
2064
2065         if (ft2232_device_desc) {
2066                 openex_string = ft2232_device_desc;
2067                 openex_flags  = FT_OPEN_BY_DESCRIPTION;
2068         } else if (ft2232_serial) {
2069                 openex_string = ft2232_serial;
2070                 openex_flags  = FT_OPEN_BY_SERIAL_NUMBER;
2071         } else {
2072                 LOG_ERROR("neither device description nor serial number specified");
2073                 LOG_ERROR(
2074                         "please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
2075
2076                 return ERROR_JTAG_INIT_FAILED;
2077         }
2078
2079         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2080         if (status != FT_OK) {
2081                 /* under Win32, the FTD2XX driver appends an "A" to the end
2082                  * of the description, if we tried by the desc, then
2083                  * try by the alternate "A" description. */
2084                 if (openex_string == ft2232_device_desc) {
2085                         /* Try the alternate method. */
2086                         openex_string = ft2232_device_desc_A;
2087                         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2088                         if (status == FT_OK) {
2089                                 /* yea, the "alternate" method worked! */
2090                         } else {
2091                                 /* drat, give the user a meaningfull message.
2092                                  * telling the use we tried *BOTH* methods. */
2093                                 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'",
2094                                         ft2232_device_desc,
2095                                         ft2232_device_desc_A);
2096                         }
2097                 }
2098         }
2099
2100         if (status != FT_OK) {
2101                 DWORD num_devices;
2102
2103                 if (more) {
2104                         LOG_WARNING("unable to open ftdi device (trying more): %s",
2105                                 ftd2xx_status_string(status));
2106                         *try_more = 1;
2107                         return ERROR_JTAG_INIT_FAILED;
2108                 }
2109                 LOG_ERROR("unable to open ftdi device: %s",
2110                         ftd2xx_status_string(status));
2111                 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
2112                 if (status == FT_OK) {
2113                         char **desc_array = malloc(sizeof(char *) * (num_devices + 1));
2114                         uint32_t i;
2115
2116                         for (i = 0; i < num_devices; i++)
2117                                 desc_array[i] = malloc(64);
2118
2119                         desc_array[num_devices] = NULL;
2120
2121                         status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
2122
2123                         if (status == FT_OK) {
2124                                 LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
2125                                 for (i = 0; i < num_devices; i++)
2126                                         LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
2127                         }
2128
2129                         for (i = 0; i < num_devices; i++)
2130                                 free(desc_array[i]);
2131
2132                         free(desc_array);
2133                 } else
2134                         LOG_ERROR("ListDevices: NONE");
2135                 return ERROR_JTAG_INIT_FAILED;
2136         }
2137
2138         status = FT_SetLatencyTimer(ftdih, ft2232_latency);
2139         if (status != FT_OK) {
2140                 LOG_ERROR("unable to set latency timer: %s",
2141                         ftd2xx_status_string(status));
2142                 return ERROR_JTAG_INIT_FAILED;
2143         }
2144
2145         status = FT_GetLatencyTimer(ftdih, &latency_timer);
2146         if (status != FT_OK) {
2147                 /* ftd2xx 1.04 (linux) has a bug when calling FT_GetLatencyTimer
2148                  * so ignore errors if using this driver version */
2149                 DWORD dw_version;
2150
2151                 status = FT_GetDriverVersion(ftdih, &dw_version);
2152                 LOG_ERROR("unable to get latency timer: %s",
2153                         ftd2xx_status_string(status));
2154
2155                 if ((status == FT_OK) && (dw_version == 0x10004)) {
2156                         LOG_ERROR("ftd2xx 1.04 detected - this has known issues " \
2157                                 "with FT_GetLatencyTimer, upgrade to a newer version");
2158                 } else
2159                         return ERROR_JTAG_INIT_FAILED;
2160         } else
2161                 LOG_DEBUG("current latency timer: %i", latency_timer);
2162
2163         status = FT_SetTimeouts(ftdih, 5000, 5000);
2164         if (status != FT_OK) {
2165                 LOG_ERROR("unable to set timeouts: %s",
2166                         ftd2xx_status_string(status));
2167                 return ERROR_JTAG_INIT_FAILED;
2168         }
2169
2170         status = FT_SetBitMode(ftdih, 0x0b, 2);
2171         if (status != FT_OK) {
2172                 LOG_ERROR("unable to enable bit i/o mode: %s",
2173                         ftd2xx_status_string(status));
2174                 return ERROR_JTAG_INIT_FAILED;
2175         }
2176
2177         status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID,
2178                         SerialNumber, Description, NULL);
2179         if (status != FT_OK) {
2180                 LOG_ERROR("unable to get FT_GetDeviceInfo: %s",
2181                         ftd2xx_status_string(status));
2182                 return ERROR_JTAG_INIT_FAILED;
2183         } else {
2184                 static const char *type_str[] = {
2185                         "BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H", "232H"
2186                 };
2187                 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2188                 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
2189                         ? ftdi_device : FT_DEVICE_UNKNOWN;
2190                 LOG_INFO("device: %" PRIu32 " \"%s\"", (uint32_t)ftdi_device, type_str[type_index]);
2191                 LOG_INFO("deviceID: %" PRIu32, (uint32_t)deviceID);
2192                 LOG_INFO("SerialNumber: %s", SerialNumber);
2193                 LOG_INFO("Description: %s", Description);
2194         }
2195
2196         return ERROR_OK;
2197 }
2198
2199 static int ft2232_purge_ftd2xx(void)
2200 {
2201         FT_STATUS status;
2202
2203         status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
2204         if (status != FT_OK) {
2205                 LOG_ERROR("error purging ftd2xx device: %s",
2206                         ftd2xx_status_string(status));
2207                 return ERROR_JTAG_INIT_FAILED;
2208         }
2209
2210         return ERROR_OK;
2211 }
2212
2213 #endif  /* BUILD_FT2232_FTD2XX == 1 */
2214
2215 #if BUILD_FT2232_LIBFTDI == 1
2216 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int *try_more, int channel)
2217 {
2218         uint8_t latency_timer;
2219
2220         if (layout == NULL) {
2221                 LOG_WARNING("No ft2232 layout specified'");
2222                 return ERROR_JTAG_INIT_FAILED;
2223         }
2224
2225         LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2226                 layout->name, vid, pid);
2227
2228         if (ftdi_init(&ftdic) < 0)
2229                 return ERROR_JTAG_INIT_FAILED;
2230
2231         /* default to INTERFACE_A */
2232         if (channel == INTERFACE_ANY)
2233                 channel = INTERFACE_A;
2234         if (ftdi_set_interface(&ftdic, channel) < 0) {
2235                 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2236                 return ERROR_JTAG_INIT_FAILED;
2237         }
2238
2239         /* context, vendor id, product id */
2240         if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc, ft2232_serial) < 0) {
2241                 if (more)
2242                         LOG_WARNING("unable to open ftdi device (trying more): %s",
2243                                 ftdic.error_str);
2244                 else
2245                         LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2246                 *try_more = 1;
2247                 return ERROR_JTAG_INIT_FAILED;
2248         }
2249
2250         /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2251         if (ftdi_usb_reset(&ftdic) < 0) {
2252                 LOG_ERROR("unable to reset ftdi device");
2253                 return ERROR_JTAG_INIT_FAILED;
2254         }
2255
2256         if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0) {
2257                 LOG_ERROR("unable to set latency timer");
2258                 return ERROR_JTAG_INIT_FAILED;
2259         }
2260
2261         if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
2262                 LOG_ERROR("unable to get latency timer");
2263                 return ERROR_JTAG_INIT_FAILED;
2264         } else
2265                 LOG_DEBUG("current latency timer: %i", latency_timer);
2266
2267         ftdi_set_bitmode(&ftdic, 0x0b, 2);      /* ctx, JTAG I/O mask */
2268
2269         ftdi_device = ftdic.type;
2270         static const char *type_str[] = {
2271                 "AM", "BM", "2232C", "R", "2232H", "4232H", "232H", "Unknown"
2272         };
2273         unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2274         unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2275                 ? ftdi_device : no_of_known_types;
2276         LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2277         return ERROR_OK;
2278 }
2279
2280 static int ft2232_purge_libftdi(void)
2281 {
2282         if (ftdi_usb_purge_buffers(&ftdic) < 0) {
2283                 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2284                 return ERROR_JTAG_INIT_FAILED;
2285         }
2286
2287         return ERROR_OK;
2288 }
2289
2290 #endif  /* BUILD_FT2232_LIBFTDI == 1 */
2291
2292 static int ft2232_set_data_bits_low_byte(uint8_t value, uint8_t direction)
2293 {
2294         uint8_t buf[3];
2295         uint32_t bytes_written;
2296
2297         buf[0] = 0x80;          /* command "set data bits low byte" */
2298         buf[1] = value;         /* value */
2299         buf[2] = direction;     /* direction */
2300
2301         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2302
2303         if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2304                 LOG_ERROR("couldn't initialize data bits low byte");
2305                 return ERROR_JTAG_INIT_FAILED;
2306         }
2307
2308         return ERROR_OK;
2309 }
2310
2311 static int ft2232_set_data_bits_high_byte(uint8_t value, uint8_t direction)
2312 {
2313         uint8_t buf[3];
2314         uint32_t bytes_written;
2315
2316         buf[0] = 0x82;          /* command "set data bits high byte" */
2317         buf[1] = value;         /* value */
2318         buf[2] = direction;     /* direction */
2319
2320         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2321
2322         if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2323                 LOG_ERROR("couldn't initialize data bits high byte");
2324                 return ERROR_JTAG_INIT_FAILED;
2325         }
2326
2327         return ERROR_OK;
2328 }
2329
2330 static int ft2232_init(void)
2331 {
2332         uint8_t buf[1];
2333         int retval;
2334         uint32_t bytes_written;
2335
2336         if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
2337                 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2338         else
2339                 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2340         if (layout == NULL) {
2341                 LOG_WARNING("No ft2232 layout specified'");
2342                 return ERROR_JTAG_INIT_FAILED;
2343         }
2344
2345         for (int i = 0; 1; i++) {
2346                 /*
2347                  * "more indicates that there are more IDs to try, so we should
2348                  * not print an error for an ID mismatch (but for anything
2349                  * else, we should).
2350                  *
2351                  * try_more indicates that the error code returned indicates an
2352                  * ID mismatch (and nothing else) and that we should proceeed
2353                  * with the next ID pair.
2354                  */
2355                 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2356                 int try_more = 0;
2357
2358 #if BUILD_FT2232_FTD2XX == 1
2359                 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2360                                 more, &try_more);
2361 #elif BUILD_FT2232_LIBFTDI == 1
2362                 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2363                                 more, &try_more, ft2232_channel);
2364 #endif
2365                 if (retval >= 0)
2366                         break;
2367                 if (!more || !try_more)
2368                         return retval;
2369         }
2370
2371         ft2232_buffer_size = 0;
2372         ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2373
2374         if (layout->init() != ERROR_OK)
2375                 return ERROR_JTAG_INIT_FAILED;
2376
2377         if (ft2232_device_is_highspeed()) {
2378 #ifndef BUILD_FT2232_HIGHSPEED
2379  #if BUILD_FT2232_FTD2XX == 1
2380                 LOG_WARNING(
2381                         "High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2382  #elif BUILD_FT2232_LIBFTDI == 1
2383                 LOG_WARNING(
2384                         "High Speed device found - You need a newer libftdi version (0.16 or later)");
2385  #endif
2386 #endif
2387                 /* make sure the legacy mode is disabled */
2388                 if (ftx232h_clk_divide_by_5(false) != ERROR_OK)
2389                         return ERROR_JTAG_INIT_FAILED;
2390         }
2391
2392         buf[0] = 0x85;  /* Disconnect TDI/DO to TDO/DI for Loopback */
2393         retval = ft2232_write(buf, 1, &bytes_written);
2394         if (retval != ERROR_OK) {
2395                 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2396                 return ERROR_JTAG_INIT_FAILED;
2397         }
2398
2399 #if BUILD_FT2232_FTD2XX == 1
2400         return ft2232_purge_ftd2xx();
2401 #elif BUILD_FT2232_LIBFTDI == 1
2402         return ft2232_purge_libftdi();
2403 #endif
2404
2405         return ERROR_OK;
2406 }
2407
2408 /** Updates defaults for DBUS signals:  the four JTAG signals
2409  * (TCK, TDI, TDO, TMS) and * the four GPIOL signals.
2410  */
2411 static inline void ftx232_dbus_init(void)
2412 {
2413         low_output    = 0x08;
2414         low_direction = 0x0b;
2415 }
2416
2417 /** Initializes DBUS signals:  the four JTAG signals (TCK, TDI, TDO, TMS),
2418  * the four GPIOL signals.  Initialization covers value and direction,
2419  * as customized for each layout.
2420  */
2421 static int ftx232_dbus_write(void)
2422 {
2423         enum reset_types jtag_reset_config = jtag_get_reset_config();
2424         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2425                 low_direction &= ~nTRSTnOE;     /* nTRST input */
2426                 low_output &= ~nTRST;   /* nTRST = 0 */
2427         } else {
2428                 low_direction |= nTRSTnOE;      /* nTRST output */
2429                 low_output |= nTRST;            /* nTRST = 1 */
2430         }
2431
2432         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2433                 low_direction |= nSRSTnOE;      /* nSRST output */
2434                 low_output |= nSRST;            /* nSRST = 1 */
2435         } else {
2436                 low_direction &= ~nSRSTnOE;     /* nSRST input */
2437                 low_output &= ~nSRST;   /* nSRST = 0 */
2438         }
2439
2440         /* initialize low byte for jtag */
2441         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2442                 LOG_ERROR("couldn't initialize FT2232 DBUS");
2443                 return ERROR_JTAG_INIT_FAILED;
2444         }
2445
2446         return ERROR_OK;
2447 }
2448
2449 static int usbjtag_init(void)
2450 {
2451         /*
2452          * NOTE:  This is now _specific_ to the "usbjtag" layout.
2453          * Don't try cram any more layouts into this.
2454          */
2455         ftx232_dbus_init();
2456
2457         nTRST    = 0x10;
2458         nTRSTnOE = 0x10;
2459         nSRST    = 0x40;
2460         nSRSTnOE = 0x40;
2461
2462         return ftx232_dbus_write();
2463 }
2464
2465 static int lm3s811_jtag_init(void)
2466 {
2467         ftx232_dbus_init();
2468
2469         /* There are multiple revisions of LM3S811 eval boards:
2470          * - Rev B (and older?) boards have no SWO trace support.
2471          * - Rev C boards add ADBUS_6 DBG_ENn and BDBUS_4 SWO_EN;
2472          *   they should use the "luminary_icdi" layout instead.
2473          */
2474         nTRST = 0x0;
2475         nTRSTnOE = 0x00;
2476         nSRST = 0x20;
2477         nSRSTnOE = 0x20;
2478         low_output    = 0x88;
2479         low_direction = 0x8b;
2480
2481         return ftx232_dbus_write();
2482 }
2483
2484 static int icdi_jtag_init(void)
2485 {
2486         ftx232_dbus_init();
2487
2488         /* Most Luminary eval boards support SWO trace output,
2489          * and should use this "luminary_icdi" layout.
2490          *
2491          * ADBUS 0..3 are used for JTAG as usual.  GPIOs are used
2492          * to switch between JTAG and SWD, or switch the ft2232 UART
2493          * on the second MPSSE channel/interface (BDBUS)
2494          * between (i) the stellaris UART (on Luminary boards)
2495          * or (ii) SWO trace data (generic).
2496          *
2497          * We come up in JTAG mode and may switch to SWD later (with
2498          * SWO/trace option if SWD is active).
2499          *
2500          * DBUS == GPIO-Lx
2501          * CBUS == GPIO-Hx
2502          */
2503
2504
2505 #define ICDI_JTAG_EN (1 << 7)           /* ADBUS 7 (a.k.a. DBGMOD) */
2506 #define ICDI_DBG_ENn (1 << 6)           /* ADBUS 6 */
2507 #define ICDI_SRST (1 << 5)              /* ADBUS 5 */
2508
2509
2510         /* GPIOs on second channel/interface (UART) ... */
2511 #define ICDI_SWO_EN (1 << 4)            /* BDBUS 4 */
2512 #define ICDI_TX_SWO (1 << 1)            /* BDBUS 1 */
2513 #define ICDI_VCP_RX (1 << 0)            /* BDBUS 0 (to stellaris UART) */
2514
2515         nTRST = 0x0;
2516         nTRSTnOE = 0x00;
2517         nSRST = ICDI_SRST;
2518         nSRSTnOE = ICDI_SRST;
2519
2520         low_direction |= ICDI_JTAG_EN | ICDI_DBG_ENn;
2521         low_output    |= ICDI_JTAG_EN;
2522         low_output    &= ~ICDI_DBG_ENn;
2523
2524         return ftx232_dbus_write();
2525 }
2526
2527 static int signalyzer_init(void)
2528 {
2529         ftx232_dbus_init();
2530
2531         nTRST    = 0x10;
2532         nTRSTnOE = 0x10;
2533         nSRST    = 0x20;
2534         nSRSTnOE = 0x20;
2535         return ftx232_dbus_write();
2536 }
2537
2538 static int axm0432_jtag_init(void)
2539 {
2540         low_output    = 0x08;
2541         low_direction = 0x2b;
2542
2543         /* initialize low byte for jtag */
2544         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2545                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2546                 return ERROR_JTAG_INIT_FAILED;
2547         }
2548
2549         if (strcmp(layout->name, "axm0432_jtag") == 0) {
2550                 nTRST    = 0x08;
2551                 nTRSTnOE = 0x0;         /* No output enable for TRST*/
2552                 nSRST    = 0x04;
2553                 nSRSTnOE = 0x0;         /* No output enable for SRST*/
2554         } else {
2555                 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2556                 exit(-1);
2557         }
2558
2559         high_output    = 0x0;
2560         high_direction = 0x0c;
2561
2562         enum reset_types jtag_reset_config = jtag_get_reset_config();
2563         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2564                 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2565         else
2566                 high_output |= nTRST;
2567
2568         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2569                 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2570         else
2571                 high_output |= nSRST;
2572
2573         /* initialize high byte for jtag */
2574         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2575                 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2576                 return ERROR_JTAG_INIT_FAILED;
2577         }
2578
2579         return ERROR_OK;
2580 }
2581
2582 static int redbee_init(void)
2583 {
2584         low_output    = 0x08;
2585         low_direction = 0x2b;
2586
2587         /* initialize low byte for jtag */
2588         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2589                 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2590                 return ERROR_JTAG_INIT_FAILED;
2591         }
2592
2593         nTRST    = 0x08;
2594         nTRSTnOE = 0x0;         /* No output enable for TRST*/
2595         nSRST    = 0x04;
2596         nSRSTnOE = 0x0;         /* No output enable for SRST*/
2597
2598         high_output    = 0x0;
2599         high_direction = 0x0c;
2600
2601         enum reset_types jtag_reset_config = jtag_get_reset_config();
2602         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2603                 LOG_ERROR("can't set nTRSTOE to push-pull on redbee");
2604         else
2605                 high_output |= nTRST;
2606
2607         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2608                 LOG_ERROR("can't set nSRST to push-pull on redbee");
2609         else
2610                 high_output |= nSRST;
2611
2612         /* initialize high byte for jtag */
2613         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2614                 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2615                 return ERROR_JTAG_INIT_FAILED;
2616         }
2617
2618         return ERROR_OK;
2619 }
2620
2621 static int jtagkey_init(void)
2622 {
2623         low_output    = 0x08;
2624         low_direction = 0x1b;
2625
2626         /* initialize low byte for jtag */
2627         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2628                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2629                 return ERROR_JTAG_INIT_FAILED;
2630         }
2631
2632         if (strcmp(layout->name, "jtagkey") == 0) {
2633                 nTRST    = 0x01;
2634                 nTRSTnOE = 0x4;
2635                 nSRST    = 0x02;
2636                 nSRSTnOE = 0x08;
2637         } else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2638                    || (strcmp(layout->name, "oocdlink") == 0)) {
2639                 nTRST    = 0x02;
2640                 nTRSTnOE = 0x1;
2641                 nSRST    = 0x08;
2642                 nSRSTnOE = 0x04;
2643         } else {
2644                 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2645                 exit(-1);
2646         }
2647
2648         high_output    = 0x0;
2649         high_direction = 0x0f;
2650
2651         enum reset_types jtag_reset_config = jtag_get_reset_config();
2652         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2653                 high_output |= nTRSTnOE;
2654                 high_output &= ~nTRST;
2655         } else {
2656                 high_output &= ~nTRSTnOE;
2657                 high_output |= nTRST;
2658         }
2659
2660         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2661                 high_output &= ~nSRSTnOE;
2662                 high_output |= nSRST;
2663         } else {
2664                 high_output |= nSRSTnOE;
2665                 high_output &= ~nSRST;
2666         }
2667
2668         /* initialize high byte for jtag */
2669         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2670                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2671                 return ERROR_JTAG_INIT_FAILED;
2672         }
2673
2674         return ERROR_OK;
2675 }
2676
2677 static int olimex_jtag_init(void)
2678 {
2679         low_output    = 0x08;
2680         low_direction = 0x1b;
2681
2682         /* initialize low byte for jtag */
2683         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2684                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2685                 return ERROR_JTAG_INIT_FAILED;
2686         }
2687
2688         nTRST    = 0x01;
2689         nTRSTnOE = 0x4;
2690         nSRST    = 0x02;
2691         nSRSTnOE = 0x00;/* no output enable for nSRST */
2692
2693         high_output    = 0x0;
2694         high_direction = 0x0f;
2695
2696         enum reset_types jtag_reset_config = jtag_get_reset_config();
2697         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2698                 high_output |= nTRSTnOE;
2699                 high_output &= ~nTRST;
2700         } else {
2701                 high_output &= ~nTRSTnOE;
2702                 high_output |= nTRST;
2703         }
2704
2705         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2706                 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2707         else
2708                 high_output &= ~nSRST;
2709
2710         /* turn red LED on */
2711         high_output |= 0x08;
2712
2713         /* initialize high byte for jtag */
2714         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2715                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2716                 return ERROR_JTAG_INIT_FAILED;
2717         }
2718
2719         return ERROR_OK;
2720 }
2721
2722 static int flyswatter_init(int rev)
2723 {
2724         low_output    = 0x18;
2725         low_direction = 0x7b;
2726
2727         if ((rev < 0) || (rev > 3)) {
2728                 LOG_ERROR("bogus 'flyswatter' revision supplied (%i)", rev);
2729                 return ERROR_JTAG_INIT_FAILED;
2730         }
2731
2732         if (rev == 1)
2733                 low_direction |= 1 << 7;
2734
2735         /* initialize low byte for jtag */
2736         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2737                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2738                 return ERROR_JTAG_INIT_FAILED;
2739         }
2740
2741         nTRST    = 0x10;
2742         nTRSTnOE = 0x0;         /* not output enable for nTRST */
2743         nSRST    = 0x20;
2744         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2745
2746         high_output    = 0x00;
2747
2748         if (rev == 1)
2749                 high_direction = 0x0c;
2750         else
2751                 high_direction = 0x01;
2752
2753         /* turn red LED3 on, LED2 off */
2754         high_output |= 0x08;
2755
2756         /* initialize high byte for jtag */
2757         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2758                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2759                 return ERROR_JTAG_INIT_FAILED;
2760         }
2761
2762         return ERROR_OK;
2763 }
2764
2765 static int flyswatter1_init(void)
2766 {
2767         return flyswatter_init(1);
2768 }
2769
2770 static int flyswatter2_init(void)
2771 {
2772         return flyswatter_init(2);
2773 }
2774
2775 static int minimodule_init(void)
2776 {
2777         low_output    = 0x18;   /* check if srst should be 1 or 0 initially. (0x08) (flyswatter was
2778                                  * 0x18) */
2779         low_direction = 0xfb;   /* 0xfb; */
2780
2781         /* initialize low byte for jtag */
2782         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2783                 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2784                 return ERROR_JTAG_INIT_FAILED;
2785         }
2786
2787
2788         nSRST    = 0x20;
2789
2790         high_output    = 0x00;
2791         high_direction = 0x05;
2792
2793         /* turn red LED3 on, LED2 off */
2794         /* high_output |= 0x08; */
2795
2796         /* initialize high byte for jtag */
2797         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2798                 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2799                 return ERROR_JTAG_INIT_FAILED;
2800         }
2801
2802         return ERROR_OK;
2803 }
2804
2805 static int turtle_init(void)
2806 {
2807         low_output    = 0x08;
2808         low_direction = 0x5b;
2809
2810         /* initialize low byte for jtag */
2811         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2812                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2813                 return ERROR_JTAG_INIT_FAILED;
2814         }
2815
2816         nSRST = 0x40;
2817
2818         high_output    = 0x00;
2819         high_direction = 0x0C;
2820
2821         /* initialize high byte for jtag */
2822         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2823                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2824                 return ERROR_JTAG_INIT_FAILED;
2825         }
2826
2827         return ERROR_OK;
2828 }
2829
2830 static int comstick_init(void)
2831 {
2832         low_output    = 0x08;
2833         low_direction = 0x0b;
2834
2835         /* initialize low byte for jtag */
2836         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2837                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2838                 return ERROR_JTAG_INIT_FAILED;
2839         }
2840
2841         nTRST    = 0x01;
2842         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2843         nSRST    = 0x02;
2844         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2845
2846         high_output    = 0x03;
2847         high_direction = 0x03;
2848
2849         /* initialize high byte for jtag */
2850         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2851                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2852                 return ERROR_JTAG_INIT_FAILED;
2853         }
2854
2855         return ERROR_OK;
2856 }
2857
2858 static int stm32stick_init(void)
2859 {
2860         low_output    = 0x88;
2861         low_direction = 0x8b;
2862
2863         /* initialize low byte for jtag */
2864         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2865                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2866                 return ERROR_JTAG_INIT_FAILED;
2867         }
2868
2869         nTRST    = 0x01;
2870         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2871         nSRST    = 0x80;
2872         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2873
2874         high_output    = 0x01;
2875         high_direction = 0x03;
2876
2877         /* initialize high byte for jtag */
2878         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2879                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2880                 return ERROR_JTAG_INIT_FAILED;
2881         }
2882
2883         return ERROR_OK;
2884 }
2885
2886 static int sheevaplug_init(void)
2887 {
2888         low_output = 0x08;
2889         low_direction = 0x1b;
2890
2891         /* initialize low byte for jtag */
2892         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2893                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2894                 return ERROR_JTAG_INIT_FAILED;
2895         }
2896
2897         nTRSTnOE = 0x1;
2898         nTRST = 0x02;
2899         nSRSTnOE = 0x4;
2900         nSRST = 0x08;
2901
2902         high_output = 0x0;
2903         high_direction = 0x0f;
2904
2905         /* nTRST is always push-pull */
2906         high_output &= ~nTRSTnOE;
2907         high_output |= nTRST;
2908
2909         /* nSRST is always open-drain */
2910         high_output |= nSRSTnOE;
2911         high_output &= ~nSRST;
2912
2913         /* initialize high byte for jtag */
2914         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2915                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2916                 return ERROR_JTAG_INIT_FAILED;
2917         }
2918
2919         return ERROR_OK;
2920 }
2921
2922 static int cortino_jtag_init(void)
2923 {
2924         low_output    = 0x08;
2925         low_direction = 0x1b;
2926
2927         /* initialize low byte for jtag */
2928         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2929                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2930                 return ERROR_JTAG_INIT_FAILED;
2931         }
2932
2933         nTRST    = 0x01;
2934         nTRSTnOE = 0x00;        /* no output enable for nTRST */
2935         nSRST    = 0x02;
2936         nSRSTnOE = 0x00;        /* no output enable for nSRST */
2937
2938         high_output    = 0x03;
2939         high_direction = 0x03;
2940
2941         /* initialize high byte for jtag */
2942         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2943                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2944                 return ERROR_JTAG_INIT_FAILED;
2945         }
2946
2947         return ERROR_OK;
2948 }
2949
2950 static int lisa_l_init(void)
2951 {
2952         ftx232_dbus_init();
2953
2954         nTRST    = 0x10;
2955         nTRSTnOE = 0x10;
2956         nSRST    = 0x40;
2957         nSRSTnOE = 0x40;
2958
2959         high_output = 0x00;
2960         high_direction = 0x18;
2961
2962         /* initialize high byte for jtag */
2963         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2964                 LOG_ERROR("couldn't initialize FT2232 with 'lisa_l' layout");
2965                 return ERROR_JTAG_INIT_FAILED;
2966         }
2967
2968         return ftx232_dbus_write();
2969 }
2970
2971 static int flossjtag_init(void)
2972 {
2973         ftx232_dbus_init();
2974
2975         nTRST    = 0x10;
2976         nTRSTnOE = 0x10;
2977         nSRST    = 0x40;
2978         nSRSTnOE = 0x40;
2979
2980         high_output = 0x00;
2981         high_direction = 0x18;
2982
2983         /* initialize high byte for jtag */
2984         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2985                 LOG_ERROR("couldn't initialize FT2232 with 'Floss-JTAG' layout");
2986                 return ERROR_JTAG_INIT_FAILED;
2987         }
2988
2989         return ftx232_dbus_write();
2990 }
2991
2992 /*
2993  * The reference schematic from TI for the XDS100v2 has a CPLD on which opens
2994  * the door for a number of different configurations
2995  *
2996  * Known Implementations:
2997  * http://processors.wiki.ti.com/images/9/93/TMS570LS20216_USB_STICK_Schematic.pdf
2998  *
2999  * http://processors.wiki.ti.com/index.php/XDS100 (rev2)
3000  *      * CLPD logic: Rising edge to enable outputs (XDS100_PWR_RST)
3001  *              * ACBUS3 to transition 0->1 (OE rising edge)
3002  *      * CPLD logic: Put the EMU0/1 pins in Hi-Z:
3003  *              * ADBUS5/GPIOL1 = EMU_EN = 1
3004  *              * ADBUS6/GPIOL2 = EMU0 = 0
3005  *              * ACBUS4/SPARE0 = EMU1 = 0
3006  *      * CPLD logic: Disable loopback
3007  *              * ACBUS6/SPARE2 = LOOPBACK = 0
3008  */
3009 #define XDS100_nEMU_EN  (1<<5)
3010 #define XDS100_nEMU0    (1<<6)
3011
3012 #define XDS100_PWR_RST  (1<<3)
3013 #define XDS100_nEMU1    (1<<4)
3014 #define XDS100_LOOPBACK (1<<6)
3015 static int xds100v2_init(void)
3016 {
3017         /* These are in the lower byte */
3018         nTRST    = 0x10;
3019         nTRSTnOE = 0x10;
3020
3021         /* These aren't actually used on 14 pin connectors
3022          * These are in the upper byte */
3023         nSRST    = 0x01;
3024         nSRSTnOE = 0x01;
3025
3026         low_output    = 0x08 | nTRST | XDS100_nEMU_EN;
3027         low_direction = 0x0b | nTRSTnOE | XDS100_nEMU_EN | XDS100_nEMU0;
3028
3029         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3030                 LOG_ERROR("couldn't initialize FT2232 with 'xds100v2' layout");
3031                 return ERROR_JTAG_INIT_FAILED;
3032         }
3033
3034         high_output = 0;
3035         high_direction = nSRSTnOE | XDS100_LOOPBACK | XDS100_PWR_RST | XDS100_nEMU1;
3036
3037         /* initialize high byte for jtag */
3038         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3039                 LOG_ERROR("couldn't put CPLD in to reset with 'xds100v2' layout");
3040                 return ERROR_JTAG_INIT_FAILED;
3041         }
3042
3043         high_output |= XDS100_PWR_RST;
3044
3045         /* initialize high byte for jtag */
3046         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3047                 LOG_ERROR("couldn't bring CPLD out of reset with 'xds100v2' layout");
3048                 return ERROR_JTAG_INIT_FAILED;
3049         }
3050
3051         return ERROR_OK;
3052 }
3053
3054 static void olimex_jtag_blink(void)
3055 {
3056         /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
3057          * ACBUS3 is bit 3 of the GPIOH port
3058          */
3059         high_output ^= 0x08;
3060
3061         buffer_write(0x82);
3062         buffer_write(high_output);
3063         buffer_write(high_direction);
3064 }
3065
3066 static void flyswatter_jtag_blink(unsigned char led)
3067 {
3068         buffer_write(0x82);
3069         buffer_write(high_output ^ led);
3070         buffer_write(high_direction);
3071 }
3072
3073 static void flyswatter1_jtag_blink(void)
3074 {
3075         /*
3076          * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
3077          */
3078         flyswatter_jtag_blink(0xc);
3079 }
3080
3081 static void flyswatter2_jtag_blink(void)
3082 {
3083         /*
3084          * Flyswatter2 only has one LED connected to ACBUS2
3085          */
3086         flyswatter_jtag_blink(0x4);
3087 }
3088
3089 static void turtle_jtag_blink(void)
3090 {
3091         /*
3092          * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
3093          */
3094         if (high_output & 0x08)
3095                 high_output = 0x04;
3096         else
3097                 high_output = 0x08;
3098
3099         buffer_write(0x82);
3100         buffer_write(high_output);
3101         buffer_write(high_direction);
3102 }
3103
3104 static void lisa_l_blink(void)
3105 {
3106         /*
3107          * Lisa/L has two LEDs connected to BCBUS3 and BCBUS4
3108          */
3109         if (high_output & 0x10)
3110                 high_output = 0x08;
3111         else
3112                 high_output = 0x10;
3113
3114         buffer_write(0x82);
3115         buffer_write(high_output);
3116         buffer_write(high_direction);
3117 }
3118
3119 static void flossjtag_blink(void)
3120 {
3121         /*
3122          * Floss-JTAG has two LEDs connected to ACBUS3 and ACBUS4
3123          */
3124         if (high_output & 0x10)
3125                 high_output = 0x08;
3126         else
3127                 high_output = 0x10;
3128
3129         buffer_write(0x82);
3130         buffer_write(high_output);
3131         buffer_write(high_direction);
3132 }
3133
3134 static int ft2232_quit(void)
3135 {
3136 #if BUILD_FT2232_FTD2XX == 1
3137         FT_STATUS status;
3138
3139         status = FT_Close(ftdih);
3140 #elif BUILD_FT2232_LIBFTDI == 1
3141         ftdi_usb_close(&ftdic);
3142
3143         ftdi_deinit(&ftdic);
3144 #endif
3145
3146         free(ft2232_buffer);
3147         ft2232_buffer = NULL;
3148
3149         return ERROR_OK;
3150 }
3151
3152 COMMAND_HANDLER(ft2232_handle_device_desc_command)
3153 {
3154         char *cp;
3155         char buf[200];
3156         if (CMD_ARGC == 1) {
3157                 ft2232_device_desc = strdup(CMD_ARGV[0]);
3158                 cp = strchr(ft2232_device_desc, 0);
3159                 /* under Win32, the FTD2XX driver appends an "A" to the end
3160                  * of the description, this examines the given desc
3161                  * and creates the 'missing' _A or non_A variable. */
3162                 if ((cp[-1] == 'A') && (cp[-2] == ' ')) {
3163                         /* it was, so make this the "A" version. */
3164                         ft2232_device_desc_A = ft2232_device_desc;
3165                         /* and *CREATE* the non-A version. */
3166                         strcpy(buf, ft2232_device_desc);
3167                         cp = strchr(buf, 0);
3168                         cp[-2] = 0;
3169                         ft2232_device_desc = strdup(buf);
3170                 } else {
3171                         /* <space > A not defined
3172                          * so create it */
3173                         sprintf(buf, "%s A", ft2232_device_desc);
3174                         ft2232_device_desc_A = strdup(buf);
3175                 }
3176         } else
3177                 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
3178
3179         return ERROR_OK;
3180 }
3181
3182 COMMAND_HANDLER(ft2232_handle_serial_command)
3183 {
3184         if (CMD_ARGC == 1)
3185                 ft2232_serial = strdup(CMD_ARGV[0]);
3186         else
3187                 return ERROR_COMMAND_SYNTAX_ERROR;
3188
3189         return ERROR_OK;
3190 }
3191
3192 COMMAND_HANDLER(ft2232_handle_layout_command)
3193 {
3194         if (CMD_ARGC != 1)
3195                 return ERROR_COMMAND_SYNTAX_ERROR;
3196
3197         if (layout) {
3198                 LOG_ERROR("already specified ft2232_layout %s",
3199                         layout->name);
3200                 return (strcmp(layout->name, CMD_ARGV[0]) != 0)
3201                        ? ERROR_FAIL
3202                        : ERROR_OK;
3203         }
3204
3205         for (const struct ft2232_layout *l = ft2232_layouts; l->name; l++) {
3206                 if (strcmp(l->name, CMD_ARGV[0]) == 0) {
3207                         layout = l;
3208                         ft2232_channel = l->channel;
3209                         return ERROR_OK;
3210                 }
3211         }
3212
3213         LOG_ERROR("No FT2232 layout '%s' found", CMD_ARGV[0]);
3214         return ERROR_FAIL;
3215 }
3216
3217 COMMAND_HANDLER(ft2232_handle_vid_pid_command)
3218 {
3219         if (CMD_ARGC > MAX_USB_IDS * 2) {
3220                 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
3221                         "(maximum is %d pairs)", MAX_USB_IDS);
3222                 CMD_ARGC = MAX_USB_IDS * 2;
3223         }
3224         if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
3225                 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
3226                 if (CMD_ARGC < 2)
3227                         return ERROR_COMMAND_SYNTAX_ERROR;
3228                 /* remove the incomplete trailing id */
3229                 CMD_ARGC -= 1;
3230         }
3231
3232         unsigned i;
3233         for (i = 0; i < CMD_ARGC; i += 2) {
3234                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ft2232_vid[i >> 1]);
3235                 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ft2232_pid[i >> 1]);
3236         }
3237
3238         /*
3239          * Explicitly terminate, in case there are multiples instances of
3240          * ft2232_vid_pid.
3241          */
3242         ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
3243
3244         return ERROR_OK;
3245 }
3246
3247 COMMAND_HANDLER(ft2232_handle_latency_command)
3248 {
3249         if (CMD_ARGC == 1)
3250                 ft2232_latency = atoi(CMD_ARGV[0]);
3251         else
3252                 return ERROR_COMMAND_SYNTAX_ERROR;
3253
3254         return ERROR_OK;
3255 }
3256
3257 COMMAND_HANDLER(ft2232_handle_channel_command)
3258 {
3259         if (CMD_ARGC == 1) {
3260                 ft2232_channel = atoi(CMD_ARGV[0]);
3261                 if (ft2232_channel < 0 || ft2232_channel > 4)
3262                         LOG_ERROR("ft2232_channel must be in the 0 to 4 range");
3263         } else
3264                 LOG_ERROR("expected exactly one argument to ft2232_channel <ch>");
3265
3266         return ERROR_OK;
3267 }
3268
3269 static int ft2232_stableclocks(int num_cycles, struct jtag_command *cmd)
3270 {
3271         int retval = 0;
3272
3273         /* 7 bits of either ones or zeros. */
3274         uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
3275
3276         while (num_cycles > 0) {
3277                 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
3278                  * at most 7 bits per invocation.  Here we invoke it potentially
3279                  * several times.
3280                  */
3281                 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
3282
3283                 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE) {
3284                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
3285                                 retval = ERROR_JTAG_QUEUE_FAILED;
3286
3287                         first_unsent = cmd;
3288                 }
3289
3290                 /* there are no state transitions in this code, so omit state tracking */
3291
3292                 /* command "Clock Data to TMS/CS Pin (no Read)" */
3293                 buffer_write(0x4b);
3294
3295                 /* scan 7 bit */
3296                 buffer_write(bitcount_per_command - 1);
3297
3298                 /* TMS data bits are either all zeros or ones to stay in the current stable state */
3299                 buffer_write(tms);
3300
3301                 require_send = 1;
3302
3303                 num_cycles -= bitcount_per_command;
3304         }
3305
3306         return retval;
3307 }
3308
3309 /* ---------------------------------------------------------------------
3310  * Support for IceBear JTAG adapter from Section5:
3311  *      http://section5.ch/icebear
3312  *
3313  * Author: Sten, debian@sansys-electronic.com
3314  */
3315
3316 /* Icebear pin layout
3317  *
3318  * ADBUS5 (nEMU) nSRST  | 2   1|        GND (10k->VCC)
3319  * GND GND              | 4   3|        n.c.
3320  * ADBUS3 TMS           | 6   5|        ADBUS6 VCC
3321  * ADBUS0 TCK           | 8   7|        ADBUS7 (GND)
3322  * ADBUS4 nTRST         |10   9|        ACBUS0 (GND)
3323  * ADBUS1 TDI           |12  11|        ACBUS1 (GND)
3324  * ADBUS2 TDO           |14  13|        GND GND
3325  *
3326  * ADBUS0 O L TCK               ACBUS0 GND
3327  * ADBUS1 O L TDI               ACBUS1 GND
3328  * ADBUS2 I   TDO               ACBUS2 n.c.
3329  * ADBUS3 O H TMS               ACBUS3 n.c.
3330  * ADBUS4 O H nTRST
3331  * ADBUS5 O H nSRST
3332  * ADBUS6 -   VCC
3333  * ADBUS7 -   GND
3334  */
3335 static int icebear_jtag_init(void)
3336 {
3337         low_direction   = 0x0b; /* output: TCK TDI TMS; input: TDO */
3338         low_output      = 0x08; /* high: TMS; low: TCK TDI */
3339         nTRST           = 0x10;
3340         nSRST           = 0x20;
3341
3342         enum reset_types jtag_reset_config = jtag_get_reset_config();
3343         if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3344                 low_direction   &= ~nTRST;      /* nTRST high impedance */
3345         else {
3346                 low_direction   |= nTRST;
3347                 low_output      |= nTRST;
3348         }
3349
3350         low_direction   |= nSRST;
3351         low_output      |= nSRST;
3352
3353         /* initialize low byte for jtag */
3354         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3355                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3356                 return ERROR_JTAG_INIT_FAILED;
3357         }
3358
3359         high_output    = 0x0;
3360         high_direction = 0x00;
3361
3362         /* initialize high byte for jtag */
3363         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3364                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3365                 return ERROR_JTAG_INIT_FAILED;
3366         }
3367
3368         return ERROR_OK;
3369 }
3370
3371 static void icebear_jtag_reset(int trst, int srst)
3372 {
3373         if (trst == 1) {
3374                 low_direction   |= nTRST;
3375                 low_output      &= ~nTRST;
3376         } else if (trst == 0) {
3377                 enum reset_types jtag_reset_config = jtag_get_reset_config();
3378                 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3379                         low_direction   &= ~nTRST;
3380                 else
3381                         low_output      |= nTRST;
3382         }
3383
3384         if (srst == 1)
3385                 low_output &= ~nSRST;
3386         else if (srst == 0)
3387                 low_output |= nSRST;
3388
3389         /* command "set data bits low byte" */
3390         buffer_write(0x80);
3391         buffer_write(low_output);
3392         buffer_write(low_direction);
3393
3394         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
3395                 trst,
3396                 srst,
3397                 low_output,
3398                 low_direction);
3399 }
3400
3401 /* ---------------------------------------------------------------------
3402  * Support for Signalyzer H2 and Signalyzer H4
3403  * JTAG adapter from Xverve Technologies Inc.
3404  * http://www.signalyzer.com or http://www.xverve.com
3405  *
3406  * Author: Oleg Seiljus, oleg@signalyzer.com
3407  */
3408 static unsigned char signalyzer_h_side;
3409 static unsigned int signalyzer_h_adapter_type;
3410
3411 static int signalyzer_h_ctrl_write(int address, unsigned short value);
3412
3413 #if BUILD_FT2232_FTD2XX == 1
3414 static int signalyzer_h_ctrl_read(int address, unsigned short *value);
3415 #endif
3416
3417 #define SIGNALYZER_COMMAND_ADDR                                 128
3418 #define SIGNALYZER_DATA_BUFFER_ADDR                             129
3419
3420 #define SIGNALYZER_COMMAND_VERSION                              0x41
3421 #define SIGNALYZER_COMMAND_RESET                                0x42
3422 #define SIGNALYZER_COMMAND_POWERCONTROL_GET             0x50
3423 #define SIGNALYZER_COMMAND_POWERCONTROL_SET             0x51
3424 #define SIGNALYZER_COMMAND_PWM_SET                              0x52
3425 #define SIGNALYZER_COMMAND_LED_SET                              0x53
3426 #define SIGNALYZER_COMMAND_ADC                                  0x54
3427 #define SIGNALYZER_COMMAND_GPIO_STATE                   0x55
3428 #define SIGNALYZER_COMMAND_GPIO_MODE                    0x56
3429 #define SIGNALYZER_COMMAND_GPIO_PORT                    0x57
3430 #define SIGNALYZER_COMMAND_I2C                                  0x58
3431
3432 #define SIGNALYZER_CHAN_A                                               1
3433 #define SIGNALYZER_CHAN_B                                               2
3434 /* LEDS use channel C */
3435 #define SIGNALYZER_CHAN_C                                               4
3436
3437 #define SIGNALYZER_LED_GREEN                                    1
3438 #define SIGNALYZER_LED_RED                                              2
3439
3440 #define SIGNALYZER_MODULE_TYPE_EM_LT16_A                0x0301
3441 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG              0x0302
3442 #define SIGNALYZER_MODULE_TYPE_EM_JTAG                  0x0303
3443 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P    0x0304
3444 #define SIGNALYZER_MODULE_TYPE_EM_JTAG_P                0x0305
3445
3446
3447 static int signalyzer_h_ctrl_write(int address, unsigned short value)
3448 {
3449 #if BUILD_FT2232_FTD2XX == 1
3450         return FT_WriteEE(ftdih, address, value);
3451 #elif BUILD_FT2232_LIBFTDI == 1
3452         return 0;
3453 #endif
3454 }
3455
3456 #if BUILD_FT2232_FTD2XX == 1
3457 static int signalyzer_h_ctrl_read(int address, unsigned short *value)
3458 {
3459         return FT_ReadEE(ftdih, address, value);
3460 }
3461 #endif
3462
3463 static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
3464         int on_time_ms, int off_time_ms, unsigned char cycles)
3465 {
3466         unsigned char on_time;
3467         unsigned char off_time;
3468
3469         if (on_time_ms < 0xFFFF)
3470                 on_time = (unsigned char)(on_time_ms / 62);
3471         else
3472                 on_time = 0xFF;
3473
3474         off_time = (unsigned char)(off_time_ms / 62);
3475
3476 #if BUILD_FT2232_FTD2XX == 1
3477         FT_STATUS status;
3478
3479         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3480                         ((uint32_t)(channel << 8) | led));
3481         if (status != FT_OK) {
3482                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3483                         ftd2xx_status_string(status));
3484                 return ERROR_JTAG_DEVICE_ERROR;
3485         }
3486
3487         status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3488                         ((uint32_t)(on_time << 8) | off_time));
3489         if (status != FT_OK) {
3490                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3491                         ftd2xx_status_string(status));
3492                 return ERROR_JTAG_DEVICE_ERROR;
3493         }
3494
3495         status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3496                         ((uint32_t)cycles));
3497         if (status != FT_OK) {
3498                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3499                         ftd2xx_status_string(status));
3500                 return ERROR_JTAG_DEVICE_ERROR;
3501         }
3502
3503         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3504                                 SIGNALYZER_COMMAND_LED_SET);
3505         if (status != FT_OK) {
3506                 LOG_ERROR("signalyzer_h_ctrl_write  returned: %s",
3507                         ftd2xx_status_string(status));
3508                 return ERROR_JTAG_DEVICE_ERROR;
3509         }
3510
3511         return ERROR_OK;
3512 #elif BUILD_FT2232_LIBFTDI == 1
3513         int retval;
3514
3515         retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3516                                 ((uint32_t)(channel << 8) | led));
3517         if (retval < 0) {
3518                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3519                         ftdi_get_error_string(&ftdic));
3520                 return ERROR_JTAG_DEVICE_ERROR;
3521         }
3522
3523         retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3524                         ((uint32_t)(on_time << 8) | off_time));
3525         if (retval < 0) {
3526                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3527                         ftdi_get_error_string(&ftdic));
3528                 return ERROR_JTAG_DEVICE_ERROR;
3529         }
3530
3531         retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3532                         (uint32_t)cycles);
3533         if (retval < 0) {
3534                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3535                         ftdi_get_error_string(&ftdic));
3536                 return ERROR_JTAG_DEVICE_ERROR;
3537         }
3538
3539         retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3540                         SIGNALYZER_COMMAND_LED_SET);
3541         if (retval < 0) {
3542                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3543                         ftdi_get_error_string(&ftdic));
3544                 return ERROR_JTAG_DEVICE_ERROR;
3545         }
3546
3547         return ERROR_OK;
3548 #endif
3549 }
3550
3551 static int signalyzer_h_init(void)
3552 {
3553 #if BUILD_FT2232_FTD2XX == 1
3554         FT_STATUS status;
3555         int i;
3556 #endif
3557
3558         char *end_of_desc;
3559
3560         uint16_t read_buf[12] = { 0 };
3561
3562         /* turn on center green led */
3563         signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
3564                 0xFFFF, 0x00, 0x00);
3565
3566         /* determine what channel config wants to open
3567          * TODO: change me... current implementation is made to work
3568          * with openocd description parsing.
3569          */
3570         end_of_desc = strrchr(ft2232_device_desc, 0x00);
3571
3572         if (end_of_desc) {
3573                 signalyzer_h_side = *(end_of_desc - 1);
3574                 if (signalyzer_h_side == 'B')
3575                         signalyzer_h_side = SIGNALYZER_CHAN_B;
3576                 else
3577                         signalyzer_h_side = SIGNALYZER_CHAN_A;
3578         } else {
3579                 LOG_ERROR("No Channel was specified");
3580                 return ERROR_FAIL;
3581         }
3582
3583         signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
3584                 1000, 1000, 0xFF);
3585
3586 #if BUILD_FT2232_FTD2XX == 1
3587         /* read signalyzer versionining information */
3588         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3589                         SIGNALYZER_COMMAND_VERSION);
3590         if (status != FT_OK) {
3591                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3592                         ftd2xx_status_string(status));
3593                 return ERROR_JTAG_DEVICE_ERROR;
3594         }
3595
3596         for (i = 0; i < 10; i++) {
3597                 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i),
3598                                 &read_buf[i]);
3599                 if (status != FT_OK) {
3600                         LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3601                                 ftd2xx_status_string(status));
3602                         return ERROR_JTAG_DEVICE_ERROR;
3603                 }
3604         }
3605
3606         LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
3607                 read_buf[0], read_buf[1], read_buf[2], read_buf[3],
3608                 read_buf[4], read_buf[5], read_buf[6]);
3609
3610         /* set gpio register */
3611         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3612                         (uint32_t)(signalyzer_h_side << 8));
3613         if (status != FT_OK) {
3614                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3615                         ftd2xx_status_string(status));
3616                 return ERROR_JTAG_DEVICE_ERROR;
3617         }
3618
3619         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0404);
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_COMMAND_ADDR,
3627                         SIGNALYZER_COMMAND_GPIO_STATE);
3628         if (status != FT_OK) {
3629                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3630                         ftd2xx_status_string(status));
3631                 return ERROR_JTAG_DEVICE_ERROR;
3632         }
3633
3634         /* read adapter type information */
3635         status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3636                         ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3637         if (status != FT_OK) {
3638                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3639                         ftd2xx_status_string(status));
3640                 return ERROR_JTAG_DEVICE_ERROR;
3641         }
3642
3643         status = signalyzer_h_ctrl_write(
3644                         (SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000);
3645         if (status != FT_OK) {
3646                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3647                         ftd2xx_status_string(status));
3648                 return ERROR_JTAG_DEVICE_ERROR;
3649         }
3650
3651         status = signalyzer_h_ctrl_write(
3652                         (SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008);
3653         if (status != FT_OK) {
3654                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3655                         ftd2xx_status_string(status));
3656                 return ERROR_JTAG_DEVICE_ERROR;
3657         }
3658
3659         status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3660                         SIGNALYZER_COMMAND_I2C);
3661         if (status != FT_OK) {
3662                 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3663                         ftd2xx_status_string(status));
3664                 return ERROR_JTAG_DEVICE_ERROR;
3665         }
3666
3667         usleep(100000);
3668
3669         status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR, &read_buf[0]);
3670         if (status != FT_OK) {
3671                 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3672                         ftd2xx_status_string(status));
3673                 return ERROR_JTAG_DEVICE_ERROR;
3674         }
3675
3676         if (read_buf[0] != 0x0498)
3677                 signalyzer_h_adapter_type = 0x0000;
3678         else {
3679                 for (i = 0; i < 4; i++) {
3680                         status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i), &read_buf[i]);
3681                         if (status != FT_OK) {
3682                                 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3683                                         ftd2xx_status_string(status));
3684                                 return ERROR_JTAG_DEVICE_ERROR;
3685                         }
3686                 }
3687
3688                 signalyzer_h_adapter_type = read_buf[0];
3689         }
3690
3691 #elif BUILD_FT2232_LIBFTDI == 1
3692         /* currently libftdi does not allow reading individual eeprom
3693          * locations, therefore adapter type cannot be detected.
3694          * override with most common type
3695          */
3696         signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
3697 #endif
3698
3699         enum reset_types jtag_reset_config = jtag_get_reset_config();
3700
3701         /* ADAPTOR: EM_LT16_A */
3702         if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3703                 LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
3704                         "detected. (HW: %2x).", (read_buf[1] >> 8));
3705
3706                 nTRST    = 0x10;
3707                 nTRSTnOE = 0x10;
3708                 nSRST    = 0x20;
3709                 nSRSTnOE = 0x20;
3710
3711                 low_output     = 0x08;
3712                 low_direction  = 0x1b;
3713
3714                 high_output    = 0x0;
3715                 high_direction = 0x0;
3716
3717                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3718                         low_direction &= ~nTRSTnOE;     /* nTRST input */
3719                         low_output    &= ~nTRST;        /* nTRST = 0 */
3720                 } else {
3721                         low_direction |= nTRSTnOE;      /* nTRST output */
3722                         low_output    |= nTRST;         /* nTRST = 1 */
3723                 }
3724
3725                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3726                         low_direction |= nSRSTnOE;      /* nSRST output */
3727                         low_output    |= nSRST;         /* nSRST = 1 */
3728                 } else {
3729                         low_direction &= ~nSRSTnOE;     /* nSRST input */
3730                         low_output    &= ~nSRST;        /* nSRST = 0 */
3731                 }
3732
3733 #if BUILD_FT2232_FTD2XX == 1
3734                 /* enable power to the module */
3735                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3736                                 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3737                 if (status != FT_OK) {
3738                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3739                                 ftd2xx_status_string(status));
3740                         return ERROR_JTAG_DEVICE_ERROR;
3741                 }
3742
3743                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3744                                 SIGNALYZER_COMMAND_POWERCONTROL_SET);
3745                 if (status != FT_OK) {
3746                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3747                                 ftd2xx_status_string(status));
3748                         return ERROR_JTAG_DEVICE_ERROR;
3749                 }
3750
3751                 /* set gpio mode register */
3752                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3753                                 (uint32_t)(signalyzer_h_side << 8));
3754                 if (status != FT_OK) {
3755                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3756                                 ftd2xx_status_string(status));
3757                         return ERROR_JTAG_DEVICE_ERROR;
3758                 }
3759
3760                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000);
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_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_MODE);
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                 /* set gpio register */
3775                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3776                                 (uint32_t)(signalyzer_h_side << 8));
3777                 if (status != FT_OK) {
3778                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3779                                 ftd2xx_status_string(status));
3780                         return ERROR_JTAG_DEVICE_ERROR;
3781                 }
3782
3783                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x4040);
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_COMMAND_ADDR,
3791                                 SIGNALYZER_COMMAND_GPIO_STATE);
3792                 if (status != FT_OK) {
3793                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3794                                 ftd2xx_status_string(status));
3795                         return ERROR_JTAG_DEVICE_ERROR;
3796                 }
3797 #endif
3798         }
3799         /* ADAPTOR: EM_ARM_JTAG, EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
3800         else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
3801                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
3802                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
3803                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)) {
3804                 if (signalyzer_h_adapter_type
3805                     == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG)
3806                         LOG_INFO("Signalyzer: EM-ARM-JTAG (ARM JTAG) "
3807                                 "detected. (HW: %2x).", (read_buf[1] >> 8));
3808                 else if (signalyzer_h_adapter_type
3809                          == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P)
3810                         LOG_INFO("Signalyzer: EM-ARM-JTAG_P "
3811                                 "(ARM JTAG with PSU) detected. (HW: %2x).",
3812                                 (read_buf[1] >> 8));
3813                 else if (signalyzer_h_adapter_type
3814                          == SIGNALYZER_MODULE_TYPE_EM_JTAG)
3815                         LOG_INFO("Signalyzer: EM-JTAG (Generic JTAG) "
3816                                 "detected. (HW: %2x).", (read_buf[1] >> 8));
3817                 else if (signalyzer_h_adapter_type
3818                          == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)
3819                         LOG_INFO("Signalyzer: EM-JTAG-P "
3820                                 "(Generic JTAG with PSU) detected. (HW: %2x).",
3821                                 (read_buf[1] >> 8));
3822
3823                 nTRST          = 0x02;
3824                 nTRSTnOE       = 0x04;
3825                 nSRST          = 0x08;
3826                 nSRSTnOE       = 0x10;
3827
3828                 low_output     = 0x08;
3829                 low_direction  = 0x1b;
3830
3831                 high_output    = 0x0;
3832                 high_direction = 0x1f;
3833
3834                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3835                         high_output |= nTRSTnOE;
3836                         high_output &= ~nTRST;
3837                 } else {
3838                         high_output &= ~nTRSTnOE;
3839                         high_output |= nTRST;
3840                 }
3841
3842                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3843                         high_output &= ~nSRSTnOE;
3844                         high_output |= nSRST;
3845                 } else {
3846                         high_output |= nSRSTnOE;
3847                         high_output &= ~nSRST;
3848                 }
3849
3850 #if BUILD_FT2232_FTD2XX == 1
3851                 /* enable power to the module */
3852                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3853                                 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3854                 if (status != FT_OK) {
3855                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3856                                 ftd2xx_status_string(status));
3857                         return ERROR_JTAG_DEVICE_ERROR;
3858                 }
3859
3860                 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3861                                 SIGNALYZER_COMMAND_POWERCONTROL_SET);
3862                 if (status != FT_OK) {
3863                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3864                                 ftd2xx_status_string(status));
3865                         return ERROR_JTAG_DEVICE_ERROR;
3866                 }
3867
3868                 /* set gpio mode register (IO_16 and IO_17 set as analog
3869                  * inputs, other is gpio)
3870                  */
3871                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3872                                 (uint32_t)(signalyzer_h_side << 8));
3873                 if (status != FT_OK) {
3874                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3875                                 ftd2xx_status_string(status));
3876                         return ERROR_JTAG_DEVICE_ERROR;
3877                 }
3878
3879                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0060);
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_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_MODE);
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                 /* set gpio register (all inputs, for -P modules,
3894                  * PSU will be turned off)
3895                  */
3896                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3897                                 (uint32_t)(signalyzer_h_side << 8));
3898                 if (status != FT_OK) {
3899                         LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3900                                 ftd2xx_status_string(status));
3901                         return ERROR_JTAG_DEVICE_ERROR;
3902                 }
3903
3904                 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0000);
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_COMMAND_ADDR, SIGNALYZER_COMMAND_GPIO_STATE);
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 #endif
3918         } else if (signalyzer_h_adapter_type == 0x0000) {
3919                 LOG_INFO("Signalyzer: No external modules were detected.");
3920
3921                 nTRST    = 0x10;
3922                 nTRSTnOE = 0x10;
3923                 nSRST    = 0x20;
3924                 nSRSTnOE = 0x20;
3925
3926                 low_output     = 0x08;
3927                 low_direction  = 0x1b;
3928
3929                 high_output    = 0x0;
3930                 high_direction = 0x0;
3931
3932                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3933                         low_direction &= ~nTRSTnOE;     /* nTRST input */
3934                         low_output    &= ~nTRST;        /* nTRST = 0 */
3935                 } else {
3936                         low_direction |= nTRSTnOE;      /* nTRST output */
3937                         low_output    |= nTRST;         /* nTRST = 1 */
3938                 }
3939
3940                 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3941                         low_direction |= nSRSTnOE;      /* nSRST output */
3942                         low_output    |= nSRST;         /* nSRST = 1 */
3943                 } else {
3944                         low_direction &= ~nSRSTnOE;     /* nSRST input */
3945                         low_output    &= ~nSRST;        /* nSRST = 0 */
3946                 }
3947         } else {
3948                 LOG_ERROR("Unknown module type is detected: %.4x",
3949                         signalyzer_h_adapter_type);
3950                 return ERROR_JTAG_DEVICE_ERROR;
3951         }
3952
3953         /* initialize low byte of controller for jtag operation */
3954         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3955                 LOG_ERROR("couldn't initialize Signalyzer-H layout");
3956                 return ERROR_JTAG_INIT_FAILED;
3957         }
3958
3959 #if BUILD_FT2232_FTD2XX == 1
3960         if (ftdi_device == FT_DEVICE_2232H) {
3961                 /* initialize high byte of controller for jtag operation */
3962                 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3963                         LOG_ERROR("couldn't initialize Signalyzer-H layout");
3964                         return ERROR_JTAG_INIT_FAILED;
3965                 }
3966         }
3967 #elif BUILD_FT2232_LIBFTDI == 1
3968         if (ftdi_device == TYPE_2232H) {
3969                 /* initialize high byte of controller for jtag operation */
3970                 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3971                         LOG_ERROR("couldn't initialize Signalyzer-H layout");
3972                         return ERROR_JTAG_INIT_FAILED;
3973                 }
3974         }
3975 #endif
3976         return ERROR_OK;
3977 }
3978
3979 static void signalyzer_h_reset(int trst, int srst)
3980 {
3981         enum reset_types jtag_reset_config = jtag_get_reset_config();
3982
3983         /* ADAPTOR: EM_LT16_A */
3984         if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3985                 if (trst == 1) {
3986                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3987                                 /* switch to output pin (output is low) */
3988                                 low_direction |= nTRSTnOE;
3989                         else
3990                                 /* switch output low */
3991                                 low_output &= ~nTRST;
3992                 } else if (trst == 0) {
3993                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
3994                                 /* switch to input pin (high-Z + internal
3995                                  * and external pullup) */
3996                                 low_direction &= ~nTRSTnOE;
3997                         else
3998                                 /* switch output high */
3999                                 low_output |= nTRST;
4000                 }
4001
4002                 if (srst == 1) {
4003                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4004                                 /* switch output low */
4005                                 low_output &= ~nSRST;
4006                         else
4007                                 /* switch to output pin (output is low) */
4008                                 low_direction |= nSRSTnOE;
4009                 } else if (srst == 0) {
4010                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4011                                 /* switch output high */
4012                                 low_output |= nSRST;
4013                         else
4014                                 /* switch to input pin (high-Z) */
4015                                 low_direction &= ~nSRSTnOE;
4016                 }
4017
4018                 /* command "set data bits low byte" */
4019                 buffer_write(0x80);
4020                 buffer_write(low_output);
4021                 buffer_write(low_direction);
4022                 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
4023                         "low_direction: 0x%2.2x",
4024                         trst, srst, low_output, low_direction);
4025         }
4026         /* ADAPTOR: EM_ARM_JTAG,  EM_ARM_JTAG_P, EM_JTAG, EM_JTAG_P */
4027         else if ((signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG) ||
4028                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P) ||
4029                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG)  ||
4030                  (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_JTAG_P)) {
4031                 if (trst == 1) {
4032                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4033                                 high_output &= ~nTRSTnOE;
4034                         else
4035                                 high_output &= ~nTRST;
4036                 } else if (trst == 0) {
4037                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4038                                 high_output |= nTRSTnOE;
4039                         else
4040                                 high_output |= nTRST;
4041                 }
4042
4043                 if (srst == 1) {
4044                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4045                                 high_output &= ~nSRST;
4046                         else
4047                                 high_output &= ~nSRSTnOE;
4048                 } else if (srst == 0) {
4049                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4050                                 high_output |= nSRST;
4051                         else
4052                                 high_output |= nSRSTnOE;
4053                 }
4054
4055                 /* command "set data bits high byte" */
4056                 buffer_write(0x82);
4057                 buffer_write(high_output);
4058                 buffer_write(high_direction);
4059                 LOG_INFO("trst: %i, srst: %i, high_output: 0x%2.2x, "
4060                         "high_direction: 0x%2.2x",
4061                         trst, srst, high_output, high_direction);
4062         } else if (signalyzer_h_adapter_type == 0x0000) {
4063                 if (trst == 1) {
4064                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4065                                 /* switch to output pin (output is low) */
4066                                 low_direction |= nTRSTnOE;
4067                         else
4068                                 /* switch output low */
4069                                 low_output &= ~nTRST;
4070                 } else if (trst == 0) {
4071                         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4072                                 /* switch to input pin (high-Z + internal
4073                                  * and external pullup) */
4074                                 low_direction &= ~nTRSTnOE;
4075                         else
4076                                 /* switch output high */
4077                                 low_output |= nTRST;
4078                 }
4079
4080                 if (srst == 1) {
4081                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4082                                 /* switch output low */
4083                                 low_output &= ~nSRST;
4084                         else
4085                                 /* switch to output pin (output is low) */
4086                                 low_direction |= nSRSTnOE;
4087                 } else if (srst == 0) {
4088                         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4089                                 /* switch output high */
4090                                 low_output |= nSRST;
4091                         else
4092                                 /* switch to input pin (high-Z) */
4093                                 low_direction &= ~nSRSTnOE;
4094                 }
4095
4096                 /* command "set data bits low byte" */
4097                 buffer_write(0x80);
4098                 buffer_write(low_output);
4099                 buffer_write(low_direction);
4100                 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, "
4101                         "low_direction: 0x%2.2x",
4102                         trst, srst, low_output, low_direction);
4103         }
4104 }
4105
4106 static void signalyzer_h_blink(void)
4107 {
4108         signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_RED, 100, 0, 1);
4109 }
4110
4111 /********************************************************************
4112  * Support for KT-LINK
4113  * JTAG adapter from KRISTECH
4114  * http://www.kristech.eu
4115  *******************************************************************/
4116 static int ktlink_init(void)
4117 {
4118         uint8_t swd_en = 0x20;  /* 0x20 SWD disable, 0x00 SWD enable (ADBUS5) */
4119
4120         low_output    = 0x08 | swd_en;  /* value; TMS=1,TCK=0,TDI=0,SWD=swd_en */
4121         low_direction = 0x3B;           /* out=1; TCK/TDI/TMS=out,TDO=in,SWD=out,RTCK=in,SRSTIN=in */
4122
4123         /* initialize low byte for jtag */
4124         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
4125                 LOG_ERROR("couldn't initialize FT2232 with 'ktlink' layout");
4126                 return ERROR_JTAG_INIT_FAILED;
4127         }
4128
4129         nTRST    = 0x01;
4130         nSRST    = 0x02;
4131         nTRSTnOE = 0x04;
4132         nSRSTnOE = 0x08;
4133
4134         high_output    = 0x80;  /* turn LED on */
4135         high_direction = 0xFF;  /* all outputs */
4136
4137         enum reset_types jtag_reset_config = jtag_get_reset_config();
4138
4139         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
4140                 high_output |= nTRSTnOE;
4141                 high_output &= ~nTRST;
4142         } else {
4143                 high_output &= ~nTRSTnOE;
4144                 high_output |= nTRST;
4145         }
4146
4147         if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
4148                 high_output &= ~nSRSTnOE;
4149                 high_output |= nSRST;
4150         } else {
4151                 high_output |= nSRSTnOE;
4152                 high_output &= ~nSRST;
4153         }
4154
4155         /* initialize high byte for jtag */
4156         if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
4157                 LOG_ERROR("couldn't initialize FT2232 with 'ktlink' layout");
4158                 return ERROR_JTAG_INIT_FAILED;
4159         }
4160
4161         return ERROR_OK;
4162 }
4163
4164 static void ktlink_reset(int trst, int srst)
4165 {
4166         enum reset_types jtag_reset_config = jtag_get_reset_config();
4167
4168         if (trst == 1) {
4169                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4170                         high_output &= ~nTRSTnOE;
4171                 else
4172                         high_output &= ~nTRST;
4173         } else if (trst == 0) {
4174                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
4175                         high_output |= nTRSTnOE;
4176                 else
4177                         high_output |= nTRST;
4178         }
4179
4180         if (srst == 1) {
4181                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4182                         high_output &= ~nSRST;
4183                 else
4184                         high_output &= ~nSRSTnOE;
4185         } else if (srst == 0) {
4186                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
4187                         high_output |= nSRST;
4188                 else
4189                         high_output |= nSRSTnOE;
4190         }
4191
4192         buffer_write(0x82);     /* command "set data bits high byte" */
4193         buffer_write(high_output);
4194         buffer_write(high_direction);
4195         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
4196                 trst,
4197                 srst,
4198                 high_output,
4199                 high_direction);
4200 }
4201
4202 static void ktlink_blink(void)
4203 {
4204         /* LED connected to ACBUS7 */
4205         high_output ^= 0x80;
4206
4207         buffer_write(0x82);     /* command "set data bits high byte" */
4208         buffer_write(high_output);
4209         buffer_write(high_direction);
4210 }
4211
4212 /********************************************************************
4213  * Support for Digilent HS-1
4214  * JTAG adapter from Digilent
4215  * http://www.digilent.com
4216  * Author: Stephane Bonnet bonnetst@hds.utc.fr
4217  *******************************************************************/
4218
4219 static int digilent_hs1_init(void)
4220 {
4221         /* the adapter only supports the base JTAG signals, no nTRST
4222            nor nSRST */
4223         low_output      = 0x88;
4224         low_direction   = 0x8b;
4225
4226         /* initialize low byte for jtag */
4227         if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
4228                 LOG_ERROR("couldn't initialize FT2232 with 'digilent_hs1' layout");
4229                 return ERROR_JTAG_INIT_FAILED;
4230         }
4231         return ERROR_OK;
4232 }
4233
4234 static void digilent_hs1_reset(int trst, int srst)
4235 {
4236         /* Dummy function, no reset signals supported. */
4237 }
4238
4239 static const struct command_registration ft2232_command_handlers[] = {
4240         {
4241                 .name = "ft2232_device_desc",
4242                 .handler = &ft2232_handle_device_desc_command,
4243                 .mode = COMMAND_CONFIG,
4244                 .help = "set the USB device description of the FTDI FT2232 device",
4245                 .usage = "description_string",
4246         },
4247         {
4248                 .name = "ft2232_serial",
4249                 .handler = &ft2232_handle_serial_command,
4250                 .mode = COMMAND_CONFIG,
4251                 .help = "set the serial number of the FTDI FT2232 device",
4252                 .usage = "serial_string",
4253         },
4254         {
4255                 .name = "ft2232_layout",
4256                 .handler = &ft2232_handle_layout_command,
4257                 .mode = COMMAND_CONFIG,
4258                 .help = "set the layout of the FT2232 GPIO signals used "
4259                         "to control output-enables and reset signals",
4260                 .usage = "layout_name",
4261         },
4262         {
4263                 .name = "ft2232_vid_pid",
4264                 .handler = &ft2232_handle_vid_pid_command,
4265                 .mode = COMMAND_CONFIG,
4266                 .help = "the vendor ID and product ID of the FTDI FT2232 device",
4267                 .usage = "(vid pid)* ",
4268         },
4269         {
4270                 .name = "ft2232_latency",
4271                 .handler = &ft2232_handle_latency_command,
4272                 .mode = COMMAND_CONFIG,
4273                 .help = "set the FT2232 latency timer to a new value",
4274                 .usage = "value",
4275         },
4276         {
4277                 .name = "ft2232_channel",
4278                 .handler = &ft2232_handle_channel_command,
4279                 .mode = COMMAND_CONFIG,
4280                 .help = "set the FT2232 channel to a new value",
4281                 .usage = "value",
4282         },
4283         COMMAND_REGISTRATION_DONE
4284 };
4285
4286 struct jtag_interface ft2232_interface = {
4287         .name = "ft2232",
4288         .supported = DEBUG_CAP_TMS_SEQ,
4289         .commands = ft2232_command_handlers,
4290         .transports = jtag_only,
4291
4292         .init = ft2232_init,
4293         .quit = ft2232_quit,
4294         .speed = ft2232_speed,
4295         .speed_div = ft2232_speed_div,
4296         .khz = ft2232_khz,
4297         .execute_queue = ft2232_execute_queue,
4298 };