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