c4a74ef7f38de2171336214131762d7a34cf5840
[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 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 <transport/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 #include "ftd2xx_common.h"
103
104 enum ftdi_interface {
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_x232H_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, FT_DEVICE_232H };
137 #elif BUILD_FT2232_LIBFTDI == 1
138 enum ftdi_chip_type { TYPE_2232H = 4, TYPE_4232H = 5, TYPE_232H = 6 };
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;
155 static char *ft2232_device_desc;
156 static char *ft2232_serial;
157 static uint8_t ft2232_latency = 2;
158 static unsigned ft2232_max_tck = FTDI_2232C_MAX_TCK;
159 static int ft2232_channel = INTERFACE_ANY;
160
161 #define MAX_USB_IDS 8
162 /* vid = pid = 0 marks the end of the list */
163 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
164 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
165
166 struct ft2232_layout {
167 char *name;
168 int (*init)(void);
169 void (*reset)(int trst, int srst);
170 void (*blink)(void);
171 int channel;
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 flyswatter1_init(void);
181 static int flyswatter2_init(void);
182 static int minimodule_init(void);
183 static int turtle_init(void);
184 static int comstick_init(void);
185 static int stm32stick_init(void);
186 static int axm0432_jtag_init(void);
187 static int sheevaplug_init(void);
188 static int icebear_jtag_init(void);
189 static int cortino_jtag_init(void);
190 static int signalyzer_init(void);
191 static int signalyzer_h_init(void);
192 static int ktlink_init(void);
193 static int redbee_init(void);
194 static int lisa_l_init(void);
195 static int flossjtag_init(void);
196 static int xds100v2_init(void);
197 static int digilent_hs1_init(void);
198
199 /* reset procedures for supported layouts */
200 static void ftx23_reset(int trst, int srst);
201 static void jtagkey_reset(int trst, int srst);
202 static void olimex_jtag_reset(int trst, int srst);
203 static void flyswatter1_reset(int trst, int srst);
204 static void flyswatter2_reset(int trst, int srst);
205 static void minimodule_reset(int trst, int srst);
206 static void turtle_reset(int trst, int srst);
207 static void comstick_reset(int trst, int srst);
208 static void stm32stick_reset(int trst, int srst);
209 static void axm0432_jtag_reset(int trst, int srst);
210 static void sheevaplug_reset(int trst, int srst);
211 static void icebear_jtag_reset(int trst, int srst);
212 static void signalyzer_h_reset(int trst, int srst);
213 static void ktlink_reset(int trst, int srst);
214 static void redbee_reset(int trst, int srst);
215 static void xds100v2_reset(int trst, int srst);
216 static void digilent_hs1_reset(int trst, int srst);
217
218 /* blink procedures for layouts that support a blinking led */
219 static void olimex_jtag_blink(void);
220 static void flyswatter1_jtag_blink(void);
221 static void flyswatter2_jtag_blink(void);
222 static void turtle_jtag_blink(void);
223 static void signalyzer_h_blink(void);
224 static void ktlink_blink(void);
225 static void lisa_l_blink(void);
226 static void flossjtag_blink(void);
227
228 /* common transport support options */
229
230 /* static const char *jtag_and_swd[] = { "jtag", "swd", NULL }; */
231
232 static const struct ft2232_layout ft2232_layouts[] = {
233 { .name = "usbjtag",
234 .init = usbjtag_init,
235 .reset = ftx23_reset,
236 },
237 { .name = "jtagkey",
238 .init = jtagkey_init,
239 .reset = jtagkey_reset,
240 },
241 { .name = "jtagkey_prototype_v1",
242 .init = jtagkey_init,
243 .reset = jtagkey_reset,
244 },
245 { .name = "oocdlink",
246 .init = jtagkey_init,
247 .reset = jtagkey_reset,
248 },
249 { .name = "signalyzer",
250 .init = signalyzer_init,
251 .reset = ftx23_reset,
252 },
253 { .name = "evb_lm3s811",
254 .init = lm3s811_jtag_init,
255 .reset = ftx23_reset,
256 },
257 { .name = "luminary_icdi",
258 .init = icdi_jtag_init,
259 .reset = ftx23_reset,
260 },
261 { .name = "olimex-jtag",
262 .init = olimex_jtag_init,
263 .reset = olimex_jtag_reset,
264 .blink = olimex_jtag_blink
265 },
266 { .name = "flyswatter",
267 .init = flyswatter1_init,
268 .reset = flyswatter1_reset,
269 .blink = flyswatter1_jtag_blink
270 },
271 { .name = "flyswatter2",
272 .init = flyswatter2_init,
273 .reset = flyswatter2_reset,
274 .blink = flyswatter2_jtag_blink
275 },
276 { .name = "minimodule",
277 .init = minimodule_init,
278 .reset = minimodule_reset,
279 },
280 { .name = "turtelizer2",
281 .init = turtle_init,
282 .reset = turtle_reset,
283 .blink = turtle_jtag_blink
284 },
285 { .name = "comstick",
286 .init = comstick_init,
287 .reset = comstick_reset,
288 },
289 { .name = "stm32stick",
290 .init = stm32stick_init,
291 .reset = stm32stick_reset,
292 },
293 { .name = "axm0432_jtag",
294 .init = axm0432_jtag_init,
295 .reset = axm0432_jtag_reset,
296 },
297 { .name = "sheevaplug",
298 .init = sheevaplug_init,
299 .reset = sheevaplug_reset,
300 },
301 { .name = "icebear",
302 .init = icebear_jtag_init,
303 .reset = icebear_jtag_reset,
304 },
305 { .name = "cortino",
306 .init = cortino_jtag_init,
307 .reset = comstick_reset,
308 },
309 { .name = "signalyzer-h",
310 .init = signalyzer_h_init,
311 .reset = signalyzer_h_reset,
312 .blink = signalyzer_h_blink
313 },
314 { .name = "ktlink",
315 .init = ktlink_init,
316 .reset = ktlink_reset,
317 .blink = ktlink_blink
318 },
319 { .name = "redbee-econotag",
320 .init = redbee_init,
321 .reset = redbee_reset,
322 },
323 { .name = "redbee-usb",
324 .init = redbee_init,
325 .reset = redbee_reset,
326 .channel = INTERFACE_B,
327 },
328 { .name = "lisa-l",
329 .init = lisa_l_init,
330 .reset = ftx23_reset,
331 .blink = lisa_l_blink,
332 .channel = INTERFACE_B,
333 },
334 { .name = "flossjtag",
335 .init = flossjtag_init,
336 .reset = ftx23_reset,
337 .blink = flossjtag_blink,
338 },
339 { .name = "xds100v2",
340 .init = xds100v2_init,
341 .reset = xds100v2_reset,
342 },
343 { .name = "digilent-hs1",
344 .init = digilent_hs1_init,
345 .reset = digilent_hs1_reset,
346 .channel = INTERFACE_A,
347 },
348 { .name = NULL, /* END OF TABLE */ },
349 };
350
351 /* bitmask used to drive nTRST; usually a GPIOLx signal */
352 static uint8_t nTRST;
353 static uint8_t nTRSTnOE;
354 /* bitmask used to drive nSRST; usually a GPIOLx signal */
355 static uint8_t nSRST;
356 static uint8_t nSRSTnOE;
357
358 /** the layout being used with this debug session */
359 static const struct ft2232_layout *layout;
360
361 /** default bitmask values driven on DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
362 static uint8_t low_output;
363
364 /* note that direction bit == 1 means that signal is an output */
365
366 /** default direction bitmask for DBUS: TCK/TDI/TDO/TMS and GPIOL(0..4) */
367 static uint8_t low_direction;
368 /** default value bitmask for CBUS GPIOH(0..4) */
369 static uint8_t high_output;
370 /** default direction bitmask for CBUS GPIOH(0..4) */
371 static uint8_t high_direction;
372
373 #if BUILD_FT2232_FTD2XX == 1
374 static FT_HANDLE ftdih;
375 static FT_DEVICE ftdi_device;
376 #elif BUILD_FT2232_LIBFTDI == 1
377 static struct ftdi_context ftdic;
378 static enum ftdi_chip_type ftdi_device;
379 #endif
380
381 static struct jtag_command *first_unsent; /* next command that has to be sent */
382 static int require_send;
383
384 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
385
386 "There is a significant difference between libftdi and libftd2xx. The latter
387 one allows to schedule up to 64*64 bytes of result data while libftdi fails
388 with more than 4*64. As a consequence, the FT2232 driver is forced to
389 perform around 16x more USB transactions for long command streams with TDO
390 capture when running with libftdi."
391
392 No idea how we get
393 #define FT2232_BUFFER_SIZE 131072
394 a comment would have been nice.
395 */
396
397 #if BUILD_FT2232_FTD2XX == 1
398 #define FT2232_BUFFER_READ_QUEUE_SIZE (64*64)
399 #else
400 #define FT2232_BUFFER_READ_QUEUE_SIZE (64*4)
401 #endif
402
403 #define FT2232_BUFFER_SIZE 131072
404
405 static uint8_t *ft2232_buffer;
406 static int ft2232_buffer_size;
407 static int ft2232_read_pointer;
408 static int ft2232_expect_read;
409
410 /**
411 * Function buffer_write
412 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
413 * @param val is the byte to send.
414 */
415 static inline void buffer_write(uint8_t val)
416 {
417 assert(ft2232_buffer);
418 assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
419 ft2232_buffer[ft2232_buffer_size++] = val;
420 }
421
422 /**
423 * Function buffer_read
424 * returns a byte from the byte buffer.
425 */
426 static inline uint8_t buffer_read(void)
427 {
428 assert(ft2232_buffer);
429 assert(ft2232_read_pointer < ft2232_buffer_size);
430 return ft2232_buffer[ft2232_read_pointer++];
431 }
432
433 /**
434 * Clocks out \a bit_count bits on the TMS line, starting with the least
435 * significant bit of tms_bits and progressing to more significant bits.
436 * Rigorous state transition logging is done here via tap_set_state().
437 *
438 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
439 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
440 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
441 * is often used for this, 0x4b.
442 *
443 * @param tms_bits Holds the sequence of bits to send.
444 * @param tms_count Tells how many bits in the sequence.
445 * @param tdi_bit A single bit to pass on to TDI before the first TCK
446 * cycle and held static for the duration of TMS clocking.
447 *
448 * See the MPSSE spec referenced above.
449 */
450 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
451 {
452 uint8_t tms_byte;
453 int i;
454 int tms_ndx; /* bit index into tms_byte */
455
456 assert(tms_count > 0);
457
458 DEBUG_JTAG_IO("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d",
459 mpsse_cmd, tms_bits, tms_count);
460
461 for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits >>= 1) {
462 bool bit = tms_bits & 1;
463
464 if (bit)
465 tms_byte |= (1 << tms_ndx);
466
467 /* always do state transitions in public view */
468 tap_set_state(tap_state_transition(tap_get_state(), bit));
469
470 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
471 * also increment.
472 */
473 ++tms_ndx;
474
475 if (tms_ndx == 7 || i == tms_count-1) {
476 buffer_write(mpsse_cmd);
477 buffer_write(tms_ndx - 1);
478
479 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
480 * TMS/CS and is held static for the duration of TMS/CS clocking.
481 */
482 buffer_write(tms_byte | (tdi_bit << 7));
483 }
484 }
485 }
486
487 /**
488 * Function get_tms_buffer_requirements
489 * returns what clock_tms() will consume if called with
490 * same \a bit_count.
491 */
492 static inline int get_tms_buffer_requirements(int bit_count)
493 {
494 return ((bit_count + 6)/7) * 3;
495 }
496
497 /**
498 * Function move_to_state
499 * moves the TAP controller from the current state to a
500 * \a goal_state through a path given by tap_get_tms_path(). State transition
501 * logging is performed by delegation to clock_tms().
502 *
503 * @param goal_state is the destination state for the move.
504 */
505 static void move_to_state(tap_state_t goal_state)
506 {
507 tap_state_t start_state = tap_get_state();
508
509 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
510 * lookup of the required TMS pattern to move to this state from the start state.
511 */
512
513 /* do the 2 lookups */
514 int tms_bits = tap_get_tms_path(start_state, goal_state);
515 int tms_count = tap_get_tms_path_len(start_state, goal_state);
516
517 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
518
519 clock_tms(0x4b, tms_bits, tms_count, 0);
520 }
521
522 static int ft2232_write(uint8_t *buf, int size, uint32_t *bytes_written)
523 {
524 #if BUILD_FT2232_FTD2XX == 1
525 FT_STATUS status;
526 DWORD dw_bytes_written = 0;
527 status = FT_Write(ftdih, buf, size, &dw_bytes_written);
528 if (status != FT_OK) {
529 *bytes_written = dw_bytes_written;
530 LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(status));
531 return ERROR_JTAG_DEVICE_ERROR;
532 } else
533 *bytes_written = dw_bytes_written;
534
535 #elif BUILD_FT2232_LIBFTDI == 1
536 int retval = ftdi_write_data(&ftdic, buf, size);
537 if (retval < 0) {
538 *bytes_written = 0;
539 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
540 return ERROR_JTAG_DEVICE_ERROR;
541 } else
542 *bytes_written = retval;
543
544 #endif
545
546 if (*bytes_written != (uint32_t)size)
547 return ERROR_JTAG_DEVICE_ERROR;
548
549 return ERROR_OK;
550 }
551
552 static int ft2232_read(uint8_t *buf, uint32_t size, uint32_t *bytes_read)
553 {
554 #if BUILD_FT2232_FTD2XX == 1
555 DWORD dw_bytes_read;
556 FT_STATUS status;
557 int timeout = 5;
558 *bytes_read = 0;
559
560 while ((*bytes_read < size) && timeout--) {
561 status = FT_Read(ftdih, buf + *bytes_read, size -
562 *bytes_read, &dw_bytes_read);
563 if (status != FT_OK) {
564 *bytes_read = 0;
565 LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(status));
566 return ERROR_JTAG_DEVICE_ERROR;
567 }
568 *bytes_read += dw_bytes_read;
569 }
570
571 #elif BUILD_FT2232_LIBFTDI == 1
572 int retval;
573 int timeout = LIBFTDI_READ_RETRY_COUNT;
574 *bytes_read = 0;
575
576 while ((*bytes_read < size) && timeout--) {
577 retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read);
578 if (retval < 0) {
579 *bytes_read = 0;
580 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
581 return ERROR_JTAG_DEVICE_ERROR;
582 }
583 *bytes_read += retval;
584 }
585
586 #endif
587
588 if (*bytes_read < size) {
589 LOG_ERROR("couldn't read enough bytes from "
590 "FT2232 device (%i < %i)",
591 (unsigned)*bytes_read,
592 (unsigned)size);
593 return ERROR_JTAG_DEVICE_ERROR;
594 }
595
596 return ERROR_OK;
597 }
598
599 static bool ft2232_device_is_highspeed(void)
600 {
601 #if BUILD_FT2232_FTD2XX == 1
602 return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H)
603 #ifdef HAS_ENUM_FT232H
604 || (ftdi_device == FT_DEVICE_232H)
605 #endif
606 ;
607 #elif BUILD_FT2232_LIBFTDI == 1
608 return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H
609 #ifdef HAS_ENUM_FT232H
610 || ftdi_device == TYPE_232H
611 #endif
612 );
613 #endif
614 }
615
616 /*
617 * Commands that only apply to the highspeed FTx232H devices (FT2232H, FT4232H, FT232H).
618 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
619 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
620 */
621
622 static int ftx232h_adaptive_clocking(bool enable)
623 {
624 uint8_t buf = enable ? 0x96 : 0x97;
625 LOG_DEBUG("%2.2x", buf);
626
627 uint32_t bytes_written;
628 int retval;
629
630 retval = ft2232_write(&buf, sizeof(buf), &bytes_written);
631 if (retval != ERROR_OK) {
632 LOG_ERROR("couldn't write command to %s adaptive clocking"
633 , enable ? "enable" : "disable");
634 return retval;
635 }
636
637 return ERROR_OK;
638 }
639
640 /**
641 * Enable/disable the clk divide by 5 of the 60MHz master clock.
642 * This result in a JTAG clock speed range of 91.553Hz-6MHz
643 * respective 457.763Hz-30MHz.
644 */
645 static int ftx232h_clk_divide_by_5(bool enable)
646 {
647 uint32_t bytes_written;
648 uint8_t buf = enable ? 0x8b : 0x8a;
649
650 if (ft2232_write(&buf, sizeof(buf), &bytes_written) != ERROR_OK) {
651 LOG_ERROR("couldn't write command to %s clk divide by 5"
652 , enable ? "enable" : "disable");
653 return ERROR_JTAG_INIT_FAILED;
654 }
655 ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_x232H_MAX_TCK;
656 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
657
658 return ERROR_OK;
659 }
660
661 static int ft2232_speed(int speed)
662 {
663 uint8_t buf[3];
664 int retval;
665 uint32_t bytes_written;
666
667 retval = ERROR_OK;
668 bool enable_adaptive_clocking = (RTCK_SPEED == speed);
669 if (ft2232_device_is_highspeed())
670 retval = ftx232h_adaptive_clocking(enable_adaptive_clocking);
671 else if (enable_adaptive_clocking) {
672 LOG_ERROR("ft2232 device %lu does not support RTCK"
673 , (long unsigned int)ftdi_device);
674 return ERROR_FAIL;
675 }
676
677 if ((enable_adaptive_clocking) || (ERROR_OK != retval))
678 return retval;
679
680 buf[0] = 0x86; /* command "set divisor" */
681 buf[1] = speed & 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
682 buf[2] = (speed >> 8) & 0xff; /* valueH */
683
684 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
685 retval = ft2232_write(buf, sizeof(buf), &bytes_written);
686 if (retval != ERROR_OK) {
687 LOG_ERROR("couldn't set FT2232 TCK speed");
688 return retval;
689 }
690
691 return ERROR_OK;
692 }
693
694 static int ft2232_speed_div(int speed, int *khz)
695 {
696 /* Take a look in the FT2232 manual,
697 * AN2232C-01 Command Processor for
698 * MPSSE and MCU Host Bus. Chapter 3.8 */
699
700 *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
701
702 return ERROR_OK;
703 }
704
705 static int ft2232_khz(int khz, int *jtag_speed)
706 {
707 if (khz == 0) {
708 if (ft2232_device_is_highspeed()) {
709 *jtag_speed = RTCK_SPEED;
710 return ERROR_OK;
711 } else {
712 LOG_DEBUG("RCLK not supported");
713 return ERROR_FAIL;
714 }
715 }
716
717 /* Take a look in the FT2232 manual,
718 * AN2232C-01 Command Processor for
719 * MPSSE and MCU Host Bus. Chapter 3.8
720 *
721 * We will calc here with a multiplier
722 * of 10 for better rounding later. */
723
724 /* Calc speed, (ft2232_max_tck / khz) - 1
725 * Use 65000 for better rounding */
726 *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
727
728 /* Add 0.9 for rounding */
729 *jtag_speed += 9;
730
731 /* Calc real speed */
732 *jtag_speed = *jtag_speed / 10;
733
734 /* Check if speed is greater than 0 */
735 if (*jtag_speed < 0)
736 *jtag_speed = 0;
737
738 /* Check max value */
739 if (*jtag_speed > 0xFFFF)
740 *jtag_speed = 0xFFFF;
741
742 return ERROR_OK;
743 }
744
745 static void ft2232_end_state(tap_state_t state)
746 {
747 if (tap_is_state_stable(state))
748 tap_set_end_state(state);
749 else {
750 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
751 exit(-1);
752 }
753 }
754
755 static void ft2232_read_scan(enum scan_type type, uint8_t *buffer, int scan_size)
756 {
757 int num_bytes = (scan_size + 7) / 8;
758 int bits_left = scan_size;
759 int cur_byte = 0;
760
761 while (num_bytes-- > 1) {
762 buffer[cur_byte++] = buffer_read();
763 bits_left -= 8;
764 }
765
766 buffer[cur_byte] = 0x0;
767
768 /* There is one more partial byte left from the clock data in/out instructions */
769 if (bits_left > 1)
770 buffer[cur_byte] = buffer_read() >> 1;
771 /* This shift depends on the length of the
772 *clock data to tms instruction, insterted
773 *at end of the scan, now fixed to a two
774 *step transition in ft2232_add_scan */
775 buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
776 }
777
778 static void ft2232_debug_dump_buffer(void)
779 {
780 int i;
781 char line[256];
782 char *line_p = line;
783
784 for (i = 0; i < ft2232_buffer_size; i++) {
785 line_p += snprintf(line_p,
786 sizeof(line) - (line_p - line),
787 "%2.2x ",
788 ft2232_buffer[i]);
789 if (i % 16 == 15) {
790 LOG_DEBUG("%s", line);
791 line_p = line;
792 }
793 }
794
795 if (line_p != line)
796 LOG_DEBUG("%s", line);
797 }
798
799 static int ft2232_send_and_recv(struct jtag_command *first, struct jtag_command *last)
800 {
801 struct jtag_command *cmd;
802 uint8_t *buffer;
803 int scan_size;
804 enum scan_type type;
805 int retval;
806 uint32_t bytes_written = 0;
807 uint32_t bytes_read = 0;
808
809 #ifdef _DEBUG_USB_IO_
810 struct timeval start, inter, inter2, end;
811 struct timeval d_inter, d_inter2, d_end;
812 #endif
813
814 #ifdef _DEBUG_USB_COMMS_
815 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
816 ft2232_debug_dump_buffer();
817 #endif
818
819 #ifdef _DEBUG_USB_IO_
820 gettimeofday(&start, NULL);
821 #endif
822
823 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
824 if (retval != ERROR_OK) {
825 LOG_ERROR("couldn't write MPSSE commands to FT2232");
826 return retval;
827 }
828
829 #ifdef _DEBUG_USB_IO_
830 gettimeofday(&inter, NULL);
831 #endif
832
833 if (ft2232_expect_read) {
834 /* FIXME this "timeout" is never changed ... */
835 int timeout = LIBFTDI_READ_RETRY_COUNT;
836 ft2232_buffer_size = 0;
837
838 #ifdef _DEBUG_USB_IO_
839 gettimeofday(&inter2, NULL);
840 #endif
841
842 retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read);
843 if (retval != ERROR_OK) {
844 LOG_ERROR("couldn't read from FT2232");
845 return retval;
846 }
847
848 #ifdef _DEBUG_USB_IO_
849 gettimeofday(&end, NULL);
850
851 timeval_subtract(&d_inter, &inter, &start);
852 timeval_subtract(&d_inter2, &inter2, &start);
853 timeval_subtract(&d_end, &end, &start);
854
855 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
856 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
857 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
858 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
859 #endif
860
861 ft2232_buffer_size = bytes_read;
862
863 if (ft2232_expect_read != ft2232_buffer_size) {
864 LOG_ERROR("ft2232_expect_read (%i) != "
865 "ft2232_buffer_size (%i) "
866 "(%i retries)",
867 ft2232_expect_read,
868 ft2232_buffer_size,
869 LIBFTDI_READ_RETRY_COUNT - timeout);
870 ft2232_debug_dump_buffer();
871
872 exit(-1);
873 }
874
875 #ifdef _DEBUG_USB_COMMS_
876 LOG_DEBUG("read buffer (%i retries): %i bytes",
877 LIBFTDI_READ_RETRY_COUNT - timeout,
878 ft2232_buffer_size);
879 ft2232_debug_dump_buffer();
880 #endif
881 }
882
883 ft2232_expect_read = 0;
884 ft2232_read_pointer = 0;
885
886 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
887 * that wasn't handled by a caller-provided error handler
888 */
889 retval = ERROR_OK;
890
891 cmd = first;
892 while (cmd != last) {
893 switch (cmd->type) {
894 case JTAG_SCAN:
895 type = jtag_scan_type(cmd->cmd.scan);
896 if (type != SCAN_OUT) {
897 scan_size = jtag_scan_size(cmd->cmd.scan);
898 buffer = calloc(DIV_ROUND_UP(scan_size, 8), 1);
899 ft2232_read_scan(type, buffer, scan_size);
900 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
901 retval = ERROR_JTAG_QUEUE_FAILED;
902 free(buffer);
903 }
904 break;
905
906 default:
907 break;
908 }
909
910 cmd = cmd->next;
911 }
912
913 ft2232_buffer_size = 0;
914
915 return retval;
916 }
917
918 /**
919 * Function ft2232_add_pathmove
920 * moves the TAP controller from the current state to a new state through the
921 * given path, where path is an array of tap_state_t's.
922 *
923 * @param path is an array of tap_stat_t which gives the states to traverse through
924 * ending with the last state at path[num_states-1]
925 * @param num_states is the count of state steps to move through
926 */
927 static void ft2232_add_pathmove(tap_state_t *path, int num_states)
928 {
929 int state_count = 0;
930
931 assert((unsigned) num_states <= 32u); /* tms_bits only holds 32 bits */
932
933 DEBUG_JTAG_IO("-");
934
935 /* this loop verifies that the path is legal and logs each state in the path */
936 while (num_states) {
937 unsigned char tms_byte = 0; /* zero this on each MPSSE batch */
938 int bit_count = 0;
939 int num_states_batch = num_states > 7 ? 7 : num_states;
940
941 /* command "Clock Data to TMS/CS Pin (no Read)" */
942 buffer_write(0x4b);
943
944 /* number of states remaining */
945 buffer_write(num_states_batch - 1);
946
947 while (num_states_batch--) {
948 /* either TMS=0 or TMS=1 must work ... */
949 if (tap_state_transition(tap_get_state(), false) == path[state_count])
950 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
951 else if (tap_state_transition(tap_get_state(), true) == path[state_count])
952 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
953
954 /* ... or else the caller goofed BADLY */
955 else {
956 LOG_ERROR("BUG: %s -> %s isn't a valid "
957 "TAP state transition",
958 tap_state_name(tap_get_state()),
959 tap_state_name(path[state_count]));
960 exit(-1);
961 }
962
963 tap_set_state(path[state_count]);
964 state_count++;
965 num_states--;
966 }
967
968 buffer_write(tms_byte);
969 }
970 tap_set_end_state(tap_get_state());
971 }
972
973 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
974 {
975 int num_bytes = (scan_size + 7) / 8;
976 int bits_left = scan_size;
977 int cur_byte = 0;
978 int last_bit;
979
980 if (!ir_scan) {
981 if (tap_get_state() != TAP_DRSHIFT)
982 move_to_state(TAP_DRSHIFT);
983 } else {
984 if (tap_get_state() != TAP_IRSHIFT)
985 move_to_state(TAP_IRSHIFT);
986 }
987
988 /* add command for complete bytes */
989 while (num_bytes > 1) {
990 int thisrun_bytes;
991 if (type == SCAN_IO) {
992 /* Clock Data Bytes In and Out LSB First */
993 buffer_write(0x39);
994 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
995 } else if (type == SCAN_OUT) {
996 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
997 buffer_write(0x19);
998 /* LOG_DEBUG("added TDI bytes (o)"); */
999 } else if (type == SCAN_IN) {
1000 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1001 buffer_write(0x28);
1002 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1003 }
1004
1005 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1006 num_bytes -= thisrun_bytes;
1007
1008 buffer_write((uint8_t) (thisrun_bytes - 1));
1009 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1010
1011 if (type != SCAN_IN) {
1012 /* add complete bytes */
1013 while (thisrun_bytes-- > 0) {
1014 buffer_write(buffer[cur_byte++]);
1015 bits_left -= 8;
1016 }
1017 } else /* (type == SCAN_IN) */
1018 bits_left -= 8 * (thisrun_bytes);
1019 }
1020
1021 /* the most signifcant bit is scanned during TAP movement */
1022 if (type != SCAN_IN)
1023 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1024 else
1025 last_bit = 0;
1026
1027 /* process remaining bits but the last one */
1028 if (bits_left > 1) {
1029 if (type == SCAN_IO) {
1030 /* Clock Data Bits In and Out LSB First */
1031 buffer_write(0x3b);
1032 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1033 } else if (type == SCAN_OUT) {
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 } else if (type == SCAN_IN) {
1038 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1039 buffer_write(0x2a);
1040 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1041 }
1042
1043 buffer_write(bits_left - 2);
1044 if (type != SCAN_IN)
1045 buffer_write(buffer[cur_byte]);
1046 }
1047
1048 if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
1049 || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT))) {
1050 if (type == SCAN_IO) {
1051 /* Clock Data Bits In and Out LSB First */
1052 buffer_write(0x3b);
1053 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1054 } else if (type == SCAN_OUT) {
1055 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1056 buffer_write(0x1b);
1057 /* LOG_DEBUG("added TDI bits (o)"); */
1058 } else if (type == SCAN_IN) {
1059 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1060 buffer_write(0x2a);
1061 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1062 }
1063 buffer_write(0x0);
1064 if (type != SCAN_IN)
1065 buffer_write(last_bit);
1066 } else {
1067 int tms_bits;
1068 int tms_count;
1069 uint8_t mpsse_cmd;
1070
1071 /* move from Shift-IR/DR to end state */
1072 if (type != SCAN_OUT) {
1073 /* We always go to the PAUSE state in two step at the end of an IN or IO
1074 *scan
1075 * This must be coordinated with the bit shifts in ft2232_read_scan */
1076 tms_bits = 0x01;
1077 tms_count = 2;
1078 /* Clock Data to TMS/CS Pin with Read */
1079 mpsse_cmd = 0x6b;
1080 } else {
1081 tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1082 tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1083 /* Clock Data to TMS/CS Pin (no Read) */
1084 mpsse_cmd = 0x4b;
1085 }
1086
1087 DEBUG_JTAG_IO("finish %s", (type == SCAN_OUT) ? "without read" : "via PAUSE");
1088 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1089 }
1090
1091 if (tap_get_state() != tap_get_end_state())
1092 move_to_state(tap_get_end_state());
1093 }
1094
1095 static int ft2232_large_scan(struct scan_command *cmd,
1096 enum scan_type type,
1097 uint8_t *buffer,
1098 int scan_size)
1099 {
1100 int num_bytes = (scan_size + 7) / 8;
1101 int bits_left = scan_size;
1102 int cur_byte = 0;
1103 int last_bit;
1104 uint8_t *receive_buffer = malloc(DIV_ROUND_UP(scan_size, 8));
1105 uint8_t *receive_pointer = receive_buffer;
1106 uint32_t bytes_written;
1107 uint32_t bytes_read;
1108 int retval;
1109 int thisrun_read = 0;
1110
1111 if (!receive_buffer) {
1112 LOG_ERROR("failed to allocate memory");
1113 exit(-1);
1114 }
1115
1116 if (cmd->ir_scan) {
1117 LOG_ERROR("BUG: large IR scans are not supported");
1118 exit(-1);
1119 }
1120
1121 if (tap_get_state() != TAP_DRSHIFT)
1122 move_to_state(TAP_DRSHIFT);
1123
1124 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1125 if (retval != ERROR_OK) {
1126 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1127 exit(-1);
1128 }
1129 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1130 ft2232_buffer_size, (int)bytes_written);
1131 ft2232_buffer_size = 0;
1132
1133 /* add command for complete bytes */
1134 while (num_bytes > 1) {
1135 int thisrun_bytes;
1136
1137 if (type == SCAN_IO) {
1138 /* Clock Data Bytes In and Out LSB First */
1139 buffer_write(0x39);
1140 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1141 } else if (type == SCAN_OUT) {
1142 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1143 buffer_write(0x19);
1144 /* LOG_DEBUG("added TDI bytes (o)"); */
1145 } else if (type == SCAN_IN) {
1146 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1147 buffer_write(0x28);
1148 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1149 }
1150
1151 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1152 thisrun_read = thisrun_bytes;
1153 num_bytes -= thisrun_bytes;
1154 buffer_write((uint8_t) (thisrun_bytes - 1));
1155 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1156
1157 if (type != SCAN_IN) {
1158 /* add complete bytes */
1159 while (thisrun_bytes-- > 0) {
1160 buffer_write(buffer[cur_byte]);
1161 cur_byte++;
1162 bits_left -= 8;
1163 }
1164 } else /* (type == SCAN_IN) */
1165 bits_left -= 8 * (thisrun_bytes);
1166
1167 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1168 if (retval != ERROR_OK) {
1169 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1170 exit(-1);
1171 }
1172 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1173 ft2232_buffer_size,
1174 (int)bytes_written);
1175 ft2232_buffer_size = 0;
1176
1177 if (type != SCAN_OUT) {
1178 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1179 if (retval != ERROR_OK) {
1180 LOG_ERROR("couldn't read from FT2232");
1181 exit(-1);
1182 }
1183 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1184 thisrun_read,
1185 (int)bytes_read);
1186 receive_pointer += bytes_read;
1187 }
1188 }
1189
1190 thisrun_read = 0;
1191
1192 /* the most signifcant bit is scanned during TAP movement */
1193 if (type != SCAN_IN)
1194 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1195 else
1196 last_bit = 0;
1197
1198 /* process remaining bits but the last one */
1199 if (bits_left > 1) {
1200 if (type == SCAN_IO) {
1201 /* Clock Data Bits In and Out LSB First */
1202 buffer_write(0x3b);
1203 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1204 } else if (type == SCAN_OUT) {
1205 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1206 buffer_write(0x1b);
1207 /* LOG_DEBUG("added TDI bits (o)"); */
1208 } else if (type == SCAN_IN) {
1209 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1210 buffer_write(0x2a);
1211 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1212 }
1213 buffer_write(bits_left - 2);
1214 if (type != SCAN_IN)
1215 buffer_write(buffer[cur_byte]);
1216
1217 if (type != SCAN_OUT)
1218 thisrun_read += 2;
1219 }
1220
1221 if (tap_get_end_state() == TAP_DRSHIFT) {
1222 if (type == SCAN_IO) {
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 } else if (type == SCAN_OUT) {
1227 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1228 buffer_write(0x1b);
1229 /* LOG_DEBUG("added TDI bits (o)"); */
1230 } else if (type == SCAN_IN) {
1231 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1232 buffer_write(0x2a);
1233 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1234 }
1235 buffer_write(0x0);
1236 buffer_write(last_bit);
1237 } else {
1238 int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1239 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1240 uint8_t mpsse_cmd;
1241
1242 /* move from Shift-IR/DR to end state */
1243 if (type != SCAN_OUT) {
1244 /* Clock Data to TMS/CS Pin with Read */
1245 mpsse_cmd = 0x6b;
1246 /* LOG_DEBUG("added TMS scan (read)"); */
1247 } else {
1248 /* Clock Data to TMS/CS Pin (no Read) */
1249 mpsse_cmd = 0x4b;
1250 /* LOG_DEBUG("added TMS scan (no read)"); */
1251 }
1252
1253 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1254 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1255 }
1256
1257 if (type != SCAN_OUT)
1258 thisrun_read += 1;
1259
1260 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1261 if (retval != ERROR_OK) {
1262 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1263 exit(-1);
1264 }
1265 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1266 ft2232_buffer_size,
1267 (int)bytes_written);
1268 ft2232_buffer_size = 0;
1269
1270 if (type != SCAN_OUT) {
1271 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1272 if (retval != ERROR_OK) {
1273 LOG_ERROR("couldn't read from FT2232");
1274 exit(-1);
1275 }
1276 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1277 thisrun_read,
1278 (int)bytes_read);
1279 }
1280
1281 free(receive_buffer);
1282
1283 return ERROR_OK;
1284 }
1285
1286 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1287 {
1288 int predicted_size = 3;
1289 int num_bytes = (scan_size - 1) / 8;
1290
1291 if (tap_get_state() != TAP_DRSHIFT)
1292 predicted_size += get_tms_buffer_requirements(
1293 tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1294
1295 if (type == SCAN_IN) { /* only from device to host */
1296 /* complete bytes */
1297 predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
1298
1299 /* remaining bits - 1 (up to 7) */
1300 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1301 } else {/* host to device, or bidirectional
1302 * complete bytes */
1303 predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
1304
1305 /* remaining bits -1 (up to 7) */
1306 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1307 }
1308
1309 return predicted_size;
1310 }
1311
1312 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1313 {
1314 int predicted_size = 0;
1315
1316 if (type != SCAN_OUT) {
1317 /* complete bytes */
1318 predicted_size +=
1319 (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
1320
1321 /* remaining bits - 1 */
1322 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1323
1324 /* last bit (from TMS scan) */
1325 predicted_size += 1;
1326 }
1327
1328 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1329
1330 return predicted_size;
1331 }
1332
1333 /* semi-generic FT2232/FT4232 reset code */
1334 static void ftx23_reset(int trst, int srst)
1335 {
1336 enum reset_types jtag_reset_config = jtag_get_reset_config();
1337 if (trst == 1) {
1338 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1339 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1340 else
1341 low_output &= ~nTRST; /* switch output low */
1342 } else if (trst == 0) {
1343 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1344 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal
1345 *and external pullup) */
1346 else
1347 low_output |= nTRST; /* switch output high */
1348 }
1349
1350 if (srst == 1) {
1351 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1352 low_output &= ~nSRST; /* switch output low */
1353 else
1354 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1355 } else if (srst == 0) {
1356 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1357 low_output |= nSRST; /* switch output high */
1358 else
1359 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1360 }
1361
1362 /* command "set data bits low byte" */
1363 buffer_write(0x80);
1364 buffer_write(low_output);
1365 buffer_write(low_direction);
1366 }
1367
1368 static void jtagkey_reset(int trst, int srst)
1369 {
1370 enum reset_types jtag_reset_config = jtag_get_reset_config();
1371 if (trst == 1) {
1372 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1373 high_output &= ~nTRSTnOE;
1374 else
1375 high_output &= ~nTRST;
1376 } else if (trst == 0) {
1377 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1378 high_output |= nTRSTnOE;
1379 else
1380 high_output |= nTRST;
1381 }
1382
1383 if (srst == 1) {
1384 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1385 high_output &= ~nSRST;
1386 else
1387 high_output &= ~nSRSTnOE;
1388 } else if (srst == 0) {
1389 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1390 high_output |= nSRST;
1391 else
1392 high_output |= nSRSTnOE;
1393 }
1394
1395 /* command "set data bits high byte" */
1396 buffer_write(0x82);
1397 buffer_write(high_output);
1398 buffer_write(high_direction);
1399 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1400 trst,
1401 srst,
1402 high_output,
1403 high_direction);
1404 }
1405
1406 static void olimex_jtag_reset(int trst, int srst)
1407 {
1408 enum reset_types jtag_reset_config = jtag_get_reset_config();
1409 if (trst == 1) {
1410 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1411 high_output &= ~nTRSTnOE;
1412 else
1413 high_output &= ~nTRST;
1414 } else if (trst == 0) {
1415 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1416 high_output |= nTRSTnOE;
1417 else
1418 high_output |= nTRST;
1419 }
1420
1421 if (srst == 1)
1422 high_output |= nSRST;
1423 else if (srst == 0)
1424 high_output &= ~nSRST;
1425
1426 /* command "set data bits high byte" */
1427 buffer_write(0x82);
1428 buffer_write(high_output);
1429 buffer_write(high_direction);
1430 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1431 trst,
1432 srst,
1433 high_output,
1434 high_direction);
1435 }
1436
1437 static void axm0432_jtag_reset(int trst, int srst)
1438 {
1439 if (trst == 1) {
1440 tap_set_state(TAP_RESET);
1441 high_output &= ~nTRST;
1442 } else if (trst == 0)
1443 high_output |= nTRST;
1444
1445 if (srst == 1)
1446 high_output &= ~nSRST;
1447 else if (srst == 0)
1448 high_output |= nSRST;
1449
1450 /* command "set data bits low byte" */
1451 buffer_write(0x82);
1452 buffer_write(high_output);
1453 buffer_write(high_direction);
1454 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1455 trst,
1456 srst,
1457 high_output,
1458 high_direction);
1459 }
1460
1461 static void flyswatter_reset(int trst, int srst)
1462 {
1463 if (trst == 1)
1464 low_output &= ~nTRST;
1465 else if (trst == 0)
1466 low_output |= nTRST;
1467
1468 if (srst == 1)
1469 low_output |= nSRST;
1470 else if (srst == 0)
1471 low_output &= ~nSRST;
1472
1473 /* command "set data bits low byte" */
1474 buffer_write(0x80);
1475 buffer_write(low_output);
1476 buffer_write(low_direction);
1477 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1478 trst,
1479 srst,
1480 low_output,
1481 low_direction);
1482 }
1483
1484 static void flyswatter1_reset(int trst, int srst)
1485 {
1486 flyswatter_reset(trst, srst);
1487 }
1488
1489 static void flyswatter2_reset(int trst, int srst)
1490 {
1491 flyswatter_reset(trst, !srst);
1492 }
1493
1494 static void minimodule_reset(int trst, int srst)
1495 {
1496 if (srst == 1)
1497 low_output &= ~nSRST;
1498 else if (srst == 0)
1499 low_output |= nSRST;
1500
1501 /* command "set data bits low byte" */
1502 buffer_write(0x80);
1503 buffer_write(low_output);
1504 buffer_write(low_direction);
1505 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1506 trst,
1507 srst,
1508 low_output,
1509 low_direction);
1510 }
1511
1512 static void turtle_reset(int trst, int srst)
1513 {
1514 if (trst == 1)
1515 LOG_ERROR("Can't assert TRST: the adapter lacks this signal");
1516
1517 if (srst == 1)
1518 low_output |= nSRST;
1519 else if (srst == 0)
1520 low_output &= ~nSRST;
1521
1522 /* command "set data bits low byte" */
1523 buffer_write(0x80);
1524 buffer_write(low_output);
1525 buffer_write(low_direction);
1526 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1527 srst,
1528 low_output,
1529 low_direction);
1530 }
1531
1532 static void comstick_reset(int trst, int srst)
1533 {
1534 if (trst == 1)
1535 high_output &= ~nTRST;
1536 else if (trst == 0)
1537 high_output |= nTRST;
1538
1539 if (srst == 1)
1540 high_output &= ~nSRST;
1541 else if (srst == 0)
1542 high_output |= nSRST;
1543
1544 /* command "set data bits high byte" */
1545 buffer_write(0x82);
1546 buffer_write(high_output);
1547 buffer_write(high_direction);
1548 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1549 trst,
1550 srst,
1551 high_output,
1552 high_direction);
1553 }
1554
1555 static void stm32stick_reset(int trst, int srst)
1556 {
1557 if (trst == 1)
1558 high_output &= ~nTRST;
1559 else if (trst == 0)
1560 high_output |= nTRST;
1561
1562 if (srst == 1)
1563 low_output &= ~nSRST;
1564 else if (srst == 0)
1565 low_output |= nSRST;
1566
1567 /* command "set data bits low byte" */
1568 buffer_write(0x80);
1569 buffer_write(low_output);
1570 buffer_write(low_direction);
1571
1572 /* command "set data bits high byte" */
1573 buffer_write(0x82);
1574 buffer_write(high_output);
1575 buffer_write(high_direction);
1576 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1577 trst,
1578 srst,
1579 high_output,
1580 high_direction);
1581 }
1582
1583 static void sheevaplug_reset(int trst, int srst)
1584 {
1585 if (trst == 1)
1586 high_output &= ~nTRST;
1587 else if (trst == 0)
1588 high_output |= nTRST;
1589
1590 if (srst == 1)
1591 high_output &= ~nSRSTnOE;
1592 else if (srst == 0)
1593 high_output |= nSRSTnOE;
1594
1595 /* command "set data bits high byte" */
1596 buffer_write(0x82);
1597 buffer_write(high_output);
1598 buffer_write(high_direction);
1599 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1600 trst,
1601 srst,
1602 high_output,
1603 high_direction);
1604 }
1605
1606 static void redbee_reset(int trst, int srst)
1607 {
1608 if (trst == 1) {
1609 tap_set_state(TAP_RESET);
1610 high_output &= ~nTRST;
1611 } else if (trst == 0)
1612 high_output |= nTRST;
1613
1614 if (srst == 1)
1615 high_output &= ~nSRST;
1616 else if (srst == 0)
1617 high_output |= nSRST;
1618
1619 /* command "set data bits low byte" */
1620 buffer_write(0x82);
1621 buffer_write(high_output);
1622 buffer_write(high_direction);
1623 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1624 "high_direction: 0x%2.2x", trst, srst, high_output,
1625 high_direction);
1626 }
1627
1628 static void xds100v2_reset(int trst, int srst)
1629 {
1630 if (trst == 1) {
1631 tap_set_state(TAP_RESET);
1632 high_output &= ~nTRST;
1633 } else if (trst == 0)
1634 high_output |= nTRST;
1635
1636 if (srst == 1)
1637 high_output |= nSRST;
1638 else if (srst == 0)
1639 high_output &= ~nSRST;
1640
1641 /* command "set data bits low byte" */
1642 buffer_write(0x82);
1643 buffer_write(high_output);
1644 buffer_write(high_direction);
1645 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1646 "high_direction: 0x%2.2x", trst, srst, high_output,
1647 high_direction);
1648 }
1649
1650 static int ft2232_execute_runtest(struct jtag_command *cmd)
1651 {
1652 int retval;
1653 int i;
1654 int predicted_size = 0;
1655 retval = ERROR_OK;
1656
1657 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1658 cmd->cmd.runtest->num_cycles,
1659 tap_state_name(cmd->cmd.runtest->end_state));
1660
1661 /* only send the maximum buffer size that FT2232C can handle */
1662 predicted_size = 0;
1663 if (tap_get_state() != TAP_IDLE)
1664 predicted_size += 3;
1665 predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
1666 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1667 predicted_size += 3;
1668 if (tap_get_end_state() != TAP_IDLE)
1669 predicted_size += 3;
1670 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1671 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1672 retval = ERROR_JTAG_QUEUE_FAILED;
1673 require_send = 0;
1674 first_unsent = cmd;
1675 }
1676 if (tap_get_state() != TAP_IDLE) {
1677 move_to_state(TAP_IDLE);
1678 require_send = 1;
1679 }
1680 i = cmd->cmd.runtest->num_cycles;
1681 while (i > 0) {
1682 /* there are no state transitions in this code, so omit state tracking */
1683
1684 /* command "Clock Data to TMS/CS Pin (no Read)" */
1685 buffer_write(0x4b);
1686
1687 /* scan 7 bits */
1688 buffer_write((i > 7) ? 6 : (i - 1));
1689
1690 /* TMS data bits */
1691 buffer_write(0x0);
1692
1693 i -= (i > 7) ? 7 : i;
1694 /* LOG_DEBUG("added TMS scan (no read)"); */
1695 }
1696
1697 ft2232_end_state(cmd->cmd.runtest->end_state);
1698
1699 if (tap_get_state() != tap_get_end_state())
1700 move_to_state(tap_get_end_state());
1701
1702 require_send = 1;
1703 DEBUG_JTAG_IO("runtest: %i, end in %s",
1704 cmd->cmd.runtest->num_cycles,
1705 tap_state_name(tap_get_end_state()));
1706 return retval;
1707 }
1708
1709 static int ft2232_execute_statemove(struct jtag_command *cmd)
1710 {
1711 int predicted_size = 0;
1712 int retval = ERROR_OK;
1713
1714 DEBUG_JTAG_IO("statemove end in %s",
1715 tap_state_name(cmd->cmd.statemove->end_state));
1716
1717 /* only send the maximum buffer size that FT2232C can handle */
1718 predicted_size = 3;
1719 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1720 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1721 retval = ERROR_JTAG_QUEUE_FAILED;
1722 require_send = 0;
1723 first_unsent = cmd;
1724 }
1725 ft2232_end_state(cmd->cmd.statemove->end_state);
1726
1727 /* For TAP_RESET, ignore the current recorded state. It's often
1728 * wrong at server startup, and this transation is critical whenever
1729 * it's requested.
1730 */
1731 if (tap_get_end_state() == TAP_RESET) {
1732 clock_tms(0x4b, 0xff, 5, 0);
1733 require_send = 1;
1734
1735 /* shortest-path move to desired end state */
1736 } else if (tap_get_state() != tap_get_end_state()) {
1737 move_to_state(tap_get_end_state());
1738 require_send = 1;
1739 }
1740
1741 return retval;
1742 }
1743
1744 /**
1745 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
1746 * (or SWD) state machine.
1747 */
1748 static int ft2232_execute_tms(struct jtag_command *cmd)
1749 {
1750 int retval = ERROR_OK;
1751 unsigned num_bits = cmd->cmd.tms->num_bits;
1752 const uint8_t *bits = cmd->cmd.tms->bits;
1753 unsigned count;
1754
1755 DEBUG_JTAG_IO("TMS: %d bits", num_bits);
1756
1757 /* only send the maximum buffer size that FT2232C can handle */
1758 count = 3 * DIV_ROUND_UP(num_bits, 4);
1759 if (ft2232_buffer_size + 3*count + 1 > FT2232_BUFFER_SIZE) {
1760 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1761 retval = ERROR_JTAG_QUEUE_FAILED;
1762
1763 require_send = 0;
1764 first_unsent = cmd;
1765 }
1766
1767 /* Shift out in batches of at most 6 bits; there's a report of an
1768 * FT2232 bug in this area, where shifting exactly 7 bits can make
1769 * problems with TMS signaling for the last clock cycle:
1770 *
1771 * http://developer.intra2net.com/mailarchive/html/
1772 * libftdi/2009/msg00292.html
1773 *
1774 * Command 0x4b is: "Clock Data to TMS/CS Pin (no Read)"
1775 *
1776 * Note that pathmoves in JTAG are not often seven bits, so that
1777 * isn't a particularly likely situation outside of "special"
1778 * signaling such as switching between JTAG and SWD modes.
1779 */
1780 while (num_bits) {
1781 if (num_bits <= 6) {
1782 buffer_write(0x4b);
1783 buffer_write(num_bits - 1);
1784 buffer_write(*bits & 0x3f);
1785 break;
1786 }
1787
1788 /* Yes, this is lazy ... we COULD shift out more data
1789 * bits per operation, but doing it in nybbles is easy
1790 */
1791 buffer_write(0x4b);
1792 buffer_write(3);
1793 buffer_write(*bits & 0xf);
1794 num_bits -= 4;
1795
1796 count = (num_bits > 4) ? 4 : num_bits;
1797
1798 buffer_write(0x4b);
1799 buffer_write(count - 1);
1800 buffer_write((*bits >> 4) & 0xf);
1801 num_bits -= count;
1802
1803 bits++;
1804 }
1805
1806 require_send = 1;
1807 return retval;
1808 }
1809
1810 static int ft2232_execute_pathmove(struct jtag_command *cmd)
1811 {
1812 int predicted_size = 0;
1813 int retval = ERROR_OK;
1814
1815 tap_state_t *path = cmd->cmd.pathmove->path;
1816 int num_states = cmd->cmd.pathmove->num_states;
1817
1818 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1819 tap_state_name(tap_get_state()),
1820 tap_state_name(path[num_states-1]));
1821
1822 /* only send the maximum buffer size that FT2232C can handle */
1823 predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
1824 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1825 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1826 retval = ERROR_JTAG_QUEUE_FAILED;
1827
1828 require_send = 0;
1829 first_unsent = cmd;
1830 }
1831
1832 ft2232_add_pathmove(path, num_states);
1833 require_send = 1;
1834
1835 return retval;
1836 }
1837
1838 static int ft2232_execute_scan(struct jtag_command *cmd)
1839 {
1840 uint8_t *buffer;
1841 int scan_size; /* size of IR or DR scan */
1842 int predicted_size = 0;
1843 int retval = ERROR_OK;
1844
1845 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1846
1847 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1848
1849 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1850
1851 predicted_size = ft2232_predict_scan_out(scan_size, type);
1852 if ((predicted_size + 1) > FT2232_BUFFER_SIZE) {
1853 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1854 /* unsent commands before this */
1855 if (first_unsent != cmd)
1856 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1857 retval = ERROR_JTAG_QUEUE_FAILED;
1858
1859 /* current command */
1860 ft2232_end_state(cmd->cmd.scan->end_state);
1861 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1862 require_send = 0;
1863 first_unsent = cmd->next;
1864 if (buffer)
1865 free(buffer);
1866 return retval;
1867 } else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1868 LOG_DEBUG(
1869 "ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1870 first_unsent,
1871 cmd);
1872 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1873 retval = ERROR_JTAG_QUEUE_FAILED;
1874 require_send = 0;
1875 first_unsent = cmd;
1876 }
1877 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1878 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1879 ft2232_end_state(cmd->cmd.scan->end_state);
1880 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1881 require_send = 1;
1882 if (buffer)
1883 free(buffer);
1884 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1885 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1886 tap_state_name(tap_get_end_state()));
1887 return retval;
1888
1889 }
1890
1891 static int ft2232_execute_reset(struct jtag_command *cmd)
1892 {
1893 int retval;
1894 int predicted_size = 0;
1895 retval = ERROR_OK;
1896
1897 DEBUG_JTAG_IO("reset trst: %i srst %i",
1898 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1899
1900 /* only send the maximum buffer size that FT2232C can handle */
1901 predicted_size = 3;
1902 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1903 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1904 retval = ERROR_JTAG_QUEUE_FAILED;
1905 require_send = 0;
1906 first_unsent = cmd;
1907 }
1908
1909 if ((cmd->cmd.reset->trst == 1) ||
1910 (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1911 tap_set_state(TAP_RESET);
1912
1913 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1914 require_send = 1;
1915
1916 DEBUG_JTAG_IO("trst: %i, srst: %i",
1917 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1918 return retval;
1919 }
1920
1921 static int ft2232_execute_sleep(struct jtag_command *cmd)
1922 {
1923 int retval;
1924 retval = ERROR_OK;
1925
1926 DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
1927
1928 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1929 retval = ERROR_JTAG_QUEUE_FAILED;
1930 first_unsent = cmd->next;
1931 jtag_sleep(cmd->cmd.sleep->us);
1932 DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
1933 cmd->cmd.sleep->us,
1934 tap_state_name(tap_get_state()));
1935 return retval;
1936 }
1937
1938 static int ft2232_execute_stableclocks(struct jtag_command *cmd)
1939 {
1940 int retval;
1941 retval = ERROR_OK;
1942
1943 /* this is only allowed while in a stable state. A check for a stable
1944 * state was done in jtag_add_clocks()
1945 */
1946 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1947 retval = ERROR_JTAG_QUEUE_FAILED;
1948 DEBUG_JTAG_IO("clocks %i while in %s",
1949 cmd->cmd.stableclocks->num_cycles,
1950 tap_state_name(tap_get_state()));
1951 return retval;
1952 }
1953
1954 static int ft2232_execute_command(struct jtag_command *cmd)
1955 {
1956 int retval;
1957
1958 switch (cmd->type) {
1959 case JTAG_RESET:
1960 retval = ft2232_execute_reset(cmd);
1961 break;
1962 case JTAG_RUNTEST:
1963 retval = ft2232_execute_runtest(cmd);
1964 break;
1965 case JTAG_TLR_RESET:
1966 retval = ft2232_execute_statemove(cmd);
1967 break;
1968 case JTAG_PATHMOVE:
1969 retval = ft2232_execute_pathmove(cmd);
1970 break;
1971 case JTAG_SCAN:
1972 retval = ft2232_execute_scan(cmd);
1973 break;
1974 case JTAG_SLEEP:
1975 retval = ft2232_execute_sleep(cmd);
1976 break;
1977 case JTAG_STABLECLOCKS:
1978 retval = ft2232_execute_stableclocks(cmd);
1979 break;
1980 case JTAG_TMS:
1981 retval = ft2232_execute_tms(cmd);
1982 break;
1983 default:
1984 LOG_ERROR("BUG: unknown JTAG command type encountered");
1985 retval = ERROR_JTAG_QUEUE_FAILED;
1986 break;
1987 }
1988 return retval;
1989 }
1990
1991 static int ft2232_execute_queue(void)
1992 {
1993 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1994 int retval;
1995
1996 first_unsent = cmd; /* next command that has to be sent */
1997 require_send = 0;
1998
1999 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
2000 * that wasn't handled by a caller-provided error handler
2001 */
2002 retval = ERROR_OK;
2003
2004 ft2232_buffer_size = 0;
2005 ft2232_expect_read = 0;
2006
2007 /* blink, if the current layout has that feature */
2008 if (layout->blink)
2009 layout->blink();
2010
2011 while (cmd) {
2012 /* fill the write buffer with the desired command */
2013 if (ft2232_execute_command(cmd) != ERROR_OK)
2014 retval = ERROR_JTAG_QUEUE_FAILED;
2015 /* Start reading input before FT2232 TX buffer fills up.
2016 * Sometimes this happens because we don't know the
2017 * length of the last command before we execute it. So
2018 * we simple inform the user.
2019 */
2020 cmd = cmd->next;
2021
2022 if (ft2232_expect_read >= FT2232_BUFFER_READ_QUEUE_SIZE) {
2023 if (ft2232_expect_read > (FT2232_BUFFER_READ_QUEUE_SIZE+1))
2024 LOG_DEBUG("read buffer size looks too high %d/%d",
2025 ft2232_expect_read,
2026 (FT2232_BUFFER_READ_QUEUE_SIZE+1));
2027 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2028 retval = ERROR_JTAG_QUEUE_FAILED;
2029 first_unsent = cmd;
2030 }
2031 }
2032
2033 if (require_send > 0)
2034 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2035 retval = ERROR_JTAG_QUEUE_FAILED;
2036
2037 return retval;
2038 }
2039
2040 #if BUILD_FT2232_FTD2XX == 1
2041 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int *try_more)
2042 {
2043 FT_STATUS status;
2044 DWORD deviceID;
2045 char SerialNumber[16];
2046 char Description[64];
2047 DWORD openex_flags = 0;
2048 char *openex_string = NULL;
2049 uint8_t latency_timer;
2050
2051 if (layout == NULL) {
2052 LOG_WARNING("No ft2232 layout specified'");
2053 return ERROR_JTAG_INIT_FAILED;
2054 }
2055
2056 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)",
2057 layout->name, vid, pid);
2058
2059 #if IS_WIN32 == 0
2060 /* Add non-standard Vid/Pid to the linux driver */
2061 status = FT_SetVIDPID(vid, pid);
2062 if (status != FT_OK)
2063 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
2064
2065 #endif
2066
2067 if (ft2232_device_desc && ft2232_serial) {
2068 LOG_WARNING(
2069 "can't open by device description and serial number, giving precedence to serial");
2070 ft2232_device_desc = NULL;
2071 }
2072
2073 if (ft2232_device_desc) {
2074 openex_string = ft2232_device_desc;
2075 openex_flags = FT_OPEN_BY_DESCRIPTION;
2076 } else if (ft2232_serial) {
2077 openex_string = ft2232_serial;
2078 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
2079 } else {
2080 LOG_ERROR("neither device description nor serial number specified");
2081 LOG_ERROR(
2082 "please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
2083
2084 return ERROR_JTAG_INIT_FAILED;
2085 }
2086
2087 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2088 if (status != FT_OK) {
2089 /* under Win32, the FTD2XX driver appends an "A" to the end
2090 * of the description, if we tried by the desc, then
2091 * try by the alternate "A" description. */
2092 if (openex_string == ft2232_device_desc) {
2093 /* Try the alternate method. */
2094 openex_string = ft2232_device_desc_A;
2095 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2096 if (status == FT_OK) {
2097 /* yea, the "alternate" method worked! */
2098 } else {
2099 /* drat, give the user a meaningfull message.
2100 * telling the use we tried *BOTH* methods. */
2101 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'",
2102 ft2232_device_desc,
2103 ft2232_device_desc_A);
2104 }
2105 }
2106 }
2107
2108 if (status != FT_OK) {
2109 DWORD num_devices;
2110
2111 if (more) {
2112 LOG_WARNING("unable to open ftdi device (trying more): %s",
2113 ftd2xx_status_string(status));
2114 *try_more = 1;
2115 return ERROR_JTAG_INIT_FAILED;
2116 }
2117 LOG_ERROR("unable to open ftdi device: %s",
2118 ftd2xx_status_string(status));
2119 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
2120 if (status == FT_OK) {
2121 char **desc_array = malloc(sizeof(char *) * (num_devices + 1));
2122 uint32_t i;
2123
2124 for (i = 0; i < num_devices; i++)
2125 desc_array[i] = malloc(64);
2126
2127 desc_array[num_devices] = NULL;
2128
2129 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
2130
2131 if (status == FT_OK) {
2132 LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
2133 for (i = 0; i < num_devices; i++)
2134 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
2135 }
2136
2137 for (i = 0; i < num_devices; i++)
2138 free(desc_array[i]);
2139
2140 free(desc_array);
2141 } else
2142 LOG_ERROR("ListDevices: NONE");
2143 return ERROR_JTAG_INIT_FAILED;
2144 }
2145
2146 status = FT_SetLatencyTimer(ftdih, ft2232_latency);
2147 if (status != FT_OK) {
2148 LOG_ERROR("unable to set latency timer: %s",
2149 ftd2xx_status_string(status));
2150 return ERROR_JTAG_INIT_FAILED;
2151 }
2152
2153 status = FT_GetLatencyTimer(ftdih, &latency_timer);
2154 if (status != FT_OK) {
2155 /* ftd2xx 1.04 (linux) has a bug when calling FT_GetLatencyTimer
2156 * so ignore errors if using this driver version */
2157 DWORD dw_version;
2158
2159 status = FT_GetDriverVersion(ftdih, &dw_version);
2160 LOG_ERROR("unable to get latency timer: %s",
2161 ftd2xx_status_string(status));
2162
2163 if ((status == FT_OK) && (dw_version == 0x10004)) {
2164 LOG_ERROR("ftd2xx 1.04 detected - this has known issues " \
2165 "with FT_GetLatencyTimer, upgrade to a newer version");
2166 } else
2167 return ERROR_JTAG_INIT_FAILED;
2168 } else
2169 LOG_DEBUG("current latency timer: %i", latency_timer);
2170
2171 status = FT_SetTimeouts(ftdih, 5000, 5000);
2172 if (status != FT_OK) {
2173 LOG_ERROR("unable to set timeouts: %s",
2174 ftd2xx_status_string(status));
2175 return ERROR_JTAG_INIT_FAILED;
2176 }
2177
2178 status = FT_SetBitMode(ftdih, 0x0b, 2);
2179 if (status != FT_OK) {
2180 LOG_ERROR("unable to enable bit i/o mode: %s",
2181 ftd2xx_status_string(status));
2182 return ERROR_JTAG_INIT_FAILED;
2183 }
2184
2185 status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID,
2186 SerialNumber, Description, NULL);
2187 if (status != FT_OK) {
2188 LOG_ERROR("unable to get FT_GetDeviceInfo: %s",
2189 ftd2xx_status_string(status));
2190 return ERROR_JTAG_INIT_FAILED;
2191 } else {
2192 static const char *type_str[] = {
2193 "BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H", "232H"
2194 };
2195 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2196 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
2197 ? ftdi_device : FT_DEVICE_UNKNOWN;
2198 LOG_INFO("device: %" PRIu32 " \"%s\"", (uint32_t)ftdi_device, type_str[type_index]);
2199 LOG_INFO("deviceID: %" PRIu32, (uint32_t)deviceID);
2200 LOG_INFO("SerialNumber: %s", SerialNumber);
2201 LOG_INFO("Description: %s", Description);
2202 }
2203
2204 return ERROR_OK;
2205 }
2206
2207 static int ft2232_purge_ftd2xx(void)
2208 {
2209 FT_STATUS status;
2210
2211 status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
2212 if (status != FT_OK) {
2213 LOG_ERROR("error purging ftd2xx device: %s",
2214 ftd2xx_status_string(status));
2215 return ERROR_JTAG_INIT_FAILED;
2216 }
2217
2218 return ERROR_OK;
2219 }
2220
2221 #endif /* BUILD_FT2232_FTD2XX == 1 */
2222
2223 #if BUILD_FT2232_LIBFTDI == 1
2224 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int *try_more, int channel)
2225 {
2226 uint8_t latency_timer;
2227
2228 if (layout == NULL) {
2229 LOG_WARNING("No ft2232 layout specified'");
2230 return ERROR_JTAG_INIT_FAILED;
2231 }
2232
2233 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2234 layout->name, vid, pid);
2235
2236 if (ftdi_init(&ftdic) < 0)
2237 return ERROR_JTAG_INIT_FAILED;
2238
2239 /* default to INTERFACE_A */
2240 if (channel == INTERFACE_ANY)
2241 channel = INTERFACE_A;
2242 if (ftdi_set_interface(&ftdic, channel) < 0) {
2243 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2244 return ERROR_JTAG_INIT_FAILED;
2245 }
2246
2247 /* context, vendor id, product id */
2248 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc, ft2232_serial) < 0) {
2249 if (more)
2250 LOG_WARNING("unable to open ftdi device (trying more): %s",
2251 ftdic.error_str);
2252 else
2253 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2254 *try_more = 1;
2255 return ERROR_JTAG_INIT_FAILED;
2256 }
2257
2258 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2259 if (ftdi_usb_reset(&ftdic) < 0) {
2260 LOG_ERROR("unable to reset ftdi device");
2261 return ERROR_JTAG_INIT_FAILED;
2262 }
2263
2264 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0) {
2265 LOG_ERROR("unable to set latency timer");
2266 return ERROR_JTAG_INIT_FAILED;
2267 }
2268
2269 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
2270 LOG_ERROR("unable to get latency timer");
2271 return ERROR_JTAG_INIT_FAILED;
2272 } else
2273 LOG_DEBUG("current latency timer: %i", latency_timer);
2274
2275 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2276
2277 ftdi_device = ftdic.type;
2278 static const char *type_str[] = {
2279 "AM", "BM", "2232C", "R", "2232H", "4232H", "232H", "Unknown"
2280 };
2281 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2282 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2283 ? ftdi_device : no_of_known_types;
2284 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2285 return ERROR_OK;
2286 }
2287
2288 static int ft2232_purge_libftdi(void)
2289 {
2290 if (ftdi_usb_purge_buffers(&ftdic) < 0) {
2291 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2292 return ERROR_JTAG_INIT_FAILED;
2293 }
2294
2295 return ERROR_OK;
2296 }
2297
2298 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2299
2300 static int ft2232_set_data_bits_low_byte(uint8_t value, uint8_t direction)
2301 {
2302 uint8_t buf[3];
2303 uint32_t bytes_written;
2304
2305 buf[0] = 0x80; /* command "set data bits low byte" */
2306 buf[1] = value; /* value */
2307 buf[2] = direction; /* direction */
2308
2309 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2310
2311 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2312 LOG_ERROR("couldn't initialize data bits low byte");
2313 return ERROR_JTAG_INIT_FAILED;
2314 }
2315
2316 return ERROR_OK;
2317 }
2318
2319 static int ft2232_set_data_bits_high_byte(uint8_t value, uint8_t direction)
2320 {
2321 uint8_t buf[3];
2322 uint32_t bytes_written;
2323
2324 buf[0] = 0x82; /* command "set data bits high byte" */
2325 buf[1] = value; /* value */
2326 buf[2] = direction; /* direction */
2327
2328 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2329
2330 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2331 LOG_ERROR("couldn't initialize data bits high byte");
2332 return ERROR_JTAG_INIT_FAILED;
2333 }
2334
2335 return ERROR_OK;
2336 }
2337
2338 static int ft2232_init(void)
2339 {
2340 uint8_t buf[1];
2341 int retval;
2342 uint32_t bytes_written;
2343
2344 if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
2345 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2346 else
2347 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2348 if (layout == NULL) {
2349 LOG_WARNING("No ft2232 layout specified'");
2350 return ERROR_JTAG_INIT_FAILED;
2351 }
2352
2353 for (int i = 0; 1; i++) {
2354 /*
2355 * "more indicates that there are more IDs to try, so we should
2356 * not print an error for an ID mismatch (but for anything
2357 * else, we should).
2358 *
2359 * try_more indicates that the error code returned indicates an
2360 * ID mismatch (and nothing else) and that we should proceeed
2361 * with the next ID pair.
2362 */
2363 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2364 int try_more = 0;
2365
2366 #if BUILD_FT2232_FTD2XX == 1
2367 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2368 more, &try_more);
2369 #elif BUILD_FT2232_LIBFTDI == 1
2370 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2371 more, &try_more, ft2232_channel);
2372 #endif
2373 if (retval >= 0)
2374 break;
2375 if (!more || !try_more)
2376 return retval;
2377 }
2378
2379 ft2232_buffer_size = 0;
2380 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2381
2382 if (layout->init() != ERROR_OK)
2383 return ERROR_JTAG_INIT_FAILED;
2384
2385 if (ft2232_device_is_highspeed()) {
2386 #ifndef BUILD_FT2232_HIGHSPEED
2387 #if BUILD_FT2232_FTD2XX == 1
2388 LOG_WARNING(
2389 "High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2390 #elif BUILD_FT2232_LIBFTDI == 1
2391 LOG_WARNING(
2392 "High Speed device found - You need a newer libftdi version (0.16 or later)");
2393 #endif
2394 #endif
2395 /* make sure the legacy mode is disabled */
2396 if (ftx232h_clk_divide_by_5(false) != ERROR_OK)
2397 return ERROR_JTAG_INIT_FAILED;
2398 }
2399
2400 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2401 retval = ft2232_write(buf, 1, &bytes_written);
2402 if (retval != ERROR_OK) {
2403 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2404 return ERROR_JTAG_INIT_FAILED;
2405 }
2406
2407 #if BUILD_FT2232_FTD2XX == 1
2408 return ft2232_purge_ftd2xx();
2409 #elif BUILD_FT2232_LIBFTDI == 1
2410 return ft2232_purge_libftdi();
2411 #endif
2412
2413 return ERROR_OK;
2414 }
2415
2416 /** Updates defaults for DBUS signals: the four JTAG signals
2417 * (TCK, TDI, TDO, TMS) and * the four GPIOL signals.
2418 */
2419 static inline void ftx232_dbus_init(void)
2420 {
2421 low_output = 0x08;
2422 low_direction = 0x0b;
2423 }
2424
2425 /** Initializes DBUS signals: the four JTAG signals (TCK, TDI, TDO, TMS),
2426 * the four GPIOL signals. Initialization covers value and direction,
2427 * as customized for each layout.
2428 */
2429 static int ftx232_dbus_write(void)
2430 {
2431 enum reset_types jtag_reset_config = jtag_get_reset_config();
2432 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2433 low_direction &= ~nTRSTnOE; /* nTRST input */
2434 low_output &= ~nTRST; /* nTRST = 0 */
2435 } else {
2436 low_direction |= nTRSTnOE; /* nTRST output */
2437 low_output |= nTRST; /* nTRST = 1 */
2438 }
2439
2440 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2441 low_direction |= nSRSTnOE; /* nSRST output */
2442 low_output |= nSRST; /* nSRST = 1 */
2443 } else {
2444 low_direction &= ~nSRSTnOE; /* nSRST input */
2445 low_output &= ~nSRST; /* nSRST = 0 */
2446 }
2447
2448 /* initialize low byte for jtag */
2449 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2450 LOG_ERROR("couldn't initialize FT2232 DBUS");
2451 return ERROR_JTAG_INIT_FAILED;
2452 }
2453
2454 return ERROR_OK;
2455 }
2456
2457 static int usbjtag_init(void)
2458 {
2459 /*
2460 * NOTE: This is now _specific_ to the "usbjtag" layout.
2461 * Don't try cram any more layouts into this.
2462 */
2463 ftx232_dbus_init();
2464
2465 nTRST = 0x10;
2466 nTRSTnOE = 0x10;
2467 nSRST = 0x40;
2468 nSRSTnOE = 0x40;
2469
2470 return ftx232_dbus_write();
2471 }
2472
2473 static int lm3s811_jtag_init(void)
2474 {
2475 ftx232_dbus_init();
2476
2477 /* There are multiple revisions of LM3S811 eval boards:
2478 * - Rev B (and older?) boards have no SWO trace support.
2479 * - Rev C boards add ADBUS_6 DBG_ENn and BDBUS_4 SWO_EN;
2480 * they should use the "luminary_icdi" layout instead.
2481 */
2482 nTRST = 0x0;
2483 nTRSTnOE = 0x00;
2484 nSRST = 0x20;
2485 nSRSTnOE = 0x20;
2486 low_output = 0x88;
2487 low_direction = 0x8b;
2488
2489 return ftx232_dbus_write();
2490 }
2491
2492 static int icdi_jtag_init(void)
2493 {
2494 ftx232_dbus_init();
2495
2496 /* Most Luminary eval boards support SWO trace output,
2497 * and should use this "luminary_icdi" layout.
2498 *
2499 * ADBUS 0..3 are used for JTAG as usual. GPIOs are used
2500 * to switch between JTAG and SWD, or switch the ft2232 UART
2501 * on the second MPSSE channel/interface (BDBUS)
2502 * between (i) the stellaris UART (on Luminary boards)
2503 * or (ii) SWO trace data (generic).
2504 *
2505 * We come up in JTAG mode and may switch to SWD later (with
2506 * SWO/trace option if SWD is active).
2507 *
2508 * DBUS == GPIO-Lx
2509 * CBUS == GPIO-Hx
2510 */
2511
2512
2513 #define ICDI_JTAG_EN (1 << 7) /* ADBUS 7 (a.k.a. DBGMOD) */
2514 #define ICDI_DBG_ENn (1 << 6) /* ADBUS 6 */
2515 #define ICDI_SRST (1 << 5) /* ADBUS 5 */
2516
2517
2518 /* GPIOs on second channel/interface (UART) ... */
2519 #define ICDI_SWO_EN (1 << 4) /* BDBUS 4 */
2520 #define ICDI_TX_SWO (1 << 1) /* BDBUS 1 */
2521 #define ICDI_VCP_RX (1 << 0) /* BDBUS 0 (to stellaris UART) */
2522
2523 nTRST = 0x0;
2524 nTRSTnOE = 0x00;
2525 nSRST = ICDI_SRST;
2526 nSRSTnOE = ICDI_SRST;
2527
2528 low_direction |= ICDI_JTAG_EN | ICDI_DBG_ENn;
2529 low_output |= ICDI_JTAG_EN;
2530 low_output &= ~ICDI_DBG_ENn;
2531
2532 return ftx232_dbus_write();
2533 }
2534
2535 static int signalyzer_init(void)
2536 {
2537 ftx232_dbus_init();
2538
2539 nTRST = 0x10;
2540 nTRSTnOE = 0x10;
2541 nSRST = 0x20;
2542 nSRSTnOE = 0x20;
2543 return ftx232_dbus_write();
2544 }
2545
2546 static int axm0432_jtag_init(void)
2547 {
2548 low_output = 0x08;
2549 low_direction = 0x2b;
2550
2551 /* initialize low byte for jtag */
2552 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2553 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2554 return ERROR_JTAG_INIT_FAILED;
2555 }
2556
2557 if (strcmp(layout->name, "axm0432_jtag") == 0) {
2558 nTRST = 0x08;
2559 nTRSTnOE = 0x0; /* No output enable for TRST*/
2560 nSRST = 0x04;
2561 nSRSTnOE = 0x0; /* No output enable for SRST*/
2562 } else {
2563 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2564 exit(-1);
2565 }
2566
2567 high_output = 0x0;
2568 high_direction = 0x0c;
2569
2570 enum reset_types jtag_reset_config = jtag_get_reset_config();
2571 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2572 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2573 else
2574 high_output |= nTRST;
2575
2576 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2577 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2578 else
2579 high_output |= nSRST;
2580
2581 /* initialize high byte for jtag */
2582 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2583 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2584 return ERROR_JTAG_INIT_FAILED;
2585 }
2586
2587 return ERROR_OK;
2588 }
2589
2590 static int redbee_init(void)
2591 {
2592 low_output = 0x08;
2593 low_direction = 0x2b;
2594
2595 /* initialize low byte for jtag */
2596 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2597 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2598 return ERROR_JTAG_INIT_FAILED;
2599 }
2600
2601 nTRST = 0x08;
2602 nTRSTnOE = 0x0; /* No output enable for TRST*/
2603 nSRST = 0x04;
2604 nSRSTnOE = 0x0; /* No output enable for SRST*/
2605
2606 high_output = 0x0;
2607 high_direction = 0x0c;
2608
2609 enum reset_types jtag_reset_config = jtag_get_reset_config();
2610 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2611 LOG_ERROR("can't set nTRSTOE to push-pull on redbee");
2612 else
2613 high_output |= nTRST;
2614
2615 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2616 LOG_ERROR("can't set nSRST to push-pull on redbee");
2617 else
2618 high_output |= nSRST;
2619
2620 /* initialize high byte for jtag */
2621 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2622 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2623 return ERROR_JTAG_INIT_FAILED;
2624 }
2625
2626 return ERROR_OK;
2627 }
2628
2629 static int jtagkey_init(void)
2630 {
2631 low_output = 0x08;
2632 low_direction = 0x1b;
2633
2634 /* initialize low byte for jtag */
2635 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2636 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2637 return ERROR_JTAG_INIT_FAILED;
2638 }
2639
2640 if (strcmp(layout->name, "jtagkey") == 0) {
2641 nTRST = 0x01;
2642 nTRSTnOE = 0x4;
2643 nSRST = 0x02;
2644 nSRSTnOE = 0x08;
2645 } else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2646 || (strcmp(layout->name, "oocdlink") == 0)) {
2647 nTRST = 0x02;
2648 nTRSTnOE = 0x1;
2649 nSRST = 0x08;
2650 nSRSTnOE = 0x04;
2651 } else {
2652 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2653 exit(-1);
2654 }
2655
2656 high_output = 0x0;
2657 high_direction = 0x0f;
2658
2659 enum reset_types jtag_reset_config = jtag_get_reset_config();
2660 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2661 high_output |= nTRSTnOE;
2662 high_output &= ~nTRST;
2663 } else {
2664 high_output &= ~nTRSTnOE;
2665 high_output |= nTRST;
2666 }
2667
2668 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2669 high_output &= ~nSRSTnOE;
2670 high_output |= nSRST;
2671 } else {
2672 high_output |= nSRSTnOE;
2673 high_output &= ~nSRST;
2674 }
2675
2676 /* initialize high byte for jtag */
2677 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2678 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2679 return ERROR_JTAG_INIT_FAILED;
2680 }
2681
2682 return ERROR_OK;
2683 }
2684
2685 static int olimex_jtag_init(void)
2686 {
2687 low_output = 0x08;
2688 low_direction = 0x1b;
2689
2690 /* initialize low byte for jtag */
2691 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2692 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2693 return ERROR_JTAG_INIT_FAILED;
2694 }
2695
2696 nTRST = 0x01;
2697 nTRSTnOE = 0x4;
2698 nSRST = 0x02;
2699 nSRSTnOE = 0x00;/* no output enable for nSRST */
2700
2701 high_output = 0x0;
2702 high_direction = 0x0f;
2703
2704 enum reset_types jtag_reset_config = jtag_get_reset_config();
2705 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2706 high_output |= nTRSTnOE;
2707 high_output &= ~nTRST;
2708 } else {
2709 high_output &= ~nTRSTnOE;
2710 high_output |= nTRST;
2711 }
2712
2713 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2714 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2715 else
2716 high_output &= ~nSRST;
2717
2718 /* turn red LED on */
2719 high_output |= 0x08;
2720
2721 /* initialize high byte for jtag */
2722 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2723 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2724 return ERROR_JTAG_INIT_FAILED;
2725 }
2726
2727 return ERROR_OK;
2728 }
2729
2730 static int flyswatter_init(int rev)
2731 {
2732 low_output = 0x18;
2733 low_direction = 0x7b;
2734
2735 if ((rev < 0) || (rev > 3)) {
2736 LOG_ERROR("bogus 'flyswatter' revision supplied (%i)", rev);
2737 return ERROR_JTAG_INIT_FAILED;
2738 }
2739
2740 if (rev == 1)
2741 low_direction |= 1 << 7;
2742
2743 /* initialize low byte for jtag */
2744 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2745 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2746 return ERROR_JTAG_INIT_FAILED;
2747 }
2748
2749 nTRST = 0x10;
2750 nTRSTnOE = 0x0; /* not output enable for nTRST */
2751 nSRST = 0x20;
2752 nSRSTnOE = 0x00; /* no output enable for nSRST */
2753
2754 high_output = 0x00;
2755
2756 if (rev == 1)
2757 high_direction = 0x0c;
2758 else
2759 high_direction = 0x01;
2760
2761 /* turn red LED3 on, LED2 off */
2762 high_output |= 0x08;
2763
2764 /* initialize high byte for jtag */
2765 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2766 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2767 return ERROR_JTAG_INIT_FAILED;
2768 }
2769
2770 return ERROR_OK;
2771 }
2772
2773 static int flyswatter1_init(void)
2774 {
2775 return flyswatter_init(1);
2776 }
2777
2778 static int flyswatter2_init(void)
2779 {
2780 return flyswatter_init(2);
2781 }
2782
2783 static int minimodule_init(void)
2784 {
2785 low_output = 0x18; /* check if srst should be 1 or 0 initially. (0x08) (flyswatter was
2786 * 0x18) */
2787 low_direction = 0xfb; /* 0xfb; */
2788
2789 /* initialize low byte for jtag */
2790 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2791 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2792 return ERROR_JTAG_INIT_FAILED;
2793 }
2794
2795
2796 nSRST = 0x20;
2797
2798 high_output = 0x00;
2799 high_direction = 0x05;
2800
2801 /* turn red LED3 on, LED2 off */
2802 /* high_output |= 0x08; */
2803
2804 /* initialize high byte for jtag */
2805 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2806 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2807 return ERROR_JTAG_INIT_FAILED;
2808 }
2809
2810 return ERROR_OK;
2811 }
2812
2813 static int turtle_init(void)
2814 {
2815 low_output = 0x08;
2816 low_direction = 0x5b;
2817
2818 /* initialize low byte for jtag */
2819 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2820 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2821 return ERROR_JTAG_INIT_FAILED;
2822 }
2823
2824 nSRST = 0x40;
2825
2826 high_output = 0x00;
2827 high_direction = 0x0C;
2828
2829 /* initialize high byte for jtag */
2830 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2831 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2832 return ERROR_JTAG_INIT_FAILED;
2833 }
2834
2835 return ERROR_OK;
2836 }
2837
2838 static int comstick_init(void)
2839 {
2840 low_output = 0x08;
2841 low_direction = 0x0b;
2842
2843 /* initialize low byte for jtag */
2844 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2845 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2846 return ERROR_JTAG_INIT_FAILED;
2847 }
2848
2849 nTRST = 0x01;
2850 nTRSTnOE = 0x00; /* no output enable for nTRST */
2851 nSRST = 0x02;
2852 nSRSTnOE = 0x00; /* no output enable for nSRST */
2853
2854 high_output = 0x03;
2855 high_direction = 0x03;
2856
2857 /* initialize high byte for jtag */
2858 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2859 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2860 return ERROR_JTAG_INIT_FAILED;
2861 }
2862
2863 return ERROR_OK;
2864 }
2865
2866 static int stm32stick_init(void)
2867 {
2868 low_output = 0x88;
2869 low_direction = 0x8b;
2870
2871 /* initialize low byte for jtag */
2872 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2873 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2874 return ERROR_JTAG_INIT_FAILED;
2875 }
2876
2877 nTRST = 0x01;
2878 nTRSTnOE = 0x00; /* no output enable for nTRST */
2879 nSRST = 0x80;
2880 nSRSTnOE = 0x00; /* no output enable for nSRST */
2881
2882 high_output = 0x01;
2883 high_direction = 0x03;
2884
2885 /* initialize high byte for jtag */
2886 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2887 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2888 return ERROR_JTAG_INIT_FAILED;
2889 }
2890
2891 return ERROR_OK;
2892 }
2893
2894 static int sheevaplug_init(void)
2895 {
2896 low_output = 0x08;
2897 low_direction = 0x1b;
2898
2899 /* initialize low byte for jtag */
2900 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2901 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2902 return ERROR_JTAG_INIT_FAILED;
2903 }
2904
2905 nTRSTnOE = 0x1;
2906 nTRST = 0x02;
2907 nSRSTnOE = 0x4;
2908 nSRST = 0x08;
2909
2910 high_output = 0x0;
2911 high_direction = 0x0f;
2912
2913 /* nTRST is always push-pull */
2914 high_output &= ~nTRSTnOE;
2915 high_output |= nTRST;
2916
2917 /* nSRST is always open-drain */
2918 high_output |= nSRSTnOE;
2919 high_output &= ~nSRST;
2920
2921 /* initialize high byte for jtag */
2922 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2923 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2924 return ERROR_JTAG_INIT_FAILED;
2925 }
2926
2927 return ERROR_OK;
2928 }
2929
2930 static int cortino_jtag_init(void)
2931 {
2932 low_output = 0x08;
2933 low_direction = 0x1b;
2934
2935 /* initialize low byte for jtag */
2936 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2937 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2938 return ERROR_JTAG_INIT_FAILED;
2939 }
2940
2941 nTRST = 0x01;
2942 nTRSTnOE = 0x00; /* no output enable for nTRST */
2943 nSRST = 0x02;
2944 nSRSTnOE = 0x00; /* no output enable for nSRST */
2945
2946 high_output = 0x03;
2947 high_direction = 0x03;
2948
2949 /* initialize high byte for jtag */
2950 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2951 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2952 return ERROR_JTAG_INIT_FAILED;
2953 }
2954
2955 return ERROR_OK;
2956 }
2957
2958 static int lisa_l_init(void)
2959 {
2960 ftx232_dbus_init();
2961
2962 nTRST = 0x10;
2963 nTRSTnOE = 0x10;
2964 nSRST = 0x40;
2965 nSRSTnOE = 0x40;
2966
2967 high_output = 0x00;
2968 high_direction = 0x18;
2969
2970 /* initialize high byte for jtag */
2971 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2972 LOG_ERROR("couldn't initialize FT2232 with 'lisa_l' layout");
2973 return ERROR_JTAG_INIT_FAILED;
2974 }
2975
2976 return ftx232_dbus_write();
2977 }
2978
2979 static int flossjtag_init(void)
2980 {
2981 ftx232_dbus_init();
2982
2983 nTRST = 0x10;
2984 nTRSTnOE = 0x10;
2985 nSRST = 0x40;
2986 nSRSTnOE = 0x40;
2987
2988 high_output = 0x00;
2989 high_direction = 0x18;
2990
2991 /* initialize high byte for jtag */
2992 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2993 LOG_ERROR("couldn't initialize FT2232 with 'Floss-JTAG' layout");
2994 return ERROR_JTAG_INIT_FAILED;
2995 }
2996
2997 return ftx232_dbus_write();
2998 }
2999
3000 /*
3001 * The reference schematic from TI for the XDS100v2 has a CPLD on which opens
3002 * the door for a number of different configurations
3003 *
3004 * Known Implementations:
3005 * http://processors.wiki.ti.com/images/9/93/TMS570LS20216_USB_STICK_Schematic.pdf
3006 *
3007 * http://processors.wiki.ti.com/index.php/XDS100 (rev2)
3008 * * CLPD logic: Rising edge to enable outputs (XDS100_PWR_RST)
3009 * * ACBUS3 to transition 0->1 (OE rising edge)
3010 * * CPLD logic: Put the EMU0/1 pins in Hi-Z:
3011 * * ADBUS5/GPIOL1 = EMU_EN = 1
3012 * * ADBUS6/GPIOL2 = EMU0 = 0
3013 * * ACBUS4/SPARE0 = EMU1 = 0
3014 * * CPLD logic: Disable loopback
3015 * * ACBUS6/SPARE2 = LOOPBACK = 0
3016 */
3017 #define XDS100_nEMU_EN (1<<5)
3018 #define XDS100_nEMU0 (1<<6)
3019
3020 #define XDS100_PWR_RST (1<<3)
3021 #define XDS100_nEMU1 (1<<4)
3022 #define XDS100_LOOPBACK (1<<6)
3023 static int xds100v2_init(void)
3024 {
3025 /* These are in the lower byte */
3026 nTRST = 0x10;
3027 nTRSTnOE = 0x10;
3028
3029 /* These aren't actually used on 14 pin connectors
3030 * These are in the upper byte */
3031 nSRST = 0x01;
3032 nSRSTnOE = 0x01;
3033
3034 low_output = 0x08 | nTRST | XDS100_nEMU_EN;
3035 low_direction = 0x0b | nTRSTnOE | XDS100_nEMU_EN | XDS100_nEMU0;
3036
3037 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3038 LOG_ERROR("couldn't initialize FT2232 with 'xds100v2' layout");
3039 return ERROR_JTAG_INIT_FAILED;
3040 }
3041
3042 high_output = 0;
3043 high_direction = nSRSTnOE | XDS100_LOOPBACK | XDS100_PWR_RST | XDS100_nEMU1;
3044
3045 /* initialize high byte for jtag */
3046 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3047 LOG_ERROR("couldn't put CPLD in to reset with 'xds100v2' layout");
3048 return ERROR_JTAG_INIT_FAILED;
3049 }
3050
3051 high_output |= XDS100_PWR_RST;
3052
3053 /* initialize high byte for jtag */
3054 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3055 LOG_ERROR("couldn't bring CPLD out of reset with 'xds100v2' layout");
3056 return ERROR_JTAG_INIT_FAILED;
3057 }
3058
3059 return ERROR_OK;
3060 }
3061
3062 static void olimex_jtag_blink(void)
3063 {
3064 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
3065 * ACBUS3 is bit 3 of the GPIOH port
3066 */
3067 high_output ^= 0x08;
3068
3069 buffer_write(0x82);
3070 buffer_write(high_output);
3071 buffer_write(high_direction);
3072 }
3073
3074 static void flyswatter_jtag_blink(unsigned char led)
3075 {
3076 buffer_write(0x82);
3077 buffer_write(high_output ^ led);
3078 buffer_write(high_direction);
3079 }
3080
3081 static void flyswatter1_jtag_blink(void)
3082 {
3083 /*
3084 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
3085 */
3086 flyswatter_jtag_blink(0xc);
3087 }
3088
3089 static void flyswatter2_jtag_blink(void)
3090 {
3091 /*
3092 * Flyswatter2 only has one LED connected to ACBUS2
3093 */
3094 flyswatter_jtag_blink(0x4);
3095 }
3096
3097 static void turtle_jtag_blink(void)
3098 {
3099 /*
3100 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
3101 */
3102 if (high_output & 0x08)
3103 high_output = 0x04;
3104 else
3105 high_output = 0x08;
3106
3107 buffer_write(0x82);
3108 buffer_write(high_output);
3109 buffer_write(high_direction);
3110 }
3111
3112 static void lisa_l_blink(void)
3113 {
3114 /*
3115 * Lisa/L has two LEDs connected to BCBUS3 and BCBUS4
3116 */
3117 if (high_output & 0x10)
3118 high_output = 0x08;
3119 else
3120 high_output = 0x10;
3121
3122 buffer_write(0x82);
3123 buffer_write(high_output);
3124 buffer_write(high_direction);
3125 }
3126
3127 static void flossjtag_blink(void)
3128 {
3129 /*
3130 * Floss-JTAG has two LEDs connected to ACBUS3 and ACBUS4
3131 */
3132 if (high_output & 0x10)
3133 high_output = 0x08;
3134 else
3135 high_output = 0x10;
3136
3137 buffer_write(0x82);
3138 buffer_write(high_output);
3139 buffer_write(high_direction);
3140 }
3141
3142 static int ft2232_quit(void)
3143 {
3144 #if BUILD_FT2232_FTD2XX == 1
3145
3146 FT_Close(ftdih);
3147 #elif BUILD_FT2232_LIBFTDI == 1
3148 ftdi_usb_close(&ftdic);
3149
3150 ftdi_deinit(&ftdic);
3151 #endif
3152
3153 free(ft2232_buffer);
3154 ft2232_buffer = NULL;
3155
3156 return ERROR_OK;
3157 }
3158
3159 COMMAND_HANDLER(ft2232_handle_device_desc_command)
3160 {
3161 char *cp;
3162 char buf[200];
3163 if (CMD_ARGC == 1) {
3164 ft2232_device_desc = strdup(CMD_ARGV[0]);
3165 cp = strchr(ft2232_device_desc, 0);
3166 /* under Win32, the FTD2XX driver appends an "A" to the end
3167 * of the description, this examines the given desc
3168 * and creates the 'missing' _A or non_A variable. */
3169 if ((cp[-1] == 'A') && (cp[-2] == ' ')) {
3170 /* it was, so make this the "A" version. */
3171 ft2232_device_desc_A = ft2232_device_desc;
3172 /* and *CREATE* the non-A version. */
3173 strcpy(buf, ft2232_device_desc);
3174 cp = strchr(buf, 0);
3175 cp[-2] = 0;
3176 ft2232_device_desc = strdup(buf);
3177 } else {
3178 /* <space > A not defined
3179 * so create it */
3180 sprintf(buf, "%s A", ft2232_device_desc);
3181 ft2232_device_desc_A = strdup(buf);
3182 }
3183 } else
3184 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
3185
3186 return ERROR_OK;
3187 }
3188
3189 COMMAND_HANDLER(ft2232_handle_serial_command)
3190 {
3191 if (CMD_ARGC == 1)
3192 ft2232_serial = strdup(CMD_ARGV[0]);
3193 else
3194 return ERROR_COMMAND_SYNTAX_ERROR;
3195
3196 return ERROR_OK;
3197 }
3198
3199 COMMAND_HANDLER(ft2232_handle_layout_command)
3200 {
3201 if (CMD_ARGC != 1)
3202 return ERROR_COMMAND_SYNTAX_ERROR;
3203
3204 if (layout) {
3205 LOG_ERROR("already specified ft2232_layout %s",
3206 layout->name);
3207 return (strcmp(layout->name, CMD_ARGV[0]) != 0)
3208 ? ERROR_FAIL
3209 : ERROR_OK;
3210 }
3211
3212 for (const struct ft2232_layout *l = ft2232_layouts; l->name; l++) {
3213 if (strcmp(l->name, CMD_ARGV[0]) == 0) {
3214 layout = l;
3215 ft2232_channel = l->channel;
3216 return ERROR_OK;
3217 }
3218 }
3219
3220 LOG_ERROR("No FT2232 layout '%s' found", CMD_ARGV[0]);
3221 return ERROR_FAIL;
3222 }
3223
3224 COMMAND_HANDLER(ft2232_handle_vid_pid_command)
3225 {
3226 if (CMD_ARGC > MAX_USB_IDS * 2) {
3227 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
3228 "(maximum is %d pairs)", MAX_USB_IDS);
3229 CMD_ARGC = MAX_USB_IDS * 2;
3230 }
3231 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
3232 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
3233 if (CMD_ARGC < 2)
3234 return ERROR_COMMAND_SYNTAX_ERROR;
3235 /* remove the incomplete trailing id */
3236 CMD_ARGC -= 1;
3237 }
3238
3239 unsigned i;
3240 for (i = 0; i < CMD_ARGC; i += 2) {
3241 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ft2232_vid[i >> 1]);
3242 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ft2232_pid[i >> 1]);
3243 }
3244
3245 /*
3246 * Explicitly terminate, in case there are multiples instances of
3247 * ft2232_vid_pid.
3248 */
3249 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
3250
3251 return ERROR_OK;
3252 }
3253
3254 COMMAND_HANDLER(ft2232_handle_latency_command)
3255 {
3256 if (CMD_ARGC == 1)
3257 ft2232_latency = atoi(CMD_ARGV[0]);
3258 else
3259 return ERROR_COMMAND_SYNTAX_ERROR;
3260
3261 return ERROR_OK;
3262 }
3263
3264 COMMAND_HANDLER(ft2232_handle_channel_command)
3265 {
3266 if (CMD_ARGC == 1) {
3267 ft2232_channel = atoi(CMD_ARGV[0]);
3268 if (ft2232_channel < 0 || ft2232_channel > 4)
3269 LOG_ERROR("ft2232_channel must be in the 0 to 4 range");
3270 } else
3271 LOG_ERROR("expected exactly one argument to ft2232_channel <ch>");
3272
3273 return ERROR_OK;
3274 }
3275
3276 static int ft2232_stableclocks(int num_cycles, struct jtag_command *cmd)
3277 {
3278 int retval = 0;
3279
3280 /* 7 bits of either ones or zeros. */
3281 uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
3282
3283 while (num_cycles > 0) {
3284 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
3285 * at most 7 bits per invocation. Here we invoke it potentially
3286 * several times.
3287 */
3288 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
3289
3290 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE) {
3291 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
3292 retval = ERROR_JTAG_QUEUE_FAILED;
3293
3294 first_unsent = cmd;
3295 }
3296
3297 /* there are no state transitions in this code, so omit state tracking */
3298
3299 /* command "Clock Data to TMS/CS Pin (no Read)" */
3300 buffer_write(0x4b);
3301
3302 /* scan 7 bit */
3303 buffer_write(bitcount_per_command - 1);
3304
3305 /* TMS data bits are either all zeros or ones to stay in the current stable state */
3306 buffer_write(tms);
3307
3308 require_send = 1;
3309
3310 num_cycles -= bitcount_per_command;
3311 }
3312
3313 return retval;
3314 }
3315
3316 /* ---------------------------------------------------------------------
3317 * Support for IceBear JTAG adapter from Section5:
3318 * http://section5.ch/icebear
3319 *
3320 * Author: Sten, debian@sansys-electronic.com
3321 */
3322
3323 /* Icebear pin layout
3324 *
3325 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
3326 * GND GND | 4 3| n.c.
3327 * ADBUS3 TMS | 6 5| ADBUS6 VCC
3328 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
3329 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
3330 * ADBUS1 TDI |12 11| ACBUS1 (GND)
3331 * ADBUS2 TDO |14 13| GND GND
3332 *
3333 * ADBUS0 O L TCK ACBUS0 GND
3334 * ADBUS1 O L TDI ACBUS1 GND
3335 * ADBUS2 I TDO ACBUS2 n.c.
3336 * ADBUS3 O H TMS ACBUS3 n.c.
3337 * ADBUS4 O H nTRST
3338 * ADBUS5 O H nSRST
3339 * ADBUS6 - VCC
3340 * ADBUS7 - GND
3341 */
3342 static int icebear_jtag_init(void)
3343 {
3344 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
3345 low_output = 0x08; /* high: TMS; low: TCK TDI */
3346 nTRST = 0x10;
3347 nSRST = 0x20;
3348
3349 enum reset_types jtag_reset_config = jtag_get_reset_config();
3350 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3351 low_direction &= ~nTRST; /* nTRST high impedance */
3352 else {
3353 low_direction |= nTRST;
3354 low_output |= nTRST;
3355 }
3356
3357 low_direction |= nSRST;
3358 low_output |= nSRST;
3359
3360 /* initialize low byte for jtag */
3361 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3362 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3363 return ERROR_JTAG_INIT_FAILED;
3364 }
3365
3366 high_output = 0x0;
3367 high_direction = 0x00;
3368
3369 /* initialize high byte for jtag */
3370 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3371 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3372 return ERROR_JTAG_INIT_FAILED;
3373 }
3374
3375 return ERROR_OK;
3376 }
3377
3378 static void icebear_jtag_reset(int trst, int srst)
3379 {
3380 if (trst == 1) {
3381 low_direction |= nTRST;
3382 low_output &= ~nTRST;
3383 } else if (trst == 0) {
3384 enum reset_types jtag_reset_config = jtag_get_reset_config();
3385 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3386 low_direction &= ~nTRST;
3387 else
3388 low_output |= nTRST;
3389 }
3390
3391 if (srst == 1)
3392 low_output &= ~nSRST;
3393 else if (srst == 0)
3394 low_output |= nSRST;
3395
3396 /* command "set data bits low byte" */
3397 buffer_write(0x80);
3398 buffer_write(low_output);
3399 buffer_write(low_direction);
3400
3401 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
3402 trst,
3403 srst,
3404 low_output,
3405 low_direction);
3406 }
3407
3408 /* ---------------------------------------------------------------------
3409 * Support for Signalyzer H2 and Signalyzer H4
3410 * JTAG adapter from Xverve Technologies Inc.
3411 * http://www.signalyzer.com or http://www.xverve.com
3412 *
3413 * Author: Oleg Seiljus, oleg@signalyzer.com
3414 */
3415 static unsigned char signalyzer_h_side;
3416 static unsigned int signalyzer_h_adapter_type;
3417
3418 static int signalyzer_h_ctrl_write(int address, unsigned short value);
3419
3420 #if BUILD_FT2232_FTD2XX == 1
3421 static int signalyzer_h_ctrl_read(int address, unsigned short *value);
3422 #endif
3423
3424 #define SIGNALYZER_COMMAND_ADDR 128
3425 #define SIGNALYZER_DATA_BUFFER_ADDR 129
3426
3427 #define SIGNALYZER_COMMAND_VERSION 0x41
3428 #define SIGNALYZER_COMMAND_RESET 0x42
3429 #define SIGNALYZER_COMMAND_POWERCONTROL_GET 0x50
3430 #define SIGNALYZER_COMMAND_POWERCONTROL_SET 0x51
3431 #define SIGNALYZER_COMMAND_PWM_SET 0x52
3432 #define SIGNALYZER_COMMAND_LED_SET 0x53
3433 #define SIGNALYZER_COMMAND_ADC 0x54
3434 #define SIGNALYZER_COMMAND_GPIO_STATE 0x55
3435 #define SIGNALYZER_COMMAND_GPIO_MODE 0x56
3436 #define SIGNALYZER_COMMAND_GPIO_PORT 0x57
3437 #define SIGNALYZER_COMMAND_I2C 0x58
3438
3439 #define SIGNALYZER_CHAN_A 1
3440 #define SIGNALYZER_CHAN_B 2
3441 /* LEDS use channel C */
3442 #define SIGNALYZER_CHAN_C 4
3443
3444 #define SIGNALYZER_LED_GREEN 1
3445 #define SIGNALYZER_LED_RED 2
3446
3447 #define SIGNALYZER_MODULE_TYPE_EM_LT16_A 0x0301
3448 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG 0x0302
3449 #define SIGNALYZER_MODULE_TYPE_EM_JTAG 0x0303
3450 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P 0x0304
3451 #define SIGNALYZER_MODULE_TYPE_EM_JTAG_P 0x0305
3452
3453
3454 static int signalyzer_h_ctrl_write(int address, unsigned short value)
3455 {
3456 #if BUILD_FT2232_FTD2XX == 1
3457 return FT_WriteEE(ftdih, address, value);
3458 #elif BUILD_FT2232_LIBFTDI == 1
3459 return 0;
3460 #endif
3461 }
3462
3463 #if BUILD_FT2232_FTD2XX == 1
3464 static int signalyzer_h_ctrl_read(int address, unsigned short *value)
3465 {
3466 return FT_ReadEE(ftdih, address, value);
3467 }
3468 #endif
3469
3470 static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
3471 int on_time_ms, int off_time_ms, unsigned char cycles)
3472 {
3473 unsigned char on_time;
3474 unsigned char off_time;
3475
3476 if (on_time_ms < 0xFFFF)
3477 on_time = (unsigned char)(on_time_ms / 62);
3478 else
3479 on_time = 0xFF;
3480
3481 off_time = (unsigned char)(off_time_ms / 62);
3482
3483 #if BUILD_FT2232_FTD2XX == 1
3484 FT_STATUS status;
3485
3486 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3487 ((uint32_t)(channel << 8) | led));
3488 if (status != FT_OK) {
3489 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3490 ftd2xx_status_string(status));
3491 return ERROR_JTAG_DEVICE_ERROR;
3492 }
3493
3494 status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3495 ((uint32_t)(on_time << 8) | off_time));
3496 if (status != FT_OK) {
3497 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3498 ftd2xx_status_string(status));
3499 return ERROR_JTAG_DEVICE_ERROR;
3500 }
3501
3502 status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3503 ((uint32_t)cycles));
3504 if (status != FT_OK) {
3505 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3506 ftd2xx_status_string(status));
3507 return ERROR_JTAG_DEVICE_ERROR;
3508 }
3509
3510 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3511 SIGNALYZER_COMMAND_LED_SET);
3512 if (status != FT_OK) {
3513 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3514 ftd2xx_status_string(status));
3515 return ERROR_JTAG_DEVICE_ERROR;
3516 }
3517
3518 return ERROR_OK;
3519 #elif BUILD_FT2232_LIBFTDI == 1
3520 int retval;
3521
3522 retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3523 ((uint32_t)(channel << 8) | led));
3524 if (retval < 0) {
3525 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3526 ftdi_get_error_string(&ftdic));
3527 return ERROR_JTAG_DEVICE_ERROR;
3528 }
3529
3530 retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3531 ((uint32_t)(on_time << 8) | off_time));
3532 if (retval < 0) {
3533 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3534 ftdi_get_error_string(&ftdic));
3535 return ERROR_JTAG_DEVICE_ERROR;
3536 }
3537
3538 retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3539 (uint32_t)cycles);
3540 if (retval < 0) {
3541 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3542 ftdi_get_error_string(&ftdic));
3543 return ERROR_JTAG_DEVICE_ERROR;
3544 }
3545
3546 retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3547 SIGNALYZER_COMMAND_LED_SET);
3548 if (retval < 0) {
3549 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3550 ftdi_get_error_string(&ftdic));
3551 return ERROR_JTAG_DEVICE_ERROR;
3552 }
3553
3554 return ERROR_OK;
3555 #endif
3556 }
3557
3558 static int signalyzer_h_init(void)
3559 {
3560 #if BUILD_FT2232_FTD2XX == 1
3561 FT_STATUS status;
3562 int i;
3563 #endif
3564
3565 char *end_of_desc;
3566
3567 uint16_t read_buf[12] = { 0 };
3568
3569 /* turn on center green led */
3570 signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
3571 0xFFFF, 0x00, 0x00);
3572
3573 /* determine what channel config wants to open
3574 * TODO: change me... current implementation is made to work
3575 * with openocd description parsing.
3576 */
3577 end_of_desc = strrchr(ft2232_device_desc, 0x00);
3578
3579 if (end_of_desc) {
3580 signalyzer_h_side = *(end_of_desc - 1);
3581 if (signalyzer_h_side == 'B')
3582 signalyzer_h_side = SIGNALYZER_CHAN_B;
3583 else
3584 signalyzer_h_side = SIGNALYZER_CHAN_A;
3585 } else {
3586 LOG_ERROR("No Channel was specified");
3587 return ERROR_FAIL;
3588 }
3589
3590 signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
3591 1000, 1000, 0xFF);
3592
3593 #if BUILD_FT2232_FTD2XX == 1
3594 /* read signalyzer versionining information */
3595 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3596 SIGNALYZER_COMMAND_VERSION);
3597 if (status != FT_OK) {
3598 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3599 ftd2xx_status_string(status));
3600 return ERROR_JTAG_DEVICE_ERROR;
3601 }
3602
3603 for (i = 0; i < 10; i++) {
3604 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i),
3605 &read_buf[i]);
3606 if (status != FT_OK) {
3607 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3608 ftd2xx_status_string(status));
3609 return ERROR_JTAG_DEVICE_ERROR;
3610 }
3611 }
3612
3613 LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
3614 read_buf[0], read_buf[1], read_buf[2], read_buf[3],
3615 read_buf[4], read_buf[5], read_buf[6]);
3616
3617 /* set gpio register */
3618 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3619 (uint32_t)(signalyzer_h_side << 8));
3620 if (status != FT_OK) {
3621 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3622 ftd2xx_status_string(status));
3623 return ERROR_JTAG_DEVICE_ERROR;
3624 }
3625
3626 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0404);
3627 if (status != FT_OK) {
3628 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3629 ftd2xx_status_string(status));
3630 return ERROR_JTAG_DEVICE_ERROR;
3631 }
3632
3633 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3634 SIGNALYZER_COMMAND_GPIO_STATE);
3635 if (status != FT_OK) {
3636 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3637 ftd2xx_status_string(status));
3638 return ERROR_JTAG_DEVICE_ERROR;
3639 }
3640
3641 /* read adapter type information */
3642 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3643 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3644 if (status != FT_OK) {
3645 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3646 ftd2xx_status_string(status));
3647 return ERROR_JTAG_DEVICE_ERROR;
3648 }
3649
3650 status = signalyzer_h_ctrl_write(
3651 (SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000);
3652 if (status != FT_OK) {
3653 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3654 ftd2xx_status_string(status));
3655 return ERROR_JTAG_DEVICE_ERROR;
3656 }
3657
3658 status = signalyzer_h_ctrl_write(
3659 (SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008);
3660 if (status != FT_OK) {
3661 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3662 ftd2xx_status_string(status));
3663 return ERROR_JTAG_DEVICE_ERROR;
3664 }
3665
3666 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3667 SIGNALYZER_COMMAND_I2C);
3668 if (status != FT_OK) {
3669 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3670 ftd2xx_status_string(status));
3671 return ERROR_JTAG_DEVICE_ERROR;
3672 }
3673
3674 usleep(100000);
3675
3676 status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR, &read_buf[0]);
3677 if (status != FT_OK) {
3678 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3679 ftd2xx_status_string(status));
3680 return ERROR_JTAG_DEVICE_ERROR;
3681 }
3682
3683 if (read_buf[0] != 0x0498)
3684 signalyzer_h_adapter_type = 0x0000;
3685 else {
3686 for (i = 0; i < 4; i++) {
3687 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i), &read_buf[i]);
3688 if (status != FT_OK) {
3689 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3690 ftd2xx_status_string(status));
3691 return ERROR_JTAG_DEVICE_ERROR;
3692 }
3693 }
3694
3695 signalyzer_h_adapter_type = read_buf[0];
3696 }
3697
3698 #elif BUILD_FT2232_LIBFTDI == 1
3699 /* currently libftdi does not allow reading individual eeprom
3700 * locations, therefore adapter type cannot be detected.
3701 * override with most common type
3702 */
3703 signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
3704 #endif
3705
3706 enum reset_types jtag_reset_config = jtag_get_reset_config();
3707
3708 /* ADAPTOR: EM_LT16_A */
3709 if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3710 LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
3711 "detected. (HW: %2x).", (read_buf[1] >> 8));
3712
3713 nTRST = 0x10;
3714 nTRSTnOE = 0x10;
3715 nSRST = 0x20;
3716 nSRSTnOE = 0x20;
3717
3718 low_output = 0x08;
3719 low_direction = 0x1b;
3720
3721 high_output = 0x0;
3722 high_direction = 0x0;
3723
3724 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3725 low_direction &= ~nTRSTnOE; /* nTRST input */
3726 low_output &= ~nTRST; /* nTRST = 0 */
3727 } else {
3728 low_direction |= nTRSTnOE; /* nTRST output */
3729 low_output |= nTRST; /* nTRST = 1 */
3730 }
3731
3732 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3733 low_direction |= nSRSTnOE; /* nSRST output */
3734 low_output |= nSRST; /* nSRST = 1 */
3735 } else {
3736 low_direction &= ~nSRSTnOE; /* nSRST input */
3737 low_output &= ~nSRST; /* nSRST = 0 */<