ftdi.c - description
-------------------
begin : Fri Apr 4 2003
- copyright : (C) 2003 by Intra2net AG
+ copyright : (C) 2003-2008 by Intra2net AG
email : opensource@intra2net.com
***************************************************************************/
#include "ftdi.h"
/* stuff needed for async write */
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <sys/select.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <linux/usbdevice_fs.h>
+#ifdef LIBFTDI_LINUX_ASYNC_MODE
+ #include <sys/ioctl.h>
+ #include <sys/time.h>
+ #include <sys/select.h>
+ #include <sys/types.h>
+ #include <unistd.h>
+ #include <linux/usbdevice_fs.h>
+#endif
#define ftdi_error_return(code, str) do { \
ftdi->error_str = str; \
ftdi->error_str = NULL;
+#ifdef LIBFTDI_LINUX_ASYNC_MODE
ftdi->async_usb_buffer_size=10;
if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
ftdi_error_return(-1, "out of memory for async usb buffer");
/* initialize async usb buffer with unused-marker */
for (i=0; i < ftdi->async_usb_buffer_size; i++)
((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
+#else
+ ftdi->async_usb_buffer_size=0;
+ ftdi->async_usb_buffer = NULL;
+#endif
+
+ ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
/* All fine. Now allocate the readbuffer */
return ftdi_read_data_set_chunksize(ftdi, 4096);
}
/**
+ Allocate and initialize a new ftdi_context
+
+ \return a pointer to a new ftdi_context, or NULL on failure
+*/
+struct ftdi_context *ftdi_new()
+{
+ struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
+
+ if (ftdi == NULL) {
+ return NULL;
+ }
+
+ if (ftdi_init(ftdi) != 0) {
+ free(ftdi);
+ return NULL;
+ }
+
+ return ftdi;
+}
+
+/**
Open selected channels on a chip, otherwise use first channel.
\param ftdi pointer to ftdi_context
}
/**
+ Deinitialize and free an ftdi_context.
+
+ \param ftdi pointer to ftdi_context
+*/
+void ftdi_free(struct ftdi_context *ftdi)
+{
+ ftdi_deinit(ftdi);
+ free(ftdi);
+}
+
+/**
Use an already open libusb device.
\param ftdi pointer to ftdi_context
curdev = devlist;
*curdev = NULL;
- for (bus = usb_busses; bus; bus = bus->next) {
+ for (bus = usb_get_busses(); bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
if (dev->descriptor.idVendor == vendor
&& dev->descriptor.idProduct == product)
}
/**
+ Frees a usb device list.
+
+ \param devlist USB device list created by ftdi_usb_find_all()
+*/
+void ftdi_list_free2(struct ftdi_device_list *devlist)
+{
+ ftdi_list_free(&devlist);
+}
+
+/**
Return device ID strings from the usb device.
The parameters manufacturer, description and serial may be NULL
\param dev libusb usb_dev to use
\retval 0: all fine
+ \retval -3: unable to config device
\retval -4: unable to open device
\retval -5: unable to claim device
\retval -6: reset failed
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
+ // 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!");
+ } else {
+ ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
+ }
+ }
+
if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
usb_close (ftdi->usb_dev);
if (detach_errno == EPERM) {
if (usb_find_devices() < 0)
ftdi_error_return(-2, "usb_find_devices() failed");
- for (bus = usb_busses; bus; bus = bus->next) {
+ for (bus = usb_get_busses(); bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
if (dev->descriptor.idVendor == vendor
&& dev->descriptor.idProduct == product) {
}
/**
- Clears the buffers on the chip.
+ Clears the read buffer on the chip and the internal read buffer.
\param ftdi pointer to ftdi_context
\retval 0: all fine
- \retval -1: write buffer purge failed
- \retval -2: read buffer purge failed
+ \retval -1: read buffer purge failed
*/
-int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
+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)
ftdi_error_return(-1, "FTDI purge of RX buffer failed");
ftdi->readbuffer_offset = 0;
ftdi->readbuffer_remaining = 0;
+ return 0;
+}
+
+/**
+ Clears the write buffer on the chip.
+
+ \param ftdi pointer to ftdi_context
+
+ \retval 0: all fine
+ \retval -1: write buffer purge failed
+*/
+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)
- ftdi_error_return(-2, "FTDI purge of TX buffer failed");
+ ftdi_error_return(-1, "FTDI purge of TX buffer failed");
+
+ return 0;
+}
+
+/**
+ Clears the buffers on the chip and the internal read buffer.
+
+ \param ftdi pointer to ftdi_context
+
+ \retval 0: all fine
+ \retval -1: read buffer purge failed
+ \retval -2: write buffer purge failed
+*/
+int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
+{
+ int result;
+
+ result = ftdi_usb_purge_rx_buffer(ftdi);
+ if (result < 0)
+ return -1;
+
+ result = ftdi_usb_purge_tx_buffer(ftdi);
+ if (result < 0)
+ return -2;
return 0;
}
{
int rtn = 0;
+#ifdef LIBFTDI_LINUX_ASYNC_MODE
/* try to release some kernel resources */
ftdi_async_complete(ftdi,1);
+#endif
if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
rtn = -1;
return total_written;
}
+#ifdef LIBFTDI_LINUX_ASYNC_MODE
/* this is strongly dependent on libusb using the same struct layout. If libusb
changes in some later version this may break horribly (this is for libusb 0.1.12) */
struct usb_dev_handle {
// some other stuff coming here we don't need
};
-static int usb_get_async_urbs_pending(struct ftdi_context *ftdi)
+/**
+ Check for pending async urbs
+ \internal
+*/
+static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
{
struct usbdevfs_urb *urb;
int pending=0;
return pending;
}
-static void usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
+/**
+ Wait until one or more async URBs are completed by the kernel and mark their
+ positions in the async-buffer as unused
+
+ \param ftdi pointer to ftdi_context
+ \param wait_for_more if != 0 wait for more than one write to complete
+ \param timeout_msec max milliseconds to wait
+
+ \internal
+*/
+static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
{
struct timeval tv;
struct usbdevfs_urb *urb=NULL;
tv.tv_usec = (timeout_msec % 1000) * 1000;
do {
- while (usb_get_async_urbs_pending(ftdi)
+ while (_usb_get_async_urbs_pending(ftdi)
&& (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
&& errno == EAGAIN)
{
}
/**
- Wait until at least one async write is complete
+ Wait until one or more async URBs are completed by the kernel and mark their
+ positions in the async-buffer as unused.
\param ftdi pointer to ftdi_context
\param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
*/
void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
{
- usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
+ _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
}
/**
Stupid libusb does not offer async writes nor does it allow
access to its fd - so we need some hacks here.
+ \internal
*/
-static int usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
+static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
{
struct usbdevfs_urb *urb;
int bytesdone = 0, requested;
{
if (i==ftdi->async_usb_buffer_size) {
/* wait until some buffers are free */
- usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
+ _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
}
for (i=0; i < ftdi->async_usb_buffer_size; i++) {
caller of completion or error - but this is not done yet, volunteers welcome.
Works around libusb and directly accesses functions only available on Linux.
+ Only available if compiled with --with-async-mode.
\param ftdi pointer to ftdi_context
\param buf Buffer with the data
if (offset+write_size > size)
write_size = size-offset;
- ret = usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
+ ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
if (ret < 0)
ftdi_error_return(ret, "usb bulk write async failed");
return total_written;
}
-
+#endif // LIBFTDI_LINUX_ASYNC_MODE
/**
Configure write buffer chunk size.
}
/**
+ Poll modem status information
+
+ This function allows the retrieve the two status bytes of the device.
+ The device sends these bytes also as a header for each read access
+ where they are discarded by ftdi_read_data(). The chip generates
+ the two stripped status bytes in the absence of data every 40 ms.
+
+ Layout of the first byte:
+ - B0..B3 - must be 0
+ - B4 Clear to send (CTS)
+ 0 = inactive
+ 1 = active
+ - B5 Data set ready (DTS)
+ 0 = inactive
+ 1 = active
+ - B6 Ring indicator (RI)
+ 0 = inactive
+ 1 = active
+ - B7 Receive line signal detect (RLSD)
+ 0 = inactive
+ 1 = active
+
+ Layout of the second byte:
+ - B0 Data ready (DR)
+ - B1 Overrun error (OE)
+ - B2 Parity error (PE)
+ - B3 Framing error (FE)
+ - B4 Break interrupt (BI)
+ - B5 Transmitter holding register (THRE)
+ - B6 Transmitter empty (TEMT)
+ - B7 Error in RCVR FIFO
+
+ \param ftdi pointer to ftdi_context
+ \param status Pointer to store status information in. Must be two bytes.
+
+ \retval 0: all fine
+ \retval -1: unable to retrieve status information
+*/
+int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
+{
+ char usb_val[2];
+
+ if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 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];
+
+ return 0;
+}
+
+/**
+ Set the special event character
+
+ \param ftdi pointer to ftdi_context
+ \param eventch Event character
+ \param enable 0 to disable the event character, non-zero otherwise
+
+ \retval 0: all fine
+ \retval -1: unable to set event character
+*/
+int ftdi_set_event_char(struct ftdi_context *ftdi,
+ unsigned char eventch, unsigned char enable)
+{
+ unsigned short usb_val;
+
+ usb_val = eventch;
+ 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)
+ ftdi_error_return(-1, "setting event character failed");
+
+ return 0;
+}
+
+/**
+ Set error character
+
+ \param ftdi pointer to ftdi_context
+ \param errorch Error character
+ \param enable 0 to disable the error character, non-zero otherwise
+
+ \retval 0: all fine
+ \retval -1: unable to set error character
+*/
+int ftdi_set_error_char(struct ftdi_context *ftdi,
+ unsigned char errorch, unsigned char enable)
+{
+ unsigned short usb_val;
+
+ usb_val = errorch;
+ 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)
+ ftdi_error_return(-1, "setting error character failed");
+
+ return 0;
+}
+
+/**
+ Set the eeprom size
+
+ \param ftdi pointer to ftdi_context
+ \param eeprom Pointer to ftdi_eeprom
+ \param size
+
+*/
+void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
+{
+ ftdi->eeprom_size=size;
+ eeprom->size=size;
+}
+
+/**
Init eeprom with default values.
\param eeprom Pointer to ftdi_eeprom
eeprom->manufacturer = NULL;
eeprom->product = NULL;
eeprom->serial = NULL;
+
+ eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
}
/**
if (eeprom->serial != NULL)
serial_size = strlen(eeprom->serial);
- size_check = 128; // eeprom is 128 bytes
+ 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;
return (-1);
// empty eeprom
- memset (output, 0, 128);
+ memset (output, 0, eeprom->size);
// Addr 00: Stay 00 00
// Addr 02: Vendor ID
output[0x07] = 0x02;
// Addr 08: Config descriptor
- // Bit 1: remote wakeup if 1
- // Bit 0: self powered if 1
- //
- j = 0;
+ // 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 = 0x80;
if (eeprom->self_powered == 1)
- j = j | 1;
+ j |= 0x40;
if (eeprom->remote_wakeup == 1)
- j = j | 2;
+ j |= 0x20;
output[0x08] = j;
// Addr 09: Max power consumption: max power = value * 2 mA
output[0x09] = eeprom->max_power;
- ;
// Addr 0A: Chip configuration
// Bit 7: 0 - reserved
}
- // Addr 0E: Offset of the manufacturer string + 0x80
- output[0x0E] = 0x14 + 0x80;
-
+ // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
// Addr 0F: Length of manufacturer string
output[0x0F] = manufacturer_size*2 + 2;
output[0x13] = serial_size*2 + 2;
// Dynamic content
- output[0x14] = manufacturer_size*2 + 2;
- output[0x15] = 0x03; // type: string
+ i=0x14;
+ if(eeprom->size>=256) i = 0x80;
- i = 0x16, j = 0;
- // Output manufacturer
+ // Output manufacturer
+ output[0x0E] = i | 0x80; // calculate offset
+ output[i++] = manufacturer_size*2 + 2;
+ output[i++] = 0x03; // type: string
for (j = 0; j < manufacturer_size; j++) {
output[i] = eeprom->manufacturer[j], i++;
output[i] = 0x00, i++;
}
// Output product name
- output[0x10] = i + 0x80; // calculate offset
+ output[0x10] = i | 0x80; // calculate offset
output[i] = product_size*2 + 2, i++;
output[i] = 0x03, i++;
for (j = 0; j < product_size; j++) {
}
// Output serial
- output[0x12] = i + 0x80; // calculate offset
+ output[0x12] = i | 0x80; // calculate offset
output[i] = serial_size*2 + 2, i++;
output[i] = 0x03, i++;
for (j = 0; j < serial_size; j++) {
// calculate checksum
checksum = 0xAAAA;
- for (i = 0; i < 63; i++) {
+ for (i = 0; i < eeprom->size/2-1; i++) {
value = output[i*2];
value += output[(i*2)+1] << 8;
checksum = (checksum << 1) | (checksum >> 15);
}
- output[0x7E] = checksum;
- output[0x7F] = checksum >> 8;
+ output[eeprom->size-2] = checksum;
+ output[eeprom->size-1] = checksum >> 8;
return size_check;
}
{
int i;
- for (i = 0; i < 64; 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)
ftdi_error_return(-1, "reading eeprom failed");
}
}
/**
+ Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
+ Call this function then do a write then call again to see if size changes, if so write again.
+
+ \param ftdi pointer to ftdi_context
+ \param eeprom Pointer to store eeprom into
+ \param maxsize the size of the buffer to read into
+
+ \retval size of eeprom
+*/
+int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
+{
+ int i=0,j,minsize=32;
+ int size=minsize;
+
+ 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)
+ ftdi_error_return(-1, "reading eeprom failed");
+ i++;
+ }
+ size*=2;
+ }while(size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
+
+ return size/2;
+}
+
+/**
Write eeprom
\param ftdi pointer to ftdi_context
unsigned short usb_val;
int i;
- for (i = 0; i < 64; i++) {
+ 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)