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 * Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com *
9 * Dick Hollenbeck <dick@softplc.com> *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
27 /* This code uses information contained in the MPSSE specification which was
29 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
30 * Hereafter this is called the "MPSSE Spec".
32 * The datasheet for the ftdichip.com's FT2232D part is here:
33 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
40 /* project specific includes */
41 #include "interface.h"
43 #include "time_support.h"
51 #if (BUILD_FT2232_FTD2XX == 1 && BUILD_FT2232_LIBFTDI == 1)
52 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
53 #elif (BUILD_FT2232_FTD2XX != 1 && BUILD_FT2232_LIBFTDI != 1)
54 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
57 /* FT2232 access library includes */
58 #if BUILD_FT2232_FTD2XX == 1
60 #elif BUILD_FT2232_LIBFTDI == 1
64 /* max TCK for the high speed devices 30000 kHz */
65 #define FTDI_2232H_4232H_MAX_TCK 30000
66 /* max TCK for the full speed devices 6000 kHz */
67 #define FTDI_2232C_MAX_TCK 6000
68 /* this speed value tells that RTCK is requested */
71 #ifndef BUILD_FT2232_HIGHSPEED
72 #if BUILD_FT2232_FTD2XX == 1
73 enum { FT_DEVICE_2232H
= 6, FT_DEVICE_4232H
};
74 #elif BUILD_FT2232_LIBFTDI == 1
75 enum { TYPE_2232H
= 4, TYPE_4232H
= 5 };
79 static int ft2232_execute_queue(void);
80 static int ft2232_speed(int speed
);
81 static int ft2232_speed_div(int speed
, int* khz
);
82 static int ft2232_khz(int khz
, int* jtag_speed
);
83 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
);
84 static int ft2232_init(void);
85 static int ft2232_quit(void);
87 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
88 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
89 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
90 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
91 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
94 * Send out \a num_cycles on the TCK line while the TAP(s) are in a
95 * stable state. Calling code must ensure that current state is stable,
96 * that verification is not done in here.
98 * @param num_cycles The number of clocks cycles to send.
99 * @param cmd The command to send.
101 * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
103 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
);
105 static char * ft2232_device_desc_A
= NULL
;
106 static char* ft2232_device_desc
= NULL
;
107 static char* ft2232_serial
= NULL
;
108 static char* ft2232_layout
= NULL
;
109 static uint8_t ft2232_latency
= 2;
110 static unsigned ft2232_max_tck
= FTDI_2232C_MAX_TCK
;
112 #define MAX_USB_IDS 8
113 /* vid = pid = 0 marks the end of the list */
114 static uint16_t ft2232_vid
[MAX_USB_IDS
+ 1] = { 0x0403, 0 };
115 static uint16_t ft2232_pid
[MAX_USB_IDS
+ 1] = { 0x6010, 0 };
117 typedef struct ft2232_layout_s
121 void (*reset
)(int trst
, int srst
);
125 /* init procedures for supported layouts */
126 static int usbjtag_init(void);
127 static int jtagkey_init(void);
128 static int olimex_jtag_init(void);
129 static int flyswatter_init(void);
130 static int turtle_init(void);
131 static int comstick_init(void);
132 static int stm32stick_init(void);
133 static int axm0432_jtag_init(void);
134 static int sheevaplug_init(void);
135 static int icebear_jtag_init(void);
136 static int cortino_jtag_init(void);
138 /* reset procedures for supported layouts */
139 static void usbjtag_reset(int trst
, int srst
);
140 static void jtagkey_reset(int trst
, int srst
);
141 static void olimex_jtag_reset(int trst
, int srst
);
142 static void flyswatter_reset(int trst
, int srst
);
143 static void turtle_reset(int trst
, int srst
);
144 static void comstick_reset(int trst
, int srst
);
145 static void stm32stick_reset(int trst
, int srst
);
146 static void axm0432_jtag_reset(int trst
, int srst
);
147 static void sheevaplug_reset(int trst
, int srst
);
148 static void icebear_jtag_reset(int trst
, int srst
);
150 /* blink procedures for layouts that support a blinking led */
151 static void olimex_jtag_blink(void);
152 static void flyswatter_jtag_blink(void);
153 static void turtle_jtag_blink(void);
155 static const ft2232_layout_t ft2232_layouts
[] =
157 { "usbjtag", usbjtag_init
, usbjtag_reset
, NULL
},
158 { "jtagkey", jtagkey_init
, jtagkey_reset
, NULL
},
159 { "jtagkey_prototype_v1", jtagkey_init
, jtagkey_reset
, NULL
},
160 { "oocdlink", jtagkey_init
, jtagkey_reset
, NULL
},
161 { "signalyzer", usbjtag_init
, usbjtag_reset
, NULL
},
162 { "evb_lm3s811", usbjtag_init
, usbjtag_reset
, NULL
},
163 { "luminary_icdi", usbjtag_init
, usbjtag_reset
, NULL
},
164 { "olimex-jtag", olimex_jtag_init
, olimex_jtag_reset
, olimex_jtag_blink
},
165 { "flyswatter", flyswatter_init
, flyswatter_reset
, flyswatter_jtag_blink
},
166 { "turtelizer2", turtle_init
, turtle_reset
, turtle_jtag_blink
},
167 { "comstick", comstick_init
, comstick_reset
, NULL
},
168 { "stm32stick", stm32stick_init
, stm32stick_reset
, NULL
},
169 { "axm0432_jtag", axm0432_jtag_init
, axm0432_jtag_reset
, NULL
},
170 { "sheevaplug", sheevaplug_init
, sheevaplug_reset
, NULL
},
171 { "icebear", icebear_jtag_init
, icebear_jtag_reset
, NULL
},
172 { "cortino", cortino_jtag_init
, comstick_reset
, NULL
},
173 { NULL
, NULL
, NULL
, NULL
},
176 static uint8_t nTRST
, nTRSTnOE
, nSRST
, nSRSTnOE
;
178 static const ft2232_layout_t
*layout
;
179 static uint8_t low_output
= 0x0;
180 static uint8_t low_direction
= 0x0;
181 static uint8_t high_output
= 0x0;
182 static uint8_t high_direction
= 0x0;
184 #if BUILD_FT2232_FTD2XX == 1
185 static FT_HANDLE ftdih
= NULL
;
186 static FT_DEVICE ftdi_device
= 0;
187 #elif BUILD_FT2232_LIBFTDI == 1
188 static struct ftdi_context ftdic
;
189 static enum ftdi_chip_type ftdi_device
;
192 static jtag_command_t
* first_unsent
; /* next command that has to be sent */
193 static int require_send
;
195 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
197 "There is a significant difference between libftdi and libftd2xx. The latter
198 one allows to schedule up to 64*64 bytes of result data while libftdi fails
199 with more than 4*64. As a consequence, the FT2232 driver is forced to
200 perform around 16x more USB transactions for long command streams with TDO
201 capture when running with libftdi."
204 #define FT2232_BUFFER_SIZE 131072
205 a comment would have been nice.
208 #define FT2232_BUFFER_SIZE 131072
210 static uint8_t* ft2232_buffer
= NULL
;
211 static int ft2232_buffer_size
= 0;
212 static int ft2232_read_pointer
= 0;
213 static int ft2232_expect_read
= 0;
216 * Function buffer_write
217 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
218 * @param val is the byte to send.
220 static inline void buffer_write(uint8_t val
)
222 assert(ft2232_buffer
);
223 assert((unsigned) ft2232_buffer_size
< (unsigned) FT2232_BUFFER_SIZE
);
224 ft2232_buffer
[ft2232_buffer_size
++] = val
;
228 * Function buffer_read
229 * returns a byte from the byte buffer.
231 static inline uint8_t buffer_read(void)
233 assert(ft2232_buffer
);
234 assert(ft2232_read_pointer
< ft2232_buffer_size
);
235 return ft2232_buffer
[ft2232_read_pointer
++];
239 * Clocks out \a bit_count bits on the TMS line, starting with the least
240 * significant bit of tms_bits and progressing to more significant bits.
241 * Rigorous state transition logging is done here via tap_set_state().
243 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
244 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
245 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
246 * is often used for this, 0x4b.
248 * @param tms_bits Holds the sequence of bits to send.
249 * @param tms_count Tells how many bits in the sequence.
250 * @param tdi_bit A single bit to pass on to TDI before the first TCK
251 * cycle and held static for the duration of TMS clocking.
253 * See the MPSSE spec referenced above.
255 static void clock_tms(uint8_t mpsse_cmd
, int tms_bits
, int tms_count
, bool tdi_bit
)
259 int tms_ndx
; /* bit index into tms_byte */
261 assert(tms_count
> 0);
264 LOG_DEBUG("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d", mpsse_cmd
, tms_bits
, tms_count
);
267 for (tms_byte
= tms_ndx
= i
= 0; i
< tms_count
; ++i
, tms_bits
>>=1)
269 bool bit
= tms_bits
& 1;
272 tms_byte
|= (1 << tms_ndx
);
274 /* always do state transitions in public view */
275 tap_set_state(tap_state_transition(tap_get_state(), bit
));
277 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
282 if (tms_ndx
== 7 || i
== tms_count
-1)
284 buffer_write(mpsse_cmd
);
285 buffer_write(tms_ndx
- 1);
287 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
288 TMS/CS and is held static for the duration of TMS/CS clocking.
290 buffer_write(tms_byte
| (tdi_bit
<< 7));
296 * Function get_tms_buffer_requirements
297 * returns what clock_tms() will consume if called with
300 static inline int get_tms_buffer_requirements(int bit_count
)
302 return ((bit_count
+ 6)/7) * 3;
306 * Function move_to_state
307 * moves the TAP controller from the current state to a
308 * \a goal_state through a path given by tap_get_tms_path(). State transition
309 * logging is performed by delegation to clock_tms().
311 * @param goal_state is the destination state for the move.
313 static void move_to_state(tap_state_t goal_state
)
315 tap_state_t start_state
= tap_get_state();
317 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
318 lookup of the required TMS pattern to move to this state from the
322 /* do the 2 lookups */
323 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
324 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
326 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
328 clock_tms(0x4b, tms_bits
, tms_count
, 0);
331 jtag_interface_t ft2232_interface
=
334 .execute_queue
= ft2232_execute_queue
,
335 .speed
= ft2232_speed
,
336 .speed_div
= ft2232_speed_div
,
338 .register_commands
= ft2232_register_commands
,
343 static int ft2232_write(uint8_t* buf
, int size
, uint32_t* bytes_written
)
345 #if BUILD_FT2232_FTD2XX == 1
347 DWORD dw_bytes_written
;
348 if ((status
= FT_Write(ftdih
, buf
, size
, &dw_bytes_written
)) != FT_OK
)
350 *bytes_written
= dw_bytes_written
;
351 LOG_ERROR("FT_Write returned: %lu", status
);
352 return ERROR_JTAG_DEVICE_ERROR
;
356 *bytes_written
= dw_bytes_written
;
359 #elif BUILD_FT2232_LIBFTDI == 1
361 if ((retval
= ftdi_write_data(&ftdic
, buf
, size
)) < 0)
364 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic
));
365 return ERROR_JTAG_DEVICE_ERROR
;
369 *bytes_written
= retval
;
375 static int ft2232_read(uint8_t* buf
, uint32_t size
, uint32_t* bytes_read
)
377 #if BUILD_FT2232_FTD2XX == 1
383 while ((*bytes_read
< size
) && timeout
--)
385 if ((status
= FT_Read(ftdih
, buf
+ *bytes_read
, size
-
386 *bytes_read
, &dw_bytes_read
)) != FT_OK
)
389 LOG_ERROR("FT_Read returned: %lu", status
);
390 return ERROR_JTAG_DEVICE_ERROR
;
392 *bytes_read
+= dw_bytes_read
;
395 #elif BUILD_FT2232_LIBFTDI == 1
400 while ((*bytes_read
< size
) && timeout
--)
402 if ((retval
= ftdi_read_data(&ftdic
, buf
+ *bytes_read
, size
- *bytes_read
)) < 0)
405 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic
));
406 return ERROR_JTAG_DEVICE_ERROR
;
408 *bytes_read
+= retval
;
413 if (*bytes_read
< size
)
415 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)",
416 (unsigned int)(*bytes_read
),
418 return ERROR_JTAG_DEVICE_ERROR
;
424 static bool ft2232_device_is_highspeed(void)
426 #if BUILD_FT2232_FTD2XX == 1
427 return (ftdi_device
== FT_DEVICE_2232H
) || (ftdi_device
== FT_DEVICE_4232H
);
428 #elif BUILD_FT2232_LIBFTDI == 1
429 return (ftdi_device
== TYPE_2232H
|| ftdi_device
== TYPE_4232H
);
434 * Commands that only apply to the FT2232H and FT4232H devices.
435 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
436 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
439 static int ft2232h_ft4232h_adaptive_clocking(bool enable
)
441 uint8_t buf
= enable
? 0x96 : 0x97;
442 LOG_DEBUG("%2.2x", buf
);
444 uint32_t bytes_written
;
445 int retval
= ft2232_write(&buf
, 1, &bytes_written
);
446 if ((ERROR_OK
!= retval
) || (bytes_written
!= 1))
448 LOG_ERROR("couldn't write command to %s adaptive clocking"
449 , enable
? "enable" : "disable");
457 * Enable/disable the clk divide by 5 of the 60MHz master clock.
458 * This result in a JTAG clock speed range of 91.553Hz-6MHz
459 * respective 457.763Hz-30MHz.
461 static int ft2232h_ft4232h_clk_divide_by_5(bool enable
)
463 uint32_t bytes_written
;
464 uint8_t buf
= enable
? 0x8b : 0x8a;
465 int retval
= ft2232_write(&buf
, 1, &bytes_written
);
466 if ((ERROR_OK
!= retval
) || (bytes_written
!= 1))
468 LOG_ERROR("couldn't write command to %s clk divide by 5"
469 , enable
? "enable" : "disable");
470 return ERROR_JTAG_INIT_FAILED
;
472 ft2232_max_tck
= enable
? FTDI_2232C_MAX_TCK
: FTDI_2232H_4232H_MAX_TCK
;
473 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck
);
478 static int ft2232_speed(int speed
)
482 uint32_t bytes_written
;
485 bool enable_adaptive_clocking
= (RTCK_SPEED
== speed
);
486 if (ft2232_device_is_highspeed())
487 retval
= ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking
);
488 else if (enable_adaptive_clocking
)
490 LOG_ERROR("ft2232 device %lu does not support RTCK"
491 , (long unsigned int)ftdi_device
);
495 if ((enable_adaptive_clocking
) || (ERROR_OK
!= retval
))
498 buf
[0] = 0x86; /* command "set divisor" */
499 buf
[1] = speed
& 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
500 buf
[2] = (speed
>> 8) & 0xff; /* valueH */
502 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
503 if (((retval
= ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
505 LOG_ERROR("couldn't set FT2232 TCK speed");
512 static int ft2232_speed_div(int speed
, int* khz
)
514 /* Take a look in the FT2232 manual,
515 * AN2232C-01 Command Processor for
516 * MPSSE and MCU Host Bus. Chapter 3.8 */
518 *khz
= (RTCK_SPEED
== speed
) ? 0 : ft2232_max_tck
/ (1 + speed
);
523 static int ft2232_khz(int khz
, int* jtag_speed
)
527 if (ft2232_device_is_highspeed())
529 *jtag_speed
= RTCK_SPEED
;
534 LOG_DEBUG("RCLK not supported");
539 /* Take a look in the FT2232 manual,
540 * AN2232C-01 Command Processor for
541 * MPSSE and MCU Host Bus. Chapter 3.8
543 * We will calc here with a multiplier
544 * of 10 for better rounding later. */
546 /* Calc speed, (ft2232_max_tck / khz) - 1 */
547 /* Use 65000 for better rounding */
548 *jtag_speed
= ((ft2232_max_tck
*10) / khz
) - 10;
550 /* Add 0.9 for rounding */
553 /* Calc real speed */
554 *jtag_speed
= *jtag_speed
/ 10;
556 /* Check if speed is greater than 0 */
562 /* Check max value */
563 if (*jtag_speed
> 0xFFFF)
565 *jtag_speed
= 0xFFFF;
571 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
)
573 register_command(cmd_ctx
, NULL
, "ft2232_device_desc", ft2232_handle_device_desc_command
,
574 COMMAND_CONFIG
, "the USB device description of the FTDI FT2232 device");
575 register_command(cmd_ctx
, NULL
, "ft2232_serial", ft2232_handle_serial_command
,
576 COMMAND_CONFIG
, "the serial number of the FTDI FT2232 device");
577 register_command(cmd_ctx
, NULL
, "ft2232_layout", ft2232_handle_layout_command
,
578 COMMAND_CONFIG
, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
579 register_command(cmd_ctx
, NULL
, "ft2232_vid_pid", ft2232_handle_vid_pid_command
,
580 COMMAND_CONFIG
, "the vendor ID and product ID of the FTDI FT2232 device");
581 register_command(cmd_ctx
, NULL
, "ft2232_latency", ft2232_handle_latency_command
,
582 COMMAND_CONFIG
, "set the FT2232 latency timer to a new value");
586 static void ft2232_end_state(tap_state_t state
)
588 if (tap_is_state_stable(state
))
589 tap_set_end_state(state
);
592 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
597 static void ft2232_read_scan(enum scan_type type
, uint8_t* buffer
, int scan_size
)
599 int num_bytes
= (scan_size
+ 7) / 8;
600 int bits_left
= scan_size
;
603 while (num_bytes
-- > 1)
605 buffer
[cur_byte
++] = buffer_read();
609 buffer
[cur_byte
] = 0x0;
611 /* There is one more partial byte left from the clock data in/out instructions */
614 buffer
[cur_byte
] = buffer_read() >> 1;
616 /* This shift depends on the length of the clock data to tms instruction, insterted at end of the scan, now fixed to a two step transition in ft2232_add_scan */
617 buffer
[cur_byte
] = (buffer
[cur_byte
] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left
);
620 static void ft2232_debug_dump_buffer(void)
626 for (i
= 0; i
< ft2232_buffer_size
; i
++)
628 line_p
+= snprintf(line_p
, 256 - (line_p
- line
), "%2.2x ", ft2232_buffer
[i
]);
631 LOG_DEBUG("%s", line
);
637 LOG_DEBUG("%s", line
);
640 static int ft2232_send_and_recv(jtag_command_t
* first
, jtag_command_t
* last
)
647 uint32_t bytes_written
= 0;
648 uint32_t bytes_read
= 0;
650 #ifdef _DEBUG_USB_IO_
651 struct timeval start
, inter
, inter2
, end
;
652 struct timeval d_inter
, d_inter2
, d_end
;
655 #ifdef _DEBUG_USB_COMMS_
656 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size
);
657 ft2232_debug_dump_buffer();
660 #ifdef _DEBUG_USB_IO_
661 gettimeofday(&start
, NULL
);
664 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
666 LOG_ERROR("couldn't write MPSSE commands to FT2232");
670 #ifdef _DEBUG_USB_IO_
671 gettimeofday(&inter
, NULL
);
674 if (ft2232_expect_read
)
677 ft2232_buffer_size
= 0;
679 #ifdef _DEBUG_USB_IO_
680 gettimeofday(&inter2
, NULL
);
683 if ((retval
= ft2232_read(ft2232_buffer
, ft2232_expect_read
, &bytes_read
)) != ERROR_OK
)
685 LOG_ERROR("couldn't read from FT2232");
689 #ifdef _DEBUG_USB_IO_
690 gettimeofday(&end
, NULL
);
692 timeval_subtract(&d_inter
, &inter
, &start
);
693 timeval_subtract(&d_inter2
, &inter2
, &start
);
694 timeval_subtract(&d_end
, &end
, &start
);
696 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
697 (unsigned)d_inter
.tv_sec
, (unsigned)d_inter
.tv_usec
,
698 (unsigned)d_inter2
.tv_sec
, (unsigned)d_inter2
.tv_usec
,
699 (unsigned)d_end
.tv_sec
, (unsigned)d_end
.tv_usec
);
702 ft2232_buffer_size
= bytes_read
;
704 if (ft2232_expect_read
!= ft2232_buffer_size
)
706 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read
,
709 ft2232_debug_dump_buffer();
714 #ifdef _DEBUG_USB_COMMS_
715 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout
, ft2232_buffer_size
);
716 ft2232_debug_dump_buffer();
720 ft2232_expect_read
= 0;
721 ft2232_read_pointer
= 0;
723 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
724 * that wasn't handled by a caller-provided error handler
734 type
= jtag_scan_type(cmd
->cmd
.scan
);
735 if (type
!= SCAN_OUT
)
737 scan_size
= jtag_scan_size(cmd
->cmd
.scan
);
738 buffer
= calloc(CEIL(scan_size
, 8), 1);
739 ft2232_read_scan(type
, buffer
, scan_size
);
740 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
741 retval
= ERROR_JTAG_QUEUE_FAILED
;
753 ft2232_buffer_size
= 0;
759 * Function ft2232_add_pathmove
760 * moves the TAP controller from the current state to a new state through the
761 * given path, where path is an array of tap_state_t's.
763 * @param path is an array of tap_stat_t which gives the states to traverse through
764 * ending with the last state at path[num_states-1]
765 * @param num_states is the count of state steps to move through
767 static void ft2232_add_pathmove(tap_state_t
* path
, int num_states
)
771 tap_state_t walker
= tap_get_state();
773 assert((unsigned) num_states
<= 32u); /* tms_bits only holds 32 bits */
775 /* this loop verifies that the path is legal and logs each state in the path */
776 for (state_ndx
= 0; state_ndx
< num_states
; ++state_ndx
)
778 tap_state_t desired_next_state
= path
[state_ndx
];
780 if (tap_state_transition(walker
, false) == desired_next_state
)
781 ; /* bit within tms_bits at index state_ndx is already zero */
782 else if (tap_state_transition(walker
, true) == desired_next_state
)
783 tms_bits
|= (1 << state_ndx
);
786 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
787 tap_state_name(walker
), tap_state_name(desired_next_state
));
791 walker
= desired_next_state
;
794 clock_tms(0x4b, tms_bits
, num_states
, 0);
796 tap_set_end_state(tap_get_state());
799 static void ft2232_add_scan(bool ir_scan
, enum scan_type type
, uint8_t* buffer
, int scan_size
)
801 int num_bytes
= (scan_size
+ 7) / 8;
802 int bits_left
= scan_size
;
808 if (tap_get_state() != TAP_DRSHIFT
)
810 move_to_state(TAP_DRSHIFT
);
815 if (tap_get_state() != TAP_IRSHIFT
)
817 move_to_state(TAP_IRSHIFT
);
821 /* add command for complete bytes */
822 while (num_bytes
> 1)
827 /* Clock Data Bytes In and Out LSB First */
829 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
831 else if (type
== SCAN_OUT
)
833 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
835 /* LOG_DEBUG("added TDI bytes (o)"); */
837 else if (type
== SCAN_IN
)
839 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
841 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
844 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
845 num_bytes
-= thisrun_bytes
;
847 buffer_write((uint8_t) (thisrun_bytes
- 1));
848 buffer_write((uint8_t) ((thisrun_bytes
- 1) >> 8));
852 /* add complete bytes */
853 while (thisrun_bytes
-- > 0)
855 buffer_write(buffer
[cur_byte
++]);
859 else /* (type == SCAN_IN) */
861 bits_left
-= 8 * (thisrun_bytes
);
865 /* the most signifcant bit is scanned during TAP movement */
867 last_bit
= (buffer
[cur_byte
] >> (bits_left
- 1)) & 0x1;
871 /* process remaining bits but the last one */
876 /* Clock Data Bits In and Out LSB First */
878 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
880 else if (type
== SCAN_OUT
)
882 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
884 /* LOG_DEBUG("added TDI bits (o)"); */
886 else if (type
== SCAN_IN
)
888 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
890 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
893 buffer_write(bits_left
- 2);
895 buffer_write(buffer
[cur_byte
]);
898 if ((ir_scan
&& (tap_get_end_state() == TAP_IRSHIFT
))
899 || (!ir_scan
&& (tap_get_end_state() == TAP_DRSHIFT
)))
903 /* Clock Data Bits In and Out LSB First */
905 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
907 else if (type
== SCAN_OUT
)
909 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
911 /* LOG_DEBUG("added TDI bits (o)"); */
913 else if (type
== SCAN_IN
)
915 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
917 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
920 buffer_write(last_bit
);
928 /* move from Shift-IR/DR to end state */
929 if (type
!= SCAN_OUT
)
931 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
932 /* This must be coordinated with the bit shifts in ft2232_read_scan */
935 /* Clock Data to TMS/CS Pin with Read */
937 /* LOG_DEBUG("added TMS scan (read)"); */
941 tms_bits
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
942 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
943 /* Clock Data to TMS/CS Pin (no Read) */
945 /* LOG_DEBUG("added TMS scan (no read)"); */
948 clock_tms(mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
951 if (tap_get_state() != tap_get_end_state())
953 move_to_state(tap_get_end_state());
957 static int ft2232_large_scan(scan_command_t
* cmd
, enum scan_type type
, uint8_t* buffer
, int scan_size
)
959 int num_bytes
= (scan_size
+ 7) / 8;
960 int bits_left
= scan_size
;
963 uint8_t* receive_buffer
= malloc(CEIL(scan_size
, 8));
964 uint8_t* receive_pointer
= receive_buffer
;
965 uint32_t bytes_written
;
968 int thisrun_read
= 0;
972 LOG_ERROR("BUG: large IR scans are not supported");
976 if (tap_get_state() != TAP_DRSHIFT
)
978 move_to_state(TAP_DRSHIFT
);
981 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
983 LOG_ERROR("couldn't write MPSSE commands to FT2232");
986 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
987 ft2232_buffer_size
, (int)bytes_written
);
988 ft2232_buffer_size
= 0;
990 /* add command for complete bytes */
991 while (num_bytes
> 1)
997 /* Clock Data Bytes In and Out LSB First */
999 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1001 else if (type
== SCAN_OUT
)
1003 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1005 /* LOG_DEBUG("added TDI bytes (o)"); */
1007 else if (type
== SCAN_IN
)
1009 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1011 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1014 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
1015 thisrun_read
= thisrun_bytes
;
1016 num_bytes
-= thisrun_bytes
;
1017 buffer_write((uint8_t) (thisrun_bytes
- 1));
1018 buffer_write((uint8_t) ((thisrun_bytes
- 1) >> 8));
1020 if (type
!= SCAN_IN
)
1022 /* add complete bytes */
1023 while (thisrun_bytes
-- > 0)
1025 buffer_write(buffer
[cur_byte
]);
1030 else /* (type == SCAN_IN) */
1032 bits_left
-= 8 * (thisrun_bytes
);
1035 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
1037 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1040 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1042 (int)bytes_written
);
1043 ft2232_buffer_size
= 0;
1045 if (type
!= SCAN_OUT
)
1047 if ((retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
)) != ERROR_OK
)
1049 LOG_ERROR("couldn't read from FT2232");
1052 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1055 receive_pointer
+= bytes_read
;
1061 /* the most signifcant bit is scanned during TAP movement */
1062 if (type
!= SCAN_IN
)
1063 last_bit
= (buffer
[cur_byte
] >> (bits_left
- 1)) & 0x1;
1067 /* process remaining bits but the last one */
1070 if (type
== SCAN_IO
)
1072 /* Clock Data Bits In and Out LSB First */
1074 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1076 else if (type
== SCAN_OUT
)
1078 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1080 /* LOG_DEBUG("added TDI bits (o)"); */
1082 else if (type
== SCAN_IN
)
1084 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1086 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1088 buffer_write(bits_left
- 2);
1089 if (type
!= SCAN_IN
)
1090 buffer_write(buffer
[cur_byte
]);
1092 if (type
!= SCAN_OUT
)
1096 if (tap_get_end_state() == TAP_DRSHIFT
)
1098 if (type
== SCAN_IO
)
1100 /* Clock Data Bits In and Out LSB First */
1102 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1104 else if (type
== SCAN_OUT
)
1106 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1108 /* LOG_DEBUG("added TDI bits (o)"); */
1110 else if (type
== SCAN_IN
)
1112 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1114 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1117 buffer_write(last_bit
);
1121 int tms_bits
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1122 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1125 /* move from Shift-IR/DR to end state */
1126 if (type
!= SCAN_OUT
)
1128 /* Clock Data to TMS/CS Pin with Read */
1130 /* LOG_DEBUG("added TMS scan (read)"); */
1134 /* Clock Data to TMS/CS Pin (no Read) */
1136 /* LOG_DEBUG("added TMS scan (no read)"); */
1139 clock_tms(mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
1142 if (type
!= SCAN_OUT
)
1145 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
1147 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1150 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1152 (int)bytes_written
);
1153 ft2232_buffer_size
= 0;
1155 if (type
!= SCAN_OUT
)
1157 if ((retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
)) != ERROR_OK
)
1159 LOG_ERROR("couldn't read from FT2232");
1162 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1165 receive_pointer
+= bytes_read
;
1171 static int ft2232_predict_scan_out(int scan_size
, enum scan_type type
)
1173 int predicted_size
= 3;
1174 int num_bytes
= (scan_size
- 1) / 8;
1176 if (tap_get_state() != TAP_DRSHIFT
)
1177 predicted_size
+= get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT
));
1179 if (type
== SCAN_IN
) /* only from device to host */
1181 /* complete bytes */
1182 predicted_size
+= CEIL(num_bytes
, 65536) * 3;
1184 /* remaining bits - 1 (up to 7) */
1185 predicted_size
+= ((scan_size
- 1) % 8) ? 2 : 0;
1187 else /* host to device, or bidirectional */
1189 /* complete bytes */
1190 predicted_size
+= num_bytes
+ CEIL(num_bytes
, 65536) * 3;
1192 /* remaining bits -1 (up to 7) */
1193 predicted_size
+= ((scan_size
- 1) % 8) ? 3 : 0;
1196 return predicted_size
;
1199 static int ft2232_predict_scan_in(int scan_size
, enum scan_type type
)
1201 int predicted_size
= 0;
1203 if (type
!= SCAN_OUT
)
1205 /* complete bytes */
1206 predicted_size
+= (CEIL(scan_size
, 8) > 1) ? (CEIL(scan_size
, 8) - 1) : 0;
1208 /* remaining bits - 1 */
1209 predicted_size
+= ((scan_size
- 1) % 8) ? 1 : 0;
1211 /* last bit (from TMS scan) */
1212 predicted_size
+= 1;
1215 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1217 return predicted_size
;
1220 static void usbjtag_reset(int trst
, int srst
)
1222 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1225 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1226 low_direction
|= nTRSTnOE
; /* switch to output pin (output is low) */
1228 low_output
&= ~nTRST
; /* switch output low */
1232 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1233 low_direction
&= ~nTRSTnOE
; /* switch to input pin (high-Z + internal and external pullup) */
1235 low_output
|= nTRST
; /* switch output high */
1240 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1241 low_output
&= ~nSRST
; /* switch output low */
1243 low_direction
|= nSRSTnOE
; /* switch to output pin (output is low) */
1247 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1248 low_output
|= nSRST
; /* switch output high */
1250 low_direction
&= ~nSRSTnOE
; /* switch to input pin (high-Z) */
1253 /* command "set data bits low byte" */
1255 buffer_write(low_output
);
1256 buffer_write(low_direction
);
1259 static void jtagkey_reset(int trst
, int srst
)
1261 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1264 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1265 high_output
&= ~nTRSTnOE
;
1267 high_output
&= ~nTRST
;
1271 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1272 high_output
|= nTRSTnOE
;
1274 high_output
|= nTRST
;
1279 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1280 high_output
&= ~nSRST
;
1282 high_output
&= ~nSRSTnOE
;
1286 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1287 high_output
|= nSRST
;
1289 high_output
|= nSRSTnOE
;
1292 /* command "set data bits high byte" */
1294 buffer_write(high_output
);
1295 buffer_write(high_direction
);
1296 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1300 static void olimex_jtag_reset(int trst
, int srst
)
1302 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1305 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1306 high_output
&= ~nTRSTnOE
;
1308 high_output
&= ~nTRST
;
1312 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1313 high_output
|= nTRSTnOE
;
1315 high_output
|= nTRST
;
1320 high_output
|= nSRST
;
1324 high_output
&= ~nSRST
;
1327 /* command "set data bits high byte" */
1329 buffer_write(high_output
);
1330 buffer_write(high_direction
);
1331 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1335 static void axm0432_jtag_reset(int trst
, int srst
)
1339 tap_set_state(TAP_RESET
);
1340 high_output
&= ~nTRST
;
1344 high_output
|= nTRST
;
1349 high_output
&= ~nSRST
;
1353 high_output
|= nSRST
;
1356 /* command "set data bits low byte" */
1358 buffer_write(high_output
);
1359 buffer_write(high_direction
);
1360 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1364 static void flyswatter_reset(int trst
, int srst
)
1368 low_output
&= ~nTRST
;
1372 low_output
|= nTRST
;
1377 low_output
|= nSRST
;
1381 low_output
&= ~nSRST
;
1384 /* command "set data bits low byte" */
1386 buffer_write(low_output
);
1387 buffer_write(low_direction
);
1388 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst
, srst
, low_output
, low_direction
);
1391 static void turtle_reset(int trst
, int srst
)
1397 low_output
|= nSRST
;
1401 low_output
&= ~nSRST
;
1404 /* command "set data bits low byte" */
1406 buffer_write(low_output
);
1407 buffer_write(low_direction
);
1408 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst
, low_output
, low_direction
);
1411 static void comstick_reset(int trst
, int srst
)
1415 high_output
&= ~nTRST
;
1419 high_output
|= nTRST
;
1424 high_output
&= ~nSRST
;
1428 high_output
|= nSRST
;
1431 /* command "set data bits high byte" */
1433 buffer_write(high_output
);
1434 buffer_write(high_direction
);
1435 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1439 static void stm32stick_reset(int trst
, int srst
)
1443 high_output
&= ~nTRST
;
1447 high_output
|= nTRST
;
1452 low_output
&= ~nSRST
;
1456 low_output
|= nSRST
;
1459 /* command "set data bits low byte" */
1461 buffer_write(low_output
);
1462 buffer_write(low_direction
);
1464 /* command "set data bits high byte" */
1466 buffer_write(high_output
);
1467 buffer_write(high_direction
);
1468 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1472 static void sheevaplug_reset(int trst
, int srst
)
1475 high_output
&= ~nTRST
;
1477 high_output
|= nTRST
;
1480 high_output
&= ~nSRSTnOE
;
1482 high_output
|= nSRSTnOE
;
1484 /* command "set data bits high byte" */
1486 buffer_write(high_output
);
1487 buffer_write(high_direction
);
1488 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
, high_direction
);
1491 static int ft2232_execute_runtest(jtag_command_t
*cmd
)
1495 int predicted_size
= 0;
1498 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1499 cmd
->cmd
.runtest
->num_cycles
,
1500 tap_state_name(cmd
->cmd
.runtest
->end_state
));
1502 /* only send the maximum buffer size that FT2232C can handle */
1504 if (tap_get_state() != TAP_IDLE
)
1505 predicted_size
+= 3;
1506 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1507 if (cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
)
1508 predicted_size
+= 3;
1509 if (tap_get_end_state() != TAP_IDLE
)
1510 predicted_size
+= 3;
1511 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1513 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1514 retval
= ERROR_JTAG_QUEUE_FAILED
;
1518 if (tap_get_state() != TAP_IDLE
)
1520 move_to_state(TAP_IDLE
);
1523 i
= cmd
->cmd
.runtest
->num_cycles
;
1526 /* there are no state transitions in this code, so omit state tracking */
1528 /* command "Clock Data to TMS/CS Pin (no Read)" */
1532 buffer_write((i
> 7) ? 6 : (i
- 1));
1536 tap_set_state(TAP_IDLE
);
1538 i
-= (i
> 7) ? 7 : i
;
1539 /* LOG_DEBUG("added TMS scan (no read)"); */
1542 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1544 if (tap_get_state() != tap_get_end_state())
1546 move_to_state(tap_get_end_state());
1550 #ifdef _DEBUG_JTAG_IO_
1551 LOG_DEBUG("runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name(tap_get_end_state()));
1557 static int ft2232_execute_statemove(jtag_command_t
*cmd
)
1559 int predicted_size
= 0;
1560 int retval
= ERROR_OK
;
1562 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1564 /* only send the maximum buffer size that FT2232C can handle */
1566 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1568 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1569 retval
= ERROR_JTAG_QUEUE_FAILED
;
1573 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1575 /* move to end state */
1576 if (tap_get_state() != tap_get_end_state())
1578 move_to_state(tap_get_end_state());
1585 static int ft2232_execute_pathmove(jtag_command_t
*cmd
)
1587 int predicted_size
= 0;
1588 int retval
= ERROR_OK
;
1590 tap_state_t
* path
= cmd
->cmd
.pathmove
->path
;
1591 int num_states
= cmd
->cmd
.pathmove
->num_states
;
1593 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
1594 tap_state_name(tap_get_state()),
1595 tap_state_name(path
[num_states
-1]));
1597 /* only send the maximum buffer size that FT2232C can handle */
1598 predicted_size
= 3 * CEIL(num_states
, 7);
1599 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1601 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1602 retval
= ERROR_JTAG_QUEUE_FAILED
;
1608 ft2232_add_pathmove(path
, num_states
);
1614 static int ft2232_execute_scan(jtag_command_t
*cmd
)
1617 int scan_size
; /* size of IR or DR scan */
1618 int predicted_size
= 0;
1619 int retval
= ERROR_OK
;
1621 enum scan_type type
= jtag_scan_type(cmd
->cmd
.scan
);
1623 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN", type
);
1625 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1627 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1628 if ((predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1630 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1631 /* unsent commands before this */
1632 if (first_unsent
!= cmd
)
1633 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1634 retval
= ERROR_JTAG_QUEUE_FAILED
;
1636 /* current command */
1637 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1638 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1640 first_unsent
= cmd
->next
;
1645 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1647 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1650 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1651 retval
= ERROR_JTAG_QUEUE_FAILED
;
1655 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1656 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1657 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1658 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1662 #ifdef _DEBUG_JTAG_IO_
1663 LOG_DEBUG("%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1664 tap_state_name(tap_get_end_state()));
1670 static int ft2232_execute_reset(jtag_command_t
*cmd
)
1673 int predicted_size
= 0;
1676 DEBUG_JTAG_IO("reset trst: %i srst %i",
1677 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1679 /* only send the maximum buffer size that FT2232C can handle */
1681 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1683 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1684 retval
= ERROR_JTAG_QUEUE_FAILED
;
1689 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1692 #ifdef _DEBUG_JTAG_IO_
1693 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1698 static int ft2232_execute_sleep(jtag_command_t
*cmd
)
1703 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
1705 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1706 retval
= ERROR_JTAG_QUEUE_FAILED
;
1707 first_unsent
= cmd
->next
;
1708 jtag_sleep(cmd
->cmd
.sleep
->us
);
1709 #ifdef _DEBUG_JTAG_IO_
1710 LOG_DEBUG("sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name(tap_get_state()));
1716 static int ft2232_execute_stableclocks(jtag_command_t
*cmd
)
1721 /* this is only allowed while in a stable state. A check for a stable
1722 * state was done in jtag_add_clocks()
1724 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1725 retval
= ERROR_JTAG_QUEUE_FAILED
;
1726 #ifdef _DEBUG_JTAG_IO_
1727 LOG_DEBUG("clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name(tap_get_state()));
1733 static int ft2232_execute_command(jtag_command_t
*cmd
)
1740 case JTAG_RESET
: retval
= ft2232_execute_reset(cmd
); break;
1741 case JTAG_RUNTEST
: retval
= ft2232_execute_runtest(cmd
); break;
1742 case JTAG_STATEMOVE
: retval
= ft2232_execute_statemove(cmd
); break;
1743 case JTAG_PATHMOVE
: retval
= ft2232_execute_pathmove(cmd
); break;
1744 case JTAG_SCAN
: retval
= ft2232_execute_scan(cmd
); break;
1745 case JTAG_SLEEP
: retval
= ft2232_execute_sleep(cmd
); break;
1746 case JTAG_STABLECLOCKS
: retval
= ft2232_execute_stableclocks(cmd
); break;
1748 LOG_ERROR("BUG: unknown JTAG command type encountered");
1754 static int ft2232_execute_queue()
1756 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1759 first_unsent
= cmd
; /* next command that has to be sent */
1762 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1763 * that wasn't handled by a caller-provided error handler
1767 ft2232_buffer_size
= 0;
1768 ft2232_expect_read
= 0;
1770 /* blink, if the current layout has that feature */
1776 if (ft2232_execute_command(cmd
) != ERROR_OK
)
1777 retval
= ERROR_JTAG_QUEUE_FAILED
;
1778 /* Start reading input before FT2232 TX buffer fills up */
1780 if (ft2232_expect_read
> 256)
1782 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1783 retval
= ERROR_JTAG_QUEUE_FAILED
;
1788 if (require_send
> 0)
1789 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1790 retval
= ERROR_JTAG_QUEUE_FAILED
;
1795 #if BUILD_FT2232_FTD2XX == 1
1796 static int ft2232_init_ftd2xx(uint16_t vid
, uint16_t pid
, int more
, int* try_more
)
1800 char SerialNumber
[16];
1801 char Description
[64];
1802 DWORD openex_flags
= 0;
1803 char* openex_string
= NULL
;
1804 uint8_t latency_timer
;
1806 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1809 /* Add non-standard Vid/Pid to the linux driver */
1810 if ((status
= FT_SetVIDPID(vid
, pid
)) != FT_OK
)
1812 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1816 if (ft2232_device_desc
&& ft2232_serial
)
1818 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1819 ft2232_device_desc
= NULL
;
1822 if (ft2232_device_desc
)
1824 openex_string
= ft2232_device_desc
;
1825 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1827 else if (ft2232_serial
)
1829 openex_string
= ft2232_serial
;
1830 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1834 LOG_ERROR("neither device description nor serial number specified");
1835 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1837 return ERROR_JTAG_INIT_FAILED
;
1840 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1841 if (status
!= FT_OK
) {
1842 /* under Win32, the FTD2XX driver appends an "A" to the end
1843 * of the description, if we tried by the desc, then
1844 * try by the alternate "A" description. */
1845 if (openex_string
== ft2232_device_desc
) {
1846 /* Try the alternate method. */
1847 openex_string
= ft2232_device_desc_A
;
1848 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1849 if (status
== FT_OK
) {
1850 /* yea, the "alternate" method worked! */
1852 /* drat, give the user a meaningfull message.
1853 * telling the use we tried *BOTH* methods. */
1854 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1856 ft2232_device_desc_A
);
1861 if (status
!= FT_OK
)
1867 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1869 return ERROR_JTAG_INIT_FAILED
;
1871 LOG_ERROR("unable to open ftdi device: %lu", status
);
1872 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1873 if (status
== FT_OK
)
1875 char** desc_array
= malloc(sizeof(char*) * (num_devices
+ 1));
1878 for (i
= 0; i
< num_devices
; i
++)
1879 desc_array
[i
] = malloc(64);
1881 desc_array
[num_devices
] = NULL
;
1883 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1885 if (status
== FT_OK
)
1887 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1888 for (i
= 0; i
< num_devices
; i
++)
1889 LOG_ERROR("%" PRIu32
": \"%s\"", i
, desc_array
[i
]);
1892 for (i
= 0; i
< num_devices
; i
++)
1893 free(desc_array
[i
]);
1899 LOG_ERROR("ListDevices: NONE\n");
1901 return ERROR_JTAG_INIT_FAILED
;
1904 if ((status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
)) != FT_OK
)
1906 LOG_ERROR("unable to set latency timer: %lu", status
);
1907 return ERROR_JTAG_INIT_FAILED
;
1910 if ((status
= FT_GetLatencyTimer(ftdih
, &latency_timer
)) != FT_OK
)
1912 LOG_ERROR("unable to get latency timer: %lu", status
);
1913 return ERROR_JTAG_INIT_FAILED
;
1917 LOG_DEBUG("current latency timer: %i", latency_timer
);
1920 if ((status
= FT_SetTimeouts(ftdih
, 5000, 5000)) != FT_OK
)
1922 LOG_ERROR("unable to set timeouts: %lu", status
);
1923 return ERROR_JTAG_INIT_FAILED
;
1926 if ((status
= FT_SetBitMode(ftdih
, 0x0b, 2)) != FT_OK
)
1928 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1929 return ERROR_JTAG_INIT_FAILED
;
1932 if ((status
= FT_GetDeviceInfo(ftdih
, &ftdi_device
, &deviceID
, SerialNumber
, Description
, NULL
)) != FT_OK
)
1934 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status
);
1935 return ERROR_JTAG_INIT_FAILED
;
1939 static const char* type_str
[] =
1940 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1941 unsigned no_of_known_types
= sizeof(type_str
) / sizeof(type_str
[0]) - 1;
1942 unsigned type_index
= ((unsigned)ftdi_device
<= no_of_known_types
)
1943 ? ftdi_device
: FT_DEVICE_UNKNOWN
;
1944 LOG_INFO("device: %lu \"%s\"", ftdi_device
, type_str
[type_index
]);
1945 LOG_INFO("deviceID: %lu", deviceID
);
1946 LOG_INFO("SerialNumber: %s", SerialNumber
);
1947 LOG_INFO("Description: %s", Description
);
1953 static int ft2232_purge_ftd2xx(void)
1957 if ((status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
)) != FT_OK
)
1959 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1960 return ERROR_JTAG_INIT_FAILED
;
1966 #endif /* BUILD_FT2232_FTD2XX == 1 */
1968 #if BUILD_FT2232_LIBFTDI == 1
1969 static int ft2232_init_libftdi(uint16_t vid
, uint16_t pid
, int more
, int* try_more
)
1971 uint8_t latency_timer
;
1973 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1974 ft2232_layout
, vid
, pid
);
1976 if (ftdi_init(&ftdic
) < 0)
1977 return ERROR_JTAG_INIT_FAILED
;
1979 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1981 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1982 return ERROR_JTAG_INIT_FAILED
;
1985 /* context, vendor id, product id */
1986 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1990 LOG_WARNING("unable to open ftdi device (trying more): %s",
1993 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1995 return ERROR_JTAG_INIT_FAILED
;
1998 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1999 if (ftdi_usb_reset(&ftdic
) < 0)
2001 LOG_ERROR("unable to reset ftdi device");
2002 return ERROR_JTAG_INIT_FAILED
;
2005 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
2007 LOG_ERROR("unable to set latency timer");
2008 return ERROR_JTAG_INIT_FAILED
;
2011 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
2013 LOG_ERROR("unable to get latency timer");
2014 return ERROR_JTAG_INIT_FAILED
;
2018 LOG_DEBUG("current latency timer: %i", latency_timer
);
2021 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
2023 ftdi_device
= ftdic
.type
;
2024 static const char* type_str
[] =
2025 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2026 unsigned no_of_known_types
= sizeof(type_str
) / sizeof(type_str
[0]) - 1;
2027 unsigned type_index
= ((unsigned)ftdi_device
< no_of_known_types
)
2028 ? ftdi_device
: no_of_known_types
;
2029 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device
, type_str
[type_index
]);
2033 static int ft2232_purge_libftdi(void)
2035 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
2037 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
2038 return ERROR_JTAG_INIT_FAILED
;
2044 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2046 static int ft2232_init(void)
2050 uint32_t bytes_written
;
2051 const ft2232_layout_t
* cur_layout
= ft2232_layouts
;
2054 if (tap_get_tms_path_len(TAP_IRPAUSE
,TAP_IRPAUSE
) == 7)
2056 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2060 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2063 if ((ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0))
2065 ft2232_layout
= "usbjtag";
2066 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2069 while (cur_layout
->name
)
2071 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
2073 layout
= cur_layout
;
2081 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
2082 return ERROR_JTAG_INIT_FAILED
;
2088 * "more indicates that there are more IDs to try, so we should
2089 * not print an error for an ID mismatch (but for anything
2092 * try_more indicates that the error code returned indicates an
2093 * ID mismatch (and nothing else) and that we should proceeed
2094 * with the next ID pair.
2096 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
2099 #if BUILD_FT2232_FTD2XX == 1
2100 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
2102 #elif BUILD_FT2232_LIBFTDI == 1
2103 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
2108 if (!more
|| !try_more
)
2112 ft2232_buffer_size
= 0;
2113 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
2115 if (layout
->init() != ERROR_OK
)
2116 return ERROR_JTAG_INIT_FAILED
;
2118 if (ft2232_device_is_highspeed())
2120 #ifndef BUILD_FT2232_HIGHSPEED
2121 #if BUILD_FT2232_FTD2XX == 1
2122 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2123 #elif BUILD_FT2232_LIBFTDI == 1
2124 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2127 /* make sure the legacy mode is disabled */
2128 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK
)
2129 return ERROR_JTAG_INIT_FAILED
;
2132 ft2232_speed(jtag_get_speed());
2134 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2135 if (((retval
= ft2232_write(buf
, 1, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 1))
2137 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2138 return ERROR_JTAG_INIT_FAILED
;
2141 #if BUILD_FT2232_FTD2XX == 1
2142 return ft2232_purge_ftd2xx();
2143 #elif BUILD_FT2232_LIBFTDI == 1
2144 return ft2232_purge_libftdi();
2150 static int usbjtag_init(void)
2153 uint32_t bytes_written
;
2156 low_direction
= 0x0b;
2158 if (strcmp(ft2232_layout
, "usbjtag") == 0)
2165 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
2172 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
2179 low_direction
= 0x8b;
2181 else if (strcmp(ft2232_layout
, "luminary_icdi") == 0)
2188 low_direction
= 0xcb;
2192 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
2193 return ERROR_JTAG_INIT_FAILED
;
2196 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2197 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2199 low_direction
&= ~nTRSTnOE
; /* nTRST input */
2200 low_output
&= ~nTRST
; /* nTRST = 0 */
2204 low_direction
|= nTRSTnOE
; /* nTRST output */
2205 low_output
|= nTRST
; /* nTRST = 1 */
2208 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2210 low_direction
|= nSRSTnOE
; /* nSRST output */
2211 low_output
|= nSRST
; /* nSRST = 1 */
2215 low_direction
&= ~nSRSTnOE
; /* nSRST input */
2216 low_output
&= ~nSRST
; /* nSRST = 0 */
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, xRST high) */
2222 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
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 'USBJTAG' layout");
2228 return ERROR_JTAG_INIT_FAILED
;
2234 static int axm0432_jtag_init(void)
2237 uint32_t bytes_written
;
2240 low_direction
= 0x2b;
2242 /* initialize low byte for jtag */
2243 buf
[0] = 0x80; /* command "set data bits low byte" */
2244 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2245 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2246 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2248 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2250 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2251 return ERROR_JTAG_INIT_FAILED
;
2254 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
2257 nTRSTnOE
= 0x0; /* No output enable for TRST*/
2259 nSRSTnOE
= 0x0; /* No output enable for SRST*/
2263 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2268 high_direction
= 0x0c;
2270 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2271 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2273 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2277 high_output
|= nTRST
;
2280 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2282 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2286 high_output
|= nSRST
;
2289 /* initialize high port */
2290 buf
[0] = 0x82; /* command "set data bits high byte" */
2291 buf
[1] = high_output
; /* value */
2292 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2293 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2295 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2297 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2298 return ERROR_JTAG_INIT_FAILED
;
2304 static int jtagkey_init(void)
2307 uint32_t bytes_written
;
2310 low_direction
= 0x1b;
2312 /* initialize low byte for jtag */
2313 buf
[0] = 0x80; /* command "set data bits low byte" */
2314 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2315 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2316 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2318 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2320 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2321 return ERROR_JTAG_INIT_FAILED
;
2324 if (strcmp(layout
->name
, "jtagkey") == 0)
2331 else if ((strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2332 || (strcmp(layout
->name
, "oocdlink") == 0))
2341 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2346 high_direction
= 0x0f;
2348 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2349 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2351 high_output
|= nTRSTnOE
;
2352 high_output
&= ~nTRST
;
2356 high_output
&= ~nTRSTnOE
;
2357 high_output
|= nTRST
;
2360 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2362 high_output
&= ~nSRSTnOE
;
2363 high_output
|= nSRST
;
2367 high_output
|= nSRSTnOE
;
2368 high_output
&= ~nSRST
;
2371 /* initialize high port */
2372 buf
[0] = 0x82; /* command "set data bits high byte" */
2373 buf
[1] = high_output
; /* value */
2374 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2375 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2377 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2379 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2380 return ERROR_JTAG_INIT_FAILED
;
2386 static int olimex_jtag_init(void)
2389 uint32_t bytes_written
;
2392 low_direction
= 0x1b;
2394 /* initialize low byte for jtag */
2395 buf
[0] = 0x80; /* command "set data bits low byte" */
2396 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2397 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2398 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2400 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2402 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2403 return ERROR_JTAG_INIT_FAILED
;
2409 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2412 high_direction
= 0x0f;
2414 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2415 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2417 high_output
|= nTRSTnOE
;
2418 high_output
&= ~nTRST
;
2422 high_output
&= ~nTRSTnOE
;
2423 high_output
|= nTRST
;
2426 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2428 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2432 high_output
&= ~nSRST
;
2435 /* turn red LED on */
2436 high_output
|= 0x08;
2438 /* initialize high port */
2439 buf
[0] = 0x82; /* command "set data bits high byte" */
2440 buf
[1] = high_output
; /* value */
2441 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2442 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2444 if ((ft2232_write(buf
, 3, &bytes_written
) != ERROR_OK
) || (bytes_written
!= 3))
2446 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2447 return ERROR_JTAG_INIT_FAILED
;
2453 static int flyswatter_init(void)
2456 uint32_t bytes_written
;
2459 low_direction
= 0xfb;
2461 /* initialize low byte for jtag */
2462 buf
[0] = 0x80; /* command "set data bits low byte" */
2463 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2464 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2465 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2467 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2469 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2470 return ERROR_JTAG_INIT_FAILED
;
2474 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2476 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2479 high_direction
= 0x0c;
2481 /* turn red LED3 on, LED2 off */
2482 high_output
|= 0x08;
2484 /* initialize high port */
2485 buf
[0] = 0x82; /* command "set data bits high byte" */
2486 buf
[1] = high_output
; /* value */
2487 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2488 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2490 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2492 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2493 return ERROR_JTAG_INIT_FAILED
;
2499 static int turtle_init(void)
2502 uint32_t bytes_written
;
2505 low_direction
= 0x5b;
2507 /* initialize low byte for jtag */
2508 buf
[0] = 0x80; /* command "set data bits low byte" */
2509 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2510 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2511 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2513 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2515 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2516 return ERROR_JTAG_INIT_FAILED
;
2522 high_direction
= 0x0C;
2524 /* initialize high port */
2525 buf
[0] = 0x82; /* command "set data bits high byte" */
2526 buf
[1] = high_output
;
2527 buf
[2] = high_direction
;
2528 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2530 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2532 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2533 return ERROR_JTAG_INIT_FAILED
;
2539 static int comstick_init(void)
2542 uint32_t bytes_written
;
2545 low_direction
= 0x0b;
2547 /* initialize low byte for jtag */
2548 buf
[0] = 0x80; /* command "set data bits low byte" */
2549 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2550 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2551 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2553 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2555 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2556 return ERROR_JTAG_INIT_FAILED
;
2560 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2562 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2565 high_direction
= 0x03;
2567 /* initialize high port */
2568 buf
[0] = 0x82; /* command "set data bits high byte" */
2569 buf
[1] = high_output
;
2570 buf
[2] = high_direction
;
2571 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2573 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2575 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2576 return ERROR_JTAG_INIT_FAILED
;
2582 static int stm32stick_init(void)
2585 uint32_t bytes_written
;
2588 low_direction
= 0x8b;
2590 /* initialize low byte for jtag */
2591 buf
[0] = 0x80; /* command "set data bits low byte" */
2592 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2593 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2594 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2596 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2598 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2599 return ERROR_JTAG_INIT_FAILED
;
2603 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2605 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2608 high_direction
= 0x03;
2610 /* initialize high port */
2611 buf
[0] = 0x82; /* command "set data bits high byte" */
2612 buf
[1] = high_output
;
2613 buf
[2] = high_direction
;
2614 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2616 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2618 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2619 return ERROR_JTAG_INIT_FAILED
;
2625 static int sheevaplug_init(void)
2628 uint32_t bytes_written
;
2631 low_direction
= 0x1b;
2633 /* initialize low byte for jtag */
2634 buf
[0] = 0x80; /* command "set data bits low byte" */
2635 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2636 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2637 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2639 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2641 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2642 return ERROR_JTAG_INIT_FAILED
;
2651 high_direction
= 0x0f;
2653 /* nTRST is always push-pull */
2654 high_output
&= ~nTRSTnOE
;
2655 high_output
|= nTRST
;
2657 /* nSRST is always open-drain */
2658 high_output
|= nSRSTnOE
;
2659 high_output
&= ~nSRST
;
2661 /* initialize high port */
2662 buf
[0] = 0x82; /* command "set data bits high byte" */
2663 buf
[1] = high_output
; /* value */
2664 buf
[2] = high_direction
; /* all outputs - xRST */
2665 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2667 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2669 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2670 return ERROR_JTAG_INIT_FAILED
;
2676 static int cortino_jtag_init(void)
2679 uint32_t bytes_written
;
2682 low_direction
= 0x1b;
2684 /* initialize low byte for jtag */
2685 buf
[0] = 0x80; /* command "set data bits low byte" */
2686 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2687 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2688 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2690 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2692 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2693 return ERROR_JTAG_INIT_FAILED
;
2697 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2699 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2702 high_direction
= 0x03;
2704 /* initialize high port */
2705 buf
[0] = 0x82; /* command "set data bits high byte" */
2706 buf
[1] = high_output
;
2707 buf
[2] = high_direction
;
2708 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2710 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2712 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2713 return ERROR_JTAG_INIT_FAILED
;
2719 static void olimex_jtag_blink(void)
2721 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2722 * ACBUS3 is bit 3 of the GPIOH port
2724 if (high_output
& 0x08)
2726 /* set port pin high */
2727 high_output
&= 0x07;
2731 /* set port pin low */
2732 high_output
|= 0x08;
2736 buffer_write(high_output
);
2737 buffer_write(high_direction
);
2740 static void flyswatter_jtag_blink(void)
2743 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2745 high_output
^= 0x0c;
2748 buffer_write(high_output
);
2749 buffer_write(high_direction
);
2752 static void turtle_jtag_blink(void)
2755 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2757 if (high_output
& 0x08)
2767 buffer_write(high_output
);
2768 buffer_write(high_direction
);
2771 static int ft2232_quit(void)
2773 #if BUILD_FT2232_FTD2XX == 1
2776 status
= FT_Close(ftdih
);
2777 #elif BUILD_FT2232_LIBFTDI == 1
2778 ftdi_usb_close(&ftdic
);
2780 ftdi_deinit(&ftdic
);
2783 free(ft2232_buffer
);
2784 ft2232_buffer
= NULL
;
2789 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2795 ft2232_device_desc
= strdup(args
[0]);
2796 cp
= strchr(ft2232_device_desc
, 0);
2797 /* under Win32, the FTD2XX driver appends an "A" to the end
2798 * of the description, this examines the given desc
2799 * and creates the 'missing' _A or non_A variable. */
2800 if ((cp
[-1] == 'A') && (cp
[-2]==' ')) {
2801 /* it was, so make this the "A" version. */
2802 ft2232_device_desc_A
= ft2232_device_desc
;
2803 /* and *CREATE* the non-A version. */
2804 strcpy(buf
, ft2232_device_desc
);
2805 cp
= strchr(buf
, 0);
2807 ft2232_device_desc
= strdup(buf
);
2809 /* <space > A not defined
2811 sprintf(buf
, "%s A", ft2232_device_desc
);
2812 ft2232_device_desc_A
= strdup(buf
);
2817 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2823 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2827 ft2232_serial
= strdup(args
[0]);
2831 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2837 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2842 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2843 strcpy(ft2232_layout
, args
[0]);
2848 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2850 if (argc
> MAX_USB_IDS
* 2)
2852 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2853 "(maximum is %d pairs)", MAX_USB_IDS
);
2854 argc
= MAX_USB_IDS
* 2;
2856 if (argc
< 2 || (argc
& 1))
2858 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2860 return ERROR_COMMAND_SYNTAX_ERROR
;
2861 /* remove the incomplete trailing id */
2866 int retval
= ERROR_OK
;
2867 for (i
= 0; i
< argc
; i
+= 2)
2869 retval
= parse_u16(args
[i
], &ft2232_vid
[i
>> 1]);
2870 if (ERROR_OK
!= retval
)
2872 retval
= parse_u16(args
[i
+ 1], &ft2232_pid
[i
>> 1]);
2873 if (ERROR_OK
!= retval
)
2878 * Explicitly terminate, in case there are multiples instances of
2881 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2886 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2890 ft2232_latency
= atoi(args
[0]);
2894 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2900 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2904 /* 7 bits of either ones or zeros. */
2905 uint8_t tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2907 while (num_cycles
> 0)
2909 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2910 * at most 7 bits per invocation. Here we invoke it potentially
2913 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2915 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2917 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2918 retval
= ERROR_JTAG_QUEUE_FAILED
;
2923 /* there are no state transitions in this code, so omit state tracking */
2925 /* command "Clock Data to TMS/CS Pin (no Read)" */
2929 buffer_write(bitcount_per_command
- 1);
2931 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2936 num_cycles
-= bitcount_per_command
;
2942 /* ---------------------------------------------------------------------
2943 * Support for IceBear JTAG adapter from Section5:
2944 * http://section5.ch/icebear
2946 * Author: Sten, debian@sansys-electronic.com
2949 /* Icebear pin layout
2951 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2952 * GND GND | 4 3| n.c.
2953 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2954 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2955 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2956 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2957 * ADBUS2 TDO |14 13| GND GND
2959 * ADBUS0 O L TCK ACBUS0 GND
2960 * ADBUS1 O L TDI ACBUS1 GND
2961 * ADBUS2 I TDO ACBUS2 n.c.
2962 * ADBUS3 O H TMS ACBUS3 n.c.
2968 static int icebear_jtag_init(void) {
2970 uint32_t bytes_written
;
2972 low_direction
= 0x0b; /* output: TCK TDI TMS; input: TDO */
2973 low_output
= 0x08; /* high: TMS; low: TCK TDI */
2977 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2978 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0) {
2979 low_direction
&= ~nTRST
; /* nTRST high impedance */
2982 low_direction
|= nTRST
;
2983 low_output
|= nTRST
;
2986 low_direction
|= nSRST
;
2987 low_output
|= nSRST
;
2989 /* initialize low byte for jtag */
2990 buf
[0] = 0x80; /* command "set data bits low byte" */
2991 buf
[1] = low_output
;
2992 buf
[2] = low_direction
;
2993 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2995 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3)) {
2996 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2997 return ERROR_JTAG_INIT_FAILED
;
3001 high_direction
= 0x00;
3004 /* initialize high port */
3005 buf
[0] = 0x82; /* command "set data bits high byte" */
3006 buf
[1] = high_output
; /* value */
3007 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
3008 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
3010 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3)) {
3011 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3012 return ERROR_JTAG_INIT_FAILED
;
3018 static void icebear_jtag_reset(int trst
, int srst
) {
3021 low_direction
|= nTRST
;
3022 low_output
&= ~nTRST
;
3024 else if (trst
== 0) {
3025 enum reset_types jtag_reset_config
= jtag_get_reset_config();
3026 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0)
3027 low_direction
&= ~nTRST
;
3029 low_output
|= nTRST
;
3033 low_output
&= ~nSRST
;
3035 else if (srst
== 0) {
3036 low_output
|= nSRST
;
3039 /* command "set data bits low byte" */
3041 buffer_write(low_output
);
3042 buffer_write(low_direction
);
3044 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst
, srst
, low_output
, low_direction
);
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)