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

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