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