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_queue()
1272 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1274 int scan_size
; /* size of IR or DR scan */
1275 enum scan_type type
;
1277 int predicted_size
= 0;
1280 first_unsent
= cmd
; /* next command that has to be sent */
1283 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1284 * that wasn't handled by a caller-provided error handler
1288 ft2232_buffer_size
= 0;
1289 ft2232_expect_read
= 0;
1291 /* blink, if the current layout has that feature */
1299 case JTAG_END_STATE
:
1300 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
1301 ft2232_end_state(cmd
->cmd
.end_state
->end_state
);
1305 /* only send the maximum buffer size that FT2232C can handle */
1307 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1309 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1310 retval
= ERROR_JTAG_QUEUE_FAILED
;
1315 if ( (cmd
->cmd
.reset
->trst
== 1) || ( cmd
->cmd
.reset
->srst
&& (jtag_reset_config
& RESET_SRST_PULLS_TRST
) ) )
1317 tap_set_state(TAP_RESET
);
1319 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1322 #ifdef _DEBUG_JTAG_IO_
1323 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1328 /* only send the maximum buffer size that FT2232C can handle */
1330 if (tap_get_state() != TAP_IDLE
)
1331 predicted_size
+= 3;
1332 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1333 if ( (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
) && (cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
) )
1334 predicted_size
+= 3;
1335 if ( (cmd
->cmd
.runtest
->end_state
== TAP_INVALID
) && (tap_get_end_state() != TAP_IDLE
) )
1336 predicted_size
+= 3;
1337 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1339 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1340 retval
= ERROR_JTAG_QUEUE_FAILED
;
1344 if (tap_get_state() != TAP_IDLE
)
1346 /* command "Clock Data to TMS/CS Pin (no Read)" */
1348 BUFFER_ADD
= 0x6; /* scan 7 bits */
1351 BUFFER_ADD
= tap_get_tms_path(tap_get_state(), TAP_IDLE
);
1352 tap_set_state(TAP_IDLE
);
1355 i
= cmd
->cmd
.runtest
->num_cycles
;
1358 /* command "Clock Data to TMS/CS Pin (no Read)" */
1362 BUFFER_ADD
= (i
> 7) ? 6 : (i
- 1);
1366 tap_set_state(TAP_IDLE
);
1367 i
-= (i
> 7) ? 7 : i
;
1368 /* LOG_DEBUG("added TMS scan (no read)"); */
1371 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
1372 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1374 if ( tap_get_state() != tap_get_end_state() )
1376 /* command "Clock Data to TMS/CS Pin (no Read)" */
1381 BUFFER_ADD
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1382 tap_set_state( tap_get_end_state() );
1383 /* LOG_DEBUG("added TMS scan (no read)"); */
1386 #ifdef _DEBUG_JTAG_IO_
1387 LOG_DEBUG( "runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name( tap_get_end_state() ) );
1391 case JTAG_STATEMOVE
:
1392 /* only send the maximum buffer size that FT2232C can handle */
1394 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1396 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1397 retval
= ERROR_JTAG_QUEUE_FAILED
;
1401 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
1402 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1404 /* command "Clock Data to TMS/CS Pin (no Read)" */
1407 BUFFER_ADD
= 0x6; /* scan 7 bits */
1410 BUFFER_ADD
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1411 /* LOG_DEBUG("added TMS scan (no read)"); */
1412 tap_set_state( tap_get_end_state() );
1414 #ifdef _DEBUG_JTAG_IO_
1415 LOG_DEBUG( "statemove: %s", tap_state_name( tap_get_end_state() ) );
1420 /* only send the maximum buffer size that FT2232C can handle */
1421 predicted_size
= 3 * CEIL(cmd
->cmd
.pathmove
->num_states
, 7);
1422 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1424 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1425 retval
= ERROR_JTAG_QUEUE_FAILED
;
1429 ft2232_add_pathmove(cmd
->cmd
.pathmove
);
1431 #ifdef _DEBUG_JTAG_IO_
1432 LOG_DEBUG( "pathmove: %i states, end in %s", cmd
->cmd
.pathmove
->num_states
,
1433 tap_state_name(cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]) );
1438 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1439 type
= jtag_scan_type(cmd
->cmd
.scan
);
1440 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1441 if ( (predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1443 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1444 /* unsent commands before this */
1445 if (first_unsent
!= cmd
)
1446 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1447 retval
= ERROR_JTAG_QUEUE_FAILED
;
1449 /* current command */
1450 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
1451 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1452 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1454 first_unsent
= cmd
->next
;
1459 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1461 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1464 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1465 retval
= ERROR_JTAG_QUEUE_FAILED
;
1469 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1470 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1471 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
1472 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1473 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1477 #ifdef _DEBUG_JTAG_IO_
1478 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1479 tap_state_name( tap_get_end_state() ) );
1484 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1485 retval
= ERROR_JTAG_QUEUE_FAILED
;
1486 first_unsent
= cmd
->next
;
1487 jtag_sleep(cmd
->cmd
.sleep
->us
);
1488 #ifdef _DEBUG_JTAG_IO_
1489 LOG_DEBUG( "sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name( tap_get_state() ) );
1493 case JTAG_STABLECLOCKS
:
1495 /* this is only allowed while in a stable state. A check for a stable
1496 * state was done in jtag_add_clocks()
1498 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1499 retval
= ERROR_JTAG_QUEUE_FAILED
;
1500 #ifdef _DEBUG_JTAG_IO_
1501 LOG_DEBUG( "clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name( tap_get_state() ) );
1506 LOG_ERROR("BUG: unknown JTAG command type encountered");
1513 if (require_send
> 0)
1514 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1515 retval
= ERROR_JTAG_QUEUE_FAILED
;
1521 #if BUILD_FT2232_FTD2XX == 1
1522 static int ft2232_init_ftd2xx(u16 vid
, u16 pid
, int more
, int* try_more
)
1525 DWORD openex_flags
= 0;
1526 char* openex_string
= NULL
;
1529 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1532 /* Add non-standard Vid/Pid to the linux driver */
1533 if ( ( status
= FT_SetVIDPID(vid
, pid
) ) != FT_OK
)
1535 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1539 if (ft2232_device_desc
&& ft2232_serial
)
1541 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1542 ft2232_device_desc
= NULL
;
1545 if (ft2232_device_desc
)
1547 openex_string
= ft2232_device_desc
;
1548 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1550 else if (ft2232_serial
)
1552 openex_string
= ft2232_serial
;
1553 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1557 LOG_ERROR("neither device description nor serial number specified");
1558 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1560 return ERROR_JTAG_INIT_FAILED
;
1563 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1564 if( status
!= FT_OK
){
1565 // under Win32, the FTD2XX driver appends an "A" to the end
1566 // of the description, if we tried by the desc, then
1567 // try by the alternate "A" description.
1568 if( openex_string
== ft2232_device_desc
){
1569 // Try the alternate method.
1570 openex_string
= ft2232_device_desc_A
;
1571 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1572 if( status
== FT_OK
){
1573 // yea, the "alternate" method worked!
1575 // drat, give the user a meaningfull message.
1576 // telling the use we tried *BOTH* methods.
1577 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1579 ft2232_device_desc_A
);
1584 if ( status
!= FT_OK
)
1590 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1592 return ERROR_JTAG_INIT_FAILED
;
1594 LOG_ERROR("unable to open ftdi device: %lu", status
);
1595 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1596 if (status
== FT_OK
)
1598 char** desc_array
= malloc( sizeof(char*) * (num_devices
+ 1) );
1601 for (i
= 0; i
< num_devices
; i
++)
1602 desc_array
[i
] = malloc(64);
1604 desc_array
[num_devices
] = NULL
;
1606 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1608 if (status
== FT_OK
)
1610 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1611 for (i
= 0; i
< num_devices
; i
++)
1612 LOG_ERROR("%i: \"%s\"", i
, desc_array
[i
]);
1615 for (i
= 0; i
< num_devices
; i
++)
1616 free(desc_array
[i
]);
1622 LOG_ERROR("ListDevices: NONE\n");
1624 return ERROR_JTAG_INIT_FAILED
;
1627 if ( ( status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
) ) != FT_OK
)
1629 LOG_ERROR("unable to set latency timer: %lu", status
);
1630 return ERROR_JTAG_INIT_FAILED
;
1633 if ( ( status
= FT_GetLatencyTimer(ftdih
, &latency_timer
) ) != FT_OK
)
1635 LOG_ERROR("unable to get latency timer: %lu", status
);
1636 return ERROR_JTAG_INIT_FAILED
;
1640 LOG_DEBUG("current latency timer: %i", latency_timer
);
1643 if ( ( status
= FT_SetTimeouts(ftdih
, 5000, 5000) ) != FT_OK
)
1645 LOG_ERROR("unable to set timeouts: %lu", status
);
1646 return ERROR_JTAG_INIT_FAILED
;
1649 if ( ( status
= FT_SetBitMode(ftdih
, 0x0b, 2) ) != FT_OK
)
1651 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1652 return ERROR_JTAG_INIT_FAILED
;
1659 static int ft2232_purge_ftd2xx(void)
1663 if ( ( status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
) ) != FT_OK
)
1665 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1666 return ERROR_JTAG_INIT_FAILED
;
1673 #endif /* BUILD_FT2232_FTD2XX == 1 */
1675 #if BUILD_FT2232_LIBFTDI == 1
1676 static int ft2232_init_libftdi(u16 vid
, u16 pid
, int more
, int* try_more
)
1680 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1681 ft2232_layout
, vid
, pid
);
1683 if (ftdi_init(&ftdic
) < 0)
1684 return ERROR_JTAG_INIT_FAILED
;
1686 /* context, vendor id, product id */
1687 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1691 LOG_WARNING("unable to open ftdi device (trying more): %s",
1694 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1696 return ERROR_JTAG_INIT_FAILED
;
1699 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1701 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1702 return ERROR_JTAG_INIT_FAILED
;
1705 if (ftdi_usb_reset(&ftdic
) < 0)
1707 LOG_ERROR("unable to reset ftdi device");
1708 return ERROR_JTAG_INIT_FAILED
;
1711 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
1713 LOG_ERROR("unable to set latency timer");
1714 return ERROR_JTAG_INIT_FAILED
;
1717 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
1719 LOG_ERROR("unable to get latency timer");
1720 return ERROR_JTAG_INIT_FAILED
;
1724 LOG_DEBUG("current latency timer: %i", latency_timer
);
1727 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
1733 static int ft2232_purge_libftdi(void)
1735 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
1737 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
1738 return ERROR_JTAG_INIT_FAILED
;
1745 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1747 static int ft2232_init(void)
1752 ft2232_layout_t
* cur_layout
= ft2232_layouts
;
1755 if ( (ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0) )
1757 ft2232_layout
= "usbjtag";
1758 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1761 while (cur_layout
->name
)
1763 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
1765 layout
= cur_layout
;
1773 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
1774 return ERROR_JTAG_INIT_FAILED
;
1780 * "more indicates that there are more IDs to try, so we should
1781 * not print an error for an ID mismatch (but for anything
1784 * try_more indicates that the error code returned indicates an
1785 * ID mismatch (and nothing else) and that we should proceeed
1786 * with the next ID pair.
1788 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
1791 #if BUILD_FT2232_FTD2XX == 1
1792 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
1794 #elif BUILD_FT2232_LIBFTDI == 1
1795 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
1800 if (!more
|| !try_more
)
1804 ft2232_buffer_size
= 0;
1805 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
1807 if (layout
->init() != ERROR_OK
)
1808 return ERROR_JTAG_INIT_FAILED
;
1810 ft2232_speed(jtag_speed
);
1812 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1813 if ( ( ( retval
= ft2232_write(buf
, 1, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 1) )
1815 LOG_ERROR("couldn't write to FT2232 to disable loopback");
1816 return ERROR_JTAG_INIT_FAILED
;
1819 #if BUILD_FT2232_FTD2XX == 1
1820 return ft2232_purge_ftd2xx();
1821 #elif BUILD_FT2232_LIBFTDI == 1
1822 return ft2232_purge_libftdi();
1829 static int usbjtag_init(void)
1835 low_direction
= 0x0b;
1837 if (strcmp(ft2232_layout
, "usbjtag") == 0)
1844 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
1851 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
1858 low_direction
= 0x8b;
1862 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
1863 return ERROR_JTAG_INIT_FAILED
;
1866 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1868 low_direction
&= ~nTRSTnOE
; /* nTRST input */
1869 low_output
&= ~nTRST
; /* nTRST = 0 */
1873 low_direction
|= nTRSTnOE
; /* nTRST output */
1874 low_output
|= nTRST
; /* nTRST = 1 */
1877 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1879 low_direction
|= nSRSTnOE
; /* nSRST output */
1880 low_output
|= nSRST
; /* nSRST = 1 */
1884 low_direction
&= ~nSRSTnOE
; /* nSRST input */
1885 low_output
&= ~nSRST
; /* nSRST = 0 */
1888 /* initialize low byte for jtag */
1889 buf
[0] = 0x80; /* command "set data bits low byte" */
1890 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1891 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1892 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
1894 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
1896 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1897 return ERROR_JTAG_INIT_FAILED
;
1904 static int axm0432_jtag_init(void)
1910 low_direction
= 0x2b;
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]);
1918 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
1920 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1921 return ERROR_JTAG_INIT_FAILED
;
1924 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
1927 nTRSTnOE
= 0x0; /* No output enable for TRST*/
1929 nSRSTnOE
= 0x0; /* No output enable for SRST*/
1933 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
1938 high_direction
= 0x0c;
1940 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1942 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
1946 high_output
|= nTRST
;
1949 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1951 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
1955 high_output
|= nSRST
;
1958 /* initialize high port */
1959 buf
[0] = 0x82; /* command "set data bits high byte" */
1960 buf
[1] = high_output
; /* value */
1961 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
1962 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
1964 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
1966 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
1967 return ERROR_JTAG_INIT_FAILED
;
1974 static int jtagkey_init(void)
1980 low_direction
= 0x1b;
1982 /* initialize low byte for jtag */
1983 buf
[0] = 0x80; /* command "set data bits low byte" */
1984 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1985 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1986 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
1988 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
1990 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1991 return ERROR_JTAG_INIT_FAILED
;
1994 if (strcmp(layout
->name
, "jtagkey") == 0)
2001 else if ( (strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2002 || (strcmp(layout
->name
, "oocdlink") == 0) )
2011 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2016 high_direction
= 0x0f;
2018 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2020 high_output
|= nTRSTnOE
;
2021 high_output
&= ~nTRST
;
2025 high_output
&= ~nTRSTnOE
;
2026 high_output
|= nTRST
;
2029 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2031 high_output
&= ~nSRSTnOE
;
2032 high_output
|= nSRST
;
2036 high_output
|= nSRSTnOE
;
2037 high_output
&= ~nSRST
;
2040 /* initialize high port */
2041 buf
[0] = 0x82; /* command "set data bits high byte" */
2042 buf
[1] = high_output
; /* value */
2043 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2044 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2046 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2048 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2049 return ERROR_JTAG_INIT_FAILED
;
2056 static int olimex_jtag_init(void)
2062 low_direction
= 0x1b;
2064 /* initialize low byte for jtag */
2065 buf
[0] = 0x80; /* command "set data bits low byte" */
2066 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2067 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2068 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2070 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2072 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2073 return ERROR_JTAG_INIT_FAILED
;
2079 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2082 high_direction
= 0x0f;
2084 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2086 high_output
|= nTRSTnOE
;
2087 high_output
&= ~nTRST
;
2091 high_output
&= ~nTRSTnOE
;
2092 high_output
|= nTRST
;
2095 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2097 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2101 high_output
&= ~nSRST
;
2104 /* turn red LED on */
2105 high_output
|= 0x08;
2107 /* initialize high port */
2108 buf
[0] = 0x82; /* command "set data bits high byte" */
2109 buf
[1] = high_output
; /* value */
2110 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2111 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2113 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2115 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2116 return ERROR_JTAG_INIT_FAILED
;
2123 static int flyswatter_init(void)
2129 low_direction
= 0xfb;
2131 /* initialize low byte for jtag */
2132 buf
[0] = 0x80; /* command "set data bits low byte" */
2133 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2134 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2135 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2137 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2139 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2140 return ERROR_JTAG_INIT_FAILED
;
2144 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2146 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2149 high_direction
= 0x0c;
2151 /* turn red LED3 on, LED2 off */
2152 high_output
|= 0x08;
2154 /* initialize high port */
2155 buf
[0] = 0x82; /* command "set data bits high byte" */
2156 buf
[1] = high_output
; /* value */
2157 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2158 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2160 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2162 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2163 return ERROR_JTAG_INIT_FAILED
;
2170 static int turtle_init(void)
2176 low_direction
= 0x5b;
2178 /* initialize low byte for jtag */
2179 buf
[0] = 0x80; /* command "set data bits low byte" */
2180 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2181 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2182 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2184 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2186 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2187 return ERROR_JTAG_INIT_FAILED
;
2193 high_direction
= 0x0C;
2195 /* initialize high port */
2196 buf
[0] = 0x82; /* command "set data bits high byte" */
2197 buf
[1] = high_output
;
2198 buf
[2] = high_direction
;
2199 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2201 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2203 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2204 return ERROR_JTAG_INIT_FAILED
;
2211 static int comstick_init(void)
2217 low_direction
= 0x0b;
2219 /* initialize low byte for jtag */
2220 buf
[0] = 0x80; /* command "set data bits low byte" */
2221 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2222 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2223 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2225 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2227 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2228 return ERROR_JTAG_INIT_FAILED
;
2232 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2234 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2237 high_direction
= 0x03;
2239 /* initialize high port */
2240 buf
[0] = 0x82; /* command "set data bits high byte" */
2241 buf
[1] = high_output
;
2242 buf
[2] = high_direction
;
2243 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2245 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2247 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2248 return ERROR_JTAG_INIT_FAILED
;
2255 static int stm32stick_init(void)
2261 low_direction
= 0x8b;
2263 /* initialize low byte for jtag */
2264 buf
[0] = 0x80; /* command "set data bits low byte" */
2265 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2266 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2267 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2269 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2271 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2272 return ERROR_JTAG_INIT_FAILED
;
2276 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2278 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2281 high_direction
= 0x03;
2283 /* initialize high port */
2284 buf
[0] = 0x82; /* command "set data bits high byte" */
2285 buf
[1] = high_output
;
2286 buf
[2] = high_direction
;
2287 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2289 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2291 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2292 return ERROR_JTAG_INIT_FAILED
;
2299 static int sheevaplug_init(void)
2305 low_direction
= 0x1b;
2307 /* initialize low byte for jtag */
2308 buf
[0] = 0x80; /* command "set data bits low byte" */
2309 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2310 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2311 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2313 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2315 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2316 return ERROR_JTAG_INIT_FAILED
;
2325 high_direction
= 0x0f;
2327 /* nTRST is always push-pull */
2328 high_output
&= ~nTRSTnOE
;
2329 high_output
|= nTRST
;
2331 /* nSRST is always open-drain */
2332 high_output
|= nSRSTnOE
;
2333 high_output
&= ~nSRST
;
2335 /* initialize high port */
2336 buf
[0] = 0x82; /* command "set data bits high byte" */
2337 buf
[1] = high_output
; /* value */
2338 buf
[2] = high_direction
; /* all outputs - xRST */
2339 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2341 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2343 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2344 return ERROR_JTAG_INIT_FAILED
;
2350 static void olimex_jtag_blink(void)
2352 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2353 * ACBUS3 is bit 3 of the GPIOH port
2355 if (high_output
& 0x08)
2357 /* set port pin high */
2358 high_output
&= 0x07;
2362 /* set port pin low */
2363 high_output
|= 0x08;
2367 BUFFER_ADD
= high_output
;
2368 BUFFER_ADD
= high_direction
;
2372 static void flyswatter_jtag_blink(void)
2375 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2377 high_output
^= 0x0c;
2380 BUFFER_ADD
= high_output
;
2381 BUFFER_ADD
= high_direction
;
2385 static void turtle_jtag_blink(void)
2388 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2390 if (high_output
& 0x08)
2400 BUFFER_ADD
= high_output
;
2401 BUFFER_ADD
= high_direction
;
2405 static int ft2232_quit(void)
2407 #if BUILD_FT2232_FTD2XX == 1
2410 status
= FT_Close(ftdih
);
2411 #elif BUILD_FT2232_LIBFTDI == 1
2412 ftdi_disable_bitbang(&ftdic
);
2414 ftdi_usb_close(&ftdic
);
2416 ftdi_deinit(&ftdic
);
2419 free(ft2232_buffer
);
2420 ft2232_buffer
= NULL
;
2426 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2432 ft2232_device_desc
= strdup(args
[0]);
2433 cp
= strchr( ft2232_device_desc
, 0 );
2434 // under Win32, the FTD2XX driver appends an "A" to the end
2435 // of the description, this examines the given desc
2436 // and creates the 'missing' _A or non_A variable.
2437 if( (cp
[-1] == 'A') && (cp
[-2]==' ') ){
2438 // it was, so make this the "A" version.
2439 ft2232_device_desc_A
= ft2232_device_desc
;
2440 // and *CREATE* the non-A version.
2441 strcpy( buf
, ft2232_device_desc
);
2442 cp
= strchr( buf
, 0 );
2444 ft2232_device_desc
= strdup( buf
);
2446 // <space>A not defined
2448 sprintf( buf
, "%s A", ft2232_device_desc
);
2449 ft2232_device_desc_A
= strdup( buf
);
2454 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2461 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2465 ft2232_serial
= strdup(args
[0]);
2469 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2476 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2481 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2482 strcpy(ft2232_layout
, args
[0]);
2488 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2492 if (argc
> MAX_USB_IDS
* 2)
2494 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2495 "(maximum is %d pairs)", MAX_USB_IDS
);
2496 argc
= MAX_USB_IDS
* 2;
2498 if ( argc
< 2 || (argc
& 1) )
2500 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2505 for (i
= 0; i
+ 1 < argc
; i
+= 2)
2507 ft2232_vid
[i
>> 1] = strtol(args
[i
], NULL
, 0);
2508 ft2232_pid
[i
>> 1] = strtol(args
[i
+ 1], NULL
, 0);
2512 * Explicitly terminate, in case there are multiples instances of
2515 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2521 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2525 ft2232_latency
= atoi(args
[0]);
2529 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2536 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2540 /* 7 bits of either ones or zeros. */
2541 u8 tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2543 while (num_cycles
> 0)
2545 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2546 * at most 7 bits per invocation. Here we invoke it potentially
2549 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2551 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2553 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2554 retval
= ERROR_JTAG_QUEUE_FAILED
;
2559 /* command "Clock Data to TMS/CS Pin (no Read)" */
2563 BUFFER_ADD
= bitcount_per_command
- 1;
2565 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2570 num_cycles
-= bitcount_per_command
;
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)