Code Review / openocd.git / blob
? search:


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