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 */
44 #include "time_support.h"
52 #if (BUILD_FT2232_FTD2XX==1 && BUILD_FT2232_LIBFTDI==1)
53 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
54 #elif(BUILD_FT2232_FTD2XX!=1 && BUILD_FT2232_LIBFTDI!=1)
55 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
58 /* FT2232 access library includes */
59 #if BUILD_FT2232_FTD2XX == 1
61 #elif BUILD_FT2232_LIBFTDI == 1
65 /* max TCK for the high speed devices 30000 kHz */
66 #define FTDI_2232H_4232H_MAX_TCK 30000
68 static int ft2232_execute_queue(void);
70 static int ft2232_speed(int speed
);
71 static int ft2232_speed_div(int speed
, int* khz
);
72 static int ft2232_khz(int khz
, int* jtag_speed
);
73 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
);
74 static int ft2232_init(void);
75 static int ft2232_quit(void);
77 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
78 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
79 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
80 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
81 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
);
85 * Function ft2232_stableclocks
86 * will send out \a num_cycles on the TCK line while the TAP(s)
87 * are in a stable state. Calling code must ensure that current state is
88 * stable, that verification is not done in here.
89 * @param num_cycles is the count of clocks cycles to send.
90 * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED
92 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
);
95 static char * ft2232_device_desc_A
= NULL
;
96 static char* ft2232_device_desc
= NULL
;
97 static char* ft2232_serial
= NULL
;
98 static char* ft2232_layout
= NULL
;
99 static u8 ft2232_latency
= 2;
100 static unsigned ft2232_max_tck
= 6000;
103 #define MAX_USB_IDS 8
104 /* vid = pid = 0 marks the end of the list */
105 static u16 ft2232_vid
[MAX_USB_IDS
+ 1] = { 0x0403, 0 };
106 static u16 ft2232_pid
[MAX_USB_IDS
+ 1] = { 0x6010, 0 };
108 typedef struct ft2232_layout_s
112 void (*reset
)(int trst
, int srst
);
116 /* init procedures for supported layouts */
117 static int usbjtag_init(void);
118 static int jtagkey_init(void);
119 static int olimex_jtag_init(void);
120 static int flyswatter_init(void);
121 static int turtle_init(void);
122 static int comstick_init(void);
123 static int stm32stick_init(void);
124 static int axm0432_jtag_init(void);
125 static int sheevaplug_init(void);
126 static int icebear_jtag_init(void);
127 static int cortino_jtag_init(void);
129 /* reset procedures for supported layouts */
130 static void usbjtag_reset(int trst
, int srst
);
131 static void jtagkey_reset(int trst
, int srst
);
132 static void olimex_jtag_reset(int trst
, int srst
);
133 static void flyswatter_reset(int trst
, int srst
);
134 static void turtle_reset(int trst
, int srst
);
135 static void comstick_reset(int trst
, int srst
);
136 static void stm32stick_reset(int trst
, int srst
);
137 static void axm0432_jtag_reset(int trst
, int srst
);
138 static void sheevaplug_reset(int trst
, int srst
);
139 static void icebear_jtag_reset(int trst
, int srst
);
141 /* blink procedures for layouts that support a blinking led */
142 static void olimex_jtag_blink(void);
143 static void flyswatter_jtag_blink(void);
144 static void turtle_jtag_blink(void);
146 ft2232_layout_t ft2232_layouts
[] =
148 { "usbjtag", usbjtag_init
, usbjtag_reset
, NULL
},
149 { "jtagkey", jtagkey_init
, jtagkey_reset
, NULL
},
150 { "jtagkey_prototype_v1", jtagkey_init
, jtagkey_reset
, NULL
},
151 { "oocdlink", jtagkey_init
, jtagkey_reset
, NULL
},
152 { "signalyzer", usbjtag_init
, usbjtag_reset
, NULL
},
153 { "evb_lm3s811", usbjtag_init
, usbjtag_reset
, NULL
},
154 { "olimex-jtag", olimex_jtag_init
, olimex_jtag_reset
, olimex_jtag_blink
},
155 { "flyswatter", flyswatter_init
, flyswatter_reset
, flyswatter_jtag_blink
},
156 { "turtelizer2", turtle_init
, turtle_reset
, turtle_jtag_blink
},
157 { "comstick", comstick_init
, comstick_reset
, NULL
},
158 { "stm32stick", stm32stick_init
, stm32stick_reset
, NULL
},
159 { "axm0432_jtag", axm0432_jtag_init
, axm0432_jtag_reset
, NULL
},
160 { "sheevaplug", sheevaplug_init
, sheevaplug_reset
, NULL
},
161 { "icebear", icebear_jtag_init
, icebear_jtag_reset
, NULL
},
162 { "cortino", cortino_jtag_init
, comstick_reset
, NULL
},
163 { NULL
, NULL
, NULL
, NULL
},
166 static u8 nTRST
, nTRSTnOE
, nSRST
, nSRSTnOE
;
168 static ft2232_layout_t
* layout
;
169 static u8 low_output
= 0x0;
170 static u8 low_direction
= 0x0;
171 static u8 high_output
= 0x0;
172 static u8 high_direction
= 0x0;
174 #if BUILD_FT2232_FTD2XX == 1
175 static FT_HANDLE ftdih
= NULL
;
176 #elif BUILD_FT2232_LIBFTDI == 1
177 static struct ftdi_context ftdic
;
181 static jtag_command_t
* first_unsent
; /* next command that has to be sent */
182 static int require_send
;
185 /* http://urjtag.wiki.sourceforge.net/Cable+FT2232 says:
187 "There is a significant difference between libftdi and libftd2xx. The latter
188 one allows to schedule up to 64*64 bytes of result data while libftdi fails
189 with more than 4*64. As a consequence, the FT2232 driver is forced to
190 perform around 16x more USB transactions for long command streams with TDO
191 capture when running with libftdi."
194 #define FT2232_BUFFER_SIZE 131072
195 a comment would have been nice.
198 #define FT2232_BUFFER_SIZE 131072
200 static u8
* ft2232_buffer
= NULL
;
201 static int ft2232_buffer_size
= 0;
202 static int ft2232_read_pointer
= 0;
203 static int ft2232_expect_read
= 0;
206 * Function buffer_write
207 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
208 * @param val is the byte to send.
210 static inline void buffer_write( u8 val
)
212 assert( ft2232_buffer
);
213 assert( (unsigned) ft2232_buffer_size
< (unsigned) FT2232_BUFFER_SIZE
);
214 ft2232_buffer
[ft2232_buffer_size
++] = val
;
218 * Function buffer_read
219 * returns a byte from the byte buffer.
221 static inline u8
buffer_read(void)
223 assert( ft2232_buffer
);
224 assert( ft2232_read_pointer
< ft2232_buffer_size
);
225 return ft2232_buffer
[ft2232_read_pointer
++];
231 * clocks out \a bit_count bits on the TMS line, starting with the least
232 * significant bit of tms_bits and progressing to more significant bits.
233 * Rigorous state transition logging is done here via tap_set_state().
235 * @param pmsse_cmd is one of the MPSSE TMS oriented commands such as 0x4b or 0x6b. See
236 * the MPSSE spec referenced above for their functionality. The MPSSE command
237 * "Clock Data to TMS/CS Pin (no Read)" is often used for this, 0x4b.
239 * @param tms_bits holds the sequence of bits to send.
240 * @param tms_count tells how many bits in the sequence.
241 * @param tdi_bit is a single bit which is passed on to TDI before the first TCK cycle
242 * and is held static for the duration of TMS clocking. See the MPSSE spec referenced above.
244 static void clock_tms( u8 mpsse_cmd
, int tms_bits
, int tms_count
, bool tdi_bit
)
248 int tms_ndx
; /* bit index into tms_byte */
250 assert( tms_count
> 0 );
252 // LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count );
254 for (tms_byte
= tms_ndx
= i
= 0; i
< tms_count
; ++i
, tms_bits
>>=1)
256 bool bit
= tms_bits
& 1;
259 tms_byte
|= (1<<tms_ndx
);
261 /* always do state transitions in public view */
262 tap_set_state( tap_state_transition(tap_get_state(), bit
) );
264 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
269 if( tms_ndx
==7 || i
==tms_count
-1 )
271 buffer_write( mpsse_cmd
);
272 buffer_write( tms_ndx
- 1 );
274 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
275 TMS/CS and is held static for the duration of TMS/CS clocking.
277 buffer_write( tms_byte
| (tdi_bit
<< 7) );
284 * Function get_tms_buffer_requirements
285 * returns what clock_tms() will consume if called with
288 static inline int get_tms_buffer_requirements( int bit_count
)
290 return ((bit_count
+ 6)/7) * 3;
295 * Function move_to_state
296 * moves the TAP controller from the current state to a
297 * \a goal_state through a path given by tap_get_tms_path(). State transition
298 * logging is performed by delegation to clock_tms().
300 * @param goal_state is the destination state for the move.
302 static void move_to_state( tap_state_t goal_state
)
304 tap_state_t start_state
= tap_get_state();
306 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
307 lookup of the required TMS pattern to move to this state from the
311 /* do the 2 lookups */
312 int tms_bits
= tap_get_tms_path(start_state
, goal_state
);
313 int tms_count
= tap_get_tms_path_len(start_state
, goal_state
);
315 DEBUG_JTAG_IO( "start=%s goal=%s", tap_state_name(start_state
), tap_state_name(goal_state
) );
317 clock_tms( 0x4b, tms_bits
, tms_count
, 0 );
321 jtag_interface_t ft2232_interface
=
324 .execute_queue
= ft2232_execute_queue
,
325 .speed
= ft2232_speed
,
326 .speed_div
= ft2232_speed_div
,
328 .register_commands
= ft2232_register_commands
,
333 static int ft2232_write(u8
* buf
, int size
, u32
* bytes_written
)
335 #if BUILD_FT2232_FTD2XX == 1
337 DWORD dw_bytes_written
;
338 if ( ( status
= FT_Write(ftdih
, buf
, size
, &dw_bytes_written
) ) != FT_OK
)
340 *bytes_written
= dw_bytes_written
;
341 LOG_ERROR("FT_Write returned: %lu", status
);
342 return ERROR_JTAG_DEVICE_ERROR
;
346 *bytes_written
= dw_bytes_written
;
349 #elif BUILD_FT2232_LIBFTDI == 1
351 if ( ( retval
= ftdi_write_data(&ftdic
, buf
, size
) ) < 0 )
354 LOG_ERROR( "ftdi_write_data: %s", ftdi_get_error_string(&ftdic
) );
355 return ERROR_JTAG_DEVICE_ERROR
;
359 *bytes_written
= retval
;
366 static int ft2232_read(u8
* buf
, u32 size
, u32
* bytes_read
)
368 #if BUILD_FT2232_FTD2XX == 1
374 while ( (*bytes_read
< size
) && timeout
-- )
376 if ( ( status
= FT_Read(ftdih
, buf
+ *bytes_read
, size
-
377 *bytes_read
, &dw_bytes_read
) ) != FT_OK
)
380 LOG_ERROR("FT_Read returned: %lu", status
);
381 return ERROR_JTAG_DEVICE_ERROR
;
383 *bytes_read
+= dw_bytes_read
;
386 #elif BUILD_FT2232_LIBFTDI == 1
391 while ( (*bytes_read
< size
) && timeout
-- )
393 if ( ( retval
= ftdi_read_data(&ftdic
, buf
+ *bytes_read
, size
- *bytes_read
) ) < 0 )
396 LOG_ERROR( "ftdi_read_data: %s", ftdi_get_error_string(&ftdic
) );
397 return ERROR_JTAG_DEVICE_ERROR
;
399 *bytes_read
+= retval
;
404 if (*bytes_read
< size
)
406 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read
, size
);
407 return ERROR_JTAG_DEVICE_ERROR
;
414 static int ft2232_speed(int speed
)
420 buf
[0] = 0x86; /* command "set divisor" */
421 buf
[1] = speed
& 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
422 buf
[2] = (speed
>> 8) & 0xff; /* valueH */
424 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
425 if ( ( ( retval
= ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
427 LOG_ERROR("couldn't set FT2232 TCK speed");
435 static int ft2232_speed_div(int speed
, int* khz
)
437 /* Take a look in the FT2232 manual,
438 * AN2232C-01 Command Processor for
439 * MPSSE and MCU Host Bus. Chapter 3.8 */
441 *khz
= ft2232_max_tck
/ (1 + speed
);
447 static int ft2232_khz(int khz
, int* jtag_speed
)
451 LOG_DEBUG("RTCK not supported");
455 /* Take a look in the FT2232 manual,
456 * AN2232C-01 Command Processor for
457 * MPSSE and MCU Host Bus. Chapter 3.8
459 * We will calc here with a multiplier
460 * of 10 for better rounding later. */
462 /* Calc speed, (ft2232_max_tck / khz) - 1 */
463 /* Use 65000 for better rounding */
464 *jtag_speed
= ((ft2232_max_tck
*10) / khz
) - 10;
466 /* Add 0.9 for rounding */
469 /* Calc real speed */
470 *jtag_speed
= *jtag_speed
/ 10;
472 /* Check if speed is greater than 0 */
478 /* Check max value */
479 if (*jtag_speed
> 0xFFFF)
481 *jtag_speed
= 0xFFFF;
488 static int ft2232_register_commands(struct command_context_s
* cmd_ctx
)
490 register_command(cmd_ctx
, NULL
, "ft2232_device_desc", ft2232_handle_device_desc_command
,
491 COMMAND_CONFIG
, "the USB device description of the FTDI FT2232 device");
492 register_command(cmd_ctx
, NULL
, "ft2232_serial", ft2232_handle_serial_command
,
493 COMMAND_CONFIG
, "the serial number of the FTDI FT2232 device");
494 register_command(cmd_ctx
, NULL
, "ft2232_layout", ft2232_handle_layout_command
,
495 COMMAND_CONFIG
, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
496 register_command(cmd_ctx
, NULL
, "ft2232_vid_pid", ft2232_handle_vid_pid_command
,
497 COMMAND_CONFIG
, "the vendor ID and product ID of the FTDI FT2232 device");
498 register_command(cmd_ctx
, NULL
, "ft2232_latency", ft2232_handle_latency_command
,
499 COMMAND_CONFIG
, "set the FT2232 latency timer to a new value");
504 void ft2232_end_state(tap_state_t state
)
506 if (tap_is_state_stable(state
))
507 tap_set_end_state(state
);
510 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_end_state(jtag_command_t
*cmd
)
1420 DEBUG_JTAG_IO("execute_end_state: %s", tap_state_name(cmd
->cmd
.end_state
->end_state
) );
1422 if (cmd
->cmd
.end_state
->end_state
!= TAP_INVALID
)
1423 ft2232_end_state(cmd
->cmd
.end_state
->end_state
);
1429 static int ft2232_execute_runtest(jtag_command_t
*cmd
)
1433 int predicted_size
= 0;
1436 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1437 cmd
->cmd
.runtest
->num_cycles
,
1438 tap_state_name(cmd
->cmd
.runtest
->end_state
));
1440 /* only send the maximum buffer size that FT2232C can handle */
1442 if (tap_get_state() != TAP_IDLE
)
1443 predicted_size
+= 3;
1444 predicted_size
+= 3 * CEIL(cmd
->cmd
.runtest
->num_cycles
, 7);
1445 if ( (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
) && (cmd
->cmd
.runtest
->end_state
!= TAP_IDLE
) )
1446 predicted_size
+= 3;
1447 if ( (cmd
->cmd
.runtest
->end_state
== TAP_INVALID
) && (tap_get_end_state() != TAP_IDLE
) )
1448 predicted_size
+= 3;
1449 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1451 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1452 retval
= ERROR_JTAG_QUEUE_FAILED
;
1456 if (tap_get_state() != TAP_IDLE
)
1458 move_to_state( TAP_IDLE
);
1461 i
= cmd
->cmd
.runtest
->num_cycles
;
1464 /* there are no state transitions in this code, so omit state tracking */
1466 /* command "Clock Data to TMS/CS Pin (no Read)" */
1467 buffer_write( 0x4b );
1470 buffer_write( (i
> 7) ? 6 : (i
- 1) );
1473 buffer_write( 0x0 );
1474 tap_set_state(TAP_IDLE
);
1476 i
-= (i
> 7) ? 7 : i
;
1477 /* LOG_DEBUG("added TMS scan (no read)"); */
1480 if (cmd
->cmd
.runtest
->end_state
!= TAP_INVALID
)
1481 ft2232_end_state(cmd
->cmd
.runtest
->end_state
);
1483 if ( tap_get_state() != tap_get_end_state() )
1485 move_to_state( tap_get_end_state() );
1489 #ifdef _DEBUG_JTAG_IO_
1490 LOG_DEBUG( "runtest: %i, end in %s", cmd
->cmd
.runtest
->num_cycles
, tap_state_name( tap_get_end_state() ) );
1497 static int ft2232_execute_statemove(jtag_command_t
*cmd
)
1499 int predicted_size
= 0;
1500 int retval
= ERROR_OK
;
1502 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
1504 /* only send the maximum buffer size that FT2232C can handle */
1506 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1508 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1509 retval
= ERROR_JTAG_QUEUE_FAILED
;
1513 if (cmd
->cmd
.statemove
->end_state
!= TAP_INVALID
)
1514 ft2232_end_state(cmd
->cmd
.statemove
->end_state
);
1516 /* move to end state */
1517 if ( tap_get_state() != tap_get_end_state() )
1519 move_to_state( tap_get_end_state() );
1526 static int ft2232_execute_pathmove(jtag_command_t
*cmd
)
1528 int predicted_size
= 0;
1529 int retval
= ERROR_OK
;
1531 tap_state_t
* path
= cmd
->cmd
.pathmove
->path
;
1532 int num_states
= cmd
->cmd
.pathmove
->num_states
;
1534 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states
,
1535 tap_state_name( tap_get_state() ),
1536 tap_state_name( path
[num_states
-1] )
1539 /* only send the maximum buffer size that FT2232C can handle */
1540 predicted_size
= 3 * CEIL(num_states
, 7);
1541 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1543 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1544 retval
= ERROR_JTAG_QUEUE_FAILED
;
1550 ft2232_add_pathmove( path
, num_states
);
1557 static int ft2232_execute_scan(jtag_command_t
*cmd
)
1560 int scan_size
; /* size of IR or DR scan */
1561 int predicted_size
= 0;
1562 int retval
= ERROR_OK
;
1564 enum scan_type type
= jtag_scan_type(cmd
->cmd
.scan
);
1566 DEBUG_JTAG_IO( "%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN", type
);
1568 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
1570 predicted_size
= ft2232_predict_scan_out(scan_size
, type
);
1571 if ( (predicted_size
+ 1) > FT2232_BUFFER_SIZE
)
1573 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1574 /* unsent commands before this */
1575 if (first_unsent
!= cmd
)
1576 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1577 retval
= ERROR_JTAG_QUEUE_FAILED
;
1579 /* current command */
1580 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
1581 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1582 ft2232_large_scan(cmd
->cmd
.scan
, type
, buffer
, scan_size
);
1584 first_unsent
= cmd
->next
;
1589 else if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1591 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1594 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1595 retval
= ERROR_JTAG_QUEUE_FAILED
;
1599 ft2232_expect_read
+= ft2232_predict_scan_in(scan_size
, type
);
1600 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1601 if (cmd
->cmd
.scan
->end_state
!= TAP_INVALID
)
1602 ft2232_end_state(cmd
->cmd
.scan
->end_state
);
1603 ft2232_add_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
);
1607 #ifdef _DEBUG_JTAG_IO_
1608 LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1609 tap_state_name( tap_get_end_state() ) );
1615 static int ft2232_execute_reset(jtag_command_t
*cmd
)
1618 int predicted_size
= 0;
1621 DEBUG_JTAG_IO("reset trst: %i srst %i",
1622 cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1624 /* only send the maximum buffer size that FT2232C can handle */
1626 if (ft2232_buffer_size
+ predicted_size
+ 1 > FT2232_BUFFER_SIZE
)
1628 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1629 retval
= ERROR_JTAG_QUEUE_FAILED
;
1634 layout
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1637 #ifdef _DEBUG_JTAG_IO_
1638 LOG_DEBUG("trst: %i, srst: %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
1643 static int ft2232_execute_sleep(jtag_command_t
*cmd
)
1648 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
1650 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1651 retval
= ERROR_JTAG_QUEUE_FAILED
;
1652 first_unsent
= cmd
->next
;
1653 jtag_sleep(cmd
->cmd
.sleep
->us
);
1654 #ifdef _DEBUG_JTAG_IO_
1655 LOG_DEBUG( "sleep %i usec while in %s", cmd
->cmd
.sleep
->us
, tap_state_name( tap_get_state() ) );
1661 static int ft2232_execute_stableclocks(jtag_command_t
*cmd
)
1666 /* this is only allowed while in a stable state. A check for a stable
1667 * state was done in jtag_add_clocks()
1669 if (ft2232_stableclocks(cmd
->cmd
.stableclocks
->num_cycles
, cmd
) != ERROR_OK
)
1670 retval
= ERROR_JTAG_QUEUE_FAILED
;
1671 #ifdef _DEBUG_JTAG_IO_
1672 LOG_DEBUG( "clocks %i while in %s", cmd
->cmd
.stableclocks
->num_cycles
, tap_state_name( tap_get_state() ) );
1678 static int ft2232_execute_command(jtag_command_t
*cmd
)
1685 case JTAG_END_STATE
: retval
= ft2232_execute_end_state(cmd
); break;
1686 case JTAG_RESET
: retval
= ft2232_execute_reset(cmd
); break;
1687 case JTAG_RUNTEST
: retval
= ft2232_execute_runtest(cmd
); break;
1688 case JTAG_STATEMOVE
: retval
= ft2232_execute_statemove(cmd
); break;
1689 case JTAG_PATHMOVE
: retval
= ft2232_execute_pathmove(cmd
); break;
1690 case JTAG_SCAN
: retval
= ft2232_execute_scan(cmd
); break;
1691 case JTAG_SLEEP
: retval
= ft2232_execute_sleep(cmd
); break;
1692 case JTAG_STABLECLOCKS
: retval
= ft2232_execute_stableclocks(cmd
); break;
1694 LOG_ERROR("BUG: unknown JTAG command type encountered");
1700 static int ft2232_execute_queue()
1702 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
1705 first_unsent
= cmd
; /* next command that has to be sent */
1708 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1709 * that wasn't handled by a caller-provided error handler
1713 ft2232_buffer_size
= 0;
1714 ft2232_expect_read
= 0;
1716 /* blink, if the current layout has that feature */
1722 if (ft2232_execute_command(cmd
) != ERROR_OK
)
1723 retval
= ERROR_JTAG_QUEUE_FAILED
;
1724 /* Start reading input before FT2232 TX buffer fills up */
1726 if (ft2232_expect_read
> 256)
1728 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1729 retval
= ERROR_JTAG_QUEUE_FAILED
;
1734 if (require_send
> 0)
1735 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
1736 retval
= ERROR_JTAG_QUEUE_FAILED
;
1742 #if BUILD_FT2232_FTD2XX == 1
1743 static int ft2232_init_ftd2xx(u16 vid
, u16 pid
, int more
, int* try_more
)
1746 DWORD openex_flags
= 0;
1747 char* openex_string
= NULL
;
1750 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout
, vid
, pid
);
1753 /* Add non-standard Vid/Pid to the linux driver */
1754 if ( ( status
= FT_SetVIDPID(vid
, pid
) ) != FT_OK
)
1756 LOG_WARNING("couldn't add %4.4x:%4.4x", vid
, pid
);
1760 if (ft2232_device_desc
&& ft2232_serial
)
1762 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1763 ft2232_device_desc
= NULL
;
1766 if (ft2232_device_desc
)
1768 openex_string
= ft2232_device_desc
;
1769 openex_flags
= FT_OPEN_BY_DESCRIPTION
;
1771 else if (ft2232_serial
)
1773 openex_string
= ft2232_serial
;
1774 openex_flags
= FT_OPEN_BY_SERIAL_NUMBER
;
1778 LOG_ERROR("neither device description nor serial number specified");
1779 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1781 return ERROR_JTAG_INIT_FAILED
;
1784 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1785 if( status
!= FT_OK
){
1786 // under Win32, the FTD2XX driver appends an "A" to the end
1787 // of the description, if we tried by the desc, then
1788 // try by the alternate "A" description.
1789 if( openex_string
== ft2232_device_desc
){
1790 // Try the alternate method.
1791 openex_string
= ft2232_device_desc_A
;
1792 status
= FT_OpenEx(openex_string
, openex_flags
, &ftdih
);
1793 if( status
== FT_OK
){
1794 // yea, the "alternate" method worked!
1796 // drat, give the user a meaningfull message.
1797 // telling the use we tried *BOTH* methods.
1798 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1800 ft2232_device_desc_A
);
1805 if ( status
!= FT_OK
)
1811 LOG_WARNING("unable to open ftdi device (trying more): %lu", status
);
1813 return ERROR_JTAG_INIT_FAILED
;
1815 LOG_ERROR("unable to open ftdi device: %lu", status
);
1816 status
= FT_ListDevices(&num_devices
, NULL
, FT_LIST_NUMBER_ONLY
);
1817 if (status
== FT_OK
)
1819 char** desc_array
= malloc( sizeof(char*) * (num_devices
+ 1) );
1822 for (i
= 0; i
< num_devices
; i
++)
1823 desc_array
[i
] = malloc(64);
1825 desc_array
[num_devices
] = NULL
;
1827 status
= FT_ListDevices(desc_array
, &num_devices
, FT_LIST_ALL
| openex_flags
);
1829 if (status
== FT_OK
)
1831 LOG_ERROR("ListDevices: %lu\n", num_devices
);
1832 for (i
= 0; i
< num_devices
; i
++)
1833 LOG_ERROR("%i: \"%s\"", i
, desc_array
[i
]);
1836 for (i
= 0; i
< num_devices
; i
++)
1837 free(desc_array
[i
]);
1843 LOG_ERROR("ListDevices: NONE\n");
1845 return ERROR_JTAG_INIT_FAILED
;
1848 if ( ( status
= FT_SetLatencyTimer(ftdih
, ft2232_latency
) ) != FT_OK
)
1850 LOG_ERROR("unable to set latency timer: %lu", status
);
1851 return ERROR_JTAG_INIT_FAILED
;
1854 if ( ( status
= FT_GetLatencyTimer(ftdih
, &latency_timer
) ) != FT_OK
)
1856 LOG_ERROR("unable to get latency timer: %lu", status
);
1857 return ERROR_JTAG_INIT_FAILED
;
1861 LOG_DEBUG("current latency timer: %i", latency_timer
);
1864 if ( ( status
= FT_SetTimeouts(ftdih
, 5000, 5000) ) != FT_OK
)
1866 LOG_ERROR("unable to set timeouts: %lu", status
);
1867 return ERROR_JTAG_INIT_FAILED
;
1870 if ( ( status
= FT_SetBitMode(ftdih
, 0x0b, 2) ) != FT_OK
)
1872 LOG_ERROR("unable to enable bit i/o mode: %lu", status
);
1873 return ERROR_JTAG_INIT_FAILED
;
1880 static int ft2232_purge_ftd2xx(void)
1884 if ( ( status
= FT_Purge(ftdih
, FT_PURGE_RX
| FT_PURGE_TX
) ) != FT_OK
)
1886 LOG_ERROR("error purging ftd2xx device: %lu", status
);
1887 return ERROR_JTAG_INIT_FAILED
;
1894 #endif /* BUILD_FT2232_FTD2XX == 1 */
1896 #if BUILD_FT2232_LIBFTDI == 1
1897 static int ft2232_init_libftdi(u16 vid
, u16 pid
, int more
, int* try_more
)
1901 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1902 ft2232_layout
, vid
, pid
);
1904 if (ftdi_init(&ftdic
) < 0)
1905 return ERROR_JTAG_INIT_FAILED
;
1907 if (ftdi_set_interface(&ftdic
, INTERFACE_A
) < 0)
1909 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic
.error_str
);
1910 return ERROR_JTAG_INIT_FAILED
;
1913 /* context, vendor id, product id */
1914 if (ftdi_usb_open_desc(&ftdic
, vid
, pid
, ft2232_device_desc
,
1918 LOG_WARNING("unable to open ftdi device (trying more): %s",
1921 LOG_ERROR("unable to open ftdi device: %s", ftdic
.error_str
);
1923 return ERROR_JTAG_INIT_FAILED
;
1926 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1927 if (ftdi_usb_reset(&ftdic
) < 0)
1929 LOG_ERROR("unable to reset ftdi device");
1930 return ERROR_JTAG_INIT_FAILED
;
1933 if (ftdi_set_latency_timer(&ftdic
, ft2232_latency
) < 0)
1935 LOG_ERROR("unable to set latency timer");
1936 return ERROR_JTAG_INIT_FAILED
;
1939 if (ftdi_get_latency_timer(&ftdic
, &latency_timer
) < 0)
1941 LOG_ERROR("unable to get latency timer");
1942 return ERROR_JTAG_INIT_FAILED
;
1946 LOG_DEBUG("current latency timer: %i", latency_timer
);
1949 ftdi_set_bitmode(&ftdic
, 0x0b, 2); /* ctx, JTAG I/O mask */
1955 static int ft2232_purge_libftdi(void)
1957 if (ftdi_usb_purge_buffers(&ftdic
) < 0)
1959 LOG_ERROR("ftdi_purge_buffers: %s", ftdic
.error_str
);
1960 return ERROR_JTAG_INIT_FAILED
;
1967 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1969 static int ft2232_init(void)
1974 ft2232_layout_t
* cur_layout
= ft2232_layouts
;
1977 if (tap_get_tms_path_len(TAP_IRPAUSE
,TAP_IRPAUSE
)==7)
1979 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
1983 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
1986 if ( (ft2232_layout
== NULL
) || (ft2232_layout
[0] == 0) )
1988 ft2232_layout
= "usbjtag";
1989 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
1992 while (cur_layout
->name
)
1994 if (strcmp(cur_layout
->name
, ft2232_layout
) == 0)
1996 layout
= cur_layout
;
2004 LOG_ERROR("No matching layout found for %s", ft2232_layout
);
2005 return ERROR_JTAG_INIT_FAILED
;
2011 * "more indicates that there are more IDs to try, so we should
2012 * not print an error for an ID mismatch (but for anything
2015 * try_more indicates that the error code returned indicates an
2016 * ID mismatch (and nothing else) and that we should proceeed
2017 * with the next ID pair.
2019 int more
= ft2232_vid
[i
+ 1] || ft2232_pid
[i
+ 1];
2022 #if BUILD_FT2232_FTD2XX == 1
2023 retval
= ft2232_init_ftd2xx(ft2232_vid
[i
], ft2232_pid
[i
],
2025 #elif BUILD_FT2232_LIBFTDI == 1
2026 retval
= ft2232_init_libftdi(ft2232_vid
[i
], ft2232_pid
[i
],
2031 if (!more
|| !try_more
)
2035 ft2232_buffer_size
= 0;
2036 ft2232_buffer
= malloc(FT2232_BUFFER_SIZE
);
2038 if (layout
->init() != ERROR_OK
)
2039 return ERROR_JTAG_INIT_FAILED
;
2041 ft2232_speed(jtag_speed
);
2043 buf
[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2044 if ( ( ( retval
= ft2232_write(buf
, 1, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 1) )
2046 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2047 return ERROR_JTAG_INIT_FAILED
;
2050 #if BUILD_FT2232_FTD2XX == 1
2051 return ft2232_purge_ftd2xx();
2052 #elif BUILD_FT2232_LIBFTDI == 1
2053 return ft2232_purge_libftdi();
2060 static int usbjtag_init(void)
2066 low_direction
= 0x0b;
2068 if (strcmp(ft2232_layout
, "usbjtag") == 0)
2075 else if (strcmp(ft2232_layout
, "signalyzer") == 0)
2082 else if (strcmp(ft2232_layout
, "evb_lm3s811") == 0)
2089 low_direction
= 0x8b;
2093 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout
);
2094 return ERROR_JTAG_INIT_FAILED
;
2097 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2099 low_direction
&= ~nTRSTnOE
; /* nTRST input */
2100 low_output
&= ~nTRST
; /* nTRST = 0 */
2104 low_direction
|= nTRSTnOE
; /* nTRST output */
2105 low_output
|= nTRST
; /* nTRST = 1 */
2108 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2110 low_direction
|= nSRSTnOE
; /* nSRST output */
2111 low_output
|= nSRST
; /* nSRST = 1 */
2115 low_direction
&= ~nSRSTnOE
; /* nSRST input */
2116 low_output
&= ~nSRST
; /* nSRST = 0 */
2119 /* initialize low byte for jtag */
2120 buf
[0] = 0x80; /* command "set data bits low byte" */
2121 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2122 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2123 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2125 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2127 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2128 return ERROR_JTAG_INIT_FAILED
;
2135 static int axm0432_jtag_init(void)
2141 low_direction
= 0x2b;
2143 /* initialize low byte for jtag */
2144 buf
[0] = 0x80; /* command "set data bits low byte" */
2145 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2146 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2147 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2149 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2151 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2152 return ERROR_JTAG_INIT_FAILED
;
2155 if (strcmp(layout
->name
, "axm0432_jtag") == 0)
2158 nTRSTnOE
= 0x0; /* No output enable for TRST*/
2160 nSRSTnOE
= 0x0; /* No output enable for SRST*/
2164 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2169 high_direction
= 0x0c;
2171 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2173 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2177 high_output
|= nTRST
;
2180 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2182 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2186 high_output
|= nSRST
;
2189 /* initialize high port */
2190 buf
[0] = 0x82; /* command "set data bits high byte" */
2191 buf
[1] = high_output
; /* value */
2192 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2193 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2195 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2197 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2198 return ERROR_JTAG_INIT_FAILED
;
2205 static int jtagkey_init(void)
2211 low_direction
= 0x1b;
2213 /* initialize low byte for jtag */
2214 buf
[0] = 0x80; /* command "set data bits low byte" */
2215 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2216 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2217 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2219 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2221 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2222 return ERROR_JTAG_INIT_FAILED
;
2225 if (strcmp(layout
->name
, "jtagkey") == 0)
2232 else if ( (strcmp(layout
->name
, "jtagkey_prototype_v1") == 0)
2233 || (strcmp(layout
->name
, "oocdlink") == 0) )
2242 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2247 high_direction
= 0x0f;
2249 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2251 high_output
|= nTRSTnOE
;
2252 high_output
&= ~nTRST
;
2256 high_output
&= ~nTRSTnOE
;
2257 high_output
|= nTRST
;
2260 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2262 high_output
&= ~nSRSTnOE
;
2263 high_output
|= nSRST
;
2267 high_output
|= nSRSTnOE
;
2268 high_output
&= ~nSRST
;
2271 /* initialize high port */
2272 buf
[0] = 0x82; /* command "set data bits high byte" */
2273 buf
[1] = high_output
; /* value */
2274 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2275 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2277 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2279 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2280 return ERROR_JTAG_INIT_FAILED
;
2287 static int olimex_jtag_init(void)
2293 low_direction
= 0x1b;
2295 /* initialize low byte for jtag */
2296 buf
[0] = 0x80; /* command "set data bits low byte" */
2297 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2298 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2299 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2301 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2303 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2304 return ERROR_JTAG_INIT_FAILED
;
2310 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2313 high_direction
= 0x0f;
2315 if (jtag_reset_config
& RESET_TRST_OPEN_DRAIN
)
2317 high_output
|= nTRSTnOE
;
2318 high_output
&= ~nTRST
;
2322 high_output
&= ~nTRSTnOE
;
2323 high_output
|= nTRST
;
2326 if (jtag_reset_config
& RESET_SRST_PUSH_PULL
)
2328 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2332 high_output
&= ~nSRST
;
2335 /* turn red LED on */
2336 high_output
|= 0x08;
2338 /* initialize high port */
2339 buf
[0] = 0x82; /* command "set data bits high byte" */
2340 buf
[1] = high_output
; /* value */
2341 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2342 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2344 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2346 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2347 return ERROR_JTAG_INIT_FAILED
;
2354 static int flyswatter_init(void)
2360 low_direction
= 0xfb;
2362 /* initialize low byte for jtag */
2363 buf
[0] = 0x80; /* command "set data bits low byte" */
2364 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2365 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2366 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2368 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2370 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2371 return ERROR_JTAG_INIT_FAILED
;
2375 nTRSTnOE
= 0x0; /* not output enable for nTRST */
2377 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2380 high_direction
= 0x0c;
2382 /* turn red LED3 on, LED2 off */
2383 high_output
|= 0x08;
2385 /* initialize high port */
2386 buf
[0] = 0x82; /* command "set data bits high byte" */
2387 buf
[1] = high_output
; /* value */
2388 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2389 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2391 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2393 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2394 return ERROR_JTAG_INIT_FAILED
;
2401 static int turtle_init(void)
2407 low_direction
= 0x5b;
2409 /* initialize low byte for jtag */
2410 buf
[0] = 0x80; /* command "set data bits low byte" */
2411 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2412 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2413 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2415 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2417 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2418 return ERROR_JTAG_INIT_FAILED
;
2424 high_direction
= 0x0C;
2426 /* initialize high port */
2427 buf
[0] = 0x82; /* command "set data bits high byte" */
2428 buf
[1] = high_output
;
2429 buf
[2] = high_direction
;
2430 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2432 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2434 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2435 return ERROR_JTAG_INIT_FAILED
;
2442 static int comstick_init(void)
2448 low_direction
= 0x0b;
2450 /* initialize low byte for jtag */
2451 buf
[0] = 0x80; /* command "set data bits low byte" */
2452 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2453 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2454 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2456 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2458 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2459 return ERROR_JTAG_INIT_FAILED
;
2463 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2465 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2468 high_direction
= 0x03;
2470 /* initialize high port */
2471 buf
[0] = 0x82; /* command "set data bits high byte" */
2472 buf
[1] = high_output
;
2473 buf
[2] = high_direction
;
2474 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2476 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2478 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2479 return ERROR_JTAG_INIT_FAILED
;
2486 static int stm32stick_init(void)
2492 low_direction
= 0x8b;
2494 /* initialize low byte for jtag */
2495 buf
[0] = 0x80; /* command "set data bits low byte" */
2496 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2497 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2498 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2500 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2502 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2503 return ERROR_JTAG_INIT_FAILED
;
2507 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2509 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2512 high_direction
= 0x03;
2514 /* initialize high port */
2515 buf
[0] = 0x82; /* command "set data bits high byte" */
2516 buf
[1] = high_output
;
2517 buf
[2] = high_direction
;
2518 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2520 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2522 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2523 return ERROR_JTAG_INIT_FAILED
;
2530 static int sheevaplug_init(void)
2536 low_direction
= 0x1b;
2538 /* initialize low byte for jtag */
2539 buf
[0] = 0x80; /* command "set data bits low byte" */
2540 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2541 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2542 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2544 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2546 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2547 return ERROR_JTAG_INIT_FAILED
;
2556 high_direction
= 0x0f;
2558 /* nTRST is always push-pull */
2559 high_output
&= ~nTRSTnOE
;
2560 high_output
|= nTRST
;
2562 /* nSRST is always open-drain */
2563 high_output
|= nSRSTnOE
;
2564 high_output
&= ~nSRST
;
2566 /* initialize high port */
2567 buf
[0] = 0x82; /* command "set data bits high byte" */
2568 buf
[1] = high_output
; /* value */
2569 buf
[2] = high_direction
; /* all outputs - xRST */
2570 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2572 if (((ft2232_write(buf
, 3, &bytes_written
)) != ERROR_OK
) || (bytes_written
!= 3))
2574 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2575 return ERROR_JTAG_INIT_FAILED
;
2581 static int cortino_jtag_init(void)
2587 low_direction
= 0x1b;
2589 /* initialize low byte for jtag */
2590 buf
[0] = 0x80; /* command "set data bits low byte" */
2591 buf
[1] = low_output
; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2592 buf
[2] = low_direction
; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2593 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2595 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2597 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2598 return ERROR_JTAG_INIT_FAILED
;
2602 nTRSTnOE
= 0x00; /* no output enable for nTRST */
2604 nSRSTnOE
= 0x00; /* no output enable for nSRST */
2607 high_direction
= 0x03;
2609 /* initialize high port */
2610 buf
[0] = 0x82; /* command "set data bits high byte" */
2611 buf
[1] = high_output
;
2612 buf
[2] = high_direction
;
2613 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2615 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) )
2617 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2618 return ERROR_JTAG_INIT_FAILED
;
2624 static void olimex_jtag_blink(void)
2626 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2627 * ACBUS3 is bit 3 of the GPIOH port
2629 if (high_output
& 0x08)
2631 /* set port pin high */
2632 high_output
&= 0x07;
2636 /* set port pin low */
2637 high_output
|= 0x08;
2640 buffer_write( 0x82 );
2641 buffer_write( high_output
);
2642 buffer_write( high_direction
);
2646 static void flyswatter_jtag_blink(void)
2649 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2651 high_output
^= 0x0c;
2653 buffer_write( 0x82 );
2654 buffer_write( high_output
);
2655 buffer_write( high_direction
);
2659 static void turtle_jtag_blink(void)
2662 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2664 if (high_output
& 0x08)
2673 buffer_write( 0x82 );
2674 buffer_write( high_output
);
2675 buffer_write( high_direction
);
2679 static int ft2232_quit(void)
2681 #if BUILD_FT2232_FTD2XX == 1
2684 status
= FT_Close(ftdih
);
2685 #elif BUILD_FT2232_LIBFTDI == 1
2686 ftdi_usb_close(&ftdic
);
2688 ftdi_deinit(&ftdic
);
2691 free(ft2232_buffer
);
2692 ft2232_buffer
= NULL
;
2698 static int ft2232_handle_device_desc_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2704 ft2232_device_desc
= strdup(args
[0]);
2705 cp
= strchr( ft2232_device_desc
, 0 );
2706 // under Win32, the FTD2XX driver appends an "A" to the end
2707 // of the description, this examines the given desc
2708 // and creates the 'missing' _A or non_A variable.
2709 if( (cp
[-1] == 'A') && (cp
[-2]==' ') ){
2710 // it was, so make this the "A" version.
2711 ft2232_device_desc_A
= ft2232_device_desc
;
2712 // and *CREATE* the non-A version.
2713 strcpy( buf
, ft2232_device_desc
);
2714 cp
= strchr( buf
, 0 );
2716 ft2232_device_desc
= strdup( buf
);
2718 // <space>A not defined
2720 sprintf( buf
, "%s A", ft2232_device_desc
);
2721 ft2232_device_desc_A
= strdup( buf
);
2726 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2733 static int ft2232_handle_serial_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2737 ft2232_serial
= strdup(args
[0]);
2741 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2748 static int ft2232_handle_layout_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2753 ft2232_layout
= malloc(strlen(args
[0]) + 1);
2754 strcpy(ft2232_layout
, args
[0]);
2760 static int ft2232_handle_vid_pid_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2764 if (argc
> MAX_USB_IDS
* 2)
2766 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2767 "(maximum is %d pairs)", MAX_USB_IDS
);
2768 argc
= MAX_USB_IDS
* 2;
2770 if ( argc
< 2 || (argc
& 1) )
2772 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2777 for (i
= 0; i
+ 1 < argc
; i
+= 2)
2779 ft2232_vid
[i
>> 1] = strtol(args
[i
], NULL
, 0);
2780 ft2232_pid
[i
>> 1] = strtol(args
[i
+ 1], NULL
, 0);
2784 * Explicitly terminate, in case there are multiples instances of
2787 ft2232_vid
[i
>> 1] = ft2232_pid
[i
>> 1] = 0;
2793 static int ft2232_handle_latency_command(struct command_context_s
* cmd_ctx
, char* cmd
, char** args
, int argc
)
2797 ft2232_latency
= atoi(args
[0]);
2801 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2808 static int ft2232_stableclocks(int num_cycles
, jtag_command_t
* cmd
)
2812 /* 7 bits of either ones or zeros. */
2813 u8 tms
= (tap_get_state() == TAP_RESET
? 0x7F : 0x00);
2815 while (num_cycles
> 0)
2817 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2818 * at most 7 bits per invocation. Here we invoke it potentially
2821 int bitcount_per_command
= (num_cycles
> 7) ? 7 : num_cycles
;
2823 if (ft2232_buffer_size
+ 3 >= FT2232_BUFFER_SIZE
)
2825 if (ft2232_send_and_recv(first_unsent
, cmd
) != ERROR_OK
)
2826 retval
= ERROR_JTAG_QUEUE_FAILED
;
2831 /* there are no state transitions in this code, so omit state tracking */
2833 /* command "Clock Data to TMS/CS Pin (no Read)" */
2834 buffer_write( 0x4b );
2837 buffer_write( bitcount_per_command
- 1 );
2839 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2840 buffer_write( tms
);
2844 num_cycles
-= bitcount_per_command
;
2851 /* ---------------------------------------------------------------------
2852 * Support for IceBear JTAG adapter from Section5:
2853 * http://section5.ch/icebear
2855 * Author: Sten, debian@sansys-electronic.com
2858 /* Icebear pin layout
2860 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2861 * GND GND | 4 3| n.c.
2862 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2863 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2864 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2865 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2866 * ADBUS2 TDO |14 13| GND GND
2868 * ADBUS0 O L TCK ACBUS0 GND
2869 * ADBUS1 O L TDI ACBUS1 GND
2870 * ADBUS2 I TDO ACBUS2 n.c.
2871 * ADBUS3 O H TMS ACBUS3 n.c.
2877 static int icebear_jtag_init(void) {
2881 low_direction
= 0x0b; /* output: TCK TDI TMS; input: TDO */
2882 low_output
= 0x08; /* high: TMS; low: TCK TDI */
2886 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0) {
2887 low_direction
&= ~nTRST
; /* nTRST high impedance */
2890 low_direction
|= nTRST
;
2891 low_output
|= nTRST
;
2894 low_direction
|= nSRST
;
2895 low_output
|= nSRST
;
2897 /* initialize low byte for jtag */
2898 buf
[0] = 0x80; /* command "set data bits low byte" */
2899 buf
[1] = low_output
;
2900 buf
[2] = low_direction
;
2901 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2903 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2904 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2905 return ERROR_JTAG_INIT_FAILED
;
2909 high_direction
= 0x00;
2912 /* initialize high port */
2913 buf
[0] = 0x82; /* command "set data bits high byte" */
2914 buf
[1] = high_output
; /* value */
2915 buf
[2] = high_direction
; /* all outputs (xRST and xRSTnOE) */
2916 LOG_DEBUG("%2.2x %2.2x %2.2x", buf
[0], buf
[1], buf
[2]);
2918 if ( ( ( ft2232_write(buf
, 3, &bytes_written
) ) != ERROR_OK
) || (bytes_written
!= 3) ) {
2919 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2920 return ERROR_JTAG_INIT_FAILED
;
2926 static void icebear_jtag_reset(int trst
, int srst
) {
2929 low_direction
|= nTRST
;
2930 low_output
&= ~nTRST
;
2932 else if (trst
== 0) {
2933 if ((jtag_reset_config
& RESET_TRST_OPEN_DRAIN
) != 0)
2934 low_direction
&= ~nTRST
;
2936 low_output
|= nTRST
;
2940 low_output
&= ~nSRST
;
2942 else if (srst
== 0) {
2943 low_output
|= nSRST
;
2946 /* command "set data bits low byte" */
2947 buffer_write( 0x80 );
2948 buffer_write( low_output
);
2949 buffer_write( low_direction
);
2951 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)