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