git.sur5r.net Git - openocd/blob - src/jtag/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 /* This code uses information contained in the MPSSE specification which was
  31  * found here:
  32  * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
  33  * Hereafter this is called the "MPSSE Spec".
  34  *
  35  * The datasheet for the ftdichip.com's FT2232D part is here:
  36  * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 #include "config.h"
  41 #endif
  42
  43 /* project specific includes */
  44 #include "interface.h"
  45 #include "commands.h"
  46 #include "time_support.h"
  47
  48 #if IS_CYGWIN == 1
  49 #include <windows.h>
  50 #endif
  51
  52 #include <assert.h>
  53
  54 #if (BUILD_FT2232_FTD2XX == 1 && BUILD_FT2232_LIBFTDI == 1)
  55 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
  56 #elif (BUILD_FT2232_FTD2XX != 1 && BUILD_FT2232_LIBFTDI != 1)
  57 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
  58 #endif
  59
  60 /* FT2232 access library includes */
  61 #if BUILD_FT2232_FTD2XX == 1
  62 #include <ftd2xx.h>
  63 #elif BUILD_FT2232_LIBFTDI == 1
  64 #include <ftdi.h>
  65 #endif
  66
  67 /* max TCK for the high speed devices 30000 kHz */
  68 #define FTDI_2232H_4232H_MAX_TCK        30000
  69 /* max TCK for the full speed devices 6000 kHz */
  70 #define FTDI_2232C_MAX_TCK 6000
  71 /* this speed value tells that RTCK is requested */
  72 #define RTCK_SPEED -1
  73
  74 #ifndef BUILD_FT2232_HIGHSPEED
  75  #if BUILD_FT2232_FTD2XX == 1
  76         enum { FT_DEVICE_2232H = 6, FT_DEVICE_4232H };
  77  #elif BUILD_FT2232_LIBFTDI == 1
  78         enum { TYPE_2232H = 4, TYPE_4232H = 5 };
  79  #endif
  80 #endif
  81
  82 static int ft2232_execute_queue(void);
  83 static int ft2232_speed(int speed);
  84 static int ft2232_speed_div(int speed, int* khz);
  85 static int ft2232_khz(int khz, int* jtag_speed);
  86 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
  87 static int ft2232_init(void);
  88 static int ft2232_quit(void);
  89
  90 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
  91 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
  92 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
  93 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
  94 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
  95
  96 /**
  97  * Send out \a num_cycles on the TCK line while the TAP(s) are in a
  98  * stable state.  Calling code must ensure that current state is stable,
  99  * that verification is not done in here.
 100  *
 101  * @param num_cycles The number of clocks cycles to send.
 102  * @param cmd The command to send.
 103  *
 104  * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
 105  */
 106 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
 107
 108 static char *       ft2232_device_desc_A = NULL;
 109 static char*        ft2232_device_desc = NULL;
 110 static char*        ft2232_serial  = NULL;
 111 static char*        ft2232_layout  = NULL;
 112 static uint8_t          ft2232_latency = 2;
 113 static unsigned         ft2232_max_tck = FTDI_2232C_MAX_TCK;
 114
 115 #define MAX_USB_IDS 8
 116 /* vid = pid = 0 marks the end of the list */
 117 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
 118 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
 119
 120 typedef struct ft2232_layout_s
 121 {
 122         char* name;
 123         int (*init)(void);
 124         void (*reset)(int trst, int srst);
 125         void (*blink)(void);
 126 } ft2232_layout_t;
 127
 128 /* init procedures for supported layouts */
 129 static int usbjtag_init(void);
 130 static int jtagkey_init(void);
 131 static int olimex_jtag_init(void);
 132 static int flyswatter_init(void);
 133 static int turtle_init(void);
 134 static int comstick_init(void);
 135 static int stm32stick_init(void);
 136 static int axm0432_jtag_init(void);
 137 static int sheevaplug_init(void);
 138 static int icebear_jtag_init(void);
 139 static int cortino_jtag_init(void);
 140
 141 /* reset procedures for supported layouts */
 142 static void usbjtag_reset(int trst, int srst);
 143 static void jtagkey_reset(int trst, int srst);
 144 static void olimex_jtag_reset(int trst, int srst);
 145 static void flyswatter_reset(int trst, int srst);
 146 static void turtle_reset(int trst, int srst);
 147 static void comstick_reset(int trst, int srst);
 148 static void stm32stick_reset(int trst, int srst);
 149 static void axm0432_jtag_reset(int trst, int srst);
 150 static void sheevaplug_reset(int trst, int srst);
 151 static void icebear_jtag_reset(int trst, int srst);
 152
 153 /* blink procedures for layouts that support a blinking led */
 154 static void olimex_jtag_blink(void);
 155 static void flyswatter_jtag_blink(void);
 156 static void turtle_jtag_blink(void);
 157
 158 static const ft2232_layout_t  ft2232_layouts[] =
 159 {
 160         { "usbjtag",              usbjtag_init,              usbjtag_reset,      NULL                    },
 161         { "jtagkey",              jtagkey_init,              jtagkey_reset,      NULL                    },
 162         { "jtagkey_prototype_v1", jtagkey_init,              jtagkey_reset,      NULL                    },
 163         { "oocdlink",             jtagkey_init,              jtagkey_reset,      NULL                    },
 164         { "signalyzer",           usbjtag_init,              usbjtag_reset,      NULL                    },
 165         { "evb_lm3s811",          usbjtag_init,              usbjtag_reset,      NULL                    },
 166         { "luminary_icdi",        usbjtag_init,              usbjtag_reset,      NULL                    },
 167         { "olimex-jtag",          olimex_jtag_init,          olimex_jtag_reset,  olimex_jtag_blink       },
 168         { "flyswatter",           flyswatter_init,           flyswatter_reset,   flyswatter_jtag_blink   },
 169         { "turtelizer2",          turtle_init,               turtle_reset,       turtle_jtag_blink       },
 170         { "comstick",             comstick_init,             comstick_reset,     NULL                    },
 171         { "stm32stick",           stm32stick_init,           stm32stick_reset,   NULL                    },
 172         { "axm0432_jtag",         axm0432_jtag_init,         axm0432_jtag_reset, NULL                    },
 173         { "sheevaplug",           sheevaplug_init,           sheevaplug_reset,   NULL                    },
 174         { "icebear",              icebear_jtag_init,         icebear_jtag_reset, NULL                    },
 175         { "cortino",              cortino_jtag_init,         comstick_reset, NULL                        },
 176         { NULL,                   NULL,                      NULL,               NULL                    },
 177 };
 178
 179 static uint8_t                  nTRST, nTRSTnOE, nSRST, nSRSTnOE;
 180
 181 static const ft2232_layout_t *layout;
 182 static uint8_t                  low_output     = 0x0;
 183 static uint8_t                  low_direction  = 0x0;
 184 static uint8_t                  high_output    = 0x0;
 185 static uint8_t                  high_direction = 0x0;
 186
 187 #if BUILD_FT2232_FTD2XX == 1
 188 static FT_HANDLE        ftdih = NULL;
 189 static FT_DEVICE        ftdi_device = 0;
 190 #elif BUILD_FT2232_LIBFTDI == 1
 191 static struct ftdi_context ftdic;
 192 static enum ftdi_chip_type ftdi_device;
 193 #endif
 194
 195 static jtag_command_t* first_unsent;        /* next command that has to be sent */
 196 static int             require_send;
 197
 198 /*      http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
 199
 200         "There is a significant difference between libftdi and libftd2xx. The latter
 201         one allows to schedule up to 64*64 bytes of result data while libftdi fails
 202         with more than 4*64. As a consequence, the FT2232 driver is forced to
 203         perform around 16x more USB transactions for long command streams with TDO
 204         capture when running with libftdi."
 205
 206         No idea how we get
 207         #define FT2232_BUFFER_SIZE 131072
 208         a comment would have been nice.
 209 */
 210
 211 #define FT2232_BUFFER_SIZE 131072
 212
 213 static uint8_t*             ft2232_buffer = NULL;
 214 static int             ft2232_buffer_size  = 0;
 215 static int             ft2232_read_pointer = 0;
 216 static int             ft2232_expect_read  = 0;
 217
 218 /**
 219  * Function buffer_write
 220  * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
 221  * @param val is the byte to send.
 222  */
 223 static inline void buffer_write(uint8_t val)
 224 {
 225         assert(ft2232_buffer);
 226         assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
 227         ft2232_buffer[ft2232_buffer_size++] = val;
 228 }
 229
 230 /**
 231  * Function buffer_read
 232  * returns a byte from the byte buffer.
 233  */
 234 static inline uint8_t buffer_read(void)
 235 {
 236         assert(ft2232_buffer);
 237         assert(ft2232_read_pointer < ft2232_buffer_size);
 238         return ft2232_buffer[ft2232_read_pointer++];
 239 }
 240
 241 /**
 242  * Clocks out \a bit_count bits on the TMS line, starting with the least
 243  * significant bit of tms_bits and progressing to more significant bits.
 244  * Rigorous state transition logging is done here via tap_set_state().
 245  *
 246  * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
 247  *      0x4b or 0x6b.  See the MPSSE spec referenced above for their
 248  *      functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
 249  *      is often used for this, 0x4b.
 250  *
 251  * @param tms_bits Holds the sequence of bits to send.
 252  * @param tms_count Tells how many bits in the sequence.
 253  * @param tdi_bit A single bit to pass on to TDI before the first TCK
 254  *      cycle and held static for the duration of TMS clocking.
 255  *
 256  * See the MPSSE spec referenced above.
 257  */
 258 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
 259 {
 260         uint8_t tms_byte;
 261         int     i;
 262         int     tms_ndx;                                /* bit index into tms_byte */
 263
 264         assert(tms_count > 0);
 265
 266         DEBUG_JTAG_IO("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d",
 267                         mpsse_cmd, tms_bits, tms_count);
 268
 269         for (tms_byte = tms_ndx = i = 0;   i < tms_count;   ++i, tms_bits>>=1)
 270         {
 271                 bool bit = tms_bits & 1;
 272
 273                 if (bit)
 274                         tms_byte |= (1 << tms_ndx);
 275
 276                 /* always do state transitions in public view */
 277                 tap_set_state(tap_state_transition(tap_get_state(), bit));
 278
 279                 /*      we wrote a bit to tms_byte just above, increment bit index.  if bit was zero
 280                         also increment.
 281                 */
 282                 ++tms_ndx;
 283
 284                 if (tms_ndx == 7  || i == tms_count-1)
 285                 {
 286                         buffer_write(mpsse_cmd);
 287                         buffer_write(tms_ndx - 1);
 288
 289                         /*      Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
 290                                 TMS/CS and is held static for the duration of TMS/CS clocking.
 291                         */
 292                         buffer_write(tms_byte | (tdi_bit << 7));
 293                 }
 294         }
 295 }
 296
 297 /**
 298  * Function get_tms_buffer_requirements
 299  * returns what clock_tms() will consume if called with
 300  * same \a bit_count.
 301  */
 302 static inline int get_tms_buffer_requirements(int bit_count)
 303 {
 304         return ((bit_count + 6)/7) * 3;
 305 }
 306
 307 /**
 308  * Function move_to_state
 309  * moves the TAP controller from the current state to a
 310  * \a goal_state through a path given by tap_get_tms_path().  State transition
 311  * logging is performed by delegation to clock_tms().
 312  *
 313  * @param goal_state is the destination state for the move.
 314  */
 315 static void move_to_state(tap_state_t goal_state)
 316 {
 317         tap_state_t     start_state = tap_get_state();
 318
 319         /*      goal_state is 1/2 of a tuple/pair of states which allow convenient
 320                 lookup of the required TMS pattern to move to this state from the
 321                 start state.
 322         */
 323
 324         /* do the 2 lookups */
 325         int tms_bits  = tap_get_tms_path(start_state, goal_state);
 326         int tms_count = tap_get_tms_path_len(start_state, goal_state);
 327
 328         DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
 329
 330         clock_tms(0x4b,  tms_bits, tms_count, 0);
 331 }
 332
 333 jtag_interface_t ft2232_interface =
 334 {
 335         .name                   = "ft2232",
 336         .execute_queue          = ft2232_execute_queue,
 337         .speed                  = ft2232_speed,
 338         .speed_div              = ft2232_speed_div,
 339         .khz                    = ft2232_khz,
 340         .register_commands      = ft2232_register_commands,
 341         .init                   = ft2232_init,
 342         .quit                   = ft2232_quit,
 343 };
 344
 345 static int ft2232_write(uint8_t* buf, int size, uint32_t* bytes_written)
 346 {
 347 #if BUILD_FT2232_FTD2XX == 1
 348         FT_STATUS status;
 349         DWORD dw_bytes_written;
 350         if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
 351         {
 352                 *bytes_written = dw_bytes_written;
 353                 LOG_ERROR("FT_Write returned: %lu", status);
 354                 return ERROR_JTAG_DEVICE_ERROR;
 355         }
 356         else
 357         {
 358                 *bytes_written = dw_bytes_written;
 359                 return ERROR_OK;
 360         }
 361 #elif BUILD_FT2232_LIBFTDI == 1
 362         int retval;
 363         if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
 364         {
 365                 *bytes_written = 0;
 366                 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
 367                 return ERROR_JTAG_DEVICE_ERROR;
 368         }
 369         else
 370         {
 371                 *bytes_written = retval;
 372                 return ERROR_OK;
 373         }
 374 #endif
 375 }
 376
 377 static int ft2232_read(uint8_t* buf, uint32_t size, uint32_t* bytes_read)
 378 {
 379 #if BUILD_FT2232_FTD2XX == 1
 380         DWORD dw_bytes_read;
 381         FT_STATUS status;
 382         int timeout = 5;
 383         *bytes_read = 0;
 384
 385         while ((*bytes_read < size) && timeout--)
 386         {
 387                 if ((status = FT_Read(ftdih, buf + *bytes_read, size -
 388                                           *bytes_read, &dw_bytes_read)) != FT_OK)
 389                 {
 390                         *bytes_read = 0;
 391                         LOG_ERROR("FT_Read returned: %lu", status);
 392                         return ERROR_JTAG_DEVICE_ERROR;
 393                 }
 394                 *bytes_read += dw_bytes_read;
 395         }
 396
 397 #elif BUILD_FT2232_LIBFTDI == 1
 398         int retval;
 399         int timeout = 100;
 400         *bytes_read = 0;
 401
 402         while ((*bytes_read < size) && timeout--)
 403         {
 404                 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
 405                 {
 406                         *bytes_read = 0;
 407                         LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
 408                         return ERROR_JTAG_DEVICE_ERROR;
 409                 }
 410                 *bytes_read += retval;
 411         }
 412
 413 #endif
 414
 415         if (*bytes_read < size)
 416         {
 417                 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)",
 418                           (unsigned int)(*bytes_read),
 419                           (unsigned int)size);
 420                 return ERROR_JTAG_DEVICE_ERROR;
 421         }
 422
 423         return ERROR_OK;
 424 }
 425
 426 static bool ft2232_device_is_highspeed(void)
 427 {
 428 #if BUILD_FT2232_FTD2XX == 1
 429         return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H);
 430 #elif BUILD_FT2232_LIBFTDI == 1
 431         return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H);
 432 #endif
 433 }
 434
 435 /*
 436  * Commands that only apply to the FT2232H and FT4232H devices.
 437  * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
 438  * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
 439  */
 440
 441 static int ft2232h_ft4232h_adaptive_clocking(bool enable)
 442 {
 443         uint8_t buf = enable ? 0x96 : 0x97;
 444         LOG_DEBUG("%2.2x", buf);
 445
 446         uint32_t bytes_written;
 447         int retval = ft2232_write(&buf, 1, &bytes_written);
 448         if ((ERROR_OK != retval) || (bytes_written != 1))
 449         {
 450                 LOG_ERROR("couldn't write command to %s adaptive clocking"
 451                         , enable ? "enable" : "disable");
 452                 return retval;
 453         }
 454
 455         return ERROR_OK;
 456 }
 457
 458 /**
 459  * Enable/disable the clk divide by 5 of the 60MHz master clock.
 460  * This result in a JTAG clock speed range of 91.553Hz-6MHz
 461  * respective 457.763Hz-30MHz.
 462  */
 463 static int ft2232h_ft4232h_clk_divide_by_5(bool enable)
 464 {
 465         uint32_t bytes_written;
 466         uint8_t buf = enable ?  0x8b : 0x8a;
 467         int retval = ft2232_write(&buf, 1, &bytes_written);
 468         if ((ERROR_OK != retval) || (bytes_written != 1))
 469         {
 470                 LOG_ERROR("couldn't write command to %s clk divide by 5"
 471                         , enable ? "enable" : "disable");
 472                 return ERROR_JTAG_INIT_FAILED;
 473         }
 474         ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_2232H_4232H_MAX_TCK;
 475         LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
 476
 477         return ERROR_OK;
 478 }
 479
 480 static int ft2232_speed(int speed)
 481 {
 482         uint8_t buf[3];
 483         int retval;
 484         uint32_t bytes_written;
 485
 486         retval = ERROR_OK;
 487         bool enable_adaptive_clocking = (RTCK_SPEED == speed);
 488         if (ft2232_device_is_highspeed())
 489                 retval = ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking);
 490         else if (enable_adaptive_clocking)
 491         {
 492                 LOG_ERROR("ft2232 device %lu does not support RTCK"
 493                         , (long unsigned int)ftdi_device);
 494                 return ERROR_FAIL;
 495         }
 496
 497         if ((enable_adaptive_clocking) || (ERROR_OK != retval))
 498                 return retval;
 499
 500         buf[0] = 0x86;                                  /* command "set divisor" */
 501         buf[1] = speed & 0xff;                  /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
 502         buf[2] = (speed >> 8) & 0xff;   /* valueH */
 503
 504         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
 505         if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
 506         {
 507                 LOG_ERROR("couldn't set FT2232 TCK speed");
 508                 return retval;
 509         }
 510
 511         return ERROR_OK;
 512 }
 513
 514 static int ft2232_speed_div(int speed, int* khz)
 515 {
 516         /* Take a look in the FT2232 manual,
 517          * AN2232C-01 Command Processor for
 518          * MPSSE and MCU Host Bus. Chapter 3.8 */
 519
 520         *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
 521
 522         return ERROR_OK;
 523 }
 524
 525 static int ft2232_khz(int khz, int* jtag_speed)
 526 {
 527         if (khz == 0)
 528         {
 529                 if (ft2232_device_is_highspeed())
 530                 {
 531                         *jtag_speed = RTCK_SPEED;
 532                         return ERROR_OK;
 533                 }
 534                 else
 535                 {
 536                         LOG_DEBUG("RCLK not supported");
 537                         return ERROR_FAIL;
 538                 }
 539         }
 540
 541         /* Take a look in the FT2232 manual,
 542          * AN2232C-01 Command Processor for
 543          * MPSSE and MCU Host Bus. Chapter 3.8
 544          *
 545          * We will calc here with a multiplier
 546          * of 10 for better rounding later. */
 547
 548         /* Calc speed, (ft2232_max_tck / khz) - 1 */
 549         /* Use 65000 for better rounding */
 550         *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
 551
 552         /* Add 0.9 for rounding */
 553         *jtag_speed += 9;
 554
 555         /* Calc real speed */
 556         *jtag_speed = *jtag_speed / 10;
 557
 558         /* Check if speed is greater than 0 */
 559         if (*jtag_speed < 0)
 560         {
 561                 *jtag_speed = 0;
 562         }
 563
 564         /* Check max value */
 565         if (*jtag_speed > 0xFFFF)
 566         {
 567                 *jtag_speed = 0xFFFF;
 568         }
 569
 570         return ERROR_OK;
 571 }
 572
 573 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
 574 {
 575         register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
 576                         COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
 577         register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
 578                         COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
 579         register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
 580                         COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
 581         register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
 582                         COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
 583         register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
 584                         COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
 585         return ERROR_OK;
 586 }
 587
 588 static void ft2232_end_state(tap_state_t state)
 589 {
 590         if (tap_is_state_stable(state))
 591                 tap_set_end_state(state);
 592         else
 593         {
 594                 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
 595                 exit(-1);
 596         }
 597 }
 598
 599 static void ft2232_read_scan(enum scan_type type, uint8_t* buffer, int scan_size)
 600 {
 601         int num_bytes = (scan_size + 7) / 8;
 602         int bits_left = scan_size;
 603         int cur_byte  = 0;
 604
 605         while (num_bytes-- > 1)
 606         {
 607                 buffer[cur_byte++] = buffer_read();
 608                 bits_left -= 8;
 609         }
 610
 611         buffer[cur_byte] = 0x0;
 612
 613         /* There is one more partial byte left from the clock data in/out instructions */
 614         if (bits_left > 1)
 615         {
 616                 buffer[cur_byte] = buffer_read() >> 1;
 617         }
 618         /* 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 */
 619         buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
 620 }
 621
 622 static void ft2232_debug_dump_buffer(void)
 623 {
 624         int i;
 625         char line[256];
 626         char* line_p = line;
 627
 628         for (i = 0; i < ft2232_buffer_size; i++)
 629         {
 630                 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
 631                 if (i % 16 == 15)
 632                 {
 633                         LOG_DEBUG("%s", line);
 634                         line_p = line;
 635                 }
 636         }
 637
 638         if (line_p != line)
 639                 LOG_DEBUG("%s", line);
 640 }
 641
 642 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
 643 {
 644         jtag_command_t* cmd;
 645         uint8_t* buffer;
 646         int scan_size;
 647         enum scan_type  type;
 648         int retval;
 649         uint32_t bytes_written = 0;
 650         uint32_t bytes_read = 0;
 651
 652 #ifdef _DEBUG_USB_IO_
 653         struct timeval  start, inter, inter2, end;
 654         struct timeval  d_inter, d_inter2, d_end;
 655 #endif
 656
 657 #ifdef _DEBUG_USB_COMMS_
 658         LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
 659         ft2232_debug_dump_buffer();
 660 #endif
 661
 662 #ifdef _DEBUG_USB_IO_
 663         gettimeofday(&start, NULL);
 664 #endif
 665
 666         if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
 667         {
 668                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
 669                 return retval;
 670         }
 671
 672 #ifdef _DEBUG_USB_IO_
 673         gettimeofday(&inter, NULL);
 674 #endif
 675
 676         if (ft2232_expect_read)
 677         {
 678                 int timeout = 100;
 679                 ft2232_buffer_size = 0;
 680
 681 #ifdef _DEBUG_USB_IO_
 682                 gettimeofday(&inter2, NULL);
 683 #endif
 684
 685                 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
 686                 {
 687                         LOG_ERROR("couldn't read from FT2232");
 688                         return retval;
 689                 }
 690
 691 #ifdef _DEBUG_USB_IO_
 692                 gettimeofday(&end, NULL);
 693
 694                 timeval_subtract(&d_inter, &inter, &start);
 695                 timeval_subtract(&d_inter2, &inter2, &start);
 696                 timeval_subtract(&d_end, &end, &start);
 697
 698                 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
 699                         (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
 700                         (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
 701                         (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
 702 #endif
 703
 704                 ft2232_buffer_size = bytes_read;
 705
 706                 if (ft2232_expect_read != ft2232_buffer_size)
 707                 {
 708                         LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
 709                                         ft2232_buffer_size,
 710                                         100 - timeout);
 711                         ft2232_debug_dump_buffer();
 712
 713                         exit(-1);
 714                 }
 715
 716 #ifdef _DEBUG_USB_COMMS_
 717                 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
 718                 ft2232_debug_dump_buffer();
 719 #endif
 720         }
 721
 722         ft2232_expect_read  = 0;
 723         ft2232_read_pointer = 0;
 724
 725         /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
 726          * that wasn't handled by a caller-provided error handler
 727          */
 728         retval = ERROR_OK;
 729
 730         cmd = first;
 731         while (cmd != last)
 732         {
 733                 switch (cmd->type)
 734                 {
 735                 case JTAG_SCAN:
 736                         type = jtag_scan_type(cmd->cmd.scan);
 737                         if (type != SCAN_OUT)
 738                         {
 739                                 scan_size = jtag_scan_size(cmd->cmd.scan);
 740                                 buffer    = calloc(CEIL(scan_size, 8), 1);
 741                                 ft2232_read_scan(type, buffer, scan_size);
 742                                 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
 743                                         retval = ERROR_JTAG_QUEUE_FAILED;
 744                                 free(buffer);
 745                         }
 746                         break;
 747
 748                 default:
 749                         break;
 750                 }
 751
 752                 cmd = cmd->next;
 753         }
 754
 755         ft2232_buffer_size = 0;
 756
 757         return retval;
 758 }
 759
 760 /**
 761  * Function ft2232_add_pathmove
 762  * moves the TAP controller from the current state to a new state through the
 763  * given path, where path is an array of tap_state_t's.
 764  *
 765  * @param path is an array of tap_stat_t which gives the states to traverse through
 766  *   ending with the last state at path[num_states-1]
 767  * @param num_states is the count of state steps to move through
 768  */
 769 static void ft2232_add_pathmove(tap_state_t* path, int num_states)
 770 {
 771         int state_count = 0;
 772
 773         assert((unsigned) num_states <= 32u);           /* tms_bits only holds 32 bits */
 774
 775         DEBUG_JTAG_IO("-");
 776
 777         /* this loop verifies that the path is legal and logs each state in the path */
 778         while (num_states)
 779         {
 780                 unsigned char   tms_byte = 0;       /* zero this on each MPSSE batch */
 781                 int             bit_count = 0;
 782                 int             num_states_batch = num_states > 7 ? 7 : num_states;
 783
 784                 /* command "Clock Data to TMS/CS Pin (no Read)" */
 785                 buffer_write(0x4b);
 786
 787                 /* number of states remaining */
 788                 buffer_write(num_states_batch - 1);
 789
 790                 while (num_states_batch--) {
 791                         /* either TMS=0 or TMS=1 must work ... */
 792                         if (tap_state_transition(tap_get_state(), false)
 793                                                 == path[state_count])
 794                                 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
 795                         else if (tap_state_transition(tap_get_state(), true)
 796                                                 == path[state_count])
 797                                 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
 798
 799                         /* ... or else the caller goofed BADLY */
 800                         else {
 801                                 LOG_ERROR("BUG: %s -> %s isn't a valid "
 802                                                 "TAP state transition",
 803                                         tap_state_name(tap_get_state()),
 804                                         tap_state_name(path[state_count]));
 805                                 exit(-1);
 806                         }
 807
 808                         tap_set_state(path[state_count]);
 809                         state_count++;
 810                         num_states--;
 811                 }
 812
 813                 buffer_write(tms_byte);
 814         }
 815         tap_set_end_state(tap_get_state());
 816 }
 817
 818 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t* buffer, int scan_size)
 819 {
 820         int num_bytes = (scan_size + 7) / 8;
 821         int bits_left = scan_size;
 822         int cur_byte  = 0;
 823         int last_bit;
 824
 825         if (!ir_scan)
 826         {
 827                 if (tap_get_state() != TAP_DRSHIFT)
 828                 {
 829                         move_to_state(TAP_DRSHIFT);
 830                 }
 831         }
 832         else
 833         {
 834                 if (tap_get_state() != TAP_IRSHIFT)
 835                 {
 836                         move_to_state(TAP_IRSHIFT);
 837                 }
 838         }
 839
 840         /* add command for complete bytes */
 841         while (num_bytes > 1)
 842         {
 843                 int thisrun_bytes;
 844                 if (type == SCAN_IO)
 845                 {
 846                         /* Clock Data Bytes In and Out LSB First */
 847                         buffer_write(0x39);
 848                         /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
 849                 }
 850                 else if (type == SCAN_OUT)
 851                 {
 852                         /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
 853                         buffer_write(0x19);
 854                         /* LOG_DEBUG("added TDI bytes (o)"); */
 855                 }
 856                 else if (type == SCAN_IN)
 857                 {
 858                         /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
 859                         buffer_write(0x28);
 860                         /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
 861                 }
 862
 863                 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
 864                 num_bytes    -= thisrun_bytes;
 865
 866                 buffer_write((uint8_t) (thisrun_bytes - 1));
 867                 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
 868
 869                 if (type != SCAN_IN)
 870                 {
 871                         /* add complete bytes */
 872                         while (thisrun_bytes-- > 0)
 873                         {
 874                                 buffer_write(buffer[cur_byte++]);
 875                                 bits_left -= 8;
 876                         }
 877                 }
 878                 else /* (type == SCAN_IN) */
 879                 {
 880                         bits_left -= 8 * (thisrun_bytes);
 881                 }
 882         }
 883
 884         /* the most signifcant bit is scanned during TAP movement */
 885         if (type != SCAN_IN)
 886                 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
 887         else
 888                 last_bit = 0;
 889
 890         /* process remaining bits but the last one */
 891         if (bits_left > 1)
 892         {
 893                 if (type == SCAN_IO)
 894                 {
 895                         /* Clock Data Bits In and Out LSB First */
 896                         buffer_write(0x3b);
 897                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
 898                 }
 899                 else if (type == SCAN_OUT)
 900                 {
 901                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
 902                         buffer_write(0x1b);
 903                         /* LOG_DEBUG("added TDI bits (o)"); */
 904                 }
 905                 else if (type == SCAN_IN)
 906                 {
 907                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
 908                         buffer_write(0x2a);
 909                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
 910                 }
 911
 912                 buffer_write(bits_left - 2);
 913                 if (type != SCAN_IN)
 914                         buffer_write(buffer[cur_byte]);
 915         }
 916
 917         if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
 918           || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT)))
 919         {
 920                 if (type == SCAN_IO)
 921                 {
 922                         /* Clock Data Bits In and Out LSB First */
 923                         buffer_write(0x3b);
 924                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
 925                 }
 926                 else if (type == SCAN_OUT)
 927                 {
 928                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
 929                         buffer_write(0x1b);
 930                         /* LOG_DEBUG("added TDI bits (o)"); */
 931                 }
 932                 else if (type == SCAN_IN)
 933                 {
 934                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
 935                         buffer_write(0x2a);
 936                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
 937                 }
 938                 buffer_write(0x0);
 939                 buffer_write(last_bit);
 940         }
 941         else
 942         {
 943                 int tms_bits;
 944                 int tms_count;
 945                 uint8_t mpsse_cmd;
 946
 947                 /* move from Shift-IR/DR to end state */
 948                 if (type != SCAN_OUT)
 949                 {
 950                         /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
 951                         /* This must be coordinated with the bit shifts in ft2232_read_scan    */
 952                         tms_bits  = 0x01;
 953                         tms_count = 2;
 954                         /* Clock Data to TMS/CS Pin with Read */
 955                         mpsse_cmd = 0x6b;
 956                 }
 957                 else
 958                 {
 959                         tms_bits  = tap_get_tms_path(tap_get_state(), tap_get_end_state());
 960                         tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
 961                         /* Clock Data to TMS/CS Pin (no Read) */
 962                         mpsse_cmd = 0x4b;
 963                 }
 964
 965                 DEBUG_JTAG_IO("finish %s", (type == SCAN_OUT) ? "without read" : "via PAUSE");
 966                 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
 967         }
 968
 969         if (tap_get_state() != tap_get_end_state())
 970         {
 971                 move_to_state(tap_get_end_state());
 972         }
 973 }
 974
 975 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
 976 {
 977         int num_bytes = (scan_size + 7) / 8;
 978         int bits_left = scan_size;
 979         int cur_byte  = 0;
 980         int last_bit;
 981         uint8_t* receive_buffer  = malloc(CEIL(scan_size, 8));
 982         uint8_t* receive_pointer = receive_buffer;
 983         uint32_t bytes_written;
 984         uint32_t bytes_read;
 985         int retval;
 986         int thisrun_read = 0;
 987
 988         if (cmd->ir_scan)
 989         {
 990                 LOG_ERROR("BUG: large IR scans are not supported");
 991                 exit(-1);
 992         }
 993
 994         if (tap_get_state() != TAP_DRSHIFT)
 995         {
 996                 move_to_state(TAP_DRSHIFT);
 997         }
 998
 999         if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1000         {
1001                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1002                 exit(-1);
1003         }
1004         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1005                   ft2232_buffer_size, (int)bytes_written);
1006         ft2232_buffer_size = 0;
1007
1008         /* add command for complete bytes */
1009         while (num_bytes > 1)
1010         {
1011                 int thisrun_bytes;
1012
1013                 if (type == SCAN_IO)
1014                 {
1015                         /* Clock Data Bytes In and Out LSB First */
1016                         buffer_write(0x39);
1017                         /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1018                 }
1019                 else if (type == SCAN_OUT)
1020                 {
1021                         /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1022                         buffer_write(0x19);
1023                         /* LOG_DEBUG("added TDI bytes (o)"); */
1024                 }
1025                 else if (type == SCAN_IN)
1026                 {
1027                         /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1028                         buffer_write(0x28);
1029                         /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1030                 }
1031
1032                 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1033                 thisrun_read  = thisrun_bytes;
1034                 num_bytes    -= thisrun_bytes;
1035                 buffer_write((uint8_t) (thisrun_bytes - 1));
1036                 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1037
1038                 if (type != SCAN_IN)
1039                 {
1040                         /* add complete bytes */
1041                         while (thisrun_bytes-- > 0)
1042                         {
1043                                 buffer_write(buffer[cur_byte]);
1044                                 cur_byte++;
1045                                 bits_left -= 8;
1046                         }
1047                 }
1048                 else /* (type == SCAN_IN) */
1049                 {
1050                         bits_left -= 8 * (thisrun_bytes);
1051                 }
1052
1053                 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1054                 {
1055                         LOG_ERROR("couldn't write MPSSE commands to FT2232");
1056                         exit(-1);
1057                 }
1058                 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1059                           ft2232_buffer_size,
1060                           (int)bytes_written);
1061                 ft2232_buffer_size = 0;
1062
1063                 if (type != SCAN_OUT)
1064                 {
1065                         if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1066                         {
1067                                 LOG_ERROR("couldn't read from FT2232");
1068                                 exit(-1);
1069                         }
1070                         LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1071                                   thisrun_read,
1072                                   (int)bytes_read);
1073                         receive_pointer += bytes_read;
1074                 }
1075         }
1076
1077         thisrun_read = 0;
1078
1079         /* the most signifcant bit is scanned during TAP movement */
1080         if (type != SCAN_IN)
1081                 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1082         else
1083                 last_bit = 0;
1084
1085         /* process remaining bits but the last one */
1086         if (bits_left > 1)
1087         {
1088                 if (type == SCAN_IO)
1089                 {
1090                         /* Clock Data Bits In and Out LSB First */
1091                         buffer_write(0x3b);
1092                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1093                 }
1094                 else if (type == SCAN_OUT)
1095                 {
1096                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1097                         buffer_write(0x1b);
1098                         /* LOG_DEBUG("added TDI bits (o)"); */
1099                 }
1100                 else if (type == SCAN_IN)
1101                 {
1102                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1103                         buffer_write(0x2a);
1104                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1105                 }
1106                 buffer_write(bits_left - 2);
1107                 if (type != SCAN_IN)
1108                         buffer_write(buffer[cur_byte]);
1109
1110                 if (type != SCAN_OUT)
1111                         thisrun_read += 2;
1112         }
1113
1114         if (tap_get_end_state() == TAP_DRSHIFT)
1115         {
1116                 if (type == SCAN_IO)
1117                 {
1118                         /* Clock Data Bits In and Out LSB First */
1119                         buffer_write(0x3b);
1120                         /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1121                 }
1122                 else if (type == SCAN_OUT)
1123                 {
1124                         /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1125                         buffer_write(0x1b);
1126                         /* LOG_DEBUG("added TDI bits (o)"); */
1127                 }
1128                 else if (type == SCAN_IN)
1129                 {
1130                         /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1131                         buffer_write(0x2a);
1132                         /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1133                 }
1134                 buffer_write(0x0);
1135                 buffer_write(last_bit);
1136         }
1137         else
1138         {
1139                 int tms_bits  = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1140                 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1141                 uint8_t mpsse_cmd;
1142
1143                 /* move from Shift-IR/DR to end state */
1144                 if (type != SCAN_OUT)
1145                 {
1146                         /* Clock Data to TMS/CS Pin with Read */
1147                         mpsse_cmd = 0x6b;
1148                         /* LOG_DEBUG("added TMS scan (read)"); */
1149                 }
1150                 else
1151                 {
1152                         /* Clock Data to TMS/CS Pin (no Read) */
1153                         mpsse_cmd = 0x4b;
1154                         /* LOG_DEBUG("added TMS scan (no read)"); */
1155                 }
1156
1157                 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1158                 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1159         }
1160
1161         if (type != SCAN_OUT)
1162                 thisrun_read += 1;
1163
1164         if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1165         {
1166                 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1167                 exit(-1);
1168         }
1169         LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1170                   ft2232_buffer_size,
1171                   (int)bytes_written);
1172         ft2232_buffer_size = 0;
1173
1174         if (type != SCAN_OUT)
1175         {
1176                 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1177                 {
1178                         LOG_ERROR("couldn't read from FT2232");
1179                         exit(-1);
1180                 }
1181                 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1182                           thisrun_read,
1183                           (int)bytes_read);
1184                 receive_pointer += bytes_read;
1185         }
1186
1187         return ERROR_OK;
1188 }
1189
1190 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1191 {
1192         int predicted_size = 3;
1193         int num_bytes = (scan_size - 1) / 8;
1194
1195         if (tap_get_state() != TAP_DRSHIFT)
1196                 predicted_size += get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1197
1198         if (type == SCAN_IN)    /* only from device to host */
1199         {
1200                 /* complete bytes */
1201                 predicted_size += CEIL(num_bytes, 65536) * 3;
1202
1203                 /* remaining bits - 1 (up to 7) */
1204                 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1205         }
1206         else    /* host to device, or bidirectional */
1207         {
1208                 /* complete bytes */
1209                 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
1210
1211                 /* remaining bits -1 (up to 7) */
1212                 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1213         }
1214
1215         return predicted_size;
1216 }
1217
1218 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1219 {
1220         int predicted_size = 0;
1221
1222         if (type != SCAN_OUT)
1223         {
1224                 /* complete bytes */
1225                 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
1226
1227                 /* remaining bits - 1 */
1228                 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1229
1230                 /* last bit (from TMS scan) */
1231                 predicted_size += 1;
1232         }
1233
1234         /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1235
1236         return predicted_size;
1237 }
1238
1239 static void usbjtag_reset(int trst, int srst)
1240 {
1241         enum reset_types jtag_reset_config = jtag_get_reset_config();
1242         if (trst == 1)
1243         {
1244                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1245                         low_direction |= nTRSTnOE;      /* switch to output pin (output is low) */
1246                 else
1247                         low_output &= ~nTRST;           /* switch output low */
1248         }
1249         else if (trst == 0)
1250         {
1251                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1252                         low_direction &= ~nTRSTnOE;     /* switch to input pin (high-Z + internal and external pullup) */
1253                 else
1254                         low_output |= nTRST;            /* switch output high */
1255         }
1256
1257         if (srst == 1)
1258         {
1259                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1260                         low_output &= ~nSRST;           /* switch output low */
1261                 else
1262                         low_direction |= nSRSTnOE;      /* switch to output pin (output is low) */
1263         }
1264         else if (srst == 0)
1265         {
1266                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1267                         low_output |= nSRST;            /* switch output high */
1268                 else
1269                         low_direction &= ~nSRSTnOE;     /* switch to input pin (high-Z) */
1270         }
1271
1272         /* command "set data bits low byte" */
1273         buffer_write(0x80);
1274         buffer_write(low_output);
1275         buffer_write(low_direction);
1276 }
1277
1278 static void jtagkey_reset(int trst, int srst)
1279 {
1280         enum reset_types jtag_reset_config = jtag_get_reset_config();
1281         if (trst == 1)
1282         {
1283                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1284                         high_output &= ~nTRSTnOE;
1285                 else
1286                         high_output &= ~nTRST;
1287         }
1288         else if (trst == 0)
1289         {
1290                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1291                         high_output |= nTRSTnOE;
1292                 else
1293                         high_output |= nTRST;
1294         }
1295
1296         if (srst == 1)
1297         {
1298                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1299                         high_output &= ~nSRST;
1300                 else
1301                         high_output &= ~nSRSTnOE;
1302         }
1303         else if (srst == 0)
1304         {
1305                 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1306                         high_output |= nSRST;
1307                 else
1308                         high_output |= nSRSTnOE;
1309         }
1310
1311         /* command "set data bits high byte" */
1312         buffer_write(0x82);
1313         buffer_write(high_output);
1314         buffer_write(high_direction);
1315         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1316                         high_direction);
1317 }
1318
1319 static void olimex_jtag_reset(int trst, int srst)
1320 {
1321         enum reset_types jtag_reset_config = jtag_get_reset_config();
1322         if (trst == 1)
1323         {
1324                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1325                         high_output &= ~nTRSTnOE;
1326                 else
1327                         high_output &= ~nTRST;
1328         }
1329         else if (trst == 0)
1330         {
1331                 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1332                         high_output |= nTRSTnOE;
1333                 else
1334                         high_output |= nTRST;
1335         }
1336
1337         if (srst == 1)
1338         {
1339                 high_output |= nSRST;
1340         }
1341         else if (srst == 0)
1342         {
1343                 high_output &= ~nSRST;
1344         }
1345
1346         /* command "set data bits high byte" */
1347         buffer_write(0x82);
1348         buffer_write(high_output);
1349         buffer_write(high_direction);
1350         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1351                         high_direction);
1352 }
1353
1354 static void axm0432_jtag_reset(int trst, int srst)
1355 {
1356         if (trst == 1)
1357         {
1358                 tap_set_state(TAP_RESET);
1359                 high_output &= ~nTRST;
1360         }
1361         else if (trst == 0)
1362         {
1363                 high_output |= nTRST;
1364         }
1365
1366         if (srst == 1)
1367         {
1368                 high_output &= ~nSRST;
1369         }
1370         else if (srst == 0)
1371         {
1372                 high_output |= nSRST;
1373         }
1374
1375         /* command "set data bits low byte" */
1376         buffer_write(0x82);
1377         buffer_write(high_output);
1378         buffer_write(high_direction);
1379         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1380                         high_direction);
1381 }
1382
1383 static void flyswatter_reset(int trst, int srst)
1384 {
1385         if (trst == 1)
1386         {
1387                 low_output &= ~nTRST;
1388         }
1389         else if (trst == 0)
1390         {
1391                 low_output |= nTRST;
1392         }
1393
1394         if (srst == 1)
1395         {
1396                 low_output |= nSRST;
1397         }
1398         else if (srst == 0)
1399         {
1400                 low_output &= ~nSRST;
1401         }
1402
1403         /* command "set data bits low byte" */
1404         buffer_write(0x80);
1405         buffer_write(low_output);
1406         buffer_write(low_direction);
1407         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1408 }
1409
1410 static void turtle_reset(int trst, int srst)
1411 {
1412         trst = trst;
1413
1414         if (srst == 1)
1415         {
1416                 low_output |= nSRST;
1417         }
1418         else if (srst == 0)
1419         {
1420                 low_output &= ~nSRST;
1421         }
1422
1423         /* command "set data bits low byte" */
1424         buffer_write(0x80);
1425         buffer_write(low_output);
1426         buffer_write(low_direction);
1427         LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1428 }
1429
1430 static void comstick_reset(int trst, int srst)
1431 {
1432         if (trst == 1)
1433         {
1434                 high_output &= ~nTRST;
1435         }
1436         else if (trst == 0)
1437         {
1438                 high_output |= nTRST;
1439         }
1440
1441         if (srst == 1)
1442         {
1443                 high_output &= ~nSRST;
1444         }
1445         else if (srst == 0)
1446         {
1447                 high_output |= nSRST;
1448         }
1449
1450         /* command "set data bits high byte" */
1451         buffer_write(0x82);
1452         buffer_write(high_output);
1453         buffer_write(high_direction);
1454         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1455                         high_direction);
1456 }
1457
1458 static void stm32stick_reset(int trst, int srst)
1459 {
1460         if (trst == 1)
1461         {
1462                 high_output &= ~nTRST;
1463         }
1464         else if (trst == 0)
1465         {
1466                 high_output |= nTRST;
1467         }
1468
1469         if (srst == 1)
1470         {
1471                 low_output &= ~nSRST;
1472         }
1473         else if (srst == 0)
1474         {
1475                 low_output |= nSRST;
1476         }
1477
1478         /* command "set data bits low byte" */
1479         buffer_write(0x80);
1480         buffer_write(low_output);
1481         buffer_write(low_direction);
1482
1483         /* command "set data bits high byte" */
1484         buffer_write(0x82);
1485         buffer_write(high_output);
1486         buffer_write(high_direction);
1487         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1488                         high_direction);
1489 }
1490
1491 static void sheevaplug_reset(int trst, int srst)
1492 {
1493         if (trst == 1)
1494                 high_output &= ~nTRST;
1495         else if (trst == 0)
1496                 high_output |= nTRST;
1497
1498         if (srst == 1)
1499                 high_output &= ~nSRSTnOE;
1500         else if (srst == 0)
1501                 high_output |= nSRSTnOE;
1502
1503         /* command "set data bits high byte" */
1504         buffer_write(0x82);
1505         buffer_write(high_output);
1506         buffer_write(high_direction);
1507         LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1508 }
1509
1510 static int ft2232_execute_runtest(jtag_command_t *cmd)
1511 {
1512         int retval;
1513         int i;
1514         int predicted_size = 0;
1515         retval = ERROR_OK;
1516
1517         DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1518                         cmd->cmd.runtest->num_cycles,
1519                         tap_state_name(cmd->cmd.runtest->end_state));
1520
1521         /* only send the maximum buffer size that FT2232C can handle */
1522         predicted_size = 0;
1523         if (tap_get_state() != TAP_IDLE)
1524                 predicted_size += 3;
1525         predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1526         if (cmd->cmd.runtest->end_state != TAP_IDLE)
1527                 predicted_size += 3;
1528         if (tap_get_end_state() != TAP_IDLE)
1529                 predicted_size += 3;
1530         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1531         {
1532                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1533                         retval = ERROR_JTAG_QUEUE_FAILED;
1534                 require_send = 0;
1535                 first_unsent = cmd;
1536         }
1537         if (tap_get_state() != TAP_IDLE)
1538         {
1539                 move_to_state(TAP_IDLE);
1540                 require_send = 1;
1541         }
1542         i = cmd->cmd.runtest->num_cycles;
1543         while (i > 0)
1544         {
1545                 /* there are no state transitions in this code, so omit state tracking */
1546
1547                 /* command "Clock Data to TMS/CS Pin (no Read)" */
1548                 buffer_write(0x4b);
1549
1550                 /* scan 7 bits */
1551                 buffer_write((i > 7) ? 6 : (i - 1));
1552
1553                 /* TMS data bits */
1554                 buffer_write(0x0);
1555                 tap_set_state(TAP_IDLE);
1556
1557                 i -= (i > 7) ? 7 : i;
1558                 /* LOG_DEBUG("added TMS scan (no read)"); */
1559         }
1560
1561         ft2232_end_state(cmd->cmd.runtest->end_state);
1562
1563         if (tap_get_state() != tap_get_end_state())
1564         {
1565                 move_to_state(tap_get_end_state());
1566         }
1567
1568         require_send = 1;
1569         DEBUG_JTAG_IO("runtest: %i, end in %s",
1570                         cmd->cmd.runtest->num_cycles,
1571                         tap_state_name(tap_get_end_state()));
1572         return retval;
1573 }
1574
1575 static int ft2232_execute_statemove(jtag_command_t *cmd)
1576 {
1577         int     predicted_size = 0;
1578         int     retval = ERROR_OK;
1579
1580         DEBUG_JTAG_IO("statemove end in %s",
1581                         tap_state_name(cmd->cmd.statemove->end_state));
1582
1583         /* only send the maximum buffer size that FT2232C can handle */
1584         predicted_size = 3;
1585         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1586         {
1587                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1588                         retval = ERROR_JTAG_QUEUE_FAILED;
1589                 require_send = 0;
1590                 first_unsent = cmd;
1591         }
1592         ft2232_end_state(cmd->cmd.statemove->end_state);
1593
1594         /* For TAP_RESET, ignore the current recorded state.  It's often
1595          * wrong at server startup, and this transation is critical whenever
1596          * it's requested.
1597          */
1598         if (tap_get_end_state() == TAP_RESET) {
1599                 clock_tms(0x4b,  0xff, 5, 0);
1600                 require_send = 1;
1601
1602         /* shortest-path move to desired end state */
1603         } else if (tap_get_state() != tap_get_end_state())
1604         {
1605                 move_to_state(tap_get_end_state());
1606                 require_send = 1;
1607         }
1608
1609         return retval;
1610 }
1611
1612 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1613 {
1614         int     predicted_size = 0;
1615         int     retval = ERROR_OK;
1616
1617         tap_state_t*     path = cmd->cmd.pathmove->path;
1618         int     num_states    = cmd->cmd.pathmove->num_states;
1619
1620         DEBUG_JTAG_IO("pathmove: %i states, current: %s  end: %s", num_states,
1621                         tap_state_name(tap_get_state()),
1622                         tap_state_name(path[num_states-1]));
1623
1624         /* only send the maximum buffer size that FT2232C can handle */
1625         predicted_size = 3 * CEIL(num_states, 7);
1626         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1627         {
1628                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1629                         retval = ERROR_JTAG_QUEUE_FAILED;
1630
1631                 require_send = 0;
1632                 first_unsent = cmd;
1633         }
1634
1635         ft2232_add_pathmove(path, num_states);
1636         require_send = 1;
1637
1638         return retval;
1639 }
1640
1641 static int ft2232_execute_scan(jtag_command_t *cmd)
1642 {
1643         uint8_t* buffer;
1644         int scan_size;                          /* size of IR or DR scan */
1645         int predicted_size = 0;
1646         int retval = ERROR_OK;
1647
1648         enum scan_type  type = jtag_scan_type(cmd->cmd.scan);
1649
1650         DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1651
1652         scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1653
1654         predicted_size = ft2232_predict_scan_out(scan_size, type);
1655         if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1656         {
1657                 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1658                 /* unsent commands before this */
1659                 if (first_unsent != cmd)
1660                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1661                                 retval = ERROR_JTAG_QUEUE_FAILED;
1662
1663                 /* current command */
1664                 ft2232_end_state(cmd->cmd.scan->end_state);
1665                 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1666                 require_send = 0;
1667                 first_unsent = cmd->next;
1668                 if (buffer)
1669                         free(buffer);
1670                 return retval;
1671         }
1672         else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1673         {
1674                 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1675                                 first_unsent,
1676                                 cmd);
1677                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1678                         retval = ERROR_JTAG_QUEUE_FAILED;
1679                 require_send = 0;
1680                 first_unsent = cmd;
1681         }
1682         ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1683         /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1684         ft2232_end_state(cmd->cmd.scan->end_state);
1685         ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1686         require_send = 1;
1687         if (buffer)
1688                 free(buffer);
1689         DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1690                         (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1691                         tap_state_name(tap_get_end_state()));
1692         return retval;
1693
1694 }
1695
1696 static int ft2232_execute_reset(jtag_command_t *cmd)
1697 {
1698         int retval;
1699         int predicted_size = 0;
1700         retval = ERROR_OK;
1701
1702         DEBUG_JTAG_IO("reset trst: %i srst %i",
1703                         cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1704
1705         /* only send the maximum buffer size that FT2232C can handle */
1706         predicted_size = 3;
1707         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1708         {
1709                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1710                         retval = ERROR_JTAG_QUEUE_FAILED;
1711                 require_send = 0;
1712                 first_unsent = cmd;
1713         }
1714
1715         if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1716         {
1717                 tap_set_state(TAP_RESET);
1718         }
1719
1720         layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1721         require_send = 1;
1722
1723         DEBUG_JTAG_IO("trst: %i, srst: %i",
1724                         cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1725         return retval;
1726 }
1727
1728 static int ft2232_execute_sleep(jtag_command_t *cmd)
1729 {
1730         int retval;
1731         retval = ERROR_OK;
1732
1733         DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1734
1735         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1736                                 retval = ERROR_JTAG_QUEUE_FAILED;
1737         first_unsent = cmd->next;
1738         jtag_sleep(cmd->cmd.sleep->us);
1739         DEBUG_JTAG_IO("sleep %i usec while in %s",
1740                         cmd->cmd.sleep->us,
1741                         tap_state_name(tap_get_state()));
1742         return retval;
1743 }
1744
1745 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1746 {
1747         int retval;
1748         retval = ERROR_OK;
1749
1750         /* this is only allowed while in a stable state.  A check for a stable
1751          * state was done in jtag_add_clocks()
1752          */
1753         if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1754                 retval = ERROR_JTAG_QUEUE_FAILED;
1755         DEBUG_JTAG_IO("clocks %i while in %s",
1756                         cmd->cmd.stableclocks->num_cycles,
1757                         tap_state_name(tap_get_state()));
1758         return retval;
1759 }
1760
1761 static int ft2232_execute_command(jtag_command_t *cmd)
1762 {
1763         int retval;
1764         retval = ERROR_OK;
1765
1766         switch (cmd->type)
1767         {
1768         case JTAG_RESET:        retval = ft2232_execute_reset(cmd); break;
1769         case JTAG_RUNTEST:      retval = ft2232_execute_runtest(cmd); break;
1770         case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1771         case JTAG_PATHMOVE:     retval = ft2232_execute_pathmove(cmd); break;
1772         case JTAG_SCAN:         retval = ft2232_execute_scan(cmd); break;
1773         case JTAG_SLEEP:        retval = ft2232_execute_sleep(cmd); break;
1774         case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1775         default:
1776                 LOG_ERROR("BUG: unknown JTAG command type encountered");
1777                 exit(-1);
1778         }
1779         return retval;
1780 }
1781
1782 static int ft2232_execute_queue()
1783 {
1784         jtag_command_t* cmd = jtag_command_queue;       /* currently processed command */
1785         int retval;
1786
1787         first_unsent = cmd;             /* next command that has to be sent */
1788         require_send = 0;
1789
1790         /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1791          * that wasn't handled by a caller-provided error handler
1792          */
1793         retval = ERROR_OK;
1794
1795         ft2232_buffer_size = 0;
1796         ft2232_expect_read = 0;
1797
1798         /* blink, if the current layout has that feature */
1799         if (layout->blink)
1800                 layout->blink();
1801
1802         while (cmd)
1803         {
1804                 if (ft2232_execute_command(cmd) != ERROR_OK)
1805                         retval = ERROR_JTAG_QUEUE_FAILED;
1806                 /* Start reading input before FT2232 TX buffer fills up */
1807                 cmd = cmd->next;
1808                 if (ft2232_expect_read > 256)
1809                 {
1810                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1811                                 retval = ERROR_JTAG_QUEUE_FAILED;
1812                         first_unsent = cmd;
1813                 }
1814         }
1815
1816         if (require_send > 0)
1817                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1818                         retval = ERROR_JTAG_QUEUE_FAILED;
1819
1820         return retval;
1821 }
1822
1823 #if BUILD_FT2232_FTD2XX == 1
1824 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more)
1825 {
1826         FT_STATUS       status;
1827         DWORD           deviceID;
1828         char            SerialNumber[16];
1829         char            Description[64];
1830         DWORD   openex_flags  = 0;
1831         char*   openex_string = NULL;
1832         uint8_t latency_timer;
1833
1834         LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1835
1836 #if IS_WIN32 == 0
1837         /* Add non-standard Vid/Pid to the linux driver */
1838         if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1839         {
1840                 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1841         }
1842 #endif
1843
1844         if (ft2232_device_desc && ft2232_serial)
1845         {
1846                 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1847                 ft2232_device_desc = NULL;
1848         }
1849
1850         if (ft2232_device_desc)
1851         {
1852                 openex_string = ft2232_device_desc;
1853                 openex_flags  = FT_OPEN_BY_DESCRIPTION;
1854         }
1855         else if (ft2232_serial)
1856         {
1857                 openex_string = ft2232_serial;
1858                 openex_flags  = FT_OPEN_BY_SERIAL_NUMBER;
1859         }
1860         else
1861         {
1862                 LOG_ERROR("neither device description nor serial number specified");
1863                 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1864
1865                 return ERROR_JTAG_INIT_FAILED;
1866         }
1867
1868         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1869         if (status != FT_OK) {
1870                 /* under Win32, the FTD2XX driver appends an "A" to the end
1871                  * of the description, if we tried by the desc, then
1872                  * try by the alternate "A" description. */
1873                 if (openex_string == ft2232_device_desc) {
1874                         /* Try the alternate method. */
1875                         openex_string = ft2232_device_desc_A;
1876                         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1877                         if (status == FT_OK) {
1878                                 /* yea, the "alternate" method worked! */
1879                         } else {
1880                                 /* drat, give the user a meaningfull message.
1881                                  * telling the use we tried *BOTH* methods. */
1882                                 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1883                                                         ft2232_device_desc,
1884                                                         ft2232_device_desc_A);
1885                         }
1886                 }
1887         }
1888
1889         if (status != FT_OK)
1890         {
1891                 DWORD num_devices;
1892
1893                 if (more)
1894                 {
1895                         LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1896                         *try_more = 1;
1897                         return ERROR_JTAG_INIT_FAILED;
1898                 }
1899                 LOG_ERROR("unable to open ftdi device: %lu", status);
1900                 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1901                 if (status == FT_OK)
1902                 {
1903                         char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
1904                         uint32_t i;
1905
1906                         for (i = 0; i < num_devices; i++)
1907                                 desc_array[i] = malloc(64);
1908
1909                         desc_array[num_devices] = NULL;
1910
1911                         status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1912
1913                         if (status == FT_OK)
1914                         {
1915                                 LOG_ERROR("ListDevices: %lu\n", num_devices);
1916                                 for (i = 0; i < num_devices; i++)
1917                                         LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
1918                         }
1919
1920                         for (i = 0; i < num_devices; i++)
1921                                 free(desc_array[i]);
1922
1923                         free(desc_array);
1924                 }
1925                 else
1926                 {
1927                         LOG_ERROR("ListDevices: NONE\n");
1928                 }
1929                 return ERROR_JTAG_INIT_FAILED;
1930         }
1931
1932         if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1933         {
1934                 LOG_ERROR("unable to set latency timer: %lu", status);
1935                 return ERROR_JTAG_INIT_FAILED;
1936         }
1937
1938         if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1939         {
1940                 LOG_ERROR("unable to get latency timer: %lu", status);
1941                 return ERROR_JTAG_INIT_FAILED;
1942         }
1943         else
1944         {
1945                 LOG_DEBUG("current latency timer: %i", latency_timer);
1946         }
1947
1948         if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1949         {
1950                 LOG_ERROR("unable to set timeouts: %lu", status);
1951                 return ERROR_JTAG_INIT_FAILED;
1952         }
1953
1954         if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1955         {
1956                 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1957                 return ERROR_JTAG_INIT_FAILED;
1958         }
1959
1960         if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
1961         {
1962                 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
1963                 return ERROR_JTAG_INIT_FAILED;
1964         }
1965         else
1966         {
1967                 static const char* type_str[] =
1968                         {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1969                 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
1970                 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
1971                         ? ftdi_device : FT_DEVICE_UNKNOWN;
1972                 LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
1973                 LOG_INFO("deviceID: %lu", deviceID);
1974                 LOG_INFO("SerialNumber: %s", SerialNumber);
1975                 LOG_INFO("Description: %s", Description);
1976         }
1977
1978         return ERROR_OK;
1979 }
1980
1981 static int ft2232_purge_ftd2xx(void)
1982 {
1983         FT_STATUS status;
1984
1985         if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1986         {
1987                 LOG_ERROR("error purging ftd2xx device: %lu", status);
1988                 return ERROR_JTAG_INIT_FAILED;
1989         }
1990
1991         return ERROR_OK;
1992 }
1993
1994 #endif /* BUILD_FT2232_FTD2XX == 1 */
1995
1996 #if BUILD_FT2232_LIBFTDI == 1
1997 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more)
1998 {
1999         uint8_t latency_timer;
2000
2001         LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2002                         ft2232_layout, vid, pid);
2003
2004         if (ftdi_init(&ftdic) < 0)
2005                 return ERROR_JTAG_INIT_FAILED;
2006
2007         if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
2008         {
2009                 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2010                 return ERROR_JTAG_INIT_FAILED;
2011         }
2012
2013         /* context, vendor id, product id */
2014         if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
2015                                 ft2232_serial) < 0)
2016         {
2017                 if (more)
2018                         LOG_WARNING("unable to open ftdi device (trying more): %s",
2019                                         ftdic.error_str);
2020                 else
2021                         LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2022                 *try_more = 1;
2023                 return ERROR_JTAG_INIT_FAILED;
2024         }
2025
2026         /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2027         if (ftdi_usb_reset(&ftdic) < 0)
2028         {
2029                 LOG_ERROR("unable to reset ftdi device");
2030                 return ERROR_JTAG_INIT_FAILED;
2031         }
2032
2033         if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
2034         {
2035                 LOG_ERROR("unable to set latency timer");
2036                 return ERROR_JTAG_INIT_FAILED;
2037         }
2038
2039         if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2040         {
2041                 LOG_ERROR("unable to get latency timer");
2042                 return ERROR_JTAG_INIT_FAILED;
2043         }
2044         else
2045         {
2046                 LOG_DEBUG("current latency timer: %i", latency_timer);
2047         }
2048
2049         ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2050
2051         ftdi_device = ftdic.type;
2052         static const char* type_str[] =
2053                 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2054         unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
2055         unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2056                 ? ftdi_device : no_of_known_types;
2057         LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2058         return ERROR_OK;
2059 }
2060
2061 static int ft2232_purge_libftdi(void)
2062 {
2063         if (ftdi_usb_purge_buffers(&ftdic) < 0)
2064         {
2065                 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2066                 return ERROR_JTAG_INIT_FAILED;
2067         }
2068
2069         return ERROR_OK;
2070 }
2071
2072 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2073
2074 static int ft2232_init(void)
2075 {
2076         uint8_t  buf[1];
2077         int retval;
2078         uint32_t bytes_written;
2079         const ft2232_layout_t* cur_layout = ft2232_layouts;
2080         int i;
2081
2082         if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE) == 7)
2083         {
2084                 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2085         }
2086         else
2087         {
2088                 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2089
2090         }
2091         if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
2092         {
2093                 ft2232_layout = "usbjtag";
2094                 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2095         }
2096
2097         while (cur_layout->name)
2098         {
2099                 if (strcmp(cur_layout->name, ft2232_layout) == 0)
2100                 {
2101                         layout = cur_layout;
2102                         break;
2103                 }
2104                 cur_layout++;
2105         }
2106
2107         if (!layout)
2108         {
2109                 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2110                 return ERROR_JTAG_INIT_FAILED;
2111         }
2112
2113         for (i = 0; 1; i++)
2114         {
2115                 /*
2116                  * "more indicates that there are more IDs to try, so we should
2117                  * not print an error for an ID mismatch (but for anything
2118                  * else, we should).
2119                  *
2120                  * try_more indicates that the error code returned indicates an
2121                  * ID mismatch (and nothing else) and that we should proceeed
2122                  * with the next ID pair.
2123                  */
2124                 int more     = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2125                 int try_more = 0;
2126
2127 #if BUILD_FT2232_FTD2XX == 1
2128                 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2129                                 more, &try_more);
2130 #elif BUILD_FT2232_LIBFTDI == 1
2131                 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2132                                 more, &try_more);
2133 #endif
2134                 if (retval >= 0)
2135                         break;
2136                 if (!more || !try_more)
2137                         return retval;
2138         }
2139
2140         ft2232_buffer_size = 0;
2141         ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2142
2143         if (layout->init() != ERROR_OK)
2144                 return ERROR_JTAG_INIT_FAILED;
2145
2146         if (ft2232_device_is_highspeed())
2147         {
2148 #ifndef BUILD_FT2232_HIGHSPEED
2149  #if BUILD_FT2232_FTD2XX == 1
2150                 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2151  #elif BUILD_FT2232_LIBFTDI == 1
2152                 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2153  #endif
2154 #endif
2155                 /* make sure the legacy mode is disabled */
2156                 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK)
2157                         return ERROR_JTAG_INIT_FAILED;
2158         }
2159
2160         ft2232_speed(jtag_get_speed());
2161
2162         buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2163         if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
2164         {
2165                 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2166                 return ERROR_JTAG_INIT_FAILED;
2167         }
2168
2169 #if BUILD_FT2232_FTD2XX == 1
2170         return ft2232_purge_ftd2xx();
2171 #elif BUILD_FT2232_LIBFTDI == 1
2172         return ft2232_purge_libftdi();
2173 #endif
2174
2175         return ERROR_OK;
2176 }
2177
2178 static int usbjtag_init(void)
2179 {
2180         uint8_t  buf[3];
2181         uint32_t bytes_written;
2182
2183         low_output    = 0x08;
2184         low_direction = 0x0b;
2185
2186         if (strcmp(ft2232_layout, "usbjtag") == 0)
2187         {
2188                 nTRST    = 0x10;
2189                 nTRSTnOE = 0x10;
2190                 nSRST    = 0x40;
2191                 nSRSTnOE = 0x40;
2192         }
2193         else if (strcmp(ft2232_layout, "signalyzer") == 0)
2194         {
2195                 nTRST    = 0x10;
2196                 nTRSTnOE = 0x10;
2197                 nSRST    = 0x20;
2198                 nSRSTnOE = 0x20;
2199         }
2200         else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2201         {
2202                 nTRST = 0x0;
2203                 nTRSTnOE = 0x00;
2204                 nSRST = 0x20;
2205                 nSRSTnOE = 0x20;
2206                 low_output    = 0x88;
2207                 low_direction = 0x8b;
2208         }
2209         else if (strcmp(ft2232_layout, "luminary_icdi") == 0)
2210         {
2211                 nTRST = 0x0;
2212                 nTRSTnOE = 0x00;
2213                 nSRST = 0x20;
2214                 nSRSTnOE = 0x20;
2215                 low_output    = 0x88;
2216                 low_direction = 0xcb;
2217         }
2218         else
2219         {
2220                 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2221                 return ERROR_JTAG_INIT_FAILED;
2222         }
2223
2224         enum reset_types jtag_reset_config = jtag_get_reset_config();
2225         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2226         {
2227                 low_direction &= ~nTRSTnOE; /* nTRST input */
2228                 low_output    &= ~nTRST;    /* nTRST = 0 */
2229         }
2230         else
2231         {
2232                 low_direction |= nTRSTnOE;  /* nTRST output */
2233                 low_output    |= nTRST;     /* nTRST = 1 */
2234         }
2235
2236         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2237         {
2238                 low_direction |= nSRSTnOE;  /* nSRST output */
2239                 low_output    |= nSRST;     /* nSRST = 1 */
2240         }
2241         else
2242         {
2243                 low_direction &= ~nSRSTnOE; /* nSRST input */
2244                 low_output    &= ~nSRST;    /* nSRST = 0 */
2245         }
2246
2247         /* initialize low byte for jtag */
2248         buf[0] = 0x80;          /* command "set data bits low byte" */
2249         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2250         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2251         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2252
2253         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2254         {
2255                 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2256                 return ERROR_JTAG_INIT_FAILED;
2257         }
2258
2259         return ERROR_OK;
2260 }
2261
2262 static int axm0432_jtag_init(void)
2263 {
2264         uint8_t  buf[3];
2265         uint32_t bytes_written;
2266
2267         low_output    = 0x08;
2268         low_direction = 0x2b;
2269
2270         /* initialize low byte for jtag */
2271         buf[0] = 0x80;          /* command "set data bits low byte" */
2272         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2273         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2274         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2275
2276         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2277         {
2278                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2279                 return ERROR_JTAG_INIT_FAILED;
2280         }
2281
2282         if (strcmp(layout->name, "axm0432_jtag") == 0)
2283         {
2284                 nTRST    = 0x08;
2285                 nTRSTnOE = 0x0;     /* No output enable for TRST*/
2286                 nSRST    = 0x04;
2287                 nSRSTnOE = 0x0;     /* No output enable for SRST*/
2288         }
2289         else
2290         {
2291                 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2292                 exit(-1);
2293         }
2294
2295         high_output    = 0x0;
2296         high_direction = 0x0c;
2297
2298         enum reset_types jtag_reset_config = jtag_get_reset_config();
2299         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2300         {
2301                 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2302         }
2303         else
2304         {
2305                 high_output |= nTRST;
2306         }
2307
2308         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2309         {
2310                 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2311         }
2312         else
2313         {
2314                 high_output |= nSRST;
2315         }
2316
2317         /* initialize high port */
2318         buf[0] = 0x82;              /* command "set data bits high byte" */
2319         buf[1] = high_output;       /* value */
2320         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2321         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2322
2323         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2324         {
2325                 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2326                 return ERROR_JTAG_INIT_FAILED;
2327         }
2328
2329         return ERROR_OK;
2330 }
2331
2332 static int jtagkey_init(void)
2333 {
2334         uint8_t  buf[3];
2335         uint32_t bytes_written;
2336
2337         low_output    = 0x08;
2338         low_direction = 0x1b;
2339
2340         /* initialize low byte for jtag */
2341         buf[0] = 0x80;          /* command "set data bits low byte" */
2342         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2343         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2344         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2345
2346         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2347         {
2348                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2349                 return ERROR_JTAG_INIT_FAILED;
2350         }
2351
2352         if (strcmp(layout->name, "jtagkey") == 0)
2353         {
2354                 nTRST    = 0x01;
2355                 nTRSTnOE = 0x4;
2356                 nSRST    = 0x02;
2357                 nSRSTnOE = 0x08;
2358         }
2359         else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2360                          || (strcmp(layout->name, "oocdlink") == 0))
2361         {
2362                 nTRST    = 0x02;
2363                 nTRSTnOE = 0x1;
2364                 nSRST    = 0x08;
2365                 nSRSTnOE = 0x04;
2366         }
2367         else
2368         {
2369                 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2370                 exit(-1);
2371         }
2372
2373         high_output    = 0x0;
2374         high_direction = 0x0f;
2375
2376         enum reset_types jtag_reset_config = jtag_get_reset_config();
2377         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2378         {
2379                 high_output |= nTRSTnOE;
2380                 high_output &= ~nTRST;
2381         }
2382         else
2383         {
2384                 high_output &= ~nTRSTnOE;
2385                 high_output |= nTRST;
2386         }
2387
2388         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2389         {
2390                 high_output &= ~nSRSTnOE;
2391                 high_output |= nSRST;
2392         }
2393         else
2394         {
2395                 high_output |= nSRSTnOE;
2396                 high_output &= ~nSRST;
2397         }
2398
2399         /* initialize high port */
2400         buf[0] = 0x82;              /* command "set data bits high byte" */
2401         buf[1] = high_output;       /* value */
2402         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2403         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2404
2405         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2406         {
2407                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2408                 return ERROR_JTAG_INIT_FAILED;
2409         }
2410
2411         return ERROR_OK;
2412 }
2413
2414 static int olimex_jtag_init(void)
2415 {
2416         uint8_t  buf[3];
2417         uint32_t bytes_written;
2418
2419         low_output    = 0x08;
2420         low_direction = 0x1b;
2421
2422         /* initialize low byte for jtag */
2423         buf[0] = 0x80;          /* command "set data bits low byte" */
2424         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2425         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2426         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2427
2428         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2429         {
2430                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2431                 return ERROR_JTAG_INIT_FAILED;
2432         }
2433
2434         nTRST    = 0x01;
2435         nTRSTnOE = 0x4;
2436         nSRST    = 0x02;
2437         nSRSTnOE = 0x00; /* no output enable for nSRST */
2438
2439         high_output    = 0x0;
2440         high_direction = 0x0f;
2441
2442         enum reset_types jtag_reset_config = jtag_get_reset_config();
2443         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2444         {
2445                 high_output |= nTRSTnOE;
2446                 high_output &= ~nTRST;
2447         }
2448         else
2449         {
2450                 high_output &= ~nTRSTnOE;
2451                 high_output |= nTRST;
2452         }
2453
2454         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2455         {
2456                 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2457         }
2458         else
2459         {
2460                 high_output &= ~nSRST;
2461         }
2462
2463         /* turn red LED on */
2464         high_output |= 0x08;
2465
2466         /* initialize high port */
2467         buf[0] = 0x82;              /* command "set data bits high byte" */
2468         buf[1] = high_output;       /* value */
2469         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2470         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2471
2472         if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3))
2473         {
2474                 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2475                 return ERROR_JTAG_INIT_FAILED;
2476         }
2477
2478         return ERROR_OK;
2479 }
2480
2481 static int flyswatter_init(void)
2482 {
2483         uint8_t  buf[3];
2484         uint32_t bytes_written;
2485
2486         low_output    = 0x18;
2487         low_direction = 0xfb;
2488
2489         /* initialize low byte for jtag */
2490         buf[0] = 0x80;          /* command "set data bits low byte" */
2491         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2492         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2493         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2494
2495         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2496         {
2497                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2498                 return ERROR_JTAG_INIT_FAILED;
2499         }
2500
2501         nTRST    = 0x10;
2502         nTRSTnOE = 0x0;     /* not output enable for nTRST */
2503         nSRST    = 0x20;
2504         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2505
2506         high_output    = 0x00;
2507         high_direction = 0x0c;
2508
2509         /* turn red LED3 on, LED2 off */
2510         high_output |= 0x08;
2511
2512         /* initialize high port */
2513         buf[0] = 0x82;              /* command "set data bits high byte" */
2514         buf[1] = high_output;       /* value */
2515         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2516         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2517
2518         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2519         {
2520                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2521                 return ERROR_JTAG_INIT_FAILED;
2522         }
2523
2524         return ERROR_OK;
2525 }
2526
2527 static int turtle_init(void)
2528 {
2529         uint8_t  buf[3];
2530         uint32_t bytes_written;
2531
2532         low_output    = 0x08;
2533         low_direction = 0x5b;
2534
2535         /* initialize low byte for jtag */
2536         buf[0] = 0x80;          /* command "set data bits low byte" */
2537         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2538         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2539         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2540
2541         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2542         {
2543                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2544                 return ERROR_JTAG_INIT_FAILED;
2545         }
2546
2547         nSRST = 0x40;
2548
2549         high_output    = 0x00;
2550         high_direction = 0x0C;
2551
2552         /* initialize high port */
2553         buf[0] = 0x82; /* command "set data bits high byte" */
2554         buf[1] = high_output;
2555         buf[2] = high_direction;
2556         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2557
2558         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2559         {
2560                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2561                 return ERROR_JTAG_INIT_FAILED;
2562         }
2563
2564         return ERROR_OK;
2565 }
2566
2567 static int comstick_init(void)
2568 {
2569         uint8_t  buf[3];
2570         uint32_t bytes_written;
2571
2572         low_output    = 0x08;
2573         low_direction = 0x0b;
2574
2575         /* initialize low byte for jtag */
2576         buf[0] = 0x80;          /* command "set data bits low byte" */
2577         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2578         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2579         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2580
2581         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2582         {
2583                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2584                 return ERROR_JTAG_INIT_FAILED;
2585         }
2586
2587         nTRST    = 0x01;
2588         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2589         nSRST    = 0x02;
2590         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2591
2592         high_output    = 0x03;
2593         high_direction = 0x03;
2594
2595         /* initialize high port */
2596         buf[0] = 0x82; /* command "set data bits high byte" */
2597         buf[1] = high_output;
2598         buf[2] = high_direction;
2599         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2600
2601         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2602         {
2603                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2604                 return ERROR_JTAG_INIT_FAILED;
2605         }
2606
2607         return ERROR_OK;
2608 }
2609
2610 static int stm32stick_init(void)
2611 {
2612         uint8_t  buf[3];
2613         uint32_t bytes_written;
2614
2615         low_output    = 0x88;
2616         low_direction = 0x8b;
2617
2618         /* initialize low byte for jtag */
2619         buf[0] = 0x80;          /* command "set data bits low byte" */
2620         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2621         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2622         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2623
2624         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2625         {
2626                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2627                 return ERROR_JTAG_INIT_FAILED;
2628         }
2629
2630         nTRST    = 0x01;
2631         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2632         nSRST    = 0x80;
2633         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2634
2635         high_output    = 0x01;
2636         high_direction = 0x03;
2637
2638         /* initialize high port */
2639         buf[0] = 0x82; /* command "set data bits high byte" */
2640         buf[1] = high_output;
2641         buf[2] = high_direction;
2642         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2643
2644         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2645         {
2646                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2647                 return ERROR_JTAG_INIT_FAILED;
2648         }
2649
2650         return ERROR_OK;
2651 }
2652
2653 static int sheevaplug_init(void)
2654 {
2655         uint8_t buf[3];
2656         uint32_t bytes_written;
2657
2658         low_output = 0x08;
2659         low_direction = 0x1b;
2660
2661         /* initialize low byte for jtag */
2662         buf[0] = 0x80; /* command "set data bits low byte" */
2663         buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2664         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2665         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2666
2667         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2668         {
2669                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2670                 return ERROR_JTAG_INIT_FAILED;
2671         }
2672
2673         nTRSTnOE = 0x1;
2674         nTRST = 0x02;
2675         nSRSTnOE = 0x4;
2676         nSRST = 0x08;
2677
2678         high_output = 0x0;
2679         high_direction = 0x0f;
2680
2681         /* nTRST is always push-pull */
2682         high_output &= ~nTRSTnOE;
2683         high_output |= nTRST;
2684
2685         /* nSRST is always open-drain */
2686         high_output |= nSRSTnOE;
2687         high_output &= ~nSRST;
2688
2689         /* initialize high port */
2690         buf[0] = 0x82; /* command "set data bits high byte" */
2691         buf[1] = high_output; /* value */
2692         buf[2] = high_direction;   /* all outputs - xRST */
2693         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2694
2695         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2696         {
2697                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2698                 return ERROR_JTAG_INIT_FAILED;
2699         }
2700
2701         return ERROR_OK;
2702 }
2703
2704 static int cortino_jtag_init(void)
2705 {
2706         uint8_t  buf[3];
2707         uint32_t bytes_written;
2708
2709         low_output    = 0x08;
2710         low_direction = 0x1b;
2711
2712         /* initialize low byte for jtag */
2713         buf[0] = 0x80;          /* command "set data bits low byte" */
2714         buf[1] = low_output;    /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2715         buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2716         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2717
2718         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2719         {
2720                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2721                 return ERROR_JTAG_INIT_FAILED;
2722         }
2723
2724         nTRST    = 0x01;
2725         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2726         nSRST    = 0x02;
2727         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2728
2729         high_output    = 0x03;
2730         high_direction = 0x03;
2731
2732         /* initialize high port */
2733         buf[0] = 0x82; /* command "set data bits high byte" */
2734         buf[1] = high_output;
2735         buf[2] = high_direction;
2736         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2737
2738         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2739         {
2740                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2741                 return ERROR_JTAG_INIT_FAILED;
2742         }
2743
2744         return ERROR_OK;
2745 }
2746
2747 static void olimex_jtag_blink(void)
2748 {
2749         /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2750          * ACBUS3 is bit 3 of the GPIOH port
2751          */
2752         if (high_output & 0x08)
2753         {
2754                 /* set port pin high */
2755                 high_output &= 0x07;
2756         }
2757         else
2758         {
2759                 /* set port pin low */
2760                 high_output |= 0x08;
2761         }
2762
2763         buffer_write(0x82);
2764         buffer_write(high_output);
2765         buffer_write(high_direction);
2766 }
2767
2768 static void flyswatter_jtag_blink(void)
2769 {
2770         /*
2771          * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2772          */
2773         high_output ^= 0x0c;
2774
2775         buffer_write(0x82);
2776         buffer_write(high_output);
2777         buffer_write(high_direction);
2778 }
2779
2780 static void turtle_jtag_blink(void)
2781 {
2782         /*
2783          * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2784          */
2785         if (high_output & 0x08)
2786         {
2787                 high_output = 0x04;
2788         }
2789         else
2790         {
2791                 high_output = 0x08;
2792         }
2793
2794         buffer_write(0x82);
2795         buffer_write(high_output);
2796         buffer_write(high_direction);
2797 }
2798
2799 static int ft2232_quit(void)
2800 {
2801 #if BUILD_FT2232_FTD2XX == 1
2802         FT_STATUS status;
2803
2804         status = FT_Close(ftdih);
2805 #elif BUILD_FT2232_LIBFTDI == 1
2806         ftdi_usb_close(&ftdic);
2807
2808         ftdi_deinit(&ftdic);
2809 #endif
2810
2811         free(ft2232_buffer);
2812         ft2232_buffer = NULL;
2813
2814         return ERROR_OK;
2815 }
2816
2817 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2818 {
2819         char *cp;
2820         char buf[200];
2821         if (argc == 1)
2822         {
2823                 ft2232_device_desc = strdup(args[0]);
2824                 cp = strchr(ft2232_device_desc, 0);
2825                 /* under Win32, the FTD2XX driver appends an "A" to the end
2826                  * of the description, this examines the given desc
2827                  * and creates the 'missing' _A or non_A variable. */
2828                 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
2829                         /* it was, so make this the "A" version. */
2830                         ft2232_device_desc_A = ft2232_device_desc;
2831                         /* and *CREATE* the non-A version. */
2832                         strcpy(buf, ft2232_device_desc);
2833                         cp = strchr(buf, 0);
2834                         cp[-2] = 0;
2835                         ft2232_device_desc =  strdup(buf);
2836                 } else {
2837                         /* <space > A not defined
2838                          * so create it */
2839                         sprintf(buf, "%s A", ft2232_device_desc);
2840                         ft2232_device_desc_A = strdup(buf);
2841                 }
2842         }
2843         else
2844         {
2845                 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2846         }
2847
2848         return ERROR_OK;
2849 }
2850
2851 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2852 {
2853         if (argc == 1)
2854         {
2855                 ft2232_serial = strdup(args[0]);
2856         }
2857         else
2858         {
2859                 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2860         }
2861
2862         return ERROR_OK;
2863 }
2864
2865 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2866 {
2867         if (argc == 0)
2868                 return ERROR_OK;
2869
2870         ft2232_layout = malloc(strlen(args[0]) + 1);
2871         strcpy(ft2232_layout, args[0]);
2872
2873         return ERROR_OK;
2874 }
2875
2876 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2877 {
2878         if (argc > MAX_USB_IDS * 2)
2879         {
2880                 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2881                                         "(maximum is %d pairs)", MAX_USB_IDS);
2882                 argc = MAX_USB_IDS * 2;
2883         }
2884         if (argc < 2 || (argc & 1))
2885         {
2886                 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2887                 if (argc < 2)
2888                         return ERROR_COMMAND_SYNTAX_ERROR;
2889                 /* remove the incomplete trailing id */
2890                 argc -= 1;
2891         }
2892
2893         int i;
2894         int retval = ERROR_OK;
2895         for (i = 0; i < argc; i += 2)
2896         {
2897                 retval = parse_u16(args[i], &ft2232_vid[i >> 1]);
2898                 if (ERROR_OK != retval)
2899                         break;
2900                 retval = parse_u16(args[i + 1], &ft2232_pid[i >> 1]);
2901                 if (ERROR_OK != retval)
2902                         break;
2903         }
2904
2905         /*
2906          * Explicitly terminate, in case there are multiples instances of
2907          * ft2232_vid_pid.
2908          */
2909         ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2910
2911         return retval;
2912 }
2913
2914 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2915 {
2916         if (argc == 1)
2917         {
2918                 ft2232_latency = atoi(args[0]);
2919         }
2920         else
2921         {
2922                 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2923         }
2924
2925         return ERROR_OK;
2926 }
2927
2928 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2929 {
2930         int retval = 0;
2931
2932         /* 7 bits of either ones or zeros. */
2933         uint8_t  tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2934
2935         while (num_cycles > 0)
2936         {
2937                 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2938                  * at most 7 bits per invocation.  Here we invoke it potentially
2939                  * several times.
2940                  */
2941                 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2942
2943                 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2944                 {
2945                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2946                                 retval = ERROR_JTAG_QUEUE_FAILED;
2947
2948                         first_unsent = cmd;
2949                 }
2950
2951                 /* there are no state transitions in this code, so omit state tracking */
2952
2953                 /* command "Clock Data to TMS/CS Pin (no Read)" */
2954                 buffer_write(0x4b);
2955
2956                 /* scan 7 bit */
2957                 buffer_write(bitcount_per_command - 1);
2958
2959                 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2960                 buffer_write(tms);
2961
2962                 require_send = 1;
2963
2964                 num_cycles -= bitcount_per_command;
2965         }
2966
2967         return retval;
2968 }
2969
2970 /* ---------------------------------------------------------------------
2971  * Support for IceBear JTAG adapter from Section5:
2972  *      http://section5.ch/icebear
2973  *
2974  * Author: Sten, debian@sansys-electronic.com
2975  */
2976
2977 /* Icebear pin layout
2978  *
2979  * ADBUS5 (nEMU) nSRST  | 2   1|        GND (10k->VCC)
2980  * GND GND              | 4   3|        n.c.
2981  * ADBUS3 TMS           | 6   5|        ADBUS6 VCC
2982  * ADBUS0 TCK           | 8   7|        ADBUS7 (GND)
2983  * ADBUS4 nTRST         |10   9|        ACBUS0 (GND)
2984  * ADBUS1 TDI           |12  11|        ACBUS1 (GND)
2985  * ADBUS2 TDO           |14  13|        GND GND
2986  *
2987  * ADBUS0 O L TCK               ACBUS0 GND
2988  * ADBUS1 O L TDI               ACBUS1 GND
2989  * ADBUS2 I   TDO               ACBUS2 n.c.
2990  * ADBUS3 O H TMS               ACBUS3 n.c.
2991  * ADBUS4 O H nTRST
2992  * ADBUS5 O H nSRST
2993  * ADBUS6 -   VCC
2994  * ADBUS7 -   GND
2995  */
2996 static int icebear_jtag_init(void) {
2997         uint8_t  buf[3];
2998         uint32_t bytes_written;
2999
3000         low_direction   = 0x0b; /* output: TCK TDI TMS; input: TDO */
3001         low_output      = 0x08; /* high: TMS; low: TCK TDI */
3002         nTRST           = 0x10;
3003         nSRST           = 0x20;
3004
3005         enum reset_types jtag_reset_config = jtag_get_reset_config();
3006         if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
3007                 low_direction   &= ~nTRST;      /* nTRST high impedance */
3008         }
3009         else {
3010                 low_direction   |= nTRST;
3011                 low_output      |= nTRST;
3012         }
3013
3014         low_direction   |= nSRST;
3015         low_output      |= nSRST;
3016
3017         /* initialize low byte for jtag */
3018         buf[0] = 0x80;          /* command "set data bits low byte" */
3019         buf[1] = low_output;
3020         buf[2] = low_direction;
3021         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3022
3023         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3024                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3025                 return ERROR_JTAG_INIT_FAILED;
3026         }
3027
3028         high_output    = 0x0;
3029         high_direction = 0x00;
3030
3031
3032         /* initialize high port */
3033         buf[0] = 0x82;              /* command "set data bits high byte" */
3034         buf[1] = high_output;       /* value */
3035         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
3036         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3037
3038         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3039                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3040                 return ERROR_JTAG_INIT_FAILED;
3041         }
3042
3043         return ERROR_OK;
3044 }
3045
3046 static void icebear_jtag_reset(int trst, int srst) {
3047
3048         if (trst == 1) {
3049                 low_direction   |= nTRST;
3050                 low_output      &= ~nTRST;
3051         }
3052         else if (trst == 0) {
3053                 enum reset_types jtag_reset_config = jtag_get_reset_config();
3054                 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3055                         low_direction   &= ~nTRST;
3056                 else
3057                         low_output      |= nTRST;
3058         }
3059
3060         if (srst == 1) {
3061                 low_output &= ~nSRST;
3062         }
3063         else if (srst == 0) {
3064                 low_output |= nSRST;
3065         }
3066
3067         /* command "set data bits low byte" */
3068         buffer_write(0x80);
3069         buffer_write(low_output);
3070         buffer_write(low_direction);
3071
3072         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
3073 }