/** \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; \
/**
+ Internal function to close usb device pointer.
+ Sets ftdi->usb_dev to NULL.
+ \internal
+
+ \param ftdi pointer to ftdi_context
+
+ \retval none
+*/
+static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
+{
+ if (ftdi->usb_dev)
+ {
+ libusb_close (ftdi->usb_dev);
+ ftdi->usb_dev = NULL;
+ }
+}
+
+/**
Initializes a ftdi_context.
\param ftdi pointer to ftdi_context
*/
int ftdi_init(struct ftdi_context *ftdi)
{
- 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->readbuffer_remaining = 0;
ftdi->writebuffer_chunksize = 4096;
+ ftdi->max_packet_size = 0;
ftdi->interface = 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 */
\return a pointer to a new ftdi_context, or NULL on failure
*/
-struct ftdi_context *ftdi_new()
+struct ftdi_context *ftdi_new(void)
{
struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
Open selected channels on a chip, otherwise use first channel.
\param ftdi pointer to ftdi_context
- \param interface Interface to use for FT2232C chips.
+ \param interface Interface to use for FT2232C/2232H/4232H chips.
\retval 0: all fine
\retval -1: unknown interface
ftdi->in_ep = 0x04;
ftdi->out_ep = 0x83;
break;
+ case INTERFACE_C:
+ ftdi->interface = 2;
+ ftdi->index = INTERFACE_C;
+ ftdi->in_ep = 0x06;
+ ftdi->out_ep = 0x85;
+ break;
+ case INTERFACE_D:
+ ftdi->interface = 3;
+ ftdi->index = INTERFACE_D;
+ ftdi->in_ep = 0x08;
+ ftdi->out_ep = 0x87;
+ break;
default:
ftdi_error_return(-1, "Unknown interface");
}
*/
void ftdi_deinit(struct ftdi_context *ftdi)
{
- if (ftdi->async_usb_buffer != NULL)
- {
- free(ftdi->async_usb_buffer);
- ftdi->async_usb_buffer = NULL;
- }
+ ftdi_usb_close_internal (ftdi);
if (ftdi->readbuffer != NULL)
{
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)
{
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-7, usb_strerror());
+ ftdi_usb_close_internal (ftdi);
+ 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)
{
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-8, usb_strerror());
+ ftdi_usb_close_internal (ftdi);
+ 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)
{
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-9, usb_strerror());
+ ftdi_usb_close_internal (ftdi);
+ ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
}
}
- if (usb_close (ftdi->usb_dev) != 0)
- ftdi_error_return(-10, usb_strerror());
+ ftdi_usb_close_internal (ftdi);
return 0;
}
/**
- Opens a ftdi device given by a usb_device.
+ * Internal function to determine the maximum packet size.
+ * \param ftdi pointer to ftdi_context
+ * \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, 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.
+ // New hi-speed devices from FTDI use a packet size of 512 bytes
+ // but could be connected to a normal speed USB hub -> 64 bytes packet size.
+ if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
+ packet_size = 512;
+ else
+ packet_size = 64;
+
+ if (libusb_get_device_descriptor(dev, &desc) < 0)
+ return packet_size;
+
+ if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
+ return packet_size;
+
+ if (desc.bNumConfigurations > 0)
+ {
+ if (ftdi->interface < config0->bNumInterfaces)
+ {
+ struct libusb_interface interface = config0->interface[ftdi->interface];
+ if (interface.num_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 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;
- 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
+ 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 &&
- usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue) &&
- errno != EBUSY)
+ if (desc.bNumConfigurations > 0 && cfg != cfg0)
{
- usb_close (ftdi->usb_dev);
- if (detach_errno == EPERM)
- {
- ftdi_error_return(-8, "inappropriate permissions on device!");
- }
- else
+ if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
{
+ ftdi_usb_close_internal (ftdi);
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)
+ if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
{
- usb_close (ftdi->usb_dev);
- 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_usb_close_internal (ftdi);
+ ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
}
if (ftdi_usb_reset (ftdi) != 0)
{
- usb_close (ftdi->usb_dev);
+ ftdi_usb_close_internal (ftdi);
ftdi_error_return(-6, "ftdi_usb_reset failed");
}
- if (ftdi_set_baudrate (ftdi, 9600) != 0)
- {
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-7, "set baudrate failed");
- }
-
// 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;
- if (!ftdi->index)
- ftdi->index = INTERFACE_A;
- }
- else if (dev->descriptor.bcdDevice == 0x600)
+ else if (desc.bcdDevice == 0x600)
ftdi->type = TYPE_R;
+ else if (desc.bcdDevice == 0x700)
+ ftdi->type = TYPE_2232H;
+ else if (desc.bcdDevice == 0x800)
+ ftdi->type = TYPE_4232H;
+
+ // Set default interface on dual/quad type chips
+ switch(ftdi->type)
+ {
+ case TYPE_2232C:
+ case TYPE_2232H:
+ case TYPE_4232H:
+ if (!ftdi->index)
+ ftdi->index = INTERFACE_A;
+ break;
+ default:
+ break;
+ }
+
+ // Determine maximum packet size
+ ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
+
+ if (ftdi_set_baudrate (ftdi, 9600) != 0)
+ {
+ ftdi_usb_close_internal (ftdi);
+ ftdi_error_return(-7, "set baudrate failed");
+ }
ftdi_error_return(0, "all fine");
}
\param serial Serial to search for. Use NULL if not needed.
\retval 0: all fine
+ \retval -3: usb device not found
+ \retval -4: unable to open device
+ \retval -5: unable to claim device
+ \retval -6: reset failed
+ \retval -7: set baudrate failed
+ \retval -8: get product description failed
+ \retval -9: get serial number failed
+ \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)
+{
+ return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
+}
+
+/**
+ Opens the index-th device with a given, vendor id, product id,
+ description and serial.
+
+ \param ftdi pointer to ftdi_context
+ \param vendor Vendor ID
+ \param product Product ID
+ \param description Description to search for. Use NULL if not needed.
+ \param serial Serial to search for. Use NULL if not needed.
+ \param index Number of matching device to open if there are more than one, starts with 0.
+
+ \retval 0: all fine
\retval -1: usb_find_busses() failed
\retval -2: usb_find_devices() failed
\retval -3: usb device not found
\retval -9: get serial number failed
\retval -10: unable to close device
*/
-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)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
- {
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-8, "unable to fetch product description");
- }
- if (strncmp(string, description, sizeof(string)) != 0)
- {
- if (usb_close (ftdi->usb_dev) != 0)
- ftdi_error_return(-10, "unable to close device");
- continue;
- }
+ libusb_close (ftdi->usb_dev);
+ ftdi_error_return(-8, "unable to fetch product description");
}
- if (serial != NULL)
+ if (strncmp(string, description, sizeof(string)) != 0)
{
- if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
- {
- usb_close (ftdi->usb_dev);
- ftdi_error_return(-9, "unable to fetch serial number");
- }
- if (strncmp(string, serial, sizeof(string)) != 0)
- {
- if (usb_close (ftdi->usb_dev) != 0)
- ftdi_error_return(-10, "unable to close device");
- continue;
- }
+ libusb_close (ftdi->usb_dev);
+ continue;
}
+ }
+ if (serial != NULL)
+ {
+ if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)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)
+ {
+ ftdi_usb_close_internal (ftdi);
+ continue;
+ }
+ }
- if (usb_close (ftdi->usb_dev) != 0)
- ftdi_error_return(-10, "unable to close device");
+ ftdi_usb_close_internal (ftdi);
- return ftdi_usb_open_dev(ftdi, dev);
- }
+ if (index > 0)
+ {
+ index--;
+ continue;
+ }
+
+ return ftdi_usb_open_dev(ftdi, dev);
}
}
}
/**
+ Opens the ftdi-device described by a description-string.
+ Intended to be used for parsing a device-description given as commandline argument.
+
+ \param ftdi pointer to ftdi_context
+ \param description NULL-terminated description-string, using this format:
+ \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
+ \li <tt>i:\<vendor>:\<product></tt> first device with given vendor and product id, ids can be decimal, octal (preceded by "0") or hex (preceded by "0x")
+ \li <tt>i:\<vendor>:\<product>:\<index></tt> as above with index being the number of the device (starting with 0) if there are more than one
+ \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
+
+ \note The description format may be extended in later versions.
+
+ \retval 0: all fine
+ \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
+ \retval -6: reset failed
+ \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: illegal description format
+*/
+int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
+{
+ if (description[0] == 0 || description[1] != ':')
+ ftdi_error_return(-11, "illegal description format");
+
+ if (description[0] == 'd')
+ {
+ 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");
+
+ if (libusb_get_device_list(NULL, &devs) < 0)
+ ftdi_error_return(-2, "libusb_get_device_list() 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");
+
+ while ((dev = devs[i++]) != NULL)
+ {
+ 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
+ ftdi_error_return(-3, "device not found");
+ }
+ else if (description[0] == 'i' || description[0] == 's')
+ {
+ unsigned int vendor;
+ unsigned int product;
+ unsigned int index=0;
+ const char *serial=NULL;
+ const char *startp, *endp;
+
+ errno=0;
+ startp=description+2;
+ vendor=strtoul((char*)startp,(char**)&endp,0);
+ if (*endp != ':' || endp == startp || errno != 0)
+ ftdi_error_return(-11, "illegal description format");
+
+ startp=endp+1;
+ product=strtoul((char*)startp,(char**)&endp,0);
+ if (endp == startp || errno != 0)
+ ftdi_error_return(-11, "illegal description format");
+
+ if (description[0] == 'i' && *endp != 0)
+ {
+ /* optional index field in i-mode */
+ if (*endp != ':')
+ ftdi_error_return(-11, "illegal description format");
+
+ startp=endp+1;
+ index=strtoul((char*)startp,(char**)&endp,0);
+ if (*endp != 0 || endp == startp || errno != 0)
+ ftdi_error_return(-11, "illegal description format");
+ }
+ if (description[0] == 's')
+ {
+ if (*endp != ':')
+ ftdi_error_return(-11, "illegal description format");
+
+ /* rest of the description is the serial */
+ serial=endp+1;
+ }
+
+ return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
+ }
+ else
+ {
+ ftdi_error_return(-11, "illegal description format");
+ }
+}
+
+/**
Resets the ftdi device.
\param ftdi pointer to ftdi_context
*/
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;
return 0;
}
+
+
/**
Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
\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 (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
- rtn = -1;
+ if (ftdi->usb_dev != NULL)
+ if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
+ rtn = -1;
- if (usb_close (ftdi->usb_dev) != 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
}
// Split into "value" and "index" values
*value = (unsigned short)(encoded_divisor & 0xFFFF);
- if (ftdi->type == TYPE_2232C)
+ if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
{
*index = (unsigned short)(encoded_divisor >> 8);
*index &= 0xFF00;
: (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
-/* 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
+#ifdef USB_CLASS_PTP
+#error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
+#endif
+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;
- int i;
+ struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
+ struct ftdi_context *ftdi = tc->ftdi;
+
+ tc->offset = transfer->actual_length;
- for (i=0; i < ftdi->async_usb_buffer_size; i++)
+ 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;
- return pending;
+ if (tc->offset + write_size > tc->size)
+ write_size = tc->size - tc->offset;
+
+ 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, i;
- int cleanup_count;
+ 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.
+ Wait for completion of the transfer.
- 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.
-
- 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)
+ ftdi_error_return(-1, "max_packet_size is bogus (zero)");
// everything we want is still in the readbuffer?
if (size <= ftdi->readbuffer_remaining)
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 / 64;
- chunk_remains = ret % 64;
- //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 > 62)
+ if (actual_length > packet_size - 2)
{
for (i = 1; i < num_of_chunks; i++)
- memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
- ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
- 62);
+ 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+62*i,
- ftdi->readbuffer+ftdi->readbuffer_offset+64*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;
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 buf Buffer of \a size bytes of raw eeprom data
\param size size size of eeprom data in bytes
\retval 0: all fine
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;
// Addr 04: Product ID
eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
- switch (buf[0x06] + (buf[0x07]<<8))
+ value = buf[0x06] + (buf[0x07]<<8);
+ switch (value)
{
case 0x0400:
eeprom->BM_type_chip = 1;
}
/**
+ Read eeprom location
+
+ \param ftdi pointer to ftdi_context
+ \param eeprom_addr Address of eeprom location to be read
+ \param eeprom_val Pointer to store read eeprom location
+
+ \retval 0: all fine
+ \retval -1: read failed
+*/
+int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
+{
+ 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;
+}
+
+/**
Read eeprom
\param ftdi pointer to ftdi_context
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++;
}
}
/**
+ Write eeprom location
+
+ \param ftdi pointer to ftdi_context
+ \param eeprom_addr Address of eeprom location to be written
+ \param eeprom_val Value to be written
+
+ \retval 0: all fine
+ \retval -1: read failed
+*/
+int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
+{
+ 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");
+
+ return 0;
+}
+
+/**
Write eeprom
\param ftdi pointer to ftdi_context
int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
{
unsigned short usb_val, status;
- int i;
+ int i, ret;
/* These commands were traced while running MProg */
- ftdi_usb_reset(ftdi);
- ftdi_poll_modem_status(ftdi, &status);
- ftdi_set_latency_timer(ftdi, 0x77);
+ if ((ret = ftdi_usb_reset(ftdi)) != 0)
+ return ret;
+ if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
+ return ret;
+ if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
+ return ret;
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, 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