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