git.gag.com Git - fw/openocd/blob - src/jtag/ft2232.c

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