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