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 static int ft2232_execute_queue(void);
73 static int ft2232_speed(int speed
);
74 static int ft2232_speed_div(int speed
, int* khz
);
75 static int ft2232_khz(int khz
, int* jtag_speed
);
76 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
);
77 static int ft2232_init(void);
78 static int ft2232_quit(void);
80 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
81 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
82 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
83 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
84 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
87 * Send out \a num_cycles on the TCK line while the TAP(s) are in a
88 * stable state. Calling code must ensure that current state is stable,
89 * that verification is not done in here.
91 * @param num_cycles The number of clocks cycles to send.
92 * @param cmd The command to send.
94 * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
96 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
);
98 static char * ft2232_device_desc_A
= NULL
;
99 static char* ft2232_device_desc
= NULL
;
100 static char* ft2232_serial
= NULL
;
101 static char* ft2232_layout
= NULL
;
102 static uint8_t ft2232_latency
= 2;
103 static unsigned ft2232_max_tck
= FTDI_2232C_MAX_TCK
;
105 #define MAX_USB_IDS 8
106 /* vid = pid = 0 marks the end of the list */
107 static uint16_t ft2232_vid
[MAX_USB_IDS
+ 1] = { 0x0403, 0 };
108 static uint16_t ft2232_pid
[MAX_USB_IDS
+ 1] = { 0x6010, 0 };
110 typedef struct ft2232_layout_s
114 void (*reset
)(int trst
, int srst
);
118 /* init procedures for supported layouts */
119 static int usbjtag_init(void);
120 static int jtagkey_init(void);
121 static int olimex_jtag_init(void);
122 static int flyswatter_init(void);
123 static int turtle_init(void);
124 static int comstick_init(void);
125 static int stm32stick_init(void);
126 static int axm0432_jtag_init(void);
127 static int sheevaplug_init(void);
128 static int icebear_jtag_init(void);
129 static int cortino_jtag_init(void);
131 /* reset procedures for supported layouts */
132 static void usbjtag_reset(int trst
, int srst
);
133 static void jtagkey_reset(int trst
, int srst
);
134 static void olimex_jtag_reset(int trst
, int srst
);
135 static void flyswatter_reset(int trst
, int srst
);
136 static void turtle_reset(int trst
, int srst
);
137 static void comstick_reset(int trst
, int srst
);
138 static void stm32stick_reset(int trst
, int srst
);
139 static void axm0432_jtag_reset(int trst
, int srst
);
140 static void sheevaplug_reset(int trst
, int srst
);
141 static void icebear_jtag_reset(int trst
, int srst
);
143 /* blink procedures for layouts that support a blinking led */
144 static void olimex_jtag_blink(void);
145 static void flyswatter_jtag_blink(void);
146 static void turtle_jtag_blink(void);
148 static const ft2232_layout_t ft2232_layouts
[] =
150 { "usbjtag", usbjtag_init
, usbjtag_reset
, NULL
},
151 { "jtagkey", jtagkey_init
, jtagkey_reset
, NULL
},
152 { "jtagkey_prototype_v1", jtagkey_init
, jtagkey_reset
, NULL
},
153 { "oocdlink", jtagkey_init
, jtagkey_reset
, NULL
},
154 { "signalyzer", usbjtag_init
, usbjtag_reset
, NULL
},
155 { "evb_lm3s811", usbjtag_init
, usbjtag_reset
, NULL
},
156 { "luminary_icdi", usbjtag_init
, usbjtag_reset
, NULL
},
157 { "olimex-jtag", olimex_jtag_init
, olimex_jtag_reset
, olimex_jtag_blink
},
158 { "flyswatter", flyswatter_init
, flyswatter_reset
, flyswatter_jtag_blink
},
159 { "turtelizer2", turtle_init
, turtle_reset
, turtle_jtag_blink
},
160 { "comstick", comstick_init
, comstick_reset
, NULL
},
161 { "stm32stick", stm32stick_init
, stm32stick_reset
, NULL
},
162 { "axm0432_jtag", axm0432_jtag_init
, axm0432_jtag_reset
, NULL
},
163 { "sheevaplug", sheevaplug_init
, sheevaplug_reset
, NULL
},
164 { "icebear", icebear_jtag_init
, icebear_jtag_reset
, NULL
},
165 { "cortino", cortino_jtag_init
, comstick_reset
, NULL
},
166 { NULL
, NULL
, NULL
, NULL
},
169 static uint8_t nTRST
, nTRSTnOE
, nSRST
, nSRSTnOE
;
171 static const ft2232_layout_t
*layout
;
172 static uint8_t low_output
= 0x0;
173 static uint8_t low_direction
= 0x0;
174 static uint8_t high_output
= 0x0;
175 static uint8_t high_direction
= 0x0;
177 #if BUILD_FT2232_FTD2XX == 1
178 static FT_HANDLE ftdih
= NULL
;
179 static FT_DEVICE ftdi_device
= 0;
180 #elif BUILD_FT2232_LIBFTDI == 1
181 static struct ftdi_context ftdic
;
182 static enum ftdi_chip_type ftdi_device
;
185 static jtag_command_t
* first_unsent
; /* next command that has to be sent */
186 static int require_send
;
188 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
190 "There is a significant difference between libftdi and libftd2xx. The latter
191 one allows to schedule up to 64*64 bytes of result data while libftdi fails
192 with more than 4*64. As a consequence, the FT2232 driver is forced to
193 perform around 16x more USB transactions for long command streams with TDO
194 capture when running with libftdi."
197 #define FT2232_BUFFER_SIZE 131072
198 a comment would have been nice.
201 #define FT2232_BUFFER_SIZE 131072
203 static uint8_t* ft2232_buffer
= NULL
;
204 static int ft2232_buffer_size
= 0;
205 static int ft2232_read_pointer
= 0;
206 static int ft2232_expect_read
= 0;
209 * Function buffer_write
210 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
211 * @param val is the byte to send.
213 static inline void buffer_write(uint8_t val
)
215 assert(ft2232_buffer
);
216 assert((unsigned) ft2232_buffer_size
< (unsigned) FT2232_BUFFER_SIZE
);
217 ft2232_buffer
[ft2232_buffer_size
++] = val
;
221 * Function buffer_read
222 * returns a byte from the byte buffer.
224 static inline uint8_t buffer_read(void)
226 assert(ft2232_buffer
);
227 assert(ft2232_read_pointer
< ft2232_buffer_size
);
228 return ft2232_buffer
[ft2232_read_pointer
++];
232 * Clocks out \a bit_count bits on the TMS line, starting with the least
233 * significant bit of tms_bits and progressing to more significant bits.
234 * Rigorous state transition logging is done here via tap_set_state().
236 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
237 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
238 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
239 * is often used for this, 0x4b.
241 * @param tms_bits Holds the sequence of bits to send.
242 * @param tms_count Tells how many bits in the sequence.
243 * @param tdi_bit A single bit to pass on to TDI before the first TCK
244 * cycle and held static for the duration of TMS clocking.
246 * See the MPSSE spec referenced above.
248 static void clock_tms(uint8_t mpsse_cmd
, int tms_bits
, int tms_count
, bool tdi_bit
)
252 int tms_ndx
; /* bit index into tms_byte */
254 assert(tms_count
> 0);
257 LOG_DEBUG("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d", mpsse_cmd
, tms_bits
, tms_count
);
260 for (tms_byte
= tms_ndx
= i
= 0; i
< tms_count
; ++i
, tms_bits
>>=1)
262 bool bit
= tms_bits
& 1;
265 tms_byte
|= (1 << tms_ndx
);
267 /* always do state transitions in public view */
268 tap_set_state(tap_state_transition(tap_get_state(), bit
));
270 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
275 if (tms_ndx
== 7 || i
== tms_count
-1)
277 buffer_write(mpsse_cmd
);
278 buffer_write(tms_ndx
- 1);
280 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
281 TMS/CS and is held static for the duration of TMS/CS clocking.
283 buffer_write(tms_byte
| (tdi_bit
<< 7));
289 * Function get_tms_buffer_requirements
290 * returns what clock_tms() will consume if called with
293 static inline int get_tms_buffer_requirements(int bit_count
)
295 return ((bit_count
+ 6)/7) * 3;
299 * Function move_to_state
300 * moves the TAP controller from the current state to a
301 * \a goal_state through a path given by tap_get_tms_path(). State transition
302 * logging is performed by delegation to clock_tms().
304 * @param goal_state is the destination state for the move.
306 static void move_to_state(tap_state_t goal_state
)
308 tap_state_t start_state
= tap_get_state();
310 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
311 lookup of the required TMS pattern to move to this state from the
315 /* do the 2 lookups */
316 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
317 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
319 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
));
321 clock_tms(0x4b, tms_bits
, tms_count
, 0);
324 jtag_interface_t ft2232_interface
=
327 .execute_queue
= ft2232_execute_queue
,
328 .speed
= ft2232_speed
,
329 .speed_div
= ft2232_speed_div
,
331 .register_commands
= ft2232_register_commands
,
336 static int ft2232_write(uint8_t* buf
, int size
, uint32_t* bytes_written
)
338 #if BUILD_FT2232_FTD2XX == 1
340 DWORD dw_bytes_written
;
341 if ((status
= FT_Write(ftdih
, buf
, size
, &dw_bytes_written
)) != FT_OK
)
343 *bytes_written
= dw_bytes_written
;
344 LOG_ERROR("FT_Write returned: %lu", status
);
345 return ERROR_JTAG_DEVICE_ERROR
;
349 *bytes_written
= dw_bytes_written
;
352 #elif BUILD_FT2232_LIBFTDI == 1
354 if ((retval
= ftdi_write_data(&ftdic
, buf
, size
)) < 0)
357 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic
));
358 return ERROR_JTAG_DEVICE_ERROR
;
362 *bytes_written
= retval
;
368 static int ft2232_read(uint8_t* buf
, uint32_t size
, uint32_t* bytes_read
)
370 #if BUILD_FT2232_FTD2XX == 1
376 while ((*bytes_read
< size
) && timeout
--)
378 if ((status
= FT_Read(ftdih
, buf
+ *bytes_read
, size
-
379 *bytes_read
, &dw_bytes_read
)) != FT_OK
)
382 LOG_ERROR("FT_Read returned: %lu", status
);
383 return ERROR_JTAG_DEVICE_ERROR
;
385 *bytes_read
+= dw_bytes_read
;
388 #elif BUILD_FT2232_LIBFTDI == 1
393 while ((*bytes_read
< size
) && timeout
--)
395 if ((retval
= ftdi_read_data(&ftdic
, buf
+ *bytes_read
, size
- *bytes_read
)) < 0)
398 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic
));
399 return ERROR_JTAG_DEVICE_ERROR
;
401 *bytes_read
+= retval
;
406 if (*bytes_read
< size
)
408 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)",
409 (unsigned int)(*bytes_read
),
411 return ERROR_JTAG_DEVICE_ERROR
;
417 static bool ft2232_device_is_highspeed(void)
419 #ifdef BUILD_FT2232_HIGHSPEED
420 #if BUILD_FT2232_FTD2XX == 1
421 return (ftdi_device
== FT_DEVICE_2232H
) || (ftdi_device
== FT_DEVICE_4232H
);
422 #elif BUILD_FT2232_LIBFTDI == 1
423 return (ftdi_device
== TYPE_2232H
|| ftdi_device
== TYPE_4232H
);
431 * Commands that only apply to the FT2232H and FT4232H devices.
432 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
433 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
436 static int ft2232h_ft4232h_adaptive_clocking(bool enable
)
438 uint8_t buf
= enable
? 0x96 : 0x97;
439 LOG_DEBUG("%2.2x", buf
);
441 uint32_t bytes_written
;
442 int retval
= ft2232_write(&buf
, 1, &bytes_written
);
443 if ((ERROR_OK
!= retval
) || (bytes_written
!= 1))
445 LOG_ERROR("couldn't write command to %s adaptive clocking"
446 , enable
? "enable" : "disable");
454 * Enable/disable the clk divide by 5 of the 60MHz master clock.
455 * This result in a JTAG clock speed range of 91.553Hz-6MHz
456 * respective 457.763Hz-30MHz.
458 static int ft2232h_ft4232h_clk_divide_by_5(bool enable
)
460 uint32_t bytes_written
;
461 uint8_t buf
= enable
? 0x8b : 0x8a;
462 int retval
= ft2232_write(&buf
, 1, &bytes_written
);
463 if ((ERROR_OK
!= retval
) || (bytes_written
!= 1))
465 LOG_ERROR("couldn't write command to %s clk divide by 5"
466 , enable
? "enable" : "disable");
467 return ERROR_JTAG_INIT_FAILED
;
469 ft2232_max_tck
= enable
? FTDI_2232C_MAX_TCK
: FTDI_2232H_4232H_MAX_TCK
;
470 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck
);
475 static int ft2232_speed(int speed
)
479 uint32_t bytes_written
;
482 bool enable_adaptive_clocking
= (RTCK_SPEED
== speed
);
483 if (ft2232_device_is_highspeed())
484 retval
= ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking
);
485 else if (enable_adaptive_clocking
)
487 LOG_ERROR("ft2232 device %lu does not support RTCK"
488 , (long unsigned int)ftdi_device
);
492 if ((enable_adaptive_clocking
) || (ERROR_OK
!= retval
))
495 buf
[0] = 0x86; /* command "set divisor" */
496 buf
[1] = speed
& 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
497 buf
[2] = (speed
>> 8) & 0xff; /* valueH */
499 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
500 if (((retval
= ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
502 LOG_ERROR("couldn't set FT2232 TCK speed");
509 static int ft2232_speed_div(int speed
, int* khz
)
511 /* Take a look in the FT2232 manual,
512 * AN2232C-01 Command Processor for
513 * MPSSE and MCU Host Bus. Chapter 3.8 */
515 *khz
= (RTCK_SPEED
== speed
) ? 0 : ft2232_max_tck
/ (1 + speed
);
520 static int ft2232_khz(int khz
, int* jtag_speed
)
524 if (ft2232_device_is_highspeed())
526 *jtag_speed
= RTCK_SPEED
;
531 LOG_DEBUG("RCLK not supported");
532 #ifndef BUILD_FT2232_HIGHSPEED
533 LOG_DEBUG("If you have a high-speed FTDI device, then "
534 "OpenOCD may be built with --enable-ft2232-highspeed.");
540 /* Take a look in the FT2232 manual,
541 * AN2232C-01 Command Processor for
542 * MPSSE and MCU Host Bus. Chapter 3.8
544 * We will calc here with a multiplier
545 * of 10 for better rounding later. */
547 /* Calc speed, (ft2232_max_tck / khz) - 1 */
548 /* Use 65000 for better rounding */
549 *jtag_speed
= ((ft2232_max_tck
*10) / khz
) - 10;
551 /* Add 0.9 for rounding */
554 /* Calc real speed */
555 *jtag_speed
= *jtag_speed
/ 10;
557 /* Check if speed is greater than 0 */
563 /* Check max value */
564 if (*jtag_speed
> 0xFFFF)
566 *jtag_speed
= 0xFFFF;
572 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
)
574 register_command(cmd_ctx
, NULL
, "ft2232_device_desc", ft2232_handle_device_desc_command
,
575 COMMAND_CONFIG
, "the USB device description of the FTDI FT2232 device");
576 register_command(cmd_ctx
, NULL
, "ft2232_serial", ft2232_handle_serial_command
,
577 COMMAND_CONFIG
, "the serial number of the FTDI FT2232 device");
578 register_command(cmd_ctx
, NULL
, "ft2232_layout", ft2232_handle_layout_command
,
579 COMMAND_CONFIG
, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
580 register_command(cmd_ctx
, NULL
, "ft2232_vid_pid", ft2232_handle_vid_pid_command
,
581 COMMAND_CONFIG
, "the vendor ID and product ID of the FTDI FT2232 device");
582 register_command(cmd_ctx
, NULL
, "ft2232_latency", ft2232_handle_latency_command
,
583 COMMAND_CONFIG
, "set the FT2232 latency timer to a new value");
587 static void ft2232_end_state(tap_state_t state
)
589 if (tap_is_state_stable(state
))
590 tap_set_end_state(state
);
593 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
598 static void ft2232_read_scan(enum scan_type type
, uint8_t* buffer
, int scan_size
)
600 int num_bytes
= (scan_size
+ 7) / 8;
601 int bits_left
= scan_size
;
604 while (num_bytes
-- > 1)
606 buffer
[cur_byte
++] = buffer_read();
610 buffer
[cur_byte
] = 0x0;
612 /* There is one more partial byte left from the clock data in/out instructions */
615 buffer
[cur_byte
] = buffer_read() >> 1;
617 /* 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 */
618 buffer
[cur_byte
] = (buffer
[cur_byte
] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left
);
621 static void ft2232_debug_dump_buffer(void)
627 for (i
= 0; i
< ft2232_buffer_size
; i
++)
629 line_p
+= snprintf(line_p
, 256 - (line_p
- line
), "%2.2x ", ft2232_buffer
[i
]);
632 LOG_DEBUG("%s", line
);
638 LOG_DEBUG("%s", line
);
641 static int ft2232_send_and_recv(jtag_command_t
* first
, jtag_command_t
* last
)
648 uint32_t bytes_written
= 0;
649 uint32_t bytes_read
= 0;
651 #ifdef _DEBUG_USB_IO_
652 struct timeval start
, inter
, inter2
, end
;
653 struct timeval d_inter
, d_inter2
, d_end
;
656 #ifdef _DEBUG_USB_COMMS_
657 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size
);
658 ft2232_debug_dump_buffer();
661 #ifdef _DEBUG_USB_IO_
662 gettimeofday(&start
, NULL
);
665 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
667 LOG_ERROR("couldn't write MPSSE commands to FT2232");
671 #ifdef _DEBUG_USB_IO_
672 gettimeofday(&inter
, NULL
);
675 if (ft2232_expect_read
)
678 ft2232_buffer_size
= 0;
680 #ifdef _DEBUG_USB_IO_
681 gettimeofday(&inter2
, NULL
);
684 if ((retval
= ft2232_read(ft2232_buffer
, ft2232_expect_read
, &bytes_read
)) != ERROR_OK
)
686 LOG_ERROR("couldn't read from FT2232");
690 #ifdef _DEBUG_USB_IO_
691 gettimeofday(&end
, NULL
);
693 timeval_subtract(&d_inter
, &inter
, &start
);
694 timeval_subtract(&d_inter2
, &inter2
, &start
);
695 timeval_subtract(&d_end
, &end
, &start
);
697 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
698 (unsigned)d_inter
.tv_sec
, (unsigned)d_inter
.tv_usec
,
699 (unsigned)d_inter2
.tv_sec
, (unsigned)d_inter2
.tv_usec
,
700 (unsigned)d_end
.tv_sec
, (unsigned)d_end
.tv_usec
);
703 ft2232_buffer_size
= bytes_read
;
705 if (ft2232_expect_read
!= ft2232_buffer_size
)
707 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read
,
710 ft2232_debug_dump_buffer();
715 #ifdef _DEBUG_USB_COMMS_
716 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout
, ft2232_buffer_size
);
717 ft2232_debug_dump_buffer();
721 ft2232_expect_read
= 0;
722 ft2232_read_pointer
= 0;
724 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
725 * that wasn't handled by a caller-provided error handler
735 type
= jtag_scan_type(cmd
->cmd
.scan
);
736 if (type
!= SCAN_OUT
)
738 scan_size
= jtag_scan_size(cmd
->cmd
.scan
);
739 buffer
= calloc(CEIL(scan_size
, 8), 1);
740 ft2232_read_scan(type
, buffer
, scan_size
);
741 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
742 retval
= ERROR_JTAG_QUEUE_FAILED
;
754 ft2232_buffer_size
= 0;
760 * Function ft2232_add_pathmove
761 * moves the TAP controller from the current state to a new state through the
762 * given path, where path is an array of tap_state_t's.
764 * @param path is an array of tap_stat_t which gives the states to traverse through
765 * ending with the last state at path[num_states-1]
766 * @param num_states is the count of state steps to move through
768 static void ft2232_add_pathmove(tap_state_t
* path
, int num_states
)
772 tap_state_t walker
= tap_get_state();
774 assert((unsigned) num_states
<= 32u); /* tms_bits only holds 32 bits */
776 /* this loop verifies that the path is legal and logs each state in the path */
777 for (state_ndx
= 0; state_ndx
< num_states
; ++state_ndx
)
779 tap_state_t desired_next_state
= path
[state_ndx
];
781 if (tap_state_transition(walker
, false) == desired_next_state
)
782 ; /* bit within tms_bits at index state_ndx is already zero */
783 else if (tap_state_transition(walker
, true) == desired_next_state
)
784 tms_bits
|= (1 << state_ndx
);
787 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
788 tap_state_name(walker
), tap_state_name(desired_next_state
));
792 walker
= desired_next_state
;
795 clock_tms(0x4b, tms_bits
, num_states
, 0);
797 tap_set_end_state(tap_get_state());
800 static void ft2232_add_scan(bool ir_scan
, enum scan_type type
, uint8_t* buffer
, int scan_size
)
802 int num_bytes
= (scan_size
+ 7) / 8;
803 int bits_left
= scan_size
;
809 if (tap_get_state() != TAP_DRSHIFT
)
811 move_to_state(TAP_DRSHIFT
);
816 if (tap_get_state() != TAP_IRSHIFT
)
818 move_to_state(TAP_IRSHIFT
);
822 /* add command for complete bytes */
823 while (num_bytes
> 1)
828 /* Clock Data Bytes In and Out LSB First */
830 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
832 else if (type
== SCAN_OUT
)
834 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
836 /* LOG_DEBUG("added TDI bytes (o)"); */
838 else if (type
== SCAN_IN
)
840 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
842 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
845 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
846 num_bytes
-= thisrun_bytes
;
848 buffer_write((uint8_t) (thisrun_bytes
- 1));
849 buffer_write((uint8_t) ((thisrun_bytes
- 1) >> 8));
853 /* add complete bytes */
854 while (thisrun_bytes
-- > 0)
856 buffer_write(buffer
[cur_byte
++]);
860 else /* (type == SCAN_IN) */
862 bits_left
-= 8 * (thisrun_bytes
);
866 /* the most signifcant bit is scanned during TAP movement */
868 last_bit
= (buffer
[cur_byte
] >> (bits_left
- 1)) & 0x1;
872 /* process remaining bits but the last one */
877 /* Clock Data Bits In and Out LSB First */
879 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
881 else if (type
== SCAN_OUT
)
883 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
885 /* LOG_DEBUG("added TDI bits (o)"); */
887 else if (type
== SCAN_IN
)
889 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
891 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
894 buffer_write(bits_left
- 2);
896 buffer_write(buffer
[cur_byte
]);
899 if ((ir_scan
&& (tap_get_end_state() == TAP_IRSHIFT
))
900 || (!ir_scan
&& (tap_get_end_state() == TAP_DRSHIFT
)))
904 /* Clock Data Bits In and Out LSB First */
906 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
908 else if (type
== SCAN_OUT
)
910 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
912 /* LOG_DEBUG("added TDI bits (o)"); */
914 else if (type
== SCAN_IN
)
916 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
918 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
921 buffer_write(last_bit
);
929 /* move from Shift-IR/DR to end state */
930 if (type
!= SCAN_OUT
)
932 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
933 /* This must be coordinated with the bit shifts in ft2232_read_scan */
936 /* Clock Data to TMS/CS Pin with Read */
938 /* LOG_DEBUG("added TMS scan (read)"); */
942 tms_bits
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
943 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
944 /* Clock Data to TMS/CS Pin (no Read) */
946 /* LOG_DEBUG("added TMS scan (no read)"); */
949 clock_tms(mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
952 if (tap_get_state() != tap_get_end_state())
954 move_to_state(tap_get_end_state());
958 static int ft2232_large_scan(scan_command_t
* cmd
, enum scan_type type
, uint8_t* buffer
, int scan_size
)
960 int num_bytes
= (scan_size
+ 7) / 8;
961 int bits_left
= scan_size
;
964 uint8_t* receive_buffer
= malloc(CEIL(scan_size
, 8));
965 uint8_t* receive_pointer
= receive_buffer
;
966 uint32_t bytes_written
;
969 int thisrun_read
= 0;
973 LOG_ERROR("BUG: large IR scans are not supported");
977 if (tap_get_state() != TAP_DRSHIFT
)
979 move_to_state(TAP_DRSHIFT
);
982 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
984 LOG_ERROR("couldn't write MPSSE commands to FT2232");
987 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
988 ft2232_buffer_size
, (int)bytes_written
);
989 ft2232_buffer_size
= 0;
991 /* add command for complete bytes */
992 while (num_bytes
> 1)
998 /* Clock Data Bytes In and Out LSB First */
1000 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1002 else if (type
== SCAN_OUT
)
1004 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1006 /* LOG_DEBUG("added TDI bytes (o)"); */
1008 else if (type
== SCAN_IN
)
1010 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1012 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1015 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
1016 thisrun_read
= thisrun_bytes
;
1017 num_bytes
-= thisrun_bytes
;
1018 buffer_write((uint8_t) (thisrun_bytes
- 1));
1019 buffer_write((uint8_t) ((thisrun_bytes
- 1) >> 8));
1021 if (type
!= SCAN_IN
)
1023 /* add complete bytes */
1024 while (thisrun_bytes
-- > 0)
1026 buffer_write(buffer
[cur_byte
]);
1031 else /* (type == SCAN_IN) */
1033 bits_left
-= 8 * (thisrun_bytes
);
1036 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
1038 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1041 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1043 (int)bytes_written
);
1044 ft2232_buffer_size
= 0;
1046 if (type
!= SCAN_OUT
)
1048 if ((retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
)) != ERROR_OK
)
1050 LOG_ERROR("couldn't read from FT2232");
1053 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1056 receive_pointer
+= bytes_read
;
1062 /* the most signifcant bit is scanned during TAP movement */
1063 if (type
!= SCAN_IN
)
1064 last_bit
= (buffer
[cur_byte
] >> (bits_left
- 1)) & 0x1;
1068 /* process remaining bits but the last one */
1071 if (type
== SCAN_IO
)
1073 /* Clock Data Bits In and Out LSB First */
1075 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1077 else if (type
== SCAN_OUT
)
1079 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1081 /* LOG_DEBUG("added TDI bits (o)"); */
1083 else if (type
== SCAN_IN
)
1085 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1087 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1089 buffer_write(bits_left
- 2);
1090 if (type
!= SCAN_IN
)
1091 buffer_write(buffer
[cur_byte
]);
1093 if (type
!= SCAN_OUT
)
1097 if (tap_get_end_state() == TAP_DRSHIFT
)
1099 if (type
== SCAN_IO
)
1101 /* Clock Data Bits In and Out LSB First */
1103 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1105 else if (type
== SCAN_OUT
)
1107 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1109 /* LOG_DEBUG("added TDI bits (o)"); */
1111 else if (type
== SCAN_IN
)
1113 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1115 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1118 buffer_write(last_bit
);
1122 int tms_bits
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1123 int tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1126 /* move from Shift-IR/DR to end state */
1127 if (type
!= SCAN_OUT
)
1129 /* Clock Data to TMS/CS Pin with Read */
1131 /* LOG_DEBUG("added TMS scan (read)"); */
1135 /* Clock Data to TMS/CS Pin (no Read) */
1137 /* LOG_DEBUG("added TMS scan (no read)"); */
1140 clock_tms(mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
1143 if (type
!= SCAN_OUT
)
1146 if ((retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
)) != ERROR_OK
)
1148 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1151 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1153 (int)bytes_written
);
1154 ft2232_buffer_size
= 0;
1156 if (type
!= SCAN_OUT
)
1158 if ((retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
)) != ERROR_OK
)
1160 LOG_ERROR("couldn't read from FT2232");
1163 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1166 receive_pointer
+= bytes_read
;
1172 static int ft2232_predict_scan_out(int scan_size
, enum scan_type type
)
1174 int predicted_size
= 3;
1175 int num_bytes
= (scan_size
- 1) / 8;
1177 if (tap_get_state() != TAP_DRSHIFT
)
1178 predicted_size
+= get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT
));
1180 if (type
== SCAN_IN
) /* only from device to host */
1182 /* complete bytes */
1183 predicted_size
+= CEIL(num_bytes
, 65536) * 3;
1185 /* remaining bits - 1 (up to 7) */
1186 predicted_size
+= ((scan_size
- 1) % 8) ? 2 : 0;
1188 else /* host to device, or bidirectional */
1190 /* complete bytes */
1191 predicted_size
+= num_bytes
+ CEIL(num_bytes
, 65536) * 3;
1193 /* remaining bits -1 (up to 7) */
1194 predicted_size
+= ((scan_size
- 1) % 8) ? 3 : 0;
1197 return predicted_size
;
1200 static int ft2232_predict_scan_in(int scan_size
, enum scan_type type
)
1202 int predicted_size
= 0;
1204 if (type
!= SCAN_OUT
)
1206 /* complete bytes */
1207 predicted_size
+= (CEIL(scan_size
, 8) > 1) ? (CEIL(scan_size
, 8) - 1) : 0;
1209 /* remaining bits - 1 */
1210 predicted_size
+= ((scan_size
- 1) % 8) ? 1 : 0;
1212 /* last bit (from TMS scan) */
1213 predicted_size
+= 1;
1216 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1218 return predicted_size
;
1221 static void usbjtag_reset(int trst
, int srst
)
1223 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1226 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1227 low_direction
|= nTRSTnOE
; /* switch to output pin (output is low) */
1229 low_output
&= ~nTRST
; /* switch output low */
1233 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1234 low_direction
&= ~nTRSTnOE
; /* switch to input pin (high-Z + internal and external pullup) */
1236 low_output
|= nTRST
; /* switch output high */
1241 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1242 low_output
&= ~nSRST
; /* switch output low */
1244 low_direction
|= nSRSTnOE
; /* switch to output pin (output is low) */
1248 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1249 low_output
|= nSRST
; /* switch output high */
1251 low_direction
&= ~nSRSTnOE
; /* switch to input pin (high-Z) */
1254 /* command "set data bits low byte" */
1256 buffer_write(low_output
);
1257 buffer_write(low_direction
);
1260 static void jtagkey_reset(int trst
, int srst
)
1262 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1265 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1266 high_output
&= ~nTRSTnOE
;
1268 high_output
&= ~nTRST
;
1272 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1273 high_output
|= nTRSTnOE
;
1275 high_output
|= nTRST
;
1280 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1281 high_output
&= ~nSRST
;
1283 high_output
&= ~nSRSTnOE
;
1287 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1288 high_output
|= nSRST
;
1290 high_output
|= nSRSTnOE
;
1293 /* command "set data bits high byte" */
1295 buffer_write(high_output
);
1296 buffer_write(high_direction
);
1297 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1301 static void olimex_jtag_reset(int trst
, int srst
)
1303 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1306 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1307 high_output
&= ~nTRSTnOE
;
1309 high_output
&= ~nTRST
;
1313 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1314 high_output
|= nTRSTnOE
;
1316 high_output
|= nTRST
;
1321 high_output
|= nSRST
;
1325 high_output
&= ~nSRST
;
1328 /* command "set data bits high byte" */
1330 buffer_write(high_output
);
1331 buffer_write(high_direction
);
1332 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1336 static void axm0432_jtag_reset(int trst
, int srst
)
1340 tap_set_state(TAP_RESET
);
1341 high_output
&= ~nTRST
;
1345 high_output
|= nTRST
;
1350 high_output
&= ~nSRST
;
1354 high_output
|= nSRST
;
1357 /* command "set data bits low byte" */
1359 buffer_write(high_output
);
1360 buffer_write(high_direction
);
1361 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1365 static void flyswatter_reset(int trst
, int srst
)
1369 low_output
&= ~nTRST
;
1373 low_output
|= nTRST
;
1378 low_output
|= nSRST
;
1382 low_output
&= ~nSRST
;
1385 /* command "set data bits low byte" */
1387 buffer_write(low_output
);
1388 buffer_write(low_direction
);
1389 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst
, srst
, low_output
, low_direction
);
1392 static void turtle_reset(int trst
, int srst
)
1398 low_output
|= nSRST
;
1402 low_output
&= ~nSRST
;
1405 /* command "set data bits low byte" */
1407 buffer_write(low_output
);
1408 buffer_write(low_direction
);
1409 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst
, low_output
, low_direction
);
1412 static void comstick_reset(int trst
, int srst
)
1416 high_output
&= ~nTRST
;
1420 high_output
|= nTRST
;
1425 high_output
&= ~nSRST
;
1429 high_output
|= nSRST
;
1432 /* command "set data bits high byte" */
1434 buffer_write(high_output
);
1435 buffer_write(high_direction
);
1436 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1440 static void stm32stick_reset(int trst
, int srst
)
1444 high_output
&= ~nTRST
;
1448 high_output
|= nTRST
;
1453 low_output
&= ~nSRST
;
1457 low_output
|= nSRST
;
1460 /* command "set data bits low byte" */
1462 buffer_write(low_output
);
1463 buffer_write(low_direction
);
1465 /* command "set data bits high byte" */
1467 buffer_write(high_output
);
1468 buffer_write(high_direction
);
1469 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1473 static void sheevaplug_reset(int trst
, int srst
)
1476 high_output
&= ~nTRST
;
1478 high_output
|= nTRST
;
1481 high_output
&= ~nSRSTnOE
;
1483 high_output
|= nSRSTnOE
;
1485 /* command "set data bits high byte" */
1487 buffer_write(high_output
);
1488 buffer_write(high_direction
);
1489 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
, high_direction
);
1492 static int ft2232_execute_runtest(jtag_command_t
*cmd
)
1496 int predicted_size
= 0;
1499 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1500 cmd
->cmd
.runtest
->num_cycles
,
1501 tap_state_name(cmd
->cmd
.runtest
->end_state
));
1503 /* only send the maximum buffer size that FT2232C can handle */
1505 if (tap_get_state() != TAP_IDLE
)
1506 predicted_size
+= 3;
1507 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1508 if (cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
)
1509 predicted_size
+= 3;
1510 if (tap_get_end_state() != TAP_IDLE
)
1511 predicted_size
+= 3;
1512 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1514 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1515 retval
= ERROR_JTAG_QUEUE_FAILED
;
1519 if (tap_get_state() != TAP_IDLE
)
1521 move_to_state(TAP_IDLE
);
1524 i
= cmd
->cmd
.runtest
->num_cycles
;
1527 /* there are no state transitions in this code, so omit state tracking */
1529 /* command "Clock Data to TMS/CS Pin (no Read)" */
1533 buffer_write((i
> 7) ? 6 : (i
- 1));
1537 tap_set_state(TAP_IDLE
);
1539 i
-= (i
> 7) ? 7 : i
;
1540 /* LOG_DEBUG("added TMS scan (no read)"); */
1543 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1545 if (tap_get_state() != tap_get_end_state())
1547 move_to_state(tap_get_end_state());
1551 #ifdef _DEBUG_JTAG_IO_
1552 LOG_DEBUG("runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name(tap_get_end_state()));
1558 static int ft2232_execute_statemove(jtag_command_t
*cmd
)
1560 int predicted_size
= 0;
1561 int retval
= ERROR_OK
;
1563 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1565 /* only send the maximum buffer size that FT2232C can handle */
1567 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1569 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1570 retval
= ERROR_JTAG_QUEUE_FAILED
;
1574 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1576 /* move to end state */
1577 if (tap_get_state() != tap_get_end_state())
1579 move_to_state(tap_get_end_state());
1586 static int ft2232_execute_pathmove(jtag_command_t
*cmd
)
1588 int predicted_size
= 0;
1589 int retval
= ERROR_OK
;
1591 tap_state_t
* path
= cmd
->cmd
.pathmove
->path
;
1592 int num_states
= cmd
->cmd
.pathmove
->num_states
;
1594 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
1595 tap_state_name(tap_get_state()),
1596 tap_state_name(path
[num_states
-1]));
1598 /* only send the maximum buffer size that FT2232C can handle */
1599 predicted_size
= 3 * CEIL(num_states
, 7);
1600 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1602 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1603 retval
= ERROR_JTAG_QUEUE_FAILED
;
1609 ft2232_add_pathmove(path
, num_states
);
1615 static int ft2232_execute_scan(jtag_command_t
*cmd
)
1618 int scan_size
; /* size of IR or DR scan */
1619 int predicted_size
= 0;
1620 int retval
= ERROR_OK
;
1622 enum scan_type type
= jtag_scan_type(cmd
->cmd
.scan
);
1624 DEBUG_JTAG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN", type
);
1626 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1628 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1629 if ((predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1631 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1632 /* unsent commands before this */
1633 if (first_unsent
!= cmd
)
1634 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1635 retval
= ERROR_JTAG_QUEUE_FAILED
;
1637 /* current command */
1638 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1639 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1641 first_unsent
= cmd
->next
;
1646 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1648 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1651 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1652 retval
= ERROR_JTAG_QUEUE_FAILED
;
1656 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1657 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1658 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1659 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1663 #ifdef _DEBUG_JTAG_IO_
1664 LOG_DEBUG("%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1665 tap_state_name(tap_get_end_state()));
1671 static int ft2232_execute_reset(jtag_command_t
*cmd
)
1674 int predicted_size
= 0;
1677 DEBUG_JTAG_IO("reset trst: %i srst %i",
1678 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1680 /* only send the maximum buffer size that FT2232C can handle */
1682 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1684 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1685 retval
= ERROR_JTAG_QUEUE_FAILED
;
1690 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1693 #ifdef _DEBUG_JTAG_IO_
1694 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1699 static int ft2232_execute_sleep(jtag_command_t
*cmd
)
1704 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
1706 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1707 retval
= ERROR_JTAG_QUEUE_FAILED
;
1708 first_unsent
= cmd
->next
;
1709 jtag_sleep(cmd
->cmd
.sleep
->us
);
1710 #ifdef _DEBUG_JTAG_IO_
1711 LOG_DEBUG("sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name(tap_get_state()));
1717 static int ft2232_execute_stableclocks(jtag_command_t
*cmd
)
1722 /* this is only allowed while in a stable state. A check for a stable
1723 * state was done in jtag_add_clocks()
1725 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1726 retval
= ERROR_JTAG_QUEUE_FAILED
;
1727 #ifdef _DEBUG_JTAG_IO_
1728 LOG_DEBUG("clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name(tap_get_state()));
1734 static int ft2232_execute_command(jtag_command_t
*cmd
)
1741 case JTAG_RESET
: retval
= ft2232_execute_reset(cmd
); break;
1742 case JTAG_RUNTEST
: retval
= ft2232_execute_runtest(cmd
); break;
1743 case JTAG_STATEMOVE
: retval
= ft2232_execute_statemove(cmd
); break;
1744 case JTAG_PATHMOVE
: retval
= ft2232_execute_pathmove(cmd
); break;
1745 case JTAG_SCAN
: retval
= ft2232_execute_scan(cmd
); break;
1746 case JTAG_SLEEP
: retval
= ft2232_execute_sleep(cmd
); break;
1747 case JTAG_STABLECLOCKS
: retval
= ft2232_execute_stableclocks(cmd
); break;
1749 LOG_ERROR("BUG: unknown JTAG command type encountered");
1755 static int ft2232_execute_queue()
1757 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1760 first_unsent
= cmd
; /* next command that has to be sent */
1763 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1764 * that wasn't handled by a caller-provided error handler
1768 ft2232_buffer_size
= 0;
1769 ft2232_expect_read
= 0;
1771 /* blink, if the current layout has that feature */
1777 if (ft2232_execute_command(cmd
) != ERROR_OK
)
1778 retval
= ERROR_JTAG_QUEUE_FAILED
;
1779 /* Start reading input before FT2232 TX buffer fills up */
1781 if (ft2232_expect_read
> 256)
1783 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1784 retval
= ERROR_JTAG_QUEUE_FAILED
;
1789 if (require_send
> 0)
1790 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1791 retval
= ERROR_JTAG_QUEUE_FAILED
;
1796 #if BUILD_FT2232_FTD2XX == 1
1797 static int ft2232_init_ftd2xx(uint16_t vid
, uint16_t pid
, int more
, int* try_more
)
1801 char SerialNumber
[16];
1802 char Description
[64];
1803 DWORD openex_flags
= 0;
1804 char* openex_string
= NULL
;
1805 uint8_t latency_timer
;
1807 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1810 /* Add non-standard Vid/Pid to the linux driver */
1811 if ((status
= FT_SetVIDPID(vid
, pid
)) != FT_OK
)
1813 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1817 if (ft2232_device_desc
&& ft2232_serial
)
1819 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1820 ft2232_device_desc
= NULL
;
1823 if (ft2232_device_desc
)
1825 openex_string
= ft2232_device_desc
;
1826 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1828 else if (ft2232_serial
)
1830 openex_string
= ft2232_serial
;
1831 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1835 LOG_ERROR("neither device description nor serial number specified");
1836 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1838 return ERROR_JTAG_INIT_FAILED
;
1841 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1842 if (status
!= FT_OK
) {
1843 /* under Win32, the FTD2XX driver appends an "A" to the end
1844 * of the description, if we tried by the desc, then
1845 * try by the alternate "A" description. */
1846 if (openex_string
== ft2232_device_desc
) {
1847 /* Try the alternate method. */
1848 openex_string
= ft2232_device_desc_A
;
1849 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1850 if (status
== FT_OK
) {
1851 /* yea, the "alternate" method worked! */
1853 /* drat, give the user a meaningfull message.
1854 * telling the use we tried *BOTH* methods. */
1855 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1857 ft2232_device_desc_A
);
1862 if (status
!= FT_OK
)
1868 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1870 return ERROR_JTAG_INIT_FAILED
;
1872 LOG_ERROR("unable to open ftdi device: %lu", status
);
1873 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1874 if (status
== FT_OK
)
1876 char** desc_array
= malloc(sizeof(char*) * (num_devices
+ 1));
1879 for (i
= 0; i
< num_devices
; i
++)
1880 desc_array
[i
] = malloc(64);
1882 desc_array
[num_devices
] = NULL
;
1884 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1886 if (status
== FT_OK
)
1888 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1889 for (i
= 0; i
< num_devices
; i
++)
1890 LOG_ERROR("%" PRIu32
": \"%s\"", i
, desc_array
[i
]);
1893 for (i
= 0; i
< num_devices
; i
++)
1894 free(desc_array
[i
]);
1900 LOG_ERROR("ListDevices: NONE\n");
1902 return ERROR_JTAG_INIT_FAILED
;
1905 if ((status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
)) != FT_OK
)
1907 LOG_ERROR("unable to set latency timer: %lu", status
);
1908 return ERROR_JTAG_INIT_FAILED
;
1911 if ((status
= FT_GetLatencyTimer(ftdih
, &latency_timer
)) != FT_OK
)
1913 LOG_ERROR("unable to get latency timer: %lu", status
);
1914 return ERROR_JTAG_INIT_FAILED
;
1918 LOG_DEBUG("current latency timer: %i", latency_timer
);
1921 if ((status
= FT_SetTimeouts(ftdih
, 5000, 5000)) != FT_OK
)
1923 LOG_ERROR("unable to set timeouts: %lu", status
);
1924 return ERROR_JTAG_INIT_FAILED
;
1927 if ((status
= FT_SetBitMode(ftdih
, 0x0b, 2)) != FT_OK
)
1929 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1930 return ERROR_JTAG_INIT_FAILED
;
1933 if ((status
= FT_GetDeviceInfo(ftdih
, &ftdi_device
, &deviceID
, SerialNumber
, Description
, NULL
)) != FT_OK
)
1935 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status
);
1936 return ERROR_JTAG_INIT_FAILED
;
1940 static const char* type_str
[] =
1941 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1942 unsigned no_of_known_types
= sizeof(type_str
) / sizeof(type_str
[0]) - 1;
1943 unsigned type_index
= ((unsigned)ftdi_device
<= no_of_known_types
)
1945 LOG_INFO("device: %lu \"%s\"", ftdi_device
, type_str
[type_index
]);
1946 LOG_INFO("deviceID: %lu", deviceID
);
1947 LOG_INFO("SerialNumber: %s", SerialNumber
);
1948 LOG_INFO("Description: %s", Description
);
1954 static int ft2232_purge_ftd2xx(void)
1958 if ((status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
)) != FT_OK
)
1960 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1961 return ERROR_JTAG_INIT_FAILED
;
1967 #endif /* BUILD_FT2232_FTD2XX == 1 */
1969 #if BUILD_FT2232_LIBFTDI == 1
1970 static int ft2232_init_libftdi(uint16_t vid
, uint16_t pid
, int more
, int* try_more
)
1972 uint8_t latency_timer
;
1974 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1975 ft2232_layout
, vid
, pid
);
1977 if (ftdi_init(&ftdic
) < 0)
1978 return ERROR_JTAG_INIT_FAILED
;
1980 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1982 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1983 return ERROR_JTAG_INIT_FAILED
;
1986 /* context, vendor id, product id */
1987 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1991 LOG_WARNING("unable to open ftdi device (trying more): %s",
1994 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1996 return ERROR_JTAG_INIT_FAILED
;
1999 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2000 if (ftdi_usb_reset(&ftdic
) < 0)
2002 LOG_ERROR("unable to reset ftdi device");
2003 return ERROR_JTAG_INIT_FAILED
;
2006 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
2008 LOG_ERROR("unable to set latency timer");
2009 return ERROR_JTAG_INIT_FAILED
;
2012 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
2014 LOG_ERROR("unable to get latency timer");
2015 return ERROR_JTAG_INIT_FAILED
;
2019 LOG_DEBUG("current latency timer: %i", latency_timer
);
2022 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
2024 ftdi_device
= ftdic
.type
;
2025 static const char* type_str
[] =
2026 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2027 unsigned no_of_known_types
= sizeof(type_str
) / sizeof(type_str
[0]) - 1;
2028 unsigned type_index
= ((unsigned)ftdi_device
< no_of_known_types
)
2029 ? ftdi_device
: no_of_known_types
;
2030 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device
, type_str
[type_index
]);
2034 static int ft2232_purge_libftdi(void)
2036 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
2038 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
2039 return ERROR_JTAG_INIT_FAILED
;
2045 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2047 static int ft2232_init(void)
2051 uint32_t bytes_written
;
2052 const ft2232_layout_t
* cur_layout
= ft2232_layouts
;
2055 if (tap_get_tms_path_len(TAP_IRPAUSE
,TAP_IRPAUSE
) == 7)
2057 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2061 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2064 if ((ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0))
2066 ft2232_layout
= "usbjtag";
2067 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2070 while (cur_layout
->name
)
2072 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
2074 layout
= cur_layout
;
2082 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
2083 return ERROR_JTAG_INIT_FAILED
;
2089 * "more indicates that there are more IDs to try, so we should
2090 * not print an error for an ID mismatch (but for anything
2093 * try_more indicates that the error code returned indicates an
2094 * ID mismatch (and nothing else) and that we should proceeed
2095 * with the next ID pair.
2097 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
2100 #if BUILD_FT2232_FTD2XX == 1
2101 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
2103 #elif BUILD_FT2232_LIBFTDI == 1
2104 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
2109 if (!more
|| !try_more
)
2113 ft2232_buffer_size
= 0;
2114 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
2116 if (layout
->init() != ERROR_OK
)
2117 return ERROR_JTAG_INIT_FAILED
;
2119 if (ft2232_device_is_highspeed())
2121 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK
)
2122 return ERROR_JTAG_INIT_FAILED
;
2125 ft2232_speed(jtag_get_speed());
2127 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2128 if (((retval
= ft2232_write(buf
, 1, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 1))
2130 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2131 return ERROR_JTAG_INIT_FAILED
;
2134 #if BUILD_FT2232_FTD2XX == 1
2135 return ft2232_purge_ftd2xx();
2136 #elif BUILD_FT2232_LIBFTDI == 1
2137 return ft2232_purge_libftdi();
2143 static int usbjtag_init(void)
2146 uint32_t bytes_written
;
2149 low_direction
= 0x0b;
2151 if (strcmp(ft2232_layout
, "usbjtag") == 0)
2158 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
2165 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
2172 low_direction
= 0x8b;
2174 else if (strcmp(ft2232_layout
, "luminary_icdi") == 0)
2181 low_direction
= 0xcb;
2185 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
2186 return ERROR_JTAG_INIT_FAILED
;
2189 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2190 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2192 low_direction
&= ~nTRSTnOE
; /* nTRST input */
2193 low_output
&= ~nTRST
; /* nTRST = 0 */
2197 low_direction
|= nTRSTnOE
; /* nTRST output */
2198 low_output
|= nTRST
; /* nTRST = 1 */
2201 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2203 low_direction
|= nSRSTnOE
; /* nSRST output */
2204 low_output
|= nSRST
; /* nSRST = 1 */
2208 low_direction
&= ~nSRSTnOE
; /* nSRST input */
2209 low_output
&= ~nSRST
; /* nSRST = 0 */
2212 /* initialize low byte for jtag */
2213 buf
[0] = 0x80; /* command "set data bits low byte" */
2214 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2215 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2216 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2218 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2220 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2221 return ERROR_JTAG_INIT_FAILED
;
2227 static int axm0432_jtag_init(void)
2230 uint32_t bytes_written
;
2233 low_direction
= 0x2b;
2235 /* initialize low byte for jtag */
2236 buf
[0] = 0x80; /* command "set data bits low byte" */
2237 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2238 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2239 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2241 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2243 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2244 return ERROR_JTAG_INIT_FAILED
;
2247 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
2250 nTRSTnOE
= 0x0; /* No output enable for TRST*/
2252 nSRSTnOE
= 0x0; /* No output enable for SRST*/
2256 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2261 high_direction
= 0x0c;
2263 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2264 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2266 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2270 high_output
|= nTRST
;
2273 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2275 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2279 high_output
|= nSRST
;
2282 /* initialize high port */
2283 buf
[0] = 0x82; /* command "set data bits high byte" */
2284 buf
[1] = high_output
; /* value */
2285 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2286 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2288 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2290 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2291 return ERROR_JTAG_INIT_FAILED
;
2297 static int jtagkey_init(void)
2300 uint32_t bytes_written
;
2303 low_direction
= 0x1b;
2305 /* initialize low byte for jtag */
2306 buf
[0] = 0x80; /* command "set data bits low byte" */
2307 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2308 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2309 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2311 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2313 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2314 return ERROR_JTAG_INIT_FAILED
;
2317 if (strcmp(layout
->name
, "jtagkey") == 0)
2324 else if ((strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2325 || (strcmp(layout
->name
, "oocdlink") == 0))
2334 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2339 high_direction
= 0x0f;
2341 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2342 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2344 high_output
|= nTRSTnOE
;
2345 high_output
&= ~nTRST
;
2349 high_output
&= ~nTRSTnOE
;
2350 high_output
|= nTRST
;
2353 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2355 high_output
&= ~nSRSTnOE
;
2356 high_output
|= nSRST
;
2360 high_output
|= nSRSTnOE
;
2361 high_output
&= ~nSRST
;
2364 /* initialize high port */
2365 buf
[0] = 0x82; /* command "set data bits high byte" */
2366 buf
[1] = high_output
; /* value */
2367 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2368 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2370 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2372 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2373 return ERROR_JTAG_INIT_FAILED
;
2379 static int olimex_jtag_init(void)
2382 uint32_t bytes_written
;
2385 low_direction
= 0x1b;
2387 /* initialize low byte for jtag */
2388 buf
[0] = 0x80; /* command "set data bits low byte" */
2389 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2390 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2391 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2393 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2395 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2396 return ERROR_JTAG_INIT_FAILED
;
2402 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2405 high_direction
= 0x0f;
2407 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2408 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2410 high_output
|= nTRSTnOE
;
2411 high_output
&= ~nTRST
;
2415 high_output
&= ~nTRSTnOE
;
2416 high_output
|= nTRST
;
2419 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2421 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2425 high_output
&= ~nSRST
;
2428 /* turn red LED on */
2429 high_output
|= 0x08;
2431 /* initialize high port */
2432 buf
[0] = 0x82; /* command "set data bits high byte" */
2433 buf
[1] = high_output
; /* value */
2434 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2435 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2437 if ((ft2232_write(buf
, 3, &bytes_written
) != ERROR_OK
) || (bytes_written
!= 3))
2439 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2440 return ERROR_JTAG_INIT_FAILED
;
2446 static int flyswatter_init(void)
2449 uint32_t bytes_written
;
2452 low_direction
= 0xfb;
2454 /* initialize low byte for jtag */
2455 buf
[0] = 0x80; /* command "set data bits low byte" */
2456 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2457 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2458 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2460 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2462 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2463 return ERROR_JTAG_INIT_FAILED
;
2467 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2469 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2472 high_direction
= 0x0c;
2474 /* turn red LED3 on, LED2 off */
2475 high_output
|= 0x08;
2477 /* initialize high port */
2478 buf
[0] = 0x82; /* command "set data bits high byte" */
2479 buf
[1] = high_output
; /* value */
2480 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2481 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2483 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2485 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2486 return ERROR_JTAG_INIT_FAILED
;
2492 static int turtle_init(void)
2495 uint32_t bytes_written
;
2498 low_direction
= 0x5b;
2500 /* initialize low byte for jtag */
2501 buf
[0] = 0x80; /* command "set data bits low byte" */
2502 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2503 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2504 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2506 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2508 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2509 return ERROR_JTAG_INIT_FAILED
;
2515 high_direction
= 0x0C;
2517 /* initialize high port */
2518 buf
[0] = 0x82; /* command "set data bits high byte" */
2519 buf
[1] = high_output
;
2520 buf
[2] = high_direction
;
2521 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2523 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2525 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2526 return ERROR_JTAG_INIT_FAILED
;
2532 static int comstick_init(void)
2535 uint32_t bytes_written
;
2538 low_direction
= 0x0b;
2540 /* initialize low byte for jtag */
2541 buf
[0] = 0x80; /* command "set data bits low byte" */
2542 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2543 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2544 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2546 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2548 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2549 return ERROR_JTAG_INIT_FAILED
;
2553 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2555 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2558 high_direction
= 0x03;
2560 /* initialize high port */
2561 buf
[0] = 0x82; /* command "set data bits high byte" */
2562 buf
[1] = high_output
;
2563 buf
[2] = high_direction
;
2564 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2566 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2568 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2569 return ERROR_JTAG_INIT_FAILED
;
2575 static int stm32stick_init(void)
2578 uint32_t bytes_written
;
2581 low_direction
= 0x8b;
2583 /* initialize low byte for jtag */
2584 buf
[0] = 0x80; /* command "set data bits low byte" */
2585 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2586 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2587 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2589 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2591 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2592 return ERROR_JTAG_INIT_FAILED
;
2596 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2598 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2601 high_direction
= 0x03;
2603 /* initialize high port */
2604 buf
[0] = 0x82; /* command "set data bits high byte" */
2605 buf
[1] = high_output
;
2606 buf
[2] = high_direction
;
2607 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2609 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2611 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2612 return ERROR_JTAG_INIT_FAILED
;
2618 static int sheevaplug_init(void)
2621 uint32_t bytes_written
;
2624 low_direction
= 0x1b;
2626 /* initialize low byte for jtag */
2627 buf
[0] = 0x80; /* command "set data bits low byte" */
2628 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2629 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2630 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2632 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2634 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2635 return ERROR_JTAG_INIT_FAILED
;
2644 high_direction
= 0x0f;
2646 /* nTRST is always push-pull */
2647 high_output
&= ~nTRSTnOE
;
2648 high_output
|= nTRST
;
2650 /* nSRST is always open-drain */
2651 high_output
|= nSRSTnOE
;
2652 high_output
&= ~nSRST
;
2654 /* initialize high port */
2655 buf
[0] = 0x82; /* command "set data bits high byte" */
2656 buf
[1] = high_output
; /* value */
2657 buf
[2] = high_direction
; /* all outputs - xRST */
2658 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2660 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2662 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2663 return ERROR_JTAG_INIT_FAILED
;
2669 static int cortino_jtag_init(void)
2672 uint32_t bytes_written
;
2675 low_direction
= 0x1b;
2677 /* initialize low byte for jtag */
2678 buf
[0] = 0x80; /* command "set data bits low byte" */
2679 buf
[1] = low_output
; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2680 buf
[2] = low_direction
; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2681 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2683 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2685 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2686 return ERROR_JTAG_INIT_FAILED
;
2690 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2692 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2695 high_direction
= 0x03;
2697 /* initialize high port */
2698 buf
[0] = 0x82; /* command "set data bits high byte" */
2699 buf
[1] = high_output
;
2700 buf
[2] = high_direction
;
2701 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2703 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2705 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2706 return ERROR_JTAG_INIT_FAILED
;
2712 static void olimex_jtag_blink(void)
2714 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2715 * ACBUS3 is bit 3 of the GPIOH port
2717 if (high_output
& 0x08)
2719 /* set port pin high */
2720 high_output
&= 0x07;
2724 /* set port pin low */
2725 high_output
|= 0x08;
2729 buffer_write(high_output
);
2730 buffer_write(high_direction
);
2733 static void flyswatter_jtag_blink(void)
2736 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2738 high_output
^= 0x0c;
2741 buffer_write(high_output
);
2742 buffer_write(high_direction
);
2745 static void turtle_jtag_blink(void)
2748 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2750 if (high_output
& 0x08)
2760 buffer_write(high_output
);
2761 buffer_write(high_direction
);
2764 static int ft2232_quit(void)
2766 #if BUILD_FT2232_FTD2XX == 1
2769 status
= FT_Close(ftdih
);
2770 #elif BUILD_FT2232_LIBFTDI == 1
2771 ftdi_usb_close(&ftdic
);
2773 ftdi_deinit(&ftdic
);
2776 free(ft2232_buffer
);
2777 ft2232_buffer
= NULL
;
2782 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2788 ft2232_device_desc
= strdup(args
[0]);
2789 cp
= strchr(ft2232_device_desc
, 0);
2790 /* under Win32, the FTD2XX driver appends an "A" to the end
2791 * of the description, this examines the given desc
2792 * and creates the 'missing' _A or non_A variable. */
2793 if ((cp
[-1] == 'A') && (cp
[-2]==' ')) {
2794 /* it was, so make this the "A" version. */
2795 ft2232_device_desc_A
= ft2232_device_desc
;
2796 /* and *CREATE* the non-A version. */
2797 strcpy(buf
, ft2232_device_desc
);
2798 cp
= strchr(buf
, 0);
2800 ft2232_device_desc
= strdup(buf
);
2802 /* <space > A not defined
2804 sprintf(buf
, "%s A", ft2232_device_desc
);
2805 ft2232_device_desc_A
= strdup(buf
);
2810 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2816 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2820 ft2232_serial
= strdup(args
[0]);
2824 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2830 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2835 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2836 strcpy(ft2232_layout
, args
[0]);
2841 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2843 if (argc
> MAX_USB_IDS
* 2)
2845 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2846 "(maximum is %d pairs)", MAX_USB_IDS
);
2847 argc
= MAX_USB_IDS
* 2;
2849 if (argc
< 2 || (argc
& 1))
2851 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2853 return ERROR_COMMAND_SYNTAX_ERROR
;
2854 /* remove the incomplete trailing id */
2859 int retval
= ERROR_OK
;
2860 for (i
= 0; i
< argc
; i
+= 2)
2862 retval
= parse_u16(args
[i
], &ft2232_vid
[i
>> 1]);
2863 if (ERROR_OK
!= retval
)
2865 retval
= parse_u16(args
[i
+ 1], &ft2232_pid
[i
>> 1]);
2866 if (ERROR_OK
!= retval
)
2871 * Explicitly terminate, in case there are multiples instances of
2874 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2879 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2883 ft2232_latency
= atoi(args
[0]);
2887 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2893 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2897 /* 7 bits of either ones or zeros. */
2898 uint8_t tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2900 while (num_cycles
> 0)
2902 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2903 * at most 7 bits per invocation. Here we invoke it potentially
2906 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2908 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2910 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2911 retval
= ERROR_JTAG_QUEUE_FAILED
;
2916 /* there are no state transitions in this code, so omit state tracking */
2918 /* command "Clock Data to TMS/CS Pin (no Read)" */
2922 buffer_write(bitcount_per_command
- 1);
2924 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2929 num_cycles
-= bitcount_per_command
;
2935 /* ---------------------------------------------------------------------
2936 * Support for IceBear JTAG adapter from Section5:
2937 * http://section5.ch/icebear
2939 * Author: Sten, debian@sansys-electronic.com
2942 /* Icebear pin layout
2944 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2945 * GND GND | 4 3| n.c.
2946 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2947 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2948 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2949 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2950 * ADBUS2 TDO |14 13| GND GND
2952 * ADBUS0 O L TCK ACBUS0 GND
2953 * ADBUS1 O L TDI ACBUS1 GND
2954 * ADBUS2 I TDO ACBUS2 n.c.
2955 * ADBUS3 O H TMS ACBUS3 n.c.
2961 static int icebear_jtag_init(void) {
2963 uint32_t bytes_written
;
2965 low_direction
= 0x0b; /* output: TCK TDI TMS; input: TDO */
2966 low_output
= 0x08; /* high: TMS; low: TCK TDI */
2970 enum reset_types jtag_reset_config
= jtag_get_reset_config();
2971 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0) {
2972 low_direction
&= ~nTRST
; /* nTRST high impedance */
2975 low_direction
|= nTRST
;
2976 low_output
|= nTRST
;
2979 low_direction
|= nSRST
;
2980 low_output
|= nSRST
;
2982 /* initialize low byte for jtag */
2983 buf
[0] = 0x80; /* command "set data bits low byte" */
2984 buf
[1] = low_output
;
2985 buf
[2] = low_direction
;
2986 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2988 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3)) {
2989 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2990 return ERROR_JTAG_INIT_FAILED
;
2994 high_direction
= 0x00;
2997 /* initialize high port */
2998 buf
[0] = 0x82; /* command "set data bits high byte" */
2999 buf
[1] = high_output
; /* value */
3000 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
3001 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
3003 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3)) {
3004 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3005 return ERROR_JTAG_INIT_FAILED
;
3011 static void icebear_jtag_reset(int trst
, int srst
) {
3014 low_direction
|= nTRST
;
3015 low_output
&= ~nTRST
;
3017 else if (trst
== 0) {
3018 enum reset_types jtag_reset_config
= jtag_get_reset_config();
3019 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0)
3020 low_direction
&= ~nTRST
;
3022 low_output
|= nTRST
;
3026 low_output
&= ~nSRST
;
3028 else if (srst
== 0) {
3029 low_output
|= nSRST
;
3032 /* command "set data bits low byte" */
3034 buffer_write(low_output
);
3035 buffer_write(low_direction
);
3037 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)