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 */
498 /* Clock Data Bytes In and Out LSB First */
500 //DEBUG("added TDI bytes (io %i)", num_bytes);
502 else if (type == SCAN_OUT)
504 /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */
506 //DEBUG("added TDI bytes (o)");
508 else if (type == SCAN_IN)
510 /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */
512 //DEBUG("added TDI bytes (i %i)", num_bytes);
514 BUFFER_ADD = (num_bytes-2) & 0xff;
515 BUFFER_ADD = ((num_bytes-2) >> 8) & 0xff;
519 /* add complete bytes */
520 while(num_bytes-- > 1)
522 BUFFER_ADD = buffer[cur_byte];
529 bits_left -= 8 * (num_bytes - 1);
532 /* the most signifcant bit is scanned during TAP movement */
534 last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1;
538 /* process remaining bits but the last one */
543 /* Clock Data Bits In and Out LSB First */
545 //DEBUG("added TDI bits (io) %i", bits_left - 1);
547 else if (type == SCAN_OUT)
549 /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */
551 //DEBUG("added TDI bits (o)");
553 else if (type == SCAN_IN)
555 /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */
557 //DEBUG("added TDI bits (i %i)", bits_left - 1);
559 BUFFER_ADD = bits_left - 2;
561 BUFFER_ADD = buffer[cur_byte];
564 /* move from Shift-IR/DR to end state */
565 if (type != SCAN_OUT)
567 /* Clock Data to TMS/CS Pin with Read */
569 //DEBUG("added TMS scan (read)");
573 /* Clock Data to TMS/CS Pin (no Read) */
575 //DEBUG("added TMS scan (no read)");
578 BUFFER_ADD = TAP_MOVE(cur_state, end_state) | (last_bit << 7);
579 cur_state = end_state;
583 int ft2232_predict_scan_out(int scan_size, enum scan_type type)
585 int predicted_size = 3;
587 if (cur_state != TAP_SD)
590 if (type == SCAN_IN) /* only from device to host */
593 predicted_size += (CEIL(scan_size, 8) > 1) ? 3 : 0;
594 /* remaining bits - 1 (up to 7) */
595 predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
597 else /* host to device, or bidirectional */
600 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) + 3 - 1) : 0;
601 /* remaining bits -1 (up to 7) */
602 predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
605 return predicted_size;
608 int ft2232_predict_scan_in(int scan_size, enum scan_type type)
610 int predicted_size = 0;
612 if (type != SCAN_OUT)
615 predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
616 /* remaining bits - 1 */
617 predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
618 /* last bit (from TMS scan) */
622 //DEBUG("scan_size: %i, predicted_size: %i", scan_size, predicted_size);
624 return predicted_size;
627 void usbjtag_reset(int trst, int srst)
632 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
633 low_direction |= nTRSTnOE; /* switch to output pin (output is low) */
635 low_output &= ~nTRST; /* switch output low */
639 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
640 low_direction &= ~nTRSTnOE; /* switch to input pin (high-Z + internal and external pullup) */
642 low_output |= nTRST; /* switch output high */
647 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
648 low_output &= ~nSRST; /* switch output low */
650 low_direction |= nSRSTnOE; /* switch to output pin (output is low) */
654 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
655 low_output |= nSRST; /* switch output high */
657 low_direction &= ~nSRSTnOE; /* switch to input pin (high-Z) */
660 /* command "set data bits low byte" */
662 BUFFER_ADD = low_output;
663 BUFFER_ADD = low_direction;
667 void jtagkey_reset(int trst, int srst)
672 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
673 high_output &= ~nTRSTnOE;
675 high_output &= ~nTRST;
679 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
680 high_output |= nTRSTnOE;
682 high_output |= nTRST;
687 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
688 high_output &= ~nSRST;
690 high_output &= ~nSRSTnOE;
694 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
695 high_output |= nSRST;
697 high_output |= nSRSTnOE;
700 /* command "set data bits high byte" */
702 BUFFER_ADD = high_output;
703 BUFFER_ADD = high_direction;
704 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
707 void olimex_jtag_reset(int trst, int srst)
712 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
713 high_output &= ~nTRSTnOE;
715 high_output &= ~nTRST;
719 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
720 high_output |= nTRSTnOE;
722 high_output |= nTRST;
727 high_output |= nSRST;
731 high_output &= ~nSRST;
734 /* command "set data bits high byte" */
736 BUFFER_ADD = high_output;
737 BUFFER_ADD = high_direction;
738 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
741 void m5960_reset(int trst, int srst)
746 low_output &= ~nTRST;
759 low_output &= ~nSRST;
762 /* command "set data bits low byte" */
764 BUFFER_ADD = low_output;
765 BUFFER_ADD = low_direction;
766 DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction);
769 int ft2232_execute_queue()
771 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
772 jtag_command_t *first_unsent = cmd; /* next command that has to be sent */
774 int scan_size; /* size of IR or DR scan */
777 int predicted_size = 0;
778 int require_send = 0;
780 ft2232_buffer_size = 0;
781 ft2232_expect_read = 0;
783 /* blink, if the current layout has that feature */
792 if (cmd->cmd.end_state->end_state != -1)
793 ft2232_end_state(cmd->cmd.end_state->end_state);
796 /* only send the maximum buffer size that FT2232C can handle */
798 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
800 ft2232_send_and_recv(first_unsent, cmd);
805 layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
808 #ifdef _DEBUG_JTAG_IO_
809 DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
813 /* only send the maximum buffer size that FT2232C can handle */
815 if (cur_state != TAP_RTI)
817 predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
818 if ((cmd->cmd.runtest->end_state != -1) && (cmd->cmd.runtest->end_state != TAP_RTI))
820 if ((cmd->cmd.runtest->end_state == -1) && (end_state != TAP_RTI))
822 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
824 ft2232_send_and_recv(first_unsent, cmd);
828 if (cur_state != TAP_RTI)
830 /* command "Clock Data to TMS/CS Pin (no Read)" */
835 BUFFER_ADD = TAP_MOVE(cur_state, TAP_RTI);
839 i = cmd->cmd.runtest->num_cycles;
842 /* command "Clock Data to TMS/CS Pin (no Read)" */
845 BUFFER_ADD = (i > 7) ? 6 : (i - 1);
849 i -= (i > 7) ? 7 : i;
850 //DEBUG("added TMS scan (no read)");
852 if (cmd->cmd.runtest->end_state != -1)
853 ft2232_end_state(cmd->cmd.runtest->end_state);
854 if (cur_state != end_state)
856 /* command "Clock Data to TMS/CS Pin (no Read)" */
861 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
862 cur_state = end_state;
863 //DEBUG("added TMS scan (no read)");
866 #ifdef _DEBUG_JTAG_IO_
867 DEBUG("runtest: %i, end in %i", cmd->cmd.runtest->num_cycles, end_state);
871 /* only send the maximum buffer size that FT2232C can handle */
873 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
875 ft2232_send_and_recv(first_unsent, cmd);
879 if (cmd->cmd.statemove->end_state != -1)
880 ft2232_end_state(cmd->cmd.statemove->end_state);
881 /* command "Clock Data to TMS/CS Pin (no Read)" */
886 BUFFER_ADD = TAP_MOVE(cur_state, end_state);
887 //DEBUG("added TMS scan (no read)");
888 cur_state = end_state;
890 #ifdef _DEBUG_JTAG_IO_
891 DEBUG("statemove: %i", end_state);
895 /* only send the maximum buffer size that FT2232C can handle */
896 predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7);
897 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
899 ft2232_send_and_recv(first_unsent, cmd);
903 ft2232_add_pathmove(cmd->cmd.pathmove);
905 #ifdef _DEBUG_JTAG_IO_
906 DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
910 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
911 type = jtag_scan_type(cmd->cmd.scan);
912 predicted_size = ft2232_predict_scan_out(scan_size, type);
913 if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
915 DEBUG("ftd2xx buffer size reached, sending queued commands (first_unsent: %x, cmd: %x)", first_unsent, cmd);
916 ft2232_send_and_recv(first_unsent, cmd);
920 ft2232_expect_read += ft2232_predict_scan_in(scan_size, type);
921 //DEBUG("new read size: %i", ft2232_expect_read);
922 if (cmd->cmd.scan->end_state != -1)
923 ft2232_end_state(cmd->cmd.scan->end_state);
924 ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
928 #ifdef _DEBUG_JTAG_IO_
929 DEBUG("%s scan, %i bit, end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, end_state);
933 ft2232_send_and_recv(first_unsent, cmd);
934 first_unsent = cmd->next;
935 jtag_sleep(cmd->cmd.sleep->us);
936 #ifdef _DEBUG_JTAG_IO_
937 DEBUG("sleep %i usec", cmd->cmd.sleep->us);
941 ERROR("BUG: unknown JTAG command type encountered");
947 if (require_send > 0)
948 ft2232_send_and_recv(first_unsent, cmd);
953 int ft2232_init(void)
960 #if BUILD_FT2232_FTD2XX == 1
962 DWORD openex_flags = 0;
963 char *openex_string = NULL;
966 ft2232_layout_t *cur_layout = ft2232_layouts;
968 if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0))
970 ft2232_layout = "usbjtag";
971 WARNING("No ft2232 layout specified, using default 'usbjtag'");
974 while (cur_layout->name)
976 if (strcmp(cur_layout->name, ft2232_layout) == 0)
986 ERROR("No matching layout found for %s", ft2232_layout);
987 return ERROR_JTAG_INIT_FAILED;
990 #if BUILD_FT2232_FTD2XX == 1
991 DEBUG("'ft2232' interface using FTD2XX with '%s' layout", ft2232_layout);
992 #elif BUILD_FT2232_LIBFTDI == 1
993 DEBUG("'ft2232' interface using libftdi with '%s' layout", ft2232_layout);
996 #if BUILD_FT2232_FTD2XX == 1
998 /* Add non-standard Vid/Pid to the linux driver */
999 if ((status = FT_SetVIDPID(ft2232_vid, ft2232_pid)) != FT_OK)
1001 WARNING("couldn't add %4.4x:%4.4x", ft2232_vid, ft2232_pid);
1005 if (ft2232_device_desc && ft2232_serial)
1007 WARNING("can't open by device description and serial number, giving precedence to serial");
1008 ft2232_device_desc = NULL;
1011 if (ft2232_device_desc)
1013 openex_string = ft2232_device_desc;
1014 openex_flags = FT_OPEN_BY_DESCRIPTION;
1016 else if (ft2232_serial)
1018 openex_string = ft2232_serial;
1019 openex_flags = FT_OPEN_BY_SERIAL_NUMBER;
1023 ERROR("neither device description nor serial number specified");
1024 ERROR("please add \"ft2232_device_desc <string>\" or \"ft2232_serial <string>\" to your .cfg file");
1026 return ERROR_JTAG_INIT_FAILED;
1029 if ((status = FT_OpenEx(openex_string, openex_flags, &ftdih)) != FT_OK)
1033 ERROR("unable to open ftdi device: %i", status);
1034 status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
1035 if (status == FT_OK)
1037 char **desc_array = malloc(sizeof(char*) * (num_devices + 1));
1040 for (i = 0; i < num_devices; i++)
1041 desc_array[i] = malloc(64);
1042 desc_array[num_devices] = NULL;
1044 status = FT_ListDevices(desc_array, &num_devices, FT_LIST_ALL | openex_flags);
1046 if (status == FT_OK)
1048 ERROR("ListDevices: %d\n", num_devices);
1049 for (i = 0; i < num_devices; i++)
1050 ERROR("%i: %s", i, desc_array[i]);
1053 for (i = 0; i < num_devices; i++)
1054 free(desc_array[i]);
1059 printf("ListDevices: NONE\n");
1061 return ERROR_JTAG_INIT_FAILED;
1064 if ((status = FT_SetLatencyTimer(ftdih, 2)) != FT_OK)
1066 ERROR("unable to set latency timer: %i", status);
1067 return ERROR_JTAG_INIT_FAILED;
1070 if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK)
1072 ERROR("unable to get latency timer: %i", status);
1073 return ERROR_JTAG_INIT_FAILED;
1077 DEBUG("current latency timer: %i", latency_timer);
1080 if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK)
1082 ERROR("unable to set timeouts: %i", status);
1083 return ERROR_JTAG_INIT_FAILED;
1086 if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK)
1088 ERROR("unable to enable bit i/o mode: %i", status);
1089 return ERROR_JTAG_INIT_FAILED;
1091 #elif BUILD_FT2232_LIBFTDI == 1
1092 if (ftdi_init(&ftdic) < 0)
1093 return ERROR_JTAG_INIT_FAILED;
1095 /* context, vendor id, product id */
1096 if (ftdi_usb_open(&ftdic, ft2232_vid, ft2232_pid) < 0)
1098 ERROR("unable to open ftdi device: %s", ftdic.error_str);
1099 return ERROR_JTAG_INIT_FAILED;
1102 if (ftdi_usb_reset(&ftdic) < 0)
1104 ERROR("unable to reset ftdi device");
1105 return ERROR_JTAG_INIT_FAILED;
1108 if (ftdi_set_latency_timer(&ftdic, 2) < 0)
1110 ERROR("unable to set latency timer");
1111 return ERROR_JTAG_INIT_FAILED;
1114 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
1116 ERROR("unable to get latency timer");
1117 return ERROR_JTAG_INIT_FAILED;
1121 DEBUG("current latency timer: %i", latency_timer);
1124 ftdic.bitbang_mode = 0; /* Reset controller */
1125 ftdi_enable_bitbang(&ftdic, 0x0b); /* ctx, JTAG I/O mask */
1127 ftdic.bitbang_mode = 2; /* MPSSE mode */
1128 ftdi_enable_bitbang(&ftdic, 0x0b); /* ctx, JTAG I/O mask */
1131 ft2232_buffer_size = 0;
1132 ft2232_buffer = malloc(FT2232_BUFFER_SIZE);
1134 if (layout->init() != ERROR_OK)
1135 return ERROR_JTAG_INIT_FAILED;
1137 ft2232_speed(jtag_speed);
1139 buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */
1140 if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1))
1142 ERROR("couldn't write to FT2232 to disable loopback");
1143 return ERROR_JTAG_INIT_FAILED;
1146 #if BUILD_FT2232_FTD2XX == 1
1147 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
1149 ERROR("error purging ftd2xx device: %i", status);
1150 return ERROR_JTAG_INIT_FAILED;
1152 #elif BUILD_FT2232_LIBFTDI == 1
1153 if (ftdi_usb_purge_buffers(&ftdic) < 0)
1155 ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
1156 return ERROR_JTAG_INIT_FAILED;
1163 int usbjtag_init(void)
1169 low_direction = 0x0b;
1171 if (strcmp(ft2232_layout, "usbjtag") == 0)
1178 else if (strcmp(ft2232_layout, "signalyzer") == 0)
1185 else if (strcmp(ft2232_layout, "evb_lm3s811") == 0)
1192 low_direction = 0x8b;
1196 ERROR("BUG: usbjtag_init called for unknown layout '%s'", ft2232_layout);
1197 return ERROR_JTAG_INIT_FAILED;
1200 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1202 low_direction &= ~nTRSTnOE; /* nTRST input */
1203 low_output &= ~nTRST; /* nTRST = 0 */
1207 low_direction |= nTRSTnOE; /* nTRST output */
1208 low_output |= nTRST; /* nTRST = 1 */
1211 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1213 low_direction |= nSRSTnOE; /* nSRST output */
1214 low_output |= nSRST; /* nSRST = 1 */
1218 low_direction &= ~nSRSTnOE; /* nSRST input */
1219 low_output &= ~nSRST; /* nSRST = 0 */
1222 /* initialize low byte for jtag */
1223 buf[0] = 0x80; /* command "set data bits low byte" */
1224 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, xRST high) */
1225 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */
1226 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1228 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1230 ERROR("couldn't initialize FT2232 with 'USBJTAG' layout");
1231 return ERROR_JTAG_INIT_FAILED;
1237 int jtagkey_init(void)
1243 low_direction = 0x1b;
1245 /* initialize low byte for jtag */
1246 buf[0] = 0x80; /* command "set data bits low byte" */
1247 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1248 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1249 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1251 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1253 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1254 return ERROR_JTAG_INIT_FAILED;
1257 if (strcmp(layout->name, "jtagkey") == 0)
1264 else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0) ||
1265 (strcmp(layout->name, "oocdlink") == 0))
1274 ERROR("BUG: jtagkey_init called for non jtagkey layout");
1279 high_direction = 0x0f;
1281 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1283 high_output |= nTRSTnOE;
1284 high_output &= ~nTRST;
1288 high_output &= ~nTRSTnOE;
1289 high_output |= nTRST;
1292 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1294 high_output &= ~nSRSTnOE;
1295 high_output |= nSRST;
1299 high_output |= nSRSTnOE;
1300 high_output &= ~nSRST;
1303 /* initialize high port */
1304 buf[0] = 0x82; /* command "set data bits high byte" */
1305 buf[1] = high_output; /* value */
1306 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1307 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1309 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1311 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1312 return ERROR_JTAG_INIT_FAILED;
1318 int olimex_jtag_init(void)
1324 low_direction = 0x1b;
1326 /* initialize low byte for jtag */
1327 buf[0] = 0x80; /* command "set data bits low byte" */
1328 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1329 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */
1330 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1332 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1334 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1335 return ERROR_JTAG_INIT_FAILED;
1341 nSRSTnOE = 0x00; /* no output enable for nSRST */
1344 high_direction = 0x0f;
1346 if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)
1348 high_output |= nTRSTnOE;
1349 high_output &= ~nTRST;
1353 high_output &= ~nTRSTnOE;
1354 high_output |= nTRST;
1357 if (jtag_reset_config & RESET_SRST_PUSH_PULL)
1359 ERROR("can't set nSRST to push-pull on the Olimex ARM-USB-OCD");
1363 high_output &= ~nSRST;
1366 /* turn red LED on */
1367 high_output |= 0x08;
1369 /* initialize high port */
1370 buf[0] = 0x82; /* command "set data bits high byte" */
1371 buf[1] = high_output; /* value */
1372 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1373 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1375 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1377 ERROR("couldn't initialize FT2232 with 'JTAGkey' layout");
1378 return ERROR_JTAG_INIT_FAILED;
1384 int m5960_init(void)
1390 low_direction = 0xfb;
1392 /* initialize low byte for jtag */
1393 buf[0] = 0x80; /* command "set data bits low byte" */
1394 buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */
1395 buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */
1396 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1398 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1400 ERROR("couldn't initialize FT2232 with 'm5960' layout");
1401 return ERROR_JTAG_INIT_FAILED;
1405 nTRSTnOE = 0x0; /* not output enable for nTRST */
1407 nSRSTnOE = 0x00; /* no output enable for nSRST */
1410 high_direction = 0x0c;
1412 /* turn red LED1 on, LED2 off */
1413 high_output |= 0x08;
1415 /* initialize high port */
1416 buf[0] = 0x82; /* command "set data bits high byte" */
1417 buf[1] = high_output; /* value */
1418 buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */
1419 DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]);
1421 if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3))
1423 ERROR("couldn't initialize FT2232 with 'm5960' layout");
1424 return ERROR_JTAG_INIT_FAILED;
1430 void olimex_jtag_blink(void)
1432 /* Olimex ARM-USB-OCD has a LED connected to ACBUS3
1433 * ACBUS3 is bit 3 of the GPIOH port
1435 if (high_output & 0x08)
1437 /* set port pin high */
1438 high_output &= 0x07;
1442 /* set port pin low */
1443 high_output |= 0x08;
1447 BUFFER_ADD = high_output;
1448 BUFFER_ADD = high_direction;
1451 int ft2232_quit(void)
1453 #if BUILD_FT2232_FTD2XX == 1
1456 status = FT_Close(ftdih);
1457 #elif BUILD_FT2232_LIBFTDI == 1
1458 ftdi_disable_bitbang(&ftdic);
1460 ftdi_usb_close(&ftdic);
1462 ftdi_deinit(&ftdic);
1465 free(ft2232_buffer);
1470 int ft2232_handle_device_desc_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1474 ft2232_device_desc = strdup(args[0]);
1478 ERROR("expected exactly one argument to ft2232_device_desc <description>");
1484 int ft2232_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1488 ft2232_serial = strdup(args[0]);
1492 ERROR("expected exactly one argument to ft2232_serial <serial-number>");
1498 int ft2232_handle_layout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1503 ft2232_layout = malloc(strlen(args[0]) + 1);
1504 strcpy(ft2232_layout, args[0]);
1509 int ft2232_handle_vid_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1513 ft2232_vid = strtol(args[0], NULL, 0);
1514 ft2232_pid = strtol(args[1], NULL, 0);
1518 WARNING("incomplete ft2232_vid_pid configuration directive");