Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
if srst pulls trst, then set state to TAP_RESET.
[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 #ifndef BUILD_FT2232_HIGHSPEED
75 #if BUILD_FT2232_FTD2XX == 1
76 enum { FT_DEVICE_2232H = 6, FT_DEVICE_4232H };
77 #elif BUILD_FT2232_LIBFTDI == 1
78 enum { TYPE_2232H = 4, TYPE_4232H = 5 };
79 #endif
80 #endif
81
82 static int ft2232_execute_queue(void);
83 static int ft2232_speed(int speed);
84 static int ft2232_speed_div(int speed, int* khz);
85 static int ft2232_khz(int khz, int* jtag_speed);
86 static int ft2232_register_commands(struct command_context_s* cmd_ctx);
87 static int ft2232_init(void);
88 static int ft2232_quit(void);
89
90 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
91 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
92 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
93 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
94 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc);
95
96 /**
97 * Send out \a num_cycles on the TCK line while the TAP(s) are in a
98 * stable state. Calling code must ensure that current state is stable,
99 * that verification is not done in here.
100 *
101 * @param num_cycles The number of clocks cycles to send.
102 * @param cmd The command to send.
103 *
104 * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure.
105 */
106 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd);
107
108 static char * ft2232_device_desc_A = NULL;
109 static char* ft2232_device_desc = NULL;
110 static char* ft2232_serial = NULL;
111 static char* ft2232_layout = NULL;
112 static uint8_t ft2232_latency = 2;
113 static unsigned ft2232_max_tck = FTDI_2232C_MAX_TCK;
114
115 #define MAX_USB_IDS 8
116 /* vid = pid = 0 marks the end of the list */
117 static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
118 static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 };
119
120 typedef struct ft2232_layout_s
121 {
122 char* name;
123 int (*init)(void);
124 void (*reset)(int trst, int srst);
125 void (*blink)(void);
126 } ft2232_layout_t;
127
128 /* init procedures for supported layouts */
129 static int usbjtag_init(void);
130 static int jtagkey_init(void);
131 static int olimex_jtag_init(void);
132 static int flyswatter_init(void);
133 static int turtle_init(void);
134 static int comstick_init(void);
135 static int stm32stick_init(void);
136 static int axm0432_jtag_init(void);
137 static int sheevaplug_init(void);
138 static int icebear_jtag_init(void);
139 static int cortino_jtag_init(void);
140
141 /* reset procedures for supported layouts */
142 static void usbjtag_reset(int trst, int srst);
143 static void jtagkey_reset(int trst, int srst);
144 static void olimex_jtag_reset(int trst, int srst);
145 static void flyswatter_reset(int trst, int srst);
146 static void turtle_reset(int trst, int srst);
147 static void comstick_reset(int trst, int srst);
148 static void stm32stick_reset(int trst, int srst);
149 static void axm0432_jtag_reset(int trst, int srst);
150 static void sheevaplug_reset(int trst, int srst);
151 static void icebear_jtag_reset(int trst, int srst);
152
153 /* blink procedures for layouts that support a blinking led */
154 static void olimex_jtag_blink(void);
155 static void flyswatter_jtag_blink(void);
156 static void turtle_jtag_blink(void);
157
158 static const ft2232_layout_t ft2232_layouts[] =
159 {
160 { "usbjtag", usbjtag_init, usbjtag_reset, NULL },
161 { "jtagkey", jtagkey_init, jtagkey_reset, NULL },
162 { "jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL },
163 { "oocdlink", jtagkey_init, jtagkey_reset, NULL },
164 { "signalyzer", usbjtag_init, usbjtag_reset, NULL },
165 { "evb_lm3s811", usbjtag_init, usbjtag_reset, NULL },
166 { "luminary_icdi", usbjtag_init, usbjtag_reset, NULL },
167 { "olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink },
168 { "flyswatter", flyswatter_init, flyswatter_reset, flyswatter_jtag_blink },
169 { "turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink },
170 { "comstick", comstick_init, comstick_reset, NULL },
171 { "stm32stick", stm32stick_init, stm32stick_reset, NULL },
172 { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL },
173 { "sheevaplug", sheevaplug_init, sheevaplug_reset, NULL },
174 { "icebear", icebear_jtag_init, icebear_jtag_reset, NULL },
175 { "cortino", cortino_jtag_init, comstick_reset, NULL },
176 { NULL, NULL, NULL, NULL },
177 };
178
179 static uint8_t nTRST, nTRSTnOE, nSRST, nSRSTnOE;
180
181 static const ft2232_layout_t *layout;
182 static uint8_t low_output = 0x0;
183 static uint8_t low_direction = 0x0;
184 static uint8_t high_output = 0x0;
185 static uint8_t high_direction = 0x0;
186
187 #if BUILD_FT2232_FTD2XX == 1
188 static FT_HANDLE ftdih = NULL;
189 static FT_DEVICE ftdi_device = 0;
190 #elif BUILD_FT2232_LIBFTDI == 1
191 static struct ftdi_context ftdic;
192 static enum ftdi_chip_type ftdi_device;
193 #endif
194
195 static jtag_command_t* first_unsent; /* next command that has to be sent */
196 static int require_send;
197
198 /* http://urjtag.wiki.sourceforge.net/Cable + FT2232 says:
199
200 "There is a significant difference between libftdi and libftd2xx. The latter
201 one allows to schedule up to 64*64 bytes of result data while libftdi fails
202 with more than 4*64. As a consequence, the FT2232 driver is forced to
203 perform around 16x more USB transactions for long command streams with TDO
204 capture when running with libftdi."
205
206 No idea how we get
207 #define FT2232_BUFFER_SIZE 131072
208 a comment would have been nice.
209 */
210
211 #define FT2232_BUFFER_SIZE 131072
212
213 static uint8_t* ft2232_buffer = NULL;
214 static int ft2232_buffer_size = 0;
215 static int ft2232_read_pointer = 0;
216 static int ft2232_expect_read = 0;
217
218 /**
219 * Function buffer_write
220 * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later.
221 * @param val is the byte to send.
222 */
223 static inline void buffer_write(uint8_t val)
224 {
225 assert(ft2232_buffer);
226 assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE);
227 ft2232_buffer[ft2232_buffer_size++] = val;
228 }
229
230 /**
231 * Function buffer_read
232 * returns a byte from the byte buffer.
233 */
234 static inline uint8_t buffer_read(void)
235 {
236 assert(ft2232_buffer);
237 assert(ft2232_read_pointer < ft2232_buffer_size);
238 return ft2232_buffer[ft2232_read_pointer++];
239 }
240
241 /**
242 * Clocks out \a bit_count bits on the TMS line, starting with the least
243 * significant bit of tms_bits and progressing to more significant bits.
244 * Rigorous state transition logging is done here via tap_set_state().
245 *
246 * @param mpsse_cmd One of the MPSSE TMS oriented commands such as
247 * 0x4b or 0x6b. See the MPSSE spec referenced above for their
248 * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)"
249 * is often used for this, 0x4b.
250 *
251 * @param tms_bits Holds the sequence of bits to send.
252 * @param tms_count Tells how many bits in the sequence.
253 * @param tdi_bit A single bit to pass on to TDI before the first TCK
254 * cycle and held static for the duration of TMS clocking.
255 *
256 * See the MPSSE spec referenced above.
257 */
258 static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
259 {
260 uint8_t tms_byte;
261 int i;
262 int tms_ndx; /* bit index into tms_byte */
263
264 assert(tms_count > 0);
265
266 #if 0
267 LOG_DEBUG("mpsse cmd=%02x, tms_bits = 0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count);
268 #endif
269
270 for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1)
271 {
272 bool bit = tms_bits & 1;
273
274 if (bit)
275 tms_byte |= (1 << tms_ndx);
276
277 /* always do state transitions in public view */
278 tap_set_state(tap_state_transition(tap_get_state(), bit));
279
280 /* we wrote a bit to tms_byte just above, increment bit index. if bit was zero
281 also increment.
282 */
283 ++tms_ndx;
284
285 if (tms_ndx == 7 || i == tms_count-1)
286 {
287 buffer_write(mpsse_cmd);
288 buffer_write(tms_ndx - 1);
289
290 /* Bit 7 of the byte is passed on to TDI/DO before the first TCK/SK of
291 TMS/CS and is held static for the duration of TMS/CS clocking.
292 */
293 buffer_write(tms_byte | (tdi_bit << 7));
294 }
295 }
296 }
297
298 /**
299 * Function get_tms_buffer_requirements
300 * returns what clock_tms() will consume if called with
301 * same \a bit_count.
302 */
303 static inline int get_tms_buffer_requirements(int bit_count)
304 {
305 return ((bit_count + 6)/7) * 3;
306 }
307
308 /**
309 * Function move_to_state
310 * moves the TAP controller from the current state to a
311 * \a goal_state through a path given by tap_get_tms_path(). State transition
312 * logging is performed by delegation to clock_tms().
313 *
314 * @param goal_state is the destination state for the move.
315 */
316 static void move_to_state(tap_state_t goal_state)
317 {
318 tap_state_t start_state = tap_get_state();
319
320 /* goal_state is 1/2 of a tuple/pair of states which allow convenient
321 lookup of the required TMS pattern to move to this state from the
322 start state.
323 */
324
325 /* do the 2 lookups */
326 int tms_bits = tap_get_tms_path(start_state, goal_state);
327 int tms_count = tap_get_tms_path_len(start_state, goal_state);
328
329 DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
330
331 clock_tms(0x4b, tms_bits, tms_count, 0);
332 }
333
334 jtag_interface_t ft2232_interface =
335 {
336 .name = "ft2232",
337 .execute_queue = ft2232_execute_queue,
338 .speed = ft2232_speed,
339 .speed_div = ft2232_speed_div,
340 .khz = ft2232_khz,
341 .register_commands = ft2232_register_commands,
342 .init = ft2232_init,
343 .quit = ft2232_quit,
344 };
345
346 static int ft2232_write(uint8_t* buf, int size, uint32_t* bytes_written)
347 {
348 #if BUILD_FT2232_FTD2XX == 1
349 FT_STATUS status;
350 DWORD dw_bytes_written;
351 if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
352 {
353 *bytes_written = dw_bytes_written;
354 LOG_ERROR("FT_Write returned: %lu", status);
355 return ERROR_JTAG_DEVICE_ERROR;
356 }
357 else
358 {
359 *bytes_written = dw_bytes_written;
360 return ERROR_OK;
361 }
362 #elif BUILD_FT2232_LIBFTDI == 1
363 int retval;
364 if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
365 {
366 *bytes_written = 0;
367 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
368 return ERROR_JTAG_DEVICE_ERROR;
369 }
370 else
371 {
372 *bytes_written = retval;
373 return ERROR_OK;
374 }
375 #endif
376 }
377
378 static int ft2232_read(uint8_t* buf, uint32_t size, uint32_t* bytes_read)
379 {
380 #if BUILD_FT2232_FTD2XX == 1
381 DWORD dw_bytes_read;
382 FT_STATUS status;
383 int timeout = 5;
384 *bytes_read = 0;
385
386 while ((*bytes_read < size) && timeout--)
387 {
388 if ((status = FT_Read(ftdih, buf + *bytes_read, size -
389 *bytes_read, &dw_bytes_read)) != FT_OK)
390 {
391 *bytes_read = 0;
392 LOG_ERROR("FT_Read returned: %lu", status);
393 return ERROR_JTAG_DEVICE_ERROR;
394 }
395 *bytes_read += dw_bytes_read;
396 }
397
398 #elif BUILD_FT2232_LIBFTDI == 1
399 int retval;
400 int timeout = 100;
401 *bytes_read = 0;
402
403 while ((*bytes_read < size) && timeout--)
404 {
405 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
406 {
407 *bytes_read = 0;
408 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
409 return ERROR_JTAG_DEVICE_ERROR;
410 }
411 *bytes_read += retval;
412 }
413
414 #endif
415
416 if (*bytes_read < size)
417 {
418 LOG_ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)",
419 (unsigned int)(*bytes_read),
420 (unsigned int)size);
421 return ERROR_JTAG_DEVICE_ERROR;
422 }
423
424 return ERROR_OK;
425 }
426
427 static bool ft2232_device_is_highspeed(void)
428 {
429 #if BUILD_FT2232_FTD2XX == 1
430 return (ftdi_device == FT_DEVICE_2232H) || (ftdi_device == FT_DEVICE_4232H);
431 #elif BUILD_FT2232_LIBFTDI == 1
432 return (ftdi_device == TYPE_2232H || ftdi_device == TYPE_4232H);
433 #endif
434 }
435
436 /*
437 * Commands that only apply to the FT2232H and FT4232H devices.
438 * See chapter 6 in http://www.ftdichip.com/Documents/AppNotes/
439 * AN_108_Command_Processor_for_MPSSE_and_MCU_Host_Bus_Emulation_Modes.pdf
440 */
441
442 static int ft2232h_ft4232h_adaptive_clocking(bool enable)
443 {
444 uint8_t buf = enable ? 0x96 : 0x97;
445 LOG_DEBUG("%2.2x", buf);
446
447 uint32_t bytes_written;
448 int retval = ft2232_write(&buf, 1, &bytes_written);
449 if ((ERROR_OK != retval) || (bytes_written != 1))
450 {
451 LOG_ERROR("couldn't write command to %s adaptive clocking"
452 , enable ? "enable" : "disable");
453 return retval;
454 }
455
456 return ERROR_OK;
457 }
458
459 /**
460 * Enable/disable the clk divide by 5 of the 60MHz master clock.
461 * This result in a JTAG clock speed range of 91.553Hz-6MHz
462 * respective 457.763Hz-30MHz.
463 */
464 static int ft2232h_ft4232h_clk_divide_by_5(bool enable)
465 {
466 uint32_t bytes_written;
467 uint8_t buf = enable ? 0x8b : 0x8a;
468 int retval = ft2232_write(&buf, 1, &bytes_written);
469 if ((ERROR_OK != retval) || (bytes_written != 1))
470 {
471 LOG_ERROR("couldn't write command to %s clk divide by 5"
472 , enable ? "enable" : "disable");
473 return ERROR_JTAG_INIT_FAILED;
474 }
475 ft2232_max_tck = enable ? FTDI_2232C_MAX_TCK : FTDI_2232H_4232H_MAX_TCK;
476 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
477
478 return ERROR_OK;
479 }
480
481 static int ft2232_speed(int speed)
482 {
483 uint8_t buf[3];
484 int retval;
485 uint32_t bytes_written;
486
487 retval = ERROR_OK;
488 bool enable_adaptive_clocking = (RTCK_SPEED == speed);
489 if (ft2232_device_is_highspeed())
490 retval = ft2232h_ft4232h_adaptive_clocking(enable_adaptive_clocking);
491 else if (enable_adaptive_clocking)
492 {
493 LOG_ERROR("ft2232 device %lu does not support RTCK"
494 , (long unsigned int)ftdi_device);
495 return ERROR_FAIL;
496 }
497
498 if ((enable_adaptive_clocking) || (ERROR_OK != retval))
499 return retval;
500
501 buf[0] = 0x86; /* command "set divisor" */
502 buf[1] = speed & 0xff; /* valueL (0 = 6MHz, 1 = 3MHz, 2 = 2.0MHz, ...*/
503 buf[2] = (speed >> 8) & 0xff; /* valueH */
504
505 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
506 if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
507 {
508 LOG_ERROR("couldn't set FT2232 TCK speed");
509 return retval;
510 }
511
512 return ERROR_OK;
513 }
514
515 static int ft2232_speed_div(int speed, int* khz)
516 {
517 /* Take a look in the FT2232 manual,
518 * AN2232C-01 Command Processor for
519 * MPSSE and MCU Host Bus. Chapter 3.8 */
520
521 *khz = (RTCK_SPEED == speed) ? 0 : ft2232_max_tck / (1 + speed);
522
523 return ERROR_OK;
524 }
525
526 static int ft2232_khz(int khz, int* jtag_speed)
527 {
528 if (khz == 0)
529 {
530 if (ft2232_device_is_highspeed())
531 {
532 *jtag_speed = RTCK_SPEED;
533 return ERROR_OK;
534 }
535 else
536 {
537 LOG_DEBUG("RCLK not supported");
538 return ERROR_FAIL;
539 }
540 }
541
542 /* Take a look in the FT2232 manual,
543 * AN2232C-01 Command Processor for
544 * MPSSE and MCU Host Bus. Chapter 3.8
545 *
546 * We will calc here with a multiplier
547 * of 10 for better rounding later. */
548
549 /* Calc speed, (ft2232_max_tck / khz) - 1 */
550 /* Use 65000 for better rounding */
551 *jtag_speed = ((ft2232_max_tck*10) / khz) - 10;
552
553 /* Add 0.9 for rounding */
554 *jtag_speed += 9;
555
556 /* Calc real speed */
557 *jtag_speed = *jtag_speed / 10;
558
559 /* Check if speed is greater than 0 */
560 if (*jtag_speed < 0)
561 {
562 *jtag_speed = 0;
563 }
564
565 /* Check max value */
566 if (*jtag_speed > 0xFFFF)
567 {
568 *jtag_speed = 0xFFFF;
569 }
570
571 return ERROR_OK;
572 }
573
574 static int ft2232_register_commands(struct command_context_s* cmd_ctx)
575 {
576 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
577 COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device");
578 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
579 COMMAND_CONFIG, "the serial number of the FTDI FT2232 device");
580 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
581 COMMAND_CONFIG, "the layout of the FT2232 GPIO signals used to control output-enables and reset signals");
582 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
583 COMMAND_CONFIG, "the vendor ID and product ID of the FTDI FT2232 device");
584 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
585 COMMAND_CONFIG, "set the FT2232 latency timer to a new value");
586 return ERROR_OK;
587 }
588
589 static void ft2232_end_state(tap_state_t state)
590 {
591 if (tap_is_state_stable(state))
592 tap_set_end_state(state);
593 else
594 {
595 LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
596 exit(-1);
597 }
598 }
599
600 static void ft2232_read_scan(enum scan_type type, uint8_t* buffer, int scan_size)
601 {
602 int num_bytes = (scan_size + 7) / 8;
603 int bits_left = scan_size;
604 int cur_byte = 0;
605
606 while (num_bytes-- > 1)
607 {
608 buffer[cur_byte++] = buffer_read();
609 bits_left -= 8;
610 }
611
612 buffer[cur_byte] = 0x0;
613
614 /* There is one more partial byte left from the clock data in/out instructions */
615 if (bits_left > 1)
616 {
617 buffer[cur_byte] = buffer_read() >> 1;
618 }
619 /* 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 */
620 buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left);
621 }
622
623 static void ft2232_debug_dump_buffer(void)
624 {
625 int i;
626 char line[256];
627 char* line_p = line;
628
629 for (i = 0; i < ft2232_buffer_size; i++)
630 {
631 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
632 if (i % 16 == 15)
633 {
634 LOG_DEBUG("%s", line);
635 line_p = line;
636 }
637 }
638
639 if (line_p != line)
640 LOG_DEBUG("%s", line);
641 }
642
643 static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last)
644 {
645 jtag_command_t* cmd;
646 uint8_t* buffer;
647 int scan_size;
648 enum scan_type type;
649 int retval;
650 uint32_t bytes_written = 0;
651 uint32_t bytes_read = 0;
652
653 #ifdef _DEBUG_USB_IO_
654 struct timeval start, inter, inter2, end;
655 struct timeval d_inter, d_inter2, d_end;
656 #endif
657
658 #ifdef _DEBUG_USB_COMMS_
659 LOG_DEBUG("write buffer (size %i):", ft2232_buffer_size);
660 ft2232_debug_dump_buffer();
661 #endif
662
663 #ifdef _DEBUG_USB_IO_
664 gettimeofday(&start, NULL);
665 #endif
666
667 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
668 {
669 LOG_ERROR("couldn't write MPSSE commands to FT2232");
670 return retval;
671 }
672
673 #ifdef _DEBUG_USB_IO_
674 gettimeofday(&inter, NULL);
675 #endif
676
677 if (ft2232_expect_read)
678 {
679 int timeout = 100;
680 ft2232_buffer_size = 0;
681
682 #ifdef _DEBUG_USB_IO_
683 gettimeofday(&inter2, NULL);
684 #endif
685
686 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
687 {
688 LOG_ERROR("couldn't read from FT2232");
689 return retval;
690 }
691
692 #ifdef _DEBUG_USB_IO_
693 gettimeofday(&end, NULL);
694
695 timeval_subtract(&d_inter, &inter, &start);
696 timeval_subtract(&d_inter2, &inter2, &start);
697 timeval_subtract(&d_end, &end, &start);
698
699 LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u",
700 (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec,
701 (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec,
702 (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec);
703 #endif
704
705 ft2232_buffer_size = bytes_read;
706
707 if (ft2232_expect_read != ft2232_buffer_size)
708 {
709 LOG_ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read,
710 ft2232_buffer_size,
711 100 - timeout);
712 ft2232_debug_dump_buffer();
713
714 exit(-1);
715 }
716
717 #ifdef _DEBUG_USB_COMMS_
718 LOG_DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
719 ft2232_debug_dump_buffer();
720 #endif
721 }
722
723 ft2232_expect_read = 0;
724 ft2232_read_pointer = 0;
725
726 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
727 * that wasn't handled by a caller-provided error handler
728 */
729 retval = ERROR_OK;
730
731 cmd = first;
732 while (cmd != last)
733 {
734 switch (cmd->type)
735 {
736 case JTAG_SCAN:
737 type = jtag_scan_type(cmd->cmd.scan);
738 if (type != SCAN_OUT)
739 {
740 scan_size = jtag_scan_size(cmd->cmd.scan);
741 buffer = calloc(CEIL(scan_size, 8), 1);
742 ft2232_read_scan(type, buffer, scan_size);
743 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
744 retval = ERROR_JTAG_QUEUE_FAILED;
745 free(buffer);
746 }
747 break;
748
749 default:
750 break;
751 }
752
753 cmd = cmd->next;
754 }
755
756 ft2232_buffer_size = 0;
757
758 return retval;
759 }
760
761 /**
762 * Function ft2232_add_pathmove
763 * moves the TAP controller from the current state to a new state through the
764 * given path, where path is an array of tap_state_t's.
765 *
766 * @param path is an array of tap_stat_t which gives the states to traverse through
767 * ending with the last state at path[num_states-1]
768 * @param num_states is the count of state steps to move through
769 */
770 static void ft2232_add_pathmove(tap_state_t* path, int num_states)
771 {
772 int state_count = 0;
773
774 assert((unsigned) num_states <= 32u); /* tms_bits only holds 32 bits */
775
776 /* this loop verifies that the path is legal and logs each state in the path */
777 while (num_states)
778 {
779 unsigned char tms_byte = 0; /* zero this on each MPSSE batch */
780 int bit_count = 0;
781 int num_states_batch = num_states > 7 ? 7 : num_states;
782
783 /* command "Clock Data to TMS/CS Pin (no Read)" */
784 buffer_write(0x4b);
785
786 /* number of states remaining */
787 buffer_write(num_states_batch - 1);
788
789 while (num_states_batch--) {
790 /* either TMS=0 or TMS=1 must work ... */
791 if (tap_state_transition(tap_get_state(), false)
792 == path[state_count])
793 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
794 else if (tap_state_transition(tap_get_state(), true)
795 == path[state_count])
796 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
797
798 /* ... or else the caller goofed BADLY */
799 else {
800 LOG_ERROR("BUG: %s -> %s isn't a valid "
801 "TAP state transition",
802 tap_state_name(tap_get_state()),
803 tap_state_name(path[state_count]));
804 exit(-1);
805 }
806
807 tap_set_state(path[state_count]);
808 state_count++;
809 num_states--;
810 }
811
812 buffer_write(tms_byte);
813 }
814 tap_set_end_state(tap_get_state());
815 }
816
817 static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t* buffer, int scan_size)
818 {
819 int num_bytes = (scan_size + 7) / 8;
820 int bits_left = scan_size;
821 int cur_byte = 0;
822 int last_bit;
823
824 if (!ir_scan)
825 {
826 if (tap_get_state() != TAP_DRSHIFT)
827 {
828 move_to_state(TAP_DRSHIFT);
829 }
830 }
831 else
832 {
833 if (tap_get_state() != TAP_IRSHIFT)
834 {
835 move_to_state(TAP_IRSHIFT);
836 }
837 }
838
839 /* add command for complete bytes */
840 while (num_bytes > 1)
841 {
842 int thisrun_bytes;
843 if (type == SCAN_IO)
844 {
845 /* Clock Data Bytes In and Out LSB First */
846 buffer_write(0x39);
847 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
848 }
849 else if (type == SCAN_OUT)
850 {
851 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
852 buffer_write(0x19);
853 /* LOG_DEBUG("added TDI bytes (o)"); */
854 }
855 else if (type == SCAN_IN)
856 {
857 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
858 buffer_write(0x28);
859 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
860 }
861
862 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
863 num_bytes -= thisrun_bytes;
864
865 buffer_write((uint8_t) (thisrun_bytes - 1));
866 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
867
868 if (type != SCAN_IN)
869 {
870 /* add complete bytes */
871 while (thisrun_bytes-- > 0)
872 {
873 buffer_write(buffer[cur_byte++]);
874 bits_left -= 8;
875 }
876 }
877 else /* (type == SCAN_IN) */
878 {
879 bits_left -= 8 * (thisrun_bytes);
880 }
881 }
882
883 /* the most signifcant bit is scanned during TAP movement */
884 if (type != SCAN_IN)
885 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
886 else
887 last_bit = 0;
888
889 /* process remaining bits but the last one */
890 if (bits_left > 1)
891 {
892 if (type == SCAN_IO)
893 {
894 /* Clock Data Bits In and Out LSB First */
895 buffer_write(0x3b);
896 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
897 }
898 else if (type == SCAN_OUT)
899 {
900 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
901 buffer_write(0x1b);
902 /* LOG_DEBUG("added TDI bits (o)"); */
903 }
904 else if (type == SCAN_IN)
905 {
906 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
907 buffer_write(0x2a);
908 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
909 }
910
911 buffer_write(bits_left - 2);
912 if (type != SCAN_IN)
913 buffer_write(buffer[cur_byte]);
914 }
915
916 if ((ir_scan && (tap_get_end_state() == TAP_IRSHIFT))
917 || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT)))
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 buffer_write(0x0);
938 buffer_write(last_bit);
939 }
940 else
941 {
942 int tms_bits;
943 int tms_count;
944 uint8_t mpsse_cmd;
945
946 /* move from Shift-IR/DR to end state */
947 if (type != SCAN_OUT)
948 {
949 /* We always go to the PAUSE state in two step at the end of an IN or IO scan */
950 /* This must be coordinated with the bit shifts in ft2232_read_scan */
951 tms_bits = 0x01;
952 tms_count = 2;
953 /* Clock Data to TMS/CS Pin with Read */
954 mpsse_cmd = 0x6b;
955 /* LOG_DEBUG("added TMS scan (read)"); */
956 }
957 else
958 {
959 tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
960 tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
961 /* Clock Data to TMS/CS Pin (no Read) */
962 mpsse_cmd = 0x4b;
963 /* LOG_DEBUG("added TMS scan (no read)"); */
964 }
965
966 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
967 }
968
969 if (tap_get_state() != tap_get_end_state())
970 {
971 move_to_state(tap_get_end_state());
972 }
973 }
974
975 static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, uint8_t* buffer, int scan_size)
976 {
977 int num_bytes = (scan_size + 7) / 8;
978 int bits_left = scan_size;
979 int cur_byte = 0;
980 int last_bit;
981 uint8_t* receive_buffer = malloc(CEIL(scan_size, 8));
982 uint8_t* receive_pointer = receive_buffer;
983 uint32_t bytes_written;
984 uint32_t bytes_read;
985 int retval;
986 int thisrun_read = 0;
987
988 if (cmd->ir_scan)
989 {
990 LOG_ERROR("BUG: large IR scans are not supported");
991 exit(-1);
992 }
993
994 if (tap_get_state() != TAP_DRSHIFT)
995 {
996 move_to_state(TAP_DRSHIFT);
997 }
998
999 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1000 {
1001 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1002 exit(-1);
1003 }
1004 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1005 ft2232_buffer_size, (int)bytes_written);
1006 ft2232_buffer_size = 0;
1007
1008 /* add command for complete bytes */
1009 while (num_bytes > 1)
1010 {
1011 int thisrun_bytes;
1012
1013 if (type == SCAN_IO)
1014 {
1015 /* Clock Data Bytes In and Out LSB First */
1016 buffer_write(0x39);
1017 /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */
1018 }
1019 else if (type == SCAN_OUT)
1020 {
1021 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
1022 buffer_write(0x19);
1023 /* LOG_DEBUG("added TDI bytes (o)"); */
1024 }
1025 else if (type == SCAN_IN)
1026 {
1027 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
1028 buffer_write(0x28);
1029 /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */
1030 }
1031
1032 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
1033 thisrun_read = thisrun_bytes;
1034 num_bytes -= thisrun_bytes;
1035 buffer_write((uint8_t) (thisrun_bytes - 1));
1036 buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8));
1037
1038 if (type != SCAN_IN)
1039 {
1040 /* add complete bytes */
1041 while (thisrun_bytes-- > 0)
1042 {
1043 buffer_write(buffer[cur_byte]);
1044 cur_byte++;
1045 bits_left -= 8;
1046 }
1047 }
1048 else /* (type == SCAN_IN) */
1049 {
1050 bits_left -= 8 * (thisrun_bytes);
1051 }
1052
1053 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1054 {
1055 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1056 exit(-1);
1057 }
1058 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1059 ft2232_buffer_size,
1060 (int)bytes_written);
1061 ft2232_buffer_size = 0;
1062
1063 if (type != SCAN_OUT)
1064 {
1065 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1066 {
1067 LOG_ERROR("couldn't read from FT2232");
1068 exit(-1);
1069 }
1070 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1071 thisrun_read,
1072 (int)bytes_read);
1073 receive_pointer += bytes_read;
1074 }
1075 }
1076
1077 thisrun_read = 0;
1078
1079 /* the most signifcant bit is scanned during TAP movement */
1080 if (type != SCAN_IN)
1081 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
1082 else
1083 last_bit = 0;
1084
1085 /* process remaining bits but the last one */
1086 if (bits_left > 1)
1087 {
1088 if (type == SCAN_IO)
1089 {
1090 /* Clock Data Bits In and Out LSB First */
1091 buffer_write(0x3b);
1092 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1093 }
1094 else if (type == SCAN_OUT)
1095 {
1096 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1097 buffer_write(0x1b);
1098 /* LOG_DEBUG("added TDI bits (o)"); */
1099 }
1100 else if (type == SCAN_IN)
1101 {
1102 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1103 buffer_write(0x2a);
1104 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1105 }
1106 buffer_write(bits_left - 2);
1107 if (type != SCAN_IN)
1108 buffer_write(buffer[cur_byte]);
1109
1110 if (type != SCAN_OUT)
1111 thisrun_read += 2;
1112 }
1113
1114 if (tap_get_end_state() == TAP_DRSHIFT)
1115 {
1116 if (type == SCAN_IO)
1117 {
1118 /* Clock Data Bits In and Out LSB First */
1119 buffer_write(0x3b);
1120 /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */
1121 }
1122 else if (type == SCAN_OUT)
1123 {
1124 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
1125 buffer_write(0x1b);
1126 /* LOG_DEBUG("added TDI bits (o)"); */
1127 }
1128 else if (type == SCAN_IN)
1129 {
1130 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
1131 buffer_write(0x2a);
1132 /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */
1133 }
1134 buffer_write(0x0);
1135 buffer_write(last_bit);
1136 }
1137 else
1138 {
1139 int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1140 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1141 uint8_t mpsse_cmd;
1142
1143 /* move from Shift-IR/DR to end state */
1144 if (type != SCAN_OUT)
1145 {
1146 /* Clock Data to TMS/CS Pin with Read */
1147 mpsse_cmd = 0x6b;
1148 /* LOG_DEBUG("added TMS scan (read)"); */
1149 }
1150 else
1151 {
1152 /* Clock Data to TMS/CS Pin (no Read) */
1153 mpsse_cmd = 0x4b;
1154 /* LOG_DEBUG("added TMS scan (no read)"); */
1155 }
1156
1157 clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit);
1158 }
1159
1160 if (type != SCAN_OUT)
1161 thisrun_read += 1;
1162
1163 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
1164 {
1165 LOG_ERROR("couldn't write MPSSE commands to FT2232");
1166 exit(-1);
1167 }
1168 LOG_DEBUG("ft2232_buffer_size: %i, bytes_written: %i",
1169 ft2232_buffer_size,
1170 (int)bytes_written);
1171 ft2232_buffer_size = 0;
1172
1173 if (type != SCAN_OUT)
1174 {
1175 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
1176 {
1177 LOG_ERROR("couldn't read from FT2232");
1178 exit(-1);
1179 }
1180 LOG_DEBUG("thisrun_read: %i, bytes_read: %i",
1181 thisrun_read,
1182 (int)bytes_read);
1183 receive_pointer += bytes_read;
1184 }
1185
1186 return ERROR_OK;
1187 }
1188
1189 static int ft2232_predict_scan_out(int scan_size, enum scan_type type)
1190 {
1191 int predicted_size = 3;
1192 int num_bytes = (scan_size - 1) / 8;
1193
1194 if (tap_get_state() != TAP_DRSHIFT)
1195 predicted_size += get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT));
1196
1197 if (type == SCAN_IN) /* only from device to host */
1198 {
1199 /* complete bytes */
1200 predicted_size += CEIL(num_bytes, 65536) * 3;
1201
1202 /* remaining bits - 1 (up to 7) */
1203 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
1204 }
1205 else /* host to device, or bidirectional */
1206 {
1207 /* complete bytes */
1208 predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
1209
1210 /* remaining bits -1 (up to 7) */
1211 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
1212 }
1213
1214 return predicted_size;
1215 }
1216
1217 static int ft2232_predict_scan_in(int scan_size, enum scan_type type)
1218 {
1219 int predicted_size = 0;
1220
1221 if (type != SCAN_OUT)
1222 {
1223 /* complete bytes */
1224 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
1225
1226 /* remaining bits - 1 */
1227 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
1228
1229 /* last bit (from TMS scan) */
1230 predicted_size += 1;
1231 }
1232
1233 /* LOG_DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size); */
1234
1235 return predicted_size;
1236 }
1237
1238 static void usbjtag_reset(int trst, int srst)
1239 {
1240 enum reset_types jtag_reset_config = jtag_get_reset_config();
1241 if (trst == 1)
1242 {
1243 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1244 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1245 else
1246 low_output &= ~nTRST; /* switch output low */
1247 }
1248 else if (trst == 0)
1249 {
1250 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1251 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1252 else
1253 low_output |= nTRST; /* switch output high */
1254 }
1255
1256 if (srst == 1)
1257 {
1258 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1259 low_output &= ~nSRST; /* switch output low */
1260 else
1261 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1262 }
1263 else if (srst == 0)
1264 {
1265 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1266 low_output |= nSRST; /* switch output high */
1267 else
1268 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1269 }
1270
1271 /* command "set data bits low byte" */
1272 buffer_write(0x80);
1273 buffer_write(low_output);
1274 buffer_write(low_direction);
1275 }
1276
1277 static void jtagkey_reset(int trst, int srst)
1278 {
1279 enum reset_types jtag_reset_config = jtag_get_reset_config();
1280 if (trst == 1)
1281 {
1282 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1283 high_output &= ~nTRSTnOE;
1284 else
1285 high_output &= ~nTRST;
1286 }
1287 else if (trst == 0)
1288 {
1289 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1290 high_output |= nTRSTnOE;
1291 else
1292 high_output |= nTRST;
1293 }
1294
1295 if (srst == 1)
1296 {
1297 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1298 high_output &= ~nSRST;
1299 else
1300 high_output &= ~nSRSTnOE;
1301 }
1302 else if (srst == 0)
1303 {
1304 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1305 high_output |= nSRST;
1306 else
1307 high_output |= nSRSTnOE;
1308 }
1309
1310 /* command "set data bits high byte" */
1311 buffer_write(0x82);
1312 buffer_write(high_output);
1313 buffer_write(high_direction);
1314 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1315 high_direction);
1316 }
1317
1318 static void olimex_jtag_reset(int trst, int srst)
1319 {
1320 enum reset_types jtag_reset_config = jtag_get_reset_config();
1321 if (trst == 1)
1322 {
1323 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1324 high_output &= ~nTRSTnOE;
1325 else
1326 high_output &= ~nTRST;
1327 }
1328 else if (trst == 0)
1329 {
1330 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1331 high_output |= nTRSTnOE;
1332 else
1333 high_output |= nTRST;
1334 }
1335
1336 if (srst == 1)
1337 {
1338 high_output |= nSRST;
1339 }
1340 else if (srst == 0)
1341 {
1342 high_output &= ~nSRST;
1343 }
1344
1345 /* command "set data bits high byte" */
1346 buffer_write(0x82);
1347 buffer_write(high_output);
1348 buffer_write(high_direction);
1349 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1350 high_direction);
1351 }
1352
1353 static void axm0432_jtag_reset(int trst, int srst)
1354 {
1355 if (trst == 1)
1356 {
1357 tap_set_state(TAP_RESET);
1358 high_output &= ~nTRST;
1359 }
1360 else if (trst == 0)
1361 {
1362 high_output |= nTRST;
1363 }
1364
1365 if (srst == 1)
1366 {
1367 high_output &= ~nSRST;
1368 }
1369 else if (srst == 0)
1370 {
1371 high_output |= nSRST;
1372 }
1373
1374 /* command "set data bits low byte" */
1375 buffer_write(0x82);
1376 buffer_write(high_output);
1377 buffer_write(high_direction);
1378 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1379 high_direction);
1380 }
1381
1382 static void flyswatter_reset(int trst, int srst)
1383 {
1384 if (trst == 1)
1385 {
1386 low_output &= ~nTRST;
1387 }
1388 else if (trst == 0)
1389 {
1390 low_output |= nTRST;
1391 }
1392
1393 if (srst == 1)
1394 {
1395 low_output |= nSRST;
1396 }
1397 else if (srst == 0)
1398 {
1399 low_output &= ~nSRST;
1400 }
1401
1402 /* command "set data bits low byte" */
1403 buffer_write(0x80);
1404 buffer_write(low_output);
1405 buffer_write(low_direction);
1406 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1407 }
1408
1409 static void turtle_reset(int trst, int srst)
1410 {
1411 trst = trst;
1412
1413 if (srst == 1)
1414 {
1415 low_output |= nSRST;
1416 }
1417 else if (srst == 0)
1418 {
1419 low_output &= ~nSRST;
1420 }
1421
1422 /* command "set data bits low byte" */
1423 buffer_write(0x80);
1424 buffer_write(low_output);
1425 buffer_write(low_direction);
1426 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1427 }
1428
1429 static void comstick_reset(int trst, int srst)
1430 {
1431 if (trst == 1)
1432 {
1433 high_output &= ~nTRST;
1434 }
1435 else if (trst == 0)
1436 {
1437 high_output |= nTRST;
1438 }
1439
1440 if (srst == 1)
1441 {
1442 high_output &= ~nSRST;
1443 }
1444 else if (srst == 0)
1445 {
1446 high_output |= nSRST;
1447 }
1448
1449 /* command "set data bits high byte" */
1450 buffer_write(0x82);
1451 buffer_write(high_output);
1452 buffer_write(high_direction);
1453 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1454 high_direction);
1455 }
1456
1457 static void stm32stick_reset(int trst, int srst)
1458 {
1459 if (trst == 1)
1460 {
1461 high_output &= ~nTRST;
1462 }
1463 else if (trst == 0)
1464 {
1465 high_output |= nTRST;
1466 }
1467
1468 if (srst == 1)
1469 {
1470 low_output &= ~nSRST;
1471 }
1472 else if (srst == 0)
1473 {
1474 low_output |= nSRST;
1475 }
1476
1477 /* command "set data bits low byte" */
1478 buffer_write(0x80);
1479 buffer_write(low_output);
1480 buffer_write(low_direction);
1481
1482 /* command "set data bits high byte" */
1483 buffer_write(0x82);
1484 buffer_write(high_output);
1485 buffer_write(high_direction);
1486 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1487 high_direction);
1488 }
1489
1490 static void sheevaplug_reset(int trst, int srst)
1491 {
1492 if (trst == 1)
1493 high_output &= ~nTRST;
1494 else if (trst == 0)
1495 high_output |= nTRST;
1496
1497 if (srst == 1)
1498 high_output &= ~nSRSTnOE;
1499 else if (srst == 0)
1500 high_output |= nSRSTnOE;
1501
1502 /* command "set data bits high byte" */
1503 buffer_write(0x82);
1504 buffer_write(high_output);
1505 buffer_write(high_direction);
1506 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1507 }
1508
1509 static int ft2232_execute_runtest(jtag_command_t *cmd)
1510 {
1511 int retval;
1512 int i;
1513 int predicted_size = 0;
1514 retval = ERROR_OK;
1515
1516 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1517 cmd->cmd.runtest->num_cycles,
1518 tap_state_name(cmd->cmd.runtest->end_state));
1519
1520 /* only send the maximum buffer size that FT2232C can handle */
1521 predicted_size = 0;
1522 if (tap_get_state() != TAP_IDLE)
1523 predicted_size += 3;
1524 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1525 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1526 predicted_size += 3;
1527 if (tap_get_end_state() != TAP_IDLE)
1528 predicted_size += 3;
1529 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1530 {
1531 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1532 retval = ERROR_JTAG_QUEUE_FAILED;
1533 require_send = 0;
1534 first_unsent = cmd;
1535 }
1536 if (tap_get_state() != TAP_IDLE)
1537 {
1538 move_to_state(TAP_IDLE);
1539 require_send = 1;
1540 }
1541 i = cmd->cmd.runtest->num_cycles;
1542 while (i > 0)
1543 {
1544 /* there are no state transitions in this code, so omit state tracking */
1545
1546 /* command "Clock Data to TMS/CS Pin (no Read)" */
1547 buffer_write(0x4b);
1548
1549 /* scan 7 bits */
1550 buffer_write((i > 7) ? 6 : (i - 1));
1551
1552 /* TMS data bits */
1553 buffer_write(0x0);
1554 tap_set_state(TAP_IDLE);
1555
1556 i -= (i > 7) ? 7 : i;
1557 /* LOG_DEBUG("added TMS scan (no read)"); */
1558 }
1559
1560 ft2232_end_state(cmd->cmd.runtest->end_state);
1561
1562 if (tap_get_state() != tap_get_end_state())
1563 {
1564 move_to_state(tap_get_end_state());
1565 }
1566
1567 require_send = 1;
1568 #ifdef _DEBUG_JTAG_IO_
1569 LOG_DEBUG("runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(tap_get_end_state()));
1570 #endif
1571
1572 return retval;
1573 }
1574
1575 static int ft2232_execute_statemove(jtag_command_t *cmd)
1576 {
1577 int predicted_size = 0;
1578 int retval = ERROR_OK;
1579
1580 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1581
1582 /* only send the maximum buffer size that FT2232C can handle */
1583 predicted_size = 3;
1584 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1585 {
1586 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1587 retval = ERROR_JTAG_QUEUE_FAILED;
1588 require_send = 0;
1589 first_unsent = cmd;
1590 }
1591 ft2232_end_state(cmd->cmd.statemove->end_state);
1592
1593 /* For TAP_RESET, ignore the current recorded state. It's often
1594 * wrong at server startup, and this transation is critical whenever
1595 * it's requested.
1596 */
1597 if (tap_get_end_state() == TAP_RESET) {
1598 clock_tms(0x4b, 0xff, 5, 0);
1599 require_send = 1;
1600
1601 /* shortest-path move to desired end state */
1602 } else if (tap_get_state() != tap_get_end_state())
1603 {
1604 move_to_state(tap_get_end_state());
1605 require_send = 1;
1606 }
1607
1608 return retval;
1609 }
1610
1611 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1612 {
1613 int predicted_size = 0;
1614 int retval = ERROR_OK;
1615
1616 tap_state_t* path = cmd->cmd.pathmove->path;
1617 int num_states = cmd->cmd.pathmove->num_states;
1618
1619 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1620 tap_state_name(tap_get_state()),
1621 tap_state_name(path[num_states-1]));
1622
1623 /* only send the maximum buffer size that FT2232C can handle */
1624 predicted_size = 3 * CEIL(num_states, 7);
1625 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1626 {
1627 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1628 retval = ERROR_JTAG_QUEUE_FAILED;
1629
1630 require_send = 0;
1631 first_unsent = cmd;
1632 }
1633
1634 ft2232_add_pathmove(path, num_states);
1635 require_send = 1;
1636
1637 return retval;
1638 }
1639
1640 static int ft2232_execute_scan(jtag_command_t *cmd)
1641 {
1642 uint8_t* buffer;
1643 int scan_size; /* size of IR or DR scan */
1644 int predicted_size = 0;
1645 int retval = ERROR_OK;
1646
1647 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1648
1649 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1650
1651 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1652
1653 predicted_size = ft2232_predict_scan_out(scan_size, type);
1654 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1655 {
1656 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1657 /* unsent commands before this */
1658 if (first_unsent != cmd)
1659 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1660 retval = ERROR_JTAG_QUEUE_FAILED;
1661
1662 /* current command */
1663 ft2232_end_state(cmd->cmd.scan->end_state);
1664 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1665 require_send = 0;
1666 first_unsent = cmd->next;
1667 if (buffer)
1668 free(buffer);
1669 return retval;
1670 }
1671 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1672 {
1673 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1674 first_unsent,
1675 cmd);
1676 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1677 retval = ERROR_JTAG_QUEUE_FAILED;
1678 require_send = 0;
1679 first_unsent = cmd;
1680 }
1681 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1682 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1683 ft2232_end_state(cmd->cmd.scan->end_state);
1684 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1685 require_send = 1;
1686 if (buffer)
1687 free(buffer);
1688 #ifdef _DEBUG_JTAG_IO_
1689 LOG_DEBUG("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1690 tap_state_name(tap_get_end_state()));
1691 #endif
1692 return retval;
1693
1694 }
1695
1696 static int ft2232_execute_reset(jtag_command_t *cmd)
1697 {
1698 int retval;
1699 int predicted_size = 0;
1700 retval = ERROR_OK;
1701
1702 DEBUG_JTAG_IO("reset trst: %i srst %i",
1703 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1704
1705 /* only send the maximum buffer size that FT2232C can handle */
1706 predicted_size = 3;
1707 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1708 {
1709 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1710 retval = ERROR_JTAG_QUEUE_FAILED;
1711 require_send = 0;
1712 first_unsent = cmd;
1713 }
1714
1715 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
1716 {
1717 tap_set_state(TAP_RESET);
1718 }
1719
1720 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1721 require_send = 1;
1722
1723 #ifdef _DEBUG_JTAG_IO_
1724 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1725 #endif
1726 return retval;
1727 }
1728
1729 static int ft2232_execute_sleep(jtag_command_t *cmd)
1730 {
1731 int retval;
1732 retval = ERROR_OK;
1733
1734 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1735
1736 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1737 retval = ERROR_JTAG_QUEUE_FAILED;
1738 first_unsent = cmd->next;
1739 jtag_sleep(cmd->cmd.sleep->us);
1740 #ifdef _DEBUG_JTAG_IO_
1741 LOG_DEBUG("sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name(tap_get_state()));
1742 #endif
1743
1744 return retval;
1745 }
1746
1747 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1748 {
1749 int retval;
1750 retval = ERROR_OK;
1751
1752 /* this is only allowed while in a stable state. A check for a stable
1753 * state was done in jtag_add_clocks()
1754 */
1755 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1756 retval = ERROR_JTAG_QUEUE_FAILED;
1757 #ifdef _DEBUG_JTAG_IO_
1758 LOG_DEBUG("clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name(tap_get_state()));
1759 #endif
1760
1761 return retval;
1762 }
1763
1764 static int ft2232_execute_command(jtag_command_t *cmd)
1765 {
1766 int retval;
1767 retval = ERROR_OK;
1768
1769 switch (cmd->type)
1770 {
1771 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1772 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1773 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1774 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1775 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1776 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1777 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1778 default:
1779 LOG_ERROR("BUG: unknown JTAG command type encountered");
1780 exit(-1);
1781 }
1782 return retval;
1783 }
1784
1785 static int ft2232_execute_queue()
1786 {
1787 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1788 int retval;
1789
1790 first_unsent = cmd; /* next command that has to be sent */
1791 require_send = 0;
1792
1793 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1794 * that wasn't handled by a caller-provided error handler
1795 */
1796 retval = ERROR_OK;
1797
1798 ft2232_buffer_size = 0;
1799 ft2232_expect_read = 0;
1800
1801 /* blink, if the current layout has that feature */
1802 if (layout->blink)
1803 layout->blink();
1804
1805 while (cmd)
1806 {
1807 if (ft2232_execute_command(cmd) != ERROR_OK)
1808 retval = ERROR_JTAG_QUEUE_FAILED;
1809 /* Start reading input before FT2232 TX buffer fills up */
1810 cmd = cmd->next;
1811 if (ft2232_expect_read > 256)
1812 {
1813 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1814 retval = ERROR_JTAG_QUEUE_FAILED;
1815 first_unsent = cmd;
1816 }
1817 }
1818
1819 if (require_send > 0)
1820 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1821 retval = ERROR_JTAG_QUEUE_FAILED;
1822
1823 return retval;
1824 }
1825
1826 #if BUILD_FT2232_FTD2XX == 1
1827 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more)
1828 {
1829 FT_STATUS status;
1830 DWORD deviceID;
1831 char SerialNumber[16];
1832 char Description[64];
1833 DWORD openex_flags = 0;
1834 char* openex_string = NULL;
1835 uint8_t latency_timer;
1836
1837 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1838
1839 #if IS_WIN32 == 0
1840 /* Add non-standard Vid/Pid to the linux driver */
1841 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1842 {
1843 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1844 }
1845 #endif
1846
1847 if (ft2232_device_desc && ft2232_serial)
1848 {
1849 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1850 ft2232_device_desc = NULL;
1851 }
1852
1853 if (ft2232_device_desc)
1854 {
1855 openex_string = ft2232_device_desc;
1856 openex_flags = FT_OPEN_BY_DESCRIPTION;
1857 }
1858 else if (ft2232_serial)
1859 {
1860 openex_string = ft2232_serial;
1861 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1862 }
1863 else
1864 {
1865 LOG_ERROR("neither device description nor serial number specified");
1866 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1867
1868 return ERROR_JTAG_INIT_FAILED;
1869 }
1870
1871 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1872 if (status != FT_OK) {
1873 /* under Win32, the FTD2XX driver appends an "A" to the end
1874 * of the description, if we tried by the desc, then
1875 * try by the alternate "A" description. */
1876 if (openex_string == ft2232_device_desc) {
1877 /* Try the alternate method. */
1878 openex_string = ft2232_device_desc_A;
1879 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1880 if (status == FT_OK) {
1881 /* yea, the "alternate" method worked! */
1882 } else {
1883 /* drat, give the user a meaningfull message.
1884 * telling the use we tried *BOTH* methods. */
1885 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1886 ft2232_device_desc,
1887 ft2232_device_desc_A);
1888 }
1889 }
1890 }
1891
1892 if (status != FT_OK)
1893 {
1894 DWORD num_devices;
1895
1896 if (more)
1897 {
1898 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1899 *try_more = 1;
1900 return ERROR_JTAG_INIT_FAILED;
1901 }
1902 LOG_ERROR("unable to open ftdi device: %lu", status);
1903 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1904 if (status == FT_OK)
1905 {
1906 char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
1907 uint32_t i;
1908
1909 for (i = 0; i < num_devices; i++)
1910 desc_array[i] = malloc(64);
1911
1912 desc_array[num_devices] = NULL;
1913
1914 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1915
1916 if (status == FT_OK)
1917 {
1918 LOG_ERROR("ListDevices: %lu\n", num_devices);
1919 for (i = 0; i < num_devices; i++)
1920 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
1921 }
1922
1923 for (i = 0; i < num_devices; i++)
1924 free(desc_array[i]);
1925
1926 free(desc_array);
1927 }
1928 else
1929 {
1930 LOG_ERROR("ListDevices: NONE\n");
1931 }
1932 return ERROR_JTAG_INIT_FAILED;
1933 }
1934
1935 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1936 {
1937 LOG_ERROR("unable to set latency timer: %lu", status);
1938 return ERROR_JTAG_INIT_FAILED;
1939 }
1940
1941 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1942 {
1943 LOG_ERROR("unable to get latency timer: %lu", status);
1944 return ERROR_JTAG_INIT_FAILED;
1945 }
1946 else
1947 {
1948 LOG_DEBUG("current latency timer: %i", latency_timer);
1949 }
1950
1951 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1952 {
1953 LOG_ERROR("unable to set timeouts: %lu", status);
1954 return ERROR_JTAG_INIT_FAILED;
1955 }
1956
1957 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1958 {
1959 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1960 return ERROR_JTAG_INIT_FAILED;
1961 }
1962
1963 if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
1964 {
1965 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
1966 return ERROR_JTAG_INIT_FAILED;
1967 }
1968 else
1969 {
1970 static const char* type_str[] =
1971 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1972 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
1973 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
1974 ? ftdi_device : FT_DEVICE_UNKNOWN;
1975 LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
1976 LOG_INFO("deviceID: %lu", deviceID);
1977 LOG_INFO("SerialNumber: %s", SerialNumber);
1978 LOG_INFO("Description: %s", Description);
1979 }
1980
1981 return ERROR_OK;
1982 }
1983
1984 static int ft2232_purge_ftd2xx(void)
1985 {
1986 FT_STATUS status;
1987
1988 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1989 {
1990 LOG_ERROR("error purging ftd2xx device: %lu", status);
1991 return ERROR_JTAG_INIT_FAILED;
1992 }
1993
1994 return ERROR_OK;
1995 }
1996
1997 #endif /* BUILD_FT2232_FTD2XX == 1 */
1998
1999 #if BUILD_FT2232_LIBFTDI == 1
2000 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more)
2001 {
2002 uint8_t latency_timer;
2003
2004 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
2005 ft2232_layout, vid, pid);
2006
2007 if (ftdi_init(&ftdic) < 0)
2008 return ERROR_JTAG_INIT_FAILED;
2009
2010 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
2011 {
2012 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2013 return ERROR_JTAG_INIT_FAILED;
2014 }
2015
2016 /* context, vendor id, product id */
2017 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
2018 ft2232_serial) < 0)
2019 {
2020 if (more)
2021 LOG_WARNING("unable to open ftdi device (trying more): %s",
2022 ftdic.error_str);
2023 else
2024 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2025 *try_more = 1;
2026 return ERROR_JTAG_INIT_FAILED;
2027 }
2028
2029 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2030 if (ftdi_usb_reset(&ftdic) < 0)
2031 {
2032 LOG_ERROR("unable to reset ftdi device");
2033 return ERROR_JTAG_INIT_FAILED;
2034 }
2035
2036 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
2037 {
2038 LOG_ERROR("unable to set latency timer");
2039 return ERROR_JTAG_INIT_FAILED;
2040 }
2041
2042 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2043 {
2044 LOG_ERROR("unable to get latency timer");
2045 return ERROR_JTAG_INIT_FAILED;
2046 }
2047 else
2048 {
2049 LOG_DEBUG("current latency timer: %i", latency_timer);
2050 }
2051
2052 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2053
2054 ftdi_device = ftdic.type;
2055 static const char* type_str[] =
2056 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2057 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
2058 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2059 ? ftdi_device : no_of_known_types;
2060 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2061 return ERROR_OK;
2062 }
2063
2064 static int ft2232_purge_libftdi(void)
2065 {
2066 if (ftdi_usb_purge_buffers(&ftdic) < 0)
2067 {
2068 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2069 return ERROR_JTAG_INIT_FAILED;
2070 }
2071
2072 return ERROR_OK;
2073 }
2074
2075 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2076
2077 static int ft2232_init(void)
2078 {
2079 uint8_t buf[1];
2080 int retval;
2081 uint32_t bytes_written;
2082 const ft2232_layout_t* cur_layout = ft2232_layouts;
2083 int i;
2084
2085 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE) == 7)
2086 {
2087 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2088 }
2089 else
2090 {
2091 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2092
2093 }
2094 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
2095 {
2096 ft2232_layout = "usbjtag";
2097 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2098 }
2099
2100 while (cur_layout->name)
2101 {
2102 if (strcmp(cur_layout->name, ft2232_layout) == 0)
2103 {
2104 layout = cur_layout;
2105 break;
2106 }
2107 cur_layout++;
2108 }
2109
2110 if (!layout)
2111 {
2112 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2113 return ERROR_JTAG_INIT_FAILED;
2114 }
2115
2116 for (i = 0; 1; i++)
2117 {
2118 /*
2119 * "more indicates that there are more IDs to try, so we should
2120 * not print an error for an ID mismatch (but for anything
2121 * else, we should).
2122 *
2123 * try_more indicates that the error code returned indicates an
2124 * ID mismatch (and nothing else) and that we should proceeed
2125 * with the next ID pair.
2126 */
2127 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2128 int try_more = 0;
2129
2130 #if BUILD_FT2232_FTD2XX == 1
2131 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2132 more, &try_more);
2133 #elif BUILD_FT2232_LIBFTDI == 1
2134 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2135 more, &try_more);
2136 #endif
2137 if (retval >= 0)
2138 break;
2139 if (!more || !try_more)
2140 return retval;
2141 }
2142
2143 ft2232_buffer_size = 0;
2144 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2145
2146 if (layout->init() != ERROR_OK)
2147 return ERROR_JTAG_INIT_FAILED;
2148
2149 if (ft2232_device_is_highspeed())
2150 {
2151 #ifndef BUILD_FT2232_HIGHSPEED
2152 #if BUILD_FT2232_FTD2XX == 1
2153 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2154 #elif BUILD_FT2232_LIBFTDI == 1
2155 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2156 #endif
2157 #endif
2158 /* make sure the legacy mode is disabled */
2159 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK)
2160 return ERROR_JTAG_INIT_FAILED;
2161 }
2162
2163 ft2232_speed(jtag_get_speed());
2164
2165 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2166 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
2167 {
2168 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2169 return ERROR_JTAG_INIT_FAILED;
2170 }
2171
2172 #if BUILD_FT2232_FTD2XX == 1
2173 return ft2232_purge_ftd2xx();
2174 #elif BUILD_FT2232_LIBFTDI == 1
2175 return ft2232_purge_libftdi();
2176 #endif
2177
2178 return ERROR_OK;
2179 }
2180
2181 static int usbjtag_init(void)
2182 {
2183 uint8_t buf[3];
2184 uint32_t bytes_written;
2185
2186 low_output = 0x08;
2187 low_direction = 0x0b;
2188
2189 if (strcmp(ft2232_layout, "usbjtag") == 0)
2190 {
2191 nTRST = 0x10;
2192 nTRSTnOE = 0x10;
2193 nSRST = 0x40;
2194 nSRSTnOE = 0x40;
2195 }
2196 else if (strcmp(ft2232_layout, "signalyzer") == 0)
2197 {
2198 nTRST = 0x10;
2199 nTRSTnOE = 0x10;
2200 nSRST = 0x20;
2201 nSRSTnOE = 0x20;
2202 }
2203 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2204 {
2205 nTRST = 0x0;
2206 nTRSTnOE = 0x00;
2207 nSRST = 0x20;
2208 nSRSTnOE = 0x20;
2209 low_output = 0x88;
2210 low_direction = 0x8b;
2211 }
2212 else if (strcmp(ft2232_layout, "luminary_icdi") == 0)
2213 {
2214 nTRST = 0x0;
2215 nTRSTnOE = 0x00;
2216 nSRST = 0x20;
2217 nSRSTnOE = 0x20;
2218 low_output = 0x88;
2219 low_direction = 0xcb;
2220 }
2221 else
2222 {
2223 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2224 return ERROR_JTAG_INIT_FAILED;
2225 }
2226
2227 enum reset_types jtag_reset_config = jtag_get_reset_config();
2228 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2229 {
2230 low_direction &= ~nTRSTnOE; /* nTRST input */
2231 low_output &= ~nTRST; /* nTRST = 0 */
2232 }
2233 else
2234 {
2235 low_direction |= nTRSTnOE; /* nTRST output */
2236 low_output |= nTRST; /* nTRST = 1 */
2237 }
2238
2239 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2240 {
2241 low_direction |= nSRSTnOE; /* nSRST output */
2242 low_output |= nSRST; /* nSRST = 1 */
2243 }
2244 else
2245 {
2246 low_direction &= ~nSRSTnOE; /* nSRST input */
2247 low_output &= ~nSRST; /* nSRST = 0 */
2248 }
2249
2250 /* initialize low byte for jtag */
2251 buf[0] = 0x80; /* command "set data bits low byte" */
2252 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2253 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2254 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2255
2256 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2257 {
2258 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2259 return ERROR_JTAG_INIT_FAILED;
2260 }
2261
2262 return ERROR_OK;
2263 }
2264
2265 static int axm0432_jtag_init(void)
2266 {
2267 uint8_t buf[3];
2268 uint32_t bytes_written;
2269
2270 low_output = 0x08;
2271 low_direction = 0x2b;
2272
2273 /* initialize low byte for jtag */
2274 buf[0] = 0x80; /* command "set data bits low byte" */
2275 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2276 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2277 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2278
2279 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2280 {
2281 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2282 return ERROR_JTAG_INIT_FAILED;
2283 }
2284
2285 if (strcmp(layout->name, "axm0432_jtag") == 0)
2286 {
2287 nTRST = 0x08;
2288 nTRSTnOE = 0x0; /* No output enable for TRST*/
2289 nSRST = 0x04;
2290 nSRSTnOE = 0x0; /* No output enable for SRST*/
2291 }
2292 else
2293 {
2294 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2295 exit(-1);
2296 }
2297
2298 high_output = 0x0;
2299 high_direction = 0x0c;
2300
2301 enum reset_types jtag_reset_config = jtag_get_reset_config();
2302 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2303 {
2304 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2305 }
2306 else
2307 {
2308 high_output |= nTRST;
2309 }
2310
2311 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2312 {
2313 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2314 }
2315 else
2316 {
2317 high_output |= nSRST;
2318 }
2319
2320 /* initialize high port */
2321 buf[0] = 0x82; /* command "set data bits high byte" */
2322 buf[1] = high_output; /* value */
2323 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2324 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2325
2326 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2327 {
2328 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2329 return ERROR_JTAG_INIT_FAILED;
2330 }
2331
2332 return ERROR_OK;
2333 }
2334
2335 static int jtagkey_init(void)
2336 {
2337 uint8_t buf[3];
2338 uint32_t bytes_written;
2339
2340 low_output = 0x08;
2341 low_direction = 0x1b;
2342
2343 /* initialize low byte for jtag */
2344 buf[0] = 0x80; /* command "set data bits low byte" */
2345 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2346 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2347 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2348
2349 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2350 {
2351 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2352 return ERROR_JTAG_INIT_FAILED;
2353 }
2354
2355 if (strcmp(layout->name, "jtagkey") == 0)
2356 {
2357 nTRST = 0x01;
2358 nTRSTnOE = 0x4;
2359 nSRST = 0x02;
2360 nSRSTnOE = 0x08;
2361 }
2362 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2363 || (strcmp(layout->name, "oocdlink") == 0))
2364 {
2365 nTRST = 0x02;
2366 nTRSTnOE = 0x1;
2367 nSRST = 0x08;
2368 nSRSTnOE = 0x04;
2369 }
2370 else
2371 {
2372 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2373 exit(-1);
2374 }
2375
2376 high_output = 0x0;
2377 high_direction = 0x0f;
2378
2379 enum reset_types jtag_reset_config = jtag_get_reset_config();
2380 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2381 {
2382 high_output |= nTRSTnOE;
2383 high_output &= ~nTRST;
2384 }
2385 else
2386 {
2387 high_output &= ~nTRSTnOE;
2388 high_output |= nTRST;
2389 }
2390
2391 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2392 {
2393 high_output &= ~nSRSTnOE;
2394 high_output |= nSRST;
2395 }
2396 else
2397 {
2398 high_output |= nSRSTnOE;
2399 high_output &= ~nSRST;
2400 }
2401
2402 /* initialize high port */
2403 buf[0] = 0x82; /* command "set data bits high byte" */
2404 buf[1] = high_output; /* value */
2405 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2406 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2407
2408 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2409 {
2410 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2411 return ERROR_JTAG_INIT_FAILED;
2412 }
2413
2414 return ERROR_OK;
2415 }
2416
2417 static int olimex_jtag_init(void)
2418 {
2419 uint8_t buf[3];
2420 uint32_t bytes_written;
2421
2422 low_output = 0x08;
2423 low_direction = 0x1b;
2424
2425 /* initialize low byte for jtag */
2426 buf[0] = 0x80; /* command "set data bits low byte" */
2427 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2428 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2429 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2430
2431 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2432 {
2433 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2434 return ERROR_JTAG_INIT_FAILED;
2435 }
2436
2437 nTRST = 0x01;
2438 nTRSTnOE = 0x4;
2439 nSRST = 0x02;
2440 nSRSTnOE = 0x00; /* no output enable for nSRST */
2441
2442 high_output = 0x0;
2443 high_direction = 0x0f;
2444
2445 enum reset_types jtag_reset_config = jtag_get_reset_config();
2446 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2447 {
2448 high_output |= nTRSTnOE;
2449 high_output &= ~nTRST;
2450 }
2451 else
2452 {
2453 high_output &= ~nTRSTnOE;
2454 high_output |= nTRST;
2455 }
2456
2457 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2458 {
2459 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2460 }
2461 else
2462 {
2463 high_output &= ~nSRST;
2464 }
2465
2466 /* turn red LED on */
2467 high_output |= 0x08;
2468
2469 /* initialize high port */
2470 buf[0] = 0x82; /* command "set data bits high byte" */
2471 buf[1] = high_output; /* value */
2472 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2473 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2474
2475 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3))
2476 {
2477 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2478 return ERROR_JTAG_INIT_FAILED;
2479 }
2480
2481 return ERROR_OK;
2482 }
2483
2484 static int flyswatter_init(void)
2485 {
2486 uint8_t buf[3];
2487 uint32_t bytes_written;
2488
2489 low_output = 0x18;
2490 low_direction = 0xfb;
2491
2492 /* initialize low byte for jtag */
2493 buf[0] = 0x80; /* command "set data bits low byte" */
2494 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2495 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2496 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2497
2498 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2499 {
2500 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2501 return ERROR_JTAG_INIT_FAILED;
2502 }
2503
2504 nTRST = 0x10;
2505 nTRSTnOE = 0x0; /* not output enable for nTRST */
2506 nSRST = 0x20;
2507 nSRSTnOE = 0x00; /* no output enable for nSRST */
2508
2509 high_output = 0x00;
2510 high_direction = 0x0c;
2511
2512 /* turn red LED3 on, LED2 off */
2513 high_output |= 0x08;
2514
2515 /* initialize high port */
2516 buf[0] = 0x82; /* command "set data bits high byte" */
2517 buf[1] = high_output; /* value */
2518 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2519 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2520
2521 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2522 {
2523 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2524 return ERROR_JTAG_INIT_FAILED;
2525 }
2526
2527 return ERROR_OK;
2528 }
2529
2530 static int turtle_init(void)
2531 {
2532 uint8_t buf[3];
2533 uint32_t bytes_written;
2534
2535 low_output = 0x08;
2536 low_direction = 0x5b;
2537
2538 /* initialize low byte for jtag */
2539 buf[0] = 0x80; /* command "set data bits low byte" */
2540 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2541 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2542 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2543
2544 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2545 {
2546 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2547 return ERROR_JTAG_INIT_FAILED;
2548 }
2549
2550 nSRST = 0x40;
2551
2552 high_output = 0x00;
2553 high_direction = 0x0C;
2554
2555 /* initialize high port */
2556 buf[0] = 0x82; /* command "set data bits high byte" */
2557 buf[1] = high_output;
2558 buf[2] = high_direction;
2559 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2560
2561 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2562 {
2563 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2564 return ERROR_JTAG_INIT_FAILED;
2565 }
2566
2567 return ERROR_OK;
2568 }
2569
2570 static int comstick_init(void)
2571 {
2572 uint8_t buf[3];
2573 uint32_t bytes_written;
2574
2575 low_output = 0x08;
2576 low_direction = 0x0b;
2577
2578 /* initialize low byte for jtag */
2579 buf[0] = 0x80; /* command "set data bits low byte" */
2580 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2581 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2582 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2583
2584 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2585 {
2586 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2587 return ERROR_JTAG_INIT_FAILED;
2588 }
2589
2590 nTRST = 0x01;
2591 nTRSTnOE = 0x00; /* no output enable for nTRST */
2592 nSRST = 0x02;
2593 nSRSTnOE = 0x00; /* no output enable for nSRST */
2594
2595 high_output = 0x03;
2596 high_direction = 0x03;
2597
2598 /* initialize high port */
2599 buf[0] = 0x82; /* command "set data bits high byte" */
2600 buf[1] = high_output;
2601 buf[2] = high_direction;
2602 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2603
2604 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2605 {
2606 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2607 return ERROR_JTAG_INIT_FAILED;
2608 }
2609
2610 return ERROR_OK;
2611 }
2612
2613 static int stm32stick_init(void)
2614 {
2615 uint8_t buf[3];
2616 uint32_t bytes_written;
2617
2618 low_output = 0x88;
2619 low_direction = 0x8b;
2620
2621 /* initialize low byte for jtag */
2622 buf[0] = 0x80; /* command "set data bits low byte" */
2623 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2624 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2625 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2626
2627 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2628 {
2629 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2630 return ERROR_JTAG_INIT_FAILED;
2631 }
2632
2633 nTRST = 0x01;
2634 nTRSTnOE = 0x00; /* no output enable for nTRST */
2635 nSRST = 0x80;
2636 nSRSTnOE = 0x00; /* no output enable for nSRST */
2637
2638 high_output = 0x01;
2639 high_direction = 0x03;
2640
2641 /* initialize high port */
2642 buf[0] = 0x82; /* command "set data bits high byte" */
2643 buf[1] = high_output;
2644 buf[2] = high_direction;
2645 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2646
2647 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2648 {
2649 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2650 return ERROR_JTAG_INIT_FAILED;
2651 }
2652
2653 return ERROR_OK;
2654 }
2655
2656 static int sheevaplug_init(void)
2657 {
2658 uint8_t buf[3];
2659 uint32_t bytes_written;
2660
2661 low_output = 0x08;
2662 low_direction = 0x1b;
2663
2664 /* initialize low byte for jtag */
2665 buf[0] = 0x80; /* command "set data bits low byte" */
2666 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2667 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2668 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2669
2670 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2671 {
2672 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2673 return ERROR_JTAG_INIT_FAILED;
2674 }
2675
2676 nTRSTnOE = 0x1;
2677 nTRST = 0x02;
2678 nSRSTnOE = 0x4;
2679 nSRST = 0x08;
2680
2681 high_output = 0x0;
2682 high_direction = 0x0f;
2683
2684 /* nTRST is always push-pull */
2685 high_output &= ~nTRSTnOE;
2686 high_output |= nTRST;
2687
2688 /* nSRST is always open-drain */
2689 high_output |= nSRSTnOE;
2690 high_output &= ~nSRST;
2691
2692 /* initialize high port */
2693 buf[0] = 0x82; /* command "set data bits high byte" */
2694 buf[1] = high_output; /* value */
2695 buf[2] = high_direction; /* all outputs - xRST */
2696 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2697
2698 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2699 {
2700 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2701 return ERROR_JTAG_INIT_FAILED;
2702 }
2703
2704 return ERROR_OK;
2705 }
2706
2707 static int cortino_jtag_init(void)
2708 {
2709 uint8_t buf[3];
2710 uint32_t bytes_written;
2711
2712 low_output = 0x08;
2713 low_direction = 0x1b;
2714
2715 /* initialize low byte for jtag */
2716 buf[0] = 0x80; /* command "set data bits low byte" */
2717 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2718 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2719 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2720
2721 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2722 {
2723 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2724 return ERROR_JTAG_INIT_FAILED;
2725 }
2726
2727 nTRST = 0x01;
2728 nTRSTnOE = 0x00; /* no output enable for nTRST */
2729 nSRST = 0x02;
2730 nSRSTnOE = 0x00; /* no output enable for nSRST */
2731
2732 high_output = 0x03;
2733 high_direction = 0x03;
2734
2735 /* initialize high port */
2736 buf[0] = 0x82; /* command "set data bits high byte" */
2737 buf[1] = high_output;
2738 buf[2] = high_direction;
2739 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2740
2741 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2742 {
2743 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2744 return ERROR_JTAG_INIT_FAILED;
2745 }
2746
2747 return ERROR_OK;
2748 }
2749
2750 static void olimex_jtag_blink(void)
2751 {
2752 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2753 * ACBUS3 is bit 3 of the GPIOH port
2754 */
2755 if (high_output & 0x08)
2756 {
2757 /* set port pin high */
2758 high_output &= 0x07;
2759 }
2760 else
2761 {
2762 /* set port pin low */
2763 high_output |= 0x08;
2764 }
2765
2766 buffer_write(0x82);
2767 buffer_write(high_output);
2768 buffer_write(high_direction);
2769 }
2770
2771 static void flyswatter_jtag_blink(void)
2772 {
2773 /*
2774 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2775 */
2776 high_output ^= 0x0c;
2777
2778 buffer_write(0x82);
2779 buffer_write(high_output);
2780 buffer_write(high_direction);
2781 }
2782
2783 static void turtle_jtag_blink(void)
2784 {
2785 /*
2786 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2787 */
2788 if (high_output & 0x08)
2789 {
2790 high_output = 0x04;
2791 }
2792 else
2793 {
2794 high_output = 0x08;
2795 }
2796
2797 buffer_write(0x82);
2798 buffer_write(high_output);
2799 buffer_write(high_direction);
2800 }
2801
2802 static int ft2232_quit(void)
2803 {
2804 #if BUILD_FT2232_FTD2XX == 1
2805 FT_STATUS status;
2806
2807 status = FT_Close(ftdih);
2808 #elif BUILD_FT2232_LIBFTDI == 1
2809 ftdi_usb_close(&ftdic);
2810
2811 ftdi_deinit(&ftdic);
2812 #endif
2813
2814 free(ft2232_buffer);
2815 ft2232_buffer = NULL;
2816
2817 return ERROR_OK;
2818 }
2819
2820 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2821 {
2822 char *cp;
2823 char buf[200];
2824 if (argc == 1)
2825 {
2826 ft2232_device_desc = strdup(args[0]);
2827 cp = strchr(ft2232_device_desc, 0);
2828 /* under Win32, the FTD2XX driver appends an "A" to the end
2829 * of the description, this examines the given desc
2830 * and creates the 'missing' _A or non_A variable. */
2831 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
2832 /* it was, so make this the "A" version. */
2833 ft2232_device_desc_A = ft2232_device_desc;
2834 /* and *CREATE* the non-A version. */
2835 strcpy(buf, ft2232_device_desc);
2836 cp = strchr(buf, 0);
2837 cp[-2] = 0;
2838 ft2232_device_desc = strdup(buf);
2839 } else {
2840 /* <space > A not defined
2841 * so create it */
2842 sprintf(buf, "%s A", ft2232_device_desc);
2843 ft2232_device_desc_A = strdup(buf);
2844 }
2845 }
2846 else
2847 {
2848 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2849 }
2850
2851 return ERROR_OK;
2852 }
2853
2854 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2855 {
2856 if (argc == 1)
2857 {
2858 ft2232_serial = strdup(args[0]);
2859 }
2860 else
2861 {
2862 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2863 }
2864
2865 return ERROR_OK;
2866 }
2867
2868 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2869 {
2870 if (argc == 0)
2871 return ERROR_OK;
2872
2873 ft2232_layout = malloc(strlen(args[0]) + 1);
2874 strcpy(ft2232_layout, args[0]);
2875
2876 return ERROR_OK;
2877 }
2878
2879 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2880 {
2881 if (argc > MAX_USB_IDS * 2)
2882 {
2883 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2884 "(maximum is %d pairs)", MAX_USB_IDS);
2885 argc = MAX_USB_IDS * 2;
2886 }
2887 if (argc < 2 || (argc & 1))
2888 {
2889 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2890 if (argc < 2)
2891 return ERROR_COMMAND_SYNTAX_ERROR;
2892 /* remove the incomplete trailing id */
2893 argc -= 1;
2894 }
2895
2896 int i;
2897 int retval = ERROR_OK;
2898 for (i = 0; i < argc; i += 2)
2899 {
2900 retval = parse_u16(args[i], &ft2232_vid[i >> 1]);
2901 if (ERROR_OK != retval)
2902 break;
2903 retval = parse_u16(args[i + 1], &ft2232_pid[i >> 1]);
2904 if (ERROR_OK != retval)
2905 break;
2906 }
2907
2908 /*
2909 * Explicitly terminate, in case there are multiples instances of
2910 * ft2232_vid_pid.
2911 */
2912 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2913
2914 return retval;
2915 }
2916
2917 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2918 {
2919 if (argc == 1)
2920 {
2921 ft2232_latency = atoi(args[0]);
2922 }
2923 else
2924 {
2925 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2926 }
2927
2928 return ERROR_OK;
2929 }
2930
2931 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2932 {
2933 int retval = 0;
2934
2935 /* 7 bits of either ones or zeros. */
2936 uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2937
2938 while (num_cycles > 0)
2939 {
2940 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2941 * at most 7 bits per invocation. Here we invoke it potentially
2942 * several times.
2943 */
2944 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2945
2946 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2947 {
2948 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2949 retval = ERROR_JTAG_QUEUE_FAILED;
2950
2951 first_unsent = cmd;
2952 }
2953
2954 /* there are no state transitions in this code, so omit state tracking */
2955
2956 /* command "Clock Data to TMS/CS Pin (no Read)" */
2957 buffer_write(0x4b);
2958
2959 /* scan 7 bit */
2960 buffer_write(bitcount_per_command - 1);
2961
2962 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2963 buffer_write(tms);
2964
2965 require_send = 1;
2966
2967 num_cycles -= bitcount_per_command;
2968 }
2969
2970 return retval;
2971 }
2972
2973 /* ---------------------------------------------------------------------
2974 * Support for IceBear JTAG adapter from Section5:
2975 * http://section5.ch/icebear
2976 *
2977 * Author: Sten, debian@sansys-electronic.com
2978 */
2979
2980 /* Icebear pin layout
2981 *
2982 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2983 * GND GND | 4 3| n.c.
2984 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2985 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2986 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2987 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2988 * ADBUS2 TDO |14 13| GND GND
2989 *
2990 * ADBUS0 O L TCK ACBUS0 GND
2991 * ADBUS1 O L TDI ACBUS1 GND
2992 * ADBUS2 I TDO ACBUS2 n.c.
2993 * ADBUS3 O H TMS ACBUS3 n.c.
2994 * ADBUS4 O H nTRST
2995 * ADBUS5 O H nSRST
2996 * ADBUS6 - VCC
2997 * ADBUS7 - GND
2998 */
2999 static int icebear_jtag_init(void) {
3000 uint8_t buf[3];
3001 uint32_t bytes_written;
3002
3003 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
3004 low_output = 0x08; /* high: TMS; low: TCK TDI */
3005 nTRST = 0x10;
3006 nSRST = 0x20;
3007
3008 enum reset_types jtag_reset_config = jtag_get_reset_config();
3009 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
3010 low_direction &= ~nTRST; /* nTRST high impedance */
3011 }
3012 else {
3013 low_direction |= nTRST;
3014 low_output |= nTRST;
3015 }
3016
3017 low_direction |= nSRST;
3018 low_output |= nSRST;
3019
3020 /* initialize low byte for jtag */
3021 buf[0] = 0x80; /* command "set data bits low byte" */
3022 buf[1] = low_output;
3023 buf[2] = low_direction;
3024 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3025
3026 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3027 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3028 return ERROR_JTAG_INIT_FAILED;
3029 }
3030
3031 high_output = 0x0;
3032 high_direction = 0x00;
3033
3034
3035 /* initialize high port */
3036 buf[0] = 0x82; /* command "set data bits high byte" */
3037 buf[1] = high_output; /* value */
3038 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
3039 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3040
3041 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3042 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3043 return ERROR_JTAG_INIT_FAILED;
3044 }
3045
3046 return ERROR_OK;
3047 }
3048
3049 static void icebear_jtag_reset(int trst, int srst) {
3050
3051 if (trst == 1) {
3052 low_direction |= nTRST;
3053 low_output &= ~nTRST;
3054 }
3055 else if (trst == 0) {
3056 enum reset_types jtag_reset_config = jtag_get_reset_config();
3057 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3058 low_direction &= ~nTRST;
3059 else
3060 low_output |= nTRST;
3061 }
3062
3063 if (srst == 1) {
3064 low_output &= ~nSRST;
3065 }
3066 else if (srst == 0) {
3067 low_output |= nSRST;
3068 }
3069
3070 /* command "set data bits low byte" */
3071 buffer_write(0x80);
3072 buffer_write(low_output);
3073 buffer_write(low_direction);
3074
3075 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
3076 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)