git.sur5r.net Git - openocd/blob - src/jtag/ft2232.c

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