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_INVALID) && (cmd->cmd.runtest->end_state != TAP_IDLE) )
1432                 predicted_size += 3;
1433         if ( (cmd->cmd.runtest->end_state == TAP_INVALID) && (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         if (cmd->cmd.runtest->end_state != TAP_INVALID)
1467                 ft2232_end_state(cmd->cmd.runtest->end_state);
1468
1469         if ( tap_get_state() != tap_get_end_state() )
1470         {
1471                 move_to_state( tap_get_end_state() );
1472         }
1473
1474         require_send = 1;
1475 #ifdef _DEBUG_JTAG_IO_
1476         LOG_DEBUG( "runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name( tap_get_end_state() ) );
1477 #endif
1478
1479         return retval;
1480 }
1481
1482
1483 static int ft2232_execute_statemove(jtag_command_t *cmd)
1484 {
1485         int     predicted_size = 0;
1486         int     retval = ERROR_OK;
1487
1488         DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1489
1490         /* only send the maximum buffer size that FT2232C can handle */
1491         predicted_size = 3;
1492         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1493         {
1494                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1495                         retval = ERROR_JTAG_QUEUE_FAILED;
1496                 require_send = 0;
1497                 first_unsent = cmd;
1498         }
1499         if (cmd->cmd.statemove->end_state != TAP_INVALID)
1500                 ft2232_end_state(cmd->cmd.statemove->end_state);
1501
1502         /* move to end state */
1503         if ( tap_get_state() != tap_get_end_state() )
1504         {
1505                 move_to_state( tap_get_end_state() );
1506                 require_send = 1;
1507         }
1508
1509         return retval;
1510 }
1511
1512 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1513 {
1514         int     predicted_size = 0;
1515         int     retval = ERROR_OK;
1516
1517         tap_state_t*     path = cmd->cmd.pathmove->path;
1518         int     num_states    = cmd->cmd.pathmove->num_states;
1519
1520         DEBUG_JTAG_IO("pathmove: %i states, current: %s  end: %s", num_states,
1521                         tap_state_name( tap_get_state() ),
1522                         tap_state_name( path[num_states-1] )
1523                         );
1524
1525         /* only send the maximum buffer size that FT2232C can handle */
1526         predicted_size = 3 * CEIL(num_states, 7);
1527         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1528         {
1529                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1530                         retval = ERROR_JTAG_QUEUE_FAILED;
1531
1532                 require_send = 0;
1533                 first_unsent = cmd;
1534         }
1535
1536         ft2232_add_pathmove( path, num_states );
1537         require_send = 1;
1538
1539         return retval;
1540 }
1541
1542
1543 static int ft2232_execute_scan(jtag_command_t *cmd)
1544 {
1545         u8*             buffer;
1546         int             scan_size;                  /* size of IR or DR scan */
1547         int             predicted_size = 0;
1548         int                             retval = ERROR_OK;
1549
1550         enum scan_type  type = jtag_scan_type(cmd->cmd.scan);
1551
1552         DEBUG_JTAG_IO( "%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type );
1553
1554         scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1555
1556         predicted_size = ft2232_predict_scan_out(scan_size, type);
1557         if ( (predicted_size + 1) > FT2232_BUFFER_SIZE )
1558         {
1559                 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1560                 /* unsent commands before this */
1561                 if (first_unsent != cmd)
1562                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1563                                 retval = ERROR_JTAG_QUEUE_FAILED;
1564
1565                 /* current command */
1566                 if (cmd->cmd.scan->end_state != TAP_INVALID)
1567                         ft2232_end_state(cmd->cmd.scan->end_state);
1568                 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1569                 require_send = 0;
1570                 first_unsent = cmd->next;
1571                 if (buffer)
1572                         free(buffer);
1573                 return retval;
1574         }
1575         else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1576         {
1577                 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1578                                 first_unsent,
1579                                 cmd);
1580                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1581                         retval = ERROR_JTAG_QUEUE_FAILED;
1582                 require_send = 0;
1583                 first_unsent = cmd;
1584         }
1585         ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1586         /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1587         if (cmd->cmd.scan->end_state != TAP_INVALID)
1588                 ft2232_end_state(cmd->cmd.scan->end_state);
1589         ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1590         require_send = 1;
1591         if (buffer)
1592                 free(buffer);
1593 #ifdef _DEBUG_JTAG_IO_
1594         LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1595                         tap_state_name( tap_get_end_state() ) );
1596 #endif
1597         return retval;
1598
1599 }
1600
1601 static int ft2232_execute_reset(jtag_command_t *cmd)
1602 {
1603         int             retval;
1604         int             predicted_size = 0;
1605         retval = ERROR_OK;
1606
1607         DEBUG_JTAG_IO("reset trst: %i srst %i",
1608                         cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1609
1610         /* only send the maximum buffer size that FT2232C can handle */
1611         predicted_size = 3;
1612         if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1613         {
1614                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1615                         retval = ERROR_JTAG_QUEUE_FAILED;
1616                 require_send = 0;
1617                 first_unsent = cmd;
1618         }
1619
1620         layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1621         require_send = 1;
1622
1623 #ifdef _DEBUG_JTAG_IO_
1624         LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1625 #endif
1626         return retval;
1627 }
1628
1629 static int ft2232_execute_sleep(jtag_command_t *cmd)
1630 {
1631         int             retval;
1632         retval = ERROR_OK;
1633
1634         DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1635
1636         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1637                                 retval = ERROR_JTAG_QUEUE_FAILED;
1638         first_unsent = cmd->next;
1639         jtag_sleep(cmd->cmd.sleep->us);
1640 #ifdef _DEBUG_JTAG_IO_
1641                         LOG_DEBUG( "sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name( tap_get_state() ) );
1642 #endif
1643
1644         return retval;
1645 }
1646
1647 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1648 {
1649         int             retval;
1650         retval = ERROR_OK;
1651
1652         /* this is only allowed while in a stable state.  A check for a stable
1653          * state was done in jtag_add_clocks()
1654          */
1655         if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1656                 retval = ERROR_JTAG_QUEUE_FAILED;
1657 #ifdef _DEBUG_JTAG_IO_
1658         LOG_DEBUG( "clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name( tap_get_state() ) );
1659 #endif
1660
1661         return retval;
1662 }
1663
1664 static int ft2232_execute_command(jtag_command_t *cmd)
1665 {
1666         int             retval;
1667         retval = ERROR_OK;
1668
1669         switch (cmd->type)
1670         {
1671         case JTAG_RESET:                        retval = ft2232_execute_reset(cmd); break;
1672         case JTAG_RUNTEST:      retval = ft2232_execute_runtest(cmd); break;
1673         case JTAG_STATEMOVE:    retval = ft2232_execute_statemove(cmd); break;
1674         case JTAG_PATHMOVE:     retval = ft2232_execute_pathmove(cmd); break;
1675         case JTAG_SCAN:                         retval = ft2232_execute_scan(cmd); break;
1676         case JTAG_SLEEP:                        retval = ft2232_execute_sleep(cmd); break;
1677         case JTAG_STABLECLOCKS:         retval = ft2232_execute_stableclocks(cmd); break;
1678         default:
1679                 LOG_ERROR("BUG: unknown JTAG command type encountered");
1680                 exit(-1);
1681         }
1682         return retval;
1683 }
1684
1685 static int ft2232_execute_queue()
1686 {
1687         jtag_command_t* cmd = jtag_command_queue;   /* currently processed command */
1688         int             retval;
1689
1690         first_unsent = cmd;         /* next command that has to be sent */
1691         require_send = 0;
1692
1693         /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1694          * that wasn't handled by a caller-provided error handler
1695          */
1696         retval = ERROR_OK;
1697
1698         ft2232_buffer_size = 0;
1699         ft2232_expect_read = 0;
1700
1701         /* blink, if the current layout has that feature */
1702         if (layout->blink)
1703                 layout->blink();
1704
1705         while (cmd)
1706         {
1707                 if (ft2232_execute_command(cmd) != ERROR_OK)
1708                         retval = ERROR_JTAG_QUEUE_FAILED;
1709                 /* Start reading input before FT2232 TX buffer fills up */
1710                 cmd = cmd->next;
1711                 if (ft2232_expect_read > 256)
1712                 {
1713                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1714                                 retval = ERROR_JTAG_QUEUE_FAILED;
1715                         first_unsent = cmd;
1716                 }
1717         }
1718
1719         if (require_send > 0)
1720                 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1721                         retval = ERROR_JTAG_QUEUE_FAILED;
1722
1723         return retval;
1724 }
1725
1726
1727 #if BUILD_FT2232_FTD2XX == 1
1728 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1729 {
1730         FT_STATUS       status;
1731         DWORD           openex_flags  = 0;
1732         char*           openex_string = NULL;
1733         u8              latency_timer;
1734
1735         LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1736
1737 #if IS_WIN32 == 0
1738         /* Add non-standard Vid/Pid to the linux driver */
1739         if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK )
1740         {
1741                 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1742         }
1743 #endif
1744
1745         if (ft2232_device_desc && ft2232_serial)
1746         {
1747                 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1748                 ft2232_device_desc = NULL;
1749         }
1750
1751         if (ft2232_device_desc)
1752         {
1753                 openex_string = ft2232_device_desc;
1754                 openex_flags  = FT_OPEN_BY_DESCRIPTION;
1755         }
1756         else if (ft2232_serial)
1757         {
1758                 openex_string = ft2232_serial;
1759                 openex_flags  = FT_OPEN_BY_SERIAL_NUMBER;
1760         }
1761         else
1762         {
1763                 LOG_ERROR("neither device description nor serial number specified");
1764                 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1765
1766                 return ERROR_JTAG_INIT_FAILED;
1767         }
1768
1769         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1770         if( status != FT_OK ){
1771                 // under Win32, the FTD2XX driver appends an "A" to the end
1772                 // of the description, if we tried by the desc, then
1773                 // try by the alternate "A" description.
1774                 if( openex_string == ft2232_device_desc ){
1775                         // Try the alternate method.
1776                         openex_string = ft2232_device_desc_A;
1777                         status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1778                         if( status == FT_OK ){
1779                                 // yea, the "alternate" method worked!
1780                         } else {
1781                                 // drat, give the user a meaningfull message.
1782                                 // telling the use we tried *BOTH* methods.
1783                                 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1784                                                         ft2232_device_desc,
1785                                                         ft2232_device_desc_A );
1786                         }
1787                 }
1788         }
1789
1790         if ( status != FT_OK )
1791         {
1792                 DWORD num_devices;
1793
1794                 if (more)
1795                 {
1796                         LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1797                         *try_more = 1;
1798                         return ERROR_JTAG_INIT_FAILED;
1799                 }
1800                 LOG_ERROR("unable to open ftdi device: %lu", status);
1801                 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1802                 if (status == FT_OK)
1803                 {
1804                         char** desc_array = malloc( sizeof(char*) * (num_devices + 1) );
1805                         u32 i;
1806
1807                         for (i = 0; i < num_devices; i++)
1808                                 desc_array[i] = malloc(64);
1809
1810                         desc_array[num_devices] = NULL;
1811
1812                         status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1813
1814                         if (status == FT_OK)
1815                         {
1816                                 LOG_ERROR("ListDevices: %lu\n", num_devices);
1817                                 for (i = 0; i < num_devices; i++)
1818                                         LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1819                         }
1820
1821                         for (i = 0; i < num_devices; i++)
1822                                 free(desc_array[i]);
1823
1824                         free(desc_array);
1825                 }
1826                 else
1827                 {
1828                         LOG_ERROR("ListDevices: NONE\n");
1829                 }
1830                 return ERROR_JTAG_INIT_FAILED;
1831         }
1832
1833         if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK )
1834         {
1835                 LOG_ERROR("unable to set latency timer: %lu", status);
1836                 return ERROR_JTAG_INIT_FAILED;
1837         }
1838
1839         if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK )
1840         {
1841                 LOG_ERROR("unable to get latency timer: %lu", status);
1842                 return ERROR_JTAG_INIT_FAILED;
1843         }
1844         else
1845         {
1846                 LOG_DEBUG("current latency timer: %i", latency_timer);
1847         }
1848
1849         if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK )
1850         {
1851                 LOG_ERROR("unable to set timeouts: %lu", status);
1852                 return ERROR_JTAG_INIT_FAILED;
1853         }
1854
1855         if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK )
1856         {
1857                 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1858                 return ERROR_JTAG_INIT_FAILED;
1859         }
1860
1861         return ERROR_OK;
1862 }
1863
1864
1865 static int ft2232_purge_ftd2xx(void)
1866 {
1867         FT_STATUS status;
1868
1869         if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK )
1870         {
1871                 LOG_ERROR("error purging ftd2xx device: %lu", status);
1872                 return ERROR_JTAG_INIT_FAILED;
1873         }
1874
1875         return ERROR_OK;
1876 }
1877
1878
1879 #endif /* BUILD_FT2232_FTD2XX == 1 */
1880
1881 #if BUILD_FT2232_LIBFTDI == 1
1882 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1883 {
1884         u8 latency_timer;
1885
1886         LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1887                         ft2232_layout, vid, pid);
1888
1889         if (ftdi_init(&ftdic) < 0)
1890                 return ERROR_JTAG_INIT_FAILED;
1891
1892         if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1893         {
1894                 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1895                 return ERROR_JTAG_INIT_FAILED;
1896         }
1897
1898         /* context, vendor id, product id */
1899         if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1900                                 ft2232_serial) < 0)
1901         {
1902                 if (more)
1903                         LOG_WARNING("unable to open ftdi device (trying more): %s",
1904                                         ftdic.error_str);
1905                 else
1906                         LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1907                 *try_more = 1;
1908                 return ERROR_JTAG_INIT_FAILED;
1909         }
1910
1911         /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1912         if (ftdi_usb_reset(&ftdic) < 0)
1913         {
1914                 LOG_ERROR("unable to reset ftdi device");
1915                 return ERROR_JTAG_INIT_FAILED;
1916         }
1917
1918         if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1919         {
1920                 LOG_ERROR("unable to set latency timer");
1921                 return ERROR_JTAG_INIT_FAILED;
1922         }
1923
1924         if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1925         {
1926                 LOG_ERROR("unable to get latency timer");
1927                 return ERROR_JTAG_INIT_FAILED;
1928         }
1929         else
1930         {
1931                 LOG_DEBUG("current latency timer: %i", latency_timer);
1932         }
1933
1934         ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1935
1936         return ERROR_OK;
1937 }
1938
1939
1940 static int ft2232_purge_libftdi(void)
1941 {
1942         if (ftdi_usb_purge_buffers(&ftdic) < 0)
1943         {
1944                 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1945                 return ERROR_JTAG_INIT_FAILED;
1946         }
1947
1948         return ERROR_OK;
1949 }
1950
1951
1952 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1953
1954 static int ft2232_init(void)
1955 {
1956         u8  buf[1];
1957         int retval;
1958         u32 bytes_written;
1959         ft2232_layout_t* cur_layout = ft2232_layouts;
1960         int i;
1961
1962         if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE)==7)
1963         {
1964                 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
1965         }
1966         else
1967         {
1968                 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
1969
1970         }
1971         if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) )
1972         {
1973                 ft2232_layout = "usbjtag";
1974                 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1975         }
1976
1977         while (cur_layout->name)
1978         {
1979                 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1980                 {
1981                         layout = cur_layout;
1982                         break;
1983                 }
1984                 cur_layout++;
1985         }
1986
1987         if (!layout)
1988         {
1989                 LOG_ERROR("No matching layout found for %s", ft2232_layout);
1990                 return ERROR_JTAG_INIT_FAILED;
1991         }
1992
1993         for (i = 0; 1; i++)
1994         {
1995                 /*
1996                  * "more indicates that there are more IDs to try, so we should
1997                  * not print an error for an ID mismatch (but for anything
1998                  * else, we should).
1999                  *
2000                  * try_more indicates that the error code returned indicates an
2001                  * ID mismatch (and nothing else) and that we should proceeed
2002                  * with the next ID pair.
2003                  */
2004                 int more     = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2005                 int try_more = 0;
2006
2007 #if BUILD_FT2232_FTD2XX == 1
2008                 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2009                                 more, &try_more);
2010 #elif BUILD_FT2232_LIBFTDI == 1
2011                 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2012                                 more, &try_more);
2013 #endif
2014                 if (retval >= 0)
2015                         break;
2016                 if (!more || !try_more)
2017                         return retval;
2018         }
2019
2020         ft2232_buffer_size = 0;
2021         ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2022
2023         if (layout->init() != ERROR_OK)
2024                 return ERROR_JTAG_INIT_FAILED;
2025
2026         ft2232_speed(jtag_speed);
2027
2028         buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2029         if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) )
2030         {
2031                 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2032                 return ERROR_JTAG_INIT_FAILED;
2033         }
2034
2035 #if BUILD_FT2232_FTD2XX == 1
2036         return ft2232_purge_ftd2xx();
2037 #elif BUILD_FT2232_LIBFTDI == 1
2038         return ft2232_purge_libftdi();
2039 #endif
2040
2041         return ERROR_OK;
2042 }
2043
2044
2045 static int usbjtag_init(void)
2046 {
2047         u8  buf[3];
2048         u32 bytes_written;
2049
2050         low_output    = 0x08;
2051         low_direction = 0x0b;
2052
2053         if (strcmp(ft2232_layout, "usbjtag") == 0)
2054         {
2055                 nTRST    = 0x10;
2056                 nTRSTnOE = 0x10;
2057                 nSRST    = 0x40;
2058                 nSRSTnOE = 0x40;
2059         }
2060         else if (strcmp(ft2232_layout, "signalyzer") == 0)
2061         {
2062                 nTRST    = 0x10;
2063                 nTRSTnOE = 0x10;
2064                 nSRST    = 0x20;
2065                 nSRSTnOE = 0x20;
2066         }
2067         else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2068         {
2069                 nTRST = 0x0;
2070                 nTRSTnOE = 0x00;
2071                 nSRST = 0x20;
2072                 nSRSTnOE = 0x20;
2073                 low_output    = 0x88;
2074                 low_direction = 0x8b;
2075         }
2076         else
2077         {
2078                 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2079                 return ERROR_JTAG_INIT_FAILED;
2080         }
2081
2082         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2083         {
2084                 low_direction &= ~nTRSTnOE; /* nTRST input */
2085                 low_output    &= ~nTRST;    /* nTRST = 0 */
2086         }
2087         else
2088         {
2089                 low_direction |= nTRSTnOE;  /* nTRST output */
2090                 low_output    |= nTRST;     /* nTRST = 1 */
2091         }
2092
2093         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2094         {
2095                 low_direction |= nSRSTnOE;  /* nSRST output */
2096                 low_output    |= nSRST;     /* nSRST = 1 */
2097         }
2098         else
2099         {
2100                 low_direction &= ~nSRSTnOE; /* nSRST input */
2101                 low_output    &= ~nSRST;    /* nSRST = 0 */
2102         }
2103
2104         /* initialize low byte for jtag */
2105         buf[0] = 0x80;          /* command "set data bits low byte" */
2106         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2107         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2108         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2109
2110         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2111         {
2112                 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2113                 return ERROR_JTAG_INIT_FAILED;
2114         }
2115
2116         return ERROR_OK;
2117 }
2118
2119
2120 static int axm0432_jtag_init(void)
2121 {
2122         u8  buf[3];
2123         u32 bytes_written;
2124
2125         low_output    = 0x08;
2126         low_direction = 0x2b;
2127
2128         /* initialize low byte for jtag */
2129         buf[0] = 0x80;          /* command "set data bits low byte" */
2130         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2131         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2132         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2133
2134         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2135         {
2136                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2137                 return ERROR_JTAG_INIT_FAILED;
2138         }
2139
2140         if (strcmp(layout->name, "axm0432_jtag") == 0)
2141         {
2142                 nTRST    = 0x08;
2143                 nTRSTnOE = 0x0;     /* No output enable for TRST*/
2144                 nSRST    = 0x04;
2145                 nSRSTnOE = 0x0;     /* No output enable for SRST*/
2146         }
2147         else
2148         {
2149                 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2150                 exit(-1);
2151         }
2152
2153         high_output    = 0x0;
2154         high_direction = 0x0c;
2155
2156         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2157         {
2158                 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2159         }
2160         else
2161         {
2162                 high_output |= nTRST;
2163         }
2164
2165         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2166         {
2167                 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2168         }
2169         else
2170         {
2171                 high_output |= nSRST;
2172         }
2173
2174         /* initialize high port */
2175         buf[0] = 0x82;              /* command "set data bits high byte" */
2176         buf[1] = high_output;       /* value */
2177         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2178         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2179
2180         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2181         {
2182                 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2183                 return ERROR_JTAG_INIT_FAILED;
2184         }
2185
2186         return ERROR_OK;
2187 }
2188
2189
2190 static int jtagkey_init(void)
2191 {
2192         u8  buf[3];
2193         u32 bytes_written;
2194
2195         low_output    = 0x08;
2196         low_direction = 0x1b;
2197
2198         /* initialize low byte for jtag */
2199         buf[0] = 0x80;          /* command "set data bits low byte" */
2200         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2201         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2202         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2203
2204         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2205         {
2206                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2207                 return ERROR_JTAG_INIT_FAILED;
2208         }
2209
2210         if (strcmp(layout->name, "jtagkey") == 0)
2211         {
2212                 nTRST    = 0x01;
2213                 nTRSTnOE = 0x4;
2214                 nSRST    = 0x02;
2215                 nSRSTnOE = 0x08;
2216         }
2217         else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2218                          || (strcmp(layout->name, "oocdlink") == 0) )
2219         {
2220                 nTRST    = 0x02;
2221                 nTRSTnOE = 0x1;
2222                 nSRST    = 0x08;
2223                 nSRSTnOE = 0x04;
2224         }
2225         else
2226         {
2227                 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2228                 exit(-1);
2229         }
2230
2231         high_output    = 0x0;
2232         high_direction = 0x0f;
2233
2234         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2235         {
2236                 high_output |= nTRSTnOE;
2237                 high_output &= ~nTRST;
2238         }
2239         else
2240         {
2241                 high_output &= ~nTRSTnOE;
2242                 high_output |= nTRST;
2243         }
2244
2245         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2246         {
2247                 high_output &= ~nSRSTnOE;
2248                 high_output |= nSRST;
2249         }
2250         else
2251         {
2252                 high_output |= nSRSTnOE;
2253                 high_output &= ~nSRST;
2254         }
2255
2256         /* initialize high port */
2257         buf[0] = 0x82;              /* command "set data bits high byte" */
2258         buf[1] = high_output;       /* value */
2259         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2260         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2261
2262         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2263         {
2264                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2265                 return ERROR_JTAG_INIT_FAILED;
2266         }
2267
2268         return ERROR_OK;
2269 }
2270
2271
2272 static int olimex_jtag_init(void)
2273 {
2274         u8  buf[3];
2275         u32 bytes_written;
2276
2277         low_output    = 0x08;
2278         low_direction = 0x1b;
2279
2280         /* initialize low byte for jtag */
2281         buf[0] = 0x80;          /* command "set data bits low byte" */
2282         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2283         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2284         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2285
2286         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2287         {
2288                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2289                 return ERROR_JTAG_INIT_FAILED;
2290         }
2291
2292         nTRST    = 0x01;
2293         nTRSTnOE = 0x4;
2294         nSRST    = 0x02;
2295         nSRSTnOE = 0x00; /* no output enable for nSRST */
2296
2297         high_output    = 0x0;
2298         high_direction = 0x0f;
2299
2300         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2301         {
2302                 high_output |= nTRSTnOE;
2303                 high_output &= ~nTRST;
2304         }
2305         else
2306         {
2307                 high_output &= ~nTRSTnOE;
2308                 high_output |= nTRST;
2309         }
2310
2311         if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2312         {
2313                 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2314         }
2315         else
2316         {
2317                 high_output &= ~nSRST;
2318         }
2319
2320         /* turn red LED on */
2321         high_output |= 0x08;
2322
2323         /* initialize high port */
2324         buf[0] = 0x82;              /* command "set data bits high byte" */
2325         buf[1] = high_output;       /* value */
2326         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2327         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2328
2329         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2330         {
2331                 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2332                 return ERROR_JTAG_INIT_FAILED;
2333         }
2334
2335         return ERROR_OK;
2336 }
2337
2338
2339 static int flyswatter_init(void)
2340 {
2341         u8  buf[3];
2342         u32 bytes_written;
2343
2344         low_output    = 0x18;
2345         low_direction = 0xfb;
2346
2347         /* initialize low byte for jtag */
2348         buf[0] = 0x80;          /* command "set data bits low byte" */
2349         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2350         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2351         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2352
2353         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2354         {
2355                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2356                 return ERROR_JTAG_INIT_FAILED;
2357         }
2358
2359         nTRST    = 0x10;
2360         nTRSTnOE = 0x0;     /* not output enable for nTRST */
2361         nSRST    = 0x20;
2362         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2363
2364         high_output    = 0x00;
2365         high_direction = 0x0c;
2366
2367         /* turn red LED3 on, LED2 off */
2368         high_output |= 0x08;
2369
2370         /* initialize high port */
2371         buf[0] = 0x82;              /* command "set data bits high byte" */
2372         buf[1] = high_output;       /* value */
2373         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2374         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2375
2376         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2377         {
2378                 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2379                 return ERROR_JTAG_INIT_FAILED;
2380         }
2381
2382         return ERROR_OK;
2383 }
2384
2385
2386 static int turtle_init(void)
2387 {
2388         u8  buf[3];
2389         u32 bytes_written;
2390
2391         low_output    = 0x08;
2392         low_direction = 0x5b;
2393
2394         /* initialize low byte for jtag */
2395         buf[0] = 0x80;          /* command "set data bits low byte" */
2396         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2397         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2398         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2399
2400         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2401         {
2402                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2403                 return ERROR_JTAG_INIT_FAILED;
2404         }
2405
2406         nSRST = 0x40;
2407
2408         high_output    = 0x00;
2409         high_direction = 0x0C;
2410
2411         /* initialize high port */
2412         buf[0] = 0x82; /* command "set data bits high byte" */
2413         buf[1] = high_output;
2414         buf[2] = high_direction;
2415         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2416
2417         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2418         {
2419                 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2420                 return ERROR_JTAG_INIT_FAILED;
2421         }
2422
2423         return ERROR_OK;
2424 }
2425
2426
2427 static int comstick_init(void)
2428 {
2429         u8  buf[3];
2430         u32 bytes_written;
2431
2432         low_output    = 0x08;
2433         low_direction = 0x0b;
2434
2435         /* initialize low byte for jtag */
2436         buf[0] = 0x80;          /* command "set data bits low byte" */
2437         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2438         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2439         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2440
2441         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2442         {
2443                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2444                 return ERROR_JTAG_INIT_FAILED;
2445         }
2446
2447         nTRST    = 0x01;
2448         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2449         nSRST    = 0x02;
2450         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2451
2452         high_output    = 0x03;
2453         high_direction = 0x03;
2454
2455         /* initialize high port */
2456         buf[0] = 0x82; /* command "set data bits high byte" */
2457         buf[1] = high_output;
2458         buf[2] = high_direction;
2459         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2460
2461         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2462         {
2463                 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2464                 return ERROR_JTAG_INIT_FAILED;
2465         }
2466
2467         return ERROR_OK;
2468 }
2469
2470
2471 static int stm32stick_init(void)
2472 {
2473         u8  buf[3];
2474         u32 bytes_written;
2475
2476         low_output    = 0x88;
2477         low_direction = 0x8b;
2478
2479         /* initialize low byte for jtag */
2480         buf[0] = 0x80;          /* command "set data bits low byte" */
2481         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2482         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2483         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2484
2485         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2486         {
2487                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2488                 return ERROR_JTAG_INIT_FAILED;
2489         }
2490
2491         nTRST    = 0x01;
2492         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2493         nSRST    = 0x80;
2494         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2495
2496         high_output    = 0x01;
2497         high_direction = 0x03;
2498
2499         /* initialize high port */
2500         buf[0] = 0x82; /* command "set data bits high byte" */
2501         buf[1] = high_output;
2502         buf[2] = high_direction;
2503         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2504
2505         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2506         {
2507                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2508                 return ERROR_JTAG_INIT_FAILED;
2509         }
2510
2511         return ERROR_OK;
2512 }
2513
2514
2515 static int sheevaplug_init(void)
2516 {
2517         u8 buf[3];
2518         u32 bytes_written;
2519
2520         low_output = 0x08;
2521         low_direction = 0x1b;
2522
2523         /* initialize low byte for jtag */
2524         buf[0] = 0x80; /* command "set data bits low byte" */
2525         buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2526         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2527         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2528
2529         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2530         {
2531                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2532                 return ERROR_JTAG_INIT_FAILED;
2533         }
2534
2535         nTRSTnOE = 0x1;
2536         nTRST = 0x02;
2537         nSRSTnOE = 0x4;
2538         nSRST = 0x08;
2539
2540         high_output = 0x0;
2541         high_direction = 0x0f;
2542
2543         /* nTRST is always push-pull */
2544         high_output &= ~nTRSTnOE;
2545         high_output |= nTRST;
2546
2547         /* nSRST is always open-drain */
2548         high_output |= nSRSTnOE;
2549         high_output &= ~nSRST;
2550
2551         /* initialize high port */
2552         buf[0] = 0x82; /* command "set data bits high byte" */
2553         buf[1] = high_output; /* value */
2554         buf[2] = high_direction;   /* all outputs - xRST */
2555         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2556
2557         if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2558         {
2559                 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2560                 return ERROR_JTAG_INIT_FAILED;
2561         }
2562
2563         return ERROR_OK;
2564 }
2565
2566 static int      cortino_jtag_init(void)
2567 {
2568         u8  buf[3];
2569         u32 bytes_written;
2570
2571         low_output    = 0x08;
2572         low_direction = 0x1b;
2573
2574         /* initialize low byte for jtag */
2575         buf[0] = 0x80;          /* command "set data bits low byte" */
2576         buf[1] = low_output;    /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2577         buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2578         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2579
2580         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2581         {
2582                 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2583                 return ERROR_JTAG_INIT_FAILED;
2584         }
2585
2586         nTRST    = 0x01;
2587         nTRSTnOE = 0x00;    /* no output enable for nTRST */
2588         nSRST    = 0x02;
2589         nSRSTnOE = 0x00;    /* no output enable for nSRST */
2590
2591         high_output    = 0x03;
2592         high_direction = 0x03;
2593
2594         /* initialize high port */
2595         buf[0] = 0x82; /* command "set data bits high byte" */
2596         buf[1] = high_output;
2597         buf[2] = high_direction;
2598         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2599
2600         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2601         {
2602                 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2603                 return ERROR_JTAG_INIT_FAILED;
2604         }
2605
2606         return ERROR_OK;
2607 }
2608
2609 static void olimex_jtag_blink(void)
2610 {
2611         /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2612          * ACBUS3 is bit 3 of the GPIOH port
2613          */
2614         if (high_output & 0x08)
2615         {
2616                 /* set port pin high */
2617                 high_output &= 0x07;
2618         }
2619         else
2620         {
2621                 /* set port pin low */
2622                 high_output |= 0x08;
2623         }
2624
2625         buffer_write( 0x82 );
2626         buffer_write( high_output );
2627         buffer_write( high_direction );
2628 }
2629
2630
2631 static void flyswatter_jtag_blink(void)
2632 {
2633         /*
2634          * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2635          */
2636         high_output ^= 0x0c;
2637
2638         buffer_write( 0x82 );
2639         buffer_write( high_output );
2640         buffer_write( high_direction );
2641 }
2642
2643
2644 static void turtle_jtag_blink(void)
2645 {
2646         /*
2647          * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2648          */
2649         if (high_output & 0x08)
2650         {
2651                 high_output = 0x04;
2652         }
2653         else
2654         {
2655                 high_output = 0x08;
2656         }
2657
2658         buffer_write( 0x82 );
2659         buffer_write( high_output );
2660         buffer_write( high_direction );
2661 }
2662
2663
2664 static int ft2232_quit(void)
2665 {
2666 #if BUILD_FT2232_FTD2XX == 1
2667         FT_STATUS status;
2668
2669         status = FT_Close(ftdih);
2670 #elif BUILD_FT2232_LIBFTDI == 1
2671         ftdi_usb_close(&ftdic);
2672
2673         ftdi_deinit(&ftdic);
2674 #endif
2675
2676         free(ft2232_buffer);
2677         ft2232_buffer = NULL;
2678
2679         return ERROR_OK;
2680 }
2681
2682
2683 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2684 {
2685         char *cp;
2686         char buf[200];
2687         if (argc == 1)
2688         {
2689                 ft2232_device_desc = strdup(args[0]);
2690                 cp = strchr( ft2232_device_desc, 0 );
2691                 // under Win32, the FTD2XX driver appends an "A" to the end
2692                 // of the description, this examines the given desc
2693                 // and creates the 'missing' _A or non_A variable.
2694                 if( (cp[-1] == 'A') && (cp[-2]==' ') ){
2695                         // it was, so make this the "A" version.
2696                         ft2232_device_desc_A = ft2232_device_desc;
2697                         // and *CREATE* the non-A version.
2698                         strcpy( buf, ft2232_device_desc );
2699                         cp = strchr( buf, 0 );
2700                         cp[-2] = 0;
2701                         ft2232_device_desc =  strdup( buf );
2702                 } else {
2703                         // <space>A not defined
2704                         // so create it
2705                         sprintf( buf, "%s A", ft2232_device_desc );
2706                         ft2232_device_desc_A = strdup( buf );
2707                 }
2708         }
2709         else
2710         {
2711                 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2712         }
2713
2714         return ERROR_OK;
2715 }
2716
2717
2718 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2719 {
2720         if (argc == 1)
2721         {
2722                 ft2232_serial = strdup(args[0]);
2723         }
2724         else
2725         {
2726                 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2727         }
2728
2729         return ERROR_OK;
2730 }
2731
2732
2733 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2734 {
2735         if (argc == 0)
2736                 return ERROR_OK;
2737
2738         ft2232_layout = malloc(strlen(args[0]) + 1);
2739         strcpy(ft2232_layout, args[0]);
2740
2741         return ERROR_OK;
2742 }
2743
2744
2745 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2746 {
2747         int i;
2748
2749         if (argc > MAX_USB_IDS * 2)
2750         {
2751                 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2752                                         "(maximum is %d pairs)", MAX_USB_IDS);
2753                 argc = MAX_USB_IDS * 2;
2754         }
2755         if ( argc < 2 || (argc & 1) )
2756         {
2757                 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2758                 if (argc < 2)
2759                         return ERROR_OK;
2760         }
2761
2762         for (i = 0; i + 1 < argc; i += 2)
2763         {
2764                 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2765                 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2766         }
2767
2768         /*
2769          * Explicitly terminate, in case there are multiples instances of
2770          * ft2232_vid_pid.
2771          */
2772         ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2773
2774         return ERROR_OK;
2775 }
2776
2777
2778 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2779 {
2780         if (argc == 1)
2781         {
2782                 ft2232_latency = atoi(args[0]);
2783         }
2784         else
2785         {
2786                 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2787         }
2788
2789         return ERROR_OK;
2790 }
2791
2792
2793 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2794 {
2795         int retval = 0;
2796
2797         /* 7 bits of either ones or zeros. */
2798         u8  tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2799
2800         while (num_cycles > 0)
2801         {
2802                 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2803                  * at most 7 bits per invocation.  Here we invoke it potentially
2804                  * several times.
2805                  */
2806                 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2807
2808                 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2809                 {
2810                         if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2811                                 retval = ERROR_JTAG_QUEUE_FAILED;
2812
2813                         first_unsent = cmd;
2814                 }
2815
2816                 /* there are no state transitions in this code, so omit state tracking */
2817
2818                 /* command "Clock Data to TMS/CS Pin (no Read)" */
2819                 buffer_write( 0x4b );
2820
2821                 /* scan 7 bit */
2822                 buffer_write( bitcount_per_command - 1 );
2823
2824                 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2825                 buffer_write( tms );
2826
2827                 require_send = 1;
2828
2829                 num_cycles -= bitcount_per_command;
2830         }
2831
2832         return retval;
2833 }
2834
2835
2836 /* ---------------------------------------------------------------------
2837  * Support for IceBear JTAG adapter from Section5:
2838  *      http://section5.ch/icebear
2839  *
2840  * Author: Sten, debian@sansys-electronic.com
2841  */
2842
2843 /* Icebear pin layout
2844  *
2845  * ADBUS5 (nEMU) nSRST  | 2   1|        GND (10k->VCC)
2846  * GND GND              | 4   3|        n.c.
2847  * ADBUS3 TMS           | 6   5|        ADBUS6 VCC
2848  * ADBUS0 TCK           | 8   7|        ADBUS7 (GND)
2849  * ADBUS4 nTRST         |10   9|        ACBUS0 (GND)
2850  * ADBUS1 TDI           |12  11|        ACBUS1 (GND)
2851  * ADBUS2 TDO           |14  13|        GND GND
2852  *
2853  * ADBUS0 O L TCK               ACBUS0 GND
2854  * ADBUS1 O L TDI               ACBUS1 GND
2855  * ADBUS2 I   TDO               ACBUS2 n.c.
2856  * ADBUS3 O H TMS               ACBUS3 n.c.
2857  * ADBUS4 O H nTRST
2858  * ADBUS5 O H nSRST
2859  * ADBUS6 -   VCC
2860  * ADBUS7 -   GND
2861  */
2862 static int icebear_jtag_init(void) {
2863         u8  buf[3];
2864         u32 bytes_written;
2865
2866         low_direction   = 0x0b; /* output: TCK TDI TMS; input: TDO */
2867         low_output      = 0x08; /* high: TMS; low: TCK TDI */
2868         nTRST           = 0x10;
2869         nSRST           = 0x20;
2870
2871         if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
2872                 low_direction   &= ~nTRST;      /* nTRST high impedance */
2873         }
2874         else {
2875                 low_direction   |= nTRST;
2876                 low_output      |= nTRST;
2877         }
2878
2879         low_direction   |= nSRST;
2880         low_output      |= nSRST;
2881
2882         /* initialize low byte for jtag */
2883         buf[0] = 0x80;          /* command "set data bits low byte" */
2884         buf[1] = low_output;
2885         buf[2] = low_direction;
2886         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2887
2888         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2889                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2890                 return ERROR_JTAG_INIT_FAILED;
2891         }
2892
2893         high_output    = 0x0;
2894         high_direction = 0x00;
2895
2896
2897         /* initialize high port */
2898         buf[0] = 0x82;              /* command "set data bits high byte" */
2899         buf[1] = high_output;       /* value */
2900         buf[2] = high_direction;    /* all outputs (xRST and xRSTnOE) */
2901         LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2902
2903         if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) {
2904                 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2905                 return ERROR_JTAG_INIT_FAILED;
2906         }
2907
2908         return ERROR_OK;
2909 }
2910
2911 static void icebear_jtag_reset(int trst, int srst) {
2912
2913         if (trst == 1) {
2914                 low_direction   |= nTRST;
2915                 low_output      &= ~nTRST;
2916         }
2917         else if (trst == 0) {
2918                 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
2919                         low_direction   &= ~nTRST;
2920                 else
2921                         low_output      |= nTRST;
2922         }
2923
2924         if (srst == 1) {
2925                 low_output &= ~nSRST;
2926         }
2927         else if (srst == 0) {
2928                 low_output |= nSRST;
2929         }
2930
2931         /* command "set data bits low byte" */
2932         buffer_write( 0x80 );
2933         buffer_write( low_output );
2934         buffer_write( low_direction );
2935
2936         LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
2937 }