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