git.sur5r.net Git - openocd/blob - src/jtag/ft2232.c

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