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