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