1 /***************************************************************************
2 * Copyright (C) 2004, 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
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. *
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. *
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 ***************************************************************************/
25 /* This code uses information contained in the MPSSE specification which was
27 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
28 * Hereafter this is called the "MPSSE Spec".
40 #include "replacements.h"
42 /* project specific includes */
46 #include "configuration.h"
47 #include "time_support.h"
54 /* FT2232 access library includes */
55 #if BUILD_FT2232_FTD2XX == 1
57 #elif BUILD_FT2232_LIBFTDI == 1
61 static int ft2232_execute_queue(void);
63 static int ft2232_speed(int speed);
64 static int ft2232_speed_div(int speed, int* khz);
65 static int ft2232_khz(int khz, int* jtag_speed);
66 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
67 static int ft2232_init(void);
68 static int ft2232_quit(void);
70 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
71 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
72 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
73 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
74 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
78 * Function ft2232_stableclocks
79 * will send out \a num_cycles on the TCK line while the TAP(s)
80 * are in a stable state. Calling code must ensure that current state is
81 * stable, that verification is not done in here.
82 * @param num_cycles is the count of clocks cycles to send.
83 * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED
85 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
88 static char * ft2232_device_desc_A = NULL;
89 static char* ft2232_device_desc = NULL;
90 static char* ft2232_serial = NULL;
91 static char* ft2232_layout = NULL;
92 static unsigned char ft2232_latency = 2;
95 /* vid = pid = 0 marks the end of the list */
96 static u16 ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
97 static u16 ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
99 typedef struct ft2232_layout_s
103 void (*reset)(int trst, int srst);
107 /* init procedures for supported layouts */
108 static int usbjtag_init(void);
109 static int jtagkey_init(void);
110 static int olimex_jtag_init(void);
111 static int flyswatter_init(void);
112 static int turtle_init(void);
113 static int comstick_init(void);
114 static int stm32stick_init(void);
115 static int axm0432_jtag_init(void);
116 static int sheevaplug_init(void);
118 /* reset procedures for supported layouts */
119 static void usbjtag_reset(int trst, int srst);
120 static void jtagkey_reset(int trst, int srst);
121 static void olimex_jtag_reset(int trst, int srst);
122 static void flyswatter_reset(int trst, int srst);
123 static void turtle_reset(int trst, int srst);
124 static void comstick_reset(int trst, int srst);
125 static void stm32stick_reset(int trst, int srst);
126 static void axm0432_jtag_reset(int trst, int srst);
127 static void sheevaplug_reset(int trst, int srst);
129 /* blink procedures for layouts that support a blinking led */
130 static void olimex_jtag_blink(void);
131 static void flyswatter_jtag_blink(void);
132 static void turtle_jtag_blink(void);
134 ft2232_layout_t ft2232_layouts[] =
136 { "usbjtag", usbjtag_init, usbjtag_reset, NULL },
137 { "jtagkey", jtagkey_init, jtagkey_reset, NULL },
138 { "jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL },
139 { "oocdlink", jtagkey_init, jtagkey_reset, NULL },
140 { "signalyzer", usbjtag_init, usbjtag_reset, NULL },
141 { "evb_lm3s811", usbjtag_init, usbjtag_reset, NULL },
142 { "olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink },
143 { "flyswatter", flyswatter_init, flyswatter_reset, flyswatter_jtag_blink },
144 { "turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink },
145 { "comstick", comstick_init, comstick_reset, NULL },
146 { "stm32stick", stm32stick_init, stm32stick_reset, NULL },
147 { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL },
148 {"sheevaplug", sheevaplug_init, sheevaplug_reset, NULL },
149 { NULL, NULL, NULL, NULL },
152 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
154 static ft2232_layout_t* layout;
155 static u8 low_output = 0x0;
156 static u8 low_direction = 0x0;
157 static u8 high_output = 0x0;
158 static u8 high_direction = 0x0;
160 #if BUILD_FT2232_FTD2XX == 1
161 static FT_HANDLE ftdih = NULL;
162 #elif BUILD_FT2232_LIBFTDI == 1
163 static struct ftdi_context ftdic;
167 static jtag_command_t* first_unsent; /* next command that has to be sent */
168 static int require_send;
170 static u8* ft2232_buffer = NULL;
171 static int ft2232_buffer_size = 0;
172 static int ft2232_read_pointer = 0;
173 static int ft2232_expect_read = 0;
175 #define FT2232_BUFFER_SIZE 131072
176 #define BUFFER_ADD ft2232_buffer[ft2232_buffer_size++]
177 #define BUFFER_READ ft2232_buffer[ft2232_read_pointer++]
179 jtag_interface_t ft2232_interface =
182 .execute_queue = ft2232_execute_queue,
183 .speed = ft2232_speed,
184 .speed_div = ft2232_speed_div,
186 .register_commands = ft2232_register_commands,
191 static int ft2232_write(u8* buf, int size, u32* bytes_written)
193 #if BUILD_FT2232_FTD2XX == 1
195 DWORD dw_bytes_written;
196 if ( ( status = FT_Write(ftdih, buf, size, &dw_bytes_written) ) != FT_OK )
198 *bytes_written = dw_bytes_written;
199 LOG_ERROR("FT_Write returned: %lu", status);
200 return ERROR_JTAG_DEVICE_ERROR;
204 *bytes_written = dw_bytes_written;
207 #elif BUILD_FT2232_LIBFTDI == 1
209 if ( ( retval = ftdi_write_data(&ftdic, buf, size) ) < 0 )
212 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic) );
213 return ERROR_JTAG_DEVICE_ERROR;
217 *bytes_written = retval;
224 static int ft2232_read(u8* buf, u32 size, u32* bytes_read)
226 #if BUILD_FT2232_FTD2XX == 1
232 while ( (*bytes_read < size) && timeout-- )
234 if ( ( status = FT_Read(ftdih, buf + *bytes_read, size -
235 *bytes_read, &dw_bytes_read) ) != FT_OK )
238 LOG_ERROR("FT_Read returned: %lu", status);
239 return ERROR_JTAG_DEVICE_ERROR;
241 *bytes_read += dw_bytes_read;
244 #elif BUILD_FT2232_LIBFTDI == 1
249 while ( (*bytes_read < size) && timeout-- )
251 if ( ( retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read) ) < 0 )
254 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic) );
255 return ERROR_JTAG_DEVICE_ERROR;
257 *bytes_read += retval;
262 if (*bytes_read < size)
264 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read, size);
265 return ERROR_JTAG_DEVICE_ERROR;
272 static int ft2232_speed(int speed)
278 buf[0] = 0x86; /* command "set divisor" */
279 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
280 buf[2] = (speed >> 8) & 0xff; /* valueH */
282 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
283 if ( ( ( retval = ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
285 LOG_ERROR("couldn't set FT2232 TCK speed");
293 static int ft2232_speed_div(int speed, int* khz)
295 /* Take a look in the FT2232 manual,
296 * AN2232C-01 Command Processor for
297 * MPSSE and MCU Host Bus. Chapter 3.8 */
299 *khz = 6000 / (1 + speed);
305 static int ft2232_khz(int khz, int* jtag_speed)
309 LOG_ERROR("RCLK not supported");
313 /* Take a look in the FT2232 manual,
314 * AN2232C-01 Command Processor for
315 * MPSSE and MCU Host Bus. Chapter 3.8
317 * We will calc here with a multiplier
318 * of 10 for better rounding later. */
320 /* Calc speed, (6000 / khz) - 1 */
321 /* Use 65000 for better rounding */
322 *jtag_speed = (60000 / khz) - 10;
324 /* Add 0.9 for rounding */
327 /* Calc real speed */
328 *jtag_speed = *jtag_speed / 10;
330 /* Check if speed is greater than 0 */
336 /* Check max value */
337 if (*jtag_speed > 0xFFFF)
339 *jtag_speed = 0xFFFF;
346 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
348 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
349 COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
350 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
351 COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
352 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
353 COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
354 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
355 COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
356 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
357 COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
362 void ft2232_end_state(tap_state_t state)
364 if (tap_is_state_stable(state))
365 tap_set_end_state(state);
368 LOG_ERROR("BUG: %i is not a valid end state", state);
374 static void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size)
376 int num_bytes = (scan_size + 7) / 8;
377 int bits_left = scan_size;
380 while (num_bytes-- > 1)
382 buffer[cur_byte] = BUFFER_READ;
387 buffer[cur_byte] = 0x0;
391 buffer[cur_byte] = BUFFER_READ >> 1;
394 buffer[cur_byte] = ( buffer[cur_byte] | ( (BUFFER_READ & 0x02) << 6 ) ) >> (8 - bits_left);
398 static void ft2232_debug_dump_buffer(void)
404 for (i = 0; i < ft2232_buffer_size; i++)
406 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
409 LOG_DEBUG("%s", line);
415 LOG_DEBUG("%s", line);
419 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
429 #ifdef _DEBUG_USB_IO_
430 struct timeval start, inter, inter2, end;
431 struct timeval d_inter, d_inter2, d_end;
434 #ifdef _DEBUG_USB_COMMS_
435 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
436 ft2232_debug_dump_buffer();
439 #ifdef _DEBUG_USB_IO_
440 gettimeofday(&start, NULL);
443 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
445 LOG_ERROR("couldn't write MPSSE commands to FT2232");
449 #ifdef _DEBUG_USB_IO_
450 gettimeofday(&inter, NULL);
453 if (ft2232_expect_read)
456 ft2232_buffer_size = 0;
458 #ifdef _DEBUG_USB_IO_
459 gettimeofday(&inter2, NULL);
462 if ( ( retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read) ) != ERROR_OK )
464 LOG_ERROR("couldn't read from FT2232");
468 #ifdef _DEBUG_USB_IO_
469 gettimeofday(&end, NULL);
471 timeval_subtract(&d_inter, &inter, &start);
472 timeval_subtract(&d_inter2, &inter2, &start);
473 timeval_subtract(&d_end, &end, &start);
475 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
476 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
477 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
478 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
481 ft2232_buffer_size = bytes_read;
483 if (ft2232_expect_read != ft2232_buffer_size)
485 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
488 ft2232_debug_dump_buffer();
493 #ifdef _DEBUG_USB_COMMS_
494 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
495 ft2232_debug_dump_buffer();
499 ft2232_expect_read = 0;
500 ft2232_read_pointer = 0;
502 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
503 * that wasn't handled by a caller-provided error handler
513 type = jtag_scan_type(cmd->cmd.scan);
514 if (type != SCAN_OUT)
516 scan_size = jtag_scan_size(cmd->cmd.scan);
517 buffer = calloc(CEIL(scan_size, 8), 1);
518 ft2232_read_scan(type, buffer, scan_size);
519 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
520 retval = ERROR_JTAG_QUEUE_FAILED;
532 ft2232_buffer_size = 0;
538 static void ft2232_add_pathmove(pathmove_command_t* cmd)
540 int num_states = cmd->num_states;
545 u8 tms_byte = 0; /* zero this on each MPSSE batch */
549 int num_states_batch = num_states > 7 ? 7 : num_states;
551 /* command "Clock Data to TMS/CS Pin (no Read)" */
554 /* number of states remaining */
555 BUFFER_ADD = num_states_batch - 1;
557 while (num_states_batch--)
559 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
560 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
561 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
562 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
565 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name(
566 tap_get_state() ), tap_state_name(cmd->path[state_count]) );
570 tap_set_state(cmd->path[state_count]);
575 BUFFER_ADD = tms_byte;
578 tap_set_end_state(tap_get_state());
582 void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size)
584 int num_bytes = (scan_size + 7) / 8;
585 int bits_left = scan_size;
589 if ( !( ( !ir_scan && (tap_get_state() == TAP_DRSHIFT) )
590 || ( ir_scan && (tap_get_state() == TAP_IRSHIFT) ) ) )
592 /* command "Clock Data to TMS/CS Pin (no Read)" */
595 BUFFER_ADD = 0x6; /* scan 7 bits */
600 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IRSHIFT);
601 tap_set_state(TAP_IRSHIFT);
605 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT);
606 tap_set_state(TAP_DRSHIFT);
608 /* LOG_DEBUG("added TMS scan (no read)"); */
611 /* add command for complete bytes */
612 while (num_bytes > 1)
617 /* Clock Data Bytes In and Out LSB First */
619 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
621 else if (type == SCAN_OUT)
623 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
625 /* LOG_DEBUG("added TDI bytes (o)"); */
627 else if (type == SCAN_IN)
629 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
631 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
634 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
635 num_bytes -= thisrun_bytes;
636 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
637 BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff;
641 /* add complete bytes */
642 while (thisrun_bytes-- > 0)
644 BUFFER_ADD = buffer[cur_byte];
649 else /* (type == SCAN_IN) */
651 bits_left -= 8 * (thisrun_bytes);
655 /* the most signifcant bit is scanned during TAP movement */
657 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
661 /* process remaining bits but the last one */
666 /* Clock Data Bits In and Out LSB First */
668 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
670 else if (type == SCAN_OUT)
672 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
674 /* LOG_DEBUG("added TDI bits (o)"); */
676 else if (type == SCAN_IN)
678 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
680 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
682 BUFFER_ADD = bits_left - 2;
684 BUFFER_ADD = buffer[cur_byte];
687 if ( ( ir_scan && (tap_get_end_state() == TAP_IRSHIFT) )
688 || ( !ir_scan && (tap_get_end_state() == TAP_DRSHIFT) ) )
692 /* Clock Data Bits In and Out LSB First */
694 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
696 else if (type == SCAN_OUT)
698 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
700 /* LOG_DEBUG("added TDI bits (o)"); */
702 else if (type == SCAN_IN)
704 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
706 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
709 BUFFER_ADD = last_bit;
713 /* move from Shift-IR/DR to end state */
714 if (type != SCAN_OUT)
716 /* Clock Data to TMS/CS Pin with Read */
718 /* LOG_DEBUG("added TMS scan (read)"); */
722 /* Clock Data to TMS/CS Pin (no Read) */
724 /* LOG_DEBUG("added TMS scan (no read)"); */
726 BUFFER_ADD = 0x6; /* scan 7 bits */
728 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7);
729 tap_set_state( tap_get_end_state() );
734 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int scan_size)
736 int num_bytes = (scan_size + 7) / 8;
737 int bits_left = scan_size;
740 u8* receive_buffer = malloc( CEIL(scan_size, 8) );
741 u8* receive_pointer = receive_buffer;
745 int thisrun_read = 0;
749 LOG_ERROR("BUG: large IR scans are not supported");
753 if (tap_get_state() != TAP_DRSHIFT)
755 /* command "Clock Data to TMS/CS Pin (no Read)" */
758 BUFFER_ADD = 0x6; /* scan 7 bits */
761 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT);
762 tap_set_state(TAP_DRSHIFT);
765 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
767 LOG_ERROR("couldn't write MPSSE commands to FT2232");
770 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
771 ft2232_buffer_size = 0;
773 /* add command for complete bytes */
774 while (num_bytes > 1)
780 /* Clock Data Bytes In and Out LSB First */
782 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
784 else if (type == SCAN_OUT)
786 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
788 /* LOG_DEBUG("added TDI bytes (o)"); */
790 else if (type == SCAN_IN)
792 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
794 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
797 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
798 thisrun_read = thisrun_bytes;
799 num_bytes -= thisrun_bytes;
800 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
801 BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff;
805 /* add complete bytes */
806 while (thisrun_bytes-- > 0)
808 BUFFER_ADD = buffer[cur_byte];
813 else /* (type == SCAN_IN) */
815 bits_left -= 8 * (thisrun_bytes);
818 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
820 LOG_ERROR("couldn't write MPSSE commands to FT2232");
823 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
824 ft2232_buffer_size = 0;
826 if (type != SCAN_OUT)
828 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
830 LOG_ERROR("couldn't read from FT2232");
833 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
834 receive_pointer += bytes_read;
840 /* the most signifcant bit is scanned during TAP movement */
842 last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1;
846 /* process remaining bits but the last one */
851 /* Clock Data Bits In and Out LSB First */
853 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
855 else if (type == SCAN_OUT)
857 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
859 /* LOG_DEBUG("added TDI bits (o)"); */
861 else if (type == SCAN_IN)
863 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
865 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
867 BUFFER_ADD = bits_left - 2;
869 BUFFER_ADD = buffer[cur_byte];
871 if (type != SCAN_OUT)
875 if (tap_get_end_state() == TAP_DRSHIFT)
879 /* Clock Data Bits In and Out LSB First */
881 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
883 else if (type == SCAN_OUT)
885 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
887 /* LOG_DEBUG("added TDI bits (o)"); */
889 else if (type == SCAN_IN)
891 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
893 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
896 BUFFER_ADD = last_bit;
900 /* move from Shift-IR/DR to end state */
901 if (type != SCAN_OUT)
903 /* Clock Data to TMS/CS Pin with Read */
905 /* LOG_DEBUG("added TMS scan (read)"); */
909 /* Clock Data to TMS/CS Pin (no Read) */
911 /* LOG_DEBUG("added TMS scan (no read)"); */
914 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7);
915 tap_set_state( tap_get_end_state() );
918 if (type != SCAN_OUT)
921 if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK )
923 LOG_ERROR("couldn't write MPSSE commands to FT2232");
926 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
927 ft2232_buffer_size = 0;
929 if (type != SCAN_OUT)
931 if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK )
933 LOG_ERROR("couldn't read from FT2232");
936 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
937 receive_pointer += bytes_read;
944 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
946 int predicted_size = 3;
947 int num_bytes = (scan_size - 1) / 8;
949 if (tap_get_state() != TAP_DRSHIFT)
952 if (type == SCAN_IN) /* only from device to host */
955 predicted_size += CEIL(num_bytes, 65536) * 3;
956 /* remaining bits - 1 (up to 7) */
957 predicted_size += ( (scan_size - 1) % 8 ) ? 2 : 0;
959 else /* host to device, or bidirectional */
962 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
963 /* remaining bits -1 (up to 7) */
964 predicted_size += ( (scan_size - 1) % 8 ) ? 3 : 0;
967 return predicted_size;
971 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
973 int predicted_size = 0;
975 if (type != SCAN_OUT)
978 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
980 /* remaining bits - 1 */
981 predicted_size += ( (scan_size - 1) % 8 ) ? 1 : 0;
983 /* last bit (from TMS scan) */
987 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
989 return predicted_size;
993 static void usbjtag_reset(int trst, int srst)
997 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
998 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1000 low_output &= ~nTRST; /* switch output low */
1004 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1005 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1007 low_output |= nTRST; /* switch output high */
1012 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1013 low_output &= ~nSRST; /* switch output low */
1015 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1019 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1020 low_output |= nSRST; /* switch output high */
1022 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1025 /* command "set data bits low byte" */
1027 BUFFER_ADD = low_output;
1028 BUFFER_ADD = low_direction;
1032 static void jtagkey_reset(int trst, int srst)
1036 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1037 high_output &= ~nTRSTnOE;
1039 high_output &= ~nTRST;
1043 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1044 high_output |= nTRSTnOE;
1046 high_output |= nTRST;
1051 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1052 high_output &= ~nSRST;
1054 high_output &= ~nSRSTnOE;
1058 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1059 high_output |= nSRST;
1061 high_output |= nSRSTnOE;
1064 /* command "set data bits high byte" */
1066 BUFFER_ADD = high_output;
1067 BUFFER_ADD = high_direction;
1068 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1073 static void olimex_jtag_reset(int trst, int srst)
1077 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1078 high_output &= ~nTRSTnOE;
1080 high_output &= ~nTRST;
1084 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1085 high_output |= nTRSTnOE;
1087 high_output |= nTRST;
1092 high_output |= nSRST;
1096 high_output &= ~nSRST;
1099 /* command "set data bits high byte" */
1101 BUFFER_ADD = high_output;
1102 BUFFER_ADD = high_direction;
1103 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1108 static void axm0432_jtag_reset(int trst, int srst)
1112 tap_set_state(TAP_RESET);
1113 high_output &= ~nTRST;
1117 high_output |= nTRST;
1122 high_output &= ~nSRST;
1126 high_output |= nSRST;
1129 /* command "set data bits low byte" */
1131 BUFFER_ADD = high_output;
1132 BUFFER_ADD = high_direction;
1133 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1138 static void flyswatter_reset(int trst, int srst)
1142 low_output &= ~nTRST;
1146 low_output |= nTRST;
1151 low_output |= nSRST;
1155 low_output &= ~nSRST;
1158 /* command "set data bits low byte" */
1160 BUFFER_ADD = low_output;
1161 BUFFER_ADD = low_direction;
1162 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1166 static void turtle_reset(int trst, int srst)
1172 low_output |= nSRST;
1176 low_output &= ~nSRST;
1179 /* command "set data bits low byte" */
1181 BUFFER_ADD = low_output;
1182 BUFFER_ADD = low_direction;
1183 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1187 static void comstick_reset(int trst, int srst)
1191 high_output &= ~nTRST;
1195 high_output |= nTRST;
1200 high_output &= ~nSRST;
1204 high_output |= nSRST;
1207 /* command "set data bits high byte" */
1209 BUFFER_ADD = high_output;
1210 BUFFER_ADD = high_direction;
1211 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1216 static void stm32stick_reset(int trst, int srst)
1220 high_output &= ~nTRST;
1224 high_output |= nTRST;
1229 low_output &= ~nSRST;
1233 low_output |= nSRST;
1236 /* command "set data bits low byte" */
1238 BUFFER_ADD = low_output;
1239 BUFFER_ADD = low_direction;
1241 /* command "set data bits high byte" */
1243 BUFFER_ADD = high_output;
1244 BUFFER_ADD = high_direction;
1245 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1251 static void sheevaplug_reset(int trst, int srst)
1254 high_output &= ~nTRST;
1256 high_output |= nTRST;
1259 high_output &= ~nSRSTnOE;
1261 high_output |= nSRSTnOE;
1263 /* command "set data bits high byte" */
1265 BUFFER_ADD = high_output;
1266 BUFFER_ADD = high_direction;
1267 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1270 static int ft2232_execute_end_state(jtag_command_t *cmd)
1275 DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state);
1277 if (cmd->cmd.end_state->end_state != TAP_INVALID)
1278 ft2232_end_state(cmd->cmd.end_state->end_state);
1284 static int ft2232_execute_runtest(jtag_command_t *cmd)
1288 int predicted_size = 0;
1291 DEBUG_JTAG_IO("runtest %i cycles, end in %i",
1292 cmd->cmd.runtest->num_cycles,
1293 cmd->cmd.runtest->end_state);
1294 /* only send the maximum buffer size that FT2232C can handle */
1296 if (tap_get_state() != TAP_IDLE)
1297 predicted_size += 3;
1298 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1299 if ( (cmd->cmd.runtest->end_state != TAP_INVALID) && (cmd->cmd.runtest->end_state != TAP_IDLE) )
1300 predicted_size += 3;
1301 if ( (cmd->cmd.runtest->end_state == TAP_INVALID) && (tap_get_end_state() != TAP_IDLE) )
1302 predicted_size += 3;
1303 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1305 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1306 retval = ERROR_JTAG_QUEUE_FAILED;
1310 if (tap_get_state() != TAP_IDLE)
1312 /* command "Clock Data to TMS/CS Pin (no Read)" */
1314 BUFFER_ADD = 0x6; /* scan 7 bits */
1317 BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IDLE);
1318 tap_set_state(TAP_IDLE);
1321 i = cmd->cmd.runtest->num_cycles;
1324 /* command "Clock Data to TMS/CS Pin (no Read)" */
1328 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
1332 tap_set_state(TAP_IDLE);
1333 i -= (i > 7) ? 7 : i;
1334 /* LOG_DEBUG("added TMS scan (no read)"); */
1337 if (cmd->cmd.runtest->end_state != TAP_INVALID)
1338 ft2232_end_state(cmd->cmd.runtest->end_state);
1340 if ( tap_get_state() != tap_get_end_state() )
1342 /* command "Clock Data to TMS/CS Pin (no Read)" */
1347 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1348 tap_set_state( tap_get_end_state() );
1349 /* LOG_DEBUG("added TMS scan (no read)"); */
1352 #ifdef _DEBUG_JTAG_IO_
1353 LOG_DEBUG( "runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name( tap_get_end_state() ) );
1359 static int ft2232_execute_statemove(jtag_command_t *cmd)
1362 int predicted_size = 0;
1365 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1367 /* only send the maximum buffer size that FT2232C can handle */
1369 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1371 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1372 retval = ERROR_JTAG_QUEUE_FAILED;
1376 if (cmd->cmd.statemove->end_state != TAP_INVALID)
1377 ft2232_end_state(cmd->cmd.statemove->end_state);
1379 /* command "Clock Data to TMS/CS Pin (no Read)" */
1382 BUFFER_ADD = 0x6; /* scan 7 bits */
1385 BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1386 /* LOG_DEBUG("added TMS scan (no read)"); */
1387 tap_set_state( tap_get_end_state() );
1389 #ifdef _DEBUG_JTAG_IO_
1390 LOG_DEBUG( "statemove: %s", tap_state_name( tap_get_end_state() ) );
1396 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1399 int predicted_size = 0;
1402 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
1403 cmd->cmd.pathmove->num_states,
1404 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1405 /* only send the maximum buffer size that FT2232C can handle */
1406 predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7);
1407 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1409 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1410 retval = ERROR_JTAG_QUEUE_FAILED;
1414 ft2232_add_pathmove(cmd->cmd.pathmove);
1416 #ifdef _DEBUG_JTAG_IO_
1417 LOG_DEBUG( "pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states,
1418 tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]) );
1423 static int ft2232_execute_scan(jtag_command_t *cmd)
1427 int scan_size; /* size of IR or DR scan */
1428 enum scan_type type;
1429 int predicted_size = 0;
1432 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1433 type = jtag_scan_type(cmd->cmd.scan);
1434 predicted_size = ft2232_predict_scan_out(scan_size, type);
1435 if ( (predicted_size + 1) > FT2232_BUFFER_SIZE )
1437 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1438 /* unsent commands before this */
1439 if (first_unsent != cmd)
1440 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1441 retval = ERROR_JTAG_QUEUE_FAILED;
1443 /* current command */
1444 if (cmd->cmd.scan->end_state != TAP_INVALID)
1445 ft2232_end_state(cmd->cmd.scan->end_state);
1446 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1448 first_unsent = cmd->next;
1453 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1455 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1458 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1459 retval = ERROR_JTAG_QUEUE_FAILED;
1463 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1464 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1465 if (cmd->cmd.scan->end_state != TAP_INVALID)
1466 ft2232_end_state(cmd->cmd.scan->end_state);
1467 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1471 #ifdef _DEBUG_JTAG_IO_
1472 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1473 tap_state_name( tap_get_end_state() ) );
1479 static int ft2232_execute_reset(jtag_command_t *cmd)
1482 int predicted_size = 0;
1485 DEBUG_JTAG_IO("reset trst: %i srst %i",
1486 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1488 /* only send the maximum buffer size that FT2232C can handle */
1490 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1492 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1493 retval = ERROR_JTAG_QUEUE_FAILED;
1498 if ( (cmd->cmd.reset->trst == 1) || ( cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST) ) )
1500 tap_set_state(TAP_RESET);
1502 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1505 #ifdef _DEBUG_JTAG_IO_
1506 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1511 static int ft2232_execute_sleep(jtag_command_t *cmd)
1516 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1518 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1519 retval = ERROR_JTAG_QUEUE_FAILED;
1520 first_unsent = cmd->next;
1521 jtag_sleep(cmd->cmd.sleep->us);
1522 #ifdef _DEBUG_JTAG_IO_
1523 LOG_DEBUG( "sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name( tap_get_state() ) );
1529 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1534 /* this is only allowed while in a stable state. A check for a stable
1535 * state was done in jtag_add_clocks()
1537 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1538 retval = ERROR_JTAG_QUEUE_FAILED;
1539 #ifdef _DEBUG_JTAG_IO_
1540 LOG_DEBUG( "clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name( tap_get_state() ) );
1546 static int ft2232_execute_command(jtag_command_t *cmd)
1553 case JTAG_END_STATE: retval = ft2232_execute_end_state(cmd); break;
1554 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1555 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1556 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1557 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1558 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1559 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1560 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1562 LOG_ERROR("BUG: unknown JTAG command type encountered");
1568 static int ft2232_execute_queue()
1570 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1573 first_unsent = cmd; /* next command that has to be sent */
1576 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1577 * that wasn't handled by a caller-provided error handler
1581 ft2232_buffer_size = 0;
1582 ft2232_expect_read = 0;
1584 /* blink, if the current layout has that feature */
1590 if (ft2232_execute_command(cmd) != ERROR_OK)
1591 retval = ERROR_JTAG_QUEUE_FAILED;
1592 /* Start reading input before FT2232 TX buffer fills up */
1593 if (ft2232_expect_read > 280)
1595 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1596 retval = ERROR_JTAG_QUEUE_FAILED;
1602 if (require_send > 0)
1603 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1604 retval = ERROR_JTAG_QUEUE_FAILED;
1610 #if BUILD_FT2232_FTD2XX == 1
1611 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1614 DWORD openex_flags = 0;
1615 char* openex_string = NULL;
1618 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1621 /* Add non-standard Vid/Pid to the linux driver */
1622 if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK )
1624 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1628 if (ft2232_device_desc && ft2232_serial)
1630 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1631 ft2232_device_desc = NULL;
1634 if (ft2232_device_desc)
1636 openex_string = ft2232_device_desc;
1637 openex_flags = FT_OPEN_BY_DESCRIPTION;
1639 else if (ft2232_serial)
1641 openex_string = ft2232_serial;
1642 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1646 LOG_ERROR("neither device description nor serial number specified");
1647 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1649 return ERROR_JTAG_INIT_FAILED;
1652 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1653 if( status != FT_OK ){
1654 // under Win32, the FTD2XX driver appends an "A" to the end
1655 // of the description, if we tried by the desc, then
1656 // try by the alternate "A" description.
1657 if( openex_string == ft2232_device_desc ){
1658 // Try the alternate method.
1659 openex_string = ft2232_device_desc_A;
1660 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1661 if( status == FT_OK ){
1662 // yea, the "alternate" method worked!
1664 // drat, give the user a meaningfull message.
1665 // telling the use we tried *BOTH* methods.
1666 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1668 ft2232_device_desc_A );
1673 if ( status != FT_OK )
1679 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1681 return ERROR_JTAG_INIT_FAILED;
1683 LOG_ERROR("unable to open ftdi device: %lu", status);
1684 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1685 if (status == FT_OK)
1687 char** desc_array = malloc( sizeof(char*) * (num_devices + 1) );
1690 for (i = 0; i < num_devices; i++)
1691 desc_array[i] = malloc(64);
1693 desc_array[num_devices] = NULL;
1695 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1697 if (status == FT_OK)
1699 LOG_ERROR("ListDevices: %lu\n", num_devices);
1700 for (i = 0; i < num_devices; i++)
1701 LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1704 for (i = 0; i < num_devices; i++)
1705 free(desc_array[i]);
1711 LOG_ERROR("ListDevices: NONE\n");
1713 return ERROR_JTAG_INIT_FAILED;
1716 if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK )
1718 LOG_ERROR("unable to set latency timer: %lu", status);
1719 return ERROR_JTAG_INIT_FAILED;
1722 if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK )
1724 LOG_ERROR("unable to get latency timer: %lu", status);
1725 return ERROR_JTAG_INIT_FAILED;
1729 LOG_DEBUG("current latency timer: %i", latency_timer);
1732 if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK )
1734 LOG_ERROR("unable to set timeouts: %lu", status);
1735 return ERROR_JTAG_INIT_FAILED;
1738 if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK )
1740 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1741 return ERROR_JTAG_INIT_FAILED;
1748 static int ft2232_purge_ftd2xx(void)
1752 if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK )
1754 LOG_ERROR("error purging ftd2xx device: %lu", status);
1755 return ERROR_JTAG_INIT_FAILED;
1762 #endif /* BUILD_FT2232_FTD2XX == 1 */
1764 #if BUILD_FT2232_LIBFTDI == 1
1765 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1769 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1770 ft2232_layout, vid, pid);
1772 if (ftdi_init(&ftdic) < 0)
1773 return ERROR_JTAG_INIT_FAILED;
1775 /* context, vendor id, product id */
1776 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1780 LOG_WARNING("unable to open ftdi device (trying more): %s",
1783 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1785 return ERROR_JTAG_INIT_FAILED;
1788 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1790 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1791 return ERROR_JTAG_INIT_FAILED;
1794 if (ftdi_usb_reset(&ftdic) < 0)
1796 LOG_ERROR("unable to reset ftdi device");
1797 return ERROR_JTAG_INIT_FAILED;
1800 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1802 LOG_ERROR("unable to set latency timer");
1803 return ERROR_JTAG_INIT_FAILED;
1806 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1808 LOG_ERROR("unable to get latency timer");
1809 return ERROR_JTAG_INIT_FAILED;
1813 LOG_DEBUG("current latency timer: %i", latency_timer);
1816 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1822 static int ft2232_purge_libftdi(void)
1824 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1826 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1827 return ERROR_JTAG_INIT_FAILED;
1834 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1836 static int ft2232_init(void)
1841 ft2232_layout_t* cur_layout = ft2232_layouts;
1844 if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) )
1846 ft2232_layout = "usbjtag";
1847 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1850 while (cur_layout->name)
1852 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1854 layout = cur_layout;
1862 LOG_ERROR("No matching layout found for %s", ft2232_layout);
1863 return ERROR_JTAG_INIT_FAILED;
1869 * "more indicates that there are more IDs to try, so we should
1870 * not print an error for an ID mismatch (but for anything
1873 * try_more indicates that the error code returned indicates an
1874 * ID mismatch (and nothing else) and that we should proceeed
1875 * with the next ID pair.
1877 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
1880 #if BUILD_FT2232_FTD2XX == 1
1881 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
1883 #elif BUILD_FT2232_LIBFTDI == 1
1884 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
1889 if (!more || !try_more)
1893 ft2232_buffer_size = 0;
1894 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1896 if (layout->init() != ERROR_OK)
1897 return ERROR_JTAG_INIT_FAILED;
1899 ft2232_speed(jtag_speed);
1901 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1902 if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) )
1904 LOG_ERROR("couldn't write to FT2232 to disable loopback");
1905 return ERROR_JTAG_INIT_FAILED;
1908 #if BUILD_FT2232_FTD2XX == 1
1909 return ft2232_purge_ftd2xx();
1910 #elif BUILD_FT2232_LIBFTDI == 1
1911 return ft2232_purge_libftdi();
1918 static int usbjtag_init(void)
1924 low_direction = 0x0b;
1926 if (strcmp(ft2232_layout, "usbjtag") == 0)
1933 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1940 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1947 low_direction = 0x8b;
1951 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1952 return ERROR_JTAG_INIT_FAILED;
1955 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1957 low_direction &= ~nTRSTnOE; /* nTRST input */
1958 low_output &= ~nTRST; /* nTRST = 0 */
1962 low_direction |= nTRSTnOE; /* nTRST output */
1963 low_output |= nTRST; /* nTRST = 1 */
1966 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1968 low_direction |= nSRSTnOE; /* nSRST output */
1969 low_output |= nSRST; /* nSRST = 1 */
1973 low_direction &= ~nSRSTnOE; /* nSRST input */
1974 low_output &= ~nSRST; /* nSRST = 0 */
1977 /* initialize low byte for jtag */
1978 buf[0] = 0x80; /* command "set data bits low byte" */
1979 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1980 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1981 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1983 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
1985 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1986 return ERROR_JTAG_INIT_FAILED;
1993 static int axm0432_jtag_init(void)
1999 low_direction = 0x2b;
2001 /* initialize low byte for jtag */
2002 buf[0] = 0x80; /* command "set data bits low byte" */
2003 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2004 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2005 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2007 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2009 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2010 return ERROR_JTAG_INIT_FAILED;
2013 if (strcmp(layout->name, "axm0432_jtag") == 0)
2016 nTRSTnOE = 0x0; /* No output enable for TRST*/
2018 nSRSTnOE = 0x0; /* No output enable for SRST*/
2022 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2027 high_direction = 0x0c;
2029 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2031 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2035 high_output |= nTRST;
2038 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2040 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2044 high_output |= nSRST;
2047 /* initialize high port */
2048 buf[0] = 0x82; /* command "set data bits high byte" */
2049 buf[1] = high_output; /* value */
2050 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2051 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2053 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2055 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2056 return ERROR_JTAG_INIT_FAILED;
2063 static int jtagkey_init(void)
2069 low_direction = 0x1b;
2071 /* initialize low byte for jtag */
2072 buf[0] = 0x80; /* command "set data bits low byte" */
2073 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2074 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2075 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2077 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2079 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2080 return ERROR_JTAG_INIT_FAILED;
2083 if (strcmp(layout->name, "jtagkey") == 0)
2090 else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2091 || (strcmp(layout->name, "oocdlink") == 0) )
2100 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2105 high_direction = 0x0f;
2107 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2109 high_output |= nTRSTnOE;
2110 high_output &= ~nTRST;
2114 high_output &= ~nTRSTnOE;
2115 high_output |= nTRST;
2118 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2120 high_output &= ~nSRSTnOE;
2121 high_output |= nSRST;
2125 high_output |= nSRSTnOE;
2126 high_output &= ~nSRST;
2129 /* initialize high port */
2130 buf[0] = 0x82; /* command "set data bits high byte" */
2131 buf[1] = high_output; /* value */
2132 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2133 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2135 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2137 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2138 return ERROR_JTAG_INIT_FAILED;
2145 static int olimex_jtag_init(void)
2151 low_direction = 0x1b;
2153 /* initialize low byte for jtag */
2154 buf[0] = 0x80; /* command "set data bits low byte" */
2155 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2156 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2157 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2159 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2161 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2162 return ERROR_JTAG_INIT_FAILED;
2168 nSRSTnOE = 0x00; /* no output enable for nSRST */
2171 high_direction = 0x0f;
2173 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2175 high_output |= nTRSTnOE;
2176 high_output &= ~nTRST;
2180 high_output &= ~nTRSTnOE;
2181 high_output |= nTRST;
2184 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2186 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2190 high_output &= ~nSRST;
2193 /* turn red LED on */
2194 high_output |= 0x08;
2196 /* initialize high port */
2197 buf[0] = 0x82; /* command "set data bits high byte" */
2198 buf[1] = high_output; /* value */
2199 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2200 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2202 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2204 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2205 return ERROR_JTAG_INIT_FAILED;
2212 static int flyswatter_init(void)
2218 low_direction = 0xfb;
2220 /* initialize low byte for jtag */
2221 buf[0] = 0x80; /* command "set data bits low byte" */
2222 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2223 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2224 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2226 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2228 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2229 return ERROR_JTAG_INIT_FAILED;
2233 nTRSTnOE = 0x0; /* not output enable for nTRST */
2235 nSRSTnOE = 0x00; /* no output enable for nSRST */
2238 high_direction = 0x0c;
2240 /* turn red LED3 on, LED2 off */
2241 high_output |= 0x08;
2243 /* initialize high port */
2244 buf[0] = 0x82; /* command "set data bits high byte" */
2245 buf[1] = high_output; /* value */
2246 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2247 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2249 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2251 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2252 return ERROR_JTAG_INIT_FAILED;
2259 static int turtle_init(void)
2265 low_direction = 0x5b;
2267 /* initialize low byte for jtag */
2268 buf[0] = 0x80; /* command "set data bits low byte" */
2269 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2270 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2271 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2273 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2275 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2276 return ERROR_JTAG_INIT_FAILED;
2282 high_direction = 0x0C;
2284 /* initialize high port */
2285 buf[0] = 0x82; /* command "set data bits high byte" */
2286 buf[1] = high_output;
2287 buf[2] = high_direction;
2288 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2290 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2292 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2293 return ERROR_JTAG_INIT_FAILED;
2300 static int comstick_init(void)
2306 low_direction = 0x0b;
2308 /* initialize low byte for jtag */
2309 buf[0] = 0x80; /* command "set data bits low byte" */
2310 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2311 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2312 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2314 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2316 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2317 return ERROR_JTAG_INIT_FAILED;
2321 nTRSTnOE = 0x00; /* no output enable for nTRST */
2323 nSRSTnOE = 0x00; /* no output enable for nSRST */
2326 high_direction = 0x03;
2328 /* initialize high port */
2329 buf[0] = 0x82; /* command "set data bits high byte" */
2330 buf[1] = high_output;
2331 buf[2] = high_direction;
2332 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2334 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2336 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2337 return ERROR_JTAG_INIT_FAILED;
2344 static int stm32stick_init(void)
2350 low_direction = 0x8b;
2352 /* initialize low byte for jtag */
2353 buf[0] = 0x80; /* command "set data bits low byte" */
2354 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2355 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2356 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2358 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2360 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2361 return ERROR_JTAG_INIT_FAILED;
2365 nTRSTnOE = 0x00; /* no output enable for nTRST */
2367 nSRSTnOE = 0x00; /* no output enable for nSRST */
2370 high_direction = 0x03;
2372 /* initialize high port */
2373 buf[0] = 0x82; /* command "set data bits high byte" */
2374 buf[1] = high_output;
2375 buf[2] = high_direction;
2376 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2378 if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) )
2380 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2381 return ERROR_JTAG_INIT_FAILED;
2388 static int sheevaplug_init(void)
2394 low_direction = 0x1b;
2396 /* initialize low byte for jtag */
2397 buf[0] = 0x80; /* command "set data bits low byte" */
2398 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2399 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2400 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2402 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2404 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2405 return ERROR_JTAG_INIT_FAILED;
2414 high_direction = 0x0f;
2416 /* nTRST is always push-pull */
2417 high_output &= ~nTRSTnOE;
2418 high_output |= nTRST;
2420 /* nSRST is always open-drain */
2421 high_output |= nSRSTnOE;
2422 high_output &= ~nSRST;
2424 /* initialize high port */
2425 buf[0] = 0x82; /* command "set data bits high byte" */
2426 buf[1] = high_output; /* value */
2427 buf[2] = high_direction; /* all outputs - xRST */
2428 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2430 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2432 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2433 return ERROR_JTAG_INIT_FAILED;
2439 static void olimex_jtag_blink(void)
2441 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2442 * ACBUS3 is bit 3 of the GPIOH port
2444 if (high_output & 0x08)
2446 /* set port pin high */
2447 high_output &= 0x07;
2451 /* set port pin low */
2452 high_output |= 0x08;
2456 BUFFER_ADD = high_output;
2457 BUFFER_ADD = high_direction;
2461 static void flyswatter_jtag_blink(void)
2464 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2466 high_output ^= 0x0c;
2469 BUFFER_ADD = high_output;
2470 BUFFER_ADD = high_direction;
2474 static void turtle_jtag_blink(void)
2477 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2479 if (high_output & 0x08)
2489 BUFFER_ADD = high_output;
2490 BUFFER_ADD = high_direction;
2494 static int ft2232_quit(void)
2496 #if BUILD_FT2232_FTD2XX == 1
2499 status = FT_Close(ftdih);
2500 #elif BUILD_FT2232_LIBFTDI == 1
2501 ftdi_disable_bitbang(&ftdic);
2503 ftdi_usb_close(&ftdic);
2505 ftdi_deinit(&ftdic);
2508 free(ft2232_buffer);
2509 ft2232_buffer = NULL;
2515 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2521 ft2232_device_desc = strdup(args[0]);
2522 cp = strchr( ft2232_device_desc, 0 );
2523 // under Win32, the FTD2XX driver appends an "A" to the end
2524 // of the description, this examines the given desc
2525 // and creates the 'missing' _A or non_A variable.
2526 if( (cp[-1] == 'A') && (cp[-2]==' ') ){
2527 // it was, so make this the "A" version.
2528 ft2232_device_desc_A = ft2232_device_desc;
2529 // and *CREATE* the non-A version.
2530 strcpy( buf, ft2232_device_desc );
2531 cp = strchr( buf, 0 );
2533 ft2232_device_desc = strdup( buf );
2535 // <space>A not defined
2537 sprintf( buf, "%s A", ft2232_device_desc );
2538 ft2232_device_desc_A = strdup( buf );
2543 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2550 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2554 ft2232_serial = strdup(args[0]);
2558 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2565 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2570 ft2232_layout = malloc(strlen(args[0]) + 1);
2571 strcpy(ft2232_layout, args[0]);
2577 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2581 if (argc > MAX_USB_IDS * 2)
2583 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2584 "(maximum is %d pairs)", MAX_USB_IDS);
2585 argc = MAX_USB_IDS * 2;
2587 if ( argc < 2 || (argc & 1) )
2589 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2594 for (i = 0; i + 1 < argc; i += 2)
2596 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2597 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2601 * Explicitly terminate, in case there are multiples instances of
2604 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2610 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2614 ft2232_latency = atoi(args[0]);
2618 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2625 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2629 /* 7 bits of either ones or zeros. */
2630 u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2632 while (num_cycles > 0)
2634 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2635 * at most 7 bits per invocation. Here we invoke it potentially
2638 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2640 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2642 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2643 retval = ERROR_JTAG_QUEUE_FAILED;
2648 /* command "Clock Data to TMS/CS Pin (no Read)" */
2652 BUFFER_ADD = bitcount_per_command - 1;
2654 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2659 num_cycles -= bitcount_per_command;