/** \addtogroup libftdi */
/* @{ */
-#include <usb.h>
+#include <libusb.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
+#include <stdlib.h>
#include "ftdi.h"
-/* stuff needed for async write */
-#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; \
return code; \
} while(0);
+
/**
Internal function to close usb device pointer.
Sets ftdi->usb_dev to NULL.
\param ftdi pointer to ftdi_context
- \retval zero if all is fine, otherwise error code from usb_close()
+ \retval none
*/
-static int ftdi_usb_close_internal (struct ftdi_context *ftdi)
+static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
{
- int ret = 0;
-
if (ftdi->usb_dev)
{
- ret = usb_close (ftdi->usb_dev);
+ libusb_close (ftdi->usb_dev);
ftdi->usb_dev = NULL;
}
-
- return ret;
}
/**
*/
int ftdi_init(struct ftdi_context *ftdi)
{
- unsigned int i;
-
ftdi->usb_dev = NULL;
ftdi->usb_read_timeout = 5000;
ftdi->usb_write_timeout = 5000;
ftdi->type = TYPE_BM; /* chip type */
ftdi->baudrate = -1;
- ftdi->bitbang_enabled = 0;
+ ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
ftdi->readbuffer = NULL;
ftdi->readbuffer_offset = 0;
ftdi->index = 0;
ftdi->in_ep = 0x02;
ftdi->out_ep = 0x81;
- ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
+ ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
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 */
{
ftdi_usb_close_internal (ftdi);
- if (ftdi->async_usb_buffer != NULL)
- {
- free(ftdi->async_usb_buffer);
- ftdi->async_usb_buffer = NULL;
- }
-
if (ftdi->readbuffer != NULL)
{
free(ftdi->readbuffer);
Use an already open libusb device.
\param ftdi pointer to ftdi_context
- \param usb libusb usb_dev_handle to use
+ \param usb libusb libusb_device_handle to use
*/
-void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
+void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
{
ftdi->usb_dev = usb;
}
\param product Product ID to search for
\retval >0: number of devices found
- \retval -1: usb_find_busses() failed
- \retval -2: usb_find_devices() failed
\retval -3: out of memory
+ \retval -4: libusb_init() failed
+ \retval -5: libusb_get_device_list() failed
+ \retval -6: libusb_get_device_descriptor() failed
*/
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
{
struct ftdi_device_list **curdev;
- struct usb_bus *bus;
- struct usb_device *dev;
+ libusb_device *dev;
+ libusb_device **devs;
int count = 0;
+ int i = 0;
+
+ if (libusb_init(NULL) < 0)
+ ftdi_error_return(-4, "libusb_init() failed");
- usb_init();
- if (usb_find_busses() < 0)
- ftdi_error_return(-1, "usb_find_busses() failed");
- if (usb_find_devices() < 0)
- ftdi_error_return(-2, "usb_find_devices() failed");
+ if (libusb_get_device_list(NULL, &devs) < 0)
+ ftdi_error_return(-5, "libusb_get_device_list() failed");
curdev = devlist;
*curdev = NULL;
- for (bus = usb_get_busses(); bus; bus = bus->next)
+
+ while ((dev = devs[i++]) != NULL)
{
- for (dev = bus->devices; dev; dev = dev->next)
- {
- if (dev->descriptor.idVendor == vendor
- && dev->descriptor.idProduct == product)
- {
- *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
- if (!*curdev)
- ftdi_error_return(-3, "out of memory");
+ struct libusb_device_descriptor desc;
- (*curdev)->next = NULL;
- (*curdev)->dev = dev;
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ ftdi_error_return(-6, "libusb_get_device_descriptor() failed");
- curdev = &(*curdev)->next;
- count++;
- }
+ if (desc.idVendor == vendor && desc.idProduct == product)
+ {
+ *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
+ if (!*curdev)
+ ftdi_error_return(-3, "out of memory");
+
+ (*curdev)->next = NULL;
+ (*curdev)->dev = dev;
+
+ curdev = &(*curdev)->next;
+ count++;
}
}
\retval -7: get product manufacturer failed
\retval -8: get product description failed
\retval -9: get serial number failed
- \retval -10: unable to close device
+ \retval -11: libusb_get_device_descriptor() failed
*/
-int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
+int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
{
+ struct libusb_device_descriptor desc;
+
if ((ftdi==NULL) || (dev==NULL))
return -1;
- if (!(ftdi->usb_dev = usb_open(dev)))
- ftdi_error_return(-4, usb_strerror());
+ if (libusb_open(dev, &ftdi->usb_dev) < 0)
+ ftdi_error_return(-4, "libusb_open() failed");
+
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
if (manufacturer != NULL)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0)
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
{
ftdi_usb_close_internal (ftdi);
- ftdi_error_return(-7, usb_strerror());
+ ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
}
}
if (description != NULL)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0)
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
{
ftdi_usb_close_internal (ftdi);
- ftdi_error_return(-8, usb_strerror());
+ ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
}
}
if (serial != NULL)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0)
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
{
ftdi_usb_close_internal (ftdi);
- ftdi_error_return(-9, usb_strerror());
+ ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
}
}
- if (ftdi_usb_close_internal (ftdi) != 0)
- ftdi_error_return(-10, usb_strerror());
+ ftdi_usb_close_internal (ftdi);
return 0;
}
* \param dev libusb usb_dev to use
* \retval Maximum packet size for this device
*/
-static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, struct usb_device *dev)
+static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
{
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *config0;
unsigned int packet_size;
// Determine maximum packet size. Init with default value.
else
packet_size = 64;
- if (dev->descriptor.bNumConfigurations > 0 && dev->config)
- {
- struct usb_config_descriptor config = dev->config[0];
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ return packet_size;
- if (ftdi->interface < config.bNumInterfaces)
+ if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
+ return packet_size;
+
+ if (desc.bNumConfigurations > 0)
+ {
+ if (ftdi->interface < config0->bNumInterfaces)
{
- struct usb_interface interface = config.interface[ftdi->interface];
+ struct libusb_interface interface = config0->interface[ftdi->interface];
if (interface.num_altsetting > 0)
{
- struct usb_interface_descriptor descriptor = interface.altsetting[0];
+ struct libusb_interface_descriptor descriptor = interface.altsetting[0];
if (descriptor.bNumEndpoints > 0)
{
packet_size = descriptor.endpoint[0].wMaxPacketSize;
}
}
+ libusb_free_config_descriptor (config0);
return packet_size;
}
/**
- Opens a ftdi device given by a usb_device.
+ Opens a ftdi device given by an usb_device.
\param ftdi pointer to ftdi_context
\param dev libusb usb_dev to use
\retval -5: unable to claim device
\retval -6: reset failed
\retval -7: set baudrate failed
+ \retval -9: libusb_get_device_descriptor() failed
+ \retval -10: libusb_get_config_descriptor() failed
+ \retval -11: libusb_etach_kernel_driver() failed
+ \retval -12: libusb_get_configuration() failed
*/
-int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
+int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
{
- int detach_errno = 0;
- int config_val = 1;
- if (!(ftdi->usb_dev = usb_open(dev)))
- ftdi_error_return(-4, "usb_open() failed");
+ struct libusb_device_descriptor desc;
+ struct libusb_config_descriptor *config0;
+ int cfg, cfg0;
+
+ if (libusb_open(dev, &ftdi->usb_dev) < 0)
+ ftdi_error_return(-4, "libusb_open() failed");
+
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
+
+ if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
+ ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
+ cfg0 = config0->bConfigurationValue;
+ libusb_free_config_descriptor (config0);
#ifdef LIBUSB_HAS_GET_DRIVER_NP
// Try to detach ftdi_sio kernel module.
// 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;
+ ret = libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface);
+ if (ret < 0 && ret != LIBUSB_ERROR_NOT_FOUND)
+ ftdi_error_return(-11, "libusb_detach_kernel_driver () failed");
#endif
-#ifdef __WIN32__
+ if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
+ ftdi_error_return(-12, "libusb_get_configuration () failed");
+
// 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)
+ if (desc.bNumConfigurations > 0 && cfg != cfg0)
{
- // libusb-win32 on Windows 64 can return a null pointer for a valid device
- if (dev->config)
- config_val = dev->config[0].bConfigurationValue;
-
- if (usb_set_configuration(ftdi->usb_dev, config_val) &&
- errno != EBUSY)
+ if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
{
ftdi_usb_close_internal (ftdi);
- 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!");
- }
+ ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
}
}
-#endif
- if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0)
+ if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
{
ftdi_usb_close_internal (ftdi);
- if (detach_errno == EPERM)
- {
- ftdi_error_return(-8, "inappropriate permissions on device!");
- }
- else
- {
- ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
- }
+ ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
}
if (ftdi_usb_reset (ftdi) != 0)
// Try to guess chip type
// Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
- if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
- && dev->descriptor.iSerialNumber == 0))
+ if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
+ && desc.iSerialNumber == 0))
ftdi->type = TYPE_BM;
- else if (dev->descriptor.bcdDevice == 0x200)
+ else if (desc.bcdDevice == 0x200)
ftdi->type = TYPE_AM;
- else if (dev->descriptor.bcdDevice == 0x500)
+ else if (desc.bcdDevice == 0x500)
ftdi->type = TYPE_2232C;
- else if (dev->descriptor.bcdDevice == 0x600)
+ else if (desc.bcdDevice == 0x600)
ftdi->type = TYPE_R;
- else if (dev->descriptor.bcdDevice == 0x700)
+ else if (desc.bcdDevice == 0x700)
ftdi->type = TYPE_2232H;
- else if (dev->descriptor.bcdDevice == 0x800)
+ else if (desc.bcdDevice == 0x800)
ftdi->type = TYPE_4232H;
// Set default interface on dual/quad type chips
\param serial Serial to search for. Use NULL if not needed.
\retval 0: all fine
- \retval -1: usb_find_busses() failed
- \retval -2: usb_find_devices() failed
\retval -3: usb device not found
\retval -4: unable to open device
\retval -5: unable to claim device
\retval -7: set baudrate failed
\retval -8: get product description failed
\retval -9: get serial number failed
- \retval -10: unable to close device
+ \retval -11: libusb_init() failed
+ \retval -12: libusb_get_device_list() failed
+ \retval -13: libusb_get_device_descriptor() failed
*/
int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
const char* description, const char* serial)
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
const char* description, const char* serial, unsigned int index)
{
- struct usb_bus *bus;
- struct usb_device *dev;
+ libusb_device *dev;
+ libusb_device **devs;
char string[256];
+ int i = 0;
- usb_init();
+ if (libusb_init(NULL) < 0)
+ ftdi_error_return(-11, "libusb_init() failed");
- if (usb_find_busses() < 0)
- ftdi_error_return(-1, "usb_find_busses() failed");
- if (usb_find_devices() < 0)
- ftdi_error_return(-2, "usb_find_devices() failed");
+ if (libusb_get_device_list(NULL, &devs) < 0)
+ ftdi_error_return(-12, "libusb_get_device_list() failed");
- for (bus = usb_get_busses(); bus; bus = bus->next)
+ while ((dev = devs[i++]) != NULL)
{
- for (dev = bus->devices; dev; dev = dev->next)
+ struct libusb_device_descriptor desc;
+
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ ftdi_error_return(-13, "libusb_get_device_descriptor() failed");
+
+ if (desc.idVendor == vendor && desc.idProduct == product)
{
- if (dev->descriptor.idVendor == vendor
- && dev->descriptor.idProduct == product)
- {
- if (!(ftdi->usb_dev = usb_open(dev)))
- ftdi_error_return(-4, "usb_open() failed");
+ if (libusb_open(dev, &ftdi->usb_dev) < 0)
+ ftdi_error_return(-4, "usb_open() failed");
- if (description != NULL)
+ if (description != NULL)
+ {
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
+ {
+ libusb_close (ftdi->usb_dev);
+ ftdi_error_return(-8, "unable to fetch product description");
+ }
+ if (strncmp(string, description, sizeof(string)) != 0)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
- {
- ftdi_usb_close_internal (ftdi);
- ftdi_error_return(-8, "unable to fetch product description");
- }
- if (strncmp(string, description, sizeof(string)) != 0)
- {
- if (ftdi_usb_close_internal (ftdi) != 0)
- ftdi_error_return(-10, "unable to close device");
- continue;
- }
+ libusb_close (ftdi->usb_dev);
+ continue;
}
- if (serial != NULL)
+ }
+ if (serial != NULL)
+ {
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
- {
- ftdi_usb_close_internal (ftdi);
- ftdi_error_return(-9, "unable to fetch serial number");
- }
- if (strncmp(string, serial, sizeof(string)) != 0)
- {
- if (ftdi_usb_close_internal (ftdi) != 0)
- ftdi_error_return(-10, "unable to close device");
- continue;
- }
+ ftdi_usb_close_internal (ftdi);
+ ftdi_error_return(-9, "unable to fetch serial number");
}
+ if (strncmp(string, serial, sizeof(string)) != 0)
+ {
+ ftdi_usb_close_internal (ftdi);
+ continue;
+ }
+ }
- if (ftdi_usb_close_internal (ftdi) != 0)
- ftdi_error_return(-10, "unable to close device");
+ ftdi_usb_close_internal (ftdi);
if (index > 0)
{
continue;
}
- return ftdi_usb_open_dev(ftdi, dev);
- }
+ return ftdi_usb_open_dev(ftdi, dev);
}
}
\note The description format may be extended in later versions.
\retval 0: all fine
- \retval -1: usb_find_busses() failed
- \retval -2: usb_find_devices() failed
+ \retval -1: libusb_init() failed
+ \retval -2: libusb_get_device_list() failed
\retval -3: usb device not found
\retval -4: unable to open device
\retval -5: unable to claim device
if (description[0] == 'd')
{
- struct usb_bus *bus;
- struct usb_device *dev;
- char dev_name[PATH_MAX+1];
+ libusb_device *dev;
+ libusb_device **devs;
+ unsigned int bus_number, device_address;
+ int i = 0;
+
+ if (libusb_init (NULL) < 0)
+ ftdi_error_return(-1, "libusb_init() failed");
- usb_init();
+ if (libusb_get_device_list(NULL, &devs) < 0)
+ ftdi_error_return(-2, "libusb_get_device_list() failed");
- if (usb_find_busses() < 0)
- ftdi_error_return(-1, "usb_find_busses() failed");
- if (usb_find_devices() < 0)
- ftdi_error_return(-2, "usb_find_devices() failed");
+ /* XXX: This doesn't handle symlinks/odd paths/etc... */
+ if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
+ ftdi_error_return(-11, "illegal description format");
- for (bus = usb_get_busses(); bus; bus = bus->next)
+ while ((dev = devs[i++]) != NULL)
{
- for (dev = bus->devices; dev; dev = dev->next)
- {
- snprintf(dev_name, sizeof(dev_name), "%s/%s",bus->dirname,dev->filename);
- if (strcmp(description+2,dev_name) == 0)
- return ftdi_usb_open_dev(ftdi, dev);
- }
+ if (bus_number == libusb_get_bus_number (dev)
+ && device_address == libusb_get_device_address (dev))
+ return ftdi_usb_open_dev(ftdi, dev);
}
// device not found
unsigned int vendor;
unsigned int product;
unsigned int index=0;
- const char *serial;
+ const char *serial=NULL;
const char *startp, *endp;
errno=0;
*/
int ftdi_usb_reset(struct ftdi_context *ftdi)
{
- 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)
+ if (libusb_control_transfer(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
*/
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
{
- 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)
+ if (libusb_control_transfer(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");
// Invalidate data in the readbuffer
*/
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
{
- 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)
+ if (libusb_control_transfer(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");
return 0;
\retval 0: all fine
\retval -1: usb_release failed
- \retval -2: usb_close failed
*/
int ftdi_usb_close(struct ftdi_context *ftdi)
{
int rtn = 0;
-#ifdef LIBFTDI_LINUX_ASYNC_MODE
- /* try to release some kernel resources */
- ftdi_async_complete(ftdi,1);
-#endif
-
if (ftdi->usb_dev != NULL)
- if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
+ if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
rtn = -1;
- if (ftdi_usb_close_internal (ftdi) != 0)
- rtn = -2;
+ ftdi_usb_close_internal (ftdi);
return rtn;
}
-/*
+/**
ftdi_convert_baudrate returns nearest supported baud rate to that requested.
Function is only used internally
\internal
: (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, FTDI_DEVICE_OUT_REQTYPE,
- SIO_SET_BAUDRATE_REQUEST, value,
- index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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");
ftdi->baudrate = baudrate;
break;
}
- 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)
+ if (libusb_control_transfer(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");
return 0;
*/
int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
{
- int ret;
int offset = 0;
- int total_written = 0;
+ int actual_length;
while (offset < size)
{
if (offset+write_size > size)
write_size = size-offset;
- ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
- if (ret < 0)
- ftdi_error_return(ret, "usb bulk write failed");
+ if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
+ ftdi_error_return(-1, "usb bulk write failed");
- total_written += ret;
- offset += write_size;
+ offset += actual_length;
}
- return total_written;
+ return offset;
}
#ifdef LIBFTDI_LINUX_ASYNC_MODE
#ifdef USB_CLASS_PTP
#error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
#endif
-/* 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
+static void ftdi_read_data_cb(struct libusb_transfer *transfer)
{
- int fd;
- // some other stuff coming here we don't need
-};
+ struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
+ struct ftdi_context *ftdi = tc->ftdi;
+ int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
-/**
- Check for pending async urbs
- \internal
-*/
-static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
+ // New hi-speed devices from FTDI use a packet size of 512 bytes
+ if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
+ packet_size = 512;
+ else
+ packet_size = 64;
+
+ actual_length = transfer->actual_length;
+
+ if (actual_length > 2)
+ {
+ // skip FTDI status bytes.
+ // Maybe stored in the future to enable modem use
+ num_of_chunks = actual_length / packet_size;
+ chunk_remains = actual_length % packet_size;
+ //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
+
+ ftdi->readbuffer_offset += 2;
+ actual_length -= 2;
+
+ if (actual_length > packet_size - 2)
+ {
+ for (i = 1; i < num_of_chunks; i++)
+ memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
+ ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
+ packet_size - 2);
+ if (chunk_remains > 2)
+ {
+ memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
+ ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
+ chunk_remains-2);
+ actual_length -= 2*num_of_chunks;
+ }
+ else
+ actual_length -= 2*(num_of_chunks-1)+chunk_remains;
+ }
+
+ if (actual_length > 0)
+ {
+ // data still fits in buf?
+ if (tc->offset + actual_length <= tc->size)
+ {
+ memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
+ //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
+ tc->offset += actual_length;
+
+ ftdi->readbuffer_offset = 0;
+ ftdi->readbuffer_remaining = 0;
+
+ /* Did we read exactly the right amount of bytes? */
+ if (tc->offset == tc->size)
+ {
+ //printf("read_data exact rem %d offset %d\n",
+ //ftdi->readbuffer_remaining, offset);
+ tc->completed = 1;
+ return;
+ }
+ }
+ else
+ {
+ // only copy part of the data or size <= readbuffer_chunksize
+ int part_size = tc->size - tc->offset;
+ memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
+ tc->offset += part_size;
+
+ ftdi->readbuffer_offset += part_size;
+ ftdi->readbuffer_remaining = actual_length - part_size;
+
+ /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
+ part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
+ tc->completed = 1;
+ return;
+ }
+ }
+ }
+ ret = libusb_submit_transfer (transfer);
+ if (ret < 0)
+ tc->completed = 1;
+}
+
+
+static void ftdi_write_data_cb(struct libusb_transfer *transfer)
{
- struct usbdevfs_urb *urb;
- int pending=0;
- unsigned int i;
+ struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
+ struct ftdi_context *ftdi = tc->ftdi;
- for (i=0; i < ftdi->async_usb_buffer_size; i++)
+ tc->offset = transfer->actual_length;
+
+ if (tc->offset == tc->size)
{
- urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
- if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
- pending++;
+ tc->completed = 1;
}
+ else
+ {
+ int write_size = ftdi->writebuffer_chunksize;
+ int ret;
+
+ if (tc->offset + write_size > tc->size)
+ write_size = tc->size - tc->offset;
- return pending;
+ transfer->length = write_size;
+ transfer->buffer = tc->buf + tc->offset;
+ ret = libusb_submit_transfer (transfer);
+ if (ret < 0)
+ tc->completed = 1;
+ }
}
+
/**
- Wait until one or more async URBs are completed by the kernel and mark their
- positions in the async-buffer as unused
+ Writes data to the chip. Does not wait for completion of the transfer
+ nor does it make sure that the transfer was successful.
+
+ Use libusb 1.0 Asynchronous API.
+ Only available if compiled with --with-async-mode.
\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
+ \param buf Buffer with the data
+ \param size Size of the buffer
- \internal
+ \retval NULL: Some error happens when submit transfer
+ \retval !NULL: Pointer to a ftdi_transfer_control
*/
-static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
+
+struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
{
- struct timeval tv;
- struct usbdevfs_urb *urb=NULL;
- int ret;
- fd_set writefds;
- int keep_going=0;
+ struct ftdi_transfer_control *tc;
+ struct libusb_transfer *transfer = libusb_alloc_transfer(0);
+ int write_size, ret;
- FD_ZERO(&writefds);
- FD_SET(ftdi->usb_dev->fd, &writefds);
+ tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
- /* init timeout only once, select writes time left after call */
- tv.tv_sec = timeout_msec / 1000;
- tv.tv_usec = (timeout_msec % 1000) * 1000;
+ if (!tc || !transfer)
+ return NULL;
- do
- {
- while (_usb_get_async_urbs_pending(ftdi)
- && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
- && errno == EAGAIN)
- {
- if (keep_going && !wait_for_more)
- {
- /* don't wait if repeating only for keep_going */
- keep_going=0;
- break;
- }
+ tc->ftdi = ftdi;
+ tc->completed = 0;
+ tc->buf = buf;
+ tc->size = size;
+ tc->offset = 0;
- /* wait for timeout msec or something written ready */
- select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
- }
+ if (size < ftdi->writebuffer_chunksize)
+ write_size = size;
+ else
+ write_size = ftdi->writebuffer_chunksize;
- if (ret == 0 && urb != NULL)
- {
- /* got a free urb, mark it */
- urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
+ libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf, write_size, ftdi_write_data_cb, tc, ftdi->usb_write_timeout);
+ transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
- /* try to get more urbs that are ready now, but don't wait anymore */
- urb=NULL;
- keep_going=1;
- }
- else
- {
- /* no more urbs waiting */
- keep_going=0;
- }
+ ret = libusb_submit_transfer(transfer);
+ if (ret < 0)
+ {
+ libusb_free_transfer(transfer);
+ tc->completed = 1;
+ tc->transfer = NULL;
+ return NULL;
}
- while (keep_going);
+ tc->transfer = transfer;
+
+ return tc;
}
/**
- Wait until one or more async URBs are completed by the kernel and mark their
- positions in the async-buffer as unused.
+ Reads data from the chip. Does not wait for completion of the transfer
+ nor does it make sure that the transfer was successful.
+
+ Use libusb 1.0 Asynchronous API.
+ Only available if compiled with --with-async-mode.
\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);
-}
+ \param buf Buffer with the data
+ \param size Size of the buffer
-/**
- Stupid libusb does not offer async writes nor does it allow
- access to its fd - so we need some hacks here.
- \internal
+ \retval NULL: Some error happens when submit transfer
+ \retval !NULL: Pointer to a ftdi_transfer_control
*/
-static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
+
+struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
{
- struct usbdevfs_urb *urb;
- int bytesdone = 0, requested;
- int ret, cleanup_count;
- unsigned int i;
+ struct ftdi_transfer_control *tc;
+ struct libusb_transfer *transfer;
+ int ret;
- do
+ tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
+ if (!tc)
+ return NULL;
+
+ tc->ftdi = ftdi;
+ tc->buf = buf;
+ tc->size = size;
+
+ if (size <= ftdi->readbuffer_remaining)
{
- /* find a free urb buffer we can use */
- urb=NULL;
- for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
- {
- if (i==ftdi->async_usb_buffer_size)
- {
- /* wait until some buffers are free */
- _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
- }
+ memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
- for (i=0; i < ftdi->async_usb_buffer_size; i++)
- {
- urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
- if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
- break; /* found a free urb position */
- urb=NULL;
- }
- }
+ // Fix offsets
+ ftdi->readbuffer_remaining -= size;
+ ftdi->readbuffer_offset += size;
- /* no free urb position found */
- if (urb==NULL)
- return -1;
+ /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
- requested = size - bytesdone;
- if (requested > 4096)
- requested = 4096;
+ tc->completed = 1;
+ tc->offset = size;
+ tc->transfer = NULL;
+ return tc;
+ }
- memset(urb,0,sizeof(urb));
+ tc->completed = 0;
+ if (ftdi->readbuffer_remaining != 0)
+ {
+ memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
- urb->type = USBDEVFS_URB_TYPE_BULK;
- urb->endpoint = ep;
- urb->flags = 0;
- urb->buffer = bytes + bytesdone;
- urb->buffer_length = requested;
- urb->signr = 0;
- urb->actual_length = 0;
- urb->number_of_packets = 0;
- urb->usercontext = 0;
+ tc->offset = ftdi->readbuffer_remaining;
+ }
+ else
+ tc->offset = 0;
- do
- {
- ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
- }
- while (ret < 0 && errno == EINTR);
- if (ret < 0)
- return ret; /* the caller can read errno to get more info */
+ transfer = libusb_alloc_transfer(0);
+ if (!transfer)
+ {
+ free (tc);
+ return NULL;
+ }
- bytesdone += requested;
+ ftdi->readbuffer_remaining = 0;
+ ftdi->readbuffer_offset = 0;
+
+ libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi_read_data_cb, tc, ftdi->usb_read_timeout);
+ transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
+
+ ret = libusb_submit_transfer(transfer);
+ if (ret < 0)
+ {
+ libusb_free_transfer(transfer);
+ free (tc);
+ return NULL;
}
- while (bytesdone < size);
- return bytesdone;
+ tc->transfer = transfer;
+
+ return tc;
}
/**
- Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
- Does not wait for completion of the transfer nor does it make sure that
- the transfer was successful.
-
- This function could be extended to use signals and callbacks to inform the
- caller of completion or error - but this is not done yet, volunteers welcome.
+ Wait for completion of the transfer.
- Works around libusb and directly accesses functions only available on Linux.
+ Use libusb 1.0 Asynchronous API.
Only available if compiled with --with-async-mode.
- \param ftdi pointer to ftdi_context
- \param buf Buffer with the data
- \param size Size of the buffer
+ \param tc pointer to ftdi_transfer_control
- \retval <0: error code from usb_bulk_write()
- \retval >0: number of bytes written
+ \retval < 0: Some error happens
+ \retval >= 0: Data size transferred
*/
-int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
+
+int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
{
int ret;
- int offset = 0;
- int total_written = 0;
- while (offset < size)
+ while (!tc->completed)
{
- int write_size = ftdi->writebuffer_chunksize;
-
- if (offset+write_size > size)
- write_size = size-offset;
-
- ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
+ ret = libusb_handle_events(NULL);
if (ret < 0)
- ftdi_error_return(ret, "usb bulk write async failed");
-
- total_written += ret;
- offset += write_size;
+ {
+ if (ret == LIBUSB_ERROR_INTERRUPTED)
+ continue;
+ libusb_cancel_transfer(tc->transfer);
+ while (!tc->completed)
+ if (libusb_handle_events(NULL) < 0)
+ break;
+ libusb_free_transfer(tc->transfer);
+ free (tc);
+ tc = NULL;
+ return ret;
+ }
}
- return total_written;
+ if (tc->transfer->status == LIBUSB_TRANSFER_COMPLETED)
+ ret = tc->offset;
+ else
+ ret = -1;
+
+ libusb_free_transfer(tc->transfer);
+ free(tc);
+ return ret;
}
+
#endif // LIBFTDI_LINUX_ASYNC_MODE
/**
\param buf Buffer to store data in
\param size Size of the buffer
- \retval <0: error code from usb_bulk_read()
+ \retval <0: error code from libusb_bulk_transfer()
\retval 0: no data was available
\retval >0: number of bytes read
- \remark This function is not useful in bitbang mode.
- Use ftdi_read_pins() to get the current state of the pins.
*/
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
{
- int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
+ int offset = 0, ret, i, num_of_chunks, chunk_remains;
int packet_size = ftdi->max_packet_size;
+ int actual_length = 1;
// Packet size sanity check (avoid division by zero)
if (packet_size == 0)
offset += ftdi->readbuffer_remaining;
}
// do the actual USB read
- while (offset < size && ret > 0)
+ while (offset < size && actual_length > 0)
{
ftdi->readbuffer_remaining = 0;
ftdi->readbuffer_offset = 0;
/* returns how much received */
- ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
+ ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
if (ret < 0)
ftdi_error_return(ret, "usb bulk read failed");
- if (ret > 2)
+ if (actual_length > 2)
{
// skip FTDI status bytes.
// Maybe stored in the future to enable modem use
- num_of_chunks = ret / packet_size;
- chunk_remains = ret % packet_size;
- //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
+ num_of_chunks = actual_length / packet_size;
+ chunk_remains = actual_length % packet_size;
+ //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
ftdi->readbuffer_offset += 2;
- ret -= 2;
+ actual_length -= 2;
- if (ret > packet_size - 2)
+ if (actual_length > packet_size - 2)
{
for (i = 1; i < num_of_chunks; i++)
memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
chunk_remains-2);
- ret -= 2*num_of_chunks;
+ actual_length -= 2*num_of_chunks;
}
else
- ret -= 2*(num_of_chunks-1)+chunk_remains;
+ actual_length -= 2*(num_of_chunks-1)+chunk_remains;
}
}
- else if (ret <= 2)
+ else if (actual_length <= 2)
{
// no more data to read?
return offset;
}
- if (ret > 0)
+ if (actual_length > 0)
{
// data still fits in buf?
- if (offset+ret <= size)
+ if (offset+actual_length <= size)
{
- memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
+ memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
//printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
- offset += ret;
+ offset += actual_length;
/* Did we read exactly the right amount of bytes? */
if (offset == size)
memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
ftdi->readbuffer_offset += part_size;
- ftdi->readbuffer_remaining = ret-part_size;
+ ftdi->readbuffer_remaining = actual_length-part_size;
offset += part_size;
- /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
- part_size, size, offset, ret, ftdi->readbuffer_remaining); */
+ /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
+ part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
return offset;
}
/**
Enable bitbang mode.
- For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
+ \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
\param ftdi pointer to ftdi_context
\param bitmask Bitmask to configure lines.
/* FT2232C: Set bitbang_mode to 2 to enable SPI */
usb_val |= (ftdi->bitbang_mode << 8);
- 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)
+ if (libusb_control_transfer(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, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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;
}
/**
- Enable advanced bitbang mode for FT2232C chips.
+ Enable/disable bitbang modes.
\param ftdi pointer to ftdi_context
\param bitmask Bitmask to configure lines.
HIGH/ON value configures a line as output.
- \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
+ \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
\retval 0: all fine
\retval -1: can't enable bitbang mode
usb_val = bitmask; // low byte: bitmask
usb_val |= (mode << 8);
- 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)
+ if (libusb_control_transfer(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;
- ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
+ ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
return 0;
}
/**
- Directly read pin state. Useful for bitbang mode.
+ Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
\param ftdi pointer to ftdi_context
\param pins Pointer to store pins into
*/
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
{
- 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)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (unsigned 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, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (unsigned 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, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, (unsigned char *)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, FTDI_DEVICE_OUT_REQTYPE,
- SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
- NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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");
return 0;
else
usb_val = SIO_SET_DTR_LOW;
- 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)
+ if (libusb_control_transfer(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");
return 0;
else
usb_val = SIO_SET_RTS_LOW;
- 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)
+ if (libusb_control_transfer(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");
return 0;
else
usb_val |= SIO_SET_RTS_LOW;
- 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)
+ if (libusb_control_transfer(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");
return 0;
if (enable)
usb_val |= 1 << 8;
- 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)
+ if (libusb_control_transfer(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, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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;
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;
*/
int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
{
- if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
ftdi_error_return(-1, "reading eeprom failed");
return 0;
for (i = 0; i < ftdi->eeprom_size/2; i++)
{
- 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)
+ if (libusb_control_transfer(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, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (unsigned char *)&a, 2, ftdi->usb_read_timeout) == 2)
{
a = a << 8 | a >> 8;
- 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)
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (unsigned char *)&b, 2, ftdi->usb_read_timeout) == 2)
{
b = b << 8 | b >> 8;
a = (a << 16) | (b & 0xFFFF);
{
for (j = 0; i < maxsize/2 && j<size; j++)
{
- 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)
+ if (libusb_control_transfer(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_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
{
- if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
+ if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
NULL, 0, ftdi->usb_write_timeout) != 0)
ftdi_error_return(-1, "unable to write eeprom");
{
usb_val = eeprom[i*2];
usb_val += eeprom[(i*2)+1] << 8;
- 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)
+ if (libusb_control_transfer(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");
}
*/
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
{
- if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
+ if (libusb_control_transfer(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;
git://developer.intra2net.com / libftdi / blobdiff