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