4b3360fe701bb92bf1d4c690c469e5930633c60d
[openocd.git] / src / jtag / drivers / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2009 by Øyvind Harboe *
3 * Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * *
5 * Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com *
6 * Dick Hollenbeck <dick@softplc.com> *
7 * *
8 * Copyright (C) 2004, 2006 by Dominic Rath *
9 * Dominic.Rath@gmx.de *
10 * *
11 * Copyright (C) 2008 by Spencer Oliver *
12 * spen@spen-soft.co.uk *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29
30 /**
31 * @file
32 * JTAG adapters based on the FT2232 full and high speed USB parts are
33 * popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
34 * are discrete, but development boards may integrate them as alternatives
35 * to more capable (and expensive) third party JTAG pods.
36 *
37 * JTAG uses only one of the two communications channels ("MPSSE engines")
38 * on these devices. Adapters based on FT4232 parts have four ports/channels
39 * (A/B/C/D), instead of just two (A/B).
40 *
41 * Especially on development boards integrating one of these chips (as
42 * opposed to discrete pods/dongles), the additional channels can be used
43 * for a variety of purposes, but OpenOCD only uses one channel at a time.
44 *
45 * - As a USB-to-serial adapter for the target's console UART ...
46 * which may be able to support ROM boot loaders that load initial
47 * firmware images to flash (or SRAM).
48 *
49 * - On systems which support ARM's SWD in addition to JTAG, or instead
50 * of it, that second port can be used for reading SWV/SWO trace data.
51 *
52 * - Additional JTAG links, e.g. to a CPLD or * FPGA.
53 *
54 * FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
55 * request/response interactions involve round trips over the USB link.
56 * A "smart" JTAG adapter has intelligence close to the scan chain, so it
57 * can for example poll quickly for a status change (usually taking on the
58 * order of microseconds not milliseconds) before beginning a queued
59 * transaction which require the previous one to have completed.
60 *
61 * There are dozens of adapters of this type, differing in details which
62 * this driver needs to understand. Those "layout" details are required
63 * as part of FT2232 driver configuration.
64 *
65 * This code uses information contained in the MPSSE specification which was
66 * found here:
67 * http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
68 * Hereafter this is called the "MPSSE Spec".
69 *
70 * The datasheet for the ftdichip.com's FT2232D part is here:
71 * http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
72 *
73 * Also note the issue with code 0x4b (clock data to TMS) noted in
74 * http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
75 * which can affect longer JTAG state paths.
76 */
77
78 #ifdef HAVE_CONFIG_H
79 #include "config.h"
80 #endif
81
82 /* project specific includes */
83 #include <jtag/interface.h>
84 #include <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 (cmd->ir_scan) {
1112 LOG_ERROR("BUG: large IR scans are not supported");
1113 exit(-1);
1114 }
1115
1116 if (tap_get_state() != TAP_DRSHIFT)
1117 move_to_state(TAP_DRSHIFT);
1118
1119 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1120 if (retval != ERROR_OK) {
1121 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1122 exit(-1);
1123 }
1124 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1125 ft2232_buffer_size, (int)bytes_written);
1126 ft2232_buffer_size = 0;
1127
1128 /* add command for complete bytes */
1129 while (num_bytes > 1) {
1130 int thisrun_bytes;
1131
1132 if (type == SCAN_IO) {
1133 /* Clock Data Bytes In and Out LSB First */
1134 buffer_write(0x39);
1135 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1136 } else if (type == SCAN_OUT) {
1137 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1138 buffer_write(0x19);
1139 /* LOG_DEBUG("added TDI bytes (o)"); */
1140 } else if (type == SCAN_IN) {
1141 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1142 buffer_write(0x28);
1143 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1144 }
1145
1146 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1147 thisrun_read = thisrun_bytes;
1148 num_bytes -= thisrun_bytes;
1149 buffer_write((uint8_t) (thisrun_bytes - 1));
1150 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1151
1152 if (type != SCAN_IN) {
1153 /* add complete bytes */
1154 while (thisrun_bytes-- > 0) {
1155 buffer_write(buffer[cur_byte]);
1156 cur_byte++;
1157 bits_left -= 8;
1158 }
1159 } else /* (type == SCAN_IN) */
1160 bits_left -= 8 * (thisrun_bytes);
1161
1162 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1163 if (retval != ERROR_OK) {
1164 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1165 exit(-1);
1166 }
1167 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1168 ft2232_buffer_size,
1169 (int)bytes_written);
1170 ft2232_buffer_size = 0;
1171
1172 if (type != SCAN_OUT) {
1173 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1174 if (retval != ERROR_OK) {
1175 LOG_ERROR("couldn't read from FT2232");
1176 exit(-1);
1177 }
1178 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1179 thisrun_read,
1180 (int)bytes_read);
1181 receive_pointer += bytes_read;
1182 }
1183 }
1184
1185 thisrun_read = 0;
1186
1187 /* the most signifcant bit is scanned during TAP movement */
1188 if (type != SCAN_IN)
1189 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1190 else
1191 last_bit = 0;
1192
1193 /* process remaining bits but the last one */
1194 if (bits_left > 1) {
1195 if (type == SCAN_IO) {
1196 /* Clock Data Bits In and Out LSB First */
1197 buffer_write(0x3b);
1198 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1199 } else if (type == SCAN_OUT) {
1200 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1201 buffer_write(0x1b);
1202 /* LOG_DEBUG("added TDI bits (o)"); */
1203 } else if (type == SCAN_IN) {
1204 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1205 buffer_write(0x2a);
1206 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1207 }
1208 buffer_write(bits_left - 2);
1209 if (type != SCAN_IN)
1210 buffer_write(buffer[cur_byte]);
1211
1212 if (type != SCAN_OUT)
1213 thisrun_read += 2;
1214 }
1215
1216 if (tap_get_end_state() == TAP_DRSHIFT) {
1217 if (type == SCAN_IO) {
1218 /* Clock Data Bits In and Out LSB First */
1219 buffer_write(0x3b);
1220 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1221 } else if (type == SCAN_OUT) {
1222 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1223 buffer_write(0x1b);
1224 /* LOG_DEBUG("added TDI bits (o)"); */
1225 } else if (type == SCAN_IN) {
1226 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1227 buffer_write(0x2a);
1228 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1229 }
1230 buffer_write(0x0);
1231 buffer_write(last_bit);
1232 } else {
1233 int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1234 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1235 uint8_t mpsse_cmd;
1236
1237 /* move from Shift-IR/DR to end state */
1238 if (type != SCAN_OUT) {
1239 /* Clock Data to TMS/CS Pin with Read */
1240 mpsse_cmd = 0x6b;
1241 /* LOG_DEBUG("added TMS scan (read)"); */
1242 } else {
1243 /* Clock Data to TMS/CS Pin (no Read) */
1244 mpsse_cmd = 0x4b;
1245 /* LOG_DEBUG("added TMS scan (no read)"); */
1246 }
1247
1248 DEBUG_JTAG_IO("finish, %s", (type == SCAN_OUT) ? "no read" : "read");
1249 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1250 }
1251
1252 if (type != SCAN_OUT)
1253 thisrun_read += 1;
1254
1255 retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written);
1256 if (retval != ERROR_OK) {
1257 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1258 exit(-1);
1259 }
1260 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1261 ft2232_buffer_size,
1262 (int)bytes_written);
1263 ft2232_buffer_size = 0;
1264
1265 if (type != SCAN_OUT) {
1266 retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read);
1267 if (retval != ERROR_OK) {
1268 LOG_ERROR("couldn't read from FT2232");
1269 exit(-1);
1270 }
1271 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1272 thisrun_read,
1273 (int)bytes_read);
1274 }
1275
1276 return ERROR_OK;
1277 }
1278
1279 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1280 {
1281 int predicted_size = 3;
1282 int num_bytes = (scan_size - 1) / 8;
1283
1284 if (tap_get_state() != TAP_DRSHIFT)
1285 predicted_size += get_tms_buffer_requirements(
1286 tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1287
1288 if (type == SCAN_IN) { /* only from device to host */
1289 /* complete bytes */
1290 predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
1291
1292 /* remaining bits - 1 (up to 7) */
1293 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1294 } else {/* host to device, or bidirectional
1295 * complete bytes */
1296 predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
1297
1298 /* remaining bits -1 (up to 7) */
1299 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1300 }
1301
1302 return predicted_size;
1303 }
1304
1305 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1306 {
1307 int predicted_size = 0;
1308
1309 if (type != SCAN_OUT) {
1310 /* complete bytes */
1311 predicted_size +=
1312 (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
1313
1314 /* remaining bits - 1 */
1315 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1316
1317 /* last bit (from TMS scan) */
1318 predicted_size += 1;
1319 }
1320
1321 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1322
1323 return predicted_size;
1324 }
1325
1326 /* semi-generic FT2232/FT4232 reset code */
1327 static void ftx23_reset(int trst, int srst)
1328 {
1329 enum reset_types jtag_reset_config = jtag_get_reset_config();
1330 if (trst == 1) {
1331 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1332 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1333 else
1334 low_output &= ~nTRST; /* switch output low */
1335 } else if (trst == 0) {
1336 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1337 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal
1338 *and external pullup) */
1339 else
1340 low_output |= nTRST; /* switch output high */
1341 }
1342
1343 if (srst == 1) {
1344 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1345 low_output &= ~nSRST; /* switch output low */
1346 else
1347 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1348 } else if (srst == 0) {
1349 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1350 low_output |= nSRST; /* switch output high */
1351 else
1352 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1353 }
1354
1355 /* command "set data bits low byte" */
1356 buffer_write(0x80);
1357 buffer_write(low_output);
1358 buffer_write(low_direction);
1359 }
1360
1361 static void jtagkey_reset(int trst, int srst)
1362 {
1363 enum reset_types jtag_reset_config = jtag_get_reset_config();
1364 if (trst == 1) {
1365 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1366 high_output &= ~nTRSTnOE;
1367 else
1368 high_output &= ~nTRST;
1369 } else if (trst == 0) {
1370 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1371 high_output |= nTRSTnOE;
1372 else
1373 high_output |= nTRST;
1374 }
1375
1376 if (srst == 1) {
1377 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1378 high_output &= ~nSRST;
1379 else
1380 high_output &= ~nSRSTnOE;
1381 } else if (srst == 0) {
1382 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1383 high_output |= nSRST;
1384 else
1385 high_output |= nSRSTnOE;
1386 }
1387
1388 /* command "set data bits high byte" */
1389 buffer_write(0x82);
1390 buffer_write(high_output);
1391 buffer_write(high_direction);
1392 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1393 trst,
1394 srst,
1395 high_output,
1396 high_direction);
1397 }
1398
1399 static void olimex_jtag_reset(int trst, int srst)
1400 {
1401 enum reset_types jtag_reset_config = jtag_get_reset_config();
1402 if (trst == 1) {
1403 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1404 high_output &= ~nTRSTnOE;
1405 else
1406 high_output &= ~nTRST;
1407 } else if (trst == 0) {
1408 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1409 high_output |= nTRSTnOE;
1410 else
1411 high_output |= nTRST;
1412 }
1413
1414 if (srst == 1)
1415 high_output |= nSRST;
1416 else if (srst == 0)
1417 high_output &= ~nSRST;
1418
1419 /* command "set data bits high byte" */
1420 buffer_write(0x82);
1421 buffer_write(high_output);
1422 buffer_write(high_direction);
1423 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1424 trst,
1425 srst,
1426 high_output,
1427 high_direction);
1428 }
1429
1430 static void axm0432_jtag_reset(int trst, int srst)
1431 {
1432 if (trst == 1) {
1433 tap_set_state(TAP_RESET);
1434 high_output &= ~nTRST;
1435 } else if (trst == 0)
1436 high_output |= nTRST;
1437
1438 if (srst == 1)
1439 high_output &= ~nSRST;
1440 else if (srst == 0)
1441 high_output |= nSRST;
1442
1443 /* command "set data bits low byte" */
1444 buffer_write(0x82);
1445 buffer_write(high_output);
1446 buffer_write(high_direction);
1447 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1448 trst,
1449 srst,
1450 high_output,
1451 high_direction);
1452 }
1453
1454 static void flyswatter_reset(int trst, int srst)
1455 {
1456 if (trst == 1)
1457 low_output &= ~nTRST;
1458 else if (trst == 0)
1459 low_output |= nTRST;
1460
1461 if (srst == 1)
1462 low_output |= nSRST;
1463 else if (srst == 0)
1464 low_output &= ~nSRST;
1465
1466 /* command "set data bits low byte" */
1467 buffer_write(0x80);
1468 buffer_write(low_output);
1469 buffer_write(low_direction);
1470 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1471 trst,
1472 srst,
1473 low_output,
1474 low_direction);
1475 }
1476
1477 static void flyswatter1_reset(int trst, int srst)
1478 {
1479 flyswatter_reset(trst, srst);
1480 }
1481
1482 static void flyswatter2_reset(int trst, int srst)
1483 {
1484 flyswatter_reset(trst, !srst);
1485 }
1486
1487 static void minimodule_reset(int trst, int srst)
1488 {
1489 if (srst == 1)
1490 low_output &= ~nSRST;
1491 else if (srst == 0)
1492 low_output |= nSRST;
1493
1494 /* command "set data bits low byte" */
1495 buffer_write(0x80);
1496 buffer_write(low_output);
1497 buffer_write(low_direction);
1498 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1499 trst,
1500 srst,
1501 low_output,
1502 low_direction);
1503 }
1504
1505 static void turtle_reset(int trst, int srst)
1506 {
1507 trst = trst;
1508
1509 if (srst == 1)
1510 low_output |= nSRST;
1511 else if (srst == 0)
1512 low_output &= ~nSRST;
1513
1514 /* command "set data bits low byte" */
1515 buffer_write(0x80);
1516 buffer_write(low_output);
1517 buffer_write(low_direction);
1518 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
1519 srst,
1520 low_output,
1521 low_direction);
1522 }
1523
1524 static void comstick_reset(int trst, int srst)
1525 {
1526 if (trst == 1)
1527 high_output &= ~nTRST;
1528 else if (trst == 0)
1529 high_output |= nTRST;
1530
1531 if (srst == 1)
1532 high_output &= ~nSRST;
1533 else if (srst == 0)
1534 high_output |= nSRST;
1535
1536 /* command "set data bits high byte" */
1537 buffer_write(0x82);
1538 buffer_write(high_output);
1539 buffer_write(high_direction);
1540 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1541 trst,
1542 srst,
1543 high_output,
1544 high_direction);
1545 }
1546
1547 static void stm32stick_reset(int trst, int srst)
1548 {
1549 if (trst == 1)
1550 high_output &= ~nTRST;
1551 else if (trst == 0)
1552 high_output |= nTRST;
1553
1554 if (srst == 1)
1555 low_output &= ~nSRST;
1556 else if (srst == 0)
1557 low_output |= nSRST;
1558
1559 /* command "set data bits low byte" */
1560 buffer_write(0x80);
1561 buffer_write(low_output);
1562 buffer_write(low_direction);
1563
1564 /* command "set data bits high byte" */
1565 buffer_write(0x82);
1566 buffer_write(high_output);
1567 buffer_write(high_direction);
1568 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1569 trst,
1570 srst,
1571 high_output,
1572 high_direction);
1573 }
1574
1575 static void sheevaplug_reset(int trst, int srst)
1576 {
1577 if (trst == 1)
1578 high_output &= ~nTRST;
1579 else if (trst == 0)
1580 high_output |= nTRST;
1581
1582 if (srst == 1)
1583 high_output &= ~nSRSTnOE;
1584 else if (srst == 0)
1585 high_output |= nSRSTnOE;
1586
1587 /* command "set data bits high byte" */
1588 buffer_write(0x82);
1589 buffer_write(high_output);
1590 buffer_write(high_direction);
1591 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x",
1592 trst,
1593 srst,
1594 high_output,
1595 high_direction);
1596 }
1597
1598 static void redbee_reset(int trst, int srst)
1599 {
1600 if (trst == 1) {
1601 tap_set_state(TAP_RESET);
1602 high_output &= ~nTRST;
1603 } else if (trst == 0)
1604 high_output |= nTRST;
1605
1606 if (srst == 1)
1607 high_output &= ~nSRST;
1608 else if (srst == 0)
1609 high_output |= nSRST;
1610
1611 /* command "set data bits low byte" */
1612 buffer_write(0x82);
1613 buffer_write(high_output);
1614 buffer_write(high_direction);
1615 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1616 "high_direction: 0x%2.2x", trst, srst, high_output,
1617 high_direction);
1618 }
1619
1620 static void xds100v2_reset(int trst, int srst)
1621 {
1622 if (trst == 1) {
1623 tap_set_state(TAP_RESET);
1624 high_output &= ~nTRST;
1625 } else if (trst == 0)
1626 high_output |= nTRST;
1627
1628 if (srst == 1)
1629 high_output |= nSRST;
1630 else if (srst == 0)
1631 high_output &= ~nSRST;
1632
1633 /* command "set data bits low byte" */
1634 buffer_write(0x82);
1635 buffer_write(high_output);
1636 buffer_write(high_direction);
1637 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, "
1638 "high_direction: 0x%2.2x", trst, srst, high_output,
1639 high_direction);
1640 }
1641
1642 static int ft2232_execute_runtest(struct jtag_command *cmd)
1643 {
1644 int retval;
1645 int i;
1646 int predicted_size = 0;
1647 retval = ERROR_OK;
1648
1649 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1650 cmd->cmd.runtest->num_cycles,
1651 tap_state_name(cmd->cmd.runtest->end_state));
1652
1653 /* only send the maximum buffer size that FT2232C can handle */
1654 predicted_size = 0;
1655 if (tap_get_state() != TAP_IDLE)
1656 predicted_size += 3;
1657 predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
1658 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1659 predicted_size += 3;
1660 if (tap_get_end_state() != TAP_IDLE)
1661 predicted_size += 3;
1662 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1663 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1664 retval = ERROR_JTAG_QUEUE_FAILED;
1665 require_send = 0;
1666 first_unsent = cmd;
1667 }
1668 if (tap_get_state() != TAP_IDLE) {
1669 move_to_state(TAP_IDLE);
1670 require_send = 1;
1671 }
1672 i = cmd->cmd.runtest->num_cycles;
1673 while (i > 0) {
1674 /* there are no state transitions in this code, so omit state tracking */
1675
1676 /* command "Clock Data to TMS/CS Pin (no Read)" */
1677 buffer_write(0x4b);
1678
1679 /* scan 7 bits */
1680 buffer_write((i > 7) ? 6 : (i - 1));
1681
1682 /* TMS data bits */
1683 buffer_write(0x0);
1684
1685 i -= (i > 7) ? 7 : i;
1686 /* LOG_DEBUG("added TMS scan (no read)"); */
1687 }
1688
1689 ft2232_end_state(cmd->cmd.runtest->end_state);
1690
1691 if (tap_get_state() != tap_get_end_state())
1692 move_to_state(tap_get_end_state());
1693
1694 require_send = 1;
1695 DEBUG_JTAG_IO("runtest: %i, end in %s",
1696 cmd->cmd.runtest->num_cycles,
1697 tap_state_name(tap_get_end_state()));
1698 return retval;
1699 }
1700
1701 static int ft2232_execute_statemove(struct jtag_command *cmd)
1702 {
1703 int predicted_size = 0;
1704 int retval = ERROR_OK;
1705
1706 DEBUG_JTAG_IO("statemove end in %s",
1707 tap_state_name(cmd->cmd.statemove->end_state));
1708
1709 /* only send the maximum buffer size that FT2232C can handle */
1710 predicted_size = 3;
1711 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1712 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1713 retval = ERROR_JTAG_QUEUE_FAILED;
1714 require_send = 0;
1715 first_unsent = cmd;
1716 }
1717 ft2232_end_state(cmd->cmd.statemove->end_state);
1718
1719 /* For TAP_RESET, ignore the current recorded state. It's often
1720 * wrong at server startup, and this transation is critical whenever
1721 * it's requested.
1722 */
1723 if (tap_get_end_state() == TAP_RESET) {
1724 clock_tms(0x4b, 0xff, 5, 0);
1725 require_send = 1;
1726
1727 /* shortest-path move to desired end state */
1728 } else if (tap_get_state() != tap_get_end_state()) {
1729 move_to_state(tap_get_end_state());
1730 require_send = 1;
1731 }
1732
1733 return retval;
1734 }
1735
1736 /**
1737 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
1738 * (or SWD) state machine.
1739 */
1740 static int ft2232_execute_tms(struct jtag_command *cmd)
1741 {
1742 int retval = ERROR_OK;
1743 unsigned num_bits = cmd->cmd.tms->num_bits;
1744 const uint8_t *bits = cmd->cmd.tms->bits;
1745 unsigned count;
1746
1747 DEBUG_JTAG_IO("TMS: %d bits", num_bits);
1748
1749 /* only send the maximum buffer size that FT2232C can handle */
1750 count = 3 * DIV_ROUND_UP(num_bits, 4);
1751 if (ft2232_buffer_size + 3*count + 1 > FT2232_BUFFER_SIZE) {
1752 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1753 retval = ERROR_JTAG_QUEUE_FAILED;
1754
1755 require_send = 0;
1756 first_unsent = cmd;
1757 }
1758
1759 /* Shift out in batches of at most 6 bits; there's a report of an
1760 * FT2232 bug in this area, where shifting exactly 7 bits can make
1761 * problems with TMS signaling for the last clock cycle:
1762 *
1763 * http://developer.intra2net.com/mailarchive/html/
1764 * libftdi/2009/msg00292.html
1765 *
1766 * Command 0x4b is: "Clock Data to TMS/CS Pin (no Read)"
1767 *
1768 * Note that pathmoves in JTAG are not often seven bits, so that
1769 * isn't a particularly likely situation outside of "special"
1770 * signaling such as switching between JTAG and SWD modes.
1771 */
1772 while (num_bits) {
1773 if (num_bits <= 6) {
1774 buffer_write(0x4b);
1775 buffer_write(num_bits - 1);
1776 buffer_write(*bits & 0x3f);
1777 break;
1778 }
1779
1780 /* Yes, this is lazy ... we COULD shift out more data
1781 * bits per operation, but doing it in nybbles is easy
1782 */
1783 buffer_write(0x4b);
1784 buffer_write(3);
1785 buffer_write(*bits & 0xf);
1786 num_bits -= 4;
1787
1788 count = (num_bits > 4) ? 4 : num_bits;
1789
1790 buffer_write(0x4b);
1791 buffer_write(count - 1);
1792 buffer_write((*bits >> 4) & 0xf);
1793 num_bits -= count;
1794
1795 bits++;
1796 }
1797
1798 require_send = 1;
1799 return retval;
1800 }
1801
1802 static int ft2232_execute_pathmove(struct jtag_command *cmd)
1803 {
1804 int predicted_size = 0;
1805 int retval = ERROR_OK;
1806
1807 tap_state_t *path = cmd->cmd.pathmove->path;
1808 int num_states = cmd->cmd.pathmove->num_states;
1809
1810 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1811 tap_state_name(tap_get_state()),
1812 tap_state_name(path[num_states-1]));
1813
1814 /* only send the maximum buffer size that FT2232C can handle */
1815 predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
1816 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1817 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1818 retval = ERROR_JTAG_QUEUE_FAILED;
1819
1820 require_send = 0;
1821 first_unsent = cmd;
1822 }
1823
1824 ft2232_add_pathmove(path, num_states);
1825 require_send = 1;
1826
1827 return retval;
1828 }
1829
1830 static int ft2232_execute_scan(struct jtag_command *cmd)
1831 {
1832 uint8_t *buffer;
1833 int scan_size; /* size of IR or DR scan */
1834 int predicted_size = 0;
1835 int retval = ERROR_OK;
1836
1837 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1838
1839 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1840
1841 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1842
1843 predicted_size = ft2232_predict_scan_out(scan_size, type);
1844 if ((predicted_size + 1) > FT2232_BUFFER_SIZE) {
1845 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1846 /* unsent commands before this */
1847 if (first_unsent != cmd)
1848 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1849 retval = ERROR_JTAG_QUEUE_FAILED;
1850
1851 /* current command */
1852 ft2232_end_state(cmd->cmd.scan->end_state);
1853 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1854 require_send = 0;
1855 first_unsent = cmd->next;
1856 if (buffer)
1857 free(buffer);
1858 return retval;
1859 } else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1860 LOG_DEBUG(
1861 "ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1862 first_unsent,
1863 cmd);
1864 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1865 retval = ERROR_JTAG_QUEUE_FAILED;
1866 require_send = 0;
1867 first_unsent = cmd;
1868 }
1869 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1870 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1871 ft2232_end_state(cmd->cmd.scan->end_state);
1872 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1873 require_send = 1;
1874 if (buffer)
1875 free(buffer);
1876 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1877 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1878 tap_state_name(tap_get_end_state()));
1879 return retval;
1880
1881 }
1882
1883 static int ft2232_execute_reset(struct jtag_command *cmd)
1884 {
1885 int retval;
1886 int predicted_size = 0;
1887 retval = ERROR_OK;
1888
1889 DEBUG_JTAG_IO("reset trst: %i srst %i",
1890 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1891
1892 /* only send the maximum buffer size that FT2232C can handle */
1893 predicted_size = 3;
1894 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) {
1895 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1896 retval = ERROR_JTAG_QUEUE_FAILED;
1897 require_send = 0;
1898 first_unsent = cmd;
1899 }
1900
1901 if ((cmd->cmd.reset->trst == 1) ||
1902 (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1903 tap_set_state(TAP_RESET);
1904
1905 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1906 require_send = 1;
1907
1908 DEBUG_JTAG_IO("trst: %i, srst: %i",
1909 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1910 return retval;
1911 }
1912
1913 static int ft2232_execute_sleep(struct jtag_command *cmd)
1914 {
1915 int retval;
1916 retval = ERROR_OK;
1917
1918 DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
1919
1920 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1921 retval = ERROR_JTAG_QUEUE_FAILED;
1922 first_unsent = cmd->next;
1923 jtag_sleep(cmd->cmd.sleep->us);
1924 DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
1925 cmd->cmd.sleep->us,
1926 tap_state_name(tap_get_state()));
1927 return retval;
1928 }
1929
1930 static int ft2232_execute_stableclocks(struct jtag_command *cmd)
1931 {
1932 int retval;
1933 retval = ERROR_OK;
1934
1935 /* this is only allowed while in a stable state. A check for a stable
1936 * state was done in jtag_add_clocks()
1937 */
1938 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1939 retval = ERROR_JTAG_QUEUE_FAILED;
1940 DEBUG_JTAG_IO("clocks %i while in %s",
1941 cmd->cmd.stableclocks->num_cycles,
1942 tap_state_name(tap_get_state()));
1943 return retval;
1944 }
1945
1946 static int ft2232_execute_command(struct jtag_command *cmd)
1947 {
1948 int retval;
1949
1950 switch (cmd->type) {
1951 case JTAG_RESET:
1952 retval = ft2232_execute_reset(cmd);
1953 break;
1954 case JTAG_RUNTEST:
1955 retval = ft2232_execute_runtest(cmd);
1956 break;
1957 case JTAG_TLR_RESET:
1958 retval = ft2232_execute_statemove(cmd);
1959 break;
1960 case JTAG_PATHMOVE:
1961 retval = ft2232_execute_pathmove(cmd);
1962 break;
1963 case JTAG_SCAN:
1964 retval = ft2232_execute_scan(cmd);
1965 break;
1966 case JTAG_SLEEP:
1967 retval = ft2232_execute_sleep(cmd);
1968 break;
1969 case JTAG_STABLECLOCKS:
1970 retval = ft2232_execute_stableclocks(cmd);
1971 break;
1972 case JTAG_TMS:
1973 retval = ft2232_execute_tms(cmd);
1974 break;
1975 default:
1976 LOG_ERROR("BUG: unknown JTAG command type encountered");
1977 retval = ERROR_JTAG_QUEUE_FAILED;
1978 break;
1979 }
1980 return retval;
1981 }
1982
1983 static int ft2232_execute_queue(void)
1984 {
1985 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
1986 int retval;
1987
1988 first_unsent = cmd; /* next command that has to be sent */
1989 require_send = 0;
1990
1991 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1992 * that wasn't handled by a caller-provided error handler
1993 */
1994 retval = ERROR_OK;
1995
1996 ft2232_buffer_size = 0;
1997 ft2232_expect_read = 0;
1998
1999 /* blink, if the current layout has that feature */
2000 if (layout->blink)
2001 layout->blink();
2002
2003 while (cmd) {
2004 /* fill the write buffer with the desired command */
2005 if (ft2232_execute_command(cmd) != ERROR_OK)
2006 retval = ERROR_JTAG_QUEUE_FAILED;
2007 /* Start reading input before FT2232 TX buffer fills up.
2008 * Sometimes this happens because we don't know the
2009 * length of the last command before we execute it. So
2010 * we simple inform the user.
2011 */
2012 cmd = cmd->next;
2013
2014 if (ft2232_expect_read >= FT2232_BUFFER_READ_QUEUE_SIZE) {
2015 if (ft2232_expect_read > (FT2232_BUFFER_READ_QUEUE_SIZE+1))
2016 LOG_DEBUG("read buffer size looks too high %d/%d",
2017 ft2232_expect_read,
2018 (FT2232_BUFFER_READ_QUEUE_SIZE+1));
2019 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2020 retval = ERROR_JTAG_QUEUE_FAILED;
2021 first_unsent = cmd;
2022 }
2023 }
2024
2025 if (require_send > 0)
2026 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2027 retval = ERROR_JTAG_QUEUE_FAILED;
2028
2029 return retval;
2030 }
2031
2032 #if BUILD_FT2232_FTD2XX == 1
2033 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int *try_more)
2034 {
2035 FT_STATUS status;
2036 DWORD deviceID;
2037 char SerialNumber[16];
2038 char Description[64];
2039 DWORD openex_flags = 0;
2040 char *openex_string = NULL;
2041 uint8_t latency_timer;
2042
2043 if (layout == NULL) {
2044 LOG_WARNING("No ft2232 layout specified'");
2045 return ERROR_JTAG_INIT_FAILED;
2046 }
2047
2048 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)",
2049 layout->name, vid, pid);
2050
2051 #if IS_WIN32 == 0
2052 /* Add non-standard Vid/Pid to the linux driver */
2053 status = FT_SetVIDPID(vid, pid);
2054 if (status != FT_OK)
2055 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
2056
2057 #endif
2058
2059 if (ft2232_device_desc && ft2232_serial) {
2060 LOG_WARNING(
2061 "can't open by device description and serial number, giving precedence to serial");
2062 ft2232_device_desc = NULL;
2063 }
2064
2065 if (ft2232_device_desc) {
2066 openex_string = ft2232_device_desc;
2067 openex_flags = FT_OPEN_BY_DESCRIPTION;
2068 } else if (ft2232_serial) {
2069 openex_string = ft2232_serial;
2070 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
2071 } else {
2072 LOG_ERROR("neither device description nor serial number specified");
2073 LOG_ERROR(
2074 "please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
2075
2076 return ERROR_JTAG_INIT_FAILED;
2077 }
2078
2079 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2080 if (status != FT_OK) {
2081 /* under Win32, the FTD2XX driver appends an "A" to the end
2082 * of the description, if we tried by the desc, then
2083 * try by the alternate "A" description. */
2084 if (openex_string == ft2232_device_desc) {
2085 /* Try the alternate method. */
2086 openex_string = ft2232_device_desc_A;
2087 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
2088 if (status == FT_OK) {
2089 /* yea, the "alternate" method worked! */
2090 } else {
2091 /* drat, give the user a meaningfull message.
2092 * telling the use we tried *BOTH* methods. */
2093 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'",
2094 ft2232_device_desc,
2095 ft2232_device_desc_A);
2096 }
2097 }
2098 }
2099
2100 if (status != FT_OK) {
2101 DWORD num_devices;
2102
2103 if (more) {
2104 LOG_WARNING("unable to open ftdi device (trying more): %s",
2105 ftd2xx_status_string(status));
2106 *try_more = 1;
2107 return ERROR_JTAG_INIT_FAILED;
2108 }
2109 LOG_ERROR("unable to open ftdi device: %s",
2110 ftd2xx_status_string(status));
2111 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
2112 if (status == FT_OK) {
2113 char **desc_array = malloc(sizeof(char *) * (num_devices + 1));
2114 uint32_t i;
2115
2116 for (i = 0; i < num_devices; i++)
2117 desc_array[i] = malloc(64);
2118
2119 desc_array[num_devices] = NULL;
2120
2121 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
2122
2123 if (status == FT_OK) {
2124 LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
2125 for (i = 0; i < num_devices; i++)
2126 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
2127 }
2128
2129 for (i = 0; i < num_devices; i++)
2130 free(desc_array[i]);
2131
2132 free(desc_array);
2133 } else
2134 LOG_ERROR("ListDevices: NONE");
2135 return ERROR_JTAG_INIT_FAILED;
2136 }
2137
2138 status = FT_SetLatencyTimer(ftdih, ft2232_latency);
2139 if (status != FT_OK) {
2140 LOG_ERROR("unable to set latency timer: %s",
2141 ftd2xx_status_string(status));
2142 return ERROR_JTAG_INIT_FAILED;
2143 }
2144
2145 status = FT_GetLatencyTimer(ftdih, &latency_timer);
2146 if (status != FT_OK) {
2147 /* ftd2xx 1.04 (linux) has a bug when calling FT_GetLatencyTimer
2148 * so ignore errors if using this driver version */
2149 DWORD dw_version;
2150
2151 status = FT_GetDriverVersion(ftdih, &dw_version);
2152 LOG_ERROR("unable to get latency timer: %s",
2153 ftd2xx_status_string(status));
2154
2155 if ((status == FT_OK) && (dw_version == 0x10004)) {
2156 LOG_ERROR("ftd2xx 1.04 detected - this has known issues " \
2157 "with FT_GetLatencyTimer, upgrade to a newer version");
2158 } else
2159 return ERROR_JTAG_INIT_FAILED;
2160 } else
2161 LOG_DEBUG("current latency timer: %i", latency_timer);
2162
2163 status = FT_SetTimeouts(ftdih, 5000, 5000);
2164 if (status != FT_OK) {
2165 LOG_ERROR("unable to set timeouts: %s",
2166 ftd2xx_status_string(status));
2167 return ERROR_JTAG_INIT_FAILED;
2168 }
2169
2170 status = FT_SetBitMode(ftdih, 0x0b, 2);
2171 if (status != FT_OK) {
2172 LOG_ERROR("unable to enable bit i/o mode: %s",
2173 ftd2xx_status_string(status));
2174 return ERROR_JTAG_INIT_FAILED;
2175 }
2176
2177 status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID,
2178 SerialNumber, Description, NULL);
2179 if (status != FT_OK) {
2180 LOG_ERROR("unable to get FT_GetDeviceInfo: %s",
2181 ftd2xx_status_string(status));
2182 return ERROR_JTAG_INIT_FAILED;
2183 } else {
2184 static const char *type_str[] = {
2185 "BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H", "232H"
2186 };
2187 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2188 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
2189 ? ftdi_device : FT_DEVICE_UNKNOWN;
2190 LOG_INFO("device: %" PRIu32 " \"%s\"", (uint32_t)ftdi_device, type_str[type_index]);
2191 LOG_INFO("deviceID: %" PRIu32, (uint32_t)deviceID);
2192 LOG_INFO("SerialNumber: %s", SerialNumber);
2193 LOG_INFO("Description: %s", Description);
2194 }
2195
2196 return ERROR_OK;
2197 }
2198
2199 static int ft2232_purge_ftd2xx(void)
2200 {
2201 FT_STATUS status;
2202
2203 status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
2204 if (status != FT_OK) {
2205 LOG_ERROR("error purging ftd2xx device: %s",
2206 ftd2xx_status_string(status));
2207 return ERROR_JTAG_INIT_FAILED;
2208 }
2209
2210 return ERROR_OK;
2211 }
2212
2213 #endif /* BUILD_FT2232_FTD2XX == 1 */
2214
2215 #if BUILD_FT2232_LIBFTDI == 1
2216 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int *try_more, int channel)
2217 {
2218 uint8_t latency_timer;
2219
2220 if (layout == NULL) {
2221 LOG_WARNING("No ft2232 layout specified'");
2222 return ERROR_JTAG_INIT_FAILED;
2223 }
2224
2225 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2226 layout->name, vid, pid);
2227
2228 if (ftdi_init(&ftdic) < 0)
2229 return ERROR_JTAG_INIT_FAILED;
2230
2231 /* default to INTERFACE_A */
2232 if (channel == INTERFACE_ANY)
2233 channel = INTERFACE_A;
2234 if (ftdi_set_interface(&ftdic, channel) < 0) {
2235 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2236 return ERROR_JTAG_INIT_FAILED;
2237 }
2238
2239 /* context, vendor id, product id */
2240 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc, ft2232_serial) < 0) {
2241 if (more)
2242 LOG_WARNING("unable to open ftdi device (trying more): %s",
2243 ftdic.error_str);
2244 else
2245 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2246 *try_more = 1;
2247 return ERROR_JTAG_INIT_FAILED;
2248 }
2249
2250 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2251 if (ftdi_usb_reset(&ftdic) < 0) {
2252 LOG_ERROR("unable to reset ftdi device");
2253 return ERROR_JTAG_INIT_FAILED;
2254 }
2255
2256 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0) {
2257 LOG_ERROR("unable to set latency timer");
2258 return ERROR_JTAG_INIT_FAILED;
2259 }
2260
2261 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0) {
2262 LOG_ERROR("unable to get latency timer");
2263 return ERROR_JTAG_INIT_FAILED;
2264 } else
2265 LOG_DEBUG("current latency timer: %i", latency_timer);
2266
2267 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2268
2269 ftdi_device = ftdic.type;
2270 static const char *type_str[] = {
2271 "AM", "BM", "2232C", "R", "2232H", "4232H", "232H", "Unknown"
2272 };
2273 unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
2274 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2275 ? ftdi_device : no_of_known_types;
2276 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2277 return ERROR_OK;
2278 }
2279
2280 static int ft2232_purge_libftdi(void)
2281 {
2282 if (ftdi_usb_purge_buffers(&ftdic) < 0) {
2283 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2284 return ERROR_JTAG_INIT_FAILED;
2285 }
2286
2287 return ERROR_OK;
2288 }
2289
2290 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2291
2292 static int ft2232_set_data_bits_low_byte(uint8_t value, uint8_t direction)
2293 {
2294 uint8_t buf[3];
2295 uint32_t bytes_written;
2296
2297 buf[0] = 0x80; /* command "set data bits low byte" */
2298 buf[1] = value; /* value */
2299 buf[2] = direction; /* direction */
2300
2301 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2302
2303 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2304 LOG_ERROR("couldn't initialize data bits low byte");
2305 return ERROR_JTAG_INIT_FAILED;
2306 }
2307
2308 return ERROR_OK;
2309 }
2310
2311 static int ft2232_set_data_bits_high_byte(uint8_t value, uint8_t direction)
2312 {
2313 uint8_t buf[3];
2314 uint32_t bytes_written;
2315
2316 buf[0] = 0x82; /* command "set data bits high byte" */
2317 buf[1] = value; /* value */
2318 buf[2] = direction; /* direction */
2319
2320 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2321
2322 if (ft2232_write(buf, sizeof(buf), &bytes_written) != ERROR_OK) {
2323 LOG_ERROR("couldn't initialize data bits high byte");
2324 return ERROR_JTAG_INIT_FAILED;
2325 }
2326
2327 return ERROR_OK;
2328 }
2329
2330 static int ft2232_init(void)
2331 {
2332 uint8_t buf[1];
2333 int retval;
2334 uint32_t bytes_written;
2335
2336 if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
2337 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2338 else
2339 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2340 if (layout == NULL) {
2341 LOG_WARNING("No ft2232 layout specified'");
2342 return ERROR_JTAG_INIT_FAILED;
2343 }
2344
2345 for (int i = 0; 1; i++) {
2346 /*
2347 * "more indicates that there are more IDs to try, so we should
2348 * not print an error for an ID mismatch (but for anything
2349 * else, we should).
2350 *
2351 * try_more indicates that the error code returned indicates an
2352 * ID mismatch (and nothing else) and that we should proceeed
2353 * with the next ID pair.
2354 */
2355 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2356 int try_more = 0;
2357
2358 #if BUILD_FT2232_FTD2XX == 1
2359 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2360 more, &try_more);
2361 #elif BUILD_FT2232_LIBFTDI == 1
2362 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2363 more, &try_more, ft2232_channel);
2364 #endif
2365 if (retval >= 0)
2366 break;
2367 if (!more || !try_more)
2368 return retval;
2369 }
2370
2371 ft2232_buffer_size = 0;
2372 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2373
2374 if (layout->init() != ERROR_OK)
2375 return ERROR_JTAG_INIT_FAILED;
2376
2377 if (ft2232_device_is_highspeed()) {
2378 #ifndef BUILD_FT2232_HIGHSPEED
2379 #if BUILD_FT2232_FTD2XX == 1
2380 LOG_WARNING(
2381 "High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2382 #elif BUILD_FT2232_LIBFTDI == 1
2383 LOG_WARNING(
2384 "High Speed device found - You need a newer libftdi version (0.16 or later)");
2385 #endif
2386 #endif
2387 /* make sure the legacy mode is disabled */
2388 if (ftx232h_clk_divide_by_5(false) != ERROR_OK)
2389 return ERROR_JTAG_INIT_FAILED;
2390 }
2391
2392 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2393 retval = ft2232_write(buf, 1, &bytes_written);
2394 if (retval != ERROR_OK) {
2395 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2396 return ERROR_JTAG_INIT_FAILED;
2397 }
2398
2399 #if BUILD_FT2232_FTD2XX == 1
2400 return ft2232_purge_ftd2xx();
2401 #elif BUILD_FT2232_LIBFTDI == 1
2402 return ft2232_purge_libftdi();
2403 #endif
2404
2405 return ERROR_OK;
2406 }
2407
2408 /** Updates defaults for DBUS signals: the four JTAG signals
2409 * (TCK, TDI, TDO, TMS) and * the four GPIOL signals.
2410 */
2411 static inline void ftx232_dbus_init(void)
2412 {
2413 low_output = 0x08;
2414 low_direction = 0x0b;
2415 }
2416
2417 /** Initializes DBUS signals: the four JTAG signals (TCK, TDI, TDO, TMS),
2418 * the four GPIOL signals. Initialization covers value and direction,
2419 * as customized for each layout.
2420 */
2421 static int ftx232_dbus_write(void)
2422 {
2423 enum reset_types jtag_reset_config = jtag_get_reset_config();
2424 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2425 low_direction &= ~nTRSTnOE; /* nTRST input */
2426 low_output &= ~nTRST; /* nTRST = 0 */
2427 } else {
2428 low_direction |= nTRSTnOE; /* nTRST output */
2429 low_output |= nTRST; /* nTRST = 1 */
2430 }
2431
2432 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2433 low_direction |= nSRSTnOE; /* nSRST output */
2434 low_output |= nSRST; /* nSRST = 1 */
2435 } else {
2436 low_direction &= ~nSRSTnOE; /* nSRST input */
2437 low_output &= ~nSRST; /* nSRST = 0 */
2438 }
2439
2440 /* initialize low byte for jtag */
2441 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2442 LOG_ERROR("couldn't initialize FT2232 DBUS");
2443 return ERROR_JTAG_INIT_FAILED;
2444 }
2445
2446 return ERROR_OK;
2447 }
2448
2449 static int usbjtag_init(void)
2450 {
2451 /*
2452 * NOTE: This is now _specific_ to the "usbjtag" layout.
2453 * Don't try cram any more layouts into this.
2454 */
2455 ftx232_dbus_init();
2456
2457 nTRST = 0x10;
2458 nTRSTnOE = 0x10;
2459 nSRST = 0x40;
2460 nSRSTnOE = 0x40;
2461
2462 return ftx232_dbus_write();
2463 }
2464
2465 static int lm3s811_jtag_init(void)
2466 {
2467 ftx232_dbus_init();
2468
2469 /* There are multiple revisions of LM3S811 eval boards:
2470 * - Rev B (and older?) boards have no SWO trace support.
2471 * - Rev C boards add ADBUS_6 DBG_ENn and BDBUS_4 SWO_EN;
2472 * they should use the "luminary_icdi" layout instead.
2473 */
2474 nTRST = 0x0;
2475 nTRSTnOE = 0x00;
2476 nSRST = 0x20;
2477 nSRSTnOE = 0x20;
2478 low_output = 0x88;
2479 low_direction = 0x8b;
2480
2481 return ftx232_dbus_write();
2482 }
2483
2484 static int icdi_jtag_init(void)
2485 {
2486 ftx232_dbus_init();
2487
2488 /* Most Luminary eval boards support SWO trace output,
2489 * and should use this "luminary_icdi" layout.
2490 *
2491 * ADBUS 0..3 are used for JTAG as usual. GPIOs are used
2492 * to switch between JTAG and SWD, or switch the ft2232 UART
2493 * on the second MPSSE channel/interface (BDBUS)
2494 * between (i) the stellaris UART (on Luminary boards)
2495 * or (ii) SWO trace data (generic).
2496 *
2497 * We come up in JTAG mode and may switch to SWD later (with
2498 * SWO/trace option if SWD is active).
2499 *
2500 * DBUS == GPIO-Lx
2501 * CBUS == GPIO-Hx
2502 */
2503
2504
2505 #define ICDI_JTAG_EN (1 << 7) /* ADBUS 7 (a.k.a. DBGMOD) */
2506 #define ICDI_DBG_ENn (1 << 6) /* ADBUS 6 */
2507 #define ICDI_SRST (1 << 5) /* ADBUS 5 */
2508
2509
2510 /* GPIOs on second channel/interface (UART) ... */
2511 #define ICDI_SWO_EN (1 << 4) /* BDBUS 4 */
2512 #define ICDI_TX_SWO (1 << 1) /* BDBUS 1 */
2513 #define ICDI_VCP_RX (1 << 0) /* BDBUS 0 (to stellaris UART) */
2514
2515 nTRST = 0x0;
2516 nTRSTnOE = 0x00;
2517 nSRST = ICDI_SRST;
2518 nSRSTnOE = ICDI_SRST;
2519
2520 low_direction |= ICDI_JTAG_EN | ICDI_DBG_ENn;
2521 low_output |= ICDI_JTAG_EN;
2522 low_output &= ~ICDI_DBG_ENn;
2523
2524 return ftx232_dbus_write();
2525 }
2526
2527 static int signalyzer_init(void)
2528 {
2529 ftx232_dbus_init();
2530
2531 nTRST = 0x10;
2532 nTRSTnOE = 0x10;
2533 nSRST = 0x20;
2534 nSRSTnOE = 0x20;
2535 return ftx232_dbus_write();
2536 }
2537
2538 static int axm0432_jtag_init(void)
2539 {
2540 low_output = 0x08;
2541 low_direction = 0x2b;
2542
2543 /* initialize low byte for jtag */
2544 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2545 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2546 return ERROR_JTAG_INIT_FAILED;
2547 }
2548
2549 if (strcmp(layout->name, "axm0432_jtag") == 0) {
2550 nTRST = 0x08;
2551 nTRSTnOE = 0x0; /* No output enable for TRST*/
2552 nSRST = 0x04;
2553 nSRSTnOE = 0x0; /* No output enable for SRST*/
2554 } else {
2555 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2556 exit(-1);
2557 }
2558
2559 high_output = 0x0;
2560 high_direction = 0x0c;
2561
2562 enum reset_types jtag_reset_config = jtag_get_reset_config();
2563 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2564 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2565 else
2566 high_output |= nTRST;
2567
2568 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2569 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2570 else
2571 high_output |= nSRST;
2572
2573 /* initialize high byte for jtag */
2574 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2575 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2576 return ERROR_JTAG_INIT_FAILED;
2577 }
2578
2579 return ERROR_OK;
2580 }
2581
2582 static int redbee_init(void)
2583 {
2584 low_output = 0x08;
2585 low_direction = 0x2b;
2586
2587 /* initialize low byte for jtag */
2588 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2589 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2590 return ERROR_JTAG_INIT_FAILED;
2591 }
2592
2593 nTRST = 0x08;
2594 nTRSTnOE = 0x0; /* No output enable for TRST*/
2595 nSRST = 0x04;
2596 nSRSTnOE = 0x0; /* No output enable for SRST*/
2597
2598 high_output = 0x0;
2599 high_direction = 0x0c;
2600
2601 enum reset_types jtag_reset_config = jtag_get_reset_config();
2602 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2603 LOG_ERROR("can't set nTRSTOE to push-pull on redbee");
2604 else
2605 high_output |= nTRST;
2606
2607 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2608 LOG_ERROR("can't set nSRST to push-pull on redbee");
2609 else
2610 high_output |= nSRST;
2611
2612 /* initialize high byte for jtag */
2613 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2614 LOG_ERROR("couldn't initialize FT2232 with 'redbee' layout");
2615 return ERROR_JTAG_INIT_FAILED;
2616 }
2617
2618 return ERROR_OK;
2619 }
2620
2621 static int jtagkey_init(void)
2622 {
2623 low_output = 0x08;
2624 low_direction = 0x1b;
2625
2626 /* initialize low byte for jtag */
2627 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2628 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2629 return ERROR_JTAG_INIT_FAILED;
2630 }
2631
2632 if (strcmp(layout->name, "jtagkey") == 0) {
2633 nTRST = 0x01;
2634 nTRSTnOE = 0x4;
2635 nSRST = 0x02;
2636 nSRSTnOE = 0x08;
2637 } else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2638 || (strcmp(layout->name, "oocdlink") == 0)) {
2639 nTRST = 0x02;
2640 nTRSTnOE = 0x1;
2641 nSRST = 0x08;
2642 nSRSTnOE = 0x04;
2643 } else {
2644 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2645 exit(-1);
2646 }
2647
2648 high_output = 0x0;
2649 high_direction = 0x0f;
2650
2651 enum reset_types jtag_reset_config = jtag_get_reset_config();
2652 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2653 high_output |= nTRSTnOE;
2654 high_output &= ~nTRST;
2655 } else {
2656 high_output &= ~nTRSTnOE;
2657 high_output |= nTRST;
2658 }
2659
2660 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
2661 high_output &= ~nSRSTnOE;
2662 high_output |= nSRST;
2663 } else {
2664 high_output |= nSRSTnOE;
2665 high_output &= ~nSRST;
2666 }
2667
2668 /* initialize high byte for jtag */
2669 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2670 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2671 return ERROR_JTAG_INIT_FAILED;
2672 }
2673
2674 return ERROR_OK;
2675 }
2676
2677 static int olimex_jtag_init(void)
2678 {
2679 low_output = 0x08;
2680 low_direction = 0x1b;
2681
2682 /* initialize low byte for jtag */
2683 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2684 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2685 return ERROR_JTAG_INIT_FAILED;
2686 }
2687
2688 nTRST = 0x01;
2689 nTRSTnOE = 0x4;
2690 nSRST = 0x02;
2691 nSRSTnOE = 0x00;/* no output enable for nSRST */
2692
2693 high_output = 0x0;
2694 high_direction = 0x0f;
2695
2696 enum reset_types jtag_reset_config = jtag_get_reset_config();
2697 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
2698 high_output |= nTRSTnOE;
2699 high_output &= ~nTRST;
2700 } else {
2701 high_output &= ~nTRSTnOE;
2702 high_output |= nTRST;
2703 }
2704
2705 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2706 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2707 else
2708 high_output &= ~nSRST;
2709
2710 /* turn red LED on */
2711 high_output |= 0x08;
2712
2713 /* initialize high byte for jtag */
2714 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2715 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2716 return ERROR_JTAG_INIT_FAILED;
2717 }
2718
2719 return ERROR_OK;
2720 }
2721
2722 static int flyswatter_init(int rev)
2723 {
2724 low_output = 0x18;
2725 low_direction = 0x7b;
2726
2727 if ((rev < 0) || (rev > 3)) {
2728 LOG_ERROR("bogus 'flyswatter' revision supplied (%i)", rev);
2729 return ERROR_JTAG_INIT_FAILED;
2730 }
2731
2732 if (rev == 1)
2733 low_direction |= 1 << 7;
2734
2735 /* initialize low byte for jtag */
2736 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2737 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2738 return ERROR_JTAG_INIT_FAILED;
2739 }
2740
2741 nTRST = 0x10;
2742 nTRSTnOE = 0x0; /* not output enable for nTRST */
2743 nSRST = 0x20;
2744 nSRSTnOE = 0x00; /* no output enable for nSRST */
2745
2746 high_output = 0x00;
2747
2748 if (rev == 1)
2749 high_direction = 0x0c;
2750 else
2751 high_direction = 0x01;
2752
2753 /* turn red LED3 on, LED2 off */
2754 high_output |= 0x08;
2755
2756 /* initialize high byte for jtag */
2757 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2758 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2759 return ERROR_JTAG_INIT_FAILED;
2760 }
2761
2762 return ERROR_OK;
2763 }
2764
2765 static int flyswatter1_init(void)
2766 {
2767 return flyswatter_init(1);
2768 }
2769
2770 static int flyswatter2_init(void)
2771 {
2772 return flyswatter_init(2);
2773 }
2774
2775 static int minimodule_init(void)
2776 {
2777 low_output = 0x18; /* check if srst should be 1 or 0 initially. (0x08) (flyswatter was
2778 * 0x18) */
2779 low_direction = 0xfb; /* 0xfb; */
2780
2781 /* initialize low byte for jtag */
2782 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2783 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2784 return ERROR_JTAG_INIT_FAILED;
2785 }
2786
2787
2788 nSRST = 0x20;
2789
2790 high_output = 0x00;
2791 high_direction = 0x05;
2792
2793 /* turn red LED3 on, LED2 off */
2794 /* high_output |= 0x08; */
2795
2796 /* initialize high byte for jtag */
2797 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2798 LOG_ERROR("couldn't initialize FT2232 with 'minimodule' layout");
2799 return ERROR_JTAG_INIT_FAILED;
2800 }
2801
2802 return ERROR_OK;
2803 }
2804
2805 static int turtle_init(void)
2806 {
2807 low_output = 0x08;
2808 low_direction = 0x5b;
2809
2810 /* initialize low byte for jtag */
2811 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2812 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2813 return ERROR_JTAG_INIT_FAILED;
2814 }
2815
2816 nSRST = 0x40;
2817
2818 high_output = 0x00;
2819 high_direction = 0x0C;
2820
2821 /* initialize high byte for jtag */
2822 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2823 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2824 return ERROR_JTAG_INIT_FAILED;
2825 }
2826
2827 return ERROR_OK;
2828 }
2829
2830 static int comstick_init(void)
2831 {
2832 low_output = 0x08;
2833 low_direction = 0x0b;
2834
2835 /* initialize low byte for jtag */
2836 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2837 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2838 return ERROR_JTAG_INIT_FAILED;
2839 }
2840
2841 nTRST = 0x01;
2842 nTRSTnOE = 0x00; /* no output enable for nTRST */
2843 nSRST = 0x02;
2844 nSRSTnOE = 0x00; /* no output enable for nSRST */
2845
2846 high_output = 0x03;
2847 high_direction = 0x03;
2848
2849 /* initialize high byte for jtag */
2850 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2851 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2852 return ERROR_JTAG_INIT_FAILED;
2853 }
2854
2855 return ERROR_OK;
2856 }
2857
2858 static int stm32stick_init(void)
2859 {
2860 low_output = 0x88;
2861 low_direction = 0x8b;
2862
2863 /* initialize low byte for jtag */
2864 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2865 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2866 return ERROR_JTAG_INIT_FAILED;
2867 }
2868
2869 nTRST = 0x01;
2870 nTRSTnOE = 0x00; /* no output enable for nTRST */
2871 nSRST = 0x80;
2872 nSRSTnOE = 0x00; /* no output enable for nSRST */
2873
2874 high_output = 0x01;
2875 high_direction = 0x03;
2876
2877 /* initialize high byte for jtag */
2878 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2879 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2880 return ERROR_JTAG_INIT_FAILED;
2881 }
2882
2883 return ERROR_OK;
2884 }
2885
2886 static int sheevaplug_init(void)
2887 {
2888 low_output = 0x08;
2889 low_direction = 0x1b;
2890
2891 /* initialize low byte for jtag */
2892 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2893 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2894 return ERROR_JTAG_INIT_FAILED;
2895 }
2896
2897 nTRSTnOE = 0x1;
2898 nTRST = 0x02;
2899 nSRSTnOE = 0x4;
2900 nSRST = 0x08;
2901
2902 high_output = 0x0;
2903 high_direction = 0x0f;
2904
2905 /* nTRST is always push-pull */
2906 high_output &= ~nTRSTnOE;
2907 high_output |= nTRST;
2908
2909 /* nSRST is always open-drain */
2910 high_output |= nSRSTnOE;
2911 high_output &= ~nSRST;
2912
2913 /* initialize high byte for jtag */
2914 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2915 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2916 return ERROR_JTAG_INIT_FAILED;
2917 }
2918
2919 return ERROR_OK;
2920 }
2921
2922 static int cortino_jtag_init(void)
2923 {
2924 low_output = 0x08;
2925 low_direction = 0x1b;
2926
2927 /* initialize low byte for jtag */
2928 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
2929 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2930 return ERROR_JTAG_INIT_FAILED;
2931 }
2932
2933 nTRST = 0x01;
2934 nTRSTnOE = 0x00; /* no output enable for nTRST */
2935 nSRST = 0x02;
2936 nSRSTnOE = 0x00; /* no output enable for nSRST */
2937
2938 high_output = 0x03;
2939 high_direction = 0x03;
2940
2941 /* initialize high byte for jtag */
2942 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2943 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2944 return ERROR_JTAG_INIT_FAILED;
2945 }
2946
2947 return ERROR_OK;
2948 }
2949
2950 static int lisa_l_init(void)
2951 {
2952 ftx232_dbus_init();
2953
2954 nTRST = 0x10;
2955 nTRSTnOE = 0x10;
2956 nSRST = 0x40;
2957 nSRSTnOE = 0x40;
2958
2959 high_output = 0x00;
2960 high_direction = 0x18;
2961
2962 /* initialize high byte for jtag */
2963 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2964 LOG_ERROR("couldn't initialize FT2232 with 'lisa_l' layout");
2965 return ERROR_JTAG_INIT_FAILED;
2966 }
2967
2968 return ftx232_dbus_write();
2969 }
2970
2971 static int flossjtag_init(void)
2972 {
2973 ftx232_dbus_init();
2974
2975 nTRST = 0x10;
2976 nTRSTnOE = 0x10;
2977 nSRST = 0x40;
2978 nSRSTnOE = 0x40;
2979
2980 high_output = 0x00;
2981 high_direction = 0x18;
2982
2983 /* initialize high byte for jtag */
2984 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
2985 LOG_ERROR("couldn't initialize FT2232 with 'Floss-JTAG' layout");
2986 return ERROR_JTAG_INIT_FAILED;
2987 }
2988
2989 return ftx232_dbus_write();
2990 }
2991
2992 /*
2993 * The reference schematic from TI for the XDS100v2 has a CPLD on which opens
2994 * the door for a number of different configurations
2995 *
2996 * Known Implementations:
2997 * http://processors.wiki.ti.com/images/9/93/TMS570LS20216_USB_STICK_Schematic.pdf
2998 *
2999 * http://processors.wiki.ti.com/index.php/XDS100 (rev2)
3000 * * CLPD logic: Rising edge to enable outputs (XDS100_PWR_RST)
3001 * * ACBUS3 to transition 0->1 (OE rising edge)
3002 * * CPLD logic: Put the EMU0/1 pins in Hi-Z:
3003 * * ADBUS5/GPIOL1 = EMU_EN = 1
3004 * * ADBUS6/GPIOL2 = EMU0 = 0
3005 * * ACBUS4/SPARE0 = EMU1 = 0
3006 * * CPLD logic: Disable loopback
3007 * * ACBUS6/SPARE2 = LOOPBACK = 0
3008 */
3009 #define XDS100_nEMU_EN (1<<5)
3010 #define XDS100_nEMU0 (1<<6)
3011
3012 #define XDS100_PWR_RST (1<<3)
3013 #define XDS100_nEMU1 (1<<4)
3014 #define XDS100_LOOPBACK (1<<6)
3015 static int xds100v2_init(void)
3016 {
3017 /* These are in the lower byte */
3018 nTRST = 0x10;
3019 nTRSTnOE = 0x10;
3020
3021 /* These aren't actually used on 14 pin connectors
3022 * These are in the upper byte */
3023 nSRST = 0x01;
3024 nSRSTnOE = 0x01;
3025
3026 low_output = 0x08 | nTRST | XDS100_nEMU_EN;
3027 low_direction = 0x0b | nTRSTnOE | XDS100_nEMU_EN | XDS100_nEMU0;
3028
3029 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3030 LOG_ERROR("couldn't initialize FT2232 with 'xds100v2' layout");
3031 return ERROR_JTAG_INIT_FAILED;
3032 }
3033
3034 high_output = 0;
3035 high_direction = nSRSTnOE | XDS100_LOOPBACK | XDS100_PWR_RST | XDS100_nEMU1;
3036
3037 /* initialize high byte for jtag */
3038 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3039 LOG_ERROR("couldn't put CPLD in to reset with 'xds100v2' layout");
3040 return ERROR_JTAG_INIT_FAILED;
3041 }
3042
3043 high_output |= XDS100_PWR_RST;
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 bring CPLD out of reset with 'xds100v2' layout");
3048 return ERROR_JTAG_INIT_FAILED;
3049 }
3050
3051 return ERROR_OK;
3052 }
3053
3054 static void olimex_jtag_blink(void)
3055 {
3056 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
3057 * ACBUS3 is bit 3 of the GPIOH port
3058 */
3059 high_output ^= 0x08;
3060
3061 buffer_write(0x82);
3062 buffer_write(high_output);
3063 buffer_write(high_direction);
3064 }
3065
3066 static void flyswatter_jtag_blink(unsigned char led)
3067 {
3068 buffer_write(0x82);
3069 buffer_write(high_output ^ led);
3070 buffer_write(high_direction);
3071 }
3072
3073 static void flyswatter1_jtag_blink(void)
3074 {
3075 /*
3076 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
3077 */
3078 flyswatter_jtag_blink(0xc);
3079 }
3080
3081 static void flyswatter2_jtag_blink(void)
3082 {
3083 /*
3084 * Flyswatter2 only has one LED connected to ACBUS2
3085 */
3086 flyswatter_jtag_blink(0x4);
3087 }
3088
3089 static void turtle_jtag_blink(void)
3090 {
3091 /*
3092 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
3093 */
3094 if (high_output & 0x08)
3095 high_output = 0x04;
3096 else
3097 high_output = 0x08;
3098
3099 buffer_write(0x82);
3100 buffer_write(high_output);
3101 buffer_write(high_direction);
3102 }
3103
3104 static void lisa_l_blink(void)
3105 {
3106 /*
3107 * Lisa/L has two LEDs connected to BCBUS3 and BCBUS4
3108 */
3109 if (high_output & 0x10)
3110 high_output = 0x08;
3111 else
3112 high_output = 0x10;
3113
3114 buffer_write(0x82);
3115 buffer_write(high_output);
3116 buffer_write(high_direction);
3117 }
3118
3119 static void flossjtag_blink(void)
3120 {
3121 /*
3122 * Floss-JTAG has two LEDs connected to ACBUS3 and ACBUS4
3123 */
3124 if (high_output & 0x10)
3125 high_output = 0x08;
3126 else
3127 high_output = 0x10;
3128
3129 buffer_write(0x82);
3130 buffer_write(high_output);
3131 buffer_write(high_direction);
3132 }
3133
3134 static int ft2232_quit(void)
3135 {
3136 #if BUILD_FT2232_FTD2XX == 1
3137 FT_STATUS status;
3138
3139 status = FT_Close(ftdih);
3140 #elif BUILD_FT2232_LIBFTDI == 1
3141 ftdi_usb_close(&ftdic);
3142
3143 ftdi_deinit(&ftdic);
3144 #endif
3145
3146 free(ft2232_buffer);
3147 ft2232_buffer = NULL;
3148
3149 return ERROR_OK;
3150 }
3151
3152 COMMAND_HANDLER(ft2232_handle_device_desc_command)
3153 {
3154 char *cp;
3155 char buf[200];
3156 if (CMD_ARGC == 1) {
3157 ft2232_device_desc = strdup(CMD_ARGV[0]);
3158 cp = strchr(ft2232_device_desc, 0);
3159 /* under Win32, the FTD2XX driver appends an "A" to the end
3160 * of the description, this examines the given desc
3161 * and creates the 'missing' _A or non_A variable. */
3162 if ((cp[-1] == 'A') && (cp[-2] == ' ')) {
3163 /* it was, so make this the "A" version. */
3164 ft2232_device_desc_A = ft2232_device_desc;
3165 /* and *CREATE* the non-A version. */
3166 strcpy(buf, ft2232_device_desc);
3167 cp = strchr(buf, 0);
3168 cp[-2] = 0;
3169 ft2232_device_desc = strdup(buf);
3170 } else {
3171 /* <space > A not defined
3172 * so create it */
3173 sprintf(buf, "%s A", ft2232_device_desc);
3174 ft2232_device_desc_A = strdup(buf);
3175 }
3176 } else
3177 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
3178
3179 return ERROR_OK;
3180 }
3181
3182 COMMAND_HANDLER(ft2232_handle_serial_command)
3183 {
3184 if (CMD_ARGC == 1)
3185 ft2232_serial = strdup(CMD_ARGV[0]);
3186 else
3187 return ERROR_COMMAND_SYNTAX_ERROR;
3188
3189 return ERROR_OK;
3190 }
3191
3192 COMMAND_HANDLER(ft2232_handle_layout_command)
3193 {
3194 if (CMD_ARGC != 1)
3195 return ERROR_COMMAND_SYNTAX_ERROR;
3196
3197 if (layout) {
3198 LOG_ERROR("already specified ft2232_layout %s",
3199 layout->name);
3200 return (strcmp(layout->name, CMD_ARGV[0]) != 0)
3201 ? ERROR_FAIL
3202 : ERROR_OK;
3203 }
3204
3205 for (const struct ft2232_layout *l = ft2232_layouts; l->name; l++) {
3206 if (strcmp(l->name, CMD_ARGV[0]) == 0) {
3207 layout = l;
3208 ft2232_channel = l->channel;
3209 return ERROR_OK;
3210 }
3211 }
3212
3213 LOG_ERROR("No FT2232 layout '%s' found", CMD_ARGV[0]);
3214 return ERROR_FAIL;
3215 }
3216
3217 COMMAND_HANDLER(ft2232_handle_vid_pid_command)
3218 {
3219 if (CMD_ARGC > MAX_USB_IDS * 2) {
3220 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
3221 "(maximum is %d pairs)", MAX_USB_IDS);
3222 CMD_ARGC = MAX_USB_IDS * 2;
3223 }
3224 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
3225 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
3226 if (CMD_ARGC < 2)
3227 return ERROR_COMMAND_SYNTAX_ERROR;
3228 /* remove the incomplete trailing id */
3229 CMD_ARGC -= 1;
3230 }
3231
3232 unsigned i;
3233 for (i = 0; i < CMD_ARGC; i += 2) {
3234 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ft2232_vid[i >> 1]);
3235 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ft2232_pid[i >> 1]);
3236 }
3237
3238 /*
3239 * Explicitly terminate, in case there are multiples instances of
3240 * ft2232_vid_pid.
3241 */
3242 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
3243
3244 return ERROR_OK;
3245 }
3246
3247 COMMAND_HANDLER(ft2232_handle_latency_command)
3248 {
3249 if (CMD_ARGC == 1)
3250 ft2232_latency = atoi(CMD_ARGV[0]);
3251 else
3252 return ERROR_COMMAND_SYNTAX_ERROR;
3253
3254 return ERROR_OK;
3255 }
3256
3257 COMMAND_HANDLER(ft2232_handle_channel_command)
3258 {
3259 if (CMD_ARGC == 1) {
3260 ft2232_channel = atoi(CMD_ARGV[0]);
3261 if (ft2232_channel < 0 || ft2232_channel > 4)
3262 LOG_ERROR("ft2232_channel must be in the 0 to 4 range");
3263 } else
3264 LOG_ERROR("expected exactly one argument to ft2232_channel <ch>");
3265
3266 return ERROR_OK;
3267 }
3268
3269 static int ft2232_stableclocks(int num_cycles, struct jtag_command *cmd)
3270 {
3271 int retval = 0;
3272
3273 /* 7 bits of either ones or zeros. */
3274 uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
3275
3276 while (num_cycles > 0) {
3277 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
3278 * at most 7 bits per invocation. Here we invoke it potentially
3279 * several times.
3280 */
3281 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
3282
3283 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE) {
3284 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
3285 retval = ERROR_JTAG_QUEUE_FAILED;
3286
3287 first_unsent = cmd;
3288 }
3289
3290 /* there are no state transitions in this code, so omit state tracking */
3291
3292 /* command "Clock Data to TMS/CS Pin (no Read)" */
3293 buffer_write(0x4b);
3294
3295 /* scan 7 bit */
3296 buffer_write(bitcount_per_command - 1);
3297
3298 /* TMS data bits are either all zeros or ones to stay in the current stable state */
3299 buffer_write(tms);
3300
3301 require_send = 1;
3302
3303 num_cycles -= bitcount_per_command;
3304 }
3305
3306 return retval;
3307 }
3308
3309 /* ---------------------------------------------------------------------
3310 * Support for IceBear JTAG adapter from Section5:
3311 * http://section5.ch/icebear
3312 *
3313 * Author: Sten, debian@sansys-electronic.com
3314 */
3315
3316 /* Icebear pin layout
3317 *
3318 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
3319 * GND GND | 4 3| n.c.
3320 * ADBUS3 TMS | 6 5| ADBUS6 VCC
3321 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
3322 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
3323 * ADBUS1 TDI |12 11| ACBUS1 (GND)
3324 * ADBUS2 TDO |14 13| GND GND
3325 *
3326 * ADBUS0 O L TCK ACBUS0 GND
3327 * ADBUS1 O L TDI ACBUS1 GND
3328 * ADBUS2 I TDO ACBUS2 n.c.
3329 * ADBUS3 O H TMS ACBUS3 n.c.
3330 * ADBUS4 O H nTRST
3331 * ADBUS5 O H nSRST
3332 * ADBUS6 - VCC
3333 * ADBUS7 - GND
3334 */
3335 static int icebear_jtag_init(void)
3336 {
3337 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
3338 low_output = 0x08; /* high: TMS; low: TCK TDI */
3339 nTRST = 0x10;
3340 nSRST = 0x20;
3341
3342 enum reset_types jtag_reset_config = jtag_get_reset_config();
3343 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3344 low_direction &= ~nTRST; /* nTRST high impedance */
3345 else {
3346 low_direction |= nTRST;
3347 low_output |= nTRST;
3348 }
3349
3350 low_direction |= nSRST;
3351 low_output |= nSRST;
3352
3353 /* initialize low byte for jtag */
3354 if (ft2232_set_data_bits_low_byte(low_output, low_direction) != ERROR_OK) {
3355 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3356 return ERROR_JTAG_INIT_FAILED;
3357 }
3358
3359 high_output = 0x0;
3360 high_direction = 0x00;
3361
3362 /* initialize high byte for jtag */
3363 if (ft2232_set_data_bits_high_byte(high_output, high_direction) != ERROR_OK) {
3364 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3365 return ERROR_JTAG_INIT_FAILED;
3366 }
3367
3368 return ERROR_OK;
3369 }
3370
3371 static void icebear_jtag_reset(int trst, int srst)
3372 {
3373 if (trst == 1) {
3374 low_direction |= nTRST;
3375 low_output &= ~nTRST;
3376 } else if (trst == 0) {
3377 enum reset_types jtag_reset_config = jtag_get_reset_config();
3378 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3379 low_direction &= ~nTRST;
3380 else
3381 low_output |= nTRST;
3382 }
3383
3384 if (srst == 1)
3385 low_output &= ~nSRST;
3386 else if (srst == 0)
3387 low_output |= nSRST;
3388
3389 /* command "set data bits low byte" */
3390 buffer_write(0x80);
3391 buffer_write(low_output);
3392 buffer_write(low_direction);
3393
3394 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x",
3395 trst,
3396 srst,
3397 low_output,
3398 low_direction);
3399 }
3400
3401 /* ---------------------------------------------------------------------
3402 * Support for Signalyzer H2 and Signalyzer H4
3403 * JTAG adapter from Xverve Technologies Inc.
3404 * http://www.signalyzer.com or http://www.xverve.com
3405 *
3406 * Author: Oleg Seiljus, oleg@signalyzer.com
3407 */
3408 static unsigned char signalyzer_h_side;
3409 static unsigned int signalyzer_h_adapter_type;
3410
3411 static int signalyzer_h_ctrl_write(int address, unsigned short value);
3412
3413 #if BUILD_FT2232_FTD2XX == 1
3414 static int signalyzer_h_ctrl_read(int address, unsigned short *value);
3415 #endif
3416
3417 #define SIGNALYZER_COMMAND_ADDR 128
3418 #define SIGNALYZER_DATA_BUFFER_ADDR 129
3419
3420 #define SIGNALYZER_COMMAND_VERSION 0x41
3421 #define SIGNALYZER_COMMAND_RESET 0x42
3422 #define SIGNALYZER_COMMAND_POWERCONTROL_GET 0x50
3423 #define SIGNALYZER_COMMAND_POWERCONTROL_SET 0x51
3424 #define SIGNALYZER_COMMAND_PWM_SET 0x52
3425 #define SIGNALYZER_COMMAND_LED_SET 0x53
3426 #define SIGNALYZER_COMMAND_ADC 0x54
3427 #define SIGNALYZER_COMMAND_GPIO_STATE 0x55
3428 #define SIGNALYZER_COMMAND_GPIO_MODE 0x56
3429 #define SIGNALYZER_COMMAND_GPIO_PORT 0x57
3430 #define SIGNALYZER_COMMAND_I2C 0x58
3431
3432 #define SIGNALYZER_CHAN_A 1
3433 #define SIGNALYZER_CHAN_B 2
3434 /* LEDS use channel C */
3435 #define SIGNALYZER_CHAN_C 4
3436
3437 #define SIGNALYZER_LED_GREEN 1
3438 #define SIGNALYZER_LED_RED 2
3439
3440 #define SIGNALYZER_MODULE_TYPE_EM_LT16_A 0x0301
3441 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG 0x0302
3442 #define SIGNALYZER_MODULE_TYPE_EM_JTAG 0x0303
3443 #define SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG_P 0x0304
3444 #define SIGNALYZER_MODULE_TYPE_EM_JTAG_P 0x0305
3445
3446
3447 static int signalyzer_h_ctrl_write(int address, unsigned short value)
3448 {
3449 #if BUILD_FT2232_FTD2XX == 1
3450 return FT_WriteEE(ftdih, address, value);
3451 #elif BUILD_FT2232_LIBFTDI == 1
3452 return 0;
3453 #endif
3454 }
3455
3456 #if BUILD_FT2232_FTD2XX == 1
3457 static int signalyzer_h_ctrl_read(int address, unsigned short *value)
3458 {
3459 return FT_ReadEE(ftdih, address, value);
3460 }
3461 #endif
3462
3463 static int signalyzer_h_led_set(unsigned char channel, unsigned char led,
3464 int on_time_ms, int off_time_ms, unsigned char cycles)
3465 {
3466 unsigned char on_time;
3467 unsigned char off_time;
3468
3469 if (on_time_ms < 0xFFFF)
3470 on_time = (unsigned char)(on_time_ms / 62);
3471 else
3472 on_time = 0xFF;
3473
3474 off_time = (unsigned char)(off_time_ms / 62);
3475
3476 #if BUILD_FT2232_FTD2XX == 1
3477 FT_STATUS status;
3478
3479 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3480 ((uint32_t)(channel << 8) | led));
3481 if (status != FT_OK) {
3482 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3483 ftd2xx_status_string(status));
3484 return ERROR_JTAG_DEVICE_ERROR;
3485 }
3486
3487 status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3488 ((uint32_t)(on_time << 8) | off_time));
3489 if (status != FT_OK) {
3490 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3491 ftd2xx_status_string(status));
3492 return ERROR_JTAG_DEVICE_ERROR;
3493 }
3494
3495 status = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3496 ((uint32_t)cycles));
3497 if (status != FT_OK) {
3498 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3499 ftd2xx_status_string(status));
3500 return ERROR_JTAG_DEVICE_ERROR;
3501 }
3502
3503 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3504 SIGNALYZER_COMMAND_LED_SET);
3505 if (status != FT_OK) {
3506 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3507 ftd2xx_status_string(status));
3508 return ERROR_JTAG_DEVICE_ERROR;
3509 }
3510
3511 return ERROR_OK;
3512 #elif BUILD_FT2232_LIBFTDI == 1
3513 int retval;
3514
3515 retval = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3516 ((uint32_t)(channel << 8) | led));
3517 if (retval < 0) {
3518 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3519 ftdi_get_error_string(&ftdic));
3520 return ERROR_JTAG_DEVICE_ERROR;
3521 }
3522
3523 retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 1),
3524 ((uint32_t)(on_time << 8) | off_time));
3525 if (retval < 0) {
3526 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3527 ftdi_get_error_string(&ftdic));
3528 return ERROR_JTAG_DEVICE_ERROR;
3529 }
3530
3531 retval = signalyzer_h_ctrl_write((SIGNALYZER_DATA_BUFFER_ADDR + 2),
3532 (uint32_t)cycles);
3533 if (retval < 0) {
3534 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3535 ftdi_get_error_string(&ftdic));
3536 return ERROR_JTAG_DEVICE_ERROR;
3537 }
3538
3539 retval = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3540 SIGNALYZER_COMMAND_LED_SET);
3541 if (retval < 0) {
3542 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3543 ftdi_get_error_string(&ftdic));
3544 return ERROR_JTAG_DEVICE_ERROR;
3545 }
3546
3547 return ERROR_OK;
3548 #endif
3549 }
3550
3551 static int signalyzer_h_init(void)
3552 {
3553 #if BUILD_FT2232_FTD2XX == 1
3554 FT_STATUS status;
3555 int i;
3556 #endif
3557
3558 char *end_of_desc;
3559
3560 uint16_t read_buf[12] = { 0 };
3561
3562 /* turn on center green led */
3563 signalyzer_h_led_set(SIGNALYZER_CHAN_C, SIGNALYZER_LED_GREEN,
3564 0xFFFF, 0x00, 0x00);
3565
3566 /* determine what channel config wants to open
3567 * TODO: change me... current implementation is made to work
3568 * with openocd description parsing.
3569 */
3570 end_of_desc = strrchr(ft2232_device_desc, 0x00);
3571
3572 if (end_of_desc) {
3573 signalyzer_h_side = *(end_of_desc - 1);
3574 if (signalyzer_h_side == 'B')
3575 signalyzer_h_side = SIGNALYZER_CHAN_B;
3576 else
3577 signalyzer_h_side = SIGNALYZER_CHAN_A;
3578 } else {
3579 LOG_ERROR("No Channel was specified");
3580 return ERROR_FAIL;
3581 }
3582
3583 signalyzer_h_led_set(signalyzer_h_side, SIGNALYZER_LED_GREEN,
3584 1000, 1000, 0xFF);
3585
3586 #if BUILD_FT2232_FTD2XX == 1
3587 /* read signalyzer versionining information */
3588 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3589 SIGNALYZER_COMMAND_VERSION);
3590 if (status != FT_OK) {
3591 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3592 ftd2xx_status_string(status));
3593 return ERROR_JTAG_DEVICE_ERROR;
3594 }
3595
3596 for (i = 0; i < 10; i++) {
3597 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i),
3598 &read_buf[i]);
3599 if (status != FT_OK) {
3600 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3601 ftd2xx_status_string(status));
3602 return ERROR_JTAG_DEVICE_ERROR;
3603 }
3604 }
3605
3606 LOG_INFO("Signalyzer: ID info: { %.4x %.4x %.4x %.4x %.4x %.4x %.4x }",
3607 read_buf[0], read_buf[1], read_buf[2], read_buf[3],
3608 read_buf[4], read_buf[5], read_buf[6]);
3609
3610 /* set gpio register */
3611 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3612 (uint32_t)(signalyzer_h_side << 8));
3613 if (status != FT_OK) {
3614 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3615 ftd2xx_status_string(status));
3616 return ERROR_JTAG_DEVICE_ERROR;
3617 }
3618
3619 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR + 1, 0x0404);
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_COMMAND_ADDR,
3627 SIGNALYZER_COMMAND_GPIO_STATE);
3628 if (status != FT_OK) {
3629 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3630 ftd2xx_status_string(status));
3631 return ERROR_JTAG_DEVICE_ERROR;
3632 }
3633
3634 /* read adapter type information */
3635 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3636 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3637 if (status != FT_OK) {
3638 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3639 ftd2xx_status_string(status));
3640 return ERROR_JTAG_DEVICE_ERROR;
3641 }
3642
3643 status = signalyzer_h_ctrl_write(
3644 (SIGNALYZER_DATA_BUFFER_ADDR + 1), 0xA000);
3645 if (status != FT_OK) {
3646 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3647 ftd2xx_status_string(status));
3648 return ERROR_JTAG_DEVICE_ERROR;
3649 }
3650
3651 status = signalyzer_h_ctrl_write(
3652 (SIGNALYZER_DATA_BUFFER_ADDR + 2), 0x0008);
3653 if (status != FT_OK) {
3654 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3655 ftd2xx_status_string(status));
3656 return ERROR_JTAG_DEVICE_ERROR;
3657 }
3658
3659 status = signalyzer_h_ctrl_write(SIGNALYZER_COMMAND_ADDR,
3660 SIGNALYZER_COMMAND_I2C);
3661 if (status != FT_OK) {
3662 LOG_ERROR("signalyzer_h_ctrl_write returned: %s",
3663 ftd2xx_status_string(status));
3664 return ERROR_JTAG_DEVICE_ERROR;
3665 }
3666
3667 usleep(100000);
3668
3669 status = signalyzer_h_ctrl_read(SIGNALYZER_COMMAND_ADDR, &read_buf[0]);
3670 if (status != FT_OK) {
3671 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3672 ftd2xx_status_string(status));
3673 return ERROR_JTAG_DEVICE_ERROR;
3674 }
3675
3676 if (read_buf[0] != 0x0498)
3677 signalyzer_h_adapter_type = 0x0000;
3678 else {
3679 for (i = 0; i < 4; i++) {
3680 status = signalyzer_h_ctrl_read((SIGNALYZER_DATA_BUFFER_ADDR + i), &read_buf[i]);
3681 if (status != FT_OK) {
3682 LOG_ERROR("signalyzer_h_ctrl_read returned: %s",
3683 ftd2xx_status_string(status));
3684 return ERROR_JTAG_DEVICE_ERROR;
3685 }
3686 }
3687
3688 signalyzer_h_adapter_type = read_buf[0];
3689 }
3690
3691 #elif BUILD_FT2232_LIBFTDI == 1
3692 /* currently libftdi does not allow reading individual eeprom
3693 * locations, therefore adapter type cannot be detected.
3694 * override with most common type
3695 */
3696 signalyzer_h_adapter_type = SIGNALYZER_MODULE_TYPE_EM_ARM_JTAG;
3697 #endif
3698
3699 enum reset_types jtag_reset_config = jtag_get_reset_config();
3700
3701 /* ADAPTOR: EM_LT16_A */
3702 if (signalyzer_h_adapter_type == SIGNALYZER_MODULE_TYPE_EM_LT16_A) {
3703 LOG_INFO("Signalyzer: EM-LT (16-channel level translator) "
3704 "detected. (HW: %2x).", (read_buf[1] >> 8));
3705
3706 nTRST = 0x10;
3707 nTRSTnOE = 0x10;
3708 nSRST = 0x20;
3709 nSRSTnOE = 0x20;
3710
3711 low_output = 0x08;
3712 low_direction = 0x1b;
3713
3714 high_output = 0x0;
3715 high_direction = 0x0;
3716
3717 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) {
3718 low_direction &= ~nTRSTnOE; /* nTRST input */
3719 low_output &= ~nTRST; /* nTRST = 0 */
3720 } else {
3721 low_direction |= nTRSTnOE; /* nTRST output */
3722 low_output |= nTRST; /* nTRST = 1 */
3723 }
3724
3725 if (jtag_reset_config & RESET_SRST_PUSH_PULL) {
3726 low_direction |= nSRSTnOE; /* nSRST output */
3727 low_output |= nSRST; /* nSRST = 1 */
3728 } else {
3729 low_direction &= ~nSRSTnOE; /* nSRST input */
3730 low_output &= ~nSRST; /* nSRST = 0 */
3731 }
3732
3733 #if BUILD_FT2232_FTD2XX == 1
3734 /* enable power to the module */
3735 status = signalyzer_h_ctrl_write(SIGNALYZER_DATA_BUFFER_ADDR,
3736 ((uint32_t)(signalyzer_h_side << 8) | 0x01));
3737 if (status