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

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