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