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
);
96 static char * ft2232_device_desc_A
= NULL
;
97 static char* ft2232_device_desc
= NULL
;
98 static char* ft2232_serial
= NULL
;
99 static char* ft2232_layout
= NULL
;
100 static u8 ft2232_latency
= 2;
101 static unsigned ft2232_max_tck
= 6000;
104 #define MAX_USB_IDS 8
105 /* vid = pid = 0 marks the end of the list */
106 static u16 ft2232_vid
[MAX_USB_IDS
+ 1] = { 0x0403, 0 };
107 static u16 ft2232_pid
[MAX_USB_IDS
+ 1] = { 0x6010, 0 };
109 typedef struct ft2232_layout_s
113 void (*reset
)(int trst
, int srst
);
117 /* init procedures for supported layouts */
118 static int usbjtag_init(void);
119 static int jtagkey_init(void);
120 static int olimex_jtag_init(void);
121 static int flyswatter_init(void);
122 static int turtle_init(void);
123 static int comstick_init(void);
124 static int stm32stick_init(void);
125 static int axm0432_jtag_init(void);
126 static int sheevaplug_init(void);
127 static int icebear_jtag_init(void);
128 static int cortino_jtag_init(void);
130 /* reset procedures for supported layouts */
131 static void usbjtag_reset(int trst
, int srst
);
132 static void jtagkey_reset(int trst
, int srst
);
133 static void olimex_jtag_reset(int trst
, int srst
);
134 static void flyswatter_reset(int trst
, int srst
);
135 static void turtle_reset(int trst
, int srst
);
136 static void comstick_reset(int trst
, int srst
);
137 static void stm32stick_reset(int trst
, int srst
);
138 static void axm0432_jtag_reset(int trst
, int srst
);
139 static void sheevaplug_reset(int trst
, int srst
);
140 static void icebear_jtag_reset(int trst
, int srst
);
142 /* blink procedures for layouts that support a blinking led */
143 static void olimex_jtag_blink(void);
144 static void flyswatter_jtag_blink(void);
145 static void turtle_jtag_blink(void);
147 ft2232_layout_t ft2232_layouts
[] =
149 { "usbjtag", usbjtag_init
, usbjtag_reset
, NULL
},
150 { "jtagkey", jtagkey_init
, jtagkey_reset
, NULL
},
151 { "jtagkey_prototype_v1", jtagkey_init
, jtagkey_reset
, NULL
},
152 { "oocdlink", jtagkey_init
, jtagkey_reset
, NULL
},
153 { "signalyzer", usbjtag_init
, usbjtag_reset
, NULL
},
154 { "evb_lm3s811", usbjtag_init
, usbjtag_reset
, NULL
},
155 { "olimex-jtag", olimex_jtag_init
, olimex_jtag_reset
, olimex_jtag_blink
},
156 { "flyswatter", flyswatter_init
, flyswatter_reset
, flyswatter_jtag_blink
},
157 { "turtelizer2", turtle_init
, turtle_reset
, turtle_jtag_blink
},
158 { "comstick", comstick_init
, comstick_reset
, NULL
},
159 { "stm32stick", stm32stick_init
, stm32stick_reset
, NULL
},
160 { "axm0432_jtag", axm0432_jtag_init
, axm0432_jtag_reset
, NULL
},
161 { "sheevaplug", sheevaplug_init
, sheevaplug_reset
, NULL
},
162 { "icebear", icebear_jtag_init
, icebear_jtag_reset
, NULL
},
163 { "cortino", cortino_jtag_init
, comstick_reset
, NULL
},
164 { NULL
, NULL
, NULL
, NULL
},
167 static u8 nTRST
, nTRSTnOE
, nSRST
, nSRSTnOE
;
169 static ft2232_layout_t
* layout
;
170 static u8 low_output
= 0x0;
171 static u8 low_direction
= 0x0;
172 static u8 high_output
= 0x0;
173 static u8 high_direction
= 0x0;
175 #if BUILD_FT2232_FTD2XX == 1
176 static FT_HANDLE ftdih
= NULL
;
177 #elif BUILD_FT2232_LIBFTDI == 1
178 static struct ftdi_context ftdic
;
182 static jtag_command_t
* first_unsent
; /* next command that has to be sent */
183 static int require_send
;
186 /* http://urjtag.wiki.sourceforge.net/Cable+FT2232 says:
188 "There is a significant difference between libftdi and libftd2xx. The latter
189 one allows to schedule up to 64*64 bytes of result data while libftdi fails
190 with more than 4*64. As a consequence, the FT2232 driver is forced to
191 perform around 16x more USB transactions for long command streams with TDO
192 capture when running with libftdi."
195 #define FT2232_BUFFER_SIZE 131072
196 a comment would have been nice.
199 #define FT2232_BUFFER_SIZE 131072
201 static u8
* ft2232_buffer
= NULL
;
202 static int ft2232_buffer_size
= 0;
203 static int ft2232_read_pointer
= 0;
204 static int ft2232_expect_read
= 0;
207 * Function buffer_write
208 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
209 * @param val is the byte to send.
211 static inline void buffer_write( u8 val
)
213 assert( ft2232_buffer
);
214 assert( (unsigned) ft2232_buffer_size
< (unsigned) FT2232_BUFFER_SIZE
);
215 ft2232_buffer
[ft2232_buffer_size
++] = val
;
219 * Function buffer_read
220 * returns a byte from the byte buffer.
222 static inline u8
buffer_read(void)
224 assert( ft2232_buffer
);
225 assert( ft2232_read_pointer
< ft2232_buffer_size
);
226 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 pmsse_cmd is one of the MPSSE TMS oriented commands such as 0x4b or 0x6b. See
237 * the MPSSE spec referenced above for their functionality. The MPSSE command
238 * "Clock Data to TMS/CS Pin (no Read)" is often used for this, 0x4b.
240 * @param tms_bits holds the sequence of bits to send.
241 * @param tms_count tells how many bits in the sequence.
242 * @param tdi_bit is a single bit which is passed on to TDI before the first TCK cycle
243 * and is held static for the duration of TMS clocking. See the MPSSE spec referenced above.
245 static void clock_tms( u8 mpsse_cmd
, int tms_bits
, int tms_count
, bool tdi_bit
)
249 int tms_ndx
; /* bit index into tms_byte */
251 assert( tms_count
> 0 );
253 // LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count );
255 for (tms_byte
= tms_ndx
= i
= 0; i
< tms_count
; ++i
, tms_bits
>>=1)
257 bool bit
= tms_bits
& 1;
260 tms_byte
|= (1<<tms_ndx
);
262 /* always do state transitions in public view */
263 tap_set_state( tap_state_transition(tap_get_state(), bit
) );
265 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
270 if( tms_ndx
==7 || i
==tms_count
-1 )
272 buffer_write( mpsse_cmd
);
273 buffer_write( tms_ndx
- 1 );
275 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
276 TMS/CS and is held static for the duration of TMS/CS clocking.
278 buffer_write( tms_byte
| (tdi_bit
<< 7) );
285 * Function get_tms_buffer_requirements
286 * returns what clock_tms() will consume if called with
289 static inline int get_tms_buffer_requirements( int bit_count
)
291 return ((bit_count
+ 6)/7) * 3;
296 * Function move_to_state
297 * moves the TAP controller from the current state to a
298 * \a goal_state through a path given by tap_get_tms_path(). State transition
299 * logging is performed by delegation to clock_tms().
301 * @param goal_state is the destination state for the move.
303 static void move_to_state( tap_state_t goal_state
)
305 tap_state_t start_state
= tap_get_state();
307 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
308 lookup of the required TMS pattern to move to this state from the
312 /* do the 2 lookups */
313 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
314 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
316 DEBUG_JTAG_IO( "start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
) );
318 clock_tms( 0x4b, tms_bits
, tms_count
, 0 );
322 jtag_interface_t ft2232_interface
=
325 .execute_queue
= ft2232_execute_queue
,
326 .speed
= ft2232_speed
,
327 .speed_div
= ft2232_speed_div
,
329 .register_commands
= ft2232_register_commands
,
334 static int ft2232_write(u8
* buf
, int size
, u32
* bytes_written
)
336 #if BUILD_FT2232_FTD2XX == 1
338 DWORD dw_bytes_written
;
339 if ( ( status
= FT_Write(ftdih
, buf
, size
, &dw_bytes_written
) ) != FT_OK
)
341 *bytes_written
= dw_bytes_written
;
342 LOG_ERROR("FT_Write returned: %lu", status
);
343 return ERROR_JTAG_DEVICE_ERROR
;
347 *bytes_written
= dw_bytes_written
;
350 #elif BUILD_FT2232_LIBFTDI == 1
352 if ( ( retval
= ftdi_write_data(&ftdic
, buf
, size
) ) < 0 )
355 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic
) );
356 return ERROR_JTAG_DEVICE_ERROR
;
360 *bytes_written
= retval
;
367 static int ft2232_read(u8
* buf
, u32 size
, u32
* bytes_read
)
369 #if BUILD_FT2232_FTD2XX == 1
375 while ( (*bytes_read
< size
) && timeout
-- )
377 if ( ( status
= FT_Read(ftdih
, buf
+ *bytes_read
, size
-
378 *bytes_read
, &dw_bytes_read
) ) != FT_OK
)
381 LOG_ERROR("FT_Read returned: %lu", status
);
382 return ERROR_JTAG_DEVICE_ERROR
;
384 *bytes_read
+= dw_bytes_read
;
387 #elif BUILD_FT2232_LIBFTDI == 1
392 while ( (*bytes_read
< size
) && timeout
-- )
394 if ( ( retval
= ftdi_read_data(&ftdic
, buf
+ *bytes_read
, size
- *bytes_read
) ) < 0 )
397 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic
) );
398 return ERROR_JTAG_DEVICE_ERROR
;
400 *bytes_read
+= retval
;
405 if (*bytes_read
< size
)
407 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read
, size
);
408 return ERROR_JTAG_DEVICE_ERROR
;
415 static int ft2232_speed(int speed
)
421 buf
[0] = 0x86; /* command "set divisor" */
422 buf
[1] = speed
& 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
423 buf
[2] = (speed
>> 8) & 0xff; /* valueH */
425 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
426 if ( ( ( retval
= ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
428 LOG_ERROR("couldn't set FT2232 TCK speed");
436 static int ft2232_speed_div(int speed
, int* khz
)
438 /* Take a look in the FT2232 manual,
439 * AN2232C-01 Command Processor for
440 * MPSSE and MCU Host Bus. Chapter 3.8 */
442 *khz
= ft2232_max_tck
/ (1 + speed
);
448 static int ft2232_khz(int khz
, int* jtag_speed
)
452 LOG_DEBUG("RTCK not supported");
456 /* Take a look in the FT2232 manual,
457 * AN2232C-01 Command Processor for
458 * MPSSE and MCU Host Bus. Chapter 3.8
460 * We will calc here with a multiplier
461 * of 10 for better rounding later. */
463 /* Calc speed, (ft2232_max_tck / khz) - 1 */
464 /* Use 65000 for better rounding */
465 *jtag_speed
= ((ft2232_max_tck
*10) / khz
) - 10;
467 /* Add 0.9 for rounding */
470 /* Calc real speed */
471 *jtag_speed
= *jtag_speed
/ 10;
473 /* Check if speed is greater than 0 */
479 /* Check max value */
480 if (*jtag_speed
> 0xFFFF)
482 *jtag_speed
= 0xFFFF;
489 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
)
491 register_command(cmd_ctx
, NULL
, "ft2232_device_desc", ft2232_handle_device_desc_command
,
492 COMMAND_CONFIG
, "the USB device description of the FTDI FT2232 device");
493 register_command(cmd_ctx
, NULL
, "ft2232_serial", ft2232_handle_serial_command
,
494 COMMAND_CONFIG
, "the serial number of the FTDI FT2232 device");
495 register_command(cmd_ctx
, NULL
, "ft2232_layout", ft2232_handle_layout_command
,
496 COMMAND_CONFIG
, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
497 register_command(cmd_ctx
, NULL
, "ft2232_vid_pid", ft2232_handle_vid_pid_command
,
498 COMMAND_CONFIG
, "the vendor ID and product ID of the FTDI FT2232 device");
499 register_command(cmd_ctx
, NULL
, "ft2232_latency", ft2232_handle_latency_command
,
500 COMMAND_CONFIG
, "set the FT2232 latency timer to a new value");
505 void ft2232_end_state(tap_state_t state
)
507 if (tap_is_state_stable(state
))
508 tap_set_end_state(state
);
511 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state
));
516 static void ft2232_read_scan(enum scan_type type
, u8
* buffer
, int scan_size
)
518 int num_bytes
= (scan_size
+ 7) / 8;
519 int bits_left
= scan_size
;
522 while (num_bytes
-- > 1)
524 buffer
[cur_byte
++] = buffer_read();
528 buffer
[cur_byte
] = 0x0;
530 /* There is one more partial byte left from the clock data in/out instructions */
533 buffer
[cur_byte
] = buffer_read() >> 1;
535 /* 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 */
536 buffer
[cur_byte
] = ( buffer
[cur_byte
] | ( ( (buffer_read()) << 1 ) & 0x80 )) >> (8 - bits_left
);
540 static void ft2232_debug_dump_buffer(void)
546 for (i
= 0; i
< ft2232_buffer_size
; i
++)
548 line_p
+= snprintf(line_p
, 256 - (line_p
- line
), "%2.2x ", ft2232_buffer
[i
]);
551 LOG_DEBUG("%s", line
);
557 LOG_DEBUG("%s", line
);
561 static int ft2232_send_and_recv(jtag_command_t
* first
, jtag_command_t
* last
)
571 #ifdef _DEBUG_USB_IO_
572 struct timeval start
, inter
, inter2
, end
;
573 struct timeval d_inter
, d_inter2
, d_end
;
576 #ifdef _DEBUG_USB_COMMS_
577 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size
);
578 ft2232_debug_dump_buffer();
581 #ifdef _DEBUG_USB_IO_
582 gettimeofday(&start
, NULL
);
585 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
587 LOG_ERROR("couldn't write MPSSE commands to FT2232");
591 #ifdef _DEBUG_USB_IO_
592 gettimeofday(&inter
, NULL
);
595 if (ft2232_expect_read
)
598 ft2232_buffer_size
= 0;
600 #ifdef _DEBUG_USB_IO_
601 gettimeofday(&inter2
, NULL
);
604 if ( ( retval
= ft2232_read(ft2232_buffer
, ft2232_expect_read
, &bytes_read
) ) != ERROR_OK
)
606 LOG_ERROR("couldn't read from FT2232");
610 #ifdef _DEBUG_USB_IO_
611 gettimeofday(&end
, NULL
);
613 timeval_subtract(&d_inter
, &inter
, &start
);
614 timeval_subtract(&d_inter2
, &inter2
, &start
);
615 timeval_subtract(&d_end
, &end
, &start
);
617 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
618 (unsigned)d_inter
.tv_sec
, (unsigned)d_inter
.tv_usec
,
619 (unsigned)d_inter2
.tv_sec
, (unsigned)d_inter2
.tv_usec
,
620 (unsigned)d_end
.tv_sec
, (unsigned)d_end
.tv_usec
);
623 ft2232_buffer_size
= bytes_read
;
625 if (ft2232_expect_read
!= ft2232_buffer_size
)
627 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read
,
630 ft2232_debug_dump_buffer();
635 #ifdef _DEBUG_USB_COMMS_
636 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout
, ft2232_buffer_size
);
637 ft2232_debug_dump_buffer();
641 ft2232_expect_read
= 0;
642 ft2232_read_pointer
= 0;
644 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
645 * that wasn't handled by a caller-provided error handler
655 type
= jtag_scan_type(cmd
->cmd
.scan
);
656 if (type
!= SCAN_OUT
)
658 scan_size
= jtag_scan_size(cmd
->cmd
.scan
);
659 buffer
= calloc(CEIL(scan_size
, 8), 1);
660 ft2232_read_scan(type
, buffer
, scan_size
);
661 if (jtag_read_buffer(buffer
, cmd
->cmd
.scan
) != ERROR_OK
)
662 retval
= ERROR_JTAG_QUEUE_FAILED
;
674 ft2232_buffer_size
= 0;
681 * Function ft2232_add_pathmove
682 * moves the TAP controller from the current state to a new state through the
683 * given path, where path is an array of tap_state_t's.
685 * @param path is an array of tap_stat_t which gives the states to traverse through
686 * ending with the last state at path[num_states-1]
687 * @param num_states is the count of state steps to move through
689 static void ft2232_add_pathmove( tap_state_t
* path
, int num_states
)
693 tap_state_t walker
= tap_get_state();
695 assert( (unsigned) num_states
<= 32u ); /* tms_bits only holds 32 bits */
697 /* this loop verifies that the path is legal and logs each state in the path */
698 for( state_ndx
= 0; state_ndx
< num_states
; ++state_ndx
)
700 tap_state_t desired_next_state
= path
[state_ndx
];
702 if (tap_state_transition(walker
, false) == desired_next_state
)
703 ; /* bit within tms_bits at index state_ndx is already zero */
704 else if (tap_state_transition(walker
, true) == desired_next_state
)
705 tms_bits
|= (1<<state_ndx
);
708 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition",
709 tap_state_name(walker
), tap_state_name(desired_next_state
) );
713 walker
= desired_next_state
;
716 clock_tms( 0x4b, tms_bits
, num_states
, 0 );
718 tap_set_end_state(tap_get_state());
722 void ft2232_add_scan(bool ir_scan
, enum scan_type type
, u8
* buffer
, int scan_size
)
724 int num_bytes
= (scan_size
+ 7) / 8;
725 int bits_left
= scan_size
;
731 if (tap_get_state() != TAP_DRSHIFT
)
733 move_to_state( TAP_DRSHIFT
);
738 if (tap_get_state() != TAP_IRSHIFT
)
740 move_to_state( TAP_IRSHIFT
);
744 /* add command for complete bytes */
745 while (num_bytes
> 1)
750 /* Clock Data Bytes In and Out LSB First */
751 buffer_write( 0x39 );
752 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
754 else if (type
== SCAN_OUT
)
756 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
757 buffer_write( 0x19 );
758 /* LOG_DEBUG("added TDI bytes (o)"); */
760 else if (type
== SCAN_IN
)
762 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
763 buffer_write( 0x28 );
764 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
767 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
768 num_bytes
-= thisrun_bytes
;
770 buffer_write( (u8
) (thisrun_bytes
- 1) );
771 buffer_write( (u8
) ((thisrun_bytes
- 1) >> 8) );
775 /* add complete bytes */
776 while (thisrun_bytes
-- > 0)
778 buffer_write( buffer
[cur_byte
++] );
782 else /* (type == SCAN_IN) */
784 bits_left
-= 8 * (thisrun_bytes
);
788 /* the most signifcant bit is scanned during TAP movement */
790 last_bit
= ( buffer
[cur_byte
] >> (bits_left
- 1) ) & 0x1;
794 /* process remaining bits but the last one */
799 /* Clock Data Bits In and Out LSB First */
800 buffer_write( 0x3b );
801 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
803 else if (type
== SCAN_OUT
)
805 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
806 buffer_write( 0x1b );
807 /* LOG_DEBUG("added TDI bits (o)"); */
809 else if (type
== SCAN_IN
)
811 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
812 buffer_write( 0x2a );
813 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
816 buffer_write( bits_left
- 2 );
818 buffer_write( buffer
[cur_byte
] );
821 if ( ( ir_scan
&& (tap_get_end_state() == TAP_IRSHIFT
) )
822 || ( !ir_scan
&& (tap_get_end_state() == TAP_DRSHIFT
) ) )
826 /* Clock Data Bits In and Out LSB First */
827 buffer_write( 0x3b );
828 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
830 else if (type
== SCAN_OUT
)
832 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
833 buffer_write( 0x1b );
834 /* LOG_DEBUG("added TDI bits (o)"); */
836 else if (type
== SCAN_IN
)
838 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
839 buffer_write( 0x2a );
840 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
843 buffer_write( last_bit
);
851 /* move from Shift-IR/DR to end state */
852 if (type
!= SCAN_OUT
)
854 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
855 /* This must be coordinated with the bit shifts in ft2232_read_scan */
858 /* Clock Data to TMS/CS Pin with Read */
860 /* LOG_DEBUG("added TMS scan (read)"); */
864 tms_bits
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
865 tms_count
= tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
866 /* Clock Data to TMS/CS Pin (no Read) */
868 /* LOG_DEBUG("added TMS scan (no read)"); */
871 clock_tms( mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
874 if (tap_get_state() != tap_get_end_state())
876 move_to_state( tap_get_end_state() );
881 static int ft2232_large_scan(scan_command_t
* cmd
, enum scan_type type
, u8
* buffer
, int scan_size
)
883 int num_bytes
= (scan_size
+ 7) / 8;
884 int bits_left
= scan_size
;
887 u8
* receive_buffer
= malloc( CEIL(scan_size
, 8) );
888 u8
* receive_pointer
= receive_buffer
;
892 int thisrun_read
= 0;
896 LOG_ERROR("BUG: large IR scans are not supported");
900 if (tap_get_state() != TAP_DRSHIFT
)
902 move_to_state( TAP_DRSHIFT
);
905 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
907 LOG_ERROR("couldn't write MPSSE commands to FT2232");
910 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
911 ft2232_buffer_size
= 0;
913 /* add command for complete bytes */
914 while (num_bytes
> 1)
920 /* Clock Data Bytes In and Out LSB First */
921 buffer_write( 0x39 );
922 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
924 else if (type
== SCAN_OUT
)
926 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
927 buffer_write( 0x19 );
928 /* LOG_DEBUG("added TDI bytes (o)"); */
930 else if (type
== SCAN_IN
)
932 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
933 buffer_write( 0x28 );
934 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
937 thisrun_bytes
= (num_bytes
> 65537) ? 65536 : (num_bytes
- 1);
938 thisrun_read
= thisrun_bytes
;
939 num_bytes
-= thisrun_bytes
;
940 buffer_write( (u8
) (thisrun_bytes
- 1) );
941 buffer_write( (u8
) ( (thisrun_bytes
- 1) >> 8 ));
945 /* add complete bytes */
946 while (thisrun_bytes
-- > 0)
948 buffer_write( buffer
[cur_byte
] );
953 else /* (type == SCAN_IN) */
955 bits_left
-= 8 * (thisrun_bytes
);
958 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
960 LOG_ERROR("couldn't write MPSSE commands to FT2232");
963 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
964 ft2232_buffer_size
= 0;
966 if (type
!= SCAN_OUT
)
968 if ( ( retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
) ) != ERROR_OK
)
970 LOG_ERROR("couldn't read from FT2232");
973 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read
, bytes_read
);
974 receive_pointer
+= bytes_read
;
980 /* the most signifcant bit is scanned during TAP movement */
982 last_bit
= ( buffer
[cur_byte
] >> (bits_left
- 1) ) & 0x1;
986 /* process remaining bits but the last one */
991 /* Clock Data Bits In and Out LSB First */
992 buffer_write( 0x3b );
993 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
995 else if (type
== SCAN_OUT
)
997 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
998 buffer_write( 0x1b );
999 /* LOG_DEBUG("added TDI bits (o)"); */
1001 else if (type
== SCAN_IN
)
1003 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1004 buffer_write( 0x2a );
1005 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1007 buffer_write( bits_left
- 2 );
1008 if (type
!= SCAN_IN
)
1009 buffer_write( buffer
[cur_byte
] );
1011 if (type
!= SCAN_OUT
)
1015 if (tap_get_end_state() == TAP_DRSHIFT
)
1017 if (type
== SCAN_IO
)
1019 /* Clock Data Bits In and Out LSB First */
1020 buffer_write( 0x3b );
1021 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1023 else if (type
== SCAN_OUT
)
1025 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1026 buffer_write( 0x1b );
1027 /* LOG_DEBUG("added TDI bits (o)"); */
1029 else if (type
== SCAN_IN
)
1031 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1032 buffer_write( 0x2a );
1033 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1035 buffer_write( 0x0 );
1036 buffer_write( last_bit
);
1040 int tms_bits
= tap_get_tms_path( tap_get_state(), tap_get_end_state() );
1041 int tms_count
= tap_get_tms_path_len( tap_get_state(), tap_get_end_state() );
1044 /* move from Shift-IR/DR to end state */
1045 if (type
!= SCAN_OUT
)
1047 /* Clock Data to TMS/CS Pin with Read */
1049 /* LOG_DEBUG("added TMS scan (read)"); */
1053 /* Clock Data to TMS/CS Pin (no Read) */
1055 /* LOG_DEBUG("added TMS scan (no read)"); */
1058 clock_tms( mpsse_cmd
, tms_bits
, tms_count
, last_bit
);
1061 if (type
!= SCAN_OUT
)
1064 if ( ( retval
= ft2232_write(ft2232_buffer
, ft2232_buffer_size
, &bytes_written
) ) != ERROR_OK
)
1066 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1069 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size
, bytes_written
);
1070 ft2232_buffer_size
= 0;
1072 if (type
!= SCAN_OUT
)
1074 if ( ( retval
= ft2232_read(receive_pointer
, thisrun_read
, &bytes_read
) ) != ERROR_OK
)
1076 LOG_ERROR("couldn't read from FT2232");
1079 LOG_DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read
, bytes_read
);
1080 receive_pointer
+= bytes_read
;
1087 static int ft2232_predict_scan_out(int scan_size
, enum scan_type type
)
1089 int predicted_size
= 3;
1090 int num_bytes
= (scan_size
- 1) / 8;
1092 if (tap_get_state() != TAP_DRSHIFT
)
1093 predicted_size
+= get_tms_buffer_requirements( tap_get_tms_path_len( tap_get_state(), TAP_DRSHIFT
) );
1095 if (type
== SCAN_IN
) /* only from device to host */
1097 /* complete bytes */
1098 predicted_size
+= CEIL(num_bytes
, 65536) * 3;
1100 /* remaining bits - 1 (up to 7) */
1101 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 2 : 0;
1103 else /* host to device, or bidirectional */
1105 /* complete bytes */
1106 predicted_size
+= num_bytes
+ CEIL(num_bytes
, 65536) * 3;
1108 /* remaining bits -1 (up to 7) */
1109 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 3 : 0;
1112 return predicted_size
;
1116 static int ft2232_predict_scan_in(int scan_size
, enum scan_type type
)
1118 int predicted_size
= 0;
1120 if (type
!= SCAN_OUT
)
1122 /* complete bytes */
1123 predicted_size
+= (CEIL(scan_size
, 8) > 1) ? (CEIL(scan_size
, 8) - 1) : 0;
1125 /* remaining bits - 1 */
1126 predicted_size
+= ( (scan_size
- 1) % 8 ) ? 1 : 0;
1128 /* last bit (from TMS scan) */
1129 predicted_size
+= 1;
1132 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1134 return predicted_size
;
1138 static void usbjtag_reset(int trst
, int srst
)
1142 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1143 low_direction
|= nTRSTnOE
; /* switch to output pin (output is low) */
1145 low_output
&= ~nTRST
; /* switch output low */
1149 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1150 low_direction
&= ~nTRSTnOE
; /* switch to input pin (high-Z + internal and external pullup) */
1152 low_output
|= nTRST
; /* switch output high */
1157 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1158 low_output
&= ~nSRST
; /* switch output low */
1160 low_direction
|= nSRSTnOE
; /* switch to output pin (output is low) */
1164 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1165 low_output
|= nSRST
; /* switch output high */
1167 low_direction
&= ~nSRSTnOE
; /* switch to input pin (high-Z) */
1170 /* command "set data bits low byte" */
1171 buffer_write( 0x80 );
1172 buffer_write( low_output
);
1173 buffer_write( low_direction
);
1177 static void jtagkey_reset(int trst
, int srst
)
1181 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1182 high_output
&= ~nTRSTnOE
;
1184 high_output
&= ~nTRST
;
1188 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1189 high_output
|= nTRSTnOE
;
1191 high_output
|= nTRST
;
1196 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1197 high_output
&= ~nSRST
;
1199 high_output
&= ~nSRSTnOE
;
1203 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
1204 high_output
|= nSRST
;
1206 high_output
|= nSRSTnOE
;
1209 /* command "set data bits high byte" */
1210 buffer_write( 0x82 );
1211 buffer_write( high_output
);
1212 buffer_write( high_direction
);
1213 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1218 static void olimex_jtag_reset(int trst
, int srst
)
1222 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1223 high_output
&= ~nTRSTnOE
;
1225 high_output
&= ~nTRST
;
1229 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
1230 high_output
|= nTRSTnOE
;
1232 high_output
|= nTRST
;
1237 high_output
|= nSRST
;
1241 high_output
&= ~nSRST
;
1244 /* command "set data bits high byte" */
1245 buffer_write( 0x82 );
1246 buffer_write( high_output
);
1247 buffer_write( high_direction
);
1248 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1253 static void axm0432_jtag_reset(int trst
, int srst
)
1257 tap_set_state(TAP_RESET
);
1258 high_output
&= ~nTRST
;
1262 high_output
|= nTRST
;
1267 high_output
&= ~nSRST
;
1271 high_output
|= nSRST
;
1274 /* command "set data bits low byte" */
1275 buffer_write( 0x82 );
1276 buffer_write( high_output
);
1277 buffer_write( high_direction
);
1278 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1283 static void flyswatter_reset(int trst
, int srst
)
1287 low_output
&= ~nTRST
;
1291 low_output
|= nTRST
;
1296 low_output
|= nSRST
;
1300 low_output
&= ~nSRST
;
1303 /* command "set data bits low byte" */
1304 buffer_write( 0x80 );
1305 buffer_write( low_output
);
1306 buffer_write( low_direction
);
1307 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst
, srst
, low_output
, low_direction
);
1311 static void turtle_reset(int trst
, int srst
)
1317 low_output
|= nSRST
;
1321 low_output
&= ~nSRST
;
1324 /* command "set data bits low byte" */
1325 buffer_write( 0x80 );
1326 buffer_write( low_output
);
1327 buffer_write( low_direction
);
1328 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst
, low_output
, low_direction
);
1332 static void comstick_reset(int trst
, int srst
)
1336 high_output
&= ~nTRST
;
1340 high_output
|= nTRST
;
1345 high_output
&= ~nSRST
;
1349 high_output
|= nSRST
;
1352 /* command "set data bits high byte" */
1353 buffer_write( 0x82 );
1354 buffer_write( high_output
);
1355 buffer_write( high_direction
);
1356 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1361 static void stm32stick_reset(int trst
, int srst
)
1365 high_output
&= ~nTRST
;
1369 high_output
|= nTRST
;
1374 low_output
&= ~nSRST
;
1378 low_output
|= nSRST
;
1381 /* command "set data bits low byte" */
1382 buffer_write( 0x80 );
1383 buffer_write( low_output
);
1384 buffer_write( low_direction
);
1386 /* command "set data bits high byte" */
1387 buffer_write( 0x82 );
1388 buffer_write( high_output
);
1389 buffer_write( high_direction
);
1390 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
,
1396 static void sheevaplug_reset(int trst
, int srst
)
1399 high_output
&= ~nTRST
;
1401 high_output
|= nTRST
;
1404 high_output
&= ~nSRSTnOE
;
1406 high_output
|= nSRSTnOE
;
1408 /* command "set data bits high byte" */
1409 buffer_write( 0x82 );
1410 buffer_write( high_output
);
1411 buffer_write( high_direction
);
1412 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst
, srst
, high_output
, high_direction
);
1415 static int ft2232_execute_runtest(jtag_command_t
*cmd
)
1419 int predicted_size
= 0;
1422 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1423 cmd
->cmd
.runtest
->num_cycles
,
1424 tap_state_name(cmd
->cmd
.runtest
->end_state
));
1426 /* only send the maximum buffer size that FT2232C can handle */
1428 if (tap_get_state() != TAP_IDLE
)
1429 predicted_size
+= 3;
1430 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1431 if ( cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
)
1432 predicted_size
+= 3;
1433 if ( tap_get_end_state() != TAP_IDLE
)
1434 predicted_size
+= 3;
1435 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1437 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1438 retval
= ERROR_JTAG_QUEUE_FAILED
;
1442 if (tap_get_state() != TAP_IDLE
)
1444 move_to_state( TAP_IDLE
);
1447 i
= cmd
->cmd
.runtest
->num_cycles
;
1450 /* there are no state transitions in this code, so omit state tracking */
1452 /* command "Clock Data to TMS/CS Pin (no Read)" */
1453 buffer_write( 0x4b );
1456 buffer_write( (i
> 7) ? 6 : (i
- 1) );
1459 buffer_write( 0x0 );
1460 tap_set_state(TAP_IDLE
);
1462 i
-= (i
> 7) ? 7 : i
;
1463 /* LOG_DEBUG("added TMS scan (no read)"); */
1466 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1468 if ( tap_get_state() != tap_get_end_state() )
1470 move_to_state( tap_get_end_state() );
1474 #ifdef _DEBUG_JTAG_IO_
1475 LOG_DEBUG( "runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name( tap_get_end_state() ) );
1482 static int ft2232_execute_statemove(jtag_command_t
*cmd
)
1484 int predicted_size
= 0;
1485 int retval
= ERROR_OK
;
1487 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1489 /* only send the maximum buffer size that FT2232C can handle */
1491 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1493 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1494 retval
= ERROR_JTAG_QUEUE_FAILED
;
1498 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1500 /* move to end state */
1501 if ( tap_get_state() != tap_get_end_state() )
1503 move_to_state( tap_get_end_state() );
1510 static int ft2232_execute_pathmove(jtag_command_t
*cmd
)
1512 int predicted_size
= 0;
1513 int retval
= ERROR_OK
;
1515 tap_state_t
* path
= cmd
->cmd
.pathmove
->path
;
1516 int num_states
= cmd
->cmd
.pathmove
->num_states
;
1518 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
1519 tap_state_name( tap_get_state() ),
1520 tap_state_name( path
[num_states
-1] )
1523 /* only send the maximum buffer size that FT2232C can handle */
1524 predicted_size
= 3 * CEIL(num_states
, 7);
1525 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1527 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1528 retval
= ERROR_JTAG_QUEUE_FAILED
;
1534 ft2232_add_pathmove( path
, num_states
);
1541 static int ft2232_execute_scan(jtag_command_t
*cmd
)
1544 int scan_size
; /* size of IR or DR scan */
1545 int predicted_size
= 0;
1546 int retval
= ERROR_OK
;
1548 enum scan_type type
= jtag_scan_type(cmd
->cmd
.scan
);
1550 DEBUG_JTAG_IO( "%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN", type
);
1552 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1554 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1555 if ( (predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1557 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1558 /* unsent commands before this */
1559 if (first_unsent
!= cmd
)
1560 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1561 retval
= ERROR_JTAG_QUEUE_FAILED
;
1563 /* current command */
1564 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1565 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1567 first_unsent
= cmd
->next
;
1572 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1574 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1577 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1578 retval
= ERROR_JTAG_QUEUE_FAILED
;
1582 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1583 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1584 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1585 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1589 #ifdef _DEBUG_JTAG_IO_
1590 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1591 tap_state_name( tap_get_end_state() ) );
1597 static int ft2232_execute_reset(jtag_command_t
*cmd
)
1600 int predicted_size
= 0;
1603 DEBUG_JTAG_IO("reset trst: %i srst %i",
1604 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1606 /* only send the maximum buffer size that FT2232C can handle */
1608 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1610 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1611 retval
= ERROR_JTAG_QUEUE_FAILED
;
1616 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1619 #ifdef _DEBUG_JTAG_IO_
1620 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1625 static int ft2232_execute_sleep(jtag_command_t
*cmd
)
1630 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
1632 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1633 retval
= ERROR_JTAG_QUEUE_FAILED
;
1634 first_unsent
= cmd
->next
;
1635 jtag_sleep(cmd
->cmd
.sleep
->us
);
1636 #ifdef _DEBUG_JTAG_IO_
1637 LOG_DEBUG( "sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name( tap_get_state() ) );
1643 static int ft2232_execute_stableclocks(jtag_command_t
*cmd
)
1648 /* this is only allowed while in a stable state. A check for a stable
1649 * state was done in jtag_add_clocks()
1651 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1652 retval
= ERROR_JTAG_QUEUE_FAILED
;
1653 #ifdef _DEBUG_JTAG_IO_
1654 LOG_DEBUG( "clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name( tap_get_state() ) );
1660 static int ft2232_execute_command(jtag_command_t
*cmd
)
1667 case JTAG_RESET
: retval
= ft2232_execute_reset(cmd
); break;
1668 case JTAG_RUNTEST
: retval
= ft2232_execute_runtest(cmd
); break;
1669 case JTAG_STATEMOVE
: retval
= ft2232_execute_statemove(cmd
); break;
1670 case JTAG_PATHMOVE
: retval
= ft2232_execute_pathmove(cmd
); break;
1671 case JTAG_SCAN
: retval
= ft2232_execute_scan(cmd
); break;
1672 case JTAG_SLEEP
: retval
= ft2232_execute_sleep(cmd
); break;
1673 case JTAG_STABLECLOCKS
: retval
= ft2232_execute_stableclocks(cmd
); break;
1675 LOG_ERROR("BUG: unknown JTAG command type encountered");
1681 static int ft2232_execute_queue()
1683 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1686 first_unsent
= cmd
; /* next command that has to be sent */
1689 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1690 * that wasn't handled by a caller-provided error handler
1694 ft2232_buffer_size
= 0;
1695 ft2232_expect_read
= 0;
1697 /* blink, if the current layout has that feature */
1703 if (ft2232_execute_command(cmd
) != ERROR_OK
)
1704 retval
= ERROR_JTAG_QUEUE_FAILED
;
1705 /* Start reading input before FT2232 TX buffer fills up */
1707 if (ft2232_expect_read
> 256)
1709 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1710 retval
= ERROR_JTAG_QUEUE_FAILED
;
1715 if (require_send
> 0)
1716 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1717 retval
= ERROR_JTAG_QUEUE_FAILED
;
1723 #if BUILD_FT2232_FTD2XX == 1
1724 static int ft2232_init_ftd2xx(u16 vid
, u16 pid
, int more
, int* try_more
)
1727 DWORD openex_flags
= 0;
1728 char* openex_string
= NULL
;
1731 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1734 /* Add non-standard Vid/Pid to the linux driver */
1735 if ( ( status
= FT_SetVIDPID(vid
, pid
) ) != FT_OK
)
1737 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1741 if (ft2232_device_desc
&& ft2232_serial
)
1743 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1744 ft2232_device_desc
= NULL
;
1747 if (ft2232_device_desc
)
1749 openex_string
= ft2232_device_desc
;
1750 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1752 else if (ft2232_serial
)
1754 openex_string
= ft2232_serial
;
1755 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1759 LOG_ERROR("neither device description nor serial number specified");
1760 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1762 return ERROR_JTAG_INIT_FAILED
;
1765 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1766 if( status
!= FT_OK
){
1767 // under Win32, the FTD2XX driver appends an "A" to the end
1768 // of the description, if we tried by the desc, then
1769 // try by the alternate "A" description.
1770 if( openex_string
== ft2232_device_desc
){
1771 // Try the alternate method.
1772 openex_string
= ft2232_device_desc_A
;
1773 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1774 if( status
== FT_OK
){
1775 // yea, the "alternate" method worked!
1777 // drat, give the user a meaningfull message.
1778 // telling the use we tried *BOTH* methods.
1779 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1781 ft2232_device_desc_A
);
1786 if ( status
!= FT_OK
)
1792 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1794 return ERROR_JTAG_INIT_FAILED
;
1796 LOG_ERROR("unable to open ftdi device: %lu", status
);
1797 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1798 if (status
== FT_OK
)
1800 char** desc_array
= malloc( sizeof(char*) * (num_devices
+ 1) );
1803 for (i
= 0; i
< num_devices
; i
++)
1804 desc_array
[i
] = malloc(64);
1806 desc_array
[num_devices
] = NULL
;
1808 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1810 if (status
== FT_OK
)
1812 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1813 for (i
= 0; i
< num_devices
; i
++)
1814 LOG_ERROR("%i: \"%s\"", i
, desc_array
[i
]);
1817 for (i
= 0; i
< num_devices
; i
++)
1818 free(desc_array
[i
]);
1824 LOG_ERROR("ListDevices: NONE\n");
1826 return ERROR_JTAG_INIT_FAILED
;
1829 if ( ( status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
) ) != FT_OK
)
1831 LOG_ERROR("unable to set latency timer: %lu", status
);
1832 return ERROR_JTAG_INIT_FAILED
;
1835 if ( ( status
= FT_GetLatencyTimer(ftdih
, &latency_timer
) ) != FT_OK
)
1837 LOG_ERROR("unable to get latency timer: %lu", status
);
1838 return ERROR_JTAG_INIT_FAILED
;
1842 LOG_DEBUG("current latency timer: %i", latency_timer
);
1845 if ( ( status
= FT_SetTimeouts(ftdih
, 5000, 5000) ) != FT_OK
)
1847 LOG_ERROR("unable to set timeouts: %lu", status
);
1848 return ERROR_JTAG_INIT_FAILED
;
1851 if ( ( status
= FT_SetBitMode(ftdih
, 0x0b, 2) ) != FT_OK
)
1853 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1854 return ERROR_JTAG_INIT_FAILED
;
1861 static int ft2232_purge_ftd2xx(void)
1865 if ( ( status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
) ) != FT_OK
)
1867 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1868 return ERROR_JTAG_INIT_FAILED
;
1875 #endif /* BUILD_FT2232_FTD2XX == 1 */
1877 #if BUILD_FT2232_LIBFTDI == 1
1878 static int ft2232_init_libftdi(u16 vid
, u16 pid
, int more
, int* try_more
)
1882 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1883 ft2232_layout
, vid
, pid
);
1885 if (ftdi_init(&ftdic
) < 0)
1886 return ERROR_JTAG_INIT_FAILED
;
1888 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1890 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1891 return ERROR_JTAG_INIT_FAILED
;
1894 /* context, vendor id, product id */
1895 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1899 LOG_WARNING("unable to open ftdi device (trying more): %s",
1902 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1904 return ERROR_JTAG_INIT_FAILED
;
1907 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1908 if (ftdi_usb_reset(&ftdic
) < 0)
1910 LOG_ERROR("unable to reset ftdi device");
1911 return ERROR_JTAG_INIT_FAILED
;
1914 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
1916 LOG_ERROR("unable to set latency timer");
1917 return ERROR_JTAG_INIT_FAILED
;
1920 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
1922 LOG_ERROR("unable to get latency timer");
1923 return ERROR_JTAG_INIT_FAILED
;
1927 LOG_DEBUG("current latency timer: %i", latency_timer
);
1930 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
1936 static int ft2232_purge_libftdi(void)
1938 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
1940 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
1941 return ERROR_JTAG_INIT_FAILED
;
1948 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1950 static int ft2232_init(void)
1955 ft2232_layout_t
* cur_layout
= ft2232_layouts
;
1958 if (tap_get_tms_path_len(TAP_IRPAUSE
,TAP_IRPAUSE
)==7)
1960 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
1964 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
1967 if ( (ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0) )
1969 ft2232_layout
= "usbjtag";
1970 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1973 while (cur_layout
->name
)
1975 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
1977 layout
= cur_layout
;
1985 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
1986 return ERROR_JTAG_INIT_FAILED
;
1992 * "more indicates that there are more IDs to try, so we should
1993 * not print an error for an ID mismatch (but for anything
1996 * try_more indicates that the error code returned indicates an
1997 * ID mismatch (and nothing else) and that we should proceeed
1998 * with the next ID pair.
2000 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
2003 #if BUILD_FT2232_FTD2XX == 1
2004 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
2006 #elif BUILD_FT2232_LIBFTDI == 1
2007 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
2012 if (!more
|| !try_more
)
2016 ft2232_buffer_size
= 0;
2017 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
2019 if (layout
->init() != ERROR_OK
)
2020 return ERROR_JTAG_INIT_FAILED
;
2022 ft2232_speed(jtag_speed
);
2024 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2025 if ( ( ( retval
= ft2232_write(buf
, 1, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 1) )
2027 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2028 return ERROR_JTAG_INIT_FAILED
;
2031 #if BUILD_FT2232_FTD2XX == 1
2032 return ft2232_purge_ftd2xx();
2033 #elif BUILD_FT2232_LIBFTDI == 1
2034 return ft2232_purge_libftdi();
2041 static int usbjtag_init(void)
2047 low_direction
= 0x0b;
2049 if (strcmp(ft2232_layout
, "usbjtag") == 0)
2056 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
2063 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
2070 low_direction
= 0x8b;
2074 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
2075 return ERROR_JTAG_INIT_FAILED
;
2078 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2080 low_direction
&= ~nTRSTnOE
; /* nTRST input */
2081 low_output
&= ~nTRST
; /* nTRST = 0 */
2085 low_direction
|= nTRSTnOE
; /* nTRST output */
2086 low_output
|= nTRST
; /* nTRST = 1 */
2089 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2091 low_direction
|= nSRSTnOE
; /* nSRST output */
2092 low_output
|= nSRST
; /* nSRST = 1 */
2096 low_direction
&= ~nSRSTnOE
; /* nSRST input */
2097 low_output
&= ~nSRST
; /* nSRST = 0 */
2100 /* initialize low byte for jtag */
2101 buf
[0] = 0x80; /* command "set data bits low byte" */
2102 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2103 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2104 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2106 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2108 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2109 return ERROR_JTAG_INIT_FAILED
;
2116 static int axm0432_jtag_init(void)
2122 low_direction
= 0x2b;
2124 /* initialize low byte for jtag */
2125 buf
[0] = 0x80; /* command "set data bits low byte" */
2126 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2127 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2128 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2130 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2132 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2133 return ERROR_JTAG_INIT_FAILED
;
2136 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
2139 nTRSTnOE
= 0x0; /* No output enable for TRST*/
2141 nSRSTnOE
= 0x0; /* No output enable for SRST*/
2145 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2150 high_direction
= 0x0c;
2152 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2154 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2158 high_output
|= nTRST
;
2161 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2163 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2167 high_output
|= nSRST
;
2170 /* initialize high port */
2171 buf
[0] = 0x82; /* command "set data bits high byte" */
2172 buf
[1] = high_output
; /* value */
2173 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2174 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2176 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2178 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2179 return ERROR_JTAG_INIT_FAILED
;
2186 static int jtagkey_init(void)
2192 low_direction
= 0x1b;
2194 /* initialize low byte for jtag */
2195 buf
[0] = 0x80; /* command "set data bits low byte" */
2196 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2197 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2198 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2200 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2202 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2203 return ERROR_JTAG_INIT_FAILED
;
2206 if (strcmp(layout
->name
, "jtagkey") == 0)
2213 else if ( (strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2214 || (strcmp(layout
->name
, "oocdlink") == 0) )
2223 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2228 high_direction
= 0x0f;
2230 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2232 high_output
|= nTRSTnOE
;
2233 high_output
&= ~nTRST
;
2237 high_output
&= ~nTRSTnOE
;
2238 high_output
|= nTRST
;
2241 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2243 high_output
&= ~nSRSTnOE
;
2244 high_output
|= nSRST
;
2248 high_output
|= nSRSTnOE
;
2249 high_output
&= ~nSRST
;
2252 /* initialize high port */
2253 buf
[0] = 0x82; /* command "set data bits high byte" */
2254 buf
[1] = high_output
; /* value */
2255 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2256 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2258 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2260 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2261 return ERROR_JTAG_INIT_FAILED
;
2268 static int olimex_jtag_init(void)
2274 low_direction
= 0x1b;
2276 /* initialize low byte for jtag */
2277 buf
[0] = 0x80; /* command "set data bits low byte" */
2278 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2279 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2280 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2282 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2284 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2285 return ERROR_JTAG_INIT_FAILED
;
2291 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2294 high_direction
= 0x0f;
2296 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2298 high_output
|= nTRSTnOE
;
2299 high_output
&= ~nTRST
;
2303 high_output
&= ~nTRSTnOE
;
2304 high_output
|= nTRST
;
2307 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2309 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2313 high_output
&= ~nSRST
;
2316 /* turn red LED on */
2317 high_output
|= 0x08;
2319 /* initialize high port */
2320 buf
[0] = 0x82; /* command "set data bits high byte" */
2321 buf
[1] = high_output
; /* value */
2322 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2323 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2325 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2327 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2328 return ERROR_JTAG_INIT_FAILED
;
2335 static int flyswatter_init(void)
2341 low_direction
= 0xfb;
2343 /* initialize low byte for jtag */
2344 buf
[0] = 0x80; /* command "set data bits low byte" */
2345 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2346 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2347 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2349 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2351 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2352 return ERROR_JTAG_INIT_FAILED
;
2356 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2358 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2361 high_direction
= 0x0c;
2363 /* turn red LED3 on, LED2 off */
2364 high_output
|= 0x08;
2366 /* initialize high port */
2367 buf
[0] = 0x82; /* command "set data bits high byte" */
2368 buf
[1] = high_output
; /* value */
2369 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2370 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2372 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2374 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2375 return ERROR_JTAG_INIT_FAILED
;
2382 static int turtle_init(void)
2388 low_direction
= 0x5b;
2390 /* initialize low byte for jtag */
2391 buf
[0] = 0x80; /* command "set data bits low byte" */
2392 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2393 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2394 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2396 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2398 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2399 return ERROR_JTAG_INIT_FAILED
;
2405 high_direction
= 0x0C;
2407 /* initialize high port */
2408 buf
[0] = 0x82; /* command "set data bits high byte" */
2409 buf
[1] = high_output
;
2410 buf
[2] = high_direction
;
2411 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2413 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2415 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2416 return ERROR_JTAG_INIT_FAILED
;
2423 static int comstick_init(void)
2429 low_direction
= 0x0b;
2431 /* initialize low byte for jtag */
2432 buf
[0] = 0x80; /* command "set data bits low byte" */
2433 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2434 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
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 'comstick' layout");
2440 return ERROR_JTAG_INIT_FAILED
;
2444 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2446 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2449 high_direction
= 0x03;
2451 /* initialize high port */
2452 buf
[0] = 0x82; /* command "set data bits high byte" */
2453 buf
[1] = high_output
;
2454 buf
[2] = high_direction
;
2455 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2457 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2459 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2460 return ERROR_JTAG_INIT_FAILED
;
2467 static int stm32stick_init(void)
2473 low_direction
= 0x8b;
2475 /* initialize low byte for jtag */
2476 buf
[0] = 0x80; /* command "set data bits low byte" */
2477 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2478 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2479 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2481 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2483 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2484 return ERROR_JTAG_INIT_FAILED
;
2488 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2490 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2493 high_direction
= 0x03;
2495 /* initialize high port */
2496 buf
[0] = 0x82; /* command "set data bits high byte" */
2497 buf
[1] = high_output
;
2498 buf
[2] = high_direction
;
2499 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2501 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2503 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2504 return ERROR_JTAG_INIT_FAILED
;
2511 static int sheevaplug_init(void)
2517 low_direction
= 0x1b;
2519 /* initialize low byte for jtag */
2520 buf
[0] = 0x80; /* command "set data bits low byte" */
2521 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2522 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2523 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2525 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2527 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2528 return ERROR_JTAG_INIT_FAILED
;
2537 high_direction
= 0x0f;
2539 /* nTRST is always push-pull */
2540 high_output
&= ~nTRSTnOE
;
2541 high_output
|= nTRST
;
2543 /* nSRST is always open-drain */
2544 high_output
|= nSRSTnOE
;
2545 high_output
&= ~nSRST
;
2547 /* initialize high port */
2548 buf
[0] = 0x82; /* command "set data bits high byte" */
2549 buf
[1] = high_output
; /* value */
2550 buf
[2] = high_direction
; /* all outputs - xRST */
2551 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2553 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2555 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2556 return ERROR_JTAG_INIT_FAILED
;
2562 static int cortino_jtag_init(void)
2568 low_direction
= 0x1b;
2570 /* initialize low byte for jtag */
2571 buf
[0] = 0x80; /* command "set data bits low byte" */
2572 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2573 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2574 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2576 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2578 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2579 return ERROR_JTAG_INIT_FAILED
;
2583 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2585 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2588 high_direction
= 0x03;
2590 /* initialize high port */
2591 buf
[0] = 0x82; /* command "set data bits high byte" */
2592 buf
[1] = high_output
;
2593 buf
[2] = high_direction
;
2594 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2596 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2598 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2599 return ERROR_JTAG_INIT_FAILED
;
2605 static void olimex_jtag_blink(void)
2607 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2608 * ACBUS3 is bit 3 of the GPIOH port
2610 if (high_output
& 0x08)
2612 /* set port pin high */
2613 high_output
&= 0x07;
2617 /* set port pin low */
2618 high_output
|= 0x08;
2621 buffer_write( 0x82 );
2622 buffer_write( high_output
);
2623 buffer_write( high_direction
);
2627 static void flyswatter_jtag_blink(void)
2630 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2632 high_output
^= 0x0c;
2634 buffer_write( 0x82 );
2635 buffer_write( high_output
);
2636 buffer_write( high_direction
);
2640 static void turtle_jtag_blink(void)
2643 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2645 if (high_output
& 0x08)
2654 buffer_write( 0x82 );
2655 buffer_write( high_output
);
2656 buffer_write( high_direction
);
2660 static int ft2232_quit(void)
2662 #if BUILD_FT2232_FTD2XX == 1
2665 status
= FT_Close(ftdih
);
2666 #elif BUILD_FT2232_LIBFTDI == 1
2667 ftdi_usb_close(&ftdic
);
2669 ftdi_deinit(&ftdic
);
2672 free(ft2232_buffer
);
2673 ft2232_buffer
= NULL
;
2679 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2685 ft2232_device_desc
= strdup(args
[0]);
2686 cp
= strchr( ft2232_device_desc
, 0 );
2687 // under Win32, the FTD2XX driver appends an "A" to the end
2688 // of the description, this examines the given desc
2689 // and creates the 'missing' _A or non_A variable.
2690 if( (cp
[-1] == 'A') && (cp
[-2]==' ') ){
2691 // it was, so make this the "A" version.
2692 ft2232_device_desc_A
= ft2232_device_desc
;
2693 // and *CREATE* the non-A version.
2694 strcpy( buf
, ft2232_device_desc
);
2695 cp
= strchr( buf
, 0 );
2697 ft2232_device_desc
= strdup( buf
);
2699 // <space>A not defined
2701 sprintf( buf
, "%s A", ft2232_device_desc
);
2702 ft2232_device_desc_A
= strdup( buf
);
2707 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2714 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2718 ft2232_serial
= strdup(args
[0]);
2722 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2729 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2734 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2735 strcpy(ft2232_layout
, args
[0]);
2741 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2745 if (argc
> MAX_USB_IDS
* 2)
2747 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2748 "(maximum is %d pairs)", MAX_USB_IDS
);
2749 argc
= MAX_USB_IDS
* 2;
2751 if ( argc
< 2 || (argc
& 1) )
2753 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2758 for (i
= 0; i
+ 1 < argc
; i
+= 2)
2760 ft2232_vid
[i
>> 1] = strtol(args
[i
], NULL
, 0);
2761 ft2232_pid
[i
>> 1] = strtol(args
[i
+ 1], NULL
, 0);
2765 * Explicitly terminate, in case there are multiples instances of
2768 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2774 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2778 ft2232_latency
= atoi(args
[0]);
2782 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2789 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2793 /* 7 bits of either ones or zeros. */
2794 u8 tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2796 while (num_cycles
> 0)
2798 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2799 * at most 7 bits per invocation. Here we invoke it potentially
2802 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2804 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2806 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2807 retval
= ERROR_JTAG_QUEUE_FAILED
;
2812 /* there are no state transitions in this code, so omit state tracking */
2814 /* command "Clock Data to TMS/CS Pin (no Read)" */
2815 buffer_write( 0x4b );
2818 buffer_write( bitcount_per_command
- 1 );
2820 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2821 buffer_write( tms
);
2825 num_cycles
-= bitcount_per_command
;
2832 /* ---------------------------------------------------------------------
2833 * Support for IceBear JTAG adapter from Section5:
2834 * http://section5.ch/icebear
2836 * Author: Sten, debian@sansys-electronic.com
2839 /* Icebear pin layout
2841 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2842 * GND GND | 4 3| n.c.
2843 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2844 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2845 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2846 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2847 * ADBUS2 TDO |14 13| GND GND
2849 * ADBUS0 O L TCK ACBUS0 GND
2850 * ADBUS1 O L TDI ACBUS1 GND
2851 * ADBUS2 I TDO ACBUS2 n.c.
2852 * ADBUS3 O H TMS ACBUS3 n.c.
2858 static int icebear_jtag_init(void) {
2862 low_direction
= 0x0b; /* output: TCK TDI TMS; input: TDO */
2863 low_output
= 0x08; /* high: TMS; low: TCK TDI */
2867 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0) {
2868 low_direction
&= ~nTRST
; /* nTRST high impedance */
2871 low_direction
|= nTRST
;
2872 low_output
|= nTRST
;
2875 low_direction
|= nSRST
;
2876 low_output
|= nSRST
;
2878 /* initialize low byte for jtag */
2879 buf
[0] = 0x80; /* command "set data bits low byte" */
2880 buf
[1] = low_output
;
2881 buf
[2] = low_direction
;
2882 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2884 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2885 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2886 return ERROR_JTAG_INIT_FAILED
;
2890 high_direction
= 0x00;
2893 /* initialize high port */
2894 buf
[0] = 0x82; /* command "set data bits high byte" */
2895 buf
[1] = high_output
; /* value */
2896 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2897 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2899 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2900 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2901 return ERROR_JTAG_INIT_FAILED
;
2907 static void icebear_jtag_reset(int trst
, int srst
) {
2910 low_direction
|= nTRST
;
2911 low_output
&= ~nTRST
;
2913 else if (trst
== 0) {
2914 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0)
2915 low_direction
&= ~nTRST
;
2917 low_output
|= nTRST
;
2921 low_output
&= ~nSRST
;
2923 else if (srst
== 0) {
2924 low_output
|= nSRST
;
2927 /* command "set data bits low byte" */
2928 buffer_write( 0x80 );
2929 buffer_write( low_output
);
2930 buffer_write( low_direction
);
2932 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)