1 /***************************************************************************
2 * Copyright (C) 2004, 2006 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
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. *
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. *
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 ***************************************************************************/
29 #include "replacements.h"
31 /* project specific includes */
35 #include "configuration.h"
36 #include "time_support.h"
43 /* FT2232 access library includes */
44 #if BUILD_FT2232_FTD2XX == 1
46 #elif BUILD_FT2232_LIBFTDI == 1
53 /* enable this to debug io latency
56 #define _DEBUG_USB_IO_
59 /* enable this to debug communication
62 #define _DEBUG_USB_COMMS_
65 int ft2232_execute_queue(void);
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);
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);
77 char *ft2232_device_desc = NULL;
78 char *ft2232_serial = NULL;
79 char *ft2232_layout = NULL;
80 u16 ft2232_vid = 0x0403;
81 u16 ft2232_pid = 0x6010;
83 typedef struct ft2232_layout_s
87 void(*reset)(int trst, int srst);
91 /* init procedures for supported layouts */
92 int usbjtag_init(void);
93 int jtagkey_init(void);
94 int olimex_jtag_init(void);
97 /* reset procedures for supported layouts */
98 void usbjtag_reset(int trst, int srst);
99 void jtagkey_reset(int trst, int srst);
100 void olimex_jtag_reset(int trst, int srst);
101 void m5960_reset(int trst, int srst);
103 /* blink procedures for layouts that support a blinking led */
104 void olimex_jtag_blink(void);
106 ft2232_layout_t ft2232_layouts[] =
108 {"usbjtag", usbjtag_init, usbjtag_reset, NULL},
109 {"jtagkey", jtagkey_init, jtagkey_reset, NULL},
110 {"jtagkey_prototype_v1", jtagkey_init, jtagkey_reset, NULL},
111 {"oocdlink", jtagkey_init, jtagkey_reset, NULL},
112 {"signalyzer", usbjtag_init, usbjtag_reset, NULL},
113 {"evb_lm3s811", usbjtag_init, usbjtag_reset, NULL},
114 {"olimex-jtag", olimex_jtag_init, olimex_jtag_reset, olimex_jtag_blink},
115 {"m5960", m5960_init, m5960_reset, NULL},
119 static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE;
121 static ft2232_layout_t *layout;
122 static u8 low_output = 0x0;
123 static u8 low_direction = 0x0;
124 static u8 high_output = 0x0;
125 static u8 high_direction = 0x0;
127 #if BUILD_FT2232_FTD2XX == 1
128 static FT_HANDLE ftdih = NULL;
129 #elif BUILD_FT2232_LIBFTDI == 1
130 static struct ftdi_context ftdic;
133 static u8 *ft2232_buffer = NULL;
134 static int ft2232_buffer_size = 0;
135 static int ft2232_read_pointer = 0;
136 static int ft2232_expect_read = 0;
137 #define FT2232_BUFFER_SIZE 131072
138 #define BUFFER_ADD ft2232_buffer[ft2232_buffer_size++]
139 #define BUFFER_READ ft2232_buffer[ft2232_read_pointer++]
141 jtag_interface_t ft2232_interface =
146 .execute_queue = ft2232_execute_queue,
148 .support_pathmove = 1,
150 .speed = ft2232_speed,
151 .register_commands = ft2232_register_commands,
156 int ft2232_write(u8 *buf, int size, u32* bytes_written)
158 #if BUILD_FT2232_FTD2XX == 1
160 DWORD dw_bytes_written;
161 if ((status = FT_Write(ftdih, buf, size, &dw_bytes_written)) != FT_OK)
163 *bytes_written = dw_bytes_written;
164 ERROR("FT_Write returned: %i", status);
165 return ERROR_JTAG_DEVICE_ERROR;
169 *bytes_written = dw_bytes_written;
172 #elif BUILD_FT2232_LIBFTDI == 1
174 if ((retval = ftdi_write_data(&ftdic, buf, size)) < 0)
177 ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
178 return ERROR_JTAG_DEVICE_ERROR;
182 *bytes_written = retval;
188 int ft2232_read(u8* buf, int size, u32* bytes_read)
190 #if BUILD_FT2232_FTD2XX == 1
196 while ((*bytes_read < size) && timeout--)
198 if ((status = FT_Read(ftdih, buf, size, &dw_bytes_read)) != FT_OK)
201 ERROR("FT_Read returned: %i", status);
202 return ERROR_JTAG_DEVICE_ERROR;
204 *bytes_read += dw_bytes_read;
206 #elif BUILD_FT2232_LIBFTDI == 1
211 while ((*bytes_read < size) && timeout--)
213 if ((retval = ftdi_read_data(&ftdic, buf + *bytes_read, size - *bytes_read)) < 0)
216 ERROR("ftdi_read_data: %s", ftdi_get_error_string(&ftdic));
217 return ERROR_JTAG_DEVICE_ERROR;
219 *bytes_read += retval;
223 if (*bytes_read < size)
225 ERROR("couldn't read the requested number of bytes from FT2232 device (%i < %i)", *bytes_read, size);
226 return ERROR_JTAG_DEVICE_ERROR;
232 int ft2232_speed(int speed)
238 buf[0] = 0x86; /* command "set divisor" */
239 buf[1] = speed & 0xff; /* valueL (0=6MHz, 1=3MHz, 2=1.5MHz, ...*/
240 buf[2] = (speed >> 8) & 0xff; /* valueH */
242 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
243 if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
245 ERROR("couldn't set FT2232 TCK speed");
252 int ft2232_register_commands(struct command_context_s *cmd_ctx)
254 register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command,
255 COMMAND_CONFIG, NULL);
256 register_command(cmd_ctx, NULL, "ft2232_serial", ft2232_handle_serial_command,
257 COMMAND_CONFIG, NULL);
258 register_command(cmd_ctx, NULL, "ft2232_layout", ft2232_handle_layout_command,
259 COMMAND_CONFIG, NULL);
260 register_command(cmd_ctx, NULL, "ft2232_vid_pid", ft2232_handle_vid_pid_command,
261 COMMAND_CONFIG, NULL);
265 void ft2232_end_state(state)
267 if (tap_move_map[state] != -1)
271 ERROR("BUG: %i is not a valid end state", state);
276 void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size)
278 int num_bytes = ((scan_size + 7) / 8);
279 int bits_left = scan_size;
282 while(num_bytes-- > 1)
284 buffer[cur_byte] = BUFFER_READ;
289 buffer[cur_byte] = 0x0;
293 buffer[cur_byte] = BUFFER_READ >> 1;
296 buffer[cur_byte] = (buffer[cur_byte] | ((BUFFER_READ & 0x02) << 6)) >> (8 - bits_left);
300 void ft2232_debug_dump_buffer(void)
306 for (i = 0; i < ft2232_buffer_size; i++)
308 line_p += snprintf(line_p, 256 - (line_p - line), "%2.2x ", ft2232_buffer[i]);
320 int ft2232_send_and_recv(jtag_command_t *first, jtag_command_t *last)
330 #ifdef _DEBUG_USB_IO_
331 struct timeval start, inter, inter2, end;
332 struct timeval d_inter, d_inter2, d_end;
335 #ifdef _DEBUG_USB_COMMS_
336 DEBUG("write buffer (size %i):", ft2232_buffer_size);
337 ft2232_debug_dump_buffer();
340 #ifdef _DEBUG_USB_IO_
341 gettimeofday(&start, NULL);
344 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
346 ERROR("couldn't write MPSSE commands to FT2232");
350 #ifdef _DEBUG_USB_IO_
351 gettimeofday(&inter, NULL);
354 if (ft2232_expect_read)
357 ft2232_buffer_size = 0;
359 #ifdef _DEBUG_USB_IO_
360 gettimeofday(&inter2, NULL);
363 if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK)
365 ERROR("couldn't read from FT2232");
369 #ifdef _DEBUG_USB_IO_
370 gettimeofday(&end, NULL);
372 timeval_subtract(&d_inter, &inter, &start);
373 timeval_subtract(&d_inter2, &inter2, &start);
374 timeval_subtract(&d_end, &end, &start);
376 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);
380 ft2232_buffer_size = bytes_read;
382 if (ft2232_expect_read != ft2232_buffer_size)
384 ERROR("ft2232_expect_read (%i) != ft2232_buffer_size (%i) (%i retries)", ft2232_expect_read, ft2232_buffer_size, 100 - timeout);
385 ft2232_debug_dump_buffer();
390 #ifdef _DEBUG_USB_COMMS_
391 DEBUG("read buffer (%i retries): %i bytes", 100 - timeout, ft2232_buffer_size);
392 ft2232_debug_dump_buffer();
396 ft2232_expect_read = 0;
397 ft2232_read_pointer = 0;
405 type = jtag_scan_type(cmd->cmd.scan);
406 if (type != SCAN_OUT)
408 scan_size = jtag_scan_size(cmd->cmd.scan);
409 buffer = calloc(CEIL(scan_size, 8), 1);
410 ft2232_read_scan(type, buffer, scan_size);
411 jtag_read_buffer(buffer, cmd->cmd.scan);
421 ft2232_buffer_size = 0;
426 void ft2232_add_pathmove(pathmove_command_t *cmd)
428 int num_states = cmd->num_states;
438 /* command "Clock Data to TMS/CS Pin (no Read)" */
440 /* number of states remaining */
441 BUFFER_ADD = (num_states % 7) - 1;
443 while (num_states % 7)
445 if (tap_transitions[cur_state].low == cmd->path[state_count])
446 buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
447 else if (tap_transitions[cur_state].high == cmd->path[state_count])
448 buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
451 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
455 cur_state = cmd->path[state_count];
460 BUFFER_ADD = tms_byte;
463 end_state = cur_state;
466 void ft2232_add_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
468 int num_bytes = (scan_size + 7) / 8;
469 int bits_left = scan_size;
473 if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
475 /* command "Clock Data to TMS/CS Pin (no Read)" */
482 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SI);
487 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SD);
490 //DEBUG("added TMS scan (no read)");
493 /* add command for complete bytes */
494 while (num_bytes > 1)
499 /* Clock Data Bytes In and Out LSB First */
501 //DEBUG("added TDI bytes (io %i)", num_bytes);
503 else if (type == SCAN_OUT)
505 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
507 //DEBUG("added TDI bytes (o)");
509 else if (type == SCAN_IN)
511 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
513 //DEBUG("added TDI bytes (i %i)", num_bytes);
515 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
516 num_bytes -= thisrun_bytes;
517 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
518 BUFFER_ADD = ((thisrun_bytes - 1) >> 8) & 0xff;
521 /* add complete bytes */
522 while(thisrun_bytes-- > 0)
524 BUFFER_ADD = buffer[cur_byte];
529 else /* (type == SCAN_IN) */
531 bits_left -= 8 * (thisrun_bytes);
535 /* the most signifcant bit is scanned during TAP movement */
537 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
541 /* process remaining bits but the last one */
546 /* Clock Data Bits In and Out LSB First */
548 //DEBUG("added TDI bits (io) %i", bits_left - 1);
550 else if (type == SCAN_OUT)
552 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
554 //DEBUG("added TDI bits (o)");
556 else if (type == SCAN_IN)
558 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
560 //DEBUG("added TDI bits (i %i)", bits_left - 1);
562 BUFFER_ADD = bits_left - 2;
564 BUFFER_ADD = buffer[cur_byte];
567 if ((ir_scan && (end_state == TAP_SI)) ||
568 (!ir_scan && (end_state == TAP_SD)))
572 /* Clock Data Bits In and Out LSB First */
574 //DEBUG("added TDI bits (io) %i", bits_left - 1);
576 else if (type == SCAN_OUT)
578 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
580 //DEBUG("added TDI bits (o)");
582 else if (type == SCAN_IN)
584 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
586 //DEBUG("added TDI bits (i %i)", bits_left - 1);
589 BUFFER_ADD = last_bit;
593 /* move from Shift-IR/DR to end state */
594 if (type != SCAN_OUT)
596 /* Clock Data to TMS/CS Pin with Read */
598 //DEBUG("added TMS scan (read)");
602 /* Clock Data to TMS/CS Pin (no Read) */
604 //DEBUG("added TMS scan (no read)");
607 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
608 cur_state = end_state;
612 int ft2232_large_scan(scan_command_t *cmd, enum scan_type type, u8 *buffer, int scan_size)
614 int num_bytes = (scan_size + 7) / 8;
615 int bits_left = scan_size;
618 u8 *receive_buffer = malloc(CEIL(scan_size, 8));
619 u8 *receive_pointer = receive_buffer;
623 int thisrun_read = 0;
627 ERROR("BUG: large IR scans are not supported");
631 if (cur_state != TAP_SD)
633 /* command "Clock Data to TMS/CS Pin (no Read)" */
638 BUFFER_ADD = TAP_MOVE(cur_state, TAP_SD);
642 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
644 ERROR("couldn't write MPSSE commands to FT2232");
647 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
648 ft2232_buffer_size = 0;
650 /* add command for complete bytes */
651 while (num_bytes > 1)
657 /* Clock Data Bytes In and Out LSB First */
659 //DEBUG("added TDI bytes (io %i)", num_bytes);
661 else if (type == SCAN_OUT)
663 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
665 //DEBUG("added TDI bytes (o)");
667 else if (type == SCAN_IN)
669 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
671 //DEBUG("added TDI bytes (i %i)", num_bytes);
673 thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1);
674 thisrun_read = thisrun_bytes;
675 num_bytes -= thisrun_bytes;
676 BUFFER_ADD = (thisrun_bytes - 1) & 0xff;
677 BUFFER_ADD = ((thisrun_bytes - 1) >> 8) & 0xff;
680 /* add complete bytes */
681 while(thisrun_bytes-- > 0)
683 BUFFER_ADD = buffer[cur_byte];
688 else /* (type == SCAN_IN) */
690 bits_left -= 8 * (thisrun_bytes);
693 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
695 ERROR("couldn't write MPSSE commands to FT2232");
698 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
699 ft2232_buffer_size = 0;
701 if (type != SCAN_OUT)
703 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
705 ERROR("couldn't read from FT2232");
708 DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
709 receive_pointer += bytes_read;
715 /* the most signifcant bit is scanned during TAP movement */
717 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
721 /* process remaining bits but the last one */
726 /* Clock Data Bits In and Out LSB First */
728 //DEBUG("added TDI bits (io) %i", bits_left - 1);
730 else if (type == SCAN_OUT)
732 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
734 //DEBUG("added TDI bits (o)");
736 else if (type == SCAN_IN)
738 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
740 //DEBUG("added TDI bits (i %i)", bits_left - 1);
742 BUFFER_ADD = bits_left - 2;
744 BUFFER_ADD = buffer[cur_byte];
746 if (type != SCAN_OUT)
750 if (end_state == TAP_SD)
754 /* Clock Data Bits In and Out LSB First */
756 //DEBUG("added TDI bits (io) %i", bits_left - 1);
758 else if (type == SCAN_OUT)
760 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
762 //DEBUG("added TDI bits (o)");
764 else if (type == SCAN_IN)
766 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
768 //DEBUG("added TDI bits (i %i)", bits_left - 1);
771 BUFFER_ADD = last_bit;
775 /* move from Shift-IR/DR to end state */
776 if (type != SCAN_OUT)
778 /* Clock Data to TMS/CS Pin with Read */
780 //DEBUG("added TMS scan (read)");
784 /* Clock Data to TMS/CS Pin (no Read) */
786 //DEBUG("added TMS scan (no read)");
789 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
790 cur_state = end_state;
793 if (type != SCAN_OUT)
796 if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK)
798 ERROR("couldn't write MPSSE commands to FT2232");
801 DEBUG("ft2232_buffer_size: %i, bytes_written: %i", ft2232_buffer_size, bytes_written);
802 ft2232_buffer_size = 0;
804 if (type != SCAN_OUT)
806 if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK)
808 ERROR("couldn't read from FT2232");
811 DEBUG("thisrun_read: %i, bytes_read: %i", thisrun_read, bytes_read);
812 receive_pointer += bytes_read;
818 int ft2232_predict_scan_out(int scan_size, enum scan_type type)
820 int predicted_size = 3;
821 int num_bytes = (scan_size - 1) / 8;
823 if (cur_state != TAP_SD)
826 if (type == SCAN_IN) /* only from device to host */
829 predicted_size += (CEIL(num_bytes, 65536)) * 3;
830 /* remaining bits - 1 (up to 7) */
831 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
833 else /* host to device, or bidirectional */
836 predicted_size += num_bytes + (CEIL(num_bytes, 65536)) * 3;
837 /* remaining bits -1 (up to 7) */
838 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
841 return predicted_size;
844 int ft2232_predict_scan_in(int scan_size, enum scan_type type)
846 int predicted_size = 0;
848 if (type != SCAN_OUT)
851 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
852 /* remaining bits - 1 */
853 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
854 /* last bit (from TMS scan) */
858 //DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size);
860 return predicted_size;
863 void usbjtag_reset(int trst, int srst)
868 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
869 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
871 low_output &= ~nTRST; /* switch output low */
875 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
876 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
878 low_output |= nTRST; /* switch output high */
883 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
884 low_output &= ~nSRST; /* switch output low */
886 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
890 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
891 low_output |= nSRST; /* switch output high */
893 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
896 /* command "set data bits low byte" */
898 BUFFER_ADD = low_output;
899 BUFFER_ADD = low_direction;
903 void jtagkey_reset(int trst, int srst)
908 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
909 high_output &= ~nTRSTnOE;
911 high_output &= ~nTRST;
915 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
916 high_output |= nTRSTnOE;
918 high_output |= nTRST;
923 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
924 high_output &= ~nSRST;
926 high_output &= ~nSRSTnOE;
930 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
931 high_output |= nSRST;
933 high_output |= nSRSTnOE;
936 /* command "set data bits high byte" */
938 BUFFER_ADD = high_output;
939 BUFFER_ADD = high_direction;
940 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
943 void olimex_jtag_reset(int trst, int srst)
948 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
949 high_output &= ~nTRSTnOE;
951 high_output &= ~nTRST;
955 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
956 high_output |= nTRSTnOE;
958 high_output |= nTRST;
963 high_output |= nSRST;
967 high_output &= ~nSRST;
970 /* command "set data bits high byte" */
972 BUFFER_ADD = high_output;
973 BUFFER_ADD = high_direction;
974 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
977 void m5960_reset(int trst, int srst)
982 low_output &= ~nTRST;
995 low_output &= ~nSRST;
998 /* command "set data bits low byte" */
1000 BUFFER_ADD = low_output;
1001 BUFFER_ADD = low_direction;
1002 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
1005 int ft2232_execute_queue()
1007 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
1008 jtag_command_t *first_unsent = cmd; /* next command that has to be sent */
1010 int scan_size; /* size of IR or DR scan */
1011 enum scan_type type;
1013 int predicted_size = 0;
1014 int require_send = 0;
1016 ft2232_buffer_size = 0;
1017 ft2232_expect_read = 0;
1019 /* blink, if the current layout has that feature */
1027 case JTAG_END_STATE:
1028 if (cmd->cmd.end_state->end_state != -1)
1029 ft2232_end_state(cmd->cmd.end_state->end_state);
1032 /* only send the maximum buffer size that FT2232C can handle */
1034 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1036 ft2232_send_and_recv(first_unsent, cmd);
1041 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1044 #ifdef _DEBUG_JTAG_IO_
1045 DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
1049 /* only send the maximum buffer size that FT2232C can handle */
1051 if (cur_state != TAP_RTI)
1052 predicted_size += 3;
1053 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
1054 if ((cmd->cmd.runtest->end_state != -1) && (cmd->cmd.runtest->end_state != TAP_RTI))
1055 predicted_size += 3;
1056 if ((cmd->cmd.runtest->end_state == -1) && (end_state != TAP_RTI))
1057 predicted_size += 3;
1058 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1060 ft2232_send_and_recv(first_unsent, cmd);
1064 if (cur_state != TAP_RTI)
1066 /* command "Clock Data to TMS/CS Pin (no Read)" */
1071 BUFFER_ADD = TAP_MOVE(cur_state, TAP_RTI);
1072 cur_state = TAP_RTI;
1075 i = cmd->cmd.runtest->num_cycles;
1078 /* command "Clock Data to TMS/CS Pin (no Read)" */
1081 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
1084 cur_state = TAP_RTI;
1085 i -= (i > 7) ? 7 : i;
1086 //DEBUG("added TMS scan (no read)");
1088 if (cmd->cmd.runtest->end_state != -1)
1089 ft2232_end_state(cmd->cmd.runtest->end_state);
1090 if (cur_state != end_state)
1092 /* command "Clock Data to TMS/CS Pin (no Read)" */
1097 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
1098 cur_state = end_state;
1099 //DEBUG("added TMS scan (no read)");
1102 #ifdef _DEBUG_JTAG_IO_
1103 DEBUG("runtest: %i, end in %i", cmd->cmd.runtest->num_cycles, end_state);
1106 case JTAG_STATEMOVE:
1107 /* only send the maximum buffer size that FT2232C can handle */
1109 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1111 ft2232_send_and_recv(first_unsent, cmd);
1115 if (cmd->cmd.statemove->end_state != -1)
1116 ft2232_end_state(cmd->cmd.statemove->end_state);
1117 /* command "Clock Data to TMS/CS Pin (no Read)" */
1122 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
1123 //DEBUG("added TMS scan (no read)");
1124 cur_state = end_state;
1126 #ifdef _DEBUG_JTAG_IO_
1127 DEBUG("statemove: %i", end_state);
1131 /* only send the maximum buffer size that FT2232C can handle */
1132 predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7);
1133 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1135 ft2232_send_and_recv(first_unsent, cmd);
1139 ft2232_add_pathmove(cmd->cmd.pathmove);
1141 #ifdef _DEBUG_JTAG_IO_
1142 DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1146 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
1147 type = jtag_scan_type(cmd->cmd.scan);
1148 predicted_size = ft2232_predict_scan_out(scan_size, type);
1149 if ((predicted_size + 1) > FT2232_BUFFER_SIZE)
1151 DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)");
1152 /* unsent commands before this */
1153 if (first_unsent != cmd)
1154 ft2232_send_and_recv(first_unsent, cmd);
1156 /* current command */
1157 if (cmd->cmd.scan->end_state != -1)
1158 ft2232_end_state(cmd->cmd.scan->end_state);
1159 ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size);
1161 first_unsent = cmd->next;
1166 else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
1168 DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %x, cmd: %x)", first_unsent, cmd);
1169 ft2232_send_and_recv(first_unsent, cmd);
1173 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
1174 //DEBUG("new read size: %i", ft2232_expect_read);
1175 if (cmd->cmd.scan->end_state != -1)
1176 ft2232_end_state(cmd->cmd.scan->end_state);
1177 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
1181 #ifdef _DEBUG_JTAG_IO_
1182 DEBUG("%s scan, %i bit, end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, end_state);
1186 ft2232_send_and_recv(first_unsent, cmd);
1187 first_unsent = cmd->next;
1188 jtag_sleep(cmd->cmd.sleep->us);
1189 #ifdef _DEBUG_JTAG_IO_
1190 DEBUG("sleep %i usec", cmd->cmd.sleep->us);
1194 ERROR("BUG: unknown JTAG command type encountered");
1200 if (require_send > 0)
1201 ft2232_send_and_recv(first_unsent, cmd);
1206 int ft2232_init(void)
1213 #if BUILD_FT2232_FTD2XX == 1
1215 DWORD openex_flags = 0;
1216 char *openex_string = NULL;
1219 ft2232_layout_t *cur_layout = ft2232_layouts;
1221 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
1223 ft2232_layout = "usbjtag";
1224 WARNING("No ft2232 layout specified, using default 'usbjtag'");
1227 while (cur_layout->name)
1229 if (strcmp(cur_layout->name, ft2232_layout) == 0)
1231 layout = cur_layout;
1239 ERROR("No matching layout found for %s", ft2232_layout);
1240 return ERROR_JTAG_INIT_FAILED;
1243 #if BUILD_FT2232_FTD2XX == 1
1244 DEBUG("'ft2232' interface using FTD2XX with '%s' layout", ft2232_layout);
1245 #elif BUILD_FT2232_LIBFTDI == 1
1246 DEBUG("'ft2232' interface using libftdi with '%s' layout", ft2232_layout);
1249 #if BUILD_FT2232_FTD2XX == 1
1251 /* Add non-standard Vid/Pid to the linux driver */
1252 if ((status = FT_SetVIDPID(ft2232_vid, ft2232_pid)) != FT_OK)
1254 WARNING("couldn't add %4.4x:%4.4x", ft2232_vid, ft2232_pid);
1258 if (ft2232_device_desc && ft2232_serial)
1260 WARNING("can't open by device description and serial number, giving precedence to serial");
1261 ft2232_device_desc = NULL;
1264 if (ft2232_device_desc)
1266 openex_string = ft2232_device_desc;
1267 openex_flags = FT_OPEN_BY_DESCRIPTION;
1269 else if (ft2232_serial)
1271 openex_string = ft2232_serial;
1272 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1276 ERROR("neither device description nor serial number specified");
1277 ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1279 return ERROR_JTAG_INIT_FAILED;
1282 if ((status = FT_OpenEx(openex_string, openex_flags, &ftdih)) != FT_OK)
1286 ERROR("unable to open ftdi device: %i", status);
1287 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1288 if (status == FT_OK)
1290 char **desc_array = malloc(sizeof(char*) * (num_devices + 1));
1293 for (i = 0; i < num_devices; i++)
1294 desc_array[i] = malloc(64);
1295 desc_array[num_devices] = NULL;
1297 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1299 if (status == FT_OK)
1301 ERROR("ListDevices: %d\n", num_devices);
1302 for (i = 0; i < num_devices; i++)
1303 ERROR("%i: %s", i, desc_array[i]);
1306 for (i = 0; i < num_devices; i++)
1307 free(desc_array[i]);
1312 printf("ListDevices: NONE\n");
1314 return ERROR_JTAG_INIT_FAILED;
1317 if ((status = FT_SetLatencyTimer(ftdih, 2)) != FT_OK)
1319 ERROR("unable to set latency timer: %i", status);
1320 return ERROR_JTAG_INIT_FAILED;
1323 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1325 ERROR("unable to get latency timer: %i", status);
1326 return ERROR_JTAG_INIT_FAILED;
1330 DEBUG("current latency timer: %i", latency_timer);
1333 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1335 ERROR("unable to set timeouts: %i", status);
1336 return ERROR_JTAG_INIT_FAILED;
1339 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1341 ERROR("unable to enable bit i/o mode: %i", status);
1342 return ERROR_JTAG_INIT_FAILED;
1344 #elif BUILD_FT2232_LIBFTDI == 1
1345 if (ftdi_init(&ftdic) < 0)
1346 return ERROR_JTAG_INIT_FAILED;
1348 /* context, vendor id, product id */
1349 if (ftdi_usb_open(&ftdic, ft2232_vid, ft2232_pid) < 0)
1351 ERROR("unable to open ftdi device: %s", ftdic.error_str);
1352 return ERROR_JTAG_INIT_FAILED;
1355 if (ftdi_usb_reset(&ftdic) < 0)
1357 ERROR("unable to reset ftdi device");
1358 return ERROR_JTAG_INIT_FAILED;
1361 if (ftdi_set_latency_timer(&ftdic, 2) < 0)
1363 ERROR("unable to set latency timer");
1364 return ERROR_JTAG_INIT_FAILED;
1367 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1369 ERROR("unable to get latency timer");
1370 return ERROR_JTAG_INIT_FAILED;
1374 DEBUG("current latency timer: %i", latency_timer);
1377 ftdic.bitbang_mode = 0; /* Reset controller */
1378 ftdi_enable_bitbang(&ftdic, 0x0b); /* ctx, JTAG I/O mask */
1380 ftdic.bitbang_mode = 2; /* MPSSE mode */
1381 ftdi_enable_bitbang(&ftdic, 0x0b); /* ctx, JTAG I/O mask */
1384 ft2232_buffer_size = 0;
1385 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1387 if (layout->init() != ERROR_OK)
1388 return ERROR_JTAG_INIT_FAILED;
1390 ft2232_speed(jtag_speed);
1392 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1393 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
1395 ERROR("couldn't write to FT2232 to disable loopback");
1396 return ERROR_JTAG_INIT_FAILED;
1399 #if BUILD_FT2232_FTD2XX == 1
1400 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1402 ERROR("error purging ftd2xx device: %i", status);
1403 return ERROR_JTAG_INIT_FAILED;
1405 #elif BUILD_FT2232_LIBFTDI == 1
1406 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1408 ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1409 return ERROR_JTAG_INIT_FAILED;
1416 int usbjtag_init(void)
1422 low_direction = 0x0b;
1424 if (strcmp(ft2232_layout, "usbjtag") == 0)
1431 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1438 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1445 low_direction = 0x8b;
1449 ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1450 return ERROR_JTAG_INIT_FAILED;
1453 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1455 low_direction &= ~nTRSTnOE; /* nTRST input */
1456 low_output &= ~nTRST; /* nTRST = 0 */
1460 low_direction |= nTRSTnOE; /* nTRST output */
1461 low_output |= nTRST; /* nTRST = 1 */
1464 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1466 low_direction |= nSRSTnOE; /* nSRST output */
1467 low_output |= nSRST; /* nSRST = 1 */
1471 low_direction &= ~nSRSTnOE; /* nSRST input */
1472 low_output &= ~nSRST; /* nSRST = 0 */
1475 /* initialize low byte for jtag */
1476 buf[0] = 0x80; /* command "set data bits low byte" */
1477 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1478 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1479 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1481 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1483 ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1484 return ERROR_JTAG_INIT_FAILED;
1490 int jtagkey_init(void)
1496 low_direction = 0x1b;
1498 /* initialize low byte for jtag */
1499 buf[0] = 0x80; /* command "set data bits low byte" */
1500 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1501 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1502 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1504 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1506 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1507 return ERROR_JTAG_INIT_FAILED;
1510 if (strcmp(layout->name, "jtagkey") == 0)
1517 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0) ||
1518 (strcmp(layout->name, "oocdlink") == 0))
1527 ERROR("BUG: jtagkey_init called for non jtagkey layout");
1532 high_direction = 0x0f;
1534 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1536 high_output |= nTRSTnOE;
1537 high_output &= ~nTRST;
1541 high_output &= ~nTRSTnOE;
1542 high_output |= nTRST;
1545 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1547 high_output &= ~nSRSTnOE;
1548 high_output |= nSRST;
1552 high_output |= nSRSTnOE;
1553 high_output &= ~nSRST;
1556 /* initialize high port */
1557 buf[0] = 0x82; /* command "set data bits high byte" */
1558 buf[1] = high_output; /* value */
1559 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1560 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1562 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1564 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1565 return ERROR_JTAG_INIT_FAILED;
1571 int olimex_jtag_init(void)
1577 low_direction = 0x1b;
1579 /* initialize low byte for jtag */
1580 buf[0] = 0x80; /* command "set data bits low byte" */
1581 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1582 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1583 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1585 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1587 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1588 return ERROR_JTAG_INIT_FAILED;
1594 nSRSTnOE = 0x00; /* no output enable for nSRST */
1597 high_direction = 0x0f;
1599 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1601 high_output |= nTRSTnOE;
1602 high_output &= ~nTRST;
1606 high_output &= ~nTRSTnOE;
1607 high_output |= nTRST;
1610 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1612 ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
1616 high_output &= ~nSRST;
1619 /* turn red LED on */
1620 high_output |= 0x08;
1622 /* initialize high port */
1623 buf[0] = 0x82; /* command "set data bits high byte" */
1624 buf[1] = high_output; /* value */
1625 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1626 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1628 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1630 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1631 return ERROR_JTAG_INIT_FAILED;
1637 int m5960_init(void)
1643 low_direction = 0xfb;
1645 /* initialize low byte for jtag */
1646 buf[0] = 0x80; /* command "set data bits low byte" */
1647 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1648 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
1649 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1651 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1653 ERROR("couldn't initialize FT2232 with 'm5960' layout");
1654 return ERROR_JTAG_INIT_FAILED;
1658 nTRSTnOE = 0x0; /* not output enable for nTRST */
1660 nSRSTnOE = 0x00; /* no output enable for nSRST */
1663 high_direction = 0x0c;
1665 /* turn red LED1 on, LED2 off */
1666 high_output |= 0x08;
1668 /* initialize high port */
1669 buf[0] = 0x82; /* command "set data bits high byte" */
1670 buf[1] = high_output; /* value */
1671 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1672 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1674 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1676 ERROR("couldn't initialize FT2232 with 'm5960' layout");
1677 return ERROR_JTAG_INIT_FAILED;
1683 void olimex_jtag_blink(void)
1685 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
1686 * ACBUS3 is bit 3 of the GPIOH port
1688 if (high_output & 0x08)
1690 /* set port pin high */
1691 high_output &= 0x07;
1695 /* set port pin low */
1696 high_output |= 0x08;
1700 BUFFER_ADD = high_output;
1701 BUFFER_ADD = high_direction;
1704 int ft2232_quit(void)
1706 #if BUILD_FT2232_FTD2XX == 1
1709 status = FT_Close(ftdih);
1710 #elif BUILD_FT2232_LIBFTDI == 1
1711 ftdi_disable_bitbang(&ftdic);
1713 ftdi_usb_close(&ftdic);
1715 ftdi_deinit(&ftdic);
1718 free(ft2232_buffer);
1723 int ft2232_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1727 ft2232_device_desc = strdup(args[0]);
1731 ERROR("expected exactly one argument to ft2232_device_desc <description>");
1737 int ft2232_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1741 ft2232_serial = strdup(args[0]);
1745 ERROR("expected exactly one argument to ft2232_serial <serial-number>");
1751 int ft2232_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1756 ft2232_layout = malloc(strlen(args[0]) + 1);
1757 strcpy(ft2232_layout, args[0]);
1762 int ft2232_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1766 ft2232_vid = strtol(args[0], NULL, 0);
1767 ft2232_pid = strtol(args[1], NULL, 0);
1771 WARNING("incomplete ft2232_vid_pid configuration directive");