Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- added support for Hitex STM32 Performance Stick
[openocd.git] / src / jtag / ft2232.c
1 /***************************************************************************
2 * Copyright (C) 2004, 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #if IS_CYGWIN == 1
25 #include "windows.h"
26 #undef ERROR
27 #endif
28
29 #include "replacements.h"
30
31 /* project specific includes */
32 #include "log.h"
33 #include "types.h"
34 #include "jtag.h"
35 #include "configuration.h"
36 #include "time_support.h"
37
38 /* system includes */
39 #include <string.h>
40 #include <stdlib.h>
41 #include <unistd.h>
42
43 /* FT2232 access library includes */
44 #if BUILD_FT2232_FTD2XX == 1
45 #include <ftd2xx.h>
46 #elif BUILD_FT2232_LIBFTDI == 1
47 #include <ftdi.h>
48 #endif
49
50 #include <sys/time.h>
51 #include <time.h>
52
53 /* enable this to debug io latency
54 */
55 #if 0
56 #define _DEBUG_USB_IO_
57 #endif
58
59 /* enable this to debug communication
60 */
61 #if 0
62 #define _DEBUG_USB_COMMS_
63 #endif
64
65 int ft2232_execute_queue(void);
66
67 int ft2232_speed(int speed);
68 int ft2232_register_commands(struct command_context_s *cmd_ctx);
69 int ft2232_init(void);
70 int ft2232_quit(void);
71
72 int ft2232_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
73 int ft2232_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
74 int ft2232_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
75 int ft2232_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
76 int ft2232_handle_latency_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
77
78 char *ft2232_device_desc = NULL;
79 char *ft2232_serial = NULL;
80 char *ft2232_layout = NULL;
81 unsigned char ft2232_latency = 2;
82
83 #define MAX_USB_IDS 8
84 /* vid = pid = 0 marks the end of the list */
85 static u16 ft2232_vid[MAX_USB_IDS+1] = { 0x0403, 0 };
86 static u16 ft2232_pid[MAX_USB_IDS+1] = { 0x6010, 0 };
87
88 typedef struct ft2232_layout_s
89 {
90 char* name;
91 int(*init)(void);
92 void(*reset)(int trst, int srst);
93 void(*blink)(void);
94 } ft2232_layout_t;
95
96 /* init procedures for supported layouts */
97 int usbjtag_init(void);
98 int jtagkey_init(void);
99 int olimex_jtag_init(void);
100 int flyswatter_init(void);
101 int turtle_init(void);
102 int comstick_init(void);
103 int stm32stick_init(void);
104
105 /* reset procedures for supported layouts */
106 void usbjtag_reset(int trst, int srst);
107 void jtagkey_reset(int trst, int srst);
108 void olimex_jtag_reset(int trst, int srst);
109 void flyswatter_reset(int trst, int srst);
110 void turtle_reset(int trst, int srst);
111 void comstick_reset(int trst, int srst);
112 void stm32stick_reset(int trst, int srst);
113
114 /* blink procedures for layouts that support a blinking led */
115 void olimex_jtag_blink(void);
116 void turtle_jtag_blink(void);
117
118 ft2232_layout_t ft2232_layouts[] =
119 {
120 {"usbjtag", usbjtag_init, usbjtag_reset, NULL},
121 {"jtagkey", jtagkey_init, jtagkey_reset, NULL},
122 {"jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL},
123 {"oocdlink", jtagkey_init, jtagkey_reset, NULL},
124 {"signalyzer", usbjtag_init, usbjtag_reset, NULL},
125 {"evb_lm3s811", usbjtag_init, usbjtag_reset, NULL},
126 {"olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink},
127 {"flyswatter", flyswatter_init, flyswatter_reset, NULL},
128 {"turtelizer2", turtle_init, turtle_reset, turtle_jtag_blink},
129 {"comstick", comstick_init, comstick_reset, NULL},
130 {"stm32stick", stm32stick_init, stm32stick_reset, NULL},
131 {NULL, NULL, NULL},
132 };
133
134 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
135
136 static ft2232_layout_t *layout;
137 static u8 low_output = 0x0;
138 static u8 low_direction = 0x0;
139 static u8 high_output = 0x0;
140 static u8 high_direction = 0x0;
141
142 #if BUILD_FT2232_FTD2XX == 1
143 static FT_HANDLE ftdih = NULL;
144 #elif BUILD_FT2232_LIBFTDI == 1
145 static struct ftdi_context ftdic;
146 #endif
147
148 static u8 *ft2232_buffer = NULL;
149 static int ft2232_buffer_size = 0;
150 static int ft2232_read_pointer = 0;
151 static int ft2232_expect_read = 0;
152 #define FT2232_BUFFER_SIZE 131072
153 #define BUFFER_ADD ft2232_buffer[ft2232_buffer_size++]
154 #define BUFFER_READ ft2232_buffer[ft2232_read_pointer++]
155
156 jtag_interface_t ft2232_interface =
157 {
158
159 .name = "ft2232",
160
161 .execute_queue = ft2232_execute_queue,
162
163 .support_pathmove = 1,
164
165 .speed = ft2232_speed,
166 .register_commands = ft2232_register_commands,
167 .init = ft2232_init,
168 .quit = ft2232_quit,
169 };
170
171 int ft2232_write(u8 *buf, int size, u32* bytes_written)
172 {
173 #if BUILD_FT2232_FTD2XX == 1
174 FT_STATUS status;
175 DWORD dw_bytes_written;
176 if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
177 {
178 *bytes_written = dw_bytes_written;
179 ERROR("FT_Write returned: %lu", status);
180 return ERROR_JTAG_DEVICE_ERROR;
181 }
182 else
183 {
184 *bytes_written = dw_bytes_written;
185 return ERROR_OK;
186 }
187 #elif BUILD_FT2232_LIBFTDI == 1
188 int retval;
189 if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
190 {
191 *bytes_written = 0;
192 ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
193 return ERROR_JTAG_DEVICE_ERROR;
194 }
195 else
196 {
197 *bytes_written = retval;
198 return ERROR_OK;
199 }
200 #endif
201 }
202
203 int ft2232_read(u8* buf, int size, u32* bytes_read)
204 {
205 #if BUILD_FT2232_FTD2XX == 1
206 DWORD dw_bytes_read;
207 FT_STATUS status;
208 int timeout = 5;
209 *bytes_read = 0;
210
211 while ((*bytes_read < size) && timeout--)
212 {
213 if ((status = FT_Read(ftdih, buf + *bytes_read, size -
214 *bytes_read, &dw_bytes_read)) != FT_OK)
215 {
216 *bytes_read = 0;
217 ERROR("FT_Read returned: %lu", status);
218 return ERROR_JTAG_DEVICE_ERROR;
219 }
220 *bytes_read += dw_bytes_read;
221 }
222 #elif BUILD_FT2232_LIBFTDI == 1
223 int retval;
224 int timeout = 100;
225 *bytes_read = 0;
226
227 while ((*bytes_read < size) && timeout--)
228 {
229 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
230 {
231 *bytes_read = 0;
232 ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
233 return ERROR_JTAG_DEVICE_ERROR;
234 }
235 *bytes_read += retval;
236 }
237 #endif
238
239 if (*bytes_read < size)
240 {
241 ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read, size);
242 return ERROR_JTAG_DEVICE_ERROR;
243 }
244
245 return ERROR_OK;
246 }
247
248 int ft2232_speed(int speed)
249 {
250 u8 buf[3];
251 int retval;
252 u32 bytes_written;
253
254 buf[0] = 0x86; /* command "set divisor" */
255 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=2.0MHz, ...*/
256 buf[2] = (speed >> 8) & 0xff; /* valueH */
257
258 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
259 if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
260 {
261 ERROR("couldn't set FT2232 TCK speed");
262 return retval;
263 }
264
265 jtag_speed = speed;
266
267 return ERROR_OK;
268 }
269
270 int ft2232_register_commands(struct command_context_s *cmd_ctx)
271 {
272 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
273 COMMAND_CONFIG, NULL);
274 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
275 COMMAND_CONFIG, NULL);
276 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
277 COMMAND_CONFIG, NULL);
278 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
279 COMMAND_CONFIG, NULL);
280 register_command(cmd_ctx, NULL, "ft2232_latency", ft2232_handle_latency_command,
281 COMMAND_CONFIG, NULL);
282 return ERROR_OK;
283 }
284
285 void ft2232_end_state(enum tap_state state)
286 {
287 if (tap_move_map[state] != -1)
288 end_state = state;
289 else
290 {
291 ERROR("BUG: %i is not a valid end state", state);
292 exit(-1);
293 }
294 }
295
296 void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size)
297 {
298 int num_bytes = ((scan_size + 7) / 8);
299 int bits_left = scan_size;
300 int cur_byte = 0;
301
302 while(num_bytes-- > 1)
303 {
304 buffer[cur_byte] = BUFFER_READ;
305 cur_byte++;
306 bits_left -= 8;
307 }
308
309 buffer[cur_byte] = 0x0;
310
311 if (bits_left > 1)
312 {
313 buffer[cur_byte] = BUFFER_READ >> 1;
314 }
315
316 buffer[cur_byte] = (buffer[cur_byte] | ((BUFFER_READ & 0x02) << 6)) >> (8 - bits_left);
317
318 }
319
320 void ft2232_debug_dump_buffer(void)
321 {
322 int i;
323 char line[256];
324 char *line_p = line;
325
326 for (i = 0; i < ft2232_buffer_size; i++)
327 {
328 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
329 if (i % 16 == 15)
330 {
331 DEBUG("%s", line);
332 line_p = line;
333 }
334 }
335
336 if (line_p != line)
337 DEBUG("%s", line);
338 }
339
340 int ft2232_send_and_recv(jtag_command_t *first, jtag_command_t *last)
341 {
342 jtag_command_t *cmd;
343 u8 *buffer;
344 int scan_size;
345 enum scan_type type;
346 int retval;
347 u32 bytes_written;
348 u32 bytes_read;
349
350 #ifdef _DEBUG_USB_IO_
351 struct timeval start, inter, inter2, end;
352 struct timeval d_inter, d_inter2, d_end;
353 #endif
354
355 #ifdef _DEBUG_USB_COMMS_
356 DEBUG("write buffer (size %i):", ft2232_buffer_size);
357 ft2232_debug_dump_buffer();
358 #endif
359
360 #ifdef _DEBUG_USB_IO_
361 gettimeofday(&start, NULL);
362 #endif
363
364 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
365 {
366 ERROR("couldn't write MPSSE commands to FT2232");
367 exit(-1);
368 }
369
370 #ifdef _DEBUG_USB_IO_
371 gettimeofday(&inter, NULL);
372 #endif
373
374 if (ft2232_expect_read)
375 {
376 int timeout = 100;
377 ft2232_buffer_size = 0;
378
379 #ifdef _DEBUG_USB_IO_
380 gettimeofday(&inter2, NULL);
381 #endif
382
383 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
384 {
385 ERROR("couldn't read from FT2232");
386 exit(-1);
387 }
388
389 #ifdef _DEBUG_USB_IO_
390 gettimeofday(&end, NULL);
391
392 timeval_subtract(&d_inter, &inter, &start);
393 timeval_subtract(&d_inter2, &inter2, &start);
394 timeval_subtract(&d_end, &end, &start);
395
396 INFO("inter: %i.%i, inter2: %i.%i end: %i.%i", d_inter.tv_sec, d_inter.tv_usec, d_inter2.tv_sec, d_inter2.tv_usec, d_end.tv_sec, d_end.tv_usec);
397 #endif
398
399
400 ft2232_buffer_size = bytes_read;
401
402 if (ft2232_expect_read != ft2232_buffer_size)
403 {
404 ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read, ft2232_buffer_size, 100 - timeout);
405 ft2232_debug_dump_buffer();
406
407 exit(-1);
408 }
409
410 #ifdef _DEBUG_USB_COMMS_
411 DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
412 ft2232_debug_dump_buffer();
413 #endif
414 }
415
416 ft2232_expect_read = 0;
417 ft2232_read_pointer = 0;
418
419 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
420 * that wasn't handled by a caller-provided error handler
421 */
422 retval = ERROR_OK;
423
424 cmd = first;
425 while (cmd != last)
426 {
427 switch (cmd->type)
428 {
429 case JTAG_SCAN:
430 type = jtag_scan_type(cmd->cmd.scan);
431 if (type != SCAN_OUT)
432 {
433 scan_size = jtag_scan_size(cmd->cmd.scan);
434 buffer = calloc(CEIL(scan_size, 8), 1);
435 ft2232_read_scan(type, buffer, scan_size);
436 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
437 retval = ERROR_JTAG_QUEUE_FAILED;
438 free(buffer);
439 }
440 break;
441 default:
442 break;
443 }
444 cmd = cmd->next;
445 }
446
447 ft2232_buffer_size = 0;
448
449 return retval;
450 }
451
452 void ft2232_add_pathmove(pathmove_command_t *cmd)
453 {
454 int num_states = cmd->num_states;
455 u8 tms_byte;
456 int state_count;
457
458 state_count = 0;
459 while (num_states)
460 {
461 tms_byte = 0x0;
462 int bit_count = 0;
463
464 /* command "Clock Data to TMS/CS Pin (no Read)" */
465 BUFFER_ADD = 0x4b;
466 /* number of states remaining */
467 BUFFER_ADD = (num_states % 7) - 1;
468
469 while (num_states % 7)
470 {
471 if (tap_transitions[cur_state].low == cmd->path[state_count])
472 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
473 else if (tap_transitions[cur_state].high == cmd->path[state_count])
474 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
475 else
476 {
477 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
478 exit(-1);
479 }
480
481 cur_state = cmd->path[state_count];
482 state_count++;
483 num_states--;
484 }
485
486 BUFFER_ADD = tms_byte;
487 }
488
489 end_state = cur_state;
490 }
491
492 void ft2232_add_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
493 {
494 int num_bytes = (scan_size + 7) / 8;
495 int bits_left = scan_size;
496 int cur_byte = 0;
497 int last_bit;
498
499 if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
500 {
501 /* command "Clock Data to TMS/CS Pin (no Read)" */
502 BUFFER_ADD = 0x4b;
503 /* scan 7 bit */
504 BUFFER_ADD = 0x6;
505 /* TMS data bits */
506 if (ir_scan)
507 {
508 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SI);
509 cur_state = TAP_SI;
510 }
511 else
512 {
513 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SD);
514 cur_state = TAP_SD;
515 }
516 //DEBUG("added TMS scan (no read)");
517 }
518
519 /* add command for complete bytes */
520 while (num_bytes > 1)
521 {
522 int thisrun_bytes;
523 if (type == SCAN_IO)
524 {
525 /* Clock Data Bytes In and Out LSB First */
526 BUFFER_ADD = 0x39;
527 //DEBUG("added TDI bytes (io %i)", num_bytes);
528 }
529 else if (type == SCAN_OUT)
530 {
531 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
532 BUFFER_ADD = 0x19;
533 //DEBUG("added TDI bytes (o)");
534 }
535 else if (type == SCAN_IN)
536 {
537 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
538 BUFFER_ADD = 0x28;
539 //DEBUG("added TDI bytes (i %i)", num_bytes);
540 }
541 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
542 num_bytes -= thisrun_bytes;
543 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
544 BUFFER_ADD = ((thisrun_bytes - 1) >> 8) & 0xff;
545 if (type != SCAN_IN)
546 {
547 /* add complete bytes */
548 while(thisrun_bytes-- > 0)
549 {
550 BUFFER_ADD = buffer[cur_byte];
551 cur_byte++;
552 bits_left -= 8;
553 }
554 }
555 else /* (type == SCAN_IN) */
556 {
557 bits_left -= 8 * (thisrun_bytes);
558 }
559 }
560
561 /* the most signifcant bit is scanned during TAP movement */
562 if (type != SCAN_IN)
563 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
564 else
565 last_bit = 0;
566
567 /* process remaining bits but the last one */
568 if (bits_left > 1)
569 {
570 if (type == SCAN_IO)
571 {
572 /* Clock Data Bits In and Out LSB First */
573 BUFFER_ADD = 0x3b;
574 //DEBUG("added TDI bits (io) %i", bits_left - 1);
575 }
576 else if (type == SCAN_OUT)
577 {
578 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
579 BUFFER_ADD = 0x1b;
580 //DEBUG("added TDI bits (o)");
581 }
582 else if (type == SCAN_IN)
583 {
584 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
585 BUFFER_ADD = 0x2a;
586 //DEBUG("added TDI bits (i %i)", bits_left - 1);
587 }
588 BUFFER_ADD = bits_left - 2;
589 if (type != SCAN_IN)
590 BUFFER_ADD = buffer[cur_byte];
591 }
592
593 if ((ir_scan && (end_state == TAP_SI)) ||
594 (!ir_scan && (end_state == TAP_SD)))
595 {
596 if (type == SCAN_IO)
597 {
598 /* Clock Data Bits In and Out LSB First */
599 BUFFER_ADD = 0x3b;
600 //DEBUG("added TDI bits (io) %i", bits_left - 1);
601 }
602 else if (type == SCAN_OUT)
603 {
604 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
605 BUFFER_ADD = 0x1b;
606 //DEBUG("added TDI bits (o)");
607 }
608 else if (type == SCAN_IN)
609 {
610 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
611 BUFFER_ADD = 0x2a;
612 //DEBUG("added TDI bits (i %i)", bits_left - 1);
613 }
614 BUFFER_ADD = 0x0;
615 BUFFER_ADD = last_bit;
616 }
617 else
618 {
619 /* move from Shift-IR/DR to end state */
620 if (type != SCAN_OUT)
621 {
622 /* Clock Data to TMS/CS Pin with Read */
623 BUFFER_ADD = 0x6b;
624 //DEBUG("added TMS scan (read)");
625 }
626 else
627 {
628 /* Clock Data to TMS/CS Pin (no Read) */
629 BUFFER_ADD = 0x4b;
630 //DEBUG("added TMS scan (no read)");
631 }
632 BUFFER_ADD = 0x6;
633 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
634 cur_state = end_state;
635 }
636 }
637
638 int ft2232_large_scan(scan_command_t *cmd, enum scan_type type, u8 *buffer, int scan_size)
639 {
640 int num_bytes = (scan_size + 7) / 8;
641 int bits_left = scan_size;
642 int cur_byte = 0;
643 int last_bit;
644 u8 *receive_buffer = malloc(CEIL(scan_size, 8));
645 u8 *receive_pointer = receive_buffer;
646 u32 bytes_written;
647 u32 bytes_read;
648 int retval;
649 int thisrun_read = 0;
650
651 if (cmd->ir_scan)
652 {
653 ERROR("BUG: large IR scans are not supported");
654 exit(-1);
655 }
656
657 if (cur_state != TAP_SD)
658 {
659 /* command "Clock Data to TMS/CS Pin (no Read)" */
660 BUFFER_ADD = 0x4b;
661 /* scan 7 bit */
662 BUFFER_ADD = 0x6;
663 /* TMS data bits */
664 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SD);
665 cur_state = TAP_SD;
666 }
667
668 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
669 {
670 ERROR("couldn't write MPSSE commands to FT2232");
671 exit(-1);
672 }
673 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
674 ft2232_buffer_size = 0;
675
676 /* add command for complete bytes */
677 while (num_bytes > 1)
678 {
679 int thisrun_bytes;
680
681 if (type == SCAN_IO)
682 {
683 /* Clock Data Bytes In and Out LSB First */
684 BUFFER_ADD = 0x39;
685 //DEBUG("added TDI bytes (io %i)", num_bytes);
686 }
687 else if (type == SCAN_OUT)
688 {
689 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
690 BUFFER_ADD = 0x19;
691 //DEBUG("added TDI bytes (o)");
692 }
693 else if (type == SCAN_IN)
694 {
695 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
696 BUFFER_ADD = 0x28;
697 //DEBUG("added TDI bytes (i %i)", num_bytes);
698 }
699 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
700 thisrun_read = thisrun_bytes;
701 num_bytes -= thisrun_bytes;
702 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
703 BUFFER_ADD = ((thisrun_bytes - 1) >> 8) & 0xff;
704 if (type != SCAN_IN)
705 {
706 /* add complete bytes */
707 while(thisrun_bytes-- > 0)
708 {
709 BUFFER_ADD = buffer[cur_byte];
710 cur_byte++;
711 bits_left -= 8;
712 }
713 }
714 else /* (type == SCAN_IN) */
715 {
716 bits_left -= 8 * (thisrun_bytes);
717 }
718
719 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
720 {
721 ERROR("couldn't write MPSSE commands to FT2232");
722 exit(-1);
723 }
724 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
725 ft2232_buffer_size = 0;
726
727 if (type != SCAN_OUT)
728 {
729 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
730 {
731 ERROR("couldn't read from FT2232");
732 exit(-1);
733 }
734 DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
735 receive_pointer += bytes_read;
736 }
737 }
738
739 thisrun_read = 0;
740
741 /* the most signifcant bit is scanned during TAP movement */
742 if (type != SCAN_IN)
743 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
744 else
745 last_bit = 0;
746
747 /* process remaining bits but the last one */
748 if (bits_left > 1)
749 {
750 if (type == SCAN_IO)
751 {
752 /* Clock Data Bits In and Out LSB First */
753 BUFFER_ADD = 0x3b;
754 //DEBUG("added TDI bits (io) %i", bits_left - 1);
755 }
756 else if (type == SCAN_OUT)
757 {
758 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
759 BUFFER_ADD = 0x1b;
760 //DEBUG("added TDI bits (o)");
761 }
762 else if (type == SCAN_IN)
763 {
764 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
765 BUFFER_ADD = 0x2a;
766 //DEBUG("added TDI bits (i %i)", bits_left - 1);
767 }
768 BUFFER_ADD = bits_left - 2;
769 if (type != SCAN_IN)
770 BUFFER_ADD = buffer[cur_byte];
771
772 if (type != SCAN_OUT)
773 thisrun_read += 2;
774 }
775
776 if (end_state == TAP_SD)
777 {
778 if (type == SCAN_IO)
779 {
780 /* Clock Data Bits In and Out LSB First */
781 BUFFER_ADD = 0x3b;
782 //DEBUG("added TDI bits (io) %i", bits_left - 1);
783 }
784 else if (type == SCAN_OUT)
785 {
786 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
787 BUFFER_ADD = 0x1b;
788 //DEBUG("added TDI bits (o)");
789 }
790 else if (type == SCAN_IN)
791 {
792 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
793 BUFFER_ADD = 0x2a;
794 //DEBUG("added TDI bits (i %i)", bits_left - 1);
795 }
796 BUFFER_ADD = 0x0;
797 BUFFER_ADD = last_bit;
798 }
799 else
800 {
801 /* move from Shift-IR/DR to end state */
802 if (type != SCAN_OUT)
803 {
804 /* Clock Data to TMS/CS Pin with Read */
805 BUFFER_ADD = 0x6b;
806 //DEBUG("added TMS scan (read)");
807 }
808 else
809 {
810 /* Clock Data to TMS/CS Pin (no Read) */
811 BUFFER_ADD = 0x4b;
812 //DEBUG("added TMS scan (no read)");
813 }
814 BUFFER_ADD = 0x6;
815 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
816 cur_state = end_state;
817 }
818
819 if (type != SCAN_OUT)
820 thisrun_read += 1;
821
822 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
823 {
824 ERROR("couldn't write MPSSE commands to FT2232");
825 exit(-1);
826 }
827 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
828 ft2232_buffer_size = 0;
829
830 if (type != SCAN_OUT)
831 {
832 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
833 {
834 ERROR("couldn't read from FT2232");
835 exit(-1);
836 }
837 DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
838 receive_pointer += bytes_read;
839 }
840
841 return ERROR_OK;
842 }
843
844 int ft2232_predict_scan_out(int scan_size, enum scan_type type)
845 {
846 int predicted_size = 3;
847 int num_bytes = (scan_size - 1) / 8;
848
849 if (cur_state != TAP_SD)
850 predicted_size += 3;
851
852 if (type == SCAN_IN) /* only from device to host */
853 {
854 /* complete bytes */
855 predicted_size += (CEIL(num_bytes, 65536)) * 3;
856 /* remaining bits - 1 (up to 7) */
857 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
858 }
859 else /* host to device, or bidirectional */
860 {
861 /* complete bytes */
862 predicted_size += num_bytes + (CEIL(num_bytes, 65536)) * 3;
863 /* remaining bits -1 (up to 7) */
864 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
865 }
866
867 return predicted_size;
868 }
869
870 int ft2232_predict_scan_in(int scan_size, enum scan_type type)
871 {
872 int predicted_size = 0;
873
874 if (type != SCAN_OUT)
875 {
876 /* complete bytes */
877 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
878 /* remaining bits - 1 */
879 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
880 /* last bit (from TMS scan) */
881 predicted_size += 1;
882 }
883
884 //DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size);
885
886 return predicted_size;
887 }
888
889 void usbjtag_reset(int trst, int srst)
890 {
891 if (trst == 1)
892 {
893 cur_state = TAP_TLR;
894 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
895 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
896 else
897 low_output &= ~nTRST; /* switch output low */
898 }
899 else if (trst == 0)
900 {
901 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
902 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
903 else
904 low_output |= nTRST; /* switch output high */
905 }
906
907 if (srst == 1)
908 {
909 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
910 low_output &= ~nSRST; /* switch output low */
911 else
912 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
913 }
914 else if (srst == 0)
915 {
916 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
917 low_output |= nSRST; /* switch output high */
918 else
919 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
920 }
921
922 /* command "set data bits low byte" */
923 BUFFER_ADD = 0x80;
924 BUFFER_ADD = low_output;
925 BUFFER_ADD = low_direction;
926
927 }
928
929 void jtagkey_reset(int trst, int srst)
930 {
931 if (trst == 1)
932 {
933 cur_state = TAP_TLR;
934 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
935 high_output &= ~nTRSTnOE;
936 else
937 high_output &= ~nTRST;
938 }
939 else if (trst == 0)
940 {
941 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
942 high_output |= nTRSTnOE;
943 else
944 high_output |= nTRST;
945 }
946
947 if (srst == 1)
948 {
949 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
950 high_output &= ~nSRST;
951 else
952 high_output &= ~nSRSTnOE;
953 }
954 else if (srst == 0)
955 {
956 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
957 high_output |= nSRST;
958 else
959 high_output |= nSRSTnOE;
960 }
961
962 /* command "set data bits high byte" */
963 BUFFER_ADD = 0x82;
964 BUFFER_ADD = high_output;
965 BUFFER_ADD = high_direction;
966 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
967 }
968
969 void olimex_jtag_reset(int trst, int srst)
970 {
971 if (trst == 1)
972 {
973 cur_state = TAP_TLR;
974 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
975 high_output &= ~nTRSTnOE;
976 else
977 high_output &= ~nTRST;
978 }
979 else if (trst == 0)
980 {
981 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
982 high_output |= nTRSTnOE;
983 else
984 high_output |= nTRST;
985 }
986
987 if (srst == 1)
988 {
989 high_output |= nSRST;
990 }
991 else if (srst == 0)
992 {
993 high_output &= ~nSRST;
994 }
995
996 /* command "set data bits high byte" */
997 BUFFER_ADD = 0x82;
998 BUFFER_ADD = high_output;
999 BUFFER_ADD = high_direction;
1000 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1001 }
1002
1003 void flyswatter_reset(int trst, int srst)
1004 {
1005 if (trst == 1)
1006 {
1007 cur_state = TAP_TLR;
1008 low_output &= ~nTRST;
1009 }
1010 else if (trst == 0)
1011 {
1012 low_output |= nTRST;
1013 }
1014
1015 if (srst == 1)
1016 {
1017 low_output |= nSRST;
1018 }
1019 else if (srst == 0)
1020 {
1021 low_output &= ~nSRST;
1022 }
1023
1024 /* command "set data bits low byte" */
1025 BUFFER_ADD = 0x80;
1026 BUFFER_ADD = low_output;
1027 BUFFER_ADD = low_direction;
1028 DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction);
1029 }
1030
1031 void turtle_reset(int trst, int srst)
1032 {
1033 trst = trst;
1034
1035 if (srst == 1)
1036 {
1037 low_output |= nSRST;
1038 }
1039 else if (srst == 0)
1040 {
1041 low_output &= ~nSRST;
1042 }
1043
1044 /* command "set data bits low byte" */
1045 BUFFER_ADD = 0x80;
1046 BUFFER_ADD = low_output;
1047 BUFFER_ADD = low_direction;
1048 DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction);
1049 }
1050
1051 void comstick_reset(int trst, int srst)
1052 {
1053 if (trst == 1)
1054 {
1055 cur_state = TAP_TLR;
1056 high_output &= ~nTRST;
1057 }
1058 else if (trst == 0)
1059 {
1060 high_output |= nTRST;
1061 }
1062
1063 if (srst == 1)
1064 {
1065 high_output &= ~nSRST;
1066 }
1067 else if (srst == 0)
1068 {
1069 high_output |= nSRST;
1070 }
1071
1072 /* command "set data bits high byte" */
1073 BUFFER_ADD = 0x82;
1074 BUFFER_ADD = high_output;
1075 BUFFER_ADD = high_direction;
1076 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1077 }
1078
1079 void stm32stick_reset(int trst, int srst)
1080 {
1081 if (trst == 1)
1082 {
1083 cur_state = TAP_TLR;
1084 high_output &= ~nTRST;
1085 }
1086 else if (trst == 0)
1087 {
1088 high_output |= nTRST;
1089 }
1090
1091 if (srst == 1)
1092 {
1093 low_output &= ~nSRST;
1094 }
1095 else if (srst == 0)
1096 {
1097 low_output |= nSRST;
1098 }
1099
1100 /* command "set data bits low byte" */
1101 BUFFER_ADD = 0x80;
1102 BUFFER_ADD = low_output;
1103 BUFFER_ADD = low_direction;
1104
1105 /* command "set data bits high byte" */
1106 BUFFER_ADD = 0x82;
1107 BUFFER_ADD = high_output;
1108 BUFFER_ADD = high_direction;
1109 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1110 }
1111
1112 int ft2232_execute_queue()
1113 {
1114 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
1115 jtag_command_t *first_unsent = cmd; /* next command that has to be sent */
1116 u8 *buffer;
1117 int scan_size; /* size of IR or DR scan */
1118 enum scan_type type;
1119 int i;
1120 int predicted_size = 0;
1121 int require_send = 0;
1122 int retval;
1123
1124 /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check
1125 * that wasn't handled by a caller-provided error handler
1126 */
1127 retval = ERROR_OK;
1128
1129 ft2232_buffer_size = 0;
1130 ft2232_expect_read = 0;
1131
1132 /* blink, if the current layout has that feature */
1133 if (layout->blink)
1134 layout->blink();
1135
1136 while (cmd)
1137 {
1138 switch(cmd->type)
1139 {
1140 case JTAG_END_STATE:
1141 if (cmd->cmd.end_state->end_state != -1)
1142 ft2232_end_state(cmd->cmd.end_state->end_state);
1143 break;
1144 case JTAG_RESET:
1145 /* only send the maximum buffer size that FT2232C can handle */
1146 predicted_size = 3;
1147 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1148 {
1149 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1150 retval = ERROR_JTAG_QUEUE_FAILED;
1151 require_send = 0;
1152 first_unsent = cmd;
1153 }
1154
1155 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1156 require_send = 1;
1157
1158 #ifdef _DEBUG_JTAG_IO_
1159 DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1160 #endif
1161 break;
1162 case JTAG_RUNTEST:
1163 /* only send the maximum buffer size that FT2232C can handle */
1164 predicted_size = 0;
1165 if (cur_state != TAP_RTI)
1166 predicted_size += 3;
1167 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1168 if ((cmd->cmd.runtest->end_state != -1) && (cmd->cmd.runtest->end_state != TAP_RTI))
1169 predicted_size += 3;
1170 if ((cmd->cmd.runtest->end_state == -1) && (end_state != TAP_RTI))
1171 predicted_size += 3;
1172 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1173 {
1174 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1175 retval = ERROR_JTAG_QUEUE_FAILED;
1176 require_send = 0;
1177 first_unsent = cmd;
1178 }
1179 if (cur_state != TAP_RTI)
1180 {
1181 /* command "Clock Data to TMS/CS Pin (no Read)" */
1182 BUFFER_ADD = 0x4b;
1183 /* scan 7 bit */
1184 BUFFER_ADD = 0x6;
1185 /* TMS data bits */
1186 BUFFER_ADD = TAP_MOVE(cur_state, TAP_RTI);
1187 cur_state = TAP_RTI;
1188 require_send = 1;
1189 }
1190 i = cmd->cmd.runtest->num_cycles;
1191 while (i > 0)
1192 {
1193 /* command "Clock Data to TMS/CS Pin (no Read)" */
1194 BUFFER_ADD = 0x4b;
1195 /* scan 7 bit */
1196 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
1197 /* TMS data bits */
1198 BUFFER_ADD = 0x0;
1199 cur_state = TAP_RTI;
1200 i -= (i > 7) ? 7 : i;
1201 //DEBUG("added TMS scan (no read)");
1202 }
1203 if (cmd->cmd.runtest->end_state != -1)
1204 ft2232_end_state(cmd->cmd.runtest->end_state);
1205 if (cur_state != end_state)
1206 {
1207 /* command "Clock Data to TMS/CS Pin (no Read)" */
1208 BUFFER_ADD = 0x4b;
1209 /* scan 7 bit */
1210 BUFFER_ADD = 0x6;
1211 /* TMS data bits */
1212 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
1213 cur_state = end_state;
1214 //DEBUG("added TMS scan (no read)");
1215 }
1216 require_send = 1;
1217 #ifdef _DEBUG_JTAG_IO_
1218 DEBUG("runtest: %i, end in %i", cmd->cmd.runtest->num_cycles, end_state);
1219 #endif
1220 break;
1221 case JTAG_STATEMOVE:
1222 /* only send the maximum buffer size that FT2232C can handle */
1223 predicted_size = 3;
1224 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1225 {
1226 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1227 retval = ERROR_JTAG_QUEUE_FAILED;
1228 require_send = 0;
1229 first_unsent = cmd;
1230 }
1231 if (cmd->cmd.statemove->end_state != -1)
1232 ft2232_end_state(cmd->cmd.statemove->end_state);
1233 /* command "Clock Data to TMS/CS Pin (no Read)" */
1234 BUFFER_ADD = 0x4b;
1235 /* scan 7 bit */
1236 BUFFER_ADD = 0x6;
1237 /* TMS data bits */
1238 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
1239 //DEBUG("added TMS scan (no read)");
1240 cur_state = end_state;
1241 require_send = 1;
1242 #ifdef _DEBUG_JTAG_IO_
1243 DEBUG("statemove: %i", end_state);
1244 #endif
1245 break;
1246 case JTAG_PATHMOVE:
1247 /* only send the maximum buffer size that FT2232C can handle */
1248 predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7);
1249 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1250 {
1251 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1252 retval = ERROR_JTAG_QUEUE_FAILED;
1253 require_send = 0;
1254 first_unsent = cmd;
1255 }
1256 ft2232_add_pathmove(cmd->cmd.pathmove);
1257 require_send = 1;
1258 #ifdef _DEBUG_JTAG_IO_
1259 DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1260 #endif
1261 break;
1262 case JTAG_SCAN:
1263 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1264 type = jtag_scan_type(cmd->cmd.scan);
1265 predicted_size = ft2232_predict_scan_out(scan_size, type);
1266 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1267 {
1268 DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1269 /* unsent commands before this */
1270 if (first_unsent != cmd)
1271 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1272 retval = ERROR_JTAG_QUEUE_FAILED;
1273
1274 /* current command */
1275 if (cmd->cmd.scan->end_state != -1)
1276 ft2232_end_state(cmd->cmd.scan->end_state);
1277 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1278 require_send = 0;
1279 first_unsent = cmd->next;
1280 if (buffer)
1281 free(buffer);
1282 break;
1283 }
1284 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1285 {
1286 DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)", first_unsent, cmd);
1287 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1288 retval = ERROR_JTAG_QUEUE_FAILED;
1289 require_send = 0;
1290 first_unsent = cmd;
1291 }
1292 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1293 //DEBUG("new read size: %i", ft2232_expect_read);
1294 if (cmd->cmd.scan->end_state != -1)
1295 ft2232_end_state(cmd->cmd.scan->end_state);
1296 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1297 require_send = 1;
1298 if (buffer)
1299 free(buffer);
1300 #ifdef _DEBUG_JTAG_IO_
1301 DEBUG("%s scan, %i bit, end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, end_state);
1302 #endif
1303 break;
1304 case JTAG_SLEEP:
1305 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1306 retval = ERROR_JTAG_QUEUE_FAILED;
1307 first_unsent = cmd->next;
1308 jtag_sleep(cmd->cmd.sleep->us);
1309 #ifdef _DEBUG_JTAG_IO_
1310 DEBUG("sleep %i usec", cmd->cmd.sleep->us);
1311 #endif
1312 break;
1313 default:
1314 ERROR("BUG: unknown JTAG command type encountered");
1315 exit(-1);
1316 }
1317 cmd = cmd->next;
1318 }
1319
1320 if (require_send > 0)
1321 if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
1322 retval = ERROR_JTAG_QUEUE_FAILED;
1323
1324 return retval;
1325 }
1326
1327 #if BUILD_FT2232_FTD2XX == 1
1328 static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int *try_more)
1329 {
1330 FT_STATUS status;
1331 DWORD openex_flags = 0;
1332 char *openex_string = NULL;
1333 u8 latency_timer;
1334
1335 DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)",
1336 ft2232_layout, vid, pid);
1337
1338 #if IS_WIN32 == 0
1339 /* Add non-standard Vid/Pid to the linux driver */
1340 if ((status = FT_SetVIDPID(vid, pid)) != FT_OK)
1341 {
1342 WARNING("couldn't add %4.4x:%4.4x",
1343 vid, pid);
1344 }
1345 #endif
1346
1347 if (ft2232_device_desc && ft2232_serial)
1348 {
1349 WARNING("can't open by device description and serial number, giving precedence to serial");
1350 ft2232_device_desc = NULL;
1351 }
1352
1353 if (ft2232_device_desc)
1354 {
1355 openex_string = ft2232_device_desc;
1356 openex_flags = FT_OPEN_BY_DESCRIPTION;
1357 }
1358 else if (ft2232_serial)
1359 {
1360 openex_string = ft2232_serial;
1361 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1362 }
1363 else
1364 {
1365 ERROR("neither device description nor serial number specified");
1366 ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1367
1368 return ERROR_JTAG_INIT_FAILED;
1369 }
1370
1371 if ((status = FT_OpenEx(openex_string, openex_flags, &ftdih)) != FT_OK)
1372 {
1373 DWORD num_devices;
1374
1375 if (more) {
1376 WARNING("unable to open ftdi device (trying more): %lu",
1377 status);
1378 *try_more = 1;
1379 return ERROR_JTAG_INIT_FAILED;
1380 }
1381 ERROR("unable to open ftdi device: %lu", status);
1382 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1383 if (status == FT_OK)
1384 {
1385 char **desc_array = malloc(sizeof(char*) * (num_devices + 1));
1386 int i;
1387
1388 for (i = 0; i < num_devices; i++)
1389 desc_array[i] = malloc(64);
1390 desc_array[num_devices] = NULL;
1391
1392 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1393
1394 if (status == FT_OK)
1395 {
1396 ERROR("ListDevices: %lu\n", num_devices);
1397 for (i = 0; i < num_devices; i++)
1398 ERROR("%i: %s", i, desc_array[i]);
1399 }
1400
1401 for (i = 0; i < num_devices; i++)
1402 free(desc_array[i]);
1403 free(desc_array);
1404 }
1405 else
1406 {
1407 printf("ListDevices: NONE\n");
1408 }
1409 return ERROR_JTAG_INIT_FAILED;
1410 }
1411
1412 if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK)
1413 {
1414 ERROR("unable to set latency timer: %lu", status);
1415 return ERROR_JTAG_INIT_FAILED;
1416 }
1417
1418 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1419 {
1420 ERROR("unable to get latency timer: %lu", status);
1421 return ERROR_JTAG_INIT_FAILED;
1422 }
1423 else
1424 {
1425 DEBUG("current latency timer: %i", latency_timer);
1426 }
1427
1428 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1429 {
1430 ERROR("unable to set timeouts: %lu", status);
1431 return ERROR_JTAG_INIT_FAILED;
1432 }
1433
1434 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1435 {
1436 ERROR("unable to enable bit i/o mode: %lu", status);
1437 return ERROR_JTAG_INIT_FAILED;
1438 }
1439
1440 return ERROR_OK;
1441 }
1442
1443 static int ft2232_purge_ftd2xx(void)
1444 {
1445 FT_STATUS status;
1446
1447 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1448 {
1449 ERROR("error purging ftd2xx device: %lu", status);
1450 return ERROR_JTAG_INIT_FAILED;
1451 }
1452
1453 return ERROR_OK;
1454 }
1455 #endif /* BUILD_FT2232_FTD2XX == 1 */
1456
1457 #if BUILD_FT2232_LIBFTDI == 1
1458 static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int *try_more)
1459 {
1460 u8 latency_timer;
1461
1462 DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)",
1463 ft2232_layout, vid, pid);
1464
1465 if (ftdi_init(&ftdic) < 0)
1466 return ERROR_JTAG_INIT_FAILED;
1467
1468 /* context, vendor id, product id */
1469 if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc,
1470 ft2232_serial) < 0) {
1471 if (more)
1472 WARNING("unable to open ftdi device (trying more): %s",
1473 ftdic.error_str);
1474 else
1475 ERROR("unable to open ftdi device: %s", ftdic.error_str);
1476 *try_more = 1;
1477 return ERROR_JTAG_INIT_FAILED;
1478 }
1479
1480 if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
1481 {
1482 ERROR("unable to select FT2232 channel A: %s", ftdic.error_str);
1483 return ERROR_JTAG_INIT_FAILED;
1484 }
1485
1486 if (ftdi_usb_reset(&ftdic) < 0)
1487 {
1488 ERROR("unable to reset ftdi device");
1489 return ERROR_JTAG_INIT_FAILED;
1490 }
1491
1492 if (ftdi_set_latency_timer(&ftdic, ft2232_latency) < 0)
1493 {
1494 ERROR("unable to set latency timer");
1495 return ERROR_JTAG_INIT_FAILED;
1496 }
1497
1498 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1499 {
1500 ERROR("unable to get latency timer");
1501 return ERROR_JTAG_INIT_FAILED;
1502 }
1503 else
1504 {
1505 DEBUG("current latency timer: %i", latency_timer);
1506 }
1507
1508 ftdi_set_bitmode(&ftdic, 0x0b, 2); /* ctx, JTAG I/O mask */
1509
1510 return ERROR_OK;
1511 }
1512
1513 static int ft2232_purge_libftdi(void)
1514 {
1515 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1516 {
1517 ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1518 return ERROR_JTAG_INIT_FAILED;
1519 }
1520
1521 return ERROR_OK;
1522 }
1523 #endif /* BUILD_FT2232_LIBFTDI == 1 */
1524
1525 int ft2232_init(void)
1526 {
1527 u8 buf[1];
1528 int retval;
1529 u32 bytes_written;
1530 ft2232_layout_t *cur_layout = ft2232_layouts;
1531 int i;
1532
1533 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
1534 {
1535 ft2232_layout = "usbjtag";
1536 WARNING("No ft2232 layout specified, using default 'usbjtag'");
1537 }
1538
1539 while (cur_layout->name)
1540 {
1541 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1542 {
1543 layout = cur_layout;
1544 break;
1545 }
1546 cur_layout++;
1547 }
1548
1549 if (!layout)
1550 {
1551 ERROR("No matching layout found for %s", ft2232_layout);
1552 return ERROR_JTAG_INIT_FAILED;
1553 }
1554
1555 for (i = 0; 1; i++) {
1556 /*
1557 * "more indicates that there are more IDs to try, so we should
1558 * not print an error for an ID mismatch (but for anything
1559 * else, we should).
1560 *
1561 * try_more indicates that the error code returned indicates an
1562 * ID mismatch (and nothing else) and that we should proceeed
1563 * with the next ID pair.
1564 */
1565 int more = ft2232_vid[i+1] || ft2232_pid[i+1];
1566 int try_more = 0;
1567
1568 #if BUILD_FT2232_FTD2XX == 1
1569 retval = ft2232_init_ftd2xx(ft2232_vid[i], ft2232_pid[i],
1570 more, &try_more);
1571 #elif BUILD_FT2232_LIBFTDI == 1
1572 retval = ft2232_init_libftdi(ft2232_vid[i], ft2232_pid[i],
1573 more, &try_more);
1574 #endif
1575 if (retval >= 0)
1576 break;
1577 if (!more || !try_more)
1578 return retval;
1579 }
1580
1581 ft2232_buffer_size = 0;
1582 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1583
1584 if (layout->init() != ERROR_OK)
1585 return ERROR_JTAG_INIT_FAILED;
1586
1587 ft2232_speed(jtag_speed);
1588
1589 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1590 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
1591 {
1592 ERROR("couldn't write to FT2232 to disable loopback");
1593 return ERROR_JTAG_INIT_FAILED;
1594 }
1595
1596 #if BUILD_FT2232_FTD2XX == 1
1597 return ft2232_purge_ftd2xx();
1598 #elif BUILD_FT2232_LIBFTDI == 1
1599 return ft2232_purge_libftdi();
1600 #endif
1601
1602 return ERROR_OK;
1603 }
1604
1605 int usbjtag_init(void)
1606 {
1607 u8 buf[3];
1608 u32 bytes_written;
1609
1610 low_output = 0x08;
1611 low_direction = 0x0b;
1612
1613 if (strcmp(ft2232_layout, "usbjtag") == 0)
1614 {
1615 nTRST = 0x10;
1616 nTRSTnOE = 0x10;
1617 nSRST = 0x40;
1618 nSRSTnOE = 0x40;
1619 }
1620 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1621 {
1622 nTRST = 0x10;
1623 nTRSTnOE = 0x10;
1624 nSRST = 0x20;
1625 nSRSTnOE = 0x20;
1626 }
1627 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1628 {
1629 nTRST = 0x0;
1630 nTRSTnOE = 0x00;
1631 nSRST = 0x20;
1632 nSRSTnOE = 0x20;
1633 low_output = 0x88;
1634 low_direction = 0x8b;
1635 }
1636 else
1637 {
1638 ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1639 return ERROR_JTAG_INIT_FAILED;
1640 }
1641
1642 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1643 {
1644 low_direction &= ~nTRSTnOE; /* nTRST input */
1645 low_output &= ~nTRST; /* nTRST = 0 */
1646 }
1647 else
1648 {
1649 low_direction |= nTRSTnOE; /* nTRST output */
1650 low_output |= nTRST; /* nTRST = 1 */
1651 }
1652
1653 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1654 {
1655 low_direction |= nSRSTnOE; /* nSRST output */
1656 low_output |= nSRST; /* nSRST = 1 */
1657 }
1658 else
1659 {
1660 low_direction &= ~nSRSTnOE; /* nSRST input */
1661 low_output &= ~nSRST; /* nSRST = 0 */
1662 }
1663
1664 /* initialize low byte for jtag */
1665 buf[0] = 0x80; /* command "set data bits low byte" */
1666 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1667 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1668 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1669
1670 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1671 {
1672 ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1673 return ERROR_JTAG_INIT_FAILED;
1674 }
1675
1676 return ERROR_OK;
1677 }
1678
1679 int jtagkey_init(void)
1680 {
1681 u8 buf[3];
1682 u32 bytes_written;
1683
1684 low_output = 0x08;
1685 low_direction = 0x1b;
1686
1687 /* initialize low byte for jtag */
1688 buf[0] = 0x80; /* command "set data bits low byte" */
1689 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1690 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1691 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1692
1693 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1694 {
1695 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1696 return ERROR_JTAG_INIT_FAILED;
1697 }
1698
1699 if (strcmp(layout->name, "jtagkey") == 0)
1700 {
1701 nTRST = 0x01;
1702 nTRSTnOE = 0x4;
1703 nSRST = 0x02;
1704 nSRSTnOE = 0x08;
1705 }
1706 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0) ||
1707 (strcmp(layout->name, "oocdlink") == 0))
1708 {
1709 nTRST = 0x02;
1710 nTRSTnOE = 0x1;
1711 nSRST = 0x08;
1712 nSRSTnOE = 0x04;
1713 }
1714 else
1715 {
1716 ERROR("BUG: jtagkey_init called for non jtagkey layout");
1717 exit(-1);
1718 }
1719
1720 high_output = 0x0;
1721 high_direction = 0x0f;
1722
1723 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1724 {
1725 high_output |= nTRSTnOE;
1726 high_output &= ~nTRST;
1727 }
1728 else
1729 {
1730 high_output &= ~nTRSTnOE;
1731 high_output |= nTRST;
1732 }
1733
1734 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1735 {
1736 high_output &= ~nSRSTnOE;
1737 high_output |= nSRST;
1738 }
1739 else
1740 {
1741 high_output |= nSRSTnOE;
1742 high_output &= ~nSRST;
1743 }
1744
1745 /* initialize high port */
1746 buf[0] = 0x82; /* command "set data bits high byte" */
1747 buf[1] = high_output; /* value */
1748 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1749 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1750
1751 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1752 {
1753 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1754 return ERROR_JTAG_INIT_FAILED;
1755 }
1756
1757 return ERROR_OK;
1758 }
1759
1760 int olimex_jtag_init(void)
1761 {
1762 u8 buf[3];
1763 u32 bytes_written;
1764
1765 low_output = 0x08;
1766 low_direction = 0x1b;
1767
1768 /* initialize low byte for jtag */
1769 buf[0] = 0x80; /* command "set data bits low byte" */
1770 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1771 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1772 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1773
1774 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1775 {
1776 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1777 return ERROR_JTAG_INIT_FAILED;
1778 }
1779
1780 nTRST = 0x01;
1781 nTRSTnOE = 0x4;
1782 nSRST = 0x02;
1783 nSRSTnOE = 0x00; /* no output enable for nSRST */
1784
1785 high_output = 0x0;
1786 high_direction = 0x0f;
1787
1788 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1789 {
1790 high_output |= nTRSTnOE;
1791 high_output &= ~nTRST;
1792 }
1793 else
1794 {
1795 high_output &= ~nTRSTnOE;
1796 high_output |= nTRST;
1797 }
1798
1799 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1800 {
1801 ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
1802 }
1803 else
1804 {
1805 high_output &= ~nSRST;
1806 }
1807
1808 /* turn red LED on */
1809 high_output |= 0x08;
1810
1811 /* initialize high port */
1812 buf[0] = 0x82; /* command "set data bits high byte" */
1813 buf[1] = high_output; /* value */
1814 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1815 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1816
1817 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1818 {
1819 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1820 return ERROR_JTAG_INIT_FAILED;
1821 }
1822
1823 return ERROR_OK;
1824 }
1825
1826 int flyswatter_init(void)
1827 {
1828 u8 buf[3];
1829 u32 bytes_written;
1830
1831 low_output = 0x18;
1832 low_direction = 0xfb;
1833
1834 /* initialize low byte for jtag */
1835 buf[0] = 0x80; /* command "set data bits low byte" */
1836 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1837 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
1838 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1839
1840 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1841 {
1842 ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
1843 return ERROR_JTAG_INIT_FAILED;
1844 }
1845
1846 nTRST = 0x10;
1847 nTRSTnOE = 0x0; /* not output enable for nTRST */
1848 nSRST = 0x20;
1849 nSRSTnOE = 0x00; /* no output enable for nSRST */
1850
1851 high_output = 0x00;
1852 high_direction = 0x0c;
1853
1854 /* turn red LED1 on, LED2 off */
1855 high_output |= 0x08;
1856
1857 /* initialize high port */
1858 buf[0] = 0x82; /* command "set data bits high byte" */
1859 buf[1] = high_output; /* value */
1860 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1861 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1862
1863 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1864 {
1865 ERROR("couldn't initialize FT2232 with 'flyswatter' layout");
1866 return ERROR_JTAG_INIT_FAILED;
1867 }
1868
1869 return ERROR_OK;
1870 }
1871
1872 int turtle_init(void)
1873 {
1874 u8 buf[3];
1875 u32 bytes_written;
1876
1877 low_output = 0x08;
1878 low_direction = 0x5b;
1879
1880 /* initialize low byte for jtag */
1881 buf[0] = 0x80; /* command "set data bits low byte" */
1882 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1883 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1884 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1885
1886 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1887 {
1888 ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
1889 return ERROR_JTAG_INIT_FAILED;
1890 }
1891
1892 nSRST = 0x40;
1893
1894 high_output = 0x00;
1895 high_direction = 0x0C;
1896
1897 /* initialize high port */
1898 buf[0] = 0x82; /* command "set data bits high byte" */
1899 buf[1] = high_output;
1900 buf[2] = high_direction;
1901 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1902
1903 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1904 {
1905 ERROR("couldn't initialize FT2232 with 'turtelizer2' layout");
1906 return ERROR_JTAG_INIT_FAILED;
1907 }
1908
1909 return ERROR_OK;
1910 }
1911
1912 int comstick_init(void)
1913 {
1914 u8 buf[3];
1915 u32 bytes_written;
1916
1917 low_output = 0x08;
1918 low_direction = 0x0b;
1919
1920 /* initialize low byte for jtag */
1921 buf[0] = 0x80; /* command "set data bits low byte" */
1922 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1923 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1924 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1925
1926 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1927 {
1928 ERROR("couldn't initialize FT2232 with 'comstick' layout");
1929 return ERROR_JTAG_INIT_FAILED;
1930 }
1931
1932 nTRST = 0x01;
1933 nTRSTnOE = 0x00; /* no output enable for nTRST */
1934 nSRST = 0x02;
1935 nSRSTnOE = 0x00; /* no output enable for nSRST */
1936
1937 high_output = 0x03;
1938 high_direction = 0x03;
1939
1940 /* initialize high port */
1941 buf[0] = 0x82; /* command "set data bits high byte" */
1942 buf[1] = high_output;
1943 buf[2] = high_direction;
1944 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1945
1946 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1947 {
1948 ERROR("couldn't initialize FT2232 with 'comstick' layout");
1949 return ERROR_JTAG_INIT_FAILED;
1950 }
1951
1952 return ERROR_OK;
1953 }
1954
1955 int stm32stick_init(void)
1956 {
1957 u8 buf[3];
1958 u32 bytes_written;
1959
1960 low_output = 0x88;
1961 low_direction = 0x8b;
1962
1963 /* initialize low byte for jtag */
1964 buf[0] = 0x80; /* command "set data bits low byte" */
1965 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1966 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1967 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1968
1969 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1970 {
1971 ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
1972 return ERROR_JTAG_INIT_FAILED;
1973 }
1974
1975 nTRST = 0x01;
1976 nTRSTnOE = 0x00; /* no output enable for nTRST */
1977 nSRST = 0x80;
1978 nSRSTnOE = 0x00; /* no output enable for nSRST */
1979
1980 high_output = 0x01;
1981 high_direction = 0x03;
1982
1983 /* initialize high port */
1984 buf[0] = 0x82; /* command "set data bits high byte" */
1985 buf[1] = high_output;
1986 buf[2] = high_direction;
1987 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1988
1989 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1990 {
1991 ERROR("couldn't initialize FT2232 with 'stm32stick' layout");
1992 return ERROR_JTAG_INIT_FAILED;
1993 }
1994
1995 return ERROR_OK;
1996 }
1997
1998 void olimex_jtag_blink(void)
1999 {
2000 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
2001 * ACBUS3 is bit 3 of the GPIOH port
2002 */
2003 if (high_output & 0x08)
2004 {
2005 /* set port pin high */
2006 high_output &= 0x07;
2007 }
2008 else
2009 {
2010 /* set port pin low */
2011 high_output |= 0x08;
2012 }
2013
2014 BUFFER_ADD = 0x82;
2015 BUFFER_ADD = high_output;
2016 BUFFER_ADD = high_direction;
2017 }
2018
2019 void turtle_jtag_blink(void)
2020 {
2021 /*
2022 * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3
2023 */
2024 if (high_output & 0x08)
2025 {
2026 high_output = 0x04;
2027 }
2028 else
2029 {
2030 high_output = 0x08;
2031 }
2032
2033 BUFFER_ADD = 0x82;
2034 BUFFER_ADD = high_output;
2035 BUFFER_ADD = high_direction;
2036 }
2037
2038
2039 int ft2232_quit(void)
2040 {
2041 #if BUILD_FT2232_FTD2XX == 1
2042 FT_STATUS status;
2043
2044 status = FT_Close(ftdih);
2045 #elif BUILD_FT2232_LIBFTDI == 1
2046 ftdi_disable_bitbang(&ftdic);
2047
2048 ftdi_usb_close(&ftdic);
2049
2050 ftdi_deinit(&ftdic);
2051 #endif
2052
2053 free(ft2232_buffer);
2054
2055 return ERROR_OK;
2056 }
2057
2058 int ft2232_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2059 {
2060 if (argc == 1)
2061 {
2062 ft2232_device_desc = strdup(args[0]);
2063 }
2064 else
2065 {
2066 ERROR("expected exactly one argument to ft2232_device_desc <description>");
2067 }
2068
2069 return ERROR_OK;
2070 }
2071
2072 int ft2232_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2073 {
2074 if (argc == 1)
2075 {
2076 ft2232_serial = strdup(args[0]);
2077 }
2078 else
2079 {
2080 ERROR("expected exactly one argument to ft2232_serial <serial-number>");
2081 }
2082
2083 return ERROR_OK;
2084 }
2085
2086 int ft2232_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2087 {
2088 if (argc == 0)
2089 return ERROR_OK;
2090
2091 ft2232_layout = malloc(strlen(args[0]) + 1);
2092 strcpy(ft2232_layout, args[0]);
2093
2094 return ERROR_OK;
2095 }
2096
2097 int ft2232_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2098 {
2099 int i;
2100
2101 if (argc > MAX_USB_IDS*2) {
2102 WARNING("ignoring extra IDs in ft2232_vid_pid "
2103 "(maximum is %d pairs)", MAX_USB_IDS);
2104 argc = MAX_USB_IDS*2;
2105 }
2106 if (argc < 2 || (argc & 1))
2107 {
2108 WARNING("incomplete ft2232_vid_pid configuration directive");
2109 if (argc < 2)
2110 return ERROR_OK;
2111 }
2112
2113 for (i = 0; i+1 < argc; i += 2) {
2114 ft2232_vid[i >> 1] = strtol(args[i], NULL, 0);
2115 ft2232_pid[i >> 1] = strtol(args[i+1], NULL, 0);
2116 }
2117 /*
2118 * Explicitly terminate, in case there are multiples instances of
2119 * ft2232_vid_pid.
2120 */
2121 ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0;
2122
2123 return ERROR_OK;
2124 }
2125
2126 int ft2232_handle_latency_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
2127 {
2128 if (argc == 1)
2129 {
2130 ft2232_latency = atoi(args[0]);
2131 }
2132 else
2133 {
2134 ERROR("expected exactly one argument to ft2232_latency <ms>");
2135 }
2136
2137 return ERROR_OK;
2138 }
2139
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)