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 ***************************************************************************/
28 /* This code uses information contained in the MPSSE specification which was
30 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
31 * Hereafter this is called the "MPSSE Spec".
33 * The datasheet for the ftdichip.com's FT2232D part is here:
34 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
42 /* project specific includes */
43 #define INCLUDE_JTAG_INTERFACE_H
45 #include "time_support.h"
53 #if (BUILD_FT2232_FTD2XX==1 && BUILD_FT2232_LIBFTDI==1)
54 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
55 #elif(BUILD_FT2232_FTD2XX!=1 && BUILD_FT2232_LIBFTDI!=1)
56 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
59 /* FT2232 access library includes */
60 #if BUILD_FT2232_FTD2XX == 1
62 #elif BUILD_FT2232_LIBFTDI == 1
66 /* max TCK for the high speed devices 30000 kHz */
67 #define FTDI_2232H_4232H_MAX_TCK 30000
69 static int ft2232_execute_queue(void);
71 static int ft2232_speed(int speed
);
72 static int ft2232_speed_div(int speed
, int* khz
);
73 static int ft2232_khz(int khz
, int* jtag_speed
);
74 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
);
75 static int ft2232_init(void);
76 static int ft2232_quit(void);
78 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
79 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
80 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
81 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
82 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
86 * Function ft2232_stableclocks
87 * will send out \a num_cycles on the TCK line while the TAP(s)
88 * are in a stable state. Calling code must ensure that current state is
89 * stable, that verification is not done in here.
90 * @param num_cycles is the count of clocks cycles to send.
91 * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED
93 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
);
95 /* max TCK for the high speed devices 30000 kHz */
96 #define FTDI_2232H_4232H_MAX_TCK 30000
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 u8 ft2232_latency
= 2;
103 static unsigned ft2232_max_tck
= 6000;
106 #define MAX_USB_IDS 8
107 /* vid = pid = 0 marks the end of the list */
108 static u16 ft2232_vid
[MAX_USB_IDS
+ 1] = { 0x0403, 0 };
109 static u16 ft2232_pid
[MAX_USB_IDS
+ 1] = { 0x6010, 0 };
111 typedef struct ft2232_layout_s
115 void (*reset
)(int trst
, int srst
);
119 /* init procedures for supported layouts */
120 static int usbjtag_init(void);
121 static int jtagkey_init(void);
122 static int olimex_jtag_init(void);
123 static int flyswatter_init(void);
124 static int turtle_init(void);
125 static int comstick_init(void);
126 static int stm32stick_init(void);
127 static int axm0432_jtag_init(void);
128 static int sheevaplug_init(void);
129 static int icebear_jtag_init(void);
130 static int cortino_jtag_init(void);
132 /* reset procedures for supported layouts */
133 static void usbjtag_reset(int trst
, int srst
);
134 static void jtagkey_reset(int trst
, int srst
);
135 static void olimex_jtag_reset(int trst
, int srst
);
136 static void flyswatter_reset(int trst
, int srst
);
137 static void turtle_reset(int trst
, int srst
);
138 static void comstick_reset(int trst
, int srst
);
139 static void stm32stick_reset(int trst
, int srst
);
140 static void axm0432_jtag_reset(int trst
, int srst
);
141 static void sheevaplug_reset(int trst
, int srst
);
142 static void icebear_jtag_reset(int trst
, int srst
);
144 /* blink procedures for layouts that support a blinking led */
145 static void olimex_jtag_blink(void);
146 static void flyswatter_jtag_blink(void);
147 static void turtle_jtag_blink(void);
149 ft2232_layout_t ft2232_layouts
[] =
151 { "usbjtag", usbjtag_init
, usbjtag_reset
, NULL
},
152 { "jtagkey", jtagkey_init
, jtagkey_reset
, NULL
},
153 { "jtagkey_prototype_v1", jtagkey_init
, jtagkey_reset
, NULL
},
154 { "oocdlink", jtagkey_init
, jtagkey_reset
, NULL
},
155 { "signalyzer", usbjtag_init
, usbjtag_reset
, NULL
},
156 { "evb_lm3s811", 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 u8 nTRST
, nTRSTnOE
, nSRST
, nSRSTnOE
;
171 static ft2232_layout_t
* layout
;
172 static u8 low_output
= 0x0;
173 static u8 low_direction
= 0x0;
174 static u8 high_output
= 0x0;
175 static u8 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
;
185 static jtag_command_t
* first_unsent
; /* next command that has to be sent */
186 static int require_send
;
189 /* http://urjtag.wiki.sourceforge.net/Cable+FT2232 says:
191 "There is a significant difference between libftdi and libftd2xx. The latter
192 one allows to schedule up to 64*64 bytes of result data while libftdi fails
193 with more than 4*64. As a consequence, the FT2232 driver is forced to
194 perform around 16x more USB transactions for long command streams with TDO
195 capture when running with libftdi."
198 #define FT2232_BUFFER_SIZE 131072
199 a comment would have been nice.
202 #define FT2232_BUFFER_SIZE 131072
204 static u8
* ft2232_buffer
= NULL
;
205 static int ft2232_buffer_size
= 0;
206 static int ft2232_read_pointer
= 0;
207 static int ft2232_expect_read
= 0;
210 * Function buffer_write
211 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
212 * @param val is the byte to send.
214 static inline void buffer_write( u8 val
)
216 assert( ft2232_buffer
);
217 assert( (unsigned) ft2232_buffer_size
< (unsigned) FT2232_BUFFER_SIZE
);
218 ft2232_buffer
[ft2232_buffer_size
++] = val
;
222 * Function buffer_read
223 * returns a byte from the byte buffer.
225 static inline u8
buffer_read(void)
227 assert( ft2232_buffer
);
228 assert( ft2232_read_pointer
< ft2232_buffer_size
);
229 return ft2232_buffer
[ft2232_read_pointer
++];
235 * clocks out \a bit_count bits on the TMS line, starting with the least
236 * significant bit of tms_bits and progressing to more significant bits.
237 * Rigorous state transition logging is done here via tap_set_state().
239 * @param pmsse_cmd is one of the MPSSE TMS oriented commands such as 0x4b or 0x6b. See
240 * the MPSSE spec referenced above for their functionality. The MPSSE command
241 * "Clock Data to TMS/CS Pin (no Read)" is often used for this, 0x4b.
243 * @param tms_bits holds the sequence of bits to send.
244 * @param tms_count tells how many bits in the sequence.
245 * @param tdi_bit is a single bit which is passed on to TDI before the first TCK cycle
246 * and is held static for the duration of TMS clocking. See the MPSSE spec referenced above.
248 static void clock_tms( u8 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 );
256 // LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count );
258 for (tms_byte
= tms_ndx
= i
= 0; i
< tms_count
; ++i
, tms_bits
>>=1)
260 bool bit
= tms_bits
& 1;
263 tms_byte
|= (1<<tms_ndx
);
265 /* always do state transitions in public view */
266 tap_set_state( tap_state_transition(tap_get_state(), bit
) );
268 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
273 if( tms_ndx
==7 || i
==tms_count
-1 )
275 buffer_write( mpsse_cmd
);
276 buffer_write( tms_ndx
- 1 );
278 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
279 TMS/CS and is held static for the duration of TMS/CS clocking.
281 buffer_write( tms_byte
| (tdi_bit
<< 7) );
288 * Function get_tms_buffer_requirements
289 * returns what clock_tms() will consume if called with
292 static inline int get_tms_buffer_requirements( int bit_count
)
294 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 );
325 jtag_interface_t ft2232_interface
=
328 .execute_queue
= ft2232_execute_queue
,
329 .speed
= ft2232_speed
,
330 .speed_div
= ft2232_speed_div
,
332 .register_commands
= ft2232_register_commands
,
337 static int ft2232_write(u8
* buf
, int size
, u32
* bytes_written
)
339 #if BUILD_FT2232_FTD2XX == 1
341 DWORD dw_bytes_written
;
342 if ( ( status
= FT_Write(ftdih
, buf
, size
, &dw_bytes_written
) ) != FT_OK
)
344 *bytes_written
= dw_bytes_written
;
345 LOG_ERROR("FT_Write returned: %lu", status
);
346 return ERROR_JTAG_DEVICE_ERROR
;
350 *bytes_written
= dw_bytes_written
;
353 #elif BUILD_FT2232_LIBFTDI == 1
355 if ( ( retval
= ftdi_write_data(&ftdic
, buf
, size
) ) < 0 )
358 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic
) );
359 return ERROR_JTAG_DEVICE_ERROR
;
363 *bytes_written
= retval
;
370 static int ft2232_read(u8
* buf
, u32 size
, u32
* bytes_read
)
372 #if BUILD_FT2232_FTD2XX == 1
378 while ( (*bytes_read
< size
) && timeout
-- )
380 if ( ( status
= FT_Read(ftdih
, buf
+ *bytes_read
, size
-
381 *bytes_read
, &dw_bytes_read
) ) != FT_OK
)
384 LOG_ERROR("FT_Read returned: %lu", status
);
385 return ERROR_JTAG_DEVICE_ERROR
;
387 *bytes_read
+= dw_bytes_read
;
390 #elif BUILD_FT2232_LIBFTDI == 1
395 while ( (*bytes_read
< size
) && timeout
-- )
397 if ( ( retval
= ftdi_read_data(&ftdic
, buf
+ *bytes_read
, size
- *bytes_read
) ) < 0 )
400 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic
) );
401 return ERROR_JTAG_DEVICE_ERROR
;
403 *bytes_read
+= retval
;
408 if (*bytes_read
< size
)
410 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read
, size
);
411 return ERROR_JTAG_DEVICE_ERROR
;
417 #ifdef BUILD_FTD2XX_HIGHSPEED
418 static bool ft2232_device_is_highspeed(void)
420 return (ftdi_device
== FT_DEVICE_2232H
) || (ftdi_device
== FT_DEVICE_4232H
);
423 static int ft2232_adaptive_clocking(int speed
)
425 bool use_adaptive_clocking
= FALSE
;
428 if (ft2232_device_is_highspeed())
429 use_adaptive_clocking
= TRUE
;
432 LOG_ERROR("ft2232 device %lu does not support RTCK", ftdi_device
);
437 u8 buf
= use_adaptive_clocking
? 0x96 : 0x97;
438 LOG_DEBUG("%2.2x", buf
);
441 int retval
= ft2232_write(&buf
, 1, &bytes_written
);
442 if (ERROR_OK
!= retval
|| bytes_written
!= 1)
444 LOG_ERROR("unable to set adative clocking: %d", retval
);
451 static int ft2232_adaptive_clocking(int speed
)
453 // not implemented on low-speed devices
454 return speed
? ERROR_OK
: -1234;
458 static int ft2232_speed(int speed
)
464 ft2232_adaptive_clocking(speed
);
466 buf
[0] = 0x86; /* command "set divisor" */
467 buf
[1] = speed
& 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
468 buf
[2] = (speed
>> 8) & 0xff; /* valueH */
470 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
471 if ( ( ( retval
= ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
473 LOG_ERROR("couldn't set FT2232 TCK speed");
481 static int ft2232_speed_div(int speed
, int* khz
)
483 /* Take a look in the FT2232 manual,
484 * AN2232C-01 Command Processor for
485 * MPSSE and MCU Host Bus. Chapter 3.8 */
487 *khz
= ft2232_max_tck
/ (1 + speed
);
493 static int ft2232_khz(int khz
, int* jtag_speed
)
497 #ifdef BUILD_FTD2XX_HIGHSPEED
501 LOG_DEBUG("RCLK not supported");
502 LOG_DEBUG("If you have a high-speed FTDI device, then "
503 "OpenOCD may be built with --enable-ftd2xx-highspeed.");
508 /* Take a look in the FT2232 manual,
509 * AN2232C-01 Command Processor for
510 * MPSSE and MCU Host Bus. Chapter 3.8
512 * We will calc here with a multiplier
513 * of 10 for better rounding later. */
515 /* Calc speed, (ft2232_max_tck / khz) - 1 */
516 /* Use 65000 for better rounding */
517 *jtag_speed
= ((ft2232_max_tck
*10) / khz
) - 10;
519 /* Add 0.9 for rounding */
522 /* Calc real speed */
523 *jtag_speed
= *jtag_speed
/ 10;
525 /* Check if speed is greater than 0 */
531 /* Check max value */
532 if (*jtag_speed
> 0xFFFF)
534 *jtag_speed
= 0xFFFF;
541 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
)
543 register_command(cmd_ctx
, NULL
, "ft2232_device_desc", ft2232_handle_device_desc_command
,
544 COMMAND_CONFIG
, "the USB device description of the FTDI FT2232 device");
545 register_command(cmd_ctx
, NULL
, "ft2232_serial", ft2232_handle_serial_command
,
546 COMMAND_CONFIG
, "the serial number of the FTDI FT2232 device");
547 register_command(cmd_ctx
, NULL
, "ft2232_layout", ft2232_handle_layout_command
,
548 COMMAND_CONFIG
, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
549 register_command(cmd_ctx
, NULL
, "ft2232_vid_pid", ft2232_handle_vid_pid_command
,
550 COMMAND_CONFIG
, "the vendor ID and product ID of the FTDI FT2232 device");
551 register_command(cmd_ctx
, NULL
, "ft2232_latency", ft2232_handle_latency_command
,
552 COMMAND_CONFIG
, "set the FT2232 latency timer to a new value");
557 void ft2232_end_state(tap_state_t state
)
559 if (tap_is_state_stable(state
))
560 tap_set_end_state(state
);
563 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
568 static void ft2232_read_scan(enum scan_type type
, u8
* buffer
, int scan_size
)
570 int num_bytes
= (scan_size
+ 7) / 8;
571 int bits_left
= scan_size
;
574 while (num_bytes
-- > 1)
576 buffer
[cur_byte
++] = buffer_read();
580 buffer
[cur_byte
] = 0x0;
582 /* There is one more partial byte left from the clock data in/out instructions */
585 buffer
[cur_byte
] = buffer_read() >> 1;
587 /* 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 */
588 buffer
[cur_byte
] = ( buffer
[cur_byte
] | ( ( (buffer_read()) << 1 ) & 0x80 )) >> (8 - bits_left
);
592 static void ft2232_debug_dump_buffer(void)
598 for (i
= 0; i
< ft2232_buffer_size
; i
++)
600 line_p
+= snprintf(line_p
, 256 - (line_p
- line
), "%2.2x ", ft2232_buffer
[i
]);
603 LOG_DEBUG("%s", line
);
609 LOG_DEBUG("%s", line
);
613 static int ft2232_send_and_recv(jtag_command_t
* first
, jtag_command_t
* last
)
623 #ifdef _DEBUG_USB_IO_
624 struct timeval start
, inter
, inter2
, end
;
625 struct timeval d_inter
, d_inter2
, d_end
;
628 #ifdef _DEBUG_USB_COMMS_
629 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size
);
630 ft2232_debug_dump_buffer();
633 #ifdef _DEBUG_USB_IO_
634 gettimeofday(&start
, NULL
);
637 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
639 LOG_ERROR("couldn't write MPSSE commands to FT2232");
643 #ifdef _DEBUG_USB_IO_
644 gettimeofday(&inter
, NULL
);
647 if (ft2232_expect_read
)
650 ft2232_buffer_size
= 0;
652 #ifdef _DEBUG_USB_IO_
653 gettimeofday(&inter2
, NULL
);
656 if ( ( retval
= ft2232_read(ft2232_buffer
, ft2232_expect_read
, &bytes_read
) ) != ERROR_OK
)
658 LOG_ERROR("couldn't read from FT2232");
662 #ifdef _DEBUG_USB_IO_
663 gettimeofday(&end
, NULL
);
665 timeval_subtract(&d_inter
, &inter
, &start
);
666 timeval_subtract(&d_inter2
, &inter2
, &start
);
667 timeval_subtract(&d_end
, &end
, &start
);
669 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
670 (unsigned)d_inter
.tv_sec
, (unsigned)d_inter
.tv_usec
,
671 (unsigned)d_inter2
.tv_sec
, (unsigned)d_inter2
.tv_usec
,
672 (unsigned)d_end
.tv_sec
, (unsigned)d_end
.tv_usec
);
675 ft2232_buffer_size
= bytes_read
;
677 if (ft2232_expect_read
!= ft2232_buffer_size
)
679 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read
,
682 ft2232_debug_dump_buffer();
687 #ifdef _DEBUG_USB_COMMS_
688 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout
, ft2232_buffer_size
);
689 ft2232_debug_dump_buffer();
693 ft2232_expect_read
= 0;
694 ft2232_read_pointer
= 0;
696 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
697 * that wasn't handled by a caller-provided error handler
707 type
= jtag_scan_type(cmd
->cmd
.scan
);
708 if (type
!= SCAN_OUT
)
710 scan_size
= jtag_scan_size(cmd
->cmd
.scan
);
711 buffer
= calloc(CEIL(scan_size
, 8), 1);
712 ft2232_read_scan(type
, buffer
, scan_size
);
713 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
714 retval
= ERROR_JTAG_QUEUE_FAILED
;
726 ft2232_buffer_size
= 0;
733 * Function ft2232_add_pathmove
734 * moves the TAP controller from the current state to a new state through the
735 * given path, where path is an array of tap_state_t's.
737 * @param path is an array of tap_stat_t which gives the states to traverse through
738 * ending with the last state at path[num_states-1]
739 * @param num_states is the count of state steps to move through
741 static void ft2232_add_pathmove( tap_state_t
* path
, int num_states
)
745 tap_state_t walker
= tap_get_state();
747 assert( (unsigned) num_states
<= 32u ); /* tms_bits only holds 32 bits */
749 /* this loop verifies that the path is legal and logs each state in the path */
750 for( state_ndx
= 0; state_ndx
< num_states
; ++state_ndx
)
752 tap_state_t desired_next_state
= path
[state_ndx
];
754 if (tap_state_transition(walker
, false) == desired_next_state
)
755 ; /* bit within tms_bits at index state_ndx is already zero */
756 else if (tap_state_transition(walker
, true) == desired_next_state
)
757 tms_bits
|= (1<<state_ndx
);
760 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition",
761 tap_state_name(walker
), tap_state_name(desired_next_state
) );
765 walker
= desired_next_state
;
768 clock_tms( 0x4b, tms_bits
, num_states
, 0 );
770 tap_set_end_state(tap_get_state());
774 void ft2232_add_scan(bool ir_scan
, enum scan_type type
, u8
* buffer
, int scan_size
)
776 int num_bytes
= (scan_size
+ 7) / 8;
777 int bits_left
= scan_size
;
783 if (tap_get_state() != TAP_DRSHIFT
)
785 move_to_state( TAP_DRSHIFT
);
790 if (tap_get_state() != TAP_IRSHIFT
)
792 move_to_state( TAP_IRSHIFT
);
796 /* add command for complete bytes */
797 while (num_bytes
> 1)
802 /* Clock Data Bytes In and Out LSB First */
803 buffer_write( 0x39 );
804 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
806 else if (type
== SCAN_OUT
)
808 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
809 buffer_write( 0x19 );
810 /* LOG_DEBUG("added TDI bytes (o)"); */
812 else if (type
== SCAN_IN
)
814 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
815 buffer_write( 0x28 );
816 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
819 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
820 num_bytes
-= thisrun_bytes
;
822 buffer_write( (u8
) (thisrun_bytes
- 1) );
823 buffer_write( (u8
) ((thisrun_bytes
- 1) >> 8) );
827 /* add complete bytes */
828 while (thisrun_bytes
-- > 0)
830 buffer_write( buffer
[cur_byte
++] );
834 else /* (type == SCAN_IN) */
836 bits_left
-= 8 * (thisrun_bytes
);
840 /* the most signifcant bit is scanned during TAP movement */
842 last_bit
= ( buffer
[cur_byte
] >> (bits_left
- 1) ) & 0x1;
846 /* process remaining bits but the last one */
851 /* Clock Data Bits In and Out LSB First */
852 buffer_write( 0x3b );
853 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
855 else if (type
== SCAN_OUT
)
857 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
858 buffer_write( 0x1b );
859 /* LOG_DEBUG("added TDI bits (o)"); */
861 else if (type
== SCAN_IN
)
863 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
864 buffer_write( 0x2a );
865 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
868 buffer_write( bits_left
- 2 );
870 buffer_write( buffer
[cur_byte
] );
873 if ( ( ir_scan
&& (tap_get_end_state() == TAP_IRSHIFT
) )
874 || ( !ir_scan
&& (tap_get_end_state() == TAP_DRSHIFT
) ) )
878 /* Clock Data Bits In and Out LSB First */
879 buffer_write( 0x3b );
880 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
882 else if (type
== SCAN_OUT
)
884 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
885 buffer_write( 0x1b );
886 /* LOG_DEBUG("added TDI bits (o)"); */
888 else if (type
== SCAN_IN
)
890 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
891 buffer_write( 0x2a );
892 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
895 buffer_write( last_bit
);
903 /* move from Shift-IR/DR to end state */
904 if (type
!= SCAN_OUT
)
906 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
907 /* This must be coordinated with the bit shifts in ft2232_read_scan */
910 /* Clock Data to TMS/CS Pin with Read */
912 /* LOG_DEBUG("added TMS scan (read)"); */
916 tms_bits
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
917 tms_count
= tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
918 /* Clock Data to TMS/CS Pin (no Read) */
920 /* LOG_DEBUG("added TMS scan (no read)"); */
923 clock_tms( mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
926 if (tap_get_state() != tap_get_end_state())
928 move_to_state( tap_get_end_state() );
933 static int ft2232_large_scan(scan_command_t
* cmd
, enum scan_type type
, u8
* buffer
, int scan_size
)
935 int num_bytes
= (scan_size
+ 7) / 8;
936 int bits_left
= scan_size
;
939 u8
* receive_buffer
= malloc( CEIL(scan_size
, 8) );
940 u8
* receive_pointer
= receive_buffer
;
944 int thisrun_read
= 0;
948 LOG_ERROR("BUG: large IR scans are not supported");
952 if (tap_get_state() != TAP_DRSHIFT
)
954 move_to_state( TAP_DRSHIFT
);
957 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
959 LOG_ERROR("couldn't write MPSSE commands to FT2232");
962 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
963 ft2232_buffer_size
= 0;
965 /* add command for complete bytes */
966 while (num_bytes
> 1)
972 /* Clock Data Bytes In and Out LSB First */
973 buffer_write( 0x39 );
974 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
976 else if (type
== SCAN_OUT
)
978 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
979 buffer_write( 0x19 );
980 /* LOG_DEBUG("added TDI bytes (o)"); */
982 else if (type
== SCAN_IN
)
984 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
985 buffer_write( 0x28 );
986 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
989 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
990 thisrun_read
= thisrun_bytes
;
991 num_bytes
-= thisrun_bytes
;
992 buffer_write( (u8
) (thisrun_bytes
- 1) );
993 buffer_write( (u8
) ( (thisrun_bytes
- 1) >> 8 ));
997 /* add complete bytes */
998 while (thisrun_bytes
-- > 0)
1000 buffer_write( buffer
[cur_byte
] );
1005 else /* (type == SCAN_IN) */
1007 bits_left
-= 8 * (thisrun_bytes
);
1010 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
1012 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1015 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
1016 ft2232_buffer_size
= 0;
1018 if (type
!= SCAN_OUT
)
1020 if ( ( retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
) ) != ERROR_OK
)
1022 LOG_ERROR("couldn't read from FT2232");
1025 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read
, bytes_read
);
1026 receive_pointer
+= bytes_read
;
1032 /* the most signifcant bit is scanned during TAP movement */
1033 if (type
!= SCAN_IN
)
1034 last_bit
= ( buffer
[cur_byte
] >> (bits_left
- 1) ) & 0x1;
1038 /* process remaining bits but the last one */
1041 if (type
== SCAN_IO
)
1043 /* Clock Data Bits In and Out LSB First */
1044 buffer_write( 0x3b );
1045 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1047 else if (type
== SCAN_OUT
)
1049 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1050 buffer_write( 0x1b );
1051 /* LOG_DEBUG("added TDI bits (o)"); */
1053 else if (type
== SCAN_IN
)
1055 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1056 buffer_write( 0x2a );
1057 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1059 buffer_write( bits_left
- 2 );
1060 if (type
!= SCAN_IN
)
1061 buffer_write( buffer
[cur_byte
] );
1063 if (type
!= SCAN_OUT
)
1067 if (tap_get_end_state() == TAP_DRSHIFT
)
1069 if (type
== SCAN_IO
)
1071 /* Clock Data Bits In and Out LSB First */
1072 buffer_write( 0x3b );
1073 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1075 else if (type
== SCAN_OUT
)
1077 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1078 buffer_write( 0x1b );
1079 /* LOG_DEBUG("added TDI bits (o)"); */
1081 else if (type
== SCAN_IN
)
1083 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1084 buffer_write( 0x2a );
1085 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1087 buffer_write( 0x0 );
1088 buffer_write( last_bit
);
1092 int tms_bits
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1093 int tms_count
= tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
1096 /* move from Shift-IR/DR to end state */
1097 if (type
!= SCAN_OUT
)
1099 /* Clock Data to TMS/CS Pin with Read */
1101 /* LOG_DEBUG("added TMS scan (read)"); */
1105 /* Clock Data to TMS/CS Pin (no Read) */
1107 /* LOG_DEBUG("added TMS scan (no read)"); */
1110 clock_tms( mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
1113 if (type
!= SCAN_OUT
)
1116 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
1118 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1121 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
1122 ft2232_buffer_size
= 0;
1124 if (type
!= SCAN_OUT
)
1126 if ( ( retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
) ) != ERROR_OK
)
1128 LOG_ERROR("couldn't read from FT2232");
1131 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read
, bytes_read
);
1132 receive_pointer
+= bytes_read
;
1139 static int ft2232_predict_scan_out(int scan_size
, enum scan_type type
)
1141 int predicted_size
= 3;
1142 int num_bytes
= (scan_size
- 1) / 8;
1144 if (tap_get_state() != TAP_DRSHIFT
)
1145 predicted_size
+= get_tms_buffer_requirements( tap_get_tms_path_len( tap_get_state(), TAP_DRSHIFT
) );
1147 if (type
== SCAN_IN
) /* only from device to host */
1149 /* complete bytes */
1150 predicted_size
+= CEIL(num_bytes
, 65536) * 3;
1152 /* remaining bits - 1 (up to 7) */
1153 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 2 : 0;
1155 else /* host to device, or bidirectional */
1157 /* complete bytes */
1158 predicted_size
+= num_bytes
+ CEIL(num_bytes
, 65536) * 3;
1160 /* remaining bits -1 (up to 7) */
1161 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 3 : 0;
1164 return predicted_size
;
1168 static int ft2232_predict_scan_in(int scan_size
, enum scan_type type
)
1170 int predicted_size
= 0;
1172 if (type
!= SCAN_OUT
)
1174 /* complete bytes */
1175 predicted_size
+= (CEIL(scan_size
, 8) > 1) ? (CEIL(scan_size
, 8) - 1) : 0;
1177 /* remaining bits - 1 */
1178 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 1 : 0;
1180 /* last bit (from TMS scan) */
1181 predicted_size
+= 1;
1184 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1186 return predicted_size
;
1190 static void usbjtag_reset(int trst
, int srst
)
1194 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1195 low_direction
|= nTRSTnOE
; /* switch to output pin (output is low) */
1197 low_output
&= ~nTRST
; /* switch output low */
1201 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1202 low_direction
&= ~nTRSTnOE
; /* switch to input pin (high-Z + internal and external pullup) */
1204 low_output
|= nTRST
; /* switch output high */
1209 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1210 low_output
&= ~nSRST
; /* switch output low */
1212 low_direction
|= nSRSTnOE
; /* switch to output pin (output is low) */
1216 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1217 low_output
|= nSRST
; /* switch output high */
1219 low_direction
&= ~nSRSTnOE
; /* switch to input pin (high-Z) */
1222 /* command "set data bits low byte" */
1223 buffer_write( 0x80 );
1224 buffer_write( low_output
);
1225 buffer_write( low_direction
);
1229 static void jtagkey_reset(int trst
, int srst
)
1233 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1234 high_output
&= ~nTRSTnOE
;
1236 high_output
&= ~nTRST
;
1240 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1241 high_output
|= nTRSTnOE
;
1243 high_output
|= nTRST
;
1248 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1249 high_output
&= ~nSRST
;
1251 high_output
&= ~nSRSTnOE
;
1255 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1256 high_output
|= nSRST
;
1258 high_output
|= nSRSTnOE
;
1261 /* command "set data bits high byte" */
1262 buffer_write( 0x82 );
1263 buffer_write( high_output
);
1264 buffer_write( high_direction
);
1265 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1270 static void olimex_jtag_reset(int trst
, int srst
)
1274 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1275 high_output
&= ~nTRSTnOE
;
1277 high_output
&= ~nTRST
;
1281 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1282 high_output
|= nTRSTnOE
;
1284 high_output
|= nTRST
;
1289 high_output
|= nSRST
;
1293 high_output
&= ~nSRST
;
1296 /* command "set data bits high byte" */
1297 buffer_write( 0x82 );
1298 buffer_write( high_output
);
1299 buffer_write( high_direction
);
1300 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1305 static void axm0432_jtag_reset(int trst
, int srst
)
1309 tap_set_state(TAP_RESET
);
1310 high_output
&= ~nTRST
;
1314 high_output
|= nTRST
;
1319 high_output
&= ~nSRST
;
1323 high_output
|= nSRST
;
1326 /* command "set data bits low byte" */
1327 buffer_write( 0x82 );
1328 buffer_write( high_output
);
1329 buffer_write( high_direction
);
1330 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1335 static void flyswatter_reset(int trst
, int srst
)
1339 low_output
&= ~nTRST
;
1343 low_output
|= nTRST
;
1348 low_output
|= nSRST
;
1352 low_output
&= ~nSRST
;
1355 /* command "set data bits low byte" */
1356 buffer_write( 0x80 );
1357 buffer_write( low_output
);
1358 buffer_write( low_direction
);
1359 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst
, srst
, low_output
, low_direction
);
1363 static void turtle_reset(int trst
, int srst
)
1369 low_output
|= nSRST
;
1373 low_output
&= ~nSRST
;
1376 /* command "set data bits low byte" */
1377 buffer_write( 0x80 );
1378 buffer_write( low_output
);
1379 buffer_write( low_direction
);
1380 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst
, low_output
, low_direction
);
1384 static void comstick_reset(int trst
, int srst
)
1388 high_output
&= ~nTRST
;
1392 high_output
|= nTRST
;
1397 high_output
&= ~nSRST
;
1401 high_output
|= nSRST
;
1404 /* command "set data bits high byte" */
1405 buffer_write( 0x82 );
1406 buffer_write( high_output
);
1407 buffer_write( high_direction
);
1408 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1413 static void stm32stick_reset(int trst
, int srst
)
1417 high_output
&= ~nTRST
;
1421 high_output
|= nTRST
;
1426 low_output
&= ~nSRST
;
1430 low_output
|= nSRST
;
1433 /* command "set data bits low byte" */
1434 buffer_write( 0x80 );
1435 buffer_write( low_output
);
1436 buffer_write( low_direction
);
1438 /* command "set data bits high byte" */
1439 buffer_write( 0x82 );
1440 buffer_write( high_output
);
1441 buffer_write( high_direction
);
1442 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1448 static void sheevaplug_reset(int trst
, int srst
)
1451 high_output
&= ~nTRST
;
1453 high_output
|= nTRST
;
1456 high_output
&= ~nSRSTnOE
;
1458 high_output
|= nSRSTnOE
;
1460 /* command "set data bits high byte" */
1461 buffer_write( 0x82 );
1462 buffer_write( high_output
);
1463 buffer_write( high_direction
);
1464 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
, high_direction
);
1467 static int ft2232_execute_runtest(jtag_command_t
*cmd
)
1471 int predicted_size
= 0;
1474 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1475 cmd
->cmd
.runtest
->num_cycles
,
1476 tap_state_name(cmd
->cmd
.runtest
->end_state
));
1478 /* only send the maximum buffer size that FT2232C can handle */
1480 if (tap_get_state() != TAP_IDLE
)
1481 predicted_size
+= 3;
1482 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1483 if ( cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
)
1484 predicted_size
+= 3;
1485 if ( tap_get_end_state() != TAP_IDLE
)
1486 predicted_size
+= 3;
1487 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1489 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1490 retval
= ERROR_JTAG_QUEUE_FAILED
;
1494 if (tap_get_state() != TAP_IDLE
)
1496 move_to_state( TAP_IDLE
);
1499 i
= cmd
->cmd
.runtest
->num_cycles
;
1502 /* there are no state transitions in this code, so omit state tracking */
1504 /* command "Clock Data to TMS/CS Pin (no Read)" */
1505 buffer_write( 0x4b );
1508 buffer_write( (i
> 7) ? 6 : (i
- 1) );
1511 buffer_write( 0x0 );
1512 tap_set_state(TAP_IDLE
);
1514 i
-= (i
> 7) ? 7 : i
;
1515 /* LOG_DEBUG("added TMS scan (no read)"); */
1518 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1520 if ( tap_get_state() != tap_get_end_state() )
1522 move_to_state( tap_get_end_state() );
1526 #ifdef _DEBUG_JTAG_IO_
1527 LOG_DEBUG( "runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name( tap_get_end_state() ) );
1534 static int ft2232_execute_statemove(jtag_command_t
*cmd
)
1536 int predicted_size
= 0;
1537 int retval
= ERROR_OK
;
1539 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1541 /* only send the maximum buffer size that FT2232C can handle */
1543 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1545 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1546 retval
= ERROR_JTAG_QUEUE_FAILED
;
1550 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1552 /* move to end state */
1553 if ( tap_get_state() != tap_get_end_state() )
1555 move_to_state( tap_get_end_state() );
1562 static int ft2232_execute_pathmove(jtag_command_t
*cmd
)
1564 int predicted_size
= 0;
1565 int retval
= ERROR_OK
;
1567 tap_state_t
* path
= cmd
->cmd
.pathmove
->path
;
1568 int num_states
= cmd
->cmd
.pathmove
->num_states
;
1570 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
1571 tap_state_name( tap_get_state() ),
1572 tap_state_name( path
[num_states
-1] )
1575 /* only send the maximum buffer size that FT2232C can handle */
1576 predicted_size
= 3 * CEIL(num_states
, 7);
1577 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1579 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1580 retval
= ERROR_JTAG_QUEUE_FAILED
;
1586 ft2232_add_pathmove( path
, num_states
);
1593 static int ft2232_execute_scan(jtag_command_t
*cmd
)
1596 int scan_size
; /* size of IR or DR scan */
1597 int predicted_size
= 0;
1598 int retval
= ERROR_OK
;
1600 enum scan_type type
= jtag_scan_type(cmd
->cmd
.scan
);
1602 DEBUG_JTAG_IO( "%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN", type
);
1604 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1606 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1607 if ( (predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1609 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1610 /* unsent commands before this */
1611 if (first_unsent
!= cmd
)
1612 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1613 retval
= ERROR_JTAG_QUEUE_FAILED
;
1615 /* current command */
1616 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1617 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1619 first_unsent
= cmd
->next
;
1624 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1626 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1629 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1630 retval
= ERROR_JTAG_QUEUE_FAILED
;
1634 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1635 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1636 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1637 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1641 #ifdef _DEBUG_JTAG_IO_
1642 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1643 tap_state_name( tap_get_end_state() ) );
1649 static int ft2232_execute_reset(jtag_command_t
*cmd
)
1652 int predicted_size
= 0;
1655 DEBUG_JTAG_IO("reset trst: %i srst %i",
1656 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1658 /* only send the maximum buffer size that FT2232C can handle */
1660 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1662 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1663 retval
= ERROR_JTAG_QUEUE_FAILED
;
1668 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1671 #ifdef _DEBUG_JTAG_IO_
1672 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1677 static int ft2232_execute_sleep(jtag_command_t
*cmd
)
1682 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
1684 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1685 retval
= ERROR_JTAG_QUEUE_FAILED
;
1686 first_unsent
= cmd
->next
;
1687 jtag_sleep(cmd
->cmd
.sleep
->us
);
1688 #ifdef _DEBUG_JTAG_IO_
1689 LOG_DEBUG( "sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name( tap_get_state() ) );
1695 static int ft2232_execute_stableclocks(jtag_command_t
*cmd
)
1700 /* this is only allowed while in a stable state. A check for a stable
1701 * state was done in jtag_add_clocks()
1703 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1704 retval
= ERROR_JTAG_QUEUE_FAILED
;
1705 #ifdef _DEBUG_JTAG_IO_
1706 LOG_DEBUG( "clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name( tap_get_state() ) );
1712 static int ft2232_execute_command(jtag_command_t
*cmd
)
1719 case JTAG_RESET
: retval
= ft2232_execute_reset(cmd
); break;
1720 case JTAG_RUNTEST
: retval
= ft2232_execute_runtest(cmd
); break;
1721 case JTAG_STATEMOVE
: retval
= ft2232_execute_statemove(cmd
); break;
1722 case JTAG_PATHMOVE
: retval
= ft2232_execute_pathmove(cmd
); break;
1723 case JTAG_SCAN
: retval
= ft2232_execute_scan(cmd
); break;
1724 case JTAG_SLEEP
: retval
= ft2232_execute_sleep(cmd
); break;
1725 case JTAG_STABLECLOCKS
: retval
= ft2232_execute_stableclocks(cmd
); break;
1727 LOG_ERROR("BUG: unknown JTAG command type encountered");
1733 static int ft2232_execute_queue()
1735 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1738 first_unsent
= cmd
; /* next command that has to be sent */
1741 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1742 * that wasn't handled by a caller-provided error handler
1746 ft2232_buffer_size
= 0;
1747 ft2232_expect_read
= 0;
1749 /* blink, if the current layout has that feature */
1755 if (ft2232_execute_command(cmd
) != ERROR_OK
)
1756 retval
= ERROR_JTAG_QUEUE_FAILED
;
1757 /* Start reading input before FT2232 TX buffer fills up */
1759 if (ft2232_expect_read
> 256)
1761 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1762 retval
= ERROR_JTAG_QUEUE_FAILED
;
1767 if (require_send
> 0)
1768 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1769 retval
= ERROR_JTAG_QUEUE_FAILED
;
1775 #if BUILD_FT2232_FTD2XX == 1
1776 static int ft2232_init_ftd2xx(u16 vid
, u16 pid
, int more
, int* try_more
)
1780 char SerialNumber
[16];
1781 char Description
[64];
1782 DWORD openex_flags
= 0;
1783 char* openex_string
= NULL
;
1786 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1789 /* Add non-standard Vid/Pid to the linux driver */
1790 if ( ( status
= FT_SetVIDPID(vid
, pid
) ) != FT_OK
)
1792 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1796 if (ft2232_device_desc
&& ft2232_serial
)
1798 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1799 ft2232_device_desc
= NULL
;
1802 if (ft2232_device_desc
)
1804 openex_string
= ft2232_device_desc
;
1805 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1807 else if (ft2232_serial
)
1809 openex_string
= ft2232_serial
;
1810 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1814 LOG_ERROR("neither device description nor serial number specified");
1815 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1817 return ERROR_JTAG_INIT_FAILED
;
1820 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1821 if( status
!= FT_OK
){
1822 // under Win32, the FTD2XX driver appends an "A" to the end
1823 // of the description, if we tried by the desc, then
1824 // try by the alternate "A" description.
1825 if( openex_string
== ft2232_device_desc
){
1826 // Try the alternate method.
1827 openex_string
= ft2232_device_desc_A
;
1828 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1829 if( status
== FT_OK
){
1830 // yea, the "alternate" method worked!
1832 // drat, give the user a meaningfull message.
1833 // telling the use we tried *BOTH* methods.
1834 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1836 ft2232_device_desc_A
);
1841 if ( status
!= FT_OK
)
1847 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1849 return ERROR_JTAG_INIT_FAILED
;
1851 LOG_ERROR("unable to open ftdi device: %lu", status
);
1852 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1853 if (status
== FT_OK
)
1855 char** desc_array
= malloc( sizeof(char*) * (num_devices
+ 1) );
1858 for (i
= 0; i
< num_devices
; i
++)
1859 desc_array
[i
] = malloc(64);
1861 desc_array
[num_devices
] = NULL
;
1863 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1865 if (status
== FT_OK
)
1867 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1868 for (i
= 0; i
< num_devices
; i
++)
1869 LOG_ERROR("%i: \"%s\"", i
, desc_array
[i
]);
1872 for (i
= 0; i
< num_devices
; i
++)
1873 free(desc_array
[i
]);
1879 LOG_ERROR("ListDevices: NONE\n");
1881 return ERROR_JTAG_INIT_FAILED
;
1884 if ( ( status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
) ) != FT_OK
)
1886 LOG_ERROR("unable to set latency timer: %lu", status
);
1887 return ERROR_JTAG_INIT_FAILED
;
1890 if ( ( status
= FT_GetLatencyTimer(ftdih
, &latency_timer
) ) != FT_OK
)
1892 LOG_ERROR("unable to get latency timer: %lu", status
);
1893 return ERROR_JTAG_INIT_FAILED
;
1897 LOG_DEBUG("current latency timer: %i", latency_timer
);
1900 if ( ( status
= FT_SetTimeouts(ftdih
, 5000, 5000) ) != FT_OK
)
1902 LOG_ERROR("unable to set timeouts: %lu", status
);
1903 return ERROR_JTAG_INIT_FAILED
;
1906 if ( ( status
= FT_SetBitMode(ftdih
, 0x0b, 2) ) != FT_OK
)
1908 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1909 return ERROR_JTAG_INIT_FAILED
;
1912 if ( ( status
= FT_GetDeviceInfo(ftdih
, &ftdi_device
, &deviceID
, SerialNumber
, Description
, NULL
) ) != FT_OK
)
1914 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status
);
1915 return ERROR_JTAG_INIT_FAILED
;
1919 LOG_INFO("device: %lu", ftdi_device
);
1920 LOG_INFO("deviceID: %lu", deviceID
);
1921 LOG_INFO("SerialNumber: %s", SerialNumber
);
1922 LOG_INFO("Description: %s", Description
);
1924 #ifdef BUILD_FTD2XX_HIGHSPEED
1925 if (ft2232_device_is_highspeed())
1927 ft2232_max_tck
= FTDI_2232H_4232H_MAX_TCK
;
1928 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck
);
1937 static int ft2232_purge_ftd2xx(void)
1941 if ( ( status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
) ) != FT_OK
)
1943 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1944 return ERROR_JTAG_INIT_FAILED
;
1951 #endif /* BUILD_FT2232_FTD2XX == 1 */
1953 #if BUILD_FT2232_LIBFTDI == 1
1954 static int ft2232_init_libftdi(u16 vid
, u16 pid
, int more
, int* try_more
)
1958 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1959 ft2232_layout
, vid
, pid
);
1961 if (ftdi_init(&ftdic
) < 0)
1962 return ERROR_JTAG_INIT_FAILED
;
1964 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1966 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1967 return ERROR_JTAG_INIT_FAILED
;
1970 /* context, vendor id, product id */
1971 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1975 LOG_WARNING("unable to open ftdi device (trying more): %s",
1978 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1980 return ERROR_JTAG_INIT_FAILED
;
1983 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1984 if (ftdi_usb_reset(&ftdic
) < 0)
1986 LOG_ERROR("unable to reset ftdi device");
1987 return ERROR_JTAG_INIT_FAILED
;
1990 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
1992 LOG_ERROR("unable to set latency timer");
1993 return ERROR_JTAG_INIT_FAILED
;
1996 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
1998 LOG_ERROR("unable to get latency timer");
1999 return ERROR_JTAG_INIT_FAILED
;
2003 LOG_DEBUG("current latency timer: %i", latency_timer
);
2006 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
2012 static int ft2232_purge_libftdi(void)
2014 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
2016 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
2017 return ERROR_JTAG_INIT_FAILED
;
2024 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2026 static int ft2232_init(void)
2031 ft2232_layout_t
* cur_layout
= ft2232_layouts
;
2034 if (tap_get_tms_path_len(TAP_IRPAUSE
,TAP_IRPAUSE
)==7)
2036 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2040 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2043 if ( (ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0) )
2045 ft2232_layout
= "usbjtag";
2046 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2049 while (cur_layout
->name
)
2051 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
2053 layout
= cur_layout
;
2061 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
2062 return ERROR_JTAG_INIT_FAILED
;
2068 * "more indicates that there are more IDs to try, so we should
2069 * not print an error for an ID mismatch (but for anything
2072 * try_more indicates that the error code returned indicates an
2073 * ID mismatch (and nothing else) and that we should proceeed
2074 * with the next ID pair.
2076 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
2079 #if BUILD_FT2232_FTD2XX == 1
2080 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
2082 #elif BUILD_FT2232_LIBFTDI == 1
2083 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
2088 if (!more
|| !try_more
)
2092 ft2232_buffer_size
= 0;
2093 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
2095 if (layout
->init() != ERROR_OK
)
2096 return ERROR_JTAG_INIT_FAILED
;
2098 ft2232_speed(jtag_speed
);
2100 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2101 if ( ( ( retval
= ft2232_write(buf
, 1, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 1) )
2103 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2104 return ERROR_JTAG_INIT_FAILED
;
2107 #if BUILD_FT2232_FTD2XX == 1
2108 return ft2232_purge_ftd2xx();
2109 #elif BUILD_FT2232_LIBFTDI == 1
2110 return ft2232_purge_libftdi();
2117 static int usbjtag_init(void)
2123 low_direction
= 0x0b;
2125 if (strcmp(ft2232_layout
, "usbjtag") == 0)
2132 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
2139 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
2146 low_direction
= 0x8b;
2150 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
2151 return ERROR_JTAG_INIT_FAILED
;
2154 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2156 low_direction
&= ~nTRSTnOE
; /* nTRST input */
2157 low_output
&= ~nTRST
; /* nTRST = 0 */
2161 low_direction
|= nTRSTnOE
; /* nTRST output */
2162 low_output
|= nTRST
; /* nTRST = 1 */
2165 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2167 low_direction
|= nSRSTnOE
; /* nSRST output */
2168 low_output
|= nSRST
; /* nSRST = 1 */
2172 low_direction
&= ~nSRSTnOE
; /* nSRST input */
2173 low_output
&= ~nSRST
; /* nSRST = 0 */
2176 /* initialize low byte for jtag */
2177 buf
[0] = 0x80; /* command "set data bits low byte" */
2178 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2179 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2180 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2182 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2184 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2185 return ERROR_JTAG_INIT_FAILED
;
2192 static int axm0432_jtag_init(void)
2198 low_direction
= 0x2b;
2200 /* initialize low byte for jtag */
2201 buf
[0] = 0x80; /* command "set data bits low byte" */
2202 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2203 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2204 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2206 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2208 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2209 return ERROR_JTAG_INIT_FAILED
;
2212 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
2215 nTRSTnOE
= 0x0; /* No output enable for TRST*/
2217 nSRSTnOE
= 0x0; /* No output enable for SRST*/
2221 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2226 high_direction
= 0x0c;
2228 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2230 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2234 high_output
|= nTRST
;
2237 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2239 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2243 high_output
|= nSRST
;
2246 /* initialize high port */
2247 buf
[0] = 0x82; /* command "set data bits high byte" */
2248 buf
[1] = high_output
; /* value */
2249 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2250 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2252 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2254 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2255 return ERROR_JTAG_INIT_FAILED
;
2262 static int jtagkey_init(void)
2268 low_direction
= 0x1b;
2270 /* initialize low byte for jtag */
2271 buf
[0] = 0x80; /* command "set data bits low byte" */
2272 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2273 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2274 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2276 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2278 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2279 return ERROR_JTAG_INIT_FAILED
;
2282 if (strcmp(layout
->name
, "jtagkey") == 0)
2289 else if ( (strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2290 || (strcmp(layout
->name
, "oocdlink") == 0) )
2299 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2304 high_direction
= 0x0f;
2306 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2308 high_output
|= nTRSTnOE
;
2309 high_output
&= ~nTRST
;
2313 high_output
&= ~nTRSTnOE
;
2314 high_output
|= nTRST
;
2317 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2319 high_output
&= ~nSRSTnOE
;
2320 high_output
|= nSRST
;
2324 high_output
|= nSRSTnOE
;
2325 high_output
&= ~nSRST
;
2328 /* initialize high port */
2329 buf
[0] = 0x82; /* command "set data bits high byte" */
2330 buf
[1] = high_output
; /* value */
2331 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2332 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2334 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2336 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2337 return ERROR_JTAG_INIT_FAILED
;
2344 static int olimex_jtag_init(void)
2350 low_direction
= 0x1b;
2352 /* initialize low byte for jtag */
2353 buf
[0] = 0x80; /* command "set data bits low byte" */
2354 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2355 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2356 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2358 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2360 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2361 return ERROR_JTAG_INIT_FAILED
;
2367 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2370 high_direction
= 0x0f;
2372 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2374 high_output
|= nTRSTnOE
;
2375 high_output
&= ~nTRST
;
2379 high_output
&= ~nTRSTnOE
;
2380 high_output
|= nTRST
;
2383 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2385 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2389 high_output
&= ~nSRST
;
2392 /* turn red LED on */
2393 high_output
|= 0x08;
2395 /* initialize high port */
2396 buf
[0] = 0x82; /* command "set data bits high byte" */
2397 buf
[1] = high_output
; /* value */
2398 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2399 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2401 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2403 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2404 return ERROR_JTAG_INIT_FAILED
;
2411 static int flyswatter_init(void)
2417 low_direction
= 0xfb;
2419 /* initialize low byte for jtag */
2420 buf
[0] = 0x80; /* command "set data bits low byte" */
2421 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2422 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2423 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2425 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2427 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2428 return ERROR_JTAG_INIT_FAILED
;
2432 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2434 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2437 high_direction
= 0x0c;
2439 /* turn red LED3 on, LED2 off */
2440 high_output
|= 0x08;
2442 /* initialize high port */
2443 buf
[0] = 0x82; /* command "set data bits high byte" */
2444 buf
[1] = high_output
; /* value */
2445 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2446 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2448 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2450 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2451 return ERROR_JTAG_INIT_FAILED
;
2458 static int turtle_init(void)
2464 low_direction
= 0x5b;
2466 /* initialize low byte for jtag */
2467 buf
[0] = 0x80; /* command "set data bits low byte" */
2468 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2469 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2470 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2472 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2474 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2475 return ERROR_JTAG_INIT_FAILED
;
2481 high_direction
= 0x0C;
2483 /* initialize high port */
2484 buf
[0] = 0x82; /* command "set data bits high byte" */
2485 buf
[1] = high_output
;
2486 buf
[2] = high_direction
;
2487 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2489 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2491 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2492 return ERROR_JTAG_INIT_FAILED
;
2499 static int comstick_init(void)
2505 low_direction
= 0x0b;
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 'comstick' layout");
2516 return ERROR_JTAG_INIT_FAILED
;
2520 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2522 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2525 high_direction
= 0x03;
2527 /* initialize high port */
2528 buf
[0] = 0x82; /* command "set data bits high byte" */
2529 buf
[1] = high_output
;
2530 buf
[2] = high_direction
;
2531 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2533 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2535 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2536 return ERROR_JTAG_INIT_FAILED
;
2543 static int stm32stick_init(void)
2549 low_direction
= 0x8b;
2551 /* initialize low byte for jtag */
2552 buf
[0] = 0x80; /* command "set data bits low byte" */
2553 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2554 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2555 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2557 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2559 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2560 return ERROR_JTAG_INIT_FAILED
;
2564 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2566 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2569 high_direction
= 0x03;
2571 /* initialize high port */
2572 buf
[0] = 0x82; /* command "set data bits high byte" */
2573 buf
[1] = high_output
;
2574 buf
[2] = high_direction
;
2575 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2577 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2579 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2580 return ERROR_JTAG_INIT_FAILED
;
2587 static int sheevaplug_init(void)
2593 low_direction
= 0x1b;
2595 /* initialize low byte for jtag */
2596 buf
[0] = 0x80; /* command "set data bits low byte" */
2597 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2598 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2599 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2601 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2603 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2604 return ERROR_JTAG_INIT_FAILED
;
2613 high_direction
= 0x0f;
2615 /* nTRST is always push-pull */
2616 high_output
&= ~nTRSTnOE
;
2617 high_output
|= nTRST
;
2619 /* nSRST is always open-drain */
2620 high_output
|= nSRSTnOE
;
2621 high_output
&= ~nSRST
;
2623 /* initialize high port */
2624 buf
[0] = 0x82; /* command "set data bits high byte" */
2625 buf
[1] = high_output
; /* value */
2626 buf
[2] = high_direction
; /* all outputs - xRST */
2627 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2629 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2631 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2632 return ERROR_JTAG_INIT_FAILED
;
2638 static int cortino_jtag_init(void)
2644 low_direction
= 0x1b;
2646 /* initialize low byte for jtag */
2647 buf
[0] = 0x80; /* command "set data bits low byte" */
2648 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2649 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2650 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2652 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2654 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2655 return ERROR_JTAG_INIT_FAILED
;
2659 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2661 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2664 high_direction
= 0x03;
2666 /* initialize high port */
2667 buf
[0] = 0x82; /* command "set data bits high byte" */
2668 buf
[1] = high_output
;
2669 buf
[2] = high_direction
;
2670 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2672 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2674 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2675 return ERROR_JTAG_INIT_FAILED
;
2681 static void olimex_jtag_blink(void)
2683 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2684 * ACBUS3 is bit 3 of the GPIOH port
2686 if (high_output
& 0x08)
2688 /* set port pin high */
2689 high_output
&= 0x07;
2693 /* set port pin low */
2694 high_output
|= 0x08;
2697 buffer_write( 0x82 );
2698 buffer_write( high_output
);
2699 buffer_write( high_direction
);
2703 static void flyswatter_jtag_blink(void)
2706 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2708 high_output
^= 0x0c;
2710 buffer_write( 0x82 );
2711 buffer_write( high_output
);
2712 buffer_write( high_direction
);
2716 static void turtle_jtag_blink(void)
2719 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2721 if (high_output
& 0x08)
2730 buffer_write( 0x82 );
2731 buffer_write( high_output
);
2732 buffer_write( high_direction
);
2736 static int ft2232_quit(void)
2738 #if BUILD_FT2232_FTD2XX == 1
2741 status
= FT_Close(ftdih
);
2742 #elif BUILD_FT2232_LIBFTDI == 1
2743 ftdi_usb_close(&ftdic
);
2745 ftdi_deinit(&ftdic
);
2748 free(ft2232_buffer
);
2749 ft2232_buffer
= NULL
;
2755 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2761 ft2232_device_desc
= strdup(args
[0]);
2762 cp
= strchr( ft2232_device_desc
, 0 );
2763 // under Win32, the FTD2XX driver appends an "A" to the end
2764 // of the description, this examines the given desc
2765 // and creates the 'missing' _A or non_A variable.
2766 if( (cp
[-1] == 'A') && (cp
[-2]==' ') ){
2767 // it was, so make this the "A" version.
2768 ft2232_device_desc_A
= ft2232_device_desc
;
2769 // and *CREATE* the non-A version.
2770 strcpy( buf
, ft2232_device_desc
);
2771 cp
= strchr( buf
, 0 );
2773 ft2232_device_desc
= strdup( buf
);
2775 // <space>A not defined
2777 sprintf( buf
, "%s A", ft2232_device_desc
);
2778 ft2232_device_desc_A
= strdup( buf
);
2783 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2790 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2794 ft2232_serial
= strdup(args
[0]);
2798 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2805 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2810 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2811 strcpy(ft2232_layout
, args
[0]);
2817 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2821 if (argc
> MAX_USB_IDS
* 2)
2823 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2824 "(maximum is %d pairs)", MAX_USB_IDS
);
2825 argc
= MAX_USB_IDS
* 2;
2827 if ( argc
< 2 || (argc
& 1) )
2829 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2834 for (i
= 0; i
+ 1 < argc
; i
+= 2)
2836 ft2232_vid
[i
>> 1] = strtol(args
[i
], NULL
, 0);
2837 ft2232_pid
[i
>> 1] = strtol(args
[i
+ 1], NULL
, 0);
2841 * Explicitly terminate, in case there are multiples instances of
2844 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2850 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2854 ft2232_latency
= atoi(args
[0]);
2858 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2865 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2869 /* 7 bits of either ones or zeros. */
2870 u8 tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2872 while (num_cycles
> 0)
2874 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2875 * at most 7 bits per invocation. Here we invoke it potentially
2878 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2880 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2882 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2883 retval
= ERROR_JTAG_QUEUE_FAILED
;
2888 /* there are no state transitions in this code, so omit state tracking */
2890 /* command "Clock Data to TMS/CS Pin (no Read)" */
2891 buffer_write( 0x4b );
2894 buffer_write( bitcount_per_command
- 1 );
2896 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2897 buffer_write( tms
);
2901 num_cycles
-= bitcount_per_command
;
2908 /* ---------------------------------------------------------------------
2909 * Support for IceBear JTAG adapter from Section5:
2910 * http://section5.ch/icebear
2912 * Author: Sten, debian@sansys-electronic.com
2915 /* Icebear pin layout
2917 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2918 * GND GND | 4 3| n.c.
2919 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2920 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2921 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2922 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2923 * ADBUS2 TDO |14 13| GND GND
2925 * ADBUS0 O L TCK ACBUS0 GND
2926 * ADBUS1 O L TDI ACBUS1 GND
2927 * ADBUS2 I TDO ACBUS2 n.c.
2928 * ADBUS3 O H TMS ACBUS3 n.c.
2934 static int icebear_jtag_init(void) {
2938 low_direction
= 0x0b; /* output: TCK TDI TMS; input: TDO */
2939 low_output
= 0x08; /* high: TMS; low: TCK TDI */
2943 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0) {
2944 low_direction
&= ~nTRST
; /* nTRST high impedance */
2947 low_direction
|= nTRST
;
2948 low_output
|= nTRST
;
2951 low_direction
|= nSRST
;
2952 low_output
|= nSRST
;
2954 /* initialize low byte for jtag */
2955 buf
[0] = 0x80; /* command "set data bits low byte" */
2956 buf
[1] = low_output
;
2957 buf
[2] = low_direction
;
2958 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2960 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2961 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2962 return ERROR_JTAG_INIT_FAILED
;
2966 high_direction
= 0x00;
2969 /* initialize high port */
2970 buf
[0] = 0x82; /* command "set data bits high byte" */
2971 buf
[1] = high_output
; /* value */
2972 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2973 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2975 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2976 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2977 return ERROR_JTAG_INIT_FAILED
;
2983 static void icebear_jtag_reset(int trst
, int srst
) {
2986 low_direction
|= nTRST
;
2987 low_output
&= ~nTRST
;
2989 else if (trst
== 0) {
2990 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0)
2991 low_direction
&= ~nTRST
;
2993 low_output
|= nTRST
;
2997 low_output
&= ~nSRST
;
2999 else if (srst
== 0) {
3000 low_output
|= nSRST
;
3003 /* command "set data bits low byte" */
3004 buffer_write( 0x80 );
3005 buffer_write( low_output
);
3006 buffer_write( low_direction
);
3008 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)