\mainpage libftdi API documentation
Library to talk to FTDI chips. You find the latest versions of libftdi at
- http://www.intra2net.com/de/produkte/opensource/ftdi/
+ http://www.intra2net.com/en/developer/libftdi/
The library is easy to use. Have a look at this short example:
\include simple.c
#include <usb.h>
#include <string.h>
#include <errno.h>
+#include <stdio.h>
#include "ftdi.h"
if (ftdi_init(ftdi) != 0) {
free(ftdi);
- return NULL;
+ return NULL;
}
return ftdi;
*/
int ftdi_usb_reset(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE,
- SIO_RESET_REQUEST, SIO_RESET_SIO,
- ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
- ftdi_error_return(-1,"FTDI reset failed");
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
+ SIO_RESET_REQUEST, SIO_RESET_SIO,
+ ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ ftdi_error_return(-1,"FTDI reset failed");
// Invalidate data in the readbuffer
ftdi->readbuffer_offset = 0;
*/
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "FTDI purge of RX buffer failed");
*/
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "FTDI purge of TX buffer failed");
: (baudrate * 21 < actual_baudrate * 20)))
ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_BAUDRATE_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_BAUDRATE_REQUEST, value,
index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return (-2, "Setting new baudrate failed");
break;
}
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_DATA_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_DATA_REQUEST, value,
ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return (-1, "Setting new line property failed");
/* FT2232C: Set bitbang_mode to 2 to enable SPI */
usb_val |= (ftdi->bitbang_mode << 8);
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
+ SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
ftdi->bitbang_enabled = 1;
*/
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
ftdi->bitbang_enabled = 0;
usb_val = bitmask; // low byte: bitmask
usb_val |= (mode << 8);
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
ftdi->bitbang_mode = mode;
*/
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
{
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
ftdi_error_return(-1, "read pins failed");
return 0;
ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
usb_val = latency;
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-2, "unable to set latency timer");
return 0;
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
{
unsigned short usb_val;
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
ftdi_error_return(-1, "reading latency timer failed");
*latency = (unsigned char)usb_val;
{
char usb_val[2];
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "getting modem status failed");
*status = (usb_val[1] << 8) | usb_val[0];
*/
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
{
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "set flow control failed");
else
usb_val = SIO_SET_DTR_LOW;
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "set dtr failed");
else
usb_val = SIO_SET_RTS_LOW;
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "set of rts failed");
else
usb_val |= SIO_SET_RTS_LOW;
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "set of rts/dtr failed");
if (enable)
usb_val |= 1 << 8;
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x06, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "setting event character failed");
return 0;
if (enable)
usb_val |= 1 << 8;
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x07, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "setting error character failed");
return 0;
}
/**
+ Decode binary EEPROM image into an ftdi_eeprom structure.
+
+ \param eeprom Pointer to ftdi_eeprom which will be filled in.
+ \param output Buffer of \a size bytes of raw eeprom data
+ \param size size size of eeprom data in bytes
+
+ \retval 0: all fine
+ \retval -1: something went wrong
+
+ FIXME: How to pass size? How to handle size field in ftdi_eeprom?
+ FIXME: Strings are malloc'ed here and should be freed somewhere
+*/
+void ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
+{
+ unsigned char i, j;
+ unsigned short checksum, eeprom_checksum, value;
+ unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
+ int size_check;
+ int eeprom_size = 128;
+#if 0
+ size_check = eeprom->size;
+ size_check -= 28; // 28 are always in use (fixed)
+
+ // Top half of a 256byte eeprom is used just for strings and checksum
+ // it seems that the FTDI chip will not read these strings from the lower half
+ // Each string starts with two bytes; offset and type (0x03 for string)
+ // the checksum needs two bytes, so without the string data that 8 bytes from the top half
+ if(eeprom->size>=256)size_check = 120;
+ size_check -= manufacturer_size*2;
+ size_check -= product_size*2;
+ size_check -= serial_size*2;
+
+ // eeprom size exceeded?
+ if (size_check < 0)
+ return (-1);
+#endif
+
+ // empty eeprom struct
+ memset(eeprom, 0, sizeof(struct ftdi_eeprom));
+
+ // Addr 00: Stay 00 00
+
+ // Addr 02: Vendor ID
+ eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
+
+ // Addr 04: Product ID
+ eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
+
+ switch (buf[0x06] + (buf[0x07]<<8)) {
+ case 0x0400:
+ eeprom->BM_type_chip = 1;
+ break;
+ case 0x0200:
+ eeprom->BM_type_chip = 0;
+ break;
+ default: // Unknown device
+ eeprom->BM_type_chip = 0;
+ break;
+ }
+
+ // Addr 08: Config descriptor
+ // Bit 7: always 1
+ // Bit 6: 1 if this device is self powered, 0 if bus powered
+ // Bit 5: 1 if this device uses remote wakeup
+ // Bit 4: 1 if this device is battery powered
+ j = buf[0x08];
+ if (j&0x40) eeprom->self_powered = 1;
+ if (j&0x20) eeprom->remote_wakeup = 1;
+
+ // Addr 09: Max power consumption: max power = value * 2 mA
+ eeprom->max_power = buf[0x09];
+
+ // Addr 0A: Chip configuration
+ // Bit 7: 0 - reserved
+ // Bit 6: 0 - reserved
+ // Bit 5: 0 - reserved
+ // Bit 4: 1 - Change USB version
+ // Bit 3: 1 - Use the serial number string
+ // Bit 2: 1 - Enable suspend pull downs for lower power
+ // Bit 1: 1 - Out EndPoint is Isochronous
+ // Bit 0: 1 - In EndPoint is Isochronous
+ //
+ j = buf[0x0A];
+ if (j&0x01) eeprom->in_is_isochronous = 1;
+ if (j&0x02) eeprom->out_is_isochronous = 1;
+ if (j&0x04) eeprom->suspend_pull_downs = 1;
+ if (j&0x08) eeprom->use_serial = 1;
+ if (j&0x10) eeprom->change_usb_version = 1;
+
+ // Addr 0B: reserved
+
+ // Addr 0C: USB version low byte when 0x0A bit 4 is set
+ // Addr 0D: USB version high byte when 0x0A bit 4 is set
+ if (eeprom->change_usb_version == 1) {
+ eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
+ }
+
+ // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
+ // Addr 0F: Length of manufacturer string
+ manufacturer_size = buf[0x0F]/2;
+ if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
+ else eeprom->manufacturer = NULL;
+
+ // Addr 10: Offset of the product string + 0x80, calculated later
+ // Addr 11: Length of product string
+ product_size = buf[0x11]/2;
+ if (product_size > 0) eeprom->product = malloc(product_size);
+ else eeprom->product = NULL;
+
+ // Addr 12: Offset of the serial string + 0x80, calculated later
+ // Addr 13: Length of serial string
+ serial_size = buf[0x13]/2;
+ if (serial_size > 0) eeprom->serial = malloc(serial_size);
+ else eeprom->serial = NULL;
+
+ // Decode manufacturer
+ i = buf[0x0E] & 0x7f; // offset
+ for (j=0;j<manufacturer_size-1;j++) {
+ eeprom->manufacturer[j] = buf[2*j+i+2];
+ }
+ eeprom->manufacturer[j] = '\0';
+
+ // Decode product name
+ i = buf[0x10] & 0x7f; // offset
+ for (j=0;j<product_size-1;j++) {
+ eeprom->product[j] = buf[2*j+i+2];
+ }
+ eeprom->product[j] = '\0';
+
+ // Decode serial
+ i = buf[0x12] & 0x7f; // offset
+ for (j=0;j<serial_size-1;j++) {
+ eeprom->serial[j] = buf[2*j+i+2];
+ }
+ eeprom->serial[j] = '\0';
+
+ // verify checksum
+ checksum = 0xAAAA;
+
+ for (i = 0; i < eeprom_size/2-1; i++) {
+ value = buf[i*2];
+ value += buf[(i*2)+1] << 8;
+
+ checksum = value^checksum;
+ checksum = (checksum << 1) | (checksum >> 15);
+ }
+
+ eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
+
+ if (eeprom_checksum != checksum) {
+ fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
+ return -1;
+ }
+
+ return 0;
+}
+
+/**
Read eeprom
\param ftdi pointer to ftdi_context
int i;
for (i = 0; i < ftdi->eeprom_size/2; i++) {
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "reading eeprom failed");
}
{
unsigned int a = 0, b = 0;
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
{
a = a << 8 | a >> 8;
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
{
b = b << 8 | b >> 8;
a = (a << 16) | b;
do{
for (j = 0; i < maxsize/2 && j<size; j++) {
- if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
+ SIO_READ_EEPROM_REQUEST, 0, i,
+ eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "reading eeprom failed");
i++;
}
*/
int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
{
- unsigned short usb_val;
+ unsigned short usb_val, status;
int i;
+ /* These commands were traced while running MProg */
+ ftdi_usb_reset(ftdi);
+ ftdi_poll_modem_status(ftdi, &status);
+ ftdi_set_latency_timer(ftdi, 0x77);
+
for (i = 0; i < ftdi->eeprom_size/2; i++) {
usb_val = eeprom[i*2];
usb_val += eeprom[(i*2)+1] << 8;
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
+ SIO_WRITE_EEPROM_REQUEST, usb_val, i,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to write eeprom");
}
/**
Erase eeprom
+ This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
+
\param ftdi pointer to ftdi_context
\retval 0: all fine
*/
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to erase eeprom");
return 0;