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