1 /***************************************************************************
2 * Driver for USB-JTAG, Altera USB-Blaster and compatibles *
3 * Original code from Kolja Waschk's USB-JTAG project *
4 * (http://www.ixo.de/info/usb_jtag/). *
5 * Some updates by Anthony Liu (2006). *
6 * Minor updates and cleanup by Catalin Patulea (2009). *
7 * Speed updates by Ali Lown (2011). *
9 * Copyright (C) 2011 Ali Lown *
12 * Copyright (C) 2009 Catalin Patulea *
13 * cat@vv.carleton.ca *
15 * Copyright (C) 2006 Kolja Waschk *
18 * Based on ft2232.c and bitbang.c, *
19 * Copyright (C) 2004,2006 by Dominic Rath *
21 * This program is free software; you can redistribute it and/or modify *
22 * it under the terms of the GNU General Public License as published by *
23 * the Free Software Foundation; either version 2 of the License, or *
24 * (at your option) any later version. *
26 * This program is distributed in the hope that it will be useful, *
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
29 * GNU General Public License for more details. *
31 * You should have received a copy of the GNU General Public License *
32 * along with this program; if not, write to the *
33 * Free Software Foundation, Inc., *
34 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
35 ***************************************************************************/
38 * The following information is originally from Kolja Waschk's USB-JTAG,
39 * where it was obtained by reverse engineering an Altera USB-Blaster.
40 * See http://www.ixo.de/info/usb_jtag/ for USB-Blaster block diagram and
41 * usb_jtag-20080705-1200.zip#usb_jtag/host/openocd for protocol.
43 * The same information is also on the UrJTAG mediawiki, with some additional
44 * notes on bits marked as "unknown" by usb_jtag.
45 * (http://sourceforge.net/apps/mediawiki/urjtag/index.php?
46 * title=Cable_Altera_USB-Blaster)
48 * USB-JTAG, Altera USB-Blaster and compatibles are typically implemented as
49 * an FTDIChip FT245 followed by a CPLD which handles a two-mode protocol:
55 * __|__________ _________
57 * USB__| FTDI 245BM |__| EPM7064 |__JTAG (B_TDO,B_TDI,B_TMS,B_TCK)
58 * |_____________| |_________|
59 * __|__________ _|___________
61 * | 6 MHz XTAL | | 24 MHz Osc. |
62 * |_____________| |_____________|
64 * Protocol details are given in the code below.
66 * It is also possible to emulate this configuration using a single-chip USB
67 * controller like the Cypress FX2 (again, see usb_jtag for details).
78 /* project specific includes */
79 #include <jtag/interface.h>
80 #include <jtag/commands.h>
81 #include <helper/time_support.h>
90 #if (BUILD_USB_BLASTER_FTD2XX == 1 && BUILD_USB_BLASTER_LIBFTDI == 1)
91 #error "BUILD_USB_BLASTER_FTD2XX && BUILD_USB_BLASTER_LIBFTDI "
92 "are mutually exclusive"
93 #elif (BUILD_USB_BLASTER_FTD2XX != 1 && BUILD_USB_BLASTER_LIBFTDI != 1)
94 #error "BUILD_USB_BLASTER_FTD2XX || BUILD_USB_BLASTER_LIBFTDI must be chosen"
97 /* USB_BLASTER access library includes */
98 #if BUILD_USB_BLASTER_FTD2XX == 1
100 #include "ftd2xx_common.h"
101 #elif BUILD_USB_BLASTER_LIBFTDI == 1
105 #include <sys/time.h>
108 static char *usb_blaster_device_desc;
109 static uint16_t usb_blaster_vid = 0x09fb; /* Altera */
110 static uint16_t usb_blaster_pid = 0x6001; /* USB-Blaster */
112 /* last output byte in simple bit banging (legacy) mode */
113 static uint8_t out_value;
114 /* global output buffer for bit banging */
115 #define BUF_LEN 64 //Size of EP1
116 static uint8_t out_buffer[BUF_LEN];
117 static uint16_t out_count = 0;
119 #if BUILD_USB_BLASTER_FTD2XX == 1
120 static FT_HANDLE ftdih;
121 #elif BUILD_USB_BLASTER_LIBFTDI == 1
122 static struct ftdi_context ftdic;
125 static int usb_blaster_buf_write(
126 uint8_t *buf, int size, uint32_t *bytes_written)
128 #if BUILD_USB_BLASTER_FTD2XX == 1
130 DWORD dw_bytes_written;
132 #ifdef _DEBUG_JTAG_IO_
133 LOG_DEBUG("usb_blaster_buf_write %02X (%d)", buf[0], size);
135 status = FT_Write(ftdih, buf, size, &dw_bytes_written);
138 *bytes_written = dw_bytes_written;
139 LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(status));
140 return ERROR_JTAG_DEVICE_ERROR;
142 *bytes_written = dw_bytes_written;
144 #elif BUILD_USB_BLASTER_LIBFTDI == 1
146 #ifdef _DEBUG_JTAG_IO_
147 LOG_DEBUG("usb_blaster_buf_write %02X (%d)", buf[0], size);
149 retval = ftdi_write_data(&ftdic, buf, size);
153 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&ftdic));
154 return ERROR_JTAG_DEVICE_ERROR;
156 *bytes_written = retval;
162 usb_blaster_buf_read(uint8_t *buf, unsigned size, uint32_t *bytes_read)
164 #if BUILD_USB_BLASTER_FTD2XX == 1
168 status = FT_Read(ftdih, buf, size, &dw_bytes_read);
171 *bytes_read = dw_bytes_read;
172 LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(status));
173 return ERROR_JTAG_DEVICE_ERROR;
175 #ifdef _DEBUG_JTAG_IO_
176 LOG_DEBUG("usb_blaster_buf_read %02X (%" PRIu32 ")", buf[0], dw_bytes_read);
178 *bytes_read = dw_bytes_read;
181 #elif BUILD_USB_BLASTER_LIBFTDI == 1
186 while ((*bytes_read < size) && timeout--)
188 retval = ftdi_read_data(&ftdic, buf + *bytes_read,
193 LOG_ERROR("ftdi_read_data: %s",
194 ftdi_get_error_string(&ftdic));
195 return ERROR_JTAG_DEVICE_ERROR;
197 *bytes_read += retval;
199 #ifdef _DEBUG_JTAG_IO_
200 LOG_DEBUG("usb_blaster_buf_read %02X (%d)", buf[0], *bytes_read);
206 /* The following code doesn't fully utilize the possibilities of the
207 * USB-Blaster. It only buffers data up to the maximum packet size of 64 bytes.
209 * Actually, the USB-Blaster offers a byte-shift mode to transmit up to 504 data
210 * bits (bidirectional) in a single USB packet. A header byte has to be sent as
211 * the first byte in a packet with the following meaning:
213 * Bit 7 (0x80): Must be set to indicate byte-shift mode.
214 * Bit 6 (0x40): If set, the USB-Blaster will also read data, not just write.
215 * Bit 5..0: Define the number N of following bytes
217 * All N following bytes will then be clocked out serially on TDI. If Bit 6 was
218 * set, it will afterwards return N bytes with TDO data read while clocking out
219 * the TDI data. LSB of the first byte after the header byte will appear first
223 /* Simple bit banging mode:
225 * Bit 7 (0x80): Must be zero (see byte-shift mode above)
226 * Bit 6 (0x40): If set, you will receive a byte indicating the state of TDO
228 * Bit 5 (0x20): Output Enable/LED.
229 * Bit 4 (0x10): TDI Output.
230 * Bit 3 (0x08): nCS Output (not used in JTAG mode).
231 * Bit 2 (0x04): nCE Output (not used in JTAG mode).
232 * Bit 1 (0x02): TMS Output.
233 * Bit 0 (0x01): TCK Output.
235 * For transmitting a single data bit, you need to write two bytes. Up to 64
236 * bytes can be combined in a single USB packet.
237 * It isn't possible to read a data without transmitting data.
246 #define READ (1 << 6)
247 #define SHMODE (1 << 7)
248 #define OTHERS ((1 << 2) | (1 << 3) | (1 << 5))
250 #define READ_TDO (1 << 0)
252 static void usb_blaster_write_databuffer(uint8_t* buf, uint16_t len)
254 uint32_t bytes_written;
255 usb_blaster_buf_write(buf, len, &bytes_written);
257 #ifdef _DEBUG_JTAG_IO_
258 LOG_DEBUG("---- WROTE %d",bytes_written);
262 static void usb_blaster_addtowritebuffer(uint8_t value, bool forcewrite)
264 out_buffer[out_count] = value;
266 if(out_count == BUF_LEN || forcewrite)
267 usb_blaster_write_databuffer(out_buffer, out_count);
270 static int usb_blaster_read_data(void)
277 usb_blaster_write_databuffer(out_buffer, out_count);
280 usb_blaster_addtowritebuffer(out_value, true);
283 status = usb_blaster_buf_read(buf, 1, &bytes_read);
287 return !!(buf[0] & READ_TDO);
290 static void usb_blaster_write(int tck, int tms, int tdi)
292 #ifdef _DEBUG_JTAG_IO_
293 LOG_DEBUG("---- usb_blaster_write(%d,%d,%d)", tck, tms, tdi);
295 out_value &= ~(TCK | TMS | TDI);
303 usb_blaster_addtowritebuffer(out_value, false);
306 static int usb_blaster_speed(int speed)
308 #if BUILD_USB_BLASTER_FTD2XX == 1
309 LOG_DEBUG("TODO: usb_blaster_speed() isn't implemented for libftd2xx!");
310 #elif BUILD_USB_BLASTER_LIBFTDI == 1
311 LOG_DEBUG("TODO: usb_blaster_speed() isn't optimally implemented!");
313 /* TODO: libftdi's ftdi_set_baudrate chokes on high rates, use lowlevel
314 * usb function instead! And additionally allow user to throttle.
316 if (ftdi_set_baudrate(&ftdic, 3000000 / 4) < 0)
318 LOG_ERROR("Can't set baud rate to max: %s",
319 ftdi_get_error_string(&ftdic));
320 return ERROR_JTAG_DEVICE_ERROR;
327 static void usb_blaster_reset(int trst, int srst)
329 LOG_DEBUG("TODO: usb_blaster_reset(%d,%d) isn't implemented!",
333 static void usb_blaster_blink(int state)
339 usb_blaster_addtowritebuffer(out_value, true);
342 static struct bitbang_interface usb_blaster_bitbang = {
343 .read = usb_blaster_read_data,
344 .write = usb_blaster_write,
345 .reset = usb_blaster_reset,
346 .blink = usb_blaster_blink,
349 static int usb_blaster_init(void)
351 uint8_t latency_timer;
353 #if BUILD_USB_BLASTER_FTD2XX == 1
357 #if BUILD_USB_BLASTER_FTD2XX == 1
358 LOG_DEBUG("'usb_blaster' interface using FTD2XX");
359 #elif BUILD_USB_BLASTER_LIBFTDI == 1
360 LOG_DEBUG("'usb_blaster' interface using libftdi");
363 #if BUILD_USB_BLASTER_FTD2XX == 1
364 /* Open by device description */
365 if (usb_blaster_device_desc == NULL)
367 LOG_WARNING("no usb_blaster device description specified, "
368 "using default 'USB-Blaster'");
369 usb_blaster_device_desc = "USB-Blaster";
373 /* Add non-standard Vid/Pid to the linux driver */
374 status = FT_SetVIDPID(usb_blaster_vid, usb_blaster_pid);
377 LOG_WARNING("couldn't add %4.4x:%4.4x",
378 usb_blaster_vid, usb_blaster_pid);
382 status = FT_OpenEx(usb_blaster_device_desc, FT_OPEN_BY_DESCRIPTION,
388 LOG_ERROR("unable to open ftdi device: %s",
389 ftd2xx_status_string(status));
390 status = FT_ListDevices(&num_devices, NULL,
391 FT_LIST_NUMBER_ONLY);
394 char **desc_array = malloc(sizeof(char *)
395 * (num_devices + 1));
398 for (i = 0; i < num_devices; i++)
399 desc_array[i] = malloc(64);
400 desc_array[num_devices] = NULL;
402 status = FT_ListDevices(desc_array, &num_devices,
403 FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
407 LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
408 for (i = 0; i < num_devices; i++)
409 LOG_ERROR("%i: %s", i, desc_array[i]);
412 for (i = 0; i < num_devices; i++)
418 printf("ListDevices: NONE\n");
420 return ERROR_JTAG_INIT_FAILED;
423 status = FT_SetLatencyTimer(ftdih, 2);
426 LOG_ERROR("unable to set latency timer: %s",
427 ftd2xx_status_string(status));
428 return ERROR_JTAG_INIT_FAILED;
431 status = FT_GetLatencyTimer(ftdih, &latency_timer);
434 LOG_ERROR("unable to get latency timer: %s",
435 ftd2xx_status_string(status));
436 return ERROR_JTAG_INIT_FAILED;
438 LOG_DEBUG("current latency timer: %i", latency_timer);
440 status = FT_SetBitMode(ftdih, 0x00, 0);
443 LOG_ERROR("unable to disable bit i/o mode: %s",
444 ftd2xx_status_string(status));
445 return ERROR_JTAG_INIT_FAILED;
447 #elif BUILD_USB_BLASTER_LIBFTDI == 1
448 if (ftdi_init(&ftdic) < 0)
449 return ERROR_JTAG_INIT_FAILED;
451 /* context, vendor id, product id */
452 if (ftdi_usb_open(&ftdic, usb_blaster_vid, usb_blaster_pid) < 0)
454 LOG_ERROR("unable to open ftdi device: %s", ftdic.error_str);
455 return ERROR_JTAG_INIT_FAILED;
458 if (ftdi_usb_reset(&ftdic) < 0)
460 LOG_ERROR("unable to reset ftdi device");
461 return ERROR_JTAG_INIT_FAILED;
464 if (ftdi_set_latency_timer(&ftdic, 2) < 0)
466 LOG_ERROR("unable to set latency timer");
467 return ERROR_JTAG_INIT_FAILED;
470 if (ftdi_get_latency_timer(&ftdic, &latency_timer) < 0)
472 LOG_ERROR("unable to get latency timer");
473 return ERROR_JTAG_INIT_FAILED;
475 LOG_DEBUG("current latency timer: %u", latency_timer);
477 ftdi_disable_bitbang(&ftdic);
480 bitbang_interface = &usb_blaster_bitbang;
483 #if BUILD_USB_BLASTER_FTD2XX == 1
484 if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK)
486 LOG_ERROR("error purging ftd2xx device: %i", status);
487 return ERROR_JTAG_INIT_FAILED;
489 #elif BUILD_USB_BLASTER_LIBFTDI == 1
490 if (ftdi_usb_purge_buffers(&ftdic) < 0)
492 LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
493 return ERROR_JTAG_INIT_FAILED;
501 static int usb_blaster_quit(void)
504 usb_blaster_write_databuffer(out_buffer, out_count);
506 #if BUILD_USB_BLASTER_FTD2XX == 1
509 status = FT_Close(ftdih);
510 #elif BUILD_USB_BLASTER_LIBFTDI == 1
511 ftdi_usb_close(&ftdic);
518 COMMAND_HANDLER(usb_blaster_handle_device_desc_command)
521 usb_blaster_device_desc = strdup(CMD_ARGV[0]);
523 LOG_ERROR("require exactly one argument to "
524 "usb_blaster_device_desc <description>");
529 COMMAND_HANDLER(usb_blaster_handle_vid_pid_command)
533 LOG_WARNING("ignoring extra IDs in usb_blaster_vid_pid "
534 "(maximum is 1 pair)");
539 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], usb_blaster_vid);
540 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], usb_blaster_pid);
543 LOG_WARNING("incomplete usb_blaster_vid_pid configuration");
548 COMMAND_HANDLER(usb_blaster_handle_pin_command)
552 const char * const pin_name = CMD_ARGV[0];
556 if (!strcmp(pin_name, "pin6"))
558 else if (!strcmp(pin_name, "pin8"))
562 LOG_ERROR("%s: pin name must be \"pin6\" or \"pin8\"",
564 return ERROR_COMMAND_SYNTAX_ERROR;
567 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], state);
571 usb_blaster_addtowritebuffer(out_value, true);
576 usb_blaster_addtowritebuffer(out_value, true);
580 LOG_ERROR("%s: pin state must be 0 or 1", CMD_NAME);
581 return ERROR_COMMAND_SYNTAX_ERROR;
588 LOG_ERROR("%s takes exactly two arguments", CMD_NAME);
589 return ERROR_COMMAND_SYNTAX_ERROR;
593 static const struct command_registration usb_blaster_command_handlers[] = {
595 .name = "usb_blaster_device_desc",
596 .handler = usb_blaster_handle_device_desc_command,
597 .mode = COMMAND_CONFIG,
598 .help = "set the USB device description of the USB-Blaster",
599 .usage = "description-string",
602 .name = "usb_blaster_vid_pid",
603 .handler = usb_blaster_handle_vid_pid_command,
604 .mode = COMMAND_CONFIG,
605 .help = "the vendor ID and product ID of the USB-Blaster",
609 .name = "usb_blaster",
610 .handler = usb_blaster_handle_pin_command,
612 .help = "set pin state for the unused GPIO pins",
613 .usage = "(pin6|pin8) (0|1)",
615 COMMAND_REGISTRATION_DONE
618 struct jtag_interface usb_blaster_interface = {
619 .name = "usb_blaster",
620 .commands = usb_blaster_command_handlers,
621 .supported = DEBUG_CAP_TMS_SEQ,
623 .execute_queue = bitbang_execute_queue,
625 .speed = usb_blaster_speed,
626 .init = usb_blaster_init,
627 .quit = usb_blaster_quit,