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