Code Review / openocd.git / blob
? search:


bebf707ad4311ca58b5e54e6ce184e6aa6659b71
[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 /* For TAP_RESET, ignore the current recorded state. It's often
1591 * wrong at server startup, and this transation is critical whenever
1592 * it's requested.
1593 */
1594 if (tap_get_end_state() == TAP_RESET) {
1595 clock_tms(0x4b, 0xff, 5, 0);
1596 require_send = 1;
1597
1598 /* shortest-path move to desired end state */
1599 } else if (tap_get_state() != tap_get_end_state())
1600 {
1601 move_to_state(tap_get_end_state());
1602 require_send = 1;
1603 }
1604
1605 return retval;
1606 }
1607
1608 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1609 {
1610 int predicted_size = 0;
1611 int retval = ERROR_OK;
1612
1613 tap_state_t* path = cmd->cmd.pathmove->path;
1614 int num_states = cmd->cmd.pathmove->num_states;
1615
1616 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1617 tap_state_name(tap_get_state()),
1618 tap_state_name(path[num_states-1]));
1619
1620 /* only send the maximum buffer size that FT2232C can handle */
1621 predicted_size = 3 * CEIL(num_states, 7);
1622 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1623 {
1624 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1625 retval = ERROR_JTAG_QUEUE_FAILED;
1626
1627 require_send = 0;
1628 first_unsent = cmd;
1629 }
1630
1631 ft2232_add_pathmove(path, num_states);
1632 require_send = 1;
1633
1634 return retval;
1635 }
1636
1637 static int ft2232_execute_scan(jtag_command_t *cmd)
1638 {
1639 uint8_t* buffer;
1640 int scan_size; /* size of IR or DR scan */
1641 int predicted_size = 0;
1642 int retval = ERROR_OK;
1643
1644 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1645
1646 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1647
1648 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1649
1650 predicted_size = ft2232_predict_scan_out(scan_size, type);
1651 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1652 {
1653 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1654 /* unsent commands before this */
1655 if (first_unsent != cmd)
1656 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1657 retval = ERROR_JTAG_QUEUE_FAILED;
1658
1659 /* current command */
1660 ft2232_end_state(cmd->cmd.scan->end_state);
1661 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1662 require_send = 0;
1663 first_unsent = cmd->next;
1664 if (buffer)
1665 free(buffer);
1666 return retval;
1667 }
1668 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1669 {
1670 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1671 first_unsent,
1672 cmd);
1673 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1674 retval = ERROR_JTAG_QUEUE_FAILED;
1675 require_send = 0;
1676 first_unsent = cmd;
1677 }
1678 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1679 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1680 ft2232_end_state(cmd->cmd.scan->end_state);
1681 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1682 require_send = 1;
1683 if (buffer)
1684 free(buffer);
1685 #ifdef _DEBUG_JTAG_IO_
1686 LOG_DEBUG("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1687 tap_state_name(tap_get_end_state()));
1688 #endif
1689 return retval;
1690
1691 }
1692
1693 static int ft2232_execute_reset(jtag_command_t *cmd)
1694 {
1695 int retval;
1696 int predicted_size = 0;
1697 retval = ERROR_OK;
1698
1699 DEBUG_JTAG_IO("reset trst: %i srst %i",
1700 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1701
1702 /* only send the maximum buffer size that FT2232C can handle */
1703 predicted_size = 3;
1704 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1705 {
1706 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1707 retval = ERROR_JTAG_QUEUE_FAILED;
1708 require_send = 0;
1709 first_unsent = cmd;
1710 }
1711
1712 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1713 require_send = 1;
1714
1715 #ifdef _DEBUG_JTAG_IO_
1716 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1717 #endif
1718 return retval;
1719 }
1720
1721 static int ft2232_execute_sleep(jtag_command_t *cmd)
1722 {
1723 int retval;
1724 retval = ERROR_OK;
1725
1726 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1727
1728 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1729 retval = ERROR_JTAG_QUEUE_FAILED;
1730 first_unsent = cmd->next;
1731 jtag_sleep(cmd->cmd.sleep->us);
1732 #ifdef _DEBUG_JTAG_IO_
1733 LOG_DEBUG("sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name(tap_get_state()));
1734 #endif
1735
1736 return retval;
1737 }
1738
1739 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1740 {
1741 int retval;
1742 retval = ERROR_OK;
1743
1744 /* this is only allowed while in a stable state. A check for a stable
1745 * state was done in jtag_add_clocks()
1746 */
1747 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1748 retval = ERROR_JTAG_QUEUE_FAILED;
1749 #ifdef _DEBUG_JTAG_IO_
1750 LOG_DEBUG("clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name(tap_get_state()));
1751 #endif
1752
1753 return retval;
1754 }
1755
1756 static int ft2232_execute_command(jtag_command_t *cmd)
1757 {
1758 int retval;
1759 retval = ERROR_OK;
1760
1761 switch (cmd->type)
1762 {
1763 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1764 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1765 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1766 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1767 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1768 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1769 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1770 default:
1771 LOG_ERROR("BUG: unknown JTAG command type encountered");
1772 exit(-1);
1773 }
1774 return retval;
1775 }
1776
1777 static int ft2232_execute_queue()
1778 {
1779 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1780 int retval;
1781
1782 first_unsent = cmd; /* next command that has to be sent */
1783 require_send = 0;
1784
1785 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1786 * that wasn't handled by a caller-provided error handler
1787 */
1788 retval = ERROR_OK;
1789
1790 ft2232_buffer_size = 0;
1791 ft2232_expect_read = 0;
1792
1793 /* blink, if the current layout has that feature */
1794 if (layout->blink)
1795 layout->blink();
1796
1797 while (cmd)
1798 {
1799 if (ft2232_execute_command(cmd) != ERROR_OK)
1800 retval = ERROR_JTAG_QUEUE_FAILED;
1801 /* Start reading input before FT2232 TX buffer fills up */
1802 cmd = cmd->next;
1803 if (ft2232_expect_read > 256)
1804 {
1805 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1806 retval = ERROR_JTAG_QUEUE_FAILED;
1807 first_unsent = cmd;
1808 }
1809 }
1810
1811 if (require_send > 0)
1812 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1813 retval = ERROR_JTAG_QUEUE_FAILED;
1814
1815 return retval;
1816 }
1817
1818 #if BUILD_FT2232_FTD2XX == 1
1819 static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more)
1820 {
1821 FT_STATUS status;
1822 DWORD deviceID;
1823 char SerialNumber[16];
1824 char Description[64];
1825 DWORD openex_flags = 0;
1826 char* openex_string = NULL;
1827 uint8_t latency_timer;
1828
1829 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1830
1831 #if IS_WIN32 == 0
1832 /* Add non-standard Vid/Pid to the linux driver */
1833 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1834 {
1835 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1836 }
1837 #endif
1838
1839 if (ft2232_device_desc && ft2232_serial)
1840 {
1841 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1842 ft2232_device_desc = NULL;
1843 }
1844
1845 if (ft2232_device_desc)
1846 {
1847 openex_string = ft2232_device_desc;
1848 openex_flags = FT_OPEN_BY_DESCRIPTION;
1849 }
1850 else if (ft2232_serial)
1851 {
1852 openex_string = ft2232_serial;
1853 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1854 }
1855 else
1856 {
1857 LOG_ERROR("neither device description nor serial number specified");
1858 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1859
1860 return ERROR_JTAG_INIT_FAILED;
1861 }
1862
1863 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1864 if (status != FT_OK) {
1865 /* under Win32, the FTD2XX driver appends an "A" to the end
1866 * of the description, if we tried by the desc, then
1867 * try by the alternate "A" description. */
1868 if (openex_string == ft2232_device_desc) {
1869 /* Try the alternate method. */
1870 openex_string = ft2232_device_desc_A;
1871 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1872 if (status == FT_OK) {
1873 /* yea, the "alternate" method worked! */
1874 } else {
1875 /* drat, give the user a meaningfull message.
1876 * telling the use we tried *BOTH* methods. */
1877 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1878 ft2232_device_desc,
1879 ft2232_device_desc_A);
1880 }
1881 }
1882 }
1883
1884 if (status != FT_OK)
1885 {
1886 DWORD num_devices;
1887
1888 if (more)
1889 {
1890 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1891 *try_more = 1;
1892 return ERROR_JTAG_INIT_FAILED;
1893 }
1894 LOG_ERROR("unable to open ftdi device: %lu", status);
1895 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1896 if (status == FT_OK)
1897 {
1898 char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
1899 uint32_t i;
1900
1901 for (i = 0; i < num_devices; i++)
1902 desc_array[i] = malloc(64);
1903
1904 desc_array[num_devices] = NULL;
1905
1906 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1907
1908 if (status == FT_OK)
1909 {
1910 LOG_ERROR("ListDevices: %lu\n", num_devices);
1911 for (i = 0; i < num_devices; i++)
1912 LOG_ERROR("%" PRIu32 ": \"%s\"", i, desc_array[i]);
1913 }
1914
1915 for (i = 0; i < num_devices; i++)
1916 free(desc_array[i]);
1917
1918 free(desc_array);
1919 }
1920 else
1921 {
1922 LOG_ERROR("ListDevices: NONE\n");
1923 }
1924 return ERROR_JTAG_INIT_FAILED;
1925 }
1926
1927 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1928 {
1929 LOG_ERROR("unable to set latency timer: %lu", status);
1930 return ERROR_JTAG_INIT_FAILED;
1931 }
1932
1933 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1934 {
1935 LOG_ERROR("unable to get latency timer: %lu", status);
1936 return ERROR_JTAG_INIT_FAILED;
1937 }
1938 else
1939 {
1940 LOG_DEBUG("current latency timer: %i", latency_timer);
1941 }
1942
1943 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1944 {
1945 LOG_ERROR("unable to set timeouts: %lu", status);
1946 return ERROR_JTAG_INIT_FAILED;
1947 }
1948
1949 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1950 {
1951 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1952 return ERROR_JTAG_INIT_FAILED;
1953 }
1954
1955 if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
1956 {
1957 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
1958 return ERROR_JTAG_INIT_FAILED;
1959 }
1960 else
1961 {
1962 static const char* type_str[] =
1963 {"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
1964 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
1965 unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
1966 ? ftdi_device : FT_DEVICE_UNKNOWN;
1967 LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
1968 LOG_INFO("deviceID: %lu", deviceID);
1969 LOG_INFO("SerialNumber: %s", SerialNumber);
1970 LOG_INFO("Description: %s", Description);
1971 }
1972
1973 return ERROR_OK;
1974 }
1975
1976 static int ft2232_purge_ftd2xx(void)
1977 {
1978 FT_STATUS status;
1979
1980 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1981 {
1982 LOG_ERROR("error purging ftd2xx device: %lu", status);
1983 return ERROR_JTAG_INIT_FAILED;
1984 }
1985
1986 return ERROR_OK;
1987 }
1988
1989 #endif /* BUILD_FT2232_FTD2XX == 1 */
1990
1991 #if BUILD_FT2232_LIBFTDI == 1
1992 static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more)
1993 {
1994 uint8_t latency_timer;
1995
1996 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1997 ft2232_layout, vid, pid);
1998
1999 if (ftdi_init(&ftdic) < 0)
2000 return ERROR_JTAG_INIT_FAILED;
2001
2002 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
2003 {
2004 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
2005 return ERROR_JTAG_INIT_FAILED;
2006 }
2007
2008 /* context, vendor id, product id */
2009 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
2010 ft2232_serial) < 0)
2011 {
2012 if (more)
2013 LOG_WARNING("unable to open ftdi device (trying more): %s",
2014 ftdic.error_str);
2015 else
2016 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
2017 *try_more = 1;
2018 return ERROR_JTAG_INIT_FAILED;
2019 }
2020
2021 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
2022 if (ftdi_usb_reset(&ftdic) < 0)
2023 {
2024 LOG_ERROR("unable to reset ftdi device");
2025 return ERROR_JTAG_INIT_FAILED;
2026 }
2027
2028 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
2029 {
2030 LOG_ERROR("unable to set latency timer");
2031 return ERROR_JTAG_INIT_FAILED;
2032 }
2033
2034 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2035 {
2036 LOG_ERROR("unable to get latency timer");
2037 return ERROR_JTAG_INIT_FAILED;
2038 }
2039 else
2040 {
2041 LOG_DEBUG("current latency timer: %i", latency_timer);
2042 }
2043
2044 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2045
2046 ftdi_device = ftdic.type;
2047 static const char* type_str[] =
2048 {"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
2049 unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
2050 unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
2051 ? ftdi_device : no_of_known_types;
2052 LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
2053 return ERROR_OK;
2054 }
2055
2056 static int ft2232_purge_libftdi(void)
2057 {
2058 if (ftdi_usb_purge_buffers(&ftdic) < 0)
2059 {
2060 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2061 return ERROR_JTAG_INIT_FAILED;
2062 }
2063
2064 return ERROR_OK;
2065 }
2066
2067 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2068
2069 static int ft2232_init(void)
2070 {
2071 uint8_t buf[1];
2072 int retval;
2073 uint32_t bytes_written;
2074 const ft2232_layout_t* cur_layout = ft2232_layouts;
2075 int i;
2076
2077 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE) == 7)
2078 {
2079 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2080 }
2081 else
2082 {
2083 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2084
2085 }
2086 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
2087 {
2088 ft2232_layout = "usbjtag";
2089 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2090 }
2091
2092 while (cur_layout->name)
2093 {
2094 if (strcmp(cur_layout->name, ft2232_layout) == 0)
2095 {
2096 layout = cur_layout;
2097 break;
2098 }
2099 cur_layout++;
2100 }
2101
2102 if (!layout)
2103 {
2104 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2105 return ERROR_JTAG_INIT_FAILED;
2106 }
2107
2108 for (i = 0; 1; i++)
2109 {
2110 /*
2111 * "more indicates that there are more IDs to try, so we should
2112 * not print an error for an ID mismatch (but for anything
2113 * else, we should).
2114 *
2115 * try_more indicates that the error code returned indicates an
2116 * ID mismatch (and nothing else) and that we should proceeed
2117 * with the next ID pair.
2118 */
2119 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2120 int try_more = 0;
2121
2122 #if BUILD_FT2232_FTD2XX == 1
2123 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2124 more, &try_more);
2125 #elif BUILD_FT2232_LIBFTDI == 1
2126 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2127 more, &try_more);
2128 #endif
2129 if (retval >= 0)
2130 break;
2131 if (!more || !try_more)
2132 return retval;
2133 }
2134
2135 ft2232_buffer_size = 0;
2136 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2137
2138 if (layout->init() != ERROR_OK)
2139 return ERROR_JTAG_INIT_FAILED;
2140
2141 if (ft2232_device_is_highspeed())
2142 {
2143 #ifndef BUILD_FT2232_HIGHSPEED
2144 #if BUILD_FT2232_FTD2XX == 1
2145 LOG_WARNING("High Speed device found - You need a newer FTD2XX driver (version 2.04.16 or later)");
2146 #elif BUILD_FT2232_LIBFTDI == 1
2147 LOG_WARNING("High Speed device found - You need a newer libftdi version (0.16 or later)");
2148 #endif
2149 #endif
2150 /* make sure the legacy mode is disabled */
2151 if (ft2232h_ft4232h_clk_divide_by_5(false) != ERROR_OK)
2152 return ERROR_JTAG_INIT_FAILED;
2153 }
2154
2155 ft2232_speed(jtag_get_speed());
2156
2157 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2158 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
2159 {
2160 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2161 return ERROR_JTAG_INIT_FAILED;
2162 }
2163
2164 #if BUILD_FT2232_FTD2XX == 1
2165 return ft2232_purge_ftd2xx();
2166 #elif BUILD_FT2232_LIBFTDI == 1
2167 return ft2232_purge_libftdi();
2168 #endif
2169
2170 return ERROR_OK;
2171 }
2172
2173 static int usbjtag_init(void)
2174 {
2175 uint8_t buf[3];
2176 uint32_t bytes_written;
2177
2178 low_output = 0x08;
2179 low_direction = 0x0b;
2180
2181 if (strcmp(ft2232_layout, "usbjtag") == 0)
2182 {
2183 nTRST = 0x10;
2184 nTRSTnOE = 0x10;
2185 nSRST = 0x40;
2186 nSRSTnOE = 0x40;
2187 }
2188 else if (strcmp(ft2232_layout, "signalyzer") == 0)
2189 {
2190 nTRST = 0x10;
2191 nTRSTnOE = 0x10;
2192 nSRST = 0x20;
2193 nSRSTnOE = 0x20;
2194 }
2195 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2196 {
2197 nTRST = 0x0;
2198 nTRSTnOE = 0x00;
2199 nSRST = 0x20;
2200 nSRSTnOE = 0x20;
2201 low_output = 0x88;
2202 low_direction = 0x8b;
2203 }
2204 else if (strcmp(ft2232_layout, "luminary_icdi") == 0)
2205 {
2206 nTRST = 0x0;
2207 nTRSTnOE = 0x00;
2208 nSRST = 0x20;
2209 nSRSTnOE = 0x20;
2210 low_output = 0x88;
2211 low_direction = 0xcb;
2212 }
2213 else
2214 {
2215 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2216 return ERROR_JTAG_INIT_FAILED;
2217 }
2218
2219 enum reset_types jtag_reset_config = jtag_get_reset_config();
2220 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2221 {
2222 low_direction &= ~nTRSTnOE; /* nTRST input */
2223 low_output &= ~nTRST; /* nTRST = 0 */
2224 }
2225 else
2226 {
2227 low_direction |= nTRSTnOE; /* nTRST output */
2228 low_output |= nTRST; /* nTRST = 1 */
2229 }
2230
2231 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2232 {
2233 low_direction |= nSRSTnOE; /* nSRST output */
2234 low_output |= nSRST; /* nSRST = 1 */
2235 }
2236 else
2237 {
2238 low_direction &= ~nSRSTnOE; /* nSRST input */
2239 low_output &= ~nSRST; /* nSRST = 0 */
2240 }
2241
2242 /* initialize low byte for jtag */
2243 buf[0] = 0x80; /* command "set data bits low byte" */
2244 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, xRST high) */
2245 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2246 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2247
2248 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2249 {
2250 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2251 return ERROR_JTAG_INIT_FAILED;
2252 }
2253
2254 return ERROR_OK;
2255 }
2256
2257 static int axm0432_jtag_init(void)
2258 {
2259 uint8_t buf[3];
2260 uint32_t bytes_written;
2261
2262 low_output = 0x08;
2263 low_direction = 0x2b;
2264
2265 /* initialize low byte for jtag */
2266 buf[0] = 0x80; /* command "set data bits low byte" */
2267 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2268 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2269 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2270
2271 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2272 {
2273 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2274 return ERROR_JTAG_INIT_FAILED;
2275 }
2276
2277 if (strcmp(layout->name, "axm0432_jtag") == 0)
2278 {
2279 nTRST = 0x08;
2280 nTRSTnOE = 0x0; /* No output enable for TRST*/
2281 nSRST = 0x04;
2282 nSRSTnOE = 0x0; /* No output enable for SRST*/
2283 }
2284 else
2285 {
2286 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2287 exit(-1);
2288 }
2289
2290 high_output = 0x0;
2291 high_direction = 0x0c;
2292
2293 enum reset_types jtag_reset_config = jtag_get_reset_config();
2294 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2295 {
2296 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2297 }
2298 else
2299 {
2300 high_output |= nTRST;
2301 }
2302
2303 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2304 {
2305 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2306 }
2307 else
2308 {
2309 high_output |= nSRST;
2310 }
2311
2312 /* initialize high port */
2313 buf[0] = 0x82; /* command "set data bits high byte" */
2314 buf[1] = high_output; /* value */
2315 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2316 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2317
2318 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2319 {
2320 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2321 return ERROR_JTAG_INIT_FAILED;
2322 }
2323
2324 return ERROR_OK;
2325 }
2326
2327 static int jtagkey_init(void)
2328 {
2329 uint8_t buf[3];
2330 uint32_t bytes_written;
2331
2332 low_output = 0x08;
2333 low_direction = 0x1b;
2334
2335 /* initialize low byte for jtag */
2336 buf[0] = 0x80; /* command "set data bits low byte" */
2337 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2338 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2339 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2340
2341 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2342 {
2343 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2344 return ERROR_JTAG_INIT_FAILED;
2345 }
2346
2347 if (strcmp(layout->name, "jtagkey") == 0)
2348 {
2349 nTRST = 0x01;
2350 nTRSTnOE = 0x4;
2351 nSRST = 0x02;
2352 nSRSTnOE = 0x08;
2353 }
2354 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2355 || (strcmp(layout->name, "oocdlink") == 0))
2356 {
2357 nTRST = 0x02;
2358 nTRSTnOE = 0x1;
2359 nSRST = 0x08;
2360 nSRSTnOE = 0x04;
2361 }
2362 else
2363 {
2364 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2365 exit(-1);
2366 }
2367
2368 high_output = 0x0;
2369 high_direction = 0x0f;
2370
2371 enum reset_types jtag_reset_config = jtag_get_reset_config();
2372 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2373 {
2374 high_output |= nTRSTnOE;
2375 high_output &= ~nTRST;
2376 }
2377 else
2378 {
2379 high_output &= ~nTRSTnOE;
2380 high_output |= nTRST;
2381 }
2382
2383 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2384 {
2385 high_output &= ~nSRSTnOE;
2386 high_output |= nSRST;
2387 }
2388 else
2389 {
2390 high_output |= nSRSTnOE;
2391 high_output &= ~nSRST;
2392 }
2393
2394 /* initialize high port */
2395 buf[0] = 0x82; /* command "set data bits high byte" */
2396 buf[1] = high_output; /* value */
2397 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2398 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2399
2400 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2401 {
2402 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2403 return ERROR_JTAG_INIT_FAILED;
2404 }
2405
2406 return ERROR_OK;
2407 }
2408
2409 static int olimex_jtag_init(void)
2410 {
2411 uint8_t buf[3];
2412 uint32_t bytes_written;
2413
2414 low_output = 0x08;
2415 low_direction = 0x1b;
2416
2417 /* initialize low byte for jtag */
2418 buf[0] = 0x80; /* command "set data bits low byte" */
2419 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2420 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2421 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2422
2423 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2424 {
2425 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2426 return ERROR_JTAG_INIT_FAILED;
2427 }
2428
2429 nTRST = 0x01;
2430 nTRSTnOE = 0x4;
2431 nSRST = 0x02;
2432 nSRSTnOE = 0x00; /* no output enable for nSRST */
2433
2434 high_output = 0x0;
2435 high_direction = 0x0f;
2436
2437 enum reset_types jtag_reset_config = jtag_get_reset_config();
2438 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2439 {
2440 high_output |= nTRSTnOE;
2441 high_output &= ~nTRST;
2442 }
2443 else
2444 {
2445 high_output &= ~nTRSTnOE;
2446 high_output |= nTRST;
2447 }
2448
2449 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2450 {
2451 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2452 }
2453 else
2454 {
2455 high_output &= ~nSRST;
2456 }
2457
2458 /* turn red LED on */
2459 high_output |= 0x08;
2460
2461 /* initialize high port */
2462 buf[0] = 0x82; /* command "set data bits high byte" */
2463 buf[1] = high_output; /* value */
2464 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2465 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2466
2467 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3))
2468 {
2469 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2470 return ERROR_JTAG_INIT_FAILED;
2471 }
2472
2473 return ERROR_OK;
2474 }
2475
2476 static int flyswatter_init(void)
2477 {
2478 uint8_t buf[3];
2479 uint32_t bytes_written;
2480
2481 low_output = 0x18;
2482 low_direction = 0xfb;
2483
2484 /* initialize low byte for jtag */
2485 buf[0] = 0x80; /* command "set data bits low byte" */
2486 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2487 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE[12]=out, n[ST]srst = out */
2488 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2489
2490 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2491 {
2492 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2493 return ERROR_JTAG_INIT_FAILED;
2494 }
2495
2496 nTRST = 0x10;
2497 nTRSTnOE = 0x0; /* not output enable for nTRST */
2498 nSRST = 0x20;
2499 nSRSTnOE = 0x00; /* no output enable for nSRST */
2500
2501 high_output = 0x00;
2502 high_direction = 0x0c;
2503
2504 /* turn red LED3 on, LED2 off */
2505 high_output |= 0x08;
2506
2507 /* initialize high port */
2508 buf[0] = 0x82; /* command "set data bits high byte" */
2509 buf[1] = high_output; /* value */
2510 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2511 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2512
2513 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2514 {
2515 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2516 return ERROR_JTAG_INIT_FAILED;
2517 }
2518
2519 return ERROR_OK;
2520 }
2521
2522 static int turtle_init(void)
2523 {
2524 uint8_t buf[3];
2525 uint32_t bytes_written;
2526
2527 low_output = 0x08;
2528 low_direction = 0x5b;
2529
2530 /* initialize low byte for jtag */
2531 buf[0] = 0x80; /* command "set data bits low byte" */
2532 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2533 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2534 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2535
2536 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2537 {
2538 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2539 return ERROR_JTAG_INIT_FAILED;
2540 }
2541
2542 nSRST = 0x40;
2543
2544 high_output = 0x00;
2545 high_direction = 0x0C;
2546
2547 /* initialize high port */
2548 buf[0] = 0x82; /* command "set data bits high byte" */
2549 buf[1] = high_output;
2550 buf[2] = high_direction;
2551 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2552
2553 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2554 {
2555 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2556 return ERROR_JTAG_INIT_FAILED;
2557 }
2558
2559 return ERROR_OK;
2560 }
2561
2562 static int comstick_init(void)
2563 {
2564 uint8_t buf[3];
2565 uint32_t bytes_written;
2566
2567 low_output = 0x08;
2568 low_direction = 0x0b;
2569
2570 /* initialize low byte for jtag */
2571 buf[0] = 0x80; /* command "set data bits low byte" */
2572 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2573 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2574 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2575
2576 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2577 {
2578 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2579 return ERROR_JTAG_INIT_FAILED;
2580 }
2581
2582 nTRST = 0x01;
2583 nTRSTnOE = 0x00; /* no output enable for nTRST */
2584 nSRST = 0x02;
2585 nSRSTnOE = 0x00; /* no output enable for nSRST */
2586
2587 high_output = 0x03;
2588 high_direction = 0x03;
2589
2590 /* initialize high port */
2591 buf[0] = 0x82; /* command "set data bits high byte" */
2592 buf[1] = high_output;
2593 buf[2] = high_direction;
2594 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2595
2596 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2597 {
2598 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2599 return ERROR_JTAG_INIT_FAILED;
2600 }
2601
2602 return ERROR_OK;
2603 }
2604
2605 static int stm32stick_init(void)
2606 {
2607 uint8_t buf[3];
2608 uint32_t bytes_written;
2609
2610 low_output = 0x88;
2611 low_direction = 0x8b;
2612
2613 /* initialize low byte for jtag */
2614 buf[0] = 0x80; /* command "set data bits low byte" */
2615 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2616 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2617 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2618
2619 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2620 {
2621 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2622 return ERROR_JTAG_INIT_FAILED;
2623 }
2624
2625 nTRST = 0x01;
2626 nTRSTnOE = 0x00; /* no output enable for nTRST */
2627 nSRST = 0x80;
2628 nSRSTnOE = 0x00; /* no output enable for nSRST */
2629
2630 high_output = 0x01;
2631 high_direction = 0x03;
2632
2633 /* initialize high port */
2634 buf[0] = 0x82; /* command "set data bits high byte" */
2635 buf[1] = high_output;
2636 buf[2] = high_direction;
2637 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2638
2639 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2640 {
2641 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2642 return ERROR_JTAG_INIT_FAILED;
2643 }
2644
2645 return ERROR_OK;
2646 }
2647
2648 static int sheevaplug_init(void)
2649 {
2650 uint8_t buf[3];
2651 uint32_t bytes_written;
2652
2653 low_output = 0x08;
2654 low_direction = 0x1b;
2655
2656 /* initialize low byte for jtag */
2657 buf[0] = 0x80; /* command "set data bits low byte" */
2658 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2659 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in */
2660 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2661
2662 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2663 {
2664 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2665 return ERROR_JTAG_INIT_FAILED;
2666 }
2667
2668 nTRSTnOE = 0x1;
2669 nTRST = 0x02;
2670 nSRSTnOE = 0x4;
2671 nSRST = 0x08;
2672
2673 high_output = 0x0;
2674 high_direction = 0x0f;
2675
2676 /* nTRST is always push-pull */
2677 high_output &= ~nTRSTnOE;
2678 high_output |= nTRST;
2679
2680 /* nSRST is always open-drain */
2681 high_output |= nSRSTnOE;
2682 high_output &= ~nSRST;
2683
2684 /* initialize high port */
2685 buf[0] = 0x82; /* command "set data bits high byte" */
2686 buf[1] = high_output; /* value */
2687 buf[2] = high_direction; /* all outputs - xRST */
2688 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2689
2690 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2691 {
2692 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2693 return ERROR_JTAG_INIT_FAILED;
2694 }
2695
2696 return ERROR_OK;
2697 }
2698
2699 static int cortino_jtag_init(void)
2700 {
2701 uint8_t buf[3];
2702 uint32_t bytes_written;
2703
2704 low_output = 0x08;
2705 low_direction = 0x1b;
2706
2707 /* initialize low byte for jtag */
2708 buf[0] = 0x80; /* command "set data bits low byte" */
2709 buf[1] = low_output; /* value (TMS = 1,TCK = 0, TDI = 0, nOE = 0) */
2710 buf[2] = low_direction; /* dir (output = 1), TCK/TDI/TMS = out, TDO = in, nOE = out */
2711 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2712
2713 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2714 {
2715 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2716 return ERROR_JTAG_INIT_FAILED;
2717 }
2718
2719 nTRST = 0x01;
2720 nTRSTnOE = 0x00; /* no output enable for nTRST */
2721 nSRST = 0x02;
2722 nSRSTnOE = 0x00; /* no output enable for nSRST */
2723
2724 high_output = 0x03;
2725 high_direction = 0x03;
2726
2727 /* initialize high port */
2728 buf[0] = 0x82; /* command "set data bits high byte" */
2729 buf[1] = high_output;
2730 buf[2] = high_direction;
2731 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2732
2733 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2734 {
2735 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2736 return ERROR_JTAG_INIT_FAILED;
2737 }
2738
2739 return ERROR_OK;
2740 }
2741
2742 static void olimex_jtag_blink(void)
2743 {
2744 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2745 * ACBUS3 is bit 3 of the GPIOH port
2746 */
2747 if (high_output & 0x08)
2748 {
2749 /* set port pin high */
2750 high_output &= 0x07;
2751 }
2752 else
2753 {
2754 /* set port pin low */
2755 high_output |= 0x08;
2756 }
2757
2758 buffer_write(0x82);
2759 buffer_write(high_output);
2760 buffer_write(high_direction);
2761 }
2762
2763 static void flyswatter_jtag_blink(void)
2764 {
2765 /*
2766 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2767 */
2768 high_output ^= 0x0c;
2769
2770 buffer_write(0x82);
2771 buffer_write(high_output);
2772 buffer_write(high_direction);
2773 }
2774
2775 static void turtle_jtag_blink(void)
2776 {
2777 /*
2778 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2779 */
2780 if (high_output & 0x08)
2781 {
2782 high_output = 0x04;
2783 }
2784 else
2785 {
2786 high_output = 0x08;
2787 }
2788
2789 buffer_write(0x82);
2790 buffer_write(high_output);
2791 buffer_write(high_direction);
2792 }
2793
2794 static int ft2232_quit(void)
2795 {
2796 #if BUILD_FT2232_FTD2XX == 1
2797 FT_STATUS status;
2798
2799 status = FT_Close(ftdih);
2800 #elif BUILD_FT2232_LIBFTDI == 1
2801 ftdi_usb_close(&ftdic);
2802
2803 ftdi_deinit(&ftdic);
2804 #endif
2805
2806 free(ft2232_buffer);
2807 ft2232_buffer = NULL;
2808
2809 return ERROR_OK;
2810 }
2811
2812 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2813 {
2814 char *cp;
2815 char buf[200];
2816 if (argc == 1)
2817 {
2818 ft2232_device_desc = strdup(args[0]);
2819 cp = strchr(ft2232_device_desc, 0);
2820 /* under Win32, the FTD2XX driver appends an "A" to the end
2821 * of the description, this examines the given desc
2822 * and creates the 'missing' _A or non_A variable. */
2823 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
2824 /* it was, so make this the "A" version. */
2825 ft2232_device_desc_A = ft2232_device_desc;
2826 /* and *CREATE* the non-A version. */
2827 strcpy(buf, ft2232_device_desc);
2828 cp = strchr(buf, 0);
2829 cp[-2] = 0;
2830 ft2232_device_desc = strdup(buf);
2831 } else {
2832 /* <space > A not defined
2833 * so create it */
2834 sprintf(buf, "%s A", ft2232_device_desc);
2835 ft2232_device_desc_A = strdup(buf);
2836 }
2837 }
2838 else
2839 {
2840 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2841 }
2842
2843 return ERROR_OK;
2844 }
2845
2846 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2847 {
2848 if (argc == 1)
2849 {
2850 ft2232_serial = strdup(args[0]);
2851 }
2852 else
2853 {
2854 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2855 }
2856
2857 return ERROR_OK;
2858 }
2859
2860 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2861 {
2862 if (argc == 0)
2863 return ERROR_OK;
2864
2865 ft2232_layout = malloc(strlen(args[0]) + 1);
2866 strcpy(ft2232_layout, args[0]);
2867
2868 return ERROR_OK;
2869 }
2870
2871 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2872 {
2873 if (argc > MAX_USB_IDS * 2)
2874 {
2875 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2876 "(maximum is %d pairs)", MAX_USB_IDS);
2877 argc = MAX_USB_IDS * 2;
2878 }
2879 if (argc < 2 || (argc & 1))
2880 {
2881 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2882 if (argc < 2)
2883 return ERROR_COMMAND_SYNTAX_ERROR;
2884 /* remove the incomplete trailing id */
2885 argc -= 1;
2886 }
2887
2888 int i;
2889 int retval = ERROR_OK;
2890 for (i = 0; i < argc; i += 2)
2891 {
2892 retval = parse_u16(args[i], &ft2232_vid[i >> 1]);
2893 if (ERROR_OK != retval)
2894 break;
2895 retval = parse_u16(args[i + 1], &ft2232_pid[i >> 1]);
2896 if (ERROR_OK != retval)
2897 break;
2898 }
2899
2900 /*
2901 * Explicitly terminate, in case there are multiples instances of
2902 * ft2232_vid_pid.
2903 */
2904 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2905
2906 return retval;
2907 }
2908
2909 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2910 {
2911 if (argc == 1)
2912 {
2913 ft2232_latency = atoi(args[0]);
2914 }
2915 else
2916 {
2917 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2918 }
2919
2920 return ERROR_OK;
2921 }
2922
2923 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2924 {
2925 int retval = 0;
2926
2927 /* 7 bits of either ones or zeros. */
2928 uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2929
2930 while (num_cycles > 0)
2931 {
2932 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2933 * at most 7 bits per invocation. Here we invoke it potentially
2934 * several times.
2935 */
2936 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2937
2938 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2939 {
2940 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2941 retval = ERROR_JTAG_QUEUE_FAILED;
2942
2943 first_unsent = cmd;
2944 }
2945
2946 /* there are no state transitions in this code, so omit state tracking */
2947
2948 /* command "Clock Data to TMS/CS Pin (no Read)" */
2949 buffer_write(0x4b);
2950
2951 /* scan 7 bit */
2952 buffer_write(bitcount_per_command - 1);
2953
2954 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2955 buffer_write(tms);
2956
2957 require_send = 1;
2958
2959 num_cycles -= bitcount_per_command;
2960 }
2961
2962 return retval;
2963 }
2964
2965 /* ---------------------------------------------------------------------
2966 * Support for IceBear JTAG adapter from Section5:
2967 * http://section5.ch/icebear
2968 *
2969 * Author: Sten, debian@sansys-electronic.com
2970 */
2971
2972 /* Icebear pin layout
2973 *
2974 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2975 * GND GND | 4 3| n.c.
2976 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2977 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2978 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2979 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2980 * ADBUS2 TDO |14 13| GND GND
2981 *
2982 * ADBUS0 O L TCK ACBUS0 GND
2983 * ADBUS1 O L TDI ACBUS1 GND
2984 * ADBUS2 I TDO ACBUS2 n.c.
2985 * ADBUS3 O H TMS ACBUS3 n.c.
2986 * ADBUS4 O H nTRST
2987 * ADBUS5 O H nSRST
2988 * ADBUS6 - VCC
2989 * ADBUS7 - GND
2990 */
2991 static int icebear_jtag_init(void) {
2992 uint8_t buf[3];
2993 uint32_t bytes_written;
2994
2995 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
2996 low_output = 0x08; /* high: TMS; low: TCK TDI */
2997 nTRST = 0x10;
2998 nSRST = 0x20;
2999
3000 enum reset_types jtag_reset_config = jtag_get_reset_config();
3001 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
3002 low_direction &= ~nTRST; /* nTRST high impedance */
3003 }
3004 else {
3005 low_direction |= nTRST;
3006 low_output |= nTRST;
3007 }
3008
3009 low_direction |= nSRST;
3010 low_output |= nSRST;
3011
3012 /* initialize low byte for jtag */
3013 buf[0] = 0x80; /* command "set data bits low byte" */
3014 buf[1] = low_output;
3015 buf[2] = low_direction;
3016 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3017
3018 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3019 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
3020 return ERROR_JTAG_INIT_FAILED;
3021 }
3022
3023 high_output = 0x0;
3024 high_direction = 0x00;
3025
3026
3027 /* initialize high port */
3028 buf[0] = 0x82; /* command "set data bits high byte" */
3029 buf[1] = high_output; /* value */
3030 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
3031 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
3032
3033 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
3034 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
3035 return ERROR_JTAG_INIT_FAILED;
3036 }
3037
3038 return ERROR_OK;
3039 }
3040
3041 static void icebear_jtag_reset(int trst, int srst) {
3042
3043 if (trst == 1) {
3044 low_direction |= nTRST;
3045 low_output &= ~nTRST;
3046 }
3047 else if (trst == 0) {
3048 enum reset_types jtag_reset_config = jtag_get_reset_config();
3049 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
3050 low_direction &= ~nTRST;
3051 else
3052 low_output |= nTRST;
3053 }
3054
3055 if (srst == 1) {
3056 low_output &= ~nSRST;
3057 }
3058 else if (srst == 0) {
3059 low_output |= nSRST;
3060 }
3061
3062 /* command "set data bits low byte" */
3063 buffer_write(0x80);
3064 buffer_write(low_output);
3065 buffer_write(low_direction);
3066
3067 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
3068 }
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)