Code Review / openocd.git / blob
? search:


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