\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;
ftdi_error_return(-4, "usb_open() failed");
#ifdef LIBUSB_HAS_GET_DRIVER_NP
- // Try to detach ftdi_sio kernel module
- // Returns ENODATA if driver is not loaded
+ // Try to detach ftdi_sio kernel module.
+ // Returns ENODATA if driver is not loaded.
+ //
+ // The return code is kept in a separate variable and only parsed
+ // if usb_set_configuration() or usb_claim_interface() fails as the
+ // detach operation might be denied and everything still works fine.
+ // Likely scenario is a static ftdi_sio kernel module.
if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
detach_errno = errno;
#endif
- if (usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue)) {
+ // set configuration (needed especially for windows)
+ // tolerate EBUSY: one device with one configuration, but two interfaces
+ // and libftdi sessions to both interfaces (e.g. FT2232)
+ if (dev->descriptor.bNumConfigurations > 0 &&
+ usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue) &&
+ errno != EBUSY)
+ {
usb_close (ftdi->usb_dev);
if (detach_errno == EPERM) {
ftdi_error_return(-8, "inappropriate permissions on device!");
*/
int ftdi_usb_reset(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ 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");
// Invalidate data in the readbuffer
*/
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE,
+ 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");
// Invalidate data in the readbuffer
*/
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE,
+ 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");
return 0;
: (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, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_BAUDRATE_REQUEST_TYPE,
+ SIO_SET_BAUDRATE_REQUEST, value,
+ index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return (-2, "Setting new baudrate failed");
ftdi->baudrate = baudrate;
}
/**
- Set (RS232) line characteristics by Alain Abbas
+ Set (RS232) line characteristics.
+ The break type can only be set via ftdi_set_line_property2()
+ and defaults to "off".
\param ftdi pointer to ftdi_context
\param bits Number of bits
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
{
+ return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
+}
+
+/**
+ Set (RS232) line characteristics
+
+ \param ftdi pointer to ftdi_context
+ \param bits Number of bits
+ \param sbit Number of stop bits
+ \param parity Parity mode
+ \param break_type Break type
+
+ \retval 0: all fine
+ \retval -1: Setting line property failed
+*/
+int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
+ enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
+ enum ftdi_break_type break_type)
+{
unsigned short value = bits;
switch(parity) {
break;
}
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ switch(break_type) {
+ case BREAK_OFF:
+ value |= (0x00 << 14);
+ break;
+ case BREAK_ON:
+ value |= (0x01 << 14);
+ break;
+ }
+
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_DATA_REQUEST_TYPE,
+ SIO_SET_DATA_REQUEST, value,
+ ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return (-1, "Setting new line property failed");
return 0;
}
/**
+ Set flowcontrol for ftdi chip
+
+ \param ftdi pointer to ftdi_context
+ \param flowctrl flow control to use. should be
+ SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
+
+ \retval 0: all fine
+ \retval -1: set flow control failed
+*/
+int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
+{
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
+ SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
+ NULL, 0, ftdi->usb_write_timeout) != 0)
+ ftdi_error_return(-1, "set flow control failed");
+
+ return 0;
+}
+
+/**
+ Set dtr line
+
+ \param ftdi pointer to ftdi_context
+ \param state state to set line to (1 or 0)
+
+ \retval 0: all fine
+ \retval -1: set dtr failed
+*/
+int ftdi_setdtr(struct ftdi_context *ftdi, int state)
+{
+ unsigned short usb_val;
+
+ if (state)
+ usb_val = SIO_SET_DTR_HIGH;
+ else
+ usb_val = SIO_SET_DTR_LOW;
+
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
+ ftdi_error_return(-1, "set dtr failed");
+
+ return 0;
+}
+
+/**
+ Set rts line
+
+ \param ftdi pointer to ftdi_context
+ \param state state to set line to (1 or 0)
+
+ \retval 0: all fine
+ \retval -1 set rts failed
+*/
+int ftdi_setrts(struct ftdi_context *ftdi, int state)
+{
+ unsigned short usb_val;
+
+ if (state)
+ usb_val = SIO_SET_RTS_HIGH;
+ else
+ usb_val = SIO_SET_RTS_LOW;
+
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
+ NULL, 0, ftdi->usb_write_timeout) != 0)
+ ftdi_error_return(-1, "set of rts failed");
+
+ return 0;
+}
+
+/**
+ Set dtr and rts line in one pass
+
+ \param ftdi pointer to ftdi_context
+ \param dtr DTR state to set line to (1 or 0)
+ \param rts RTS state to set line to (1 or 0)
+
+ \retval 0: all fine
+ \retval -1 set dtr/rts failed
+ */
+int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
+{
+ unsigned short usb_val;
+
+ if (dtr)
+ usb_val = SIO_SET_DTR_HIGH;
+ else
+ usb_val = SIO_SET_DTR_LOW;
+
+ if (rts)
+ usb_val |= SIO_SET_RTS_HIGH;
+ else
+ usb_val |= SIO_SET_RTS_LOW;
+
+ if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
+ 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");
+
+ return 0;
+}
+
+/**
Set the special event character
\param ftdi pointer to ftdi_context
return size_check;
}
+void ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf)
+{
+ 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);
+
+/* // Addr 06: Device release number (0400h for BM features) */
+/* output[0x06] = 0x00; */
+
+ if (buf[0x07] == 0x04) eeprom->BM_type_chip = 1;
+
+ // 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&1) eeprom->in_is_isochronous = 1;
+ if (j&2) eeprom->out_is_isochronous = 1;
+ if (j&4) eeprom->suspend_pull_downs = 1;
+ if (j&8) eeprom->use_serial = 1;
+ if (j&16) eeprom->change_usb_version = 1;
+
+/* // Addr 0B: reserved */
+/* output[0x0B] = 0x00; */
+
+ // 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;
+
+ // Dynamic content
+ // if(eeprom->size>=256) i = 0x80;
+
+ // Decode manufacturer
+ i = buf[0x0E] & 0x7f; // offset
+/* printf("debug size: %d, %d\n", buf[i]/2, manufacturer_size); // length */
+/* printf("debug 0x03: %02x\n", buf[i+1]); // type: string */
+ 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
+/* printf("debug size: %d, %d\n", buf[i]/2, product_size); // length */
+/* printf("debug 0x03: %02x\n", buf[i+1]); // type: string */
+ 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
+/* printf("debug size: %d, %d\n", buf[i]/2, serial_size); // length */
+/* printf("debug 0x03: %02x\n", buf[i+1]); // type: string */
+ 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;
+}
+
/**
Read eeprom
*/
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;
return ftdi->error_str;
}
-/*
- Flow control code by Lorenz Moesenlechner (lorenz@hcilab.org)
- and Matthias Kranz (matthias@hcilab.org)
-*/
-/**
- Set flowcontrol for ftdi chip
-
- \param ftdi pointer to ftdi_context
- \param flowctrl flow control to use. should be
- SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
-
- \retval 0: all fine
- \retval -1: set flow control failed
-*/
-int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
-{
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
- SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->interface),
- NULL, 0, ftdi->usb_write_timeout) != 0)
- ftdi_error_return(-1, "set flow control failed");
-
- return 0;
-}
-
-/**
- Set dtr line
-
- \param ftdi pointer to ftdi_context
- \param state state to set line to (1 or 0)
-
- \retval 0: all fine
- \retval -1: set dtr failed
-*/
-int ftdi_setdtr(struct ftdi_context *ftdi, int state)
-{
- unsigned short usb_val;
-
- if (state)
- usb_val = SIO_SET_DTR_HIGH;
- else
- usb_val = SIO_SET_DTR_LOW;
-
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
- SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
- NULL, 0, ftdi->usb_write_timeout) != 0)
- ftdi_error_return(-1, "set dtr failed");
-
- return 0;
-}
-
-/**
- Set rts line
-
- \param ftdi pointer to ftdi_context
- \param state state to set line to (1 or 0)
-
- \retval 0: all fine
- \retval -1 set rts failed
-*/
-int ftdi_setrts(struct ftdi_context *ftdi, int state)
-{
- unsigned short usb_val;
-
- if (state)
- usb_val = SIO_SET_RTS_HIGH;
- else
- usb_val = SIO_SET_RTS_LOW;
-
- if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
- SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface,
- NULL, 0, ftdi->usb_write_timeout) != 0)
- ftdi_error_return(-1, "set of rts failed");
-
- return 0;
-}
-
/* @} end of doxygen libftdi group */
git://developer.intra2net.com / libftdi / blobdiff