initial "transport" framework
[openocd.git] / src / jtag / drivers / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2009 by Øyvind Harboe *
3 * Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * *
5 * Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com *
6 * Dick Hollenbeck <dick@softplc.com> *
7 * *
8 * Copyright (C) 2004, 2006 by Dominic Rath *
9 * Dominic.Rath@gmx.de *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29
30 /**
31 * @file
32 * JTAG adapters based on the FT2232 full and high speed USB parts are
33 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
34 * are discrete, but development boards may integrate them as alternatives
35 * to more capable (and expensive) third party JTAG pods.
36 *
37 * JTAG uses only one of the two communications channels ("MPSSE engines")
38 * on these devices. Adapters based on FT4232 parts have four ports/channels
39 * (A/B/C/D), instead of just two (A/B).
40 *
41 * Especially on development boards integrating one of these chips (as
42 * opposed to discrete pods/dongles), the additional channels can be used
43 * for a variety of purposes, but OpenOCD only uses one channel at a time.
44 *
45 * - As a USB-to-serial adapter for the target's console UART ...
46 * which may be able to support ROM boot loaders that load initial
47 * firmware images to flash (or SRAM).
48 *
49 * - On systems which support ARM's SWD in addition to JTAG, or instead
50 * of it, that second port can be used for reading SWV/SWO trace data.
51 *
52 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
53 *
54 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
55 * request/response interactions involve round trips over the USB link.
56 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
57 * can for example poll quickly for a status change (usually taking on the
58 * order of microseconds not milliseconds) before beginning a queued
59 * transaction which require the previous one to have completed.
60 *
61 * There are dozens of adapters of this type, differing in details which
62 * this driver needs to understand. Those "layout" details are required
63 * as part of FT2232 driver configuration.
64 *
65 * This code uses information contained in the MPSSE specification which was
66 * found here:
67 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
68 * Hereafter this is called the "MPSSE Spec".
69 *
70 * The datasheet for the ftdichip.com's FT2232D part is here:
71 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
72 *
73 * Also note the issue with code 0x4b (clock data to TMS) noted in
74 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
75 * which can affect longer JTAG state paths.
76 */
77
78 #ifdef HAVE_CONFIG_H
79 #include "config.h"
80 #endif
81
82 /* project specific includes */
83 #include <jtag/interface.h>
84 #include <jtag/transport.h>
85 #include <helper/time_support.h>
86
87 #if IS_CYGWIN == 1
88 #include <windows.h>
89 #endif
90
91 #include <assert.h>
92
93 #if (BUILD_FT2232_FTD2XX == 1 && BUILD_FT2232_LIBFTDI == 1)
94 #error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive"
95 #elif (BUILD_FT2232_FTD2XX != 1 && BUILD_FT2232_LIBFTDI != 1)
96 #error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen"
97 #endif
98
99 /* FT2232 access library includes */
100 #if BUILD_FT2232_FTD2XX == 1
101 #include <ftd2xx.h>
102
103 enum ftdi_interface
104 {
105 INTERFACE_ANY = 0,
106 INTERFACE_A = 1,
107 INTERFACE_B = 2,
108 INTERFACE_C = 3,
109 INTERFACE_D = 4
110 };
111
112 #elif BUILD_FT2232_LIBFTDI == 1
113 #include <ftdi.h>
114 #endif
115
116 /* max TCK for the high speed devices 30000 kHz */
117 #define FTDI_2232H_4232H_MAX_TCK 30000
118 /* max TCK for the full speed devices 6000 kHz */
119 #define FTDI_2232C_MAX_TCK 6000
120 /* this speed value tells that RTCK is requested */
121 #define RTCK_SPEED -1
122
123 /*
124 * On my Athlon XP 1900+ EHCI host with FT2232H JTAG dongle I get read timeout
125 * errors with a retry count of 100. Increasing it solves the problem for me.
126 * - Dimitar
127 *
128 * FIXME There's likely an issue with the usb_read_timeout from libftdi.
129 * Fix that (libusb? kernel? libftdi? here?) and restore the retry count
130 * to something sane.
131 */
132 #define LIBFTDI_READ_RETRY_COUNT 2000
133
134 #ifndef BUILD_FT2232_HIGHSPEED
135 #if BUILD_FT2232_FTD2XX == 1
136 enum { FT_DEVICE_2232H = 6, FT_DEVICE_4232H };
137 #elif BUILD_FT2232_LIBFTDI == 1
138 enum { TYPE_2232H = 4, TYPE_4232H = 5 };
139 #endif
140 #endif
141
142 /**
143 * Send out \a num_cycles on the TCK line while the TAP(s) are in a
144 * stable state. Calling code must ensure that current state is stable,
145 * that verification is not done in here.
146 *
147 * @param num_cycles The number of clocks cycles to send.
148 * @param cmd The command to send.
149 *
150 * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
151 */
152 static int ft2232_stableclocks(int num_cycles, struct jtag_command* cmd);
153
154 static char * ft2232_device_desc_A = NULL;
155 static char* ft2232_device_desc = NULL;
156 static char* ft2232_serial = NULL;
157 static uint8_t ft2232_latency = 2;
158 static unsigned ft2232_max_tck = FTDI_2232C_MAX_TCK;
159
160 #define MAX_USB_IDS 8
161 /* vid = pid = 0 marks the end of the list */
162 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
163 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
164
165 struct ft2232_layout {
166 char* name;
167 int (*init)(void);
168 void (*reset)(int trst, int srst);
169 void (*blink)(void);
170 int channel;
171 const char **transports;
172 };
173
174 /* init procedures for supported layouts */
175 static int usbjtag_init(void);
176 static int jtagkey_init(void);
177 static int lm3s811_jtag_init(void);
178 static int icdi_jtag_init(void);
179 static int olimex_jtag_init(void);
180 static int flyswatter_init(void);
181 static int turtle_init(void);
182 static int comstick_init(void);
183 static int stm32stick_init(void);
184 static int axm0432_jtag_init(void);
185 static int sheevaplug_init(void);
186 static int icebear_jtag_init(void);
187 static int cortino_jtag_init(void);
188 static int signalyzer_init(void);
189 static int signalyzer_h_init(void);
190 static int ktlink_init(void);
191 static int redbee_init(void);
192
193 /* reset procedures for supported layouts */
194 static void ftx23_reset(int trst, int srst);
195 static void jtagkey_reset(int trst, int srst);
196 static void olimex_jtag_reset(int trst, int srst);
197 static void flyswatter_reset(int trst, int srst);
198 static void turtle_reset(int trst, int srst);
199 static void comstick_reset(int trst, int srst);
200 static void stm32stick_reset(int trst, int srst);
201 static void axm0432_jtag_reset(int trst, int srst);
202 static void sheevaplug_reset(int trst, int srst);
203 static void icebear_jtag_reset(int trst, int srst);
204 static void signalyzer_h_reset(int trst, int srst);
205 static void ktlink_reset(int trst, int srst);
206 static void redbee_reset(int trst, int srst);
207
208 /* blink procedures for layouts that support a blinking led */
209 static void olimex_jtag_blink(void);
210 static void flyswatter_jtag_blink(void);
211 static void turtle_jtag_blink(void);
212 static void signalyzer_h_blink(void);
213 static void ktlink_blink(void);
214
215 /* common transport support options */
216 static const char *jtag_only[] = { "jtag", NULL };
217
218
219 //static const char *jtag_and_swd[] = { "jtag", "swd", NULL };
220 #define jtag_and_swd NULL
221
222 static const struct ft2232_layout ft2232_layouts[] =
223 {
224 { .name = "usbjtag",
225 .init = usbjtag_init,
226 .reset = ftx23_reset,
227 },
228 { .name = "jtagkey",
229 .init = jtagkey_init,
230 .reset = jtagkey_reset,
231 },
232 { .name = "jtagkey_prototype_v1",
233 .init = jtagkey_init,
234 .reset = jtagkey_reset,
235 },
236 { .name = "oocdlink",
237 .init = jtagkey_init,
238 .reset = jtagkey_reset,
239 },
240 { .name = "signalyzer",
241 .init = signalyzer_init,
242 .reset = ftx23_reset,
243 },
244 { .name = "evb_lm3s811",
245 .init = lm3s811_jtag_init,
246 .reset = ftx23_reset,
247 .transports = jtag_and_swd,
248 },
249 { .name = "luminary_icdi",
250 .init = icdi_jtag_init,
251 .reset = ftx23_reset,
252 .transports = jtag_and_swd,
253 },
254 { .name = "olimex-jtag",
255 .init = olimex_jtag_init,
256 .reset = olimex_jtag_reset,
257 .blink = olimex_jtag_blink
258 },
259 { .name = "flyswatter",
260 .init = flyswatter_init,
261 .reset = flyswatter_reset,
262 .blink = flyswatter_jtag_blink
263 },
264 { .name = "turtelizer2",
265 .init = turtle_init,
266 .reset = turtle_reset,
267 .blink = turtle_jtag_blink
268 },
269 { .name = "comstick",
270 .init = comstick_init,
271 .reset = comstick_reset,
272 },
273 { .name = "stm32stick",
274 .init = stm32stick_init,
275 .reset = stm32stick_reset,
276 },
277 { .name = "axm0432_jtag",
278 .init = axm0432_jtag_init,
279 .reset = axm0432_jtag_reset,
280 },
281 { .name = "sheevaplug",
282 .init = sheevaplug_init,
283 .reset = sheevaplug_reset,
284 },
285 { .name = "icebear",
286 .init = icebear_jtag_init,
287 .reset = icebear_jtag_reset,
288 },
289 { .name = "cortino",
290 .init = cortino_jtag_init,
291 .reset = comstick_reset,
292 },
293 { .name = "signalyzer-h",
294 .init = signalyzer_h_init,
295 .reset = signalyzer_h_reset,
296 .blink = signalyzer_h_blink
297 },
298 { .name = "ktlink",
299 .init = ktlink_init,
300 .reset = ktlink_reset,
301 .blink = ktlink_blink
302 },
303 { .name = "redbee-econotag",
304 .init = redbee_init,
305 .reset = redbee_reset,
306 },
307 { .name = "redbee-usb",
308 .init = redbee_init,
309 .reset = redbee_reset,
310 .channel = INTERFACE_B,
311 },
312 { .name = NULL, /* END OF TABLE */ },
313 };
314
315 /* bitmask used to drive nTRST; usually a GPIOLx signal */
316 static uint8_t nTRST;
317 static uint8_t nTRSTnOE;
318 /* bitmask used to drive nSRST; usually a GPIOLx signal */
319 static uint8_t nSRST;
320 static uint8_t nSRSTnOE;
321
322 /** the layout being used with this debug session */
323 static const struct ft2232_layout *layout;
324
325 /** default bitmask values ddriven on DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
326 static uint8_t low_output = 0x0;
327 /** default direction bitmask for DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
328 static uint8_t low_direction = 0x0;
329 /** default value bitmask for CBUS GPIOH(0..4) */
330 static uint8_t high_output = 0x0;
331 /** default direction bitmask for CBUS GPIOH(0..4) */
332 static uint8_t high_direction = 0x0;
333
334 #if BUILD_FT2232_FTD2XX == 1
335 static FT_HANDLE ftdih = NULL;
336 static FT_DEVICE ftdi_device = 0;
337 #elif BUILD_FT2232_LIBFTDI == 1
338 static struct ftdi_context ftdic;
339 static enum ftdi_chip_type ftdi_device;
340 #endif
341
342 static struct jtag_command* first_unsent; /* next command that has to be sent */
343 static int require_send;
344
345 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
346
347 "There is a significant difference between libftdi and libftd2xx. The latter
348 one allows to schedule up to 64*64 bytes of result data while libftdi fails
349 with more than 4*64. As a consequence, the FT2232 driver is forced to
350 perform around 16x more USB transactions for long command streams with TDO
351 capture when running with libftdi."
352
353 No idea how we get
354 #define FT2232_BUFFER_SIZE 131072
355 a comment would have been nice.
356 */
357
358 #define FT2232_BUFFER_SIZE 131072
359
360 static uint8_t* ft2232_buffer = NULL;
361 static int ft2232_buffer_size = 0;
362 static int ft2232_read_pointer = 0;
363 static int ft2232_expect_read = 0;
364
365 /**
366 * Function buffer_write
367 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
368 * @param val is the byte to send.
369 */
370 static inline void buffer_write(uint8_t val)
371 {
372 assert(ft2232_buffer);
373 assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
374 ft2232_buffer[ft2232_buffer_size++] = val;
375 }
376
377 /**
378 * Function buffer_read
379 * returns a byte from the byte buffer.
380 */
381 static inline uint8_t buffer_read(void)
382 {
383 assert(ft2232_buffer);
384 assert(ft2232_read_pointer < ft2232_buffer_size);
385 return ft2232_buffer[ft2232_read_pointer++];
386 }
387
388 /**
389 * Clocks out \a bit_count bits on the TMS line, starting with the least
390 * significant bit of tms_bits and progressing to more significant bits.
391 * Rigorous state transition logging is done here via tap_set_state().
392 *
393 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
394 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
395 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
396 * is often used for this, 0x4b.
397 *
398 * @param tms_bits Holds the sequence of bits to send.
399 * @param tms_count Tells how many bits in the sequence.
400 * @param tdi_bit A single bit to pass on to TDI before the first TCK
401 * cycle and held static for the duration of TMS clocking.
402 *
403 * See the MPSSE spec referenced above.
404 */
405 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
406 {
407 uint8_t tms_byte;
408 int i;
409 int tms_ndx; /* bit index into tms_byte */
410
411 assert(tms_count > 0);
412
413 DEBUG_JTAG_IO("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d",
414 mpsse_cmd, tms_bits, tms_count);
415
416 for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
417 {
418 bool bit = tms_bits & 1;
419
420 if (bit)
421 tms_byte |= (1 << tms_ndx);
422
423 /* always do state transitions in public view */
424 tap_set_state(tap_state_transition(tap_get_state(), bit));
425
426 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
427 also increment.
428 */
429 ++tms_ndx;
430
431 if (tms_ndx == 7 || i == tms_count-1)
432 {
433 buffer_write(mpsse_cmd);
434 buffer_write(tms_ndx - 1);
435
436 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
437 TMS/CS and is held static for the duration of TMS/CS clocking.
438 */
439 buffer_write(tms_byte | (tdi_bit << 7));
440 }
441 }
442 }
443
444 /**
445 * Function get_tms_buffer_requirements
446 * returns what clock_tms() will consume if called with
447 * same \a bit_count.
448 */
449 static inline int get_tms_buffer_requirements(int bit_count)
450 {
451 return ((bit_count + 6)/7) * 3;
452 }
453
454 /**
455 * Function move_to_state
456 * moves the TAP controller from the current state to a
457 * \a goal_state through a path given by tap_get_tms_path(). State transition
458 * logging is performed by delegation to clock_tms().
459 *
460 * @param goal_state is the destination state for the move.
461 */
462 static void move_to_state(tap_state_t goal_state)
463 {
464 tap_state_t start_state = tap_get_state();
465
466 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
467 lookup of the required TMS pattern to move to this state from the
468 start state.
469 */
470
471 /* do the 2 lookups */
472 int tms_bits = tap_get_tms_path(start_state, goal_state);
473 int tms_count = tap_get_tms_path_len(start_state, goal_state);
474
475 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
476
477 clock_tms(0x4b, tms_bits, tms_count, 0);
478 }
479
480 static int ft2232_write(uint8_t* buf, int size, uint32_t* bytes_written)
481 {
482 #if BUILD_FT2232_FTD2XX == 1
483 FT_STATUS status;
484 DWORD dw_bytes_written;
485 if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
486 {
487 *bytes_written = dw_bytes_written;
488 LOG_ERROR("FT_Write returned: %lu", status);
489 return ERROR_JTAG_DEVICE_ERROR;
490 }
491 else
492 {
493 *bytes_written = dw_bytes_written;
494 }
495 #elif BUILD_FT2232_LIBFTDI == 1
496 int retval;
497 if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
498 {
499 *bytes_written = 0;
500 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
501 return ERROR_JTAG_DEVICE_ERROR;
502 }
503 else
504 {
505 *bytes_written = retval;
506 }
507 #endif
508
509 if (*bytes_written != (uint32_t)size)
510 {
511 return ERROR_JTAG_DEVICE_ERROR;
512 }
513
514 return ERROR_OK;
515 }
516
517 static int ft2232_read(uint8_t* buf, uint32_t size, uint32_t* bytes_read)
518 {
519 #if BUILD_FT2232_FTD2XX == 1
520 DWORD dw_bytes_read;
521 FT_STATUS status;
522 int timeout = 5;
523 *bytes_read = 0;
524
525 while ((*bytes_read < size) && timeout--)
526 {
527 if ((status = FT_Read(ftdih, buf + *bytes_read, size -
528 *bytes_read, &dw_bytes_read)) != FT_OK)
529 {
530 *bytes_read = 0;
531 LOG_ERROR("FT_Read returned: %lu", status);
532 return ERROR_JTAG_DEVICE_ERROR;
533 }
534 *bytes_read += dw_bytes_read;
535 }
536
537 #elif BUILD_FT2232_LIBFTDI == 1
538 int retval;
539 int timeout = LIBFTDI_READ_RETRY_COUNT;
540 *bytes_read = 0;
541
542 while ((*bytes_read < size) && timeout--)
543 {
544 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
545 {
546 *bytes_read = 0;
547 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
548 return ERROR_JTAG_DEVICE_ERROR;
549 }
550 *bytes_read += retval;
551 }
552
553 #endif
554
555 if (*bytes_read < size)
556 {
557 LOG_ERROR("couldn't read enough bytes from "
558 "FT2232 device (%i < %i)",
559 (unsigned)*bytes_read,
560 (unsigned)size);
561 return ERROR_JTAG_DEVICE_ERROR;
562 }
563
564 return ERROR_OK;
565 }
566
567 static bool ft2232_device_is_highspeed(void)
568 {
569 #if BUILD_FT2232_FTD2XX == 1
570 return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H);
571 #elif BUILD_FT2232_LIBFTDI == 1
572 return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H);
573 #endif
574 }
575
576 /*
577 * Commands that only apply to the FT2232H and FT4232H devices.
578 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
579 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
580 */
581
582 static int ft2232h_ft4232h_adaptive_clocking(bool enable)
583 {
584 uint8_t buf = enable ? 0x96 : 0x97;
585 LOG_DEBUG("%2.2x", buf);
586
587 uint32_t bytes_written;
588 int retval;
589
590 if ((retval = ft2232_write(&buf, sizeof(buf), &bytes_written)) != ERROR_OK)
591 {
592 LOG_ERROR("couldn't write command to %s adaptive clocking"
593 , enable ? "enable" : "disable");
594 return retval;
595 }
596
597 return ERROR_OK;
598 }
599
600 /**
601 * Enable/disable the clk divide by 5 of the 60MHz master clock.
602 * This result in a JTAG clock speed range of 91.553Hz-6MHz
603 * respective 457.763Hz-30MHz.
604 */
605 static int ft2232h_ft4232h_clk_divide_by_5(bool enable)
606 {
607 uint32_t bytes_written;
608 uint8_t buf = enable ? 0x8b : 0x8a;
609
610 if (ft2232_write(&buf, sizeof(buf), &bytes_written) != ERROR_OK)
611 {
612 LOG_ERROR("couldn't write command to %s clk divide by 5"
613 , enable ? "enable" : "disable");
614 return ERROR_JTAG_INIT_FAILED;
615 }
616 ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_2232H_4232H_MAX_TCK;
617 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
618
619 return ERROR_OK;
620 }
621
622 static int ft2232_speed(int speed)
623 {
624 uint8_t buf[3];
625 int retval;
626 uint32_t bytes_written;
627
628 retval = ERROR_OK;
629 bool enable_adaptive_clocking = (RTCK_SPEED == speed);
630 if (ft2232_device_is_highspeed())
631 retval = ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking);
632 else if (enable_adaptive_clocking)
633 {
634 LOG_ERROR("ft2232 device %lu does not support RTCK"
635 , (long unsigned int)ftdi_device);
636 return ERROR_FAIL;
637 }
638
639 if ((enable_adaptive_clocking) || (ERROR_OK != retval))
640 return retval;
641
642 buf[0] = 0x86; /* command "set divisor" */
643 buf[1] = speed & 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
644 buf[2] = (speed >> 8) & 0xff; /* valueH */
645
646 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
647 if ((retval = ft2232_write(buf, sizeof(buf), &bytes_written)) != ERROR_OK)
648 {
649 LOG_ERROR("couldn't set FT2232 TCK speed");
650 return retval;
651 }
652
653 return ERROR_OK;
654 }
655
656 static int ft2232_speed_div(int speed, int* khz)
657 {
658 /* Take a look in the FT2232 manual,
659 * AN2232C-01 Command Processor for
660 * MPSSE and MCU Host Bus. Chapter 3.8 */
661
662 *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
663
664 return ERROR_OK;
665 }
666
667 static int ft2232_khz(int khz, int* jtag_speed)
668 {
669 if (khz == 0)
670 {
671 if (ft2232_device_is_highspeed())
672 {
673 *jtag_speed = RTCK_SPEED;
674 return ERROR_OK;
675 }
676 else
677 {
678 LOG_DEBUG("RCLK not supported");
679 return ERROR_FAIL;
680 }
681 }
682
683 /* Take a look in the FT2232 manual,
684 * AN2232C-01 Command Processor for
685 * MPSSE and MCU Host Bus. Chapter 3.8
686 *
687 * We will calc here with a multiplier
688 * of 10 for better rounding later. */
689
690 /* Calc speed, (ft2232_max_tck / khz) - 1 */
691 /* Use 65000 for better rounding */
692 *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
693
694 /* Add 0.9 for rounding */
695 *jtag_speed += 9;
696
697 /* Calc real speed */
698 *jtag_speed = *jtag_speed / 10;
699
700 /* Check if speed is greater than 0 */
701 if (*jtag_speed < 0)
702 {
703 *jtag_speed = 0;
704 }
705
706 /* Check max value */
707 if (*jtag_speed > 0xFFFF)
708 {
709 *jtag_speed = 0xFFFF;
710 }
711
712 return ERROR_OK;
713 }
714
715 static void ft2232_end_state(tap_state_t state)
716 {
717 if (tap_is_state_stable(state))
718 tap_set_end_state(state);
719 else
720 {
721 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
722 exit(-1);
723 }
724 }
725
726 static void ft2232_read_scan(enum scan_type type, uint8_t* buffer, int scan_size)
727 {
728 int num_bytes = (scan_size + 7) / 8;
729 int bits_left = scan_size;
730 int cur_byte = 0;
731
732 while (num_bytes-- > 1)
733 {
734 buffer[cur_byte++] = buffer_read();
735 bits_left -= 8;
736 }
737
738 buffer[cur_byte] = 0x0;
739
740 /* There is one more partial byte left from the clock data in/out instructions */
741 if (bits_left > 1)
742 {
743 buffer[cur_byte] = buffer_read() >> 1;
744 }
745 /* 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 */
746 buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
747 }
748
749 static void ft2232_debug_dump_buffer(void)
750 {
751 int i;
752 char line[256];
753 char* line_p = line;
754
755 for (i = 0; i < ft2232_buffer_size; i++)
756 {
757 line_p += snprintf(line_p, sizeof(line) - (line_p - line), "%2.2x ", ft2232_buffer[i]);
758 if (i % 16 == 15)
759 {
760 LOG_DEBUG("%s", line);
761 line_p = line;
762 }
763 }
764
765 if (line_p != line)
766 LOG_DEBUG("%s", line);
767 }
768
769 static int ft2232_send_and_recv(struct jtag_command* first, struct jtag_command* last)
770 {
771 struct jtag_command* cmd;
772 uint8_t* buffer;
773 int scan_size;
774 enum scan_type type;
775 int retval;
776 uint32_t bytes_written = 0;
777 uint32_t bytes_read = 0;
778
779 #ifdef _DEBUG_USB_IO_
780 struct timeval start, inter, inter2, end;
781 struct timeval d_inter, d_inter2, d_end;
782 #endif
783
784 #ifdef _DEBUG_USB_COMMS_
785 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
786 ft2232_debug_dump_buffer();
787 #endif
788
789 #ifdef _DEBUG_USB_IO_
790 gettimeofday(&start, NULL);
791 #endif
792
793 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
794 {
795 LOG_ERROR("couldn't write MPSSE commands to FT2232");
796 return retval;
797 }
798
799 #ifdef _DEBUG_USB_IO_
800 gettimeofday(&inter, NULL);
801 #endif
802
803 if (ft2232_expect_read)
804 {
805 /* FIXME this "timeout" is never changed ... */
806 int timeout = LIBFTDI_READ_RETRY_COUNT;
807 ft2232_buffer_size = 0;
808
809 #ifdef _DEBUG_USB_IO_
810 gettimeofday(&inter2, NULL);
811 #endif
812
813 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
814 {
815 LOG_ERROR("couldn't read from FT2232");
816 return retval;
817 }
818
819 #ifdef _DEBUG_USB_IO_
820 gettimeofday(&end, NULL);
821
822 timeval_subtract(&d_inter, &inter, &start);
823 timeval_subtract(&d_inter2, &inter2, &start);
824 timeval_subtract(&d_end, &end, &start);
825
826 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
827 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
828 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
829 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
830 #endif
831
832 ft2232_buffer_size = bytes_read;
833
834 if (ft2232_expect_read != ft2232_buffer_size)
835 {
836 LOG_ERROR("ft2232_expect_read (%i) != "
837 "ft2232_buffer_size (%i) "
838 "(%i retries)",
839 ft2232_expect_read,
840 ft2232_buffer_size,
841 LIBFTDI_READ_RETRY_COUNT - timeout);
842 ft2232_debug_dump_buffer();
843
844 exit(-1);
845 }
846
847 #ifdef _DEBUG_USB_COMMS_
848 LOG_DEBUG("read buffer (%i retries): %i bytes",
849 LIBFTDI_READ_RETRY_COUNT - timeout,
850 ft2232_buffer_size);
851 ft2232_debug_dump_buffer();
852 #endif
853 }
854
855 ft2232_expect_read = 0;
856 ft2232_read_pointer = 0;
857
858 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
859 * that wasn't handled by a caller-provided error handler
860 */
861 retval = ERROR_OK;
862
863 cmd = first;
864 while (cmd != last)
865 {
866 switch (cmd->type)
867 {
868 case JTAG_SCAN:
869 type = jtag_scan_type(cmd->cmd.scan);
870 if (type != SCAN_OUT)
871 {
872 scan_size = jtag_scan_size(cmd->cmd.scan);
873 buffer = calloc(DIV_ROUND_UP(scan_size, 8), 1);
874 ft2232_read_scan(type, buffer, scan_size);
875 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
876 retval = ERROR_JTAG_QUEUE_FAILED;
877 free(buffer);
878 }
879 break;
880
881 default:
882 break;
883 }
884
885 cmd = cmd->next;
886 }
887
888 ft2232_buffer_size = 0;
889
890 return retval;
891 }
892
893 /**
894 * Function ft2232_add_pathmove
895 * moves the TAP controller from the current state to a new state through the
896 * given path, where path is an array of tap_state_t's.
897 *
898 * @param path is an array of tap_stat_t which gives the states to traverse through
899 * ending with the last state at path[num_states-1]
900 * @param num_states is the count of state steps to move through
901 */
902 static void ft2232_add_pathmove(tap_state_t* path, int num_states)
903 {
904 int state_count = 0;
905
906 assert((unsigned) num_states <= 32u); /* tms_bits only holds 32 bits */
907
908 DEBUG_JTAG_IO("-");
909
910 /* this loop verifies that the path is legal and logs each state in the path */
911 while (num_states)
912 {
913 unsigned char tms_byte = 0; /* zero this on each MPSSE batch */
914 int bit_count = 0;
915 int num_states_batch = num_states > 7 ? 7 : num_states;
916
917 /* command "Clock Data to TMS/CS Pin (no Read)" */
918 buffer_write(0x4b);
919
920 /* number of states remaining */
921 buffer_write(num_states_batch - 1);
922
923 while (num_states_batch--) {
924 /* either TMS=0 or TMS=1 must work ... */
925 if (tap_state_transition(tap_get_state(), false)
926 == path[state_count])
927 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
928 else if (tap_state_transition(tap_get_state(), true)
929 == path[state_count])
930 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
931
932 /* ... or else the caller goofed BADLY */
933 else {
934 LOG_ERROR("BUG: %s -> %s isn't a valid "
935 "TAP state transition",
936 tap_state_name(tap_get_state()),
937 tap_state_name(path[state_count]));
938 exit(-1);
939 }
940
941 tap_set_state(path[state_count]);
942 state_count++;
943 num_states--;
944 }
945
946 buffer_write(tms_byte);
947 }
948 tap_set_end_state(tap_get_state());
949 }
950
951 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t* buffer, int scan_size)
952 {
953 int num_bytes = (scan_size + 7) / 8;
954 int bits_left = scan_size;
955 int cur_byte = 0;
956 int last_bit;
957
958 if (!ir_scan)
959 {
960 if (tap_get_state() != TAP_DRSHIFT)
961 {
962 move_to_state(TAP_DRSHIFT);
963 }
964 }
965 else
966 {
967 if (tap_get_state() != TAP_IRSHIFT)
968 {
969 move_to_state(TAP_IRSHIFT);
970 }
971 }
972
973 /* add command for complete bytes */
974 while (num_bytes > 1)
975 {
976 int thisrun_bytes;
977 if (type == SCAN_IO)
978 {
979 /* Clock Data Bytes In and Out LSB First */
980 buffer_write(0x39);
981 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
982 }
983 else if (type == SCAN_OUT)
984 {
985 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
986 buffer_write(0x19);
987 /* LOG_DEBUG("added TDI bytes (o)"); */
988 }
989 else if (type == SCAN_IN)
990 {
991 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
992 buffer_write(0x28);
993 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
994 }
995
996 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
997 num_bytes -= thisrun_bytes;
998
999 buffer_write((uint8_t) (thisrun_bytes - 1));
1000 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1001
1002 if (type != SCAN_IN)
1003 {
1004 /* add complete bytes */
1005 while (thisrun_bytes-- > 0)
1006 {
1007 buffer_write(buffer[cur_byte++]);
1008 bits_left -= 8;
1009 }
1010 }
1011 else /* (type == SCAN_IN) */
1012 {
1013 bits_left -= 8 * (thisrun_bytes);
1014 }
1015 }
1016
1017 /* the most signifcant bit is scanned during TAP movement */
1018 if (type != SCAN_IN)
1019 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1020 else
1021 last_bit = 0;
1022
1023 /* process remaining bits but the last one */
1024 if (bits_left > 1)
1025 {
1026 if (type == SCAN_IO)
1027 {
1028 /* Clock Data Bits In and Out LSB First */
1029 buffer_write(0x3b);
1030 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1031 }
1032 else if (type == SCAN_OUT)
1033 {
1034 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1035 buffer_write(0x1b);
1036 /* LOG_DEBUG("added TDI bits (o)"); */
1037 }
1038 else if (type == SCAN_IN)
1039 {
1040 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1041 buffer_write(0x2a);
1042 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1043 }
1044
1045 buffer_write(bits_left - 2);
1046 if (type != SCAN_IN)
1047 buffer_write(buffer[cur_byte]);
1048 }
1049
1050 if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
1051 || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT)))
1052 {
1053 if (type == SCAN_IO)
1054 {
1055 /* Clock Data Bits In and Out LSB First */
1056 buffer_write(0x3b);
1057 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1058 }
1059 else if (type == SCAN_OUT)
1060 {
1061 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1062 buffer_write(0x1b);
1063 /* LOG_DEBUG("added TDI bits (o)"); */
1064 }
1065 else if (type == SCAN_IN)
1066 {
1067 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1068 buffer_write(0x2a);
1069 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1070 }
1071 buffer_write(0x0);
1072 buffer_write(last_bit);
1073 }
1074 else
1075 {
1076 int tms_bits;
1077 int tms_count;
1078 uint8_t mpsse_cmd;
1079
1080 /* move from Shift-IR/DR to end state */
1081 if (type != SCAN_OUT)
1082 {
1083 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
1084 /* This must be coordinated with the bit shifts in ft2232_read_scan */
1085 tms_bits = 0x01;
1086 tms_count = 2;
1087 /* Clock Data to TMS/CS Pin with Read */
1088 mpsse_cmd = 0x6b;
1089 }
1090 else
1091 {
1092 tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1093 tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1094 /* Clock Data to TMS/CS Pin (no Read) */
1095 mpsse_cmd = 0x4b;
1096 }
1097
1098 DEBUG_JTAG_IO("finish %s", (type == SCAN_OUT) ? "without read" : "via PAUSE");
1099 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1100 }
1101
1102 if (tap_get_state() != tap_get_end_state())
1103 {
1104 move_to_state(tap_get_end_state());
1105 }
1106 }
1107
1108 static int ft2232_large_scan(struct scan_command* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
1109 {
1110 int num_bytes = (scan_size + 7) / 8;
1111 int bits_left = scan_size;
1112 int cur_byte = 0;
1113 int last_bit;
1114 uint8_t* receive_buffer = malloc(DIV_ROUND_UP(scan_size, 8));
1115 uint8_t* receive_pointer = receive_buffer;
1116 uint32_t bytes_written;
1117 uint32_t bytes_read;
1118 int retval;
1119 int thisrun_read = 0;
1120
1121 if (cmd->ir_scan)
1122 {
1123 LOG_ERROR("BUG: large IR scans are not supported");
1124 exit(-1);
1125 }
1126
1127 if (tap_get_state() != TAP_DRSHIFT)
1128 {
1129 move_to_state(TAP_DRSHIFT);
1130 }
1131
1132 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1133 {
1134 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1135 exit(-1);
1136 }
1137 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1138 ft2232_buffer_size, (int)bytes_written);
1139 ft2232_buffer_size = 0;
1140
1141 /* add command for complete bytes */
1142 while (num_bytes > 1)
1143 {
1144 int thisrun_bytes;
1145
1146 if (type == SCAN_IO)
1147 {
1148 /* Clock Data Bytes In and Out LSB First */
1149 buffer_write(0x39);
1150 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1151 }
1152 else if (type == SCAN_OUT)
1153 {
1154 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1155 buffer_write(0x19);
1156 /* LOG_DEBUG("added TDI bytes (o)"); */
1157 }
1158 else if (type == SCAN_IN)
1159 {
1160 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1161 buffer_write(0x28);
1162 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1163 }
1164
1165 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1166 thisrun_read = thisrun_bytes;
1167 num_bytes -= thisrun_bytes;
1168 buffer_write((uint8_t) (thisrun_bytes - 1));
1169 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1170
1171 if (type != SCAN_IN)
1172 {
1173 /* add complete bytes */
1174 while (thisrun_bytes-- > 0)
1175 {
1176 buffer_write(buffer[cur_byte]);
1177 cur_byte++;
1178 bits_left -= 8;
1179 }
1180 }
1181 else /* (type == SCAN_IN) */
1182 {
1183 bits_left -= 8 * (thisrun_bytes);
1184 }
1185
1186 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1187 {
1188 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1189 exit(-1);
1190 }
1191 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1192 ft2232_buffer_size,
1193 (int)bytes_written);
1194 ft2232_buffer_size = 0;
1195
1196 if (type != SCAN_OUT)
1197 {
1198 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1199 {
1200 LOG_ERROR("couldn't read from FT2232");
1201 exit(-1);
1202 }
1203 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1204 thisrun_read,
1205 (int)bytes_read);
1206 receive_pointer += bytes_read;
1207 }
1208 }
1209
1210 thisrun_read = 0;
1211
1212 /* the most signifcant bit is scanned during TAP movement */
1213 if (type != SCAN_IN)
1214 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1215 else
1216 last_bit = 0;
1217
1218 /* process remaining bits but the last one */
1219 if (bits_left > 1)
1220 {
1221 if (type == SCAN_IO)
1222 {
1223 /* Clock Data Bits In and Out LSB First */
1224 buffer_write(0x3b);
1225 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1226 }
1227 else if (type == SCAN_OUT)
1228 {
1229 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1230 buffer_write(0x1b);
1231 /* LOG_DEBUG("added TDI bits (o)"); */
1232 }
1233 else if (type == SCAN_IN)
1234 {
1235 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1236 buffer_write(0x2a);
1237 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1238 }
1239 buffer_write(bits_left - 2);
1240 if (type != SCAN_IN)
1241 buffer_write(buffer[cur_byte]);
1242
1243 if (type != SCAN_OUT)
1244 thisrun_read += 2;
1245 }
1246
1247 if (tap_get_end_state() == TAP_DRSHIFT)
1248 {
1249 if (type == SCAN_IO)
1250 {
1251 /* Clock Data Bits In and Out LSB First */
1252 buffer_write(0x3b);
1253 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1254 }
1255 else if (type == SCAN_OUT)
1256 {
1257 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1258 buffer_write(0x1b);
1259 /* LOG_DEBUG("added TDI bits (o)"); */
1260 }
1261 else if (type == SCAN_IN)
1262 {
1263 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1264 buffer_write(0x2a);
1265 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1266 }
1267 buffer_write(0x0);
1268 buffer_write(last_bit);
1269 }
1270 else
1271 {
1272 int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1273 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1274 uint8_t mpsse_cmd;
1275
1276 /* move from Shift-IR/DR to end state */
1277 if (type != SCAN_OUT)
1278 {
1279 /* Clock Data to TMS/CS Pin with Read */
1280 mpsse_cmd = 0x6b;
1281 /* LOG_DEBUG("added TMS scan (read)"); */
1282 }
1283 else
1284 {
1285 /* Clock Data to TMS/CS Pin (no Read) */
1286 mpsse_cmd = 0x4b;
1287 /* LOG_DEBUG("added TMS scan (no read)"); */
1288 }
1289
1290 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1291 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1292 }
1293
1294 if (type != SCAN_OUT)
1295 thisrun_read += 1;
1296
1297 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1298 {
1299 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1300 exit(-1);
1301 }
1302 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1303 ft2232_buffer_size,
1304 (int)bytes_written);
1305 ft2232_buffer_size = 0;
1306
1307 if (type != SCAN_OUT)
1308 {
1309 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1310 {
1311 LOG_ERROR("couldn't read from FT2232");
1312 exit(-1);
1313 }
1314 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1315 thisrun_read,
1316 (int)bytes_read);
1317 receive_pointer += bytes_read;
1318 }
1319
1320 return ERROR_OK;
1321 }
1322
1323 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1324 {
1325 int predicted_size = 3;
1326 int num_bytes = (scan_size - 1) / 8;
1327
1328 if (tap_get_state() != TAP_DRSHIFT)
1329 predicted_size += get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1330
1331 if (type == SCAN_IN) /* only from device to host */
1332 {
1333 /* complete bytes */
1334 predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
1335
1336 /* remaining bits - 1 (up to 7) */
1337 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1338 }
1339 else /* host to device, or bidirectional */
1340 {
1341 /* complete bytes */
1342 predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
1343
1344 /* remaining bits -1 (up to 7) */
1345 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1346 }
1347
1348 return predicted_size;
1349 }
1350
1351 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1352 {
1353 int predicted_size = 0;
1354
1355 if (type != SCAN_OUT)
1356 {
1357 /* complete bytes */
1358 predicted_size += (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
1359
1360 /* remaining bits - 1 */
1361 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1362
1363 /* last bit (from TMS scan) */
1364 predicted_size += 1;
1365 }
1366
1367 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1368
1369 return predicted_size;
1370 }
1371
1372 /* semi-generic FT2232/FT4232 reset code */
1373 static void ftx23_reset(int trst, int srst)
1374 {
1375 enum reset_types jtag_reset_config = jtag_get_reset_config();
1376 if (trst == 1)
1377 {
1378 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1379 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1380 else
1381 low_output &= ~nTRST; /* switch output low */
1382 }
1383 else if (trst == 0)
1384 {
1385 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1386 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1387 else
1388 low_output |= nTRST; /* switch output high */
1389 }
1390
1391 if (srst == 1)
1392 {
1393 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1394 low_output &= ~nSRST; /* switch output low */
1395 else
1396 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1397 }
1398 else if (srst == 0)
1399 {
1400 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1401 low_output |= nSRST; /* switch output high */
1402 else
1403 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1404 }
1405
1406 /* command "set data bits low byte" */
1407 buffer_write(0x80);
1408 buffer_write(low_output);
1409 buffer_write(low_direction);
1410 }
1411
1412 static void jtagkey_reset(int trst, int srst)
1413 {
1414 enum reset_types jtag_reset_config = jtag_get_reset_config();
1415 if (trst == 1)
1416 {
1417 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1418 high_output &= ~nTRSTnOE;
1419 else
1420 high_output &= ~nTRST;
1421 }
1422 else if (trst == 0)
1423 {
1424 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1425 high_output |= nTRSTnOE;
1426 else
1427 high_output |= nTRST;
1428 }
1429
1430 if (srst == 1)
1431 {
1432 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1433 high_output &= ~nSRST;
1434 else
1435 high_output &= ~nSRSTnOE;
1436 }
1437 else if (srst == 0)
1438 {
1439 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1440 high_output |= nSRST;
1441 else
1442 high_output |= nSRSTnOE;
1443 }
1444
1445 /* command "set data bits high byte" */
1446 buffer_write(0x82);
1447 buffer_write(high_output);
1448 buffer_write(high_direction);
1449 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1450 high_direction);
1451 }
1452
1453 static void olimex_jtag_reset(int trst, int srst)
1454 {
1455 enum reset_types jtag_reset_config = jtag_get_reset_config();
1456 if (trst == 1)
1457 {
1458 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1459 high_output &= ~nTRSTnOE;
1460 else
1461 high_output &= ~nTRST;
1462 }
1463 else if (trst == 0)
1464 {
1465 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1466 high_output |= nTRSTnOE;
1467 else
1468 high_output |= nTRST;
1469 }
1470
1471 if (srst == 1)
1472 {
1473 high_output |= nSRST;
1474 }
1475 else if (srst == 0)
1476 {
1477 high_output &= ~nSRST;
1478 }
1479
1480 /* command "set data bits high byte" */
1481 buffer_write(0x82);
1482 buffer_write(high_output);
1483 buffer_write(high_direction);
1484 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1485 high_direction);
1486 }
1487
1488 static void axm0432_jtag_reset(int trst, int srst)
1489 {
1490 if (trst == 1)
1491 {
1492 tap_set_state(TAP_RESET);
1493 high_output &= ~nTRST;
1494 }
1495 else if (trst == 0)
1496 {
1497 high_output |= nTRST;
1498 }
1499
1500 if (srst == 1)
1501 {
1502 high_output &= ~nSRST;
1503 }
1504 else if (srst == 0)
1505 {
1506 high_output |= nSRST;
1507 }
1508
1509 /* command "set data bits low byte" */
1510 buffer_write(0x82);
1511 buffer_write(high_output);
1512 buffer_write(high_direction);
1513 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1514 high_direction);
1515 }
1516
1517 static void flyswatter_reset(int trst, int srst)
1518 {
1519 if (trst == 1)
1520 {
1521 low_output &= ~nTRST;
1522 }
1523 else if (trst == 0)
1524 {
1525 low_output |= nTRST;
1526 }
1527
1528 if (srst == 1)
1529 {
1530 low_output |= nSRST;
1531 }
1532 else if (srst == 0)
1533 {
1534 low_output &= ~nSRST;
1535 }
1536
1537 /* command "set data bits low byte" */
1538 buffer_write(0x80);
1539 buffer_write(low_output);
1540 buffer_write(low_direction);
1541 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1542 }
1543
1544 static void turtle_reset(int trst, int srst)
1545 {
1546 trst = trst;
1547
1548 if (srst == 1)
1549 {
1550 low_output |= nSRST;
1551 }
1552 else if (srst == 0)
1553 {
1554 low_output &= ~nSRST;
1555 }
1556
1557 /* command "set data bits low byte" */
1558 buffer_write(0x80);
1559 buffer_write(low_output);
1560 buffer_write(low_direction);
1561 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1562 }
1563
1564 static void comstick_reset(int trst, int srst)
1565 {
1566 if (trst == 1)
1567 {
1568 high_output &= ~nTRST;
1569 }
1570 else if (trst == 0)
1571 {
1572 high_output |= nTRST;
1573 }
1574
1575 if (srst == 1)
1576 {
1577 high_output &= ~nSRST;
1578 }
1579 else if (srst == 0)
1580 {
1581 high_output |= nSRST;
1582 }
1583
1584 /* command "set data bits high byte" */
1585 buffer_write(0x82);
1586 buffer_write(high_output);
1587 buffer_write(high_direction);
1588 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1589 high_direction);
1590 }
1591
1592 static void stm32stick_reset(int trst, int srst)
1593 {
1594 if (trst == 1)
1595 {
1596 high_output &= ~nTRST;
1597 }
1598 else if (trst == 0)
1599 {
1600 high_output |= nTRST;
1601 }
1602
1603 if (srst == 1)
1604 {
1605 low_output &= ~nSRST;
1606 }
1607 else if (srst == 0)
1608 {
1609 low_output |= nSRST;
1610 }
1611
1612 /* command "set data bits low byte" */
1613 buffer_write(0x80);
1614 buffer_write(low_output);
1615 buffer_write(low_direction);
1616
1617 /* command "set data bits high byte" */
1618 buffer_write(0x82);
1619 buffer_write(high_output);
1620 buffer_write(high_direction);
1621 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1622 high_direction);
1623 }
1624
1625 static void sheevaplug_reset(int trst, int srst)
1626 {
1627 if (trst == 1)
1628 high_output &= ~nTRST;
1629 else if (trst == 0)
1630 high_output |= nTRST;
1631
1632 if (srst == 1)
1633 high_output &= ~nSRSTnOE;
1634 else if (srst == 0)
1635 high_output |= nSRSTnOE;
1636
1637 /* command "set data bits high byte" */
1638 buffer_write(0x82);
1639 buffer_write(high_output);
1640 buffer_write(high_direction);
1641 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1642 }
1643
1644 static void redbee_reset(int trst, int srst)
1645 {
1646 if (trst == 1)
1647 {
1648 tap_set_state(TAP_RESET);
1649 high_output &= ~nTRST;
1650 }
1651 else if (trst == 0)
1652 {
1653 high_output |= nTRST;
1654 }
1655
1656 if (srst == 1)
1657 {
1658 high_output &= ~nSRST;
1659 }
1660 else if (srst == 0)
1661 {
1662 high_output |= nSRST;
1663 }
1664
1665 /* command "set data bits low byte" */
1666 buffer_write(0x82);
1667 buffer_write(high_output);
1668 buffer_write(high_direction);
1669 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1670 "high_direction: 0x%2.2x", trst, srst, high_output,
1671 high_direction);
1672 }
1673
1674 static int ft2232_execute_runtest(struct jtag_command *cmd)
1675 {
1676 int retval;
1677 int i;
1678 int predicted_size = 0;
1679 retval = ERROR_OK;
1680
1681 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1682 cmd->cmd.runtest->num_cycles,
1683 tap_state_name(cmd->cmd.runtest->end_state));
1684
1685 /* only send the maximum buffer size that FT2232C can handle */
1686 predicted_size = 0;
1687 if (tap_get_state() != TAP_IDLE)
1688 predicted_size += 3;
1689 predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
1690 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1691 predicted_size += 3;
1692 if (tap_get_end_state() != TAP_IDLE)
1693 predicted_size += 3;
1694 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1695 {
1696 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1697 retval = ERROR_JTAG_QUEUE_FAILED;
1698 require_send = 0;
1699 first_unsent = cmd;
1700 }
1701 if (tap_get_state() != TAP_IDLE)
1702 {
1703 move_to_state(TAP_IDLE);
1704 require_send = 1;
1705 }
1706 i = cmd->cmd.runtest->num_cycles;
1707 while (i > 0)
1708 {
1709 /* there are no state transitions in this code, so omit state tracking */
1710
1711 /* command "Clock Data to TMS/CS Pin (no Read)" */
1712 buffer_write(0x4b);
1713
1714 /* scan 7 bits */
1715 buffer_write((i > 7) ? 6 : (i - 1));
1716
1717 /* TMS data bits */
1718 buffer_write(0x0);
1719
1720 i -= (i > 7) ? 7 : i;
1721 /* LOG_DEBUG("added TMS scan (no read)"); */
1722 }
1723
1724 ft2232_end_state(cmd->cmd.runtest->end_state);
1725
1726 if (tap_get_state() != tap_get_end_state())
1727 {
1728 move_to_state(tap_get_end_state());
1729 }
1730
1731 require_send = 1;
1732 DEBUG_JTAG_IO("runtest: %i, end in %s",
1733 cmd->cmd.runtest->num_cycles,
1734 tap_state_name(tap_get_end_state()));
1735 return retval;
1736 }
1737
1738 static int ft2232_execute_statemove(struct jtag_command *cmd)
1739 {
1740 int predicted_size = 0;
1741 int retval = ERROR_OK;
1742
1743 DEBUG_JTAG_IO("statemove end in %s",
1744 tap_state_name(cmd->cmd.statemove->end_state));
1745
1746 /* only send the maximum buffer size that FT2232C can handle */
1747 predicted_size = 3;
1748 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1749 {
1750 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1751 retval = ERROR_JTAG_QUEUE_FAILED;
1752 require_send = 0;
1753 first_unsent = cmd;
1754 }
1755 ft2232_end_state(cmd->cmd.statemove->end_state);
1756
1757 /* For TAP_RESET, ignore the current recorded state. It's often
1758 * wrong at server startup, and this transation is critical whenever
1759 * it's requested.
1760 */
1761 if (tap_get_end_state() == TAP_RESET) {
1762 clock_tms(0x4b, 0xff, 5, 0);
1763 require_send = 1;
1764
1765 /* shortest-path move to desired end state */
1766 } else if (tap_get_state() != tap_get_end_state())
1767 {
1768 move_to_state(tap_get_end_state());
1769 require_send = 1;
1770 }
1771
1772 return retval;
1773 }
1774
1775 /**
1776 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
1777 * (or SWD) state machine.
1778 */
1779 static int ft2232_execute_tms(struct jtag_command *cmd)
1780 {
1781 int retval = ERROR_OK;
1782 unsigned num_bits = cmd->cmd.tms->num_bits;
1783 const uint8_t *bits = cmd->cmd.tms->bits;
1784 unsigned count;
1785
1786 DEBUG_JTAG_IO("TMS: %d bits", num_bits);
1787
1788 /* only send the maximum buffer size that FT2232C can handle */
1789 count = 3 * DIV_ROUND_UP(num_bits, 4);
1790 if (ft2232_buffer_size + 3*count + 1 > FT2232_BUFFER_SIZE) {
1791 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1792 retval = ERROR_JTAG_QUEUE_FAILED;
1793
1794 require_send = 0;
1795 first_unsent = cmd;
1796 }
1797
1798 /* Shift out in batches of at most 6 bits; there's a report of an
1799 * FT2232 bug in this area, where shifting exactly 7 bits can make
1800 * problems with TMS signaling for the last clock cycle:
1801 *
1802 * http://developer.intra2net.com/mailarchive/html/
1803 * libftdi/2009/msg00292.html
1804 *
1805 * Command 0x4b is: "Clock Data to TMS/CS Pin (no Read)"
1806 *
1807 * Note that pathmoves in JTAG are not often seven bits, so that
1808 * isn't a particularly likely situation outside of "special"
1809 * signaling such as switching between JTAG and SWD modes.
1810 */
1811 while (num_bits) {
1812 if (num_bits <= 6) {
1813 buffer_write(0x4b);
1814 buffer_write(num_bits - 1);
1815 buffer_write(*bits & 0x3f);
1816 break;
1817 }
1818
1819 /* Yes, this is lazy ... we COULD shift out more data
1820 * bits per operation, but doing it in nybbles is easy
1821 */
1822 buffer_write(0x4b);
1823 buffer_write(3);
1824 buffer_write(*bits & 0xf);
1825 num_bits -= 4;
1826
1827 count = (num_bits > 4) ? 4 : num_bits;
1828
1829 buffer_write(0x4b);
1830 buffer_write(count - 1);
1831 buffer_write((*bits >> 4) & 0xf);
1832 num_bits -= count;
1833
1834 bits++;
1835 }
1836
1837 require_send = 1;
1838 return retval;
1839 }
1840
1841 static int ft2232_execute_pathmove(struct jtag_command *cmd)
1842 {
1843 int predicted_size = 0;
1844 int retval = ERROR_OK;
1845
1846 tap_state_t* path = cmd->cmd.pathmove->path;
1847 int num_states = cmd->cmd.pathmove->num_states;
1848
1849 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1850 tap_state_name(tap_get_state()),
1851 tap_state_name(path[num_states-1]));
1852
1853 /* only send the maximum buffer size that FT2232C can handle */
1854 predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
1855 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1856 {
1857 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1858 retval = ERROR_JTAG_QUEUE_FAILED;
1859
1860 require_send = 0;
1861 first_unsent = cmd;
1862 }
1863
1864 ft2232_add_pathmove(path, num_states);
1865 require_send = 1;
1866
1867 return retval;
1868 }
1869
1870 static int ft2232_execute_scan(struct jtag_command *cmd)
1871 {
1872 uint8_t* buffer;
1873 int scan_size; /* size of IR or DR scan */
1874 int predicted_size = 0;
1875 int retval = ERROR_OK;
1876
1877 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1878
1879 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1880
1881 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1882
1883 predicted_size = ft2232_predict_scan_out(scan_size, type);
1884 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1885 {
1886 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1887 /* unsent commands before this */
1888 if (first_unsent != cmd)
1889 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1890 retval = ERROR_JTAG_QUEUE_FAILED;
1891
1892 /* current command */
1893 ft2232_end_state(cmd->cmd.scan->end_state);
1894 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1895 require_send = 0;
1896 first_unsent = cmd->next;
1897 if (buffer)
1898 free(buffer);
1899 return retval;
1900 }
1901 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1902 {
1903 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1904 first_unsent,
1905 cmd);
1906 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1907 retval = ERROR_JTAG_QUEUE_FAILED;
1908 require_send = 0;
1909 first_unsent = cmd;
1910 }
1911 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1912 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1913 ft2232_end_state(cmd->cmd.scan->end_state);
1914 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1915 require_send = 1;
1916 if (buffer)
1917 free(buffer);
1918 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1919 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1920 tap_state_name(tap_get_end_state()));
1921 return retval;
1922
1923 }
1924
1925 static int ft2232_execute_reset(struct jtag_command *cmd)
1926 {
1927 int retval;
1928 int predicted_size = 0;
1929 retval = ERROR_OK;
1930
1931 DEBUG_JTAG_IO("reset trst: %i srst %i",
1932 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1933
1934 /* only send the maximum buffer size that FT2232C can handle */
1935 predicted_size = 3;
1936 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1937 {
1938 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1939 retval = ERROR_JTAG_QUEUE_FAILED;
1940 require_send = 0;
1941 first_unsent = cmd;
1942 }
1943
1944 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1945 {
1946 tap_set_state(TAP_RESET);
1947 }
1948
1949 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1950 require_send = 1;
1951
1952 DEBUG_JTAG_IO("trst: %i, srst: %i",
1953 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1954 return retval;
1955 }
1956
1957 static int ft2232_execute_sleep(struct jtag_command *cmd)
1958 {
1959 int retval;
1960 retval = ERROR_OK;
1961
1962 DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
1963
1964 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1965 retval = ERROR_JTAG_QUEUE_FAILED;
1966 first_unsent = cmd->next;
1967 jtag_sleep(cmd->cmd.sleep->us);
1968 DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
1969 cmd->cmd.sleep->us,
1970 tap_state_name(tap_get_state()));
1971 return retval;
1972 }
1973
1974 static int ft2232_execute_stableclocks(struct jtag_command *cmd)
1975 {
1976 int retval;
1977 retval = ERROR_OK;
1978
1979 /* this is only allowed while in a stable state. A check for a stable
1980 * state was done in jtag_add_clocks()
1981 */
1982 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1983 retval = ERROR_JTAG_QUEUE_FAILED;
1984 DEBUG_JTAG_IO("clocks %i while in %s",
1985 cmd->cmd.stableclocks->num_cycles,
1986 tap_state_name(tap_get_state()));
1987 return retval;
1988 }
1989
1990 static int ft2232_execute_command(struct jtag_command *cmd)
1991 {
1992 int retval;
1993
1994 switch (cmd->type)
1995 {
1996 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1997 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1998 case JTAG_TLR_RESET: retval = ft2232_execute_statemove(cmd); break;
1999 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
2000 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
2001 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
2002 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
2003 case JTAG_TMS:
2004 retval = ft2232_execute_tms(cmd);
2005 break;
2006 default:
2007 LOG_ERROR("BUG: unknown JTAG command type encountered");
2008 retval = ERROR_JTAG_QUEUE_FAILED;
2009 break;
2010 }
2011 return retval;
2012 }
2013
2014 static int ft2232_execute_queue(void)
2015 {
2016 struct jtag_command* cmd = jtag_command_queue; /* currently processed command */
2017 int retval;
2018
2019 first_unsent = cmd; /* next command that has to be sent */
2020 require_send = 0;
2021
2022 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
2023 * that wasn't handled by a caller-provided error handler
2024 */
2025 retval = ERROR_OK;
2026
2027 ft2232_buffer_size = 0;
2028 ft2232_expect_read = 0;
2029
2030 /* blink, if the current layout has that feature */
2031 if (layout->blink)
2032 layout->blink();
2033
2034 while (cmd)
2035 {
2036 if (ft2232_execute_command(cmd) != ERROR_OK)
2037 retval = ERROR_JTAG_QUEUE_FAILED;
2038 /* Start reading input before FT2232 TX buffer fills up */
2039 cmd = cmd->next;
2040 if (ft2232_expect_read > 256)
2041 {
2042 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2043 retval = ERROR_JTAG_QUEUE_FAILED;
2044 first_unsent = cmd;
2045 }
2046 }
2047
2048 if (require_send > 0)
2049 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2050 retval = ERROR_JTAG_QUEUE_FAILED;
2051
2052 return retval;
2053 }
2054
2055 #if BUILD_FT2232_FTD2XX == 1
2056 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more)
2057 {
2058 FT_STATUS status;
2059 DWORD deviceID;
2060 char SerialNumber[16];
2061 char Description[64];
2062 DWORD openex_flags = 0;
2063 char* openex_string = NULL;
2064 uint8_t latency_timer;
2065
2066 if (layout == NULL) {
2067 LOG_WARNING("No ft2232 layout specified'");
2068 return ERROR_JTAG_INIT_FAILED;
2069 }
2070
2071 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", layout->name, vid, pid);
2072
2073 #if IS_WIN32 == 0
2074 /* Add non-standard Vid/Pid to the linux driver */
2075 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
2076 {
2077 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
2078 }
2079 #endif
2080
2081 if (ft2232_device_desc && ft2232_serial)
2082 {
2083 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
2084 ft2232_device_desc = NULL;
2085 }
2086
2087 if (ft2232_device_desc)
2088 {
2089 openex_string = ft2232_device_desc;
2090 openex_flags = FT_OPEN_BY_DESCRIPTION;
2091 }
2092 else if (ft2232_serial)
2093 {
2094 openex_string = ft2232_serial;
2095 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
2096 }
2097 else
2098 {
2099 LOG_ERROR("neither device description nor serial number specified");
2100 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
2101
2102 return ERROR_JTAG_INIT_FAILED;
2103 }
2104
2105 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2106 if (status != FT_OK) {
2107 /* under Win32, the FTD2XX driver appends an "A" to the end
2108 * of the description, if we tried by the desc, then
2109 * try by the alternate "A" description. */
2110 if (openex_string == ft2232_device_desc) {
2111 /* Try the alternate method. */
2112 openex_string = ft2232_device_desc_A;
2113 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2114 if (status == FT_OK) {
2115 /* yea, the "alternate" method worked! */
2116 } else {
2117 /* drat, give the user a meaningfull message.
2118 * telling the use we tried *BOTH* methods. */
2119 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
2120 ft2232_device_desc,
2121 ft2232_device_desc_A);
2122 }
2123 }
2124 }
2125
2126 if (status != FT_OK)
2127 {
2128 DWORD num_devices;
2129
2130 if (more)
2131 {
2132 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
2133 *try_more = 1;
2134 return ERROR_JTAG_INIT_FAILED;
2135 }
2136 LOG_ERROR("unable to open ftdi device: %lu", status);
2137 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
2138 if (status == FT_OK)
2139 {
2140 char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
2141 uint32_t i;
2142
2143 for (i = 0; i < num_devices; i++)
2144 desc_array[i] = malloc(64);
2145
2146 desc_array[num_devices] = NULL;
2147
2148 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
2149
2150 if (status == FT_OK)
2151 {
2152 LOG_ERROR("ListDevices: %lu\n", num_devices);
2153 for (i = 0; i < num_devices; i++)
2154 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
2155 }
2156
2157 for (i = 0; i < num_devices; i++)
2158 free(desc_array[i]);
2159
2160 free(desc_array);
2161 }
2162 else
2163 {
2164 LOG_ERROR("ListDevices: NONE\n");
2165 }
2166 return ERROR_JTAG_INIT_FAILED;
2167 }
2168
2169 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
2170 {
2171 LOG_ERROR("unable to set latency timer: %lu", status);
2172 return ERROR_JTAG_INIT_FAILED;
2173 }
2174
2175 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
2176 {
2177 LOG_ERROR("unable to get latency timer: %lu", status);
2178 return ERROR_JTAG_INIT_FAILED;
2179 }
2180 else
2181 {
2182 LOG_DEBUG("current latency timer: %i", latency_timer);
2183 }
2184
2185 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
2186 {
2187 LOG_ERROR("unable to set timeouts: %lu", status);
2188 return ERROR_JTAG_INIT_FAILED;
2189 }
2190
2191 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
2192 {
2193 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
2194 return ERROR_JTAG_INIT_FAILED;
2195 }
2196
2197 if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
2198 {
2199 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
2200 return ERROR_JTAG_INIT_FAILED;
2201 }
2202 else
2203 {
2204 static const char* type_str[] =
2205 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
2206 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2207 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
2208 ? ftdi_device : FT_DEVICE_UNKNOWN;
2209 LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
2210 LOG_INFO("deviceID: %lu", deviceID);
2211 LOG_INFO("SerialNumber: %s", SerialNumber);
2212 LOG_INFO("Description: %s", Description);
2213 }
2214
2215 return ERROR_OK;
2216 }
2217
2218 static int ft2232_purge_ftd2xx(void)
2219 {
2220 FT_STATUS status;
2221
2222 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
2223 {
2224 LOG_ERROR("error purging ftd2xx device: %lu", status);
2225 return ERROR_JTAG_INIT_FAILED;
2226 }
2227
2228 return ERROR_OK;
2229 }
2230
2231 #endif /* BUILD_FT2232_FTD2XX == 1 */
2232
2233 #if BUILD_FT2232_LIBFTDI == 1
2234 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more, int channel)
2235 {
2236 uint8_t latency_timer;
2237
2238 if (layout == NULL) {
2239 LOG_WARNING("No ft2232 layout specified'");
2240 return ERROR_JTAG_INIT_FAILED;
2241 }
2242
2243 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2244 layout->name, vid, pid);
2245
2246 if (ftdi_init(&ftdic) < 0)
2247 return ERROR_JTAG_INIT_FAILED;
2248
2249 /* default to INTERFACE_A */
2250 if(channel == INTERFACE_ANY) { channel = INTERFACE_A; }
2251
2252 if (ftdi_set_interface(&ftdic, channel) < 0)
2253 {
2254 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2255 return ERROR_JTAG_INIT_FAILED;
2256 }
2257
2258 /* context, vendor id, product id */
2259 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
2260 ft2232_serial) < 0)
2261 {
2262 if (more)
2263 LOG_WARNING("unable to open ftdi device (trying more): %s",
2264 ftdic.error_str);
2265 else
2266 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2267 *try_more = 1;
2268 return ERROR_JTAG_INIT_FAILED;
2269 }
2270
2271 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2272 if (ftdi_usb_reset(&ftdic) < 0)
2273 {
2274 LOG_ERROR("unable to reset ftdi device");
2275 return ERROR_JTAG_INIT_FAILED;
2276 }
2277
2278 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
2279 {
2280 LOG_ERROR("unable to set latency timer");
2281 return ERROR_JTAG_INIT_FAILED;
2282 }
2283
2284 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2285 {
2286 LOG_ERROR("unable to get latency timer");
2287 return ERROR_JTAG_INIT_FAILED;
2288 }
2289 else
2290 {
2291 LOG_DEBUG("current latency timer: %i", latency_timer);
2292 }
2293
2294 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2295
2296 ftdi_device = ftdic.type;
2297 static const char* type_str[] =
2298 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2299 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2300 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2301 ? ftdi_device : no_of_known_types;
2302 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2303 return ERROR_OK;
2304 }
2305
2306 static int ft2232_purge_libftdi(void)
2307 {
2308 if (ftdi_usb_purge_buffers(&ftdic) < 0)
2309 {
2310 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2311 return ERROR_JTAG_INIT_FAILED;
2312 }
2313
2314 return ERROR_OK;
2315 }
2316
2317 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2318
2319 static int ft2232_init(void)
2320 {
2321 uint8_t buf[1];
2322 int retval;
2323 uint32_t bytes_written;
2324
2325 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE) == 7)
2326 {
2327 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2328 }
2329 else
2330 {
2331 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2332
2333 }
2334 if (layout == NULL) {
2335 LOG_WARNING("No ft2232 layout specified'");
2336 return ERROR_JTAG_INIT_FAILED;
2337 }
2338
2339 for (int i = 0; 1; i++)
2340 {
2341 /*
2342 * "more indicates that there are more IDs to try, so we should
2343 * not print an error for an ID mismatch (but for anything
2344 * else, we should).
2345 *
2346 * try_more indicates that the error code returned indicates an
2347 * ID mismatch (and nothing else) and that we should proceeed
2348 * with the next ID pair.
2349 */
2350 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2351 int try_more = 0;
2352
2353 #if BUILD_FT2232_FTD2XX == 1
2354 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2355 more, &try_more);
2356 #elif BUILD_FT2232_LIBFTDI == 1
2357 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2358 more, &try_more, layout->channel);
2359 #endif
2360 if (retval >= 0)
2361 break;
2362 if (!more || !try_more)
2363 return retval;
2364 }
2365
2366 ft2232_buffer_size = 0;
2367 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2368
2369 if (layout->init() != ERROR_OK)
2370 return ERROR_JTAG_INIT_FAILED;
2371
2372 if (ft2232_device_is_highspeed())
2373 {
2374 #ifndef BUILD_FT2232_HIGHSPEED
2375 #if BUILD_FT2232_FTD2XX == 1
2376 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2377 #elif BUILD_FT2232_LIBFTDI == 1
2378 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2379 #endif
2380 #endif
2381 /* make sure the legacy mode is disabled */
2382 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK)
2383 return ERROR_JTAG_INIT_FAILED;
2384 }
2385
2386 ft2232_speed(jtag_get_speed());
2387
2388 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2389 if ((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK)
2390 {
2391 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2392 return ERROR_JTAG_INIT_FAILED;
2393 }
2394
2395 #if BUILD_FT2232_FTD2XX == 1
2396 return ft2232_purge_ftd2xx();
2397 #elif BUILD_FT2232_LIBFTDI == 1
2398 return ft2232_purge_libftdi();
2399 #endif
2400
2401 return ERROR_OK;
2402 }
2403
2404 /** Updates defaults for DBUS signals: the four JTAG signals
2405 * (TCK, TDI, TDO, TMS) and * the four GPIOL signals.
2406 */
2407 static inline void ftx232_dbus_init(void)
2408 {
2409 low_output = 0x08;
2410 low_direction = 0x0b;
2411 }
2412
2413 /** Initializes DBUS signals: the four JTAG signals (TCK, TDI, TDO, TMS),
2414 * the four GPIOL signals. Initialization covers value and direction,
2415 * as customized for each layout.
2416 */
2417 static int ftx232_dbus_write(void)
2418 {
2419 uint8_t buf[3];
2420 uint32_t bytes_written;
2421
2422 enum reset_types jtag_reset_config = jtag_get_reset_config();
2423 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2424 {
2425 low_direction &= ~nTRSTnOE; /* nTRST input */
2426 low_output &= ~nTRST; /* nTRST = 0 */
2427 }
2428 else
2429 {
2430 low_direction |= nTRSTnOE; /* nTRST output */
2431 low_output |= nTRST; /* nTRST = 1 */
2432 }
2433
2434 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2435 {
2436 low_direction |= nSRSTnOE; /* nSRST output */
2437 low_output |= nSRST; /* nSRST = 1 */
2438 }
2439 else
2440 {
2441 low_direction &= ~nSRSTnOE; /* nSRST input */
2442 low_output &= ~nSRST; /* nSRST = 0 */
2443 }
2444
2445 /* initialize low byte for jtag */
2446 buf[0] = 0x80; /* command "set data bits low byte" */
2447 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2448 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2449 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2450
2451 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2452 {
2453 LOG_ERROR("couldn't initialize FT2232 DBUS");
2454 return ERROR_JTAG_INIT_FAILED;
2455 }
2456
2457 return ERROR_OK;
2458 }
2459
2460 static int usbjtag_init(void)
2461 {
2462 /*
2463 * NOTE: This is now _specific_ to the "usbjtag" layout.
2464 * Don't try cram any more layouts into this.
2465 */
2466 ftx232_dbus_init();
2467
2468 nTRST = 0x10;
2469 nTRSTnOE = 0x10;
2470 nSRST = 0x40;
2471 nSRSTnOE = 0x40;
2472
2473 return ftx232_dbus_write();
2474 }
2475
2476 static int lm3s811_jtag_init(void)
2477 {
2478 ftx232_dbus_init();
2479
2480 /* There are multiple revisions of LM3S811 eval boards:
2481 * - Rev B (and older?) boards have no SWO trace support.
2482 * - Rev C boards add ADBUS_6 DBG_ENn and BDBUS_4 SWO_EN;
2483 * they should use the "luminary_icdi" layout instead.
2484 */
2485 nTRST = 0x0;
2486 nTRSTnOE = 0x00;
2487 nSRST = 0x20;
2488 nSRSTnOE = 0x20;
2489 low_output = 0x88;
2490 low_direction = 0x8b;
2491
2492 return ftx232_dbus_write();
2493 }
2494
2495 static int icdi_jtag_init(void)
2496 {
2497 ftx232_dbus_init();
2498
2499 /* Most Luminary eval boards support SWO trace output,
2500 * and should use this "luminary_icdi" layout.
2501 */
2502 nTRST = 0x0;
2503 nTRSTnOE = 0x00;
2504 nSRST = 0x20;
2505 nSRSTnOE = 0x20;
2506 low_output = 0x88;
2507 low_direction = 0xcb;
2508
2509 return ftx232_dbus_write();
2510 }
2511
2512 static int signalyzer_init(void)
2513 {
2514 ftx232_dbus_init();
2515
2516 nTRST = 0x10;
2517 nTRSTnOE = 0x10;
2518 nSRST = 0x20;
2519 nSRSTnOE = 0x20;
2520 return ftx232_dbus_write();
2521 }
2522
2523 static int axm0432_jtag_init(void)
2524 {
2525 uint8_t buf[3];
2526 uint32_t bytes_written;
2527
2528 low_output = 0x08;
2529 low_direction = 0x2b;
2530
2531 /* initialize low byte for jtag */
2532 buf[0] = 0x80; /* command "set data bits low byte" */
2533 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2534 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2535 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2536
2537 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2538 {
2539 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2540 return ERROR_JTAG_INIT_FAILED;
2541 }
2542
2543 if (strcmp(layout->name, "axm0432_jtag") == 0)
2544 {
2545 nTRST = 0x08;
2546 nTRSTnOE = 0x0; /* No output enable for TRST*/
2547 nSRST = 0x04;
2548 nSRSTnOE = 0x0; /* No output enable for SRST*/
2549 }
2550 else
2551 {
2552 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2553 exit(-1);
2554 }
2555
2556 high_output = 0x0;
2557 high_direction = 0x0c;
2558
2559 enum reset_types jtag_reset_config = jtag_get_reset_config();
2560 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2561 {
2562 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2563 }
2564 else
2565 {
2566 high_output |= nTRST;
2567 }
2568
2569 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2570 {
2571 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2572 }
2573 else
2574 {
2575 high_output |= nSRST;
2576 }
2577
2578 /* initialize high port */
2579 buf[0] = 0x82; /* command "set data bits high byte" */
2580 buf[1] = high_output; /* value */
2581 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2582 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2583
2584 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2585 {
2586 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2587 return ERROR_JTAG_INIT_FAILED;
2588 }
2589
2590 return ERROR_OK;
2591 }
2592
2593 static int redbee_init(void)
2594 {
2595 uint8_t buf[3];
2596 uint32_t bytes_written;
2597
2598 low_output = 0x08;
2599 low_direction = 0x2b;
2600
2601 /* initialize low byte for jtag */
2602 /* command "set data bits low byte" */
2603 buf[0] = 0x80;
2604 /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2605 buf[2] = low_direction;
2606 /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2607 buf[1] = low_output;
2608 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2609
2610 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2611 {
2612 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2613 return ERROR_JTAG_INIT_FAILED;
2614 }
2615
2616 nTRST = 0x08;
2617 nTRSTnOE = 0x0; /* No output enable for TRST*/
2618 nSRST = 0x04;
2619 nSRSTnOE = 0x0; /* No output enable for SRST*/
2620
2621 high_output = 0x0;
2622 high_direction = 0x0c;
2623
2624 enum reset_types jtag_reset_config = jtag_get_reset_config();
2625 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2626 {
2627 LOG_ERROR("can't set nTRSTOE to push-pull on redbee");
2628 }
2629 else
2630 {
2631 high_output |= nTRST;
2632 }
2633
2634 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2635 {
2636 LOG_ERROR("can't set nSRST to push-pull on redbee");
2637 }
2638 else
2639 {
2640 high_output |= nSRST;
2641 }
2642
2643 /* initialize high port */
2644 buf[0] = 0x82; /* command "set data bits high byte" */
2645 buf[1] = high_output; /* value */
2646 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2647 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2648
2649 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2650 {
2651 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2652 return ERROR_JTAG_INIT_FAILED;
2653 }
2654
2655 return ERROR_OK;
2656 }
2657
2658 static int jtagkey_init(void)
2659 {
2660 uint8_t buf[3];
2661 uint32_t bytes_written;
2662
2663 low_output = 0x08;
2664 low_direction = 0x1b;
2665
2666 /* initialize low byte for jtag */
2667 buf[0] = 0x80; /* command "set data bits low byte" */
2668 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2669 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2670 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2671
2672 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2673 {
2674 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2675 return ERROR_JTAG_INIT_FAILED;
2676 }
2677
2678 if (strcmp(layout->name, "jtagkey") == 0)
2679 {
2680 nTRST = 0x01;
2681 nTRSTnOE = 0x4;
2682 nSRST = 0x02;
2683 nSRSTnOE = 0x08;
2684 }
2685 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2686 || (strcmp(layout->name, "oocdlink") == 0))
2687 {
2688 nTRST = 0x02;
2689 nTRSTnOE = 0x1;
2690 nSRST = 0x08;
2691 nSRSTnOE = 0x04;
2692 }
2693 else
2694 {
2695 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2696 exit(-1);
2697 }
2698
2699 high_output = 0x0;
2700 high_direction = 0x0f;
2701
2702 enum reset_types jtag_reset_config = jtag_get_reset_config();
2703 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2704 {
2705 high_output |= nTRSTnOE;
2706 high_output &= ~nTRST;
2707 }
2708 else
2709 {
2710 high_output &= ~nTRSTnOE;
2711 high_output |= nTRST;
2712 }
2713
2714 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2715 {
2716 high_output &= ~nSRSTnOE;
2717 high_output |= nSRST;
2718 }
2719 else
2720 {
2721 high_output |= nSRSTnOE;
2722 high_output &= ~nSRST;
2723 }
2724
2725 /* initialize high port */
2726 buf[0] = 0x82; /* command "set data bits high byte" */
2727 buf[1] = high_output; /* value */
2728 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2729 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2730
2731 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2732 {
2733 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2734 return ERROR_JTAG_INIT_FAILED;
2735 }
2736
2737 return ERROR_OK;
2738 }
2739
2740 static int olimex_jtag_init(void)
2741 {
2742 uint8_t buf[3];
2743 uint32_t bytes_written;
2744
2745 low_output = 0x08;
2746 low_direction = 0x1b;
2747
2748 /* initialize low byte for jtag */
2749 buf[0] = 0x80; /* command "set data bits low byte" */
2750 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2751 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2752 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2753
2754 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2755 {
2756 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2757 return ERROR_JTAG_INIT_FAILED;
2758 }
2759
2760 nTRST = 0x01;
2761 nTRSTnOE = 0x4;
2762 nSRST = 0x02;
2763 nSRSTnOE = 0x00; /* no output enable for nSRST */
2764
2765 high_output = 0x0;
2766 high_direction = 0x0f;
2767
2768 enum reset_types jtag_reset_config = jtag_get_reset_config();
2769 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2770 {
2771 high_output |= nTRSTnOE;
2772 high_output &= ~nTRST;
2773 }
2774 else
2775 {
2776 high_output &= ~nTRSTnOE;
2777 high_output |= nTRST;
2778 }
2779
2780 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2781 {
2782 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2783 }
2784 else
2785 {
2786 high_output &= ~nSRST;
2787 }
2788
2789 /* turn red LED on */
2790 high_output |= 0x08;
2791
2792 /* initialize high port */
2793 buf[0] = 0x82; /* command "set data bits high byte" */
2794 buf[1] = high_output; /* value */
2795 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2796 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2797
2798 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2799 {
2800 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2801 return ERROR_JTAG_INIT_FAILED;
2802 }
2803
2804 return ERROR_OK;
2805 }
2806
2807 static int flyswatter_init(void)
2808 {
2809 uint8_t buf[3];
2810 uint32_t bytes_written;
2811
2812 low_output = 0x18;
2813 low_direction = 0xfb;
2814
2815 /* initialize low byte for jtag */
2816 buf[0] = 0x80; /* command "set data bits low byte" */
2817 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2818 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2819 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2820
2821 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2822 {
2823 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2824 return ERROR_JTAG_INIT_FAILED;
2825 }
2826
2827 nTRST = 0x10;
2828 nTRSTnOE = 0x0; /* not output enable for nTRST */
2829 nSRST = 0x20;
2830 nSRSTnOE = 0x00; /* no output enable for nSRST */
2831
2832 high_output = 0x00;
2833 high_direction = 0x0c;
2834
2835 /* turn red LED3 on, LED2 off */
2836 high_output |= 0x08;
2837
2838 /* initialize high port */
2839 buf[0] = 0x82; /* command "set data bits high byte" */
2840 buf[1] = high_output; /* value */
2841 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2842 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2843
2844 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2845 {
2846 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2847 return ERROR_JTAG_INIT_FAILED;
2848 }
2849
2850 return ERROR_OK;
2851 }
2852
2853 static int turtle_init(void)
2854 {
2855 uint8_t buf[3];
2856 uint32_t bytes_written;
2857
2858 low_output = 0x08;
2859 low_direction = 0x5b;
2860
2861 /* initialize low byte for jtag */
2862 buf[0] = 0x80; /* command "set data bits low byte" */
2863 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2864 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2865 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2866
2867 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2868 {
2869 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2870 return ERROR_JTAG_INIT_FAILED;
2871 }
2872
2873 nSRST = 0x40;
2874
2875 high_output = 0x00;
2876 high_direction = 0x0C;
2877
2878 /* initialize high port */
2879 buf[0] = 0x82; /* command "set data bits high byte" */
2880 buf[1] = high_output;
2881 buf[2] = high_direction;
2882 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2883
2884 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2885 {
2886 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2887 return ERROR_JTAG_INIT_FAILED;
2888 }
2889
2890 return ERROR_OK;
2891 }
2892
2893 static int comstick_init(void)
2894 {
2895 uint8_t buf[3];
2896 uint32_t bytes_written;
2897
2898 low_output = 0x08;
2899 low_direction = 0x0b;
2900
2901 /* initialize low byte for jtag */
2902 buf[0] = 0x80; /* command "set data bits low byte" */
2903 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2904 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2905 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2906
2907 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2908 {
2909 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2910 return ERROR_JTAG_INIT_FAILED;
2911 }
2912
2913 nTRST = 0x01;
2914 nTRSTnOE = 0x00; /* no output enable for nTRST */
2915 nSRST = 0x02;
2916 nSRSTnOE = 0x00; /* no output enable for nSRST */
2917
2918 high_output = 0x03;
2919 high_direction = 0x03;
2920
2921 /* initialize high port */
2922 buf[0] = 0x82; /* command "set data bits high byte" */
2923 buf[1] = high_output;
2924 buf[2] = high_direction;
2925 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2926
2927 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2928 {
2929 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2930 return ERROR_JTAG_INIT_FAILED;
2931 }
2932
2933 return ERROR_OK;
2934 }
2935
2936 static int stm32stick_init(void)
2937 {
2938 uint8_t buf[3];
2939 uint32_t bytes_written;
2940
2941 low_output = 0x88;
2942 low_direction = 0x8b;
2943
2944 /* initialize low byte for jtag */
2945 buf[0] = 0x80; /* command "set data bits low byte" */
2946 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2947 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2948 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2949
2950 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2951 {
2952 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2953 return ERROR_JTAG_INIT_FAILED;
2954 }
2955
2956 nTRST = 0x01;
2957 nTRSTnOE = 0x00; /* no output enable for nTRST */
2958 nSRST = 0x80;
2959 nSRSTnOE = 0x00; /* no output enable for nSRST */
2960
2961 high_output = 0x01;
2962 high_direction = 0x03;
2963
2964 /* initialize high port */
2965 buf[0] = 0x82; /* command "set data bits high byte" */
2966 buf[1] = high_output;
2967 buf[2] = high_direction;
2968 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2969
2970 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2971 {
2972 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2973 return ERROR_JTAG_INIT_FAILED;
2974 }
2975
2976 return ERROR_OK;
2977 }
2978
2979 static int sheevaplug_init(void)
2980 {
2981 uint8_t buf[3];
2982 uint32_t bytes_written;
2983
2984 low_output = 0x08;
2985 low_direction = 0x1b;
2986
2987 /* initialize low byte for jtag */
2988 buf[0] = 0x80; /* command "set data bits low byte" */
2989 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2990 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2991 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2992
2993 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
2994 {
2995 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2996 return ERROR_JTAG_INIT_FAILED;
2997 }
2998
2999 nTRSTnOE = 0x1;
3000 nTRST = 0x02;
3001 nSRSTnOE = 0x4;
3002 nSRST = 0x08;
3003
3004 high_output = 0x0;
3005 high_direction = 0x0f;
3006
3007 /* nTRST is always push-pull */
3008 high_output &= ~nTRSTnOE;
3009 high_output |= nTRST;
3010
3011 /* nSRST is always open-drain */
3012 high_output |= nSRSTnOE;
3013 high_output &= ~nSRST;
3014
3015 /* initialize high port */
3016 buf[0] = 0x82; /* command "set data bits high byte" */
3017 buf[1] = high_output; /* value */
3018 buf[2] = high_direction; /* all outputs - xRST */
3019 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3020
3021 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
3022 {
3023 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
3024 return ERROR_JTAG_INIT_FAILED;
3025 }
3026
3027 return ERROR_OK;
3028 }
3029
3030 static int cortino_jtag_init(void)
3031 {
3032 uint8_t buf[3];
3033 uint32_t bytes_written;
3034
3035 low_output = 0x08;
3036 low_direction = 0x1b;
3037
3038 /* initialize low byte for jtag */
3039 buf[0] = 0x80; /* command "set data bits low byte" */
3040 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
3041 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
3042 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3043
3044 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
3045 {
3046 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
3047 return ERROR_JTAG_INIT_FAILED;
3048 }
3049
3050 nTRST = 0x01;
3051 nTRSTnOE = 0x00; /* no output enable for nTRST */
3052 nSRST = 0x02;
3053 nSRSTnOE = 0x00; /* no output enable for nSRST */
3054
3055 high_output = 0x03;
3056 high_direction = 0x03;
3057
3058 /* initialize high port */
3059 buf[0] = 0x82; /* command "set data bits high byte" */
3060 buf[1] = high_output;
3061 buf[2] = high_direction;
3062 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3063
3064 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK)
3065 {
3066 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
3067 return ERROR_JTAG_INIT_FAILED;
3068 }
3069
3070 return ERROR_OK;
3071 }
3072
3073 static void olimex_jtag_blink(void)
3074 {
3075 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
3076 * ACBUS3 is bit 3 of the GPIOH port
3077 */
3078 if (high_output & 0x08)
3079 {
3080 /* set port pin high */
3081 high_output &= 0x07;
3082 }
3083 else
3084 {
3085 /* set port pin low */
3086 high_output |= 0x08;
3087 }
3088
3089 buffer_write(0x82);
3090 buffer_write(high_output);
3091 buffer_write(high_direction);
3092 }
3093
3094 static void flyswatter_jtag_blink(void)
3095 {
3096 /*
3097 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
3098 */
3099 high_output ^= 0x0c;
3100
3101 buffer_write(0x82);
3102 buffer_write(high_output);
3103 buffer_write(high_direction);
3104 }
3105
3106 static void turtle_jtag_blink(void)
3107 {
3108 /*
3109 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
3110 */
3111 if (high_output & 0x08)
3112 {
3113 high_output = 0x04;
3114 }
3115 else
3116 {
3117 high_output = 0x08;
3118 }
3119
3120 buffer_write(0x82);
3121 buffer_write(high_output);
3122 buffer_write(high_direction);
3123 }
3124
3125 static int ft2232_quit(void)
3126 {
3127 #if BUILD_FT2232_FTD2XX == 1
3128 FT_STATUS status;
3129
3130 status = FT_Close(ftdih);
3131 #elif BUILD_FT2232_LIBFTDI == 1
3132 ftdi_usb_close(&ftdic);
3133
3134 ftdi_deinit(&ftdic);
3135 #endif
3136
3137 free(ft2232_buffer);
3138 ft2232_buffer = NULL;
3139
3140 return ERROR_OK;
3141 }
3142
3143 COMMAND_HANDLER(ft2232_handle_device_desc_command)
3144 {
3145 char *cp;
3146 char buf[200];
3147 if (CMD_ARGC == 1)
3148 {
3149 ft2232_device_desc = strdup(CMD_ARGV[0]);
3150 cp = strchr(ft2232_device_desc, 0);
3151 /* under Win32, the FTD2XX driver appends an "A" to the end
3152 * of the description, this examines the given desc
3153 * and creates the 'missing' _A or non_A variable. */
3154 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
3155 /* it was, so make this the "A" version. */
3156 ft2232_device_desc_A = ft2232_device_desc;
3157 /* and *CREATE* the non-A version. */
3158 strcpy(buf, ft2232_device_desc);
3159 cp = strchr(buf, 0);
3160 cp[-2] = 0;
3161 ft2232_device_desc = strdup(buf);
3162 } else {
3163 /* <space > A not defined
3164 * so create it */
3165 sprintf(buf, "%s A", ft2232_device_desc);
3166 ft2232_device_desc_A = strdup(buf);
3167 }
3168 }
3169 else
3170 {
3171 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
3172 }
3173
3174 return ERROR_OK;
3175 }
3176
3177 COMMAND_HANDLER(ft2232_handle_serial_command)
3178 {
3179 if (CMD_ARGC == 1)
3180 {
3181 ft2232_serial = strdup(CMD_ARGV[0]);
3182 }
3183 else
3184 {
3185 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
3186 }
3187
3188 return ERROR_OK;
3189 }
3190
3191 COMMAND_HANDLER(ft2232_handle_layout_command)
3192 {
3193 if (CMD_ARGC != 1) {
3194 LOG_ERROR("Need exactly one argument to ft2232_layout");
3195 return ERROR_FAIL;
3196 }
3197
3198 if (layout) {
3199 LOG_ERROR("already specified ft2232_layout %s",
3200 layout->name);
3201 return (strcmp(layout->name, CMD_ARGV[0]) != 0)
3202 ? ERROR_FAIL
3203 : ERROR_OK;
3204 }
3205
3206 for (const struct ft2232_layout *l = ft2232_layouts; l->name; l++) {
3207 if (strcmp(l->name, CMD_ARGV[0]) == 0) {
3208 layout = l;
3209 /* This may also select the transport
3210 * if we only suppport one of them.
3211 */
3212 return allow_transports(CMD_CTX,
3213 l->transports ? : jtag_only);
3214 }
3215 }
3216
3217 LOG_ERROR("No FT2232 layout '%s' found", CMD_ARGV[0]);
3218 return ERROR_FAIL;
3219 }
3220
3221 COMMAND_HANDLER(ft2232_handle_vid_pid_command)
3222 {
3223 if (CMD_ARGC > MAX_USB_IDS * 2)
3224 {
3225 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
3226 "(maximum is %d pairs)", MAX_USB_IDS);