Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Add get and set accessors for jtag_speed:
[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 u8 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 u16 ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 };
111 static u16 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 u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
172
173 static const ft2232_layout_t *layout;
174 static u8 low_output = 0x0;
175 static u8 low_direction = 0x0;
176 static u8 high_output = 0x0;
177 static u8 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 u8* 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(u8 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 u8 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(u8 mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit)
253 {
254 u8 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(u8* 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(u8* 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 u8 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 u8 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, u8* 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 u8* 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, u8* 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((u8) (thisrun_bytes - 1));
827 buffer_write((u8) ((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 u8 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, u8* 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 u8* receive_buffer = malloc(CEIL(scan_size, 8));
944 u8* 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((u8) (thisrun_bytes - 1));
997 buffer_write((u8) ((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 u8 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 if (trst == 1)
1197 {
1198 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1199 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
1200 else
1201 low_output &= ~nTRST; /* switch output low */
1202 }
1203 else if (trst == 0)
1204 {
1205 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1206 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
1207 else
1208 low_output |= nTRST; /* switch output high */
1209 }
1210
1211 if (srst == 1)
1212 {
1213 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1214 low_output &= ~nSRST; /* switch output low */
1215 else
1216 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
1217 }
1218 else if (srst == 0)
1219 {
1220 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1221 low_output |= nSRST; /* switch output high */
1222 else
1223 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
1224 }
1225
1226 /* command "set data bits low byte" */
1227 buffer_write(0x80);
1228 buffer_write(low_output);
1229 buffer_write(low_direction);
1230 }
1231
1232
1233 static void jtagkey_reset(int trst, int srst)
1234 {
1235 if (trst == 1)
1236 {
1237 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1238 high_output &= ~nTRSTnOE;
1239 else
1240 high_output &= ~nTRST;
1241 }
1242 else if (trst == 0)
1243 {
1244 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1245 high_output |= nTRSTnOE;
1246 else
1247 high_output |= nTRST;
1248 }
1249
1250 if (srst == 1)
1251 {
1252 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1253 high_output &= ~nSRST;
1254 else
1255 high_output &= ~nSRSTnOE;
1256 }
1257 else if (srst == 0)
1258 {
1259 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1260 high_output |= nSRST;
1261 else
1262 high_output |= nSRSTnOE;
1263 }
1264
1265 /* command "set data bits high byte" */
1266 buffer_write(0x82);
1267 buffer_write(high_output);
1268 buffer_write(high_direction);
1269 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1270 high_direction);
1271 }
1272
1273
1274 static void olimex_jtag_reset(int trst, int srst)
1275 {
1276 if (trst == 1)
1277 {
1278 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1279 high_output &= ~nTRSTnOE;
1280 else
1281 high_output &= ~nTRST;
1282 }
1283 else if (trst == 0)
1284 {
1285 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1286 high_output |= nTRSTnOE;
1287 else
1288 high_output |= nTRST;
1289 }
1290
1291 if (srst == 1)
1292 {
1293 high_output |= nSRST;
1294 }
1295 else if (srst == 0)
1296 {
1297 high_output &= ~nSRST;
1298 }
1299
1300 /* command "set data bits high byte" */
1301 buffer_write(0x82);
1302 buffer_write(high_output);
1303 buffer_write(high_direction);
1304 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1305 high_direction);
1306 }
1307
1308
1309 static void axm0432_jtag_reset(int trst, int srst)
1310 {
1311 if (trst == 1)
1312 {
1313 tap_set_state(TAP_RESET);
1314 high_output &= ~nTRST;
1315 }
1316 else if (trst == 0)
1317 {
1318 high_output |= nTRST;
1319 }
1320
1321 if (srst == 1)
1322 {
1323 high_output &= ~nSRST;
1324 }
1325 else if (srst == 0)
1326 {
1327 high_output |= nSRST;
1328 }
1329
1330 /* command "set data bits low byte" */
1331 buffer_write(0x82);
1332 buffer_write(high_output);
1333 buffer_write(high_direction);
1334 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1335 high_direction);
1336 }
1337
1338
1339 static void flyswatter_reset(int trst, int srst)
1340 {
1341 if (trst == 1)
1342 {
1343 low_output &= ~nTRST;
1344 }
1345 else if (trst == 0)
1346 {
1347 low_output |= nTRST;
1348 }
1349
1350 if (srst == 1)
1351 {
1352 low_output |= nSRST;
1353 }
1354 else if (srst == 0)
1355 {
1356 low_output &= ~nSRST;
1357 }
1358
1359 /* command "set data bits low byte" */
1360 buffer_write(0x80);
1361 buffer_write(low_output);
1362 buffer_write(low_direction);
1363 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1364 }
1365
1366
1367 static void turtle_reset(int trst, int srst)
1368 {
1369 trst = trst;
1370
1371 if (srst == 1)
1372 {
1373 low_output |= nSRST;
1374 }
1375 else if (srst == 0)
1376 {
1377 low_output &= ~nSRST;
1378 }
1379
1380 /* command "set data bits low byte" */
1381 buffer_write(0x80);
1382 buffer_write(low_output);
1383 buffer_write(low_direction);
1384 LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1385 }
1386
1387
1388 static void comstick_reset(int trst, int srst)
1389 {
1390 if (trst == 1)
1391 {
1392 high_output &= ~nTRST;
1393 }
1394 else if (trst == 0)
1395 {
1396 high_output |= nTRST;
1397 }
1398
1399 if (srst == 1)
1400 {
1401 high_output &= ~nSRST;
1402 }
1403 else if (srst == 0)
1404 {
1405 high_output |= nSRST;
1406 }
1407
1408 /* command "set data bits high byte" */
1409 buffer_write(0x82);
1410 buffer_write(high_output);
1411 buffer_write(high_direction);
1412 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1413 high_direction);
1414 }
1415
1416
1417 static void stm32stick_reset(int trst, int srst)
1418 {
1419 if (trst == 1)
1420 {
1421 high_output &= ~nTRST;
1422 }
1423 else if (trst == 0)
1424 {
1425 high_output |= nTRST;
1426 }
1427
1428 if (srst == 1)
1429 {
1430 low_output &= ~nSRST;
1431 }
1432 else if (srst == 0)
1433 {
1434 low_output |= nSRST;
1435 }
1436
1437 /* command "set data bits low byte" */
1438 buffer_write(0x80);
1439 buffer_write(low_output);
1440 buffer_write(low_direction);
1441
1442 /* command "set data bits high byte" */
1443 buffer_write(0x82);
1444 buffer_write(high_output);
1445 buffer_write(high_direction);
1446 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output,
1447 high_direction);
1448 }
1449
1450
1451
1452 static void sheevaplug_reset(int trst, int srst)
1453 {
1454 if (trst == 1)
1455 high_output &= ~nTRST;
1456 else if (trst == 0)
1457 high_output |= nTRST;
1458
1459 if (srst == 1)
1460 high_output &= ~nSRSTnOE;
1461 else if (srst == 0)
1462 high_output |= nSRSTnOE;
1463
1464 /* command "set data bits high byte" */
1465 buffer_write(0x82);
1466 buffer_write(high_output);
1467 buffer_write(high_direction);
1468 LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1469 }
1470
1471 static int ft2232_execute_runtest(jtag_command_t *cmd)
1472 {
1473 int retval;
1474 int i;
1475 int predicted_size = 0;
1476 retval = ERROR_OK;
1477
1478 DEBUG_JTAG_IO("runtest %i cycles, end in %s",
1479 cmd->cmd.runtest->num_cycles,
1480 tap_state_name(cmd->cmd.runtest->end_state));
1481
1482 /* only send the maximum buffer size that FT2232C can handle */
1483 predicted_size = 0;
1484 if (tap_get_state() != TAP_IDLE)
1485 predicted_size += 3;
1486 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1487 if (cmd->cmd.runtest->end_state != TAP_IDLE)
1488 predicted_size += 3;
1489 if (tap_get_end_state() != TAP_IDLE)
1490 predicted_size += 3;
1491 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1492 {
1493 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1494 retval = ERROR_JTAG_QUEUE_FAILED;
1495 require_send = 0;
1496 first_unsent = cmd;
1497 }
1498 if (tap_get_state() != TAP_IDLE)
1499 {
1500 move_to_state(TAP_IDLE);
1501 require_send = 1;
1502 }
1503 i = cmd->cmd.runtest->num_cycles;
1504 while (i > 0)
1505 {
1506 /* there are no state transitions in this code, so omit state tracking */
1507
1508 /* command "Clock Data to TMS/CS Pin (no Read)" */
1509 buffer_write(0x4b);
1510
1511 /* scan 7 bits */
1512 buffer_write((i > 7) ? 6 : (i - 1));
1513
1514 /* TMS data bits */
1515 buffer_write(0x0);
1516 tap_set_state(TAP_IDLE);
1517
1518 i -= (i > 7) ? 7 : i;
1519 /* LOG_DEBUG("added TMS scan (no read)"); */
1520 }
1521
1522 ft2232_end_state(cmd->cmd.runtest->end_state);
1523
1524 if (tap_get_state() != tap_get_end_state())
1525 {
1526 move_to_state(tap_get_end_state());
1527 }
1528
1529 require_send = 1;
1530 #ifdef _DEBUG_JTAG_IO_
1531 LOG_DEBUG("runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(tap_get_end_state()));
1532 #endif
1533
1534 return retval;
1535 }
1536
1537
1538 static int ft2232_execute_statemove(jtag_command_t *cmd)
1539 {
1540 int predicted_size = 0;
1541 int retval = ERROR_OK;
1542
1543 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
1544
1545 /* only send the maximum buffer size that FT2232C can handle */
1546 predicted_size = 3;
1547 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1548 {
1549 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1550 retval = ERROR_JTAG_QUEUE_FAILED;
1551 require_send = 0;
1552 first_unsent = cmd;
1553 }
1554 ft2232_end_state(cmd->cmd.statemove->end_state);
1555
1556 /* move to end state */
1557 if (tap_get_state() != tap_get_end_state())
1558 {
1559 move_to_state(tap_get_end_state());
1560 require_send = 1;
1561 }
1562
1563 return retval;
1564 }
1565
1566 static int ft2232_execute_pathmove(jtag_command_t *cmd)
1567 {
1568 int predicted_size = 0;
1569 int retval = ERROR_OK;
1570
1571 tap_state_t* path = cmd->cmd.pathmove->path;
1572 int num_states = cmd->cmd.pathmove->num_states;
1573
1574 DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
1575 tap_state_name(tap_get_state()),
1576 tap_state_name(path[num_states-1])
1577 );
1578
1579 /* only send the maximum buffer size that FT2232C can handle */
1580 predicted_size = 3 * CEIL(num_states, 7);
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
1586 require_send = 0;
1587 first_unsent = cmd;
1588 }
1589
1590 ft2232_add_pathmove(path, num_states);
1591 require_send = 1;
1592
1593 return retval;
1594 }
1595
1596
1597 static int ft2232_execute_scan(jtag_command_t *cmd)
1598 {
1599 u8* buffer;
1600 int scan_size; /* size of IR or DR scan */
1601 int predicted_size = 0;
1602 int retval = ERROR_OK;
1603
1604 enum scan_type type = jtag_scan_type(cmd->cmd.scan);
1605
1606 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type);
1607
1608 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1609
1610 predicted_size = ft2232_predict_scan_out(scan_size, type);
1611 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1612 {
1613 LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1614 /* unsent commands before this */
1615 if (first_unsent != cmd)
1616 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1617 retval = ERROR_JTAG_QUEUE_FAILED;
1618
1619 /* current command */
1620 ft2232_end_state(cmd->cmd.scan->end_state);
1621 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1622 require_send = 0;
1623 first_unsent = cmd->next;
1624 if (buffer)
1625 free(buffer);
1626 return retval;
1627 }
1628 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1629 {
1630 LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)",
1631 first_unsent,
1632 cmd);
1633 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1634 retval = ERROR_JTAG_QUEUE_FAILED;
1635 require_send = 0;
1636 first_unsent = cmd;
1637 }
1638 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1639 /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */
1640 ft2232_end_state(cmd->cmd.scan->end_state);
1641 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1642 require_send = 1;
1643 if (buffer)
1644 free(buffer);
1645 #ifdef _DEBUG_JTAG_IO_
1646 LOG_DEBUG("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1647 tap_state_name(tap_get_end_state()));
1648 #endif
1649 return retval;
1650
1651 }
1652
1653 static int ft2232_execute_reset(jtag_command_t *cmd)
1654 {
1655 int retval;
1656 int predicted_size = 0;
1657 retval = ERROR_OK;
1658
1659 DEBUG_JTAG_IO("reset trst: %i srst %i",
1660 cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1661
1662 /* only send the maximum buffer size that FT2232C can handle */
1663 predicted_size = 3;
1664 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1665 {
1666 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1667 retval = ERROR_JTAG_QUEUE_FAILED;
1668 require_send = 0;
1669 first_unsent = cmd;
1670 }
1671
1672 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1673 require_send = 1;
1674
1675 #ifdef _DEBUG_JTAG_IO_
1676 LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1677 #endif
1678 return retval;
1679 }
1680
1681 static int ft2232_execute_sleep(jtag_command_t *cmd)
1682 {
1683 int retval;
1684 retval = ERROR_OK;
1685
1686 DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
1687
1688 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1689 retval = ERROR_JTAG_QUEUE_FAILED;
1690 first_unsent = cmd->next;
1691 jtag_sleep(cmd->cmd.sleep->us);
1692 #ifdef _DEBUG_JTAG_IO_
1693 LOG_DEBUG("sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name(tap_get_state()));
1694 #endif
1695
1696 return retval;
1697 }
1698
1699 static int ft2232_execute_stableclocks(jtag_command_t *cmd)
1700 {
1701 int retval;
1702 retval = ERROR_OK;
1703
1704 /* this is only allowed while in a stable state. A check for a stable
1705 * state was done in jtag_add_clocks()
1706 */
1707 if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK)
1708 retval = ERROR_JTAG_QUEUE_FAILED;
1709 #ifdef _DEBUG_JTAG_IO_
1710 LOG_DEBUG("clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name(tap_get_state()));
1711 #endif
1712
1713 return retval;
1714 }
1715
1716 static int ft2232_execute_command(jtag_command_t *cmd)
1717 {
1718 int retval;
1719 retval = ERROR_OK;
1720
1721 switch (cmd->type)
1722 {
1723 case JTAG_RESET: retval = ft2232_execute_reset(cmd); break;
1724 case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break;
1725 case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break;
1726 case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break;
1727 case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break;
1728 case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break;
1729 case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break;
1730 default:
1731 LOG_ERROR("BUG: unknown JTAG command type encountered");
1732 exit(-1);
1733 }
1734 return retval;
1735 }
1736
1737 static int ft2232_execute_queue()
1738 {
1739 jtag_command_t* cmd = jtag_command_queue; /* currently processed command */
1740 int retval;
1741
1742 first_unsent = cmd; /* next command that has to be sent */
1743 require_send = 0;
1744
1745 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1746 * that wasn't handled by a caller-provided error handler
1747 */
1748 retval = ERROR_OK;
1749
1750 ft2232_buffer_size = 0;
1751 ft2232_expect_read = 0;
1752
1753 /* blink, if the current layout has that feature */
1754 if (layout->blink)
1755 layout->blink();
1756
1757 while (cmd)
1758 {
1759 if (ft2232_execute_command(cmd) != ERROR_OK)
1760 retval = ERROR_JTAG_QUEUE_FAILED;
1761 /* Start reading input before FT2232 TX buffer fills up */
1762 cmd = cmd->next;
1763 if (ft2232_expect_read > 256)
1764 {
1765 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1766 retval = ERROR_JTAG_QUEUE_FAILED;
1767 first_unsent = cmd;
1768 }
1769 }
1770
1771 if (require_send > 0)
1772 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1773 retval = ERROR_JTAG_QUEUE_FAILED;
1774
1775 return retval;
1776 }
1777
1778
1779 #if BUILD_FT2232_FTD2XX == 1
1780 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more)
1781 {
1782 FT_STATUS status;
1783 DWORD deviceID;
1784 char SerialNumber[16];
1785 char Description[64];
1786 DWORD openex_flags = 0;
1787 char* openex_string = NULL;
1788 u8 latency_timer;
1789
1790 LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid);
1791
1792 #if IS_WIN32 == 0
1793 /* Add non-standard Vid/Pid to the linux driver */
1794 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1795 {
1796 LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid);
1797 }
1798 #endif
1799
1800 if (ft2232_device_desc && ft2232_serial)
1801 {
1802 LOG_WARNING("can't open by device description and serial number, giving precedence to serial");
1803 ft2232_device_desc = NULL;
1804 }
1805
1806 if (ft2232_device_desc)
1807 {
1808 openex_string = ft2232_device_desc;
1809 openex_flags = FT_OPEN_BY_DESCRIPTION;
1810 }
1811 else if (ft2232_serial)
1812 {
1813 openex_string = ft2232_serial;
1814 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1815 }
1816 else
1817 {
1818 LOG_ERROR("neither device description nor serial number specified");
1819 LOG_ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1820
1821 return ERROR_JTAG_INIT_FAILED;
1822 }
1823
1824 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1825 if (status != FT_OK) {
1826 // under Win32, the FTD2XX driver appends an "A" to the end
1827 // of the description, if we tried by the desc, then
1828 // try by the alternate "A" description.
1829 if (openex_string == ft2232_device_desc) {
1830 // Try the alternate method.
1831 openex_string = ft2232_device_desc_A;
1832 status = FT_OpenEx(openex_string, openex_flags, &ftdih);
1833 if (status == FT_OK) {
1834 // yea, the "alternate" method worked!
1835 } else {
1836 // drat, give the user a meaningfull message.
1837 // telling the use we tried *BOTH* methods.
1838 LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n",
1839 ft2232_device_desc,
1840 ft2232_device_desc_A);
1841 }
1842 }
1843 }
1844
1845 if (status != FT_OK)
1846 {
1847 DWORD num_devices;
1848
1849 if (more)
1850 {
1851 LOG_WARNING("unable to open ftdi device (trying more): %lu", status);
1852 *try_more = 1;
1853 return ERROR_JTAG_INIT_FAILED;
1854 }
1855 LOG_ERROR("unable to open ftdi device: %lu", status);
1856 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1857 if (status == FT_OK)
1858 {
1859 char** desc_array = malloc(sizeof(char*) * (num_devices + 1));
1860 u32 i;
1861
1862 for (i = 0; i < num_devices; i++)
1863 desc_array[i] = malloc(64);
1864
1865 desc_array[num_devices] = NULL;
1866
1867 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1868
1869 if (status == FT_OK)
1870 {
1871 LOG_ERROR("ListDevices: %lu\n", num_devices);
1872 for (i = 0; i < num_devices; i++)
1873 LOG_ERROR("%i: \"%s\"", i, desc_array[i]);
1874 }
1875
1876 for (i = 0; i < num_devices; i++)
1877 free(desc_array[i]);
1878
1879 free(desc_array);
1880 }
1881 else
1882 {
1883 LOG_ERROR("ListDevices: NONE\n");
1884 }
1885 return ERROR_JTAG_INIT_FAILED;
1886 }
1887
1888 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1889 {
1890 LOG_ERROR("unable to set latency timer: %lu", status);
1891 return ERROR_JTAG_INIT_FAILED;
1892 }
1893
1894 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1895 {
1896 LOG_ERROR("unable to get latency timer: %lu", status);
1897 return ERROR_JTAG_INIT_FAILED;
1898 }
1899 else
1900 {
1901 LOG_DEBUG("current latency timer: %i", latency_timer);
1902 }
1903
1904 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1905 {
1906 LOG_ERROR("unable to set timeouts: %lu", status);
1907 return ERROR_JTAG_INIT_FAILED;
1908 }
1909
1910 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1911 {
1912 LOG_ERROR("unable to enable bit i/o mode: %lu", status);
1913 return ERROR_JTAG_INIT_FAILED;
1914 }
1915
1916 if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK)
1917 {
1918 LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status);
1919 return ERROR_JTAG_INIT_FAILED;
1920 }
1921 else
1922 {
1923 LOG_INFO("device: %lu", ftdi_device);
1924 LOG_INFO("deviceID: %lu", deviceID);
1925 LOG_INFO("SerialNumber: %s", SerialNumber);
1926 LOG_INFO("Description: %s", Description);
1927
1928 #ifdef BUILD_FTD2XX_HIGHSPEED
1929 if (ft2232_device_is_highspeed())
1930 {
1931 ft2232_max_tck = FTDI_2232H_4232H_MAX_TCK;
1932 LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck);
1933 }
1934 #endif
1935 }
1936
1937 return ERROR_OK;
1938 }
1939
1940
1941 static int ft2232_purge_ftd2xx(void)
1942 {
1943 FT_STATUS status;
1944
1945 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1946 {
1947 LOG_ERROR("error purging ftd2xx device: %lu", status);
1948 return ERROR_JTAG_INIT_FAILED;
1949 }
1950
1951 return ERROR_OK;
1952 }
1953
1954
1955 #endif /* BUILD_FT2232_FTD2XX == 1 */
1956
1957 #if BUILD_FT2232_LIBFTDI == 1
1958 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more)
1959 {
1960 u8 latency_timer;
1961
1962 LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1963 ft2232_layout, vid, pid);
1964
1965 if (ftdi_init(&ftdic) < 0)
1966 return ERROR_JTAG_INIT_FAILED;
1967
1968 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1969 {
1970 LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1971 return ERROR_JTAG_INIT_FAILED;
1972 }
1973
1974 /* context, vendor id, product id */
1975 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1976 ft2232_serial) < 0)
1977 {
1978 if (more)
1979 LOG_WARNING("unable to open ftdi device (trying more): %s",
1980 ftdic.error_str);
1981 else
1982 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
1983 *try_more = 1;
1984 return ERROR_JTAG_INIT_FAILED;
1985 }
1986
1987 /* There is already a reset in ftdi_usb_open_desc, this should be redundant */
1988 if (ftdi_usb_reset(&ftdic) < 0)
1989 {
1990 LOG_ERROR("unable to reset ftdi device");
1991 return ERROR_JTAG_INIT_FAILED;
1992 }
1993
1994 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1995 {
1996 LOG_ERROR("unable to set latency timer");
1997 return ERROR_JTAG_INIT_FAILED;
1998 }
1999
2000 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
2001 {
2002 LOG_ERROR("unable to get latency timer");
2003 return ERROR_JTAG_INIT_FAILED;
2004 }
2005 else
2006 {
2007 LOG_DEBUG("current latency timer: %i", latency_timer);
2008 }
2009
2010 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
2011
2012 return ERROR_OK;
2013 }
2014
2015
2016 static int ft2232_purge_libftdi(void)
2017 {
2018 if (ftdi_usb_purge_buffers(&ftdic) < 0)
2019 {
2020 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
2021 return ERROR_JTAG_INIT_FAILED;
2022 }
2023
2024 return ERROR_OK;
2025 }
2026
2027
2028 #endif /* BUILD_FT2232_LIBFTDI == 1 */
2029
2030 static int ft2232_init(void)
2031 {
2032 u8 buf[1];
2033 int retval;
2034 u32 bytes_written;
2035 const ft2232_layout_t* cur_layout = ft2232_layouts;
2036 int i;
2037
2038 if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE)==7)
2039 {
2040 LOG_DEBUG("ft2232 interface using 7 step jtag state transitions");
2041 }
2042 else
2043 {
2044 LOG_DEBUG("ft2232 interface using shortest path jtag state transitions");
2045
2046 }
2047 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
2048 {
2049 ft2232_layout = "usbjtag";
2050 LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'");
2051 }
2052
2053 while (cur_layout->name)
2054 {
2055 if (strcmp(cur_layout->name, ft2232_layout) == 0)
2056 {
2057 layout = cur_layout;
2058 break;
2059 }
2060 cur_layout++;
2061 }
2062
2063 if (!layout)
2064 {
2065 LOG_ERROR("No matching layout found for %s", ft2232_layout);
2066 return ERROR_JTAG_INIT_FAILED;
2067 }
2068
2069 for (i = 0; 1; i++)
2070 {
2071 /*
2072 * "more indicates that there are more IDs to try, so we should
2073 * not print an error for an ID mismatch (but for anything
2074 * else, we should).
2075 *
2076 * try_more indicates that the error code returned indicates an
2077 * ID mismatch (and nothing else) and that we should proceeed
2078 * with the next ID pair.
2079 */
2080 int more = ft2232_vid[i + 1] || ft2232_pid[i + 1];
2081 int try_more = 0;
2082
2083 #if BUILD_FT2232_FTD2XX == 1
2084 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
2085 more, &try_more);
2086 #elif BUILD_FT2232_LIBFTDI == 1
2087 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
2088 more, &try_more);
2089 #endif
2090 if (retval >= 0)
2091 break;
2092 if (!more || !try_more)
2093 return retval;
2094 }
2095
2096 ft2232_buffer_size = 0;
2097 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
2098
2099 if (layout->init() != ERROR_OK)
2100 return ERROR_JTAG_INIT_FAILED;
2101
2102 ft2232_speed(jtag_get_speed());
2103
2104 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
2105 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
2106 {
2107 LOG_ERROR("couldn't write to FT2232 to disable loopback");
2108 return ERROR_JTAG_INIT_FAILED;
2109 }
2110
2111 #if BUILD_FT2232_FTD2XX == 1
2112 return ft2232_purge_ftd2xx();
2113 #elif BUILD_FT2232_LIBFTDI == 1
2114 return ft2232_purge_libftdi();
2115 #endif
2116
2117 return ERROR_OK;
2118 }
2119
2120
2121 static int usbjtag_init(void)
2122 {
2123 u8 buf[3];
2124 u32 bytes_written;
2125
2126 low_output = 0x08;
2127 low_direction = 0x0b;
2128
2129 if (strcmp(ft2232_layout, "usbjtag") == 0)
2130 {
2131 nTRST = 0x10;
2132 nTRSTnOE = 0x10;
2133 nSRST = 0x40;
2134 nSRSTnOE = 0x40;
2135 }
2136 else if (strcmp(ft2232_layout, "signalyzer") == 0)
2137 {
2138 nTRST = 0x10;
2139 nTRSTnOE = 0x10;
2140 nSRST = 0x20;
2141 nSRSTnOE = 0x20;
2142 }
2143 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
2144 {
2145 nTRST = 0x0;
2146 nTRSTnOE = 0x00;
2147 nSRST = 0x20;
2148 nSRSTnOE = 0x20;
2149 low_output = 0x88;
2150 low_direction = 0x8b;
2151 }
2152 else
2153 {
2154 LOG_ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
2155 return ERROR_JTAG_INIT_FAILED;
2156 }
2157
2158 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2159 {
2160 low_direction &= ~nTRSTnOE; /* nTRST input */
2161 low_output &= ~nTRST; /* nTRST = 0 */
2162 }
2163 else
2164 {
2165 low_direction |= nTRSTnOE; /* nTRST output */
2166 low_output |= nTRST; /* nTRST = 1 */
2167 }
2168
2169 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2170 {
2171 low_direction |= nSRSTnOE; /* nSRST output */
2172 low_output |= nSRST; /* nSRST = 1 */
2173 }
2174 else
2175 {
2176 low_direction &= ~nSRSTnOE; /* nSRST input */
2177 low_output &= ~nSRST; /* nSRST = 0 */
2178 }
2179
2180 /* initialize low byte for jtag */
2181 buf[0] = 0x80; /* command "set data bits low byte" */
2182 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
2183 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2184 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2185
2186 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2187 {
2188 LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
2189 return ERROR_JTAG_INIT_FAILED;
2190 }
2191
2192 return ERROR_OK;
2193 }
2194
2195
2196 static int axm0432_jtag_init(void)
2197 {
2198 u8 buf[3];
2199 u32 bytes_written;
2200
2201 low_output = 0x08;
2202 low_direction = 0x2b;
2203
2204 /* initialize low byte for jtag */
2205 buf[0] = 0x80; /* command "set data bits low byte" */
2206 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2207 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2208 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2209
2210 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2211 {
2212 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2213 return ERROR_JTAG_INIT_FAILED;
2214 }
2215
2216 if (strcmp(layout->name, "axm0432_jtag") == 0)
2217 {
2218 nTRST = 0x08;
2219 nTRSTnOE = 0x0; /* No output enable for TRST*/
2220 nSRST = 0x04;
2221 nSRSTnOE = 0x0; /* No output enable for SRST*/
2222 }
2223 else
2224 {
2225 LOG_ERROR("BUG: axm0432_jtag_init called for non axm0432 layout");
2226 exit(-1);
2227 }
2228
2229 high_output = 0x0;
2230 high_direction = 0x0c;
2231
2232 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2233 {
2234 LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag");
2235 }
2236 else
2237 {
2238 high_output |= nTRST;
2239 }
2240
2241 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2242 {
2243 LOG_ERROR("can't set nSRST to push-pull on the Dicarlo jtag");
2244 }
2245 else
2246 {
2247 high_output |= nSRST;
2248 }
2249
2250 /* initialize high port */
2251 buf[0] = 0x82; /* command "set data bits high byte" */
2252 buf[1] = high_output; /* value */
2253 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2254 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2255
2256 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2257 {
2258 LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout");
2259 return ERROR_JTAG_INIT_FAILED;
2260 }
2261
2262 return ERROR_OK;
2263 }
2264
2265
2266 static int jtagkey_init(void)
2267 {
2268 u8 buf[3];
2269 u32 bytes_written;
2270
2271 low_output = 0x08;
2272 low_direction = 0x1b;
2273
2274 /* initialize low byte for jtag */
2275 buf[0] = 0x80; /* command "set data bits low byte" */
2276 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2277 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2278 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2279
2280 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2281 {
2282 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2283 return ERROR_JTAG_INIT_FAILED;
2284 }
2285
2286 if (strcmp(layout->name, "jtagkey") == 0)
2287 {
2288 nTRST = 0x01;
2289 nTRSTnOE = 0x4;
2290 nSRST = 0x02;
2291 nSRSTnOE = 0x08;
2292 }
2293 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0)
2294 || (strcmp(layout->name, "oocdlink") == 0))
2295 {
2296 nTRST = 0x02;
2297 nTRSTnOE = 0x1;
2298 nSRST = 0x08;
2299 nSRSTnOE = 0x04;
2300 }
2301 else
2302 {
2303 LOG_ERROR("BUG: jtagkey_init called for non jtagkey layout");
2304 exit(-1);
2305 }
2306
2307 high_output = 0x0;
2308 high_direction = 0x0f;
2309
2310 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2311 {
2312 high_output |= nTRSTnOE;
2313 high_output &= ~nTRST;
2314 }
2315 else
2316 {
2317 high_output &= ~nTRSTnOE;
2318 high_output |= nTRST;
2319 }
2320
2321 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2322 {
2323 high_output &= ~nSRSTnOE;
2324 high_output |= nSRST;
2325 }
2326 else
2327 {
2328 high_output |= nSRSTnOE;
2329 high_output &= ~nSRST;
2330 }
2331
2332 /* initialize high port */
2333 buf[0] = 0x82; /* command "set data bits high byte" */
2334 buf[1] = high_output; /* value */
2335 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2336 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2337
2338 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2339 {
2340 LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
2341 return ERROR_JTAG_INIT_FAILED;
2342 }
2343
2344 return ERROR_OK;
2345 }
2346
2347
2348 static int olimex_jtag_init(void)
2349 {
2350 u8 buf[3];
2351 u32 bytes_written;
2352
2353 low_output = 0x08;
2354 low_direction = 0x1b;
2355
2356 /* initialize low byte for jtag */
2357 buf[0] = 0x80; /* command "set data bits low byte" */
2358 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2359 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2360 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2361
2362 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2363 {
2364 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2365 return ERROR_JTAG_INIT_FAILED;
2366 }
2367
2368 nTRST = 0x01;
2369 nTRSTnOE = 0x4;
2370 nSRST = 0x02;
2371 nSRSTnOE = 0x00; /* no output enable for nSRST */
2372
2373 high_output = 0x0;
2374 high_direction = 0x0f;
2375
2376 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
2377 {
2378 high_output |= nTRSTnOE;
2379 high_output &= ~nTRST;
2380 }
2381 else
2382 {
2383 high_output &= ~nTRSTnOE;
2384 high_output |= nTRST;
2385 }
2386
2387 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
2388 {
2389 LOG_ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
2390 }
2391 else
2392 {
2393 high_output &= ~nSRST;
2394 }
2395
2396 /* turn red LED on */
2397 high_output |= 0x08;
2398
2399 /* initialize high port */
2400 buf[0] = 0x82; /* command "set data bits high byte" */
2401 buf[1] = high_output; /* value */
2402 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2403 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2404
2405 if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3))
2406 {
2407 LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout");
2408 return ERROR_JTAG_INIT_FAILED;
2409 }
2410
2411 return ERROR_OK;
2412 }
2413
2414
2415 static int flyswatter_init(void)
2416 {
2417 u8 buf[3];
2418 u32 bytes_written;
2419
2420 low_output = 0x18;
2421 low_direction = 0xfb;
2422
2423 /* initialize low byte for jtag */
2424 buf[0] = 0x80; /* command "set data bits low byte" */
2425 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2426 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
2427 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2428
2429 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2430 {
2431 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2432 return ERROR_JTAG_INIT_FAILED;
2433 }
2434
2435 nTRST = 0x10;
2436 nTRSTnOE = 0x0; /* not output enable for nTRST */
2437 nSRST = 0x20;
2438 nSRSTnOE = 0x00; /* no output enable for nSRST */
2439
2440 high_output = 0x00;
2441 high_direction = 0x0c;
2442
2443 /* turn red LED3 on, LED2 off */
2444 high_output |= 0x08;
2445
2446 /* initialize high port */
2447 buf[0] = 0x82; /* command "set data bits high byte" */
2448 buf[1] = high_output; /* value */
2449 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2450 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2451
2452 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2453 {
2454 LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
2455 return ERROR_JTAG_INIT_FAILED;
2456 }
2457
2458 return ERROR_OK;
2459 }
2460
2461
2462 static int turtle_init(void)
2463 {
2464 u8 buf[3];
2465 u32 bytes_written;
2466
2467 low_output = 0x08;
2468 low_direction = 0x5b;
2469
2470 /* initialize low byte for jtag */
2471 buf[0] = 0x80; /* command "set data bits low byte" */
2472 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2473 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2474 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2475
2476 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2477 {
2478 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2479 return ERROR_JTAG_INIT_FAILED;
2480 }
2481
2482 nSRST = 0x40;
2483
2484 high_output = 0x00;
2485 high_direction = 0x0C;
2486
2487 /* initialize high port */
2488 buf[0] = 0x82; /* command "set data bits high byte" */
2489 buf[1] = high_output;
2490 buf[2] = high_direction;
2491 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2492
2493 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2494 {
2495 LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
2496 return ERROR_JTAG_INIT_FAILED;
2497 }
2498
2499 return ERROR_OK;
2500 }
2501
2502
2503 static int comstick_init(void)
2504 {
2505 u8 buf[3];
2506 u32 bytes_written;
2507
2508 low_output = 0x08;
2509 low_direction = 0x0b;
2510
2511 /* initialize low byte for jtag */
2512 buf[0] = 0x80; /* command "set data bits low byte" */
2513 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2514 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2515 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2516
2517 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2518 {
2519 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2520 return ERROR_JTAG_INIT_FAILED;
2521 }
2522
2523 nTRST = 0x01;
2524 nTRSTnOE = 0x00; /* no output enable for nTRST */
2525 nSRST = 0x02;
2526 nSRSTnOE = 0x00; /* no output enable for nSRST */
2527
2528 high_output = 0x03;
2529 high_direction = 0x03;
2530
2531 /* initialize high port */
2532 buf[0] = 0x82; /* command "set data bits high byte" */
2533 buf[1] = high_output;
2534 buf[2] = high_direction;
2535 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2536
2537 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2538 {
2539 LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout");
2540 return ERROR_JTAG_INIT_FAILED;
2541 }
2542
2543 return ERROR_OK;
2544 }
2545
2546
2547 static int stm32stick_init(void)
2548 {
2549 u8 buf[3];
2550 u32 bytes_written;
2551
2552 low_output = 0x88;
2553 low_direction = 0x8b;
2554
2555 /* initialize low byte for jtag */
2556 buf[0] = 0x80; /* command "set data bits low byte" */
2557 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2558 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2559 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2560
2561 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2562 {
2563 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2564 return ERROR_JTAG_INIT_FAILED;
2565 }
2566
2567 nTRST = 0x01;
2568 nTRSTnOE = 0x00; /* no output enable for nTRST */
2569 nSRST = 0x80;
2570 nSRSTnOE = 0x00; /* no output enable for nSRST */
2571
2572 high_output = 0x01;
2573 high_direction = 0x03;
2574
2575 /* initialize high port */
2576 buf[0] = 0x82; /* command "set data bits high byte" */
2577 buf[1] = high_output;
2578 buf[2] = high_direction;
2579 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2580
2581 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2582 {
2583 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2584 return ERROR_JTAG_INIT_FAILED;
2585 }
2586
2587 return ERROR_OK;
2588 }
2589
2590
2591 static int sheevaplug_init(void)
2592 {
2593 u8 buf[3];
2594 u32 bytes_written;
2595
2596 low_output = 0x08;
2597 low_direction = 0x1b;
2598
2599 /* initialize low byte for jtag */
2600 buf[0] = 0x80; /* command "set data bits low byte" */
2601 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2602 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
2603 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2604
2605 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2606 {
2607 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2608 return ERROR_JTAG_INIT_FAILED;
2609 }
2610
2611 nTRSTnOE = 0x1;
2612 nTRST = 0x02;
2613 nSRSTnOE = 0x4;
2614 nSRST = 0x08;
2615
2616 high_output = 0x0;
2617 high_direction = 0x0f;
2618
2619 /* nTRST is always push-pull */
2620 high_output &= ~nTRSTnOE;
2621 high_output |= nTRST;
2622
2623 /* nSRST is always open-drain */
2624 high_output |= nSRSTnOE;
2625 high_output &= ~nSRST;
2626
2627 /* initialize high port */
2628 buf[0] = 0x82; /* command "set data bits high byte" */
2629 buf[1] = high_output; /* value */
2630 buf[2] = high_direction; /* all outputs - xRST */
2631 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2632
2633 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2634 {
2635 LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout");
2636 return ERROR_JTAG_INIT_FAILED;
2637 }
2638
2639 return ERROR_OK;
2640 }
2641
2642 static int cortino_jtag_init(void)
2643 {
2644 u8 buf[3];
2645 u32 bytes_written;
2646
2647 low_output = 0x08;
2648 low_direction = 0x1b;
2649
2650 /* initialize low byte for jtag */
2651 buf[0] = 0x80; /* command "set data bits low byte" */
2652 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
2653 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
2654 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2655
2656 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2657 {
2658 LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout");
2659 return ERROR_JTAG_INIT_FAILED;
2660 }
2661
2662 nTRST = 0x01;
2663 nTRSTnOE = 0x00; /* no output enable for nTRST */
2664 nSRST = 0x02;
2665 nSRSTnOE = 0x00; /* no output enable for nSRST */
2666
2667 high_output = 0x03;
2668 high_direction = 0x03;
2669
2670 /* initialize high port */
2671 buf[0] = 0x82; /* command "set data bits high byte" */
2672 buf[1] = high_output;
2673 buf[2] = high_direction;
2674 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2675
2676 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
2677 {
2678 LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
2679 return ERROR_JTAG_INIT_FAILED;
2680 }
2681
2682 return ERROR_OK;
2683 }
2684
2685 static void olimex_jtag_blink(void)
2686 {
2687 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2688 * ACBUS3 is bit 3 of the GPIOH port
2689 */
2690 if (high_output & 0x08)
2691 {
2692 /* set port pin high */
2693 high_output &= 0x07;
2694 }
2695 else
2696 {
2697 /* set port pin low */
2698 high_output |= 0x08;
2699 }
2700
2701 buffer_write(0x82);
2702 buffer_write(high_output);
2703 buffer_write(high_direction);
2704 }
2705
2706
2707 static void flyswatter_jtag_blink(void)
2708 {
2709 /*
2710 * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3
2711 */
2712 high_output ^= 0x0c;
2713
2714 buffer_write(0x82);
2715 buffer_write(high_output);
2716 buffer_write(high_direction);
2717 }
2718
2719
2720 static void turtle_jtag_blink(void)
2721 {
2722 /*
2723 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2724 */
2725 if (high_output & 0x08)
2726 {
2727 high_output = 0x04;
2728 }
2729 else
2730 {
2731 high_output = 0x08;
2732 }
2733
2734 buffer_write(0x82);
2735 buffer_write(high_output);
2736 buffer_write(high_direction);
2737 }
2738
2739
2740 static int ft2232_quit(void)
2741 {
2742 #if BUILD_FT2232_FTD2XX == 1
2743 FT_STATUS status;
2744
2745 status = FT_Close(ftdih);
2746 #elif BUILD_FT2232_LIBFTDI == 1
2747 ftdi_usb_close(&ftdic);
2748
2749 ftdi_deinit(&ftdic);
2750 #endif
2751
2752 free(ft2232_buffer);
2753 ft2232_buffer = NULL;
2754
2755 return ERROR_OK;
2756 }
2757
2758
2759 static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2760 {
2761 char *cp;
2762 char buf[200];
2763 if (argc == 1)
2764 {
2765 ft2232_device_desc = strdup(args[0]);
2766 cp = strchr(ft2232_device_desc, 0);
2767 // under Win32, the FTD2XX driver appends an "A" to the end
2768 // of the description, this examines the given desc
2769 // and creates the 'missing' _A or non_A variable.
2770 if ((cp[-1] == 'A') && (cp[-2]==' ')) {
2771 // it was, so make this the "A" version.
2772 ft2232_device_desc_A = ft2232_device_desc;
2773 // and *CREATE* the non-A version.
2774 strcpy(buf, ft2232_device_desc);
2775 cp = strchr(buf, 0);
2776 cp[-2] = 0;
2777 ft2232_device_desc = strdup(buf);
2778 } else {
2779 // <space>A not defined
2780 // so create it
2781 sprintf(buf, "%s A", ft2232_device_desc);
2782 ft2232_device_desc_A = strdup(buf);
2783 }
2784 }
2785 else
2786 {
2787 LOG_ERROR("expected exactly one argument to ft2232_device_desc <description>");
2788 }
2789
2790 return ERROR_OK;
2791 }
2792
2793
2794 static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2795 {
2796 if (argc == 1)
2797 {
2798 ft2232_serial = strdup(args[0]);
2799 }
2800 else
2801 {
2802 LOG_ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2803 }
2804
2805 return ERROR_OK;
2806 }
2807
2808
2809 static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2810 {
2811 if (argc == 0)
2812 return ERROR_OK;
2813
2814 ft2232_layout = malloc(strlen(args[0]) + 1);
2815 strcpy(ft2232_layout, args[0]);
2816
2817 return ERROR_OK;
2818 }
2819
2820
2821 static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2822 {
2823 int i;
2824
2825 if (argc > MAX_USB_IDS * 2)
2826 {
2827 LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
2828 "(maximum is %d pairs)", MAX_USB_IDS);
2829 argc = MAX_USB_IDS * 2;
2830 }
2831 if (argc < 2 || (argc & 1))
2832 {
2833 LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
2834 if (argc < 2)
2835 return ERROR_OK;
2836 }
2837
2838 for (i = 0; i + 1 < argc; i += 2)
2839 {
2840 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2841 ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0);
2842 }
2843
2844 /*
2845 * Explicitly terminate, in case there are multiples instances of
2846 * ft2232_vid_pid.
2847 */
2848 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2849
2850 return ERROR_OK;
2851 }
2852
2853
2854 static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc)
2855 {
2856 if (argc == 1)
2857 {
2858 ft2232_latency = atoi(args[0]);
2859 }
2860 else
2861 {
2862 LOG_ERROR("expected exactly one argument to ft2232_latency <ms>");
2863 }
2864
2865 return ERROR_OK;
2866 }
2867
2868
2869 static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd)
2870 {
2871 int retval = 0;
2872
2873 /* 7 bits of either ones or zeros. */
2874 u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00);
2875
2876 while (num_cycles > 0)
2877 {
2878 /* the command 0x4b, "Clock Data to TMS/CS Pin (no Read)" handles
2879 * at most 7 bits per invocation. Here we invoke it potentially
2880 * several times.
2881 */
2882 int bitcount_per_command = (num_cycles > 7) ? 7 : num_cycles;
2883
2884 if (ft2232_buffer_size + 3 >= FT2232_BUFFER_SIZE)
2885 {
2886 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
2887 retval = ERROR_JTAG_QUEUE_FAILED;
2888
2889 first_unsent = cmd;
2890 }
2891
2892 /* there are no state transitions in this code, so omit state tracking */
2893
2894 /* command "Clock Data to TMS/CS Pin (no Read)" */
2895 buffer_write(0x4b);
2896
2897 /* scan 7 bit */
2898 buffer_write(bitcount_per_command - 1);
2899
2900 /* TMS data bits are either all zeros or ones to stay in the current stable state */
2901 buffer_write(tms);
2902
2903 require_send = 1;
2904
2905 num_cycles -= bitcount_per_command;
2906 }
2907
2908 return retval;
2909 }
2910
2911
2912 /* ---------------------------------------------------------------------
2913 * Support for IceBear JTAG adapter from Section5:
2914 * http://section5.ch/icebear
2915 *
2916 * Author: Sten, debian@sansys-electronic.com
2917 */
2918
2919 /* Icebear pin layout
2920 *
2921 * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC)
2922 * GND GND | 4 3| n.c.
2923 * ADBUS3 TMS | 6 5| ADBUS6 VCC
2924 * ADBUS0 TCK | 8 7| ADBUS7 (GND)
2925 * ADBUS4 nTRST |10 9| ACBUS0 (GND)
2926 * ADBUS1 TDI |12 11| ACBUS1 (GND)
2927 * ADBUS2 TDO |14 13| GND GND
2928 *
2929 * ADBUS0 O L TCK ACBUS0 GND
2930 * ADBUS1 O L TDI ACBUS1 GND
2931 * ADBUS2 I TDO ACBUS2 n.c.
2932 * ADBUS3 O H TMS ACBUS3 n.c.
2933 * ADBUS4 O H nTRST
2934 * ADBUS5 O H nSRST
2935 * ADBUS6 - VCC
2936 * ADBUS7 - GND
2937 */
2938 static int icebear_jtag_init(void) {
2939 u8 buf[3];
2940 u32 bytes_written;
2941
2942 low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */
2943 low_output = 0x08; /* high: TMS; low: TCK TDI */
2944 nTRST = 0x10;
2945 nSRST = 0x20;
2946
2947 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) {
2948 low_direction &= ~nTRST; /* nTRST high impedance */
2949 }
2950 else {
2951 low_direction |= nTRST;
2952 low_output |= nTRST;
2953 }
2954
2955 low_direction |= nSRST;
2956 low_output |= nSRST;
2957
2958 /* initialize low byte for jtag */
2959 buf[0] = 0x80; /* command "set data bits low byte" */
2960 buf[1] = low_output;
2961 buf[2] = low_direction;
2962 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2963
2964 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
2965 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)");
2966 return ERROR_JTAG_INIT_FAILED;
2967 }
2968
2969 high_output = 0x0;
2970 high_direction = 0x00;
2971
2972
2973 /* initialize high port */
2974 buf[0] = 0x82; /* command "set data bits high byte" */
2975 buf[1] = high_output; /* value */
2976 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
2977 LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
2978
2979 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) {
2980 LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)");
2981 return ERROR_JTAG_INIT_FAILED;
2982 }
2983
2984 return ERROR_OK;
2985 }
2986
2987 static void icebear_jtag_reset(int trst, int srst) {
2988
2989 if (trst == 1) {
2990 low_direction |= nTRST;
2991 low_output &= ~nTRST;
2992 }
2993 else if (trst == 0) {
2994 if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0)
2995 low_direction &= ~nTRST;
2996 else
2997 low_output |= nTRST;
2998 }
2999
3000 if (srst == 1) {
3001 low_output &= ~nSRST;
3002 }
3003 else if (srst == 0) {
3004 low_output |= nSRST;
3005 }
3006
3007 /* command "set data bits low byte" */
3008 buffer_write(0x80);
3009 buffer_write(low_output);
3010 buffer_write(low_direction);
3011
3012 LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
3013 }
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)