X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=5cf2012d88c796f99c08c0a8a7aedfdc3ce594d7;hp=a87d6537a1f700162360c78d631bb3ee50121270;hb=fccd6562b4de965f7032f5e55a5668f4629ab313;hpb=e2f12a4fb7a27243c9c8fef2755b9ace5751fe5e diff --git a/src/ftdi.c b/src/ftdi.c index a87d653..5cf2012 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2,7 +2,7 @@ ftdi.c - description ------------------- begin : Fri Apr 4 2003 - copyright : (C) 2003-2008 by Intra2net AG + copyright : (C) 2003-2010 by Intra2net AG email : opensource@intra2net.com ***************************************************************************/ @@ -28,28 +28,26 @@ /** \addtogroup libftdi */ /* @{ */ -#include +#include #include #include #include +#include #include "ftdi.h" -/* stuff needed for async write */ -#ifdef LIBFTDI_LINUX_ASYNC_MODE -#include -#include -#include -#include -#include -#include -#endif - #define ftdi_error_return(code, str) do { \ ftdi->error_str = str; \ return code; \ } while(0); +#define ftdi_error_return_free_device_list(code, str, devs) do { \ + libusb_free_device_list(devs,1); \ + ftdi->error_str = str; \ + return code; \ + } while(0); + + /** Internal function to close usb device pointer. Sets ftdi->usb_dev to NULL. @@ -57,19 +55,15 @@ \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) + if (ftdi && ftdi->usb_dev) { - ret = usb_close (ftdi->usb_dev); + libusb_close (ftdi->usb_dev); ftdi->usb_dev = NULL; } - - return ret; } /** @@ -79,20 +73,21 @@ static int ftdi_usb_close_internal (struct ftdi_context *ftdi) \retval 0: all fine \retval -1: couldn't allocate read buffer + \retval -2: couldn't allocate struct buffer \remark This should be called before all functions */ int ftdi_init(struct ftdi_context *ftdi) { - unsigned int i; - + struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom)); + ftdi->usb_ctx = NULL; 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; @@ -104,24 +99,14 @@ int ftdi_init(struct ftdi_context *ftdi) 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; + if (eeprom == 0) + ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom"); + memset(eeprom, 0, sizeof(struct ftdi_eeprom)); + ftdi->eeprom = eeprom; /* All fine. Now allocate the readbuffer */ return ftdi_read_data_set_chunksize(ftdi, 4096); @@ -158,9 +143,13 @@ struct ftdi_context *ftdi_new(void) \retval 0: all fine \retval -1: unknown interface + \retval -2: USB device unavailable */ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) { + if (ftdi == NULL) + ftdi_error_return(-2, "USB device unavailable"); + switch (interface) { case INTERFACE_ANY: @@ -198,19 +187,38 @@ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) */ void ftdi_deinit(struct ftdi_context *ftdi) { - ftdi_usb_close_internal (ftdi); + if (ftdi == NULL) + return; - 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) { free(ftdi->readbuffer); ftdi->readbuffer = NULL; } + + if (ftdi->eeprom != NULL) + { + if (ftdi->eeprom->manufacturer != 0) + { + free(ftdi->eeprom->manufacturer); + ftdi->eeprom->manufacturer = 0; + } + if (ftdi->eeprom->product != 0) + { + free(ftdi->eeprom->product); + ftdi->eeprom->product = 0; + } + if (ftdi->eeprom->serial != 0) + { + free(ftdi->eeprom->serial); + ftdi->eeprom->serial = 0; + } + free(ftdi->eeprom); + ftdi->eeprom = NULL; + } + libusb_exit(ftdi->usb_ctx); } /** @@ -228,10 +236,13 @@ void ftdi_free(struct ftdi_context *ftdi) 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) { + if (ftdi == NULL) + return; + ftdi->usb_dev = usb; } @@ -246,42 +257,46 @@ void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *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(&ftdi->usb_ctx) < 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(ftdi->usb_ctx, &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++; } } @@ -341,46 +356,50 @@ void ftdi_list_free2(struct ftdi_device_list *devlist) \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; } @@ -391,10 +410,16 @@ int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev, * \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; + // Sanity check + if (ftdi == NULL || dev == NULL) + return 64; + // 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. @@ -403,16 +428,20 @@ static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, s 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 (libusb_get_config_descriptor(dev, 0, &config0) < 0) + return packet_size; - if (ftdi->interface < config.bNumInterfaces) + 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; @@ -421,11 +450,12 @@ static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, s } } + 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 @@ -436,63 +466,72 @@ static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, s \retval -5: unable to claim device \retval -6: reset failed \retval -7: set baudrate failed + \retval -8: ftdi context invalid + \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, detach_errno = 0; + + if (ftdi == NULL) + ftdi_error_return(-8, "ftdi context invalid"); + + 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. - // Returns ENODATA if driver is not loaded. // // The return code is kept in a separate variable and only parsed // if usb_set_configuration() or usb_claim_interface() fails as the // detach operation might be denied and everything still works fine. // Likely scenario is a static ftdi_sio kernel module. - if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA) + if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0) detach_errno = errno; -#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) + 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 the default FTDI driver is not in use"); } } } -#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) + 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 the default FTDI driver is not in use"); } } @@ -504,18 +543,18 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev) // 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 @@ -568,6 +607,35 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) \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 @@ -578,70 +646,195 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) \retval -8: get product description failed \retval -9: get serial number failed \retval -10: unable to close device + \retval -11: ftdi context invalid */ -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(&ftdi->usb_ctx) < 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 (ftdi == NULL) + ftdi_error_return(-11, "ftdi context invalid"); - for (bus = usb_get_busses(); bus; bus = bus->next) + if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0) + ftdi_error_return(-12, "libusb_get_device_list() failed"); + + while ((dev = devs[i++]) != NULL) { - for (dev = bus->devices; dev; dev = dev->next) + struct libusb_device_descriptor desc; + int res; + + if (libusb_get_device_descriptor(dev, &desc) < 0) + ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs); + + 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_free_device_list(-4, "usb_open() failed", devs); - 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_free_device_list(-8, "unable to fetch product description", devs); + } + if (strncmp(string, description, sizeof(string)) != 0) + { + 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) { - 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; - } + ftdi_usb_close_internal (ftdi); + ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs); } - if (serial != NULL) + if (strncmp(string, serial, 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); + continue; } + } - if (ftdi_usb_close_internal (ftdi) != 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; + } + + res = ftdi_usb_open_dev(ftdi, dev); + libusb_free_device_list(devs,1); + return res; } } // device not found - ftdi_error_return(-3, "device not found"); + ftdi_error_return_free_device_list(-3, "device not found", devs); +} + +/** + 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 d:\ path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/) + \li i:\:\ first device with given vendor and product id, ids can be decimal, octal (preceded by "0") or hex (preceded by "0x") + \li i:\:\:\ as above with index being the number of the device (starting with 0) if there are more than one + \li s:\:\:\ 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 + \retval -12: ftdi context invalid +*/ +int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description) +{ + if (ftdi == NULL) + ftdi_error_return(-12, "ftdi context invalid"); + + 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 (&ftdi->usb_ctx) < 0) + ftdi_error_return(-1, "libusb_init() failed"); + + if (libusb_get_device_list(ftdi->usb_ctx, &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_free_device_list(-11, "illegal description format", devs); + + while ((dev = devs[i++]) != NULL) + { + int ret; + if (bus_number == libusb_get_bus_number (dev) + && device_address == libusb_get_device_address (dev)) + { + ret = ftdi_usb_open_dev(ftdi, dev); + libusb_free_device_list(devs,1); + return ret; + } + } + + // device not found + ftdi_error_return_free_device_list(-3, "device not found", devs); + } + 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"); + } } /** @@ -651,12 +844,16 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, \retval 0: all fine \retval -1: FTDI reset failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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 @@ -673,12 +870,16 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) \retval 0: all fine \retval -1: read buffer purge failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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 @@ -695,12 +896,16 @@ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) \retval 0: all fine \retval -1: write buffer purge failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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; @@ -714,11 +919,15 @@ int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) \retval 0: all fine \retval -1: read buffer purge failed \retval -2: write buffer purge failed + \retval -3: USB device unavailable */ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) { int result; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-3, "USB device unavailable"); + result = ftdi_usb_purge_rx_buffer(ftdi); if (result < 0) return -1; @@ -739,28 +948,25 @@ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) \retval 0: all fine \retval -1: usb_release failed - \retval -2: usb_close failed + \retval -3: ftdi context invalid */ 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 == NULL) + ftdi_error_return(-3, "ftdi context invalid"); 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 @@ -895,12 +1101,16 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, \retval 0: all fine \retval -1: invalid baudrate \retval -2: setting baudrate failed + \retval -3: USB device unavailable */ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) { unsigned short value, index; int actual_baudrate; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-3, "USB device unavailable"); + if (ftdi->bitbang_enabled) { baudrate = baudrate*4; @@ -917,9 +1127,9 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) : (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; @@ -956,6 +1166,7 @@ int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, \retval 0: all fine \retval -1: Setting line property failed + \retval -2: USB device unavailable */ int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, @@ -963,6 +1174,9 @@ int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, { unsigned short value = bits; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + switch (parity) { case NONE: @@ -1005,9 +1219,9 @@ int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, 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; @@ -1020,14 +1234,17 @@ int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, \param buf Buffer with the data \param size Size of the buffer + \retval -666: USB device unavailable \retval <0: error code from usb_bulk_write() \retval >0: number of bytes written */ 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; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-666, "USB device unavailable"); while (offset < size) { @@ -1036,230 +1253,313 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int 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) -{ - struct usbdevfs_urb *urb; - int pending=0; - unsigned int i; + packet_size = ftdi->max_packet_size; + + actual_length = transfer->actual_length; - for (i=0; i < ftdi->async_usb_buffer_size; i++) + if (actual_length > 2) { - urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i]; - if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE) - pending++; + // 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; +} - return pending; + +static void ftdi_write_data_cb(struct libusb_transfer *transfer) +{ + struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data; + struct ftdi_context *ftdi = tc->ftdi; + + tc->offset += transfer->actual_length; + + if (tc->offset == tc->size) + { + 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; + + 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. \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; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + { + libusb_free_transfer(transfer); + return NULL; + } - 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. \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 + if (ftdi == NULL || ftdi->usb_dev == NULL) + return NULL; + + 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; + } + + ftdi->readbuffer_remaining = 0; + ftdi->readbuffer_offset = 0; - bytesdone += requested; + 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. + Use libusb 1.0 asynchronous API. - Works around libusb and directly accesses functions only available on Linux. - Only available if compiled with --with-async-mode. + \param tc pointer to ftdi_transfer_control - \param ftdi pointer to ftdi_context - \param buf Buffer with the data - \param size Size of the buffer - - \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(tc->ftdi->usb_ctx); 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(tc->ftdi->usb_ctx) < 0) + break; + libusb_free_transfer(tc->transfer); + free (tc); + return ret; + } } - return total_written; + ret = tc->offset; + /** + * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)" + * at ftdi_read_data_submit(). Therefore, we need to check it here. + **/ + if (tc->transfer) + { + if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED) + ret = -1; + libusb_free_transfer(tc->transfer); + } + free(tc); + return ret; } -#endif // LIBFTDI_LINUX_ASYNC_MODE /** Configure write buffer chunk size. @@ -1269,9 +1569,13 @@ int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int siz \param chunksize Chunk size \retval 0: all fine + \retval -1: ftdi context invalid */ int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) { + if (ftdi == NULL) + ftdi_error_return(-1, "ftdi context invalid"); + ftdi->writebuffer_chunksize = chunksize; return 0; } @@ -1283,9 +1587,13 @@ int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunks \param chunksize Pointer to store chunk size in \retval 0: all fine + \retval -1: ftdi context invalid */ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { + if (ftdi == NULL) + ftdi_error_return(-1, "ftdi context invalid"); + *chunksize = ftdi->writebuffer_chunksize; return 0; } @@ -1299,17 +1607,20 @@ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunk \param buf Buffer to store data in \param size Size of the buffer - \retval <0: error code from usb_bulk_read() + \retval -666: USB device unavailable + \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; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-666, "USB device unavailable"); // Packet size sanity check (avoid division by zero) if (packet_size == 0) @@ -1337,27 +1648,27 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) 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, @@ -1368,25 +1679,25 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) 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) @@ -1401,11 +1712,11 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int 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; } @@ -1425,14 +1736,26 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) \param chunksize Chunk size \retval 0: all fine + \retval -1: ftdi context invalid */ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) { unsigned char *new_buf; + if (ftdi == NULL) + ftdi_error_return(-1, "ftdi context invalid"); + // Invalidate all remaining data ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; +#ifdef __linux__ + /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH, + which is defined in libusb-1.0. Otherwise, each USB read request will + be divided into multiple URBs. This will cause issues on Linux kernel + older than 2.6.32. */ + if (chunksize > 16384) + chunksize = 16384; +#endif if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) ftdi_error_return(-1, "out of memory for readbuffer"); @@ -1450,9 +1773,13 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi \param chunksize Pointer to store chunk size in \retval 0: all fine + \retval -1: FTDI context invalid */ int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { + if (ftdi == NULL) + ftdi_error_return(-1, "FTDI context invalid"); + *chunksize = ftdi->readbuffer_chunksize; return 0; } @@ -1461,7 +1788,7 @@ int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunks /** 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. @@ -1469,18 +1796,22 @@ int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunks \retval 0: all fine \retval -1: can't enable bitbang mode + \retval -2: USB device unavailable */ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + usb_val = bitmask; // low byte: bitmask /* 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; @@ -1494,10 +1825,14 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) \retval 0: all fine \retval -1: can't disable bitbang mode + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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; @@ -1505,42 +1840,50 @@ int ftdi_disable_bitbang(struct ftdi_context *ftdi) } /** - 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 + \retval -2: USB device unavailable */ int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + 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 \retval 0: all fine \retval -1: read pins failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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; @@ -1559,6 +1902,7 @@ int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) \retval 0: all fine \retval -1: latency out of range \retval -2: unable to set latency timer + \retval -3: USB device unavailable */ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) { @@ -1567,8 +1911,11 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) if (latency < 1) ftdi_error_return(-1, "latency out of range. Only valid for 1-255"); + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-3, "USB device unavailable"); + 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; @@ -1582,11 +1929,16 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) \retval 0: all fine \retval -1: unable to get latency timer + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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; @@ -1631,12 +1983,16 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) \retval 0: all fine \retval -1: unable to retrieve status information + \retval -2: USB device unavailable */ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) { 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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]; @@ -1653,12 +2009,16 @@ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) \retval 0: all fine \retval -1: set flow control failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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; @@ -1672,19 +2032,23 @@ int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl) \retval 0: all fine \retval -1: set dtr failed + \retval -2: USB device unavailable */ int ftdi_setdtr(struct ftdi_context *ftdi, int state) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + if (state) usb_val = SIO_SET_DTR_HIGH; 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; @@ -1697,39 +2061,47 @@ int ftdi_setdtr(struct ftdi_context *ftdi, int state) \param state state to set line to (1 or 0) \retval 0: all fine - \retval -1 set rts failed + \retval -1: set rts failed + \retval -2: USB device unavailable */ int ftdi_setrts(struct ftdi_context *ftdi, int state) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + if (state) usb_val = SIO_SET_RTS_HIGH; 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; } /** - Set dtr and rts line in one pass + Set dtr and rts line in one pass - \param ftdi pointer to ftdi_context - \param dtr DTR state to set line to (1 or 0) - \param rts RTS state to set line to (1 or 0) + \param ftdi pointer to ftdi_context + \param dtr DTR state to set line to (1 or 0) + \param rts RTS state to set line to (1 or 0) - \retval 0: all fine - \retval -1 set dtr/rts failed + \retval 0: all fine + \retval -1: set dtr/rts failed + \retval -2: USB device unavailable */ int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + if (dtr) usb_val = SIO_SET_DTR_HIGH; else @@ -1740,9 +2112,9 @@ int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts) 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; @@ -1757,17 +2129,21 @@ int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts) \retval 0: all fine \retval -1: unable to set event character + \retval -2: USB device unavailable */ int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + usb_val = eventch; 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; @@ -1782,82 +2158,147 @@ int ftdi_set_event_char(struct ftdi_context *ftdi, \retval 0: all fine \retval -1: unable to set error character + \retval -2: USB device unavailable */ int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable) { unsigned short usb_val; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + usb_val = errorch; 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; } /** - Set the eeprom size - - \param ftdi pointer to ftdi_context - \param eeprom Pointer to ftdi_eeprom - \param size - -*/ -void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size) -{ - ftdi->eeprom_size=size; - eeprom->size=size; -} - -/** Init eeprom with default values. + \param ftdi pointer to ftdi_context + \param manufacturer String to use as Manufacturer + \param product String to use as Product description + \param serial String to use as Serial number description - \param eeprom Pointer to ftdi_eeprom + \retval 0: all fine + \retval -1: No struct ftdi_context + \retval -2: No struct ftdi_eeprom */ -void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) +int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, + char * product, char * serial) { - eeprom->vendor_id = 0x0403; - eeprom->product_id = 0x6001; + struct ftdi_eeprom *eeprom; - eeprom->self_powered = 1; - eeprom->remote_wakeup = 1; - eeprom->BM_type_chip = 1; + if (ftdi == NULL) + ftdi_error_return(-1, "No struct ftdi_context"); - eeprom->in_is_isochronous = 0; - eeprom->out_is_isochronous = 0; - eeprom->suspend_pull_downs = 0; + if (ftdi->eeprom == NULL) + ftdi_error_return(-2,"No struct ftdi_eeprom"); - eeprom->use_serial = 0; - eeprom->change_usb_version = 0; - eeprom->usb_version = 0x0200; - eeprom->max_power = 0; + eeprom = ftdi->eeprom; + memset(eeprom, 0, sizeof(struct ftdi_eeprom)); + + eeprom->vendor_id = 0x0403; + eeprom->use_serial = USE_SERIAL_NUM; + if((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) || + (ftdi->type == TYPE_R)) + eeprom->product_id = 0x6001; + else + eeprom->product_id = 0x6010; + if (ftdi->type == TYPE_AM) + eeprom->usb_version = 0x0101; + else + eeprom->usb_version = 0x0200; + eeprom->max_power = 100; + if (eeprom->manufacturer) + free (eeprom->manufacturer); eeprom->manufacturer = NULL; + if (manufacturer) + { + eeprom->manufacturer = malloc(strlen(manufacturer)+1); + if (eeprom->manufacturer) + strcpy(eeprom->manufacturer, manufacturer); + } + + if (eeprom->product) + free (eeprom->product); eeprom->product = NULL; + { + eeprom->product = malloc(strlen(product)+1); + if (eeprom->product) + strcpy(eeprom->product, product); + } + + if (eeprom->serial) + free (eeprom->serial); eeprom->serial = NULL; + if (serial) + { + eeprom->serial = malloc(strlen(serial)+1); + if (eeprom->serial) + strcpy(eeprom->serial, serial); + } + - eeprom->size = FTDI_DEFAULT_EEPROM_SIZE; + if(ftdi->type == TYPE_R) + { + eeprom->max_power = 90; + eeprom->size = 0x80; + eeprom->cbus_function[0] = CBUS_TXLED; + eeprom->cbus_function[1] = CBUS_RXLED; + eeprom->cbus_function[2] = CBUS_TXDEN; + eeprom->cbus_function[3] = CBUS_PWREN; + eeprom->cbus_function[4] = CBUS_SLEEP; + } + else + eeprom->size = -1; + return 0; } /** - Build binary output from ftdi_eeprom structure. - Output is suitable for ftdi_write_eeprom(). + Build binary buffer from ftdi_eeprom structure. + Output is suitable for ftdi_write_eeprom(). - \param eeprom Pointer to ftdi_eeprom - \param output Buffer of 128 bytes to store eeprom image to + \param ftdi pointer to ftdi_context - \retval >0: used eeprom size - \retval -1: eeprom size (128 bytes) exceeded by custom strings + \retval >0: free eeprom size + \retval -1: eeprom size (128 bytes) exceeded by custom strings + \retval -2: Invalid eeprom pointer + \retval -3: Invalid cbus function setting + \retval -4: Chip doesn't support invert + \retval -5: Chip doesn't support high current drive + \retval -6: No connected EEPROM or EEPROM Type unknown */ -int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) +int ftdi_eeprom_build(struct ftdi_context *ftdi) { - unsigned char i, j; + unsigned char i, j, eeprom_size_mask; unsigned short checksum, value; unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; int size_check; + struct ftdi_eeprom *eeprom; + unsigned char * output; + + if (ftdi == NULL) + ftdi_error_return(-2,"No context"); + if (ftdi->eeprom == NULL) + ftdi_error_return(-2,"No eeprom structure"); + + eeprom= ftdi->eeprom; + output = eeprom->buf; + + if(eeprom->chip == -1) + ftdi_error_return(-5,"No connected EEPROM or EEPROM type unknown"); + + if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) + eeprom->size = 0x100; + else + eeprom->size = 0x80; if (eeprom->manufacturer != NULL) manufacturer_size = strlen(eeprom->manufacturer); @@ -1866,26 +2307,37 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) if (eeprom->serial != NULL) serial_size = strlen(eeprom->serial); - size_check = eeprom->size; - size_check -= 28; // 28 are always in use (fixed) + size_check = 0x80; + switch(ftdi->type) + { + case TYPE_2232H: + case TYPE_4232H: + size_check -= 4; + case TYPE_R: + size_check -= 4; + case TYPE_2232C: + size_check -= 4; + case TYPE_AM: + case TYPE_BM: + size_check -= 0x14*2; + } - // Top half of a 256byte eeprom is used just for strings and checksum - // it seems that the FTDI chip will not read these strings from the lower half - // Each string starts with two bytes; offset and type (0x03 for string) - // the checksum needs two bytes, so without the string data that 8 bytes from the top half - if (eeprom->size>=256)size_check = 120; size_check -= manufacturer_size*2; size_check -= product_size*2; size_check -= serial_size*2; + /* Space for the string type and pointer bytes */ + size_check -= -9; + // eeprom size exceeded? if (size_check < 0) return (-1); // empty eeprom - memset (output, 0, eeprom->size); + memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE); + + // Bytes and Bits set for all Types - // Addr 00: Stay 00 00 // Addr 02: Vendor ID output[0x02] = eeprom->vendor_id; output[0x03] = eeprom->vendor_id >> 8; @@ -1896,17 +2348,34 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // Addr 06: Device release number (0400h for BM features) output[0x06] = 0x00; - - if (eeprom->BM_type_chip == 1) - output[0x07] = 0x04; - else - output[0x07] = 0x02; + switch (ftdi->type) { + case TYPE_AM: + output[0x07] = 0x02; + break; + case TYPE_BM: + output[0x07] = 0x04; + break; + case TYPE_2232C: + output[0x07] = 0x05; + break; + case TYPE_R: + output[0x07] = 0x06; + break; + case TYPE_2232H: + output[0x07] = 0x07; + break; + case TYPE_4232H: + output[0x07] = 0x08; + break; + default: + output[0x07] = 0x00; + } // Addr 08: Config descriptor // Bit 7: always 1 // Bit 6: 1 if this device is self powered, 0 if bus powered // Bit 5: 1 if this device uses remote wakeup - // Bit 4: 1 if this device is battery powered + // Bit 4-0: reserved - 0 j = 0x80; if (eeprom->self_powered == 1) j |= 0x40; @@ -1915,88 +2384,254 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x08] = j; // Addr 09: Max power consumption: max power = value * 2 mA - output[0x09] = eeprom->max_power; - - // Addr 0A: Chip configuration - // Bit 7: 0 - reserved - // Bit 6: 0 - reserved - // Bit 5: 0 - reserved - // Bit 4: 1 - Change USB version - // Bit 3: 1 - Use the serial number string - // Bit 2: 1 - Enable suspend pull downs for lower power - // Bit 1: 1 - Out EndPoint is Isochronous - // Bit 0: 1 - In EndPoint is Isochronous - // - j = 0; - if (eeprom->in_is_isochronous == 1) - j = j | 1; - if (eeprom->out_is_isochronous == 1) - j = j | 2; - if (eeprom->suspend_pull_downs == 1) - j = j | 4; - if (eeprom->use_serial == 1) - j = j | 8; - if (eeprom->change_usb_version == 1) - j = j | 16; - output[0x0A] = j; + output[0x09] = eeprom->max_power>>1; - // Addr 0B: reserved - output[0x0B] = 0x00; - - // Addr 0C: USB version low byte when 0x0A bit 4 is set - // Addr 0D: USB version high byte when 0x0A bit 4 is set - if (eeprom->change_usb_version == 1) + if(ftdi->type != TYPE_AM) { - output[0x0C] = eeprom->usb_version; - output[0x0D] = eeprom->usb_version >> 8; + // Addr 0A: Chip configuration + // Bit 7: 0 - reserved + // Bit 6: 0 - reserved + // Bit 5: 0 - reserved + // Bit 4: 1 - Change USB version + // Bit 3: 1 - Use the serial number string + // Bit 2: 1 - Enable suspend pull downs for lower power + // Bit 1: 1 - Out EndPoint is Isochronous + // Bit 0: 1 - In EndPoint is Isochronous + // + j = 0; + if (eeprom->in_is_isochronous == 1) + j = j | 1; + if (eeprom->out_is_isochronous == 1) + j = j | 2; + output[0x0A] = j; } + // Dynamic content + // Strings start at 0x94 (TYPE_AM, TYPE_BM) + // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H) + i = 0; + switch(ftdi->type) + { + case TYPE_2232H: + case TYPE_4232H: + i += 2; + case TYPE_R: + i += 2; + case TYPE_2232C: + i += 2; + case TYPE_AM: + case TYPE_BM: + i += 0x94; + } + /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */ + eeprom_size_mask = eeprom->size -1; // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string + // Output manufacturer + output[0x0E] = i; // calculate offset + output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++; + output[i & eeprom_size_mask] = 0x03, i++; // type: string + for (j = 0; j < manufacturer_size; j++) + { + output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++; + output[i & eeprom_size_mask] = 0x00, i++; + } output[0x0F] = manufacturer_size*2 + 2; // Addr 10: Offset of the product string + 0x80, calculated later // Addr 11: Length of product string + output[0x10] = i | 0x80; // calculate offset + output[i & eeprom_size_mask] = product_size*2 + 2, i++; + output[i & eeprom_size_mask] = 0x03, i++; + for (j = 0; j < product_size; j++) + { + output[i & eeprom_size_mask] = eeprom->product[j], i++; + output[i & eeprom_size_mask] = 0x00, i++; + } output[0x11] = product_size*2 + 2; // Addr 12: Offset of the serial string + 0x80, calculated later // Addr 13: Length of serial string - output[0x13] = serial_size*2 + 2; - - // Dynamic content - i=0x14; - if (eeprom->size>=256) i = 0x80; - - - // Output manufacturer - output[0x0E] = i | 0x80; // calculate offset - output[i++] = manufacturer_size*2 + 2; - output[i++] = 0x03; // type: string - for (j = 0; j < manufacturer_size; j++) + output[0x12] = i | 0x80; // calculate offset + output[i & eeprom_size_mask] = serial_size*2 + 2, i++; + output[i & eeprom_size_mask] = 0x03, i++; + for (j = 0; j < serial_size; j++) { - output[i] = eeprom->manufacturer[j], i++; - output[i] = 0x00, i++; + output[i & eeprom_size_mask] = eeprom->serial[j], i++; + output[i & eeprom_size_mask] = 0x00, i++; } + output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */ + i++; + output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */ + i++; + output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */ + i++; - // Output product name - output[0x10] = i | 0x80; // calculate offset - output[i] = product_size*2 + 2, i++; - output[i] = 0x03, i++; - for (j = 0; j < product_size; j++) + output[0x13] = serial_size*2 + 2; + + if(ftdi->type > TYPE_AM) /*use_serial not used in AM devices*/ { - output[i] = eeprom->product[j], i++; - output[i] = 0x00, i++; + if (eeprom->use_serial == USE_SERIAL_NUM ) + output[0x0A] |= USE_SERIAL_NUM; + else + output[0x0A] &= ~USE_SERIAL_NUM; } + /* Fixme: ftd2xx seems to append 0x02, 0x03 and 0x01 for PnP = 0 or 0x00 else */ + // calculate checksum - // Output serial - output[0x12] = i | 0x80; // calculate offset - output[i] = serial_size*2 + 2, i++; - output[i] = 0x03, i++; - for (j = 0; j < serial_size; j++) + /* Bytes and Bits specific to (some) types + Write linear, as this allows easier fixing*/ + switch(ftdi->type) { - output[i] = eeprom->serial[j], i++; - output[i] = 0x00, i++; + case TYPE_AM: + break; + case TYPE_BM: + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + output[0x14] = eeprom->chip; + break; + case TYPE_2232C: + + output[0x00] = (eeprom->channel_a_type); + if ( eeprom->channel_a_driver == DRIVER_VCP) + output[0x00] |= DRIVER_VCP; + else + output[0x00] &= ~DRIVER_VCP; + + if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE) + output[0x00] |= HIGH_CURRENT_DRIVE; + else + output[0x00] &= ~HIGH_CURRENT_DRIVE; + + output[0x01] = (eeprom->channel_b_type); + if ( eeprom->channel_b_driver == DRIVER_VCP) + output[0x01] |= DRIVER_VCP; + else + output[0x01] &= ~DRIVER_VCP; + + if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE) + output[0x01] |= HIGH_CURRENT_DRIVE; + else + output[0x01] &= ~HIGH_CURRENT_DRIVE; + + if (eeprom->in_is_isochronous == 1) + output[0x0A] |= 0x1; + else + output[0x0A] &= ~0x1; + if (eeprom->out_is_isochronous == 1) + output[0x0A] |= 0x2; + else + output[0x0A] &= ~0x2; + if (eeprom->suspend_pull_downs == 1) + output[0x0A] |= 0x4; + else + output[0x0A] &= ~0x4; + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + output[0x14] = eeprom->chip; + break; + case TYPE_R: + if(eeprom->high_current == HIGH_CURRENT_DRIVE_R) + output[0x00] |= HIGH_CURRENT_DRIVE_R; + output[0x01] = 0x40; /* Hard coded Endpoint Size*/ + + if (eeprom->suspend_pull_downs == 1) + output[0x0A] |= 0x4; + else + output[0x0A] &= ~0x4; + output[0x0B] = eeprom->invert; + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + + if(eeprom->cbus_function[0] > CBUS_BB) + output[0x14] = CBUS_TXLED; + else + output[0x14] = eeprom->cbus_function[0]; + + if(eeprom->cbus_function[1] > CBUS_BB) + output[0x14] |= CBUS_RXLED<<4; + else + output[0x14] |= eeprom->cbus_function[1]<<4; + + if(eeprom->cbus_function[2] > CBUS_BB) + output[0x15] = CBUS_TXDEN; + else + output[0x15] = eeprom->cbus_function[2]; + + if(eeprom->cbus_function[3] > CBUS_BB) + output[0x15] |= CBUS_PWREN<<4; + else + output[0x15] |= eeprom->cbus_function[3]<<4; + + if(eeprom->cbus_function[4] > CBUS_CLK6) + output[0x16] = CBUS_SLEEP; + else + output[0x16] = eeprom->cbus_function[4]; + break; + case TYPE_2232H: + output[0x00] = (eeprom->channel_a_type); + if ( eeprom->channel_a_driver == DRIVER_VCP) + output[0x00] |= DRIVER_VCP; + else + output[0x00] &= ~DRIVER_VCP; + + output[0x01] = (eeprom->channel_b_type); + if ( eeprom->channel_b_driver == DRIVER_VCP) + output[0x01] |= DRIVER_VCP; + else + output[0x01] &= ~DRIVER_VCP; + if(eeprom->suspend_dbus7 == SUSPEND_DBUS7) + output[0x01] |= SUSPEND_DBUS7; + else + output[0x01] &= ~SUSPEND_DBUS7; + + if (eeprom->suspend_pull_downs == 1) + output[0x0A] |= 0x4; + else + output[0x0A] &= ~0x4; + + if(eeprom->group0_drive > DRIVE_16MA) + output[0x0c] |= DRIVE_16MA; + else + output[0x0c] |= eeprom->group0_drive; + if (eeprom->group0_schmitt == IS_SCHMITT) + output[0x0c] |= IS_SCHMITT; + if (eeprom->group0_slew == SLOW_SLEW) + output[0x0c] |= SLOW_SLEW; + + if(eeprom->group1_drive > DRIVE_16MA) + output[0x0c] |= DRIVE_16MA<<4; + else + output[0x0c] |= eeprom->group1_drive<<4; + if (eeprom->group1_schmitt == IS_SCHMITT) + output[0x0c] |= IS_SCHMITT<<4; + if (eeprom->group1_slew == SLOW_SLEW) + output[0x0c] |= SLOW_SLEW<<4; + + if(eeprom->group2_drive > DRIVE_16MA) + output[0x0d] |= DRIVE_16MA; + else + output[0x0d] |= eeprom->group2_drive; + if (eeprom->group2_schmitt == IS_SCHMITT) + output[0x0d] |= IS_SCHMITT; + if (eeprom->group2_slew == SLOW_SLEW) + output[0x0d] |= SLOW_SLEW; + + if(eeprom->group3_drive > DRIVE_16MA) + output[0x0d] |= DRIVE_16MA<<4; + else + output[0x0d] |= eeprom->group3_drive<<4; + if (eeprom->group3_schmitt == IS_SCHMITT) + output[0x0d] |= IS_SCHMITT<<4; + if (eeprom->group3_slew == SLOW_SLEW) + output[0x0d] |= SLOW_SLEW<<4; + + output[0x18] = eeprom->chip; + + break; + case TYPE_4232H: + fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n"); } // calculate checksum @@ -2020,45 +2655,32 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) /** Decode binary EEPROM image into an ftdi_eeprom structure. - \param eeprom Pointer to ftdi_eeprom which will be filled in. - \param buf Buffer of \a size bytes of raw eeprom data - \param size size size of eeprom data in bytes - + \param ftdi pointer to ftdi_context + \param verbose Decode EEPROM on stdout + \retval 0: all fine \retval -1: something went wrong FIXME: How to pass size? How to handle size field in ftdi_eeprom? FIXME: Strings are malloc'ed here and should be freed somewhere */ -int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size) +int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { unsigned char i, j; unsigned short checksum, eeprom_checksum, value; unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; - int size_check; - int eeprom_size = 128; -#if 0 - size_check = eeprom->size; - size_check -= 28; // 28 are always in use (fixed) - - // Top half of a 256byte eeprom is used just for strings and checksum - // it seems that the FTDI chip will not read these strings from the lower half - // Each string starts with two bytes; offset and type (0x03 for string) - // the checksum needs two bytes, so without the string data that 8 bytes from the top half - if (eeprom->size>=256)size_check = 120; - size_check -= manufacturer_size*2; - size_check -= product_size*2; - size_check -= serial_size*2; + int eeprom_size; + struct ftdi_eeprom *eeprom; + unsigned char *buf = ftdi->eeprom->buf; + int release; - // eeprom size exceeded? - if (size_check < 0) - return (-1); -#endif - - // empty eeprom struct - memset(eeprom, 0, sizeof(struct ftdi_eeprom)); - - // Addr 00: Stay 00 00 + if (ftdi == NULL) + ftdi_error_return(-1,"No context"); + if (ftdi->eeprom == NULL) + ftdi_error_return(-1,"No eeprom structure"); + + eeprom = ftdi->eeprom; + eeprom_size = eeprom->size; // Addr 02: Vendor ID eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8); @@ -2066,28 +2688,14 @@ int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size) // Addr 04: Product ID eeprom->product_id = buf[0x04] + (buf[0x05] << 8); - value = buf[0x06] + (buf[0x07]<<8); - switch (value) - { - case 0x0400: - eeprom->BM_type_chip = 1; - break; - case 0x0200: - eeprom->BM_type_chip = 0; - break; - default: // Unknown device - eeprom->BM_type_chip = 0; - break; - } + release = buf[0x06] + (buf[0x07]<<8); // Addr 08: Config descriptor // Bit 7: always 1 // Bit 6: 1 if this device is self powered, 0 if bus powered // Bit 5: 1 if this device uses remote wakeup - // Bit 4: 1 if this device is battery powered - j = buf[0x08]; - if (j&0x40) eeprom->self_powered = 1; - if (j&0x20) eeprom->remote_wakeup = 1; + eeprom->self_powered = buf[0x08] & 0x40; + eeprom->remote_wakeup = buf[0x08] & 0x20;; // Addr 09: Max power consumption: max power = value * 2 mA eeprom->max_power = buf[0x09]; @@ -2097,68 +2705,88 @@ int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size) // Bit 6: 0 - reserved // Bit 5: 0 - reserved // Bit 4: 1 - Change USB version + // Not seen on FT2232(D) // Bit 3: 1 - Use the serial number string // Bit 2: 1 - Enable suspend pull downs for lower power // Bit 1: 1 - Out EndPoint is Isochronous // Bit 0: 1 - In EndPoint is Isochronous // - j = buf[0x0A]; - if (j&0x01) eeprom->in_is_isochronous = 1; - if (j&0x02) eeprom->out_is_isochronous = 1; - if (j&0x04) eeprom->suspend_pull_downs = 1; - if (j&0x08) eeprom->use_serial = 1; - if (j&0x10) eeprom->change_usb_version = 1; + eeprom->in_is_isochronous = buf[0x0A]&0x01; + eeprom->out_is_isochronous = buf[0x0A]&0x02; + eeprom->suspend_pull_downs = buf[0x0A]&0x04; + eeprom->use_serial = buf[0x0A] & USE_SERIAL_NUM; + if(buf[0x0A]&0x10) + fprintf(stderr, + "EEPROM byte[0x0a] Bit 4 unexpected set. If this happened with the EEPROM\n" + "programmed by FTDI tools, please report to libftdi@developer.intra2net.com\n"); - // Addr 0B: reserved - // Addr 0C: USB version low byte when 0x0A bit 4 is set - // Addr 0D: USB version high byte when 0x0A bit 4 is set - if (eeprom->change_usb_version == 1) - { - eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8); - } + // Addr 0C: USB version low byte when 0x0A + // Addr 0D: USB version high byte when 0x0A + eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8); // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string manufacturer_size = buf[0x0F]/2; - if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size); + if(eeprom->manufacturer) + free(eeprom->manufacturer); + if (manufacturer_size > 0) + { + eeprom->manufacturer = malloc(manufacturer_size); + if (eeprom->manufacturer) + { + // Decode manufacturer + i = buf[0x0E] & (eeprom_size -1); // offset + for (j=0;jmanufacturer[j] = buf[2*j+i+2]; + } + eeprom->manufacturer[j] = '\0'; + } + } else eeprom->manufacturer = NULL; // Addr 10: Offset of the product string + 0x80, calculated later // Addr 11: Length of product string + if(eeprom->product) + free(eeprom->product); product_size = buf[0x11]/2; - if (product_size > 0) eeprom->product = malloc(product_size); + if (product_size > 0) + { + eeprom->product = malloc(product_size); + if(eeprom->product) + { + // Decode product name + i = buf[0x10] & (eeprom_size -1); // offset + for (j=0;jproduct[j] = buf[2*j+i+2]; + } + eeprom->product[j] = '\0'; + } + } else eeprom->product = NULL; // Addr 12: Offset of the serial string + 0x80, calculated later // Addr 13: Length of serial string + if(eeprom->serial) + free(eeprom->serial); serial_size = buf[0x13]/2; - if (serial_size > 0) eeprom->serial = malloc(serial_size); - else eeprom->serial = NULL; - - // Decode manufacturer - i = buf[0x0E] & 0x7f; // offset - for (j=0;j 0) { - eeprom->manufacturer[j] = buf[2*j+i+2]; - } - eeprom->manufacturer[j] = '\0'; - - // Decode product name - i = buf[0x10] & 0x7f; // offset - for (j=0;jproduct[j] = buf[2*j+i+2]; - } - eeprom->product[j] = '\0'; - - // Decode serial - i = buf[0x12] & 0x7f; // offset - for (j=0;jserial[j] = buf[2*j+i+2]; + eeprom->serial = malloc(serial_size); + if(eeprom->serial) + { + // Decode serial + i = buf[0x12] & (eeprom_size -1); // offset + for (j=0;jserial[j] = buf[2*j+i+2]; + } + eeprom->serial[j] = '\0'; + } } - eeprom->serial[j] = '\0'; + else eeprom->serial = NULL; // verify checksum checksum = 0xAAAA; @@ -2177,9 +2805,165 @@ int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size) if (eeprom_checksum != checksum) { fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum); - return -1; + ftdi_error_return(-1,"EEPROM checksum error"); + } + + eeprom->channel_a_type = 0; + if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM)) + { + eeprom->chip = -1; + } + else if(ftdi->type == TYPE_2232C) + { + eeprom->channel_a_type = buf[0x00] & 0x7; + eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; + eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE; + eeprom->channel_b_type = buf[0x01] & 0x7; + eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP; + eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE; + eeprom->chip = buf[0x14]; + } + else if(ftdi->type == TYPE_R) + { + /* TYPE_R flags D2XX, not VCP as all others*/ + eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP; + eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R; + if( (buf[0x01]&0x40) != 0x40) + fprintf(stderr, + "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size." + " If this happened with the\n" + " EEPROM programmed by FTDI tools, please report " + "to libftdi@developer.intra2net.com\n"); + + eeprom->chip = buf[0x16]; + // Addr 0B: Invert data lines + // Works only on FT232R, not FT245R, but no way to distinguish + eeprom->invert = buf[0x0B]; + // Addr 14: CBUS function: CBUS0, CBUS1 + // Addr 15: CBUS function: CBUS2, CBUS3 + // Addr 16: CBUS function: CBUS5 + eeprom->cbus_function[0] = buf[0x14] & 0x0f; + eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f; + eeprom->cbus_function[2] = buf[0x15] & 0x0f; + eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f; + eeprom->cbus_function[4] = buf[0x16] & 0x0f; + } + else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H)) + { + eeprom->channel_a_type = buf[0x00] & 0x7; + eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; + eeprom->channel_b_type = buf[0x01] & 0x7; + eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP; + + if(ftdi->type == TYPE_2232H) + eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7; + + eeprom->chip = buf[0x18]; + eeprom->group0_drive = buf[0x0c] & DRIVE_16MA; + eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT; + eeprom->group0_slew = buf[0x0c] & SLOW_SLEW; + eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3; + eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT; + eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW; + eeprom->group2_drive = buf[0x0d] & DRIVE_16MA; + eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT; + eeprom->group2_slew = buf[0x0d] & SLOW_SLEW; + eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA; + eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT; + eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW; } + + if(verbose) + { + char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"}; + fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id); + fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id); + fprintf(stdout, "Release: 0x%04x\n",release); + if(eeprom->self_powered) + fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n"); + else + fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2, + (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n"); + if(eeprom->manufacturer) + fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer); + if(eeprom->product) + fprintf(stdout, "Product: %s\n",eeprom->product); + if(eeprom->serial) + fprintf(stdout, "Serial: %s\n",eeprom->serial); + fprintf(stdout, "Checksum : %04x\n", checksum); + if (ftdi->type == TYPE_R) + fprintf(stdout, "Internal EEPROM\n"); + else if (eeprom->chip >= 0x46) + fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip); + if(eeprom->suspend_dbus7) + fprintf(stdout, "Suspend on DBUS7\n"); + if(eeprom->suspend_pull_downs) + fprintf(stdout, "Pull IO pins low during suspend\n"); + if(eeprom->remote_wakeup) + fprintf(stdout, "Enable Remote Wake Up\n"); + fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1); + if (ftdi->type >= TYPE_2232C) + fprintf(stdout,"Channel A has Mode %s%s%s\n", + channel_mode[eeprom->channel_a_type], + (eeprom->channel_a_driver)?" VCP":"", + (eeprom->high_current_a)?" High Current IO":""); + if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R)) + fprintf(stdout,"Channel B has Mode %s%s%s\n", + channel_mode[eeprom->channel_b_type], + (eeprom->channel_b_driver)?" VCP":"", + (eeprom->high_current_b)?" High Current IO":""); + if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H)) + { + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"AL":"A", + (eeprom->group0_drive+1) *4, + (eeprom->group0_schmitt)?" Schmitt Input":"", + (eeprom->group0_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"AH":"B", + (eeprom->group1_drive+1) *4, + (eeprom->group1_schmitt)?" Schmitt Input":"", + (eeprom->group1_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"BL":"C", + (eeprom->group2_drive+1) *4, + (eeprom->group2_schmitt)?" Schmitt Input":"", + (eeprom->group2_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"BH":"D", + (eeprom->group3_drive+1) *4, + (eeprom->group3_schmitt)?" Schmitt Input":"", + (eeprom->group3_slew)?" Slow Slew":""); + } + if (ftdi->type == TYPE_R) + { + char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED", + "SLEEP","CLK48","CLK24","CLK12","CLK6", + "IOMODE","BB_WR","BB_RD"}; + char *cbus_BB[] = {"RXF","TXE","RD", "WR"}; + int i; + + if(eeprom->invert) + { + char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"}; + fprintf(stdout,"Inverted bits:"); + for (i=0; i<8; i++) + if((eeprom->invert & (1<cbus_function[i]cbus_function[i]]); + else + fprintf(stdout,"C%d BB Function: %s\n", i, + cbus_BB[i]); + } + } + } return 0; } @@ -2192,10 +2976,14 @@ int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size) \retval 0: all fine \retval -1: read failed + \retval -2: USB device unavailable */ 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2) ftdi_error_return(-1, "reading eeprom failed"); return 0; @@ -2205,21 +2993,40 @@ int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsig Read eeprom \param ftdi pointer to ftdi_context - \param eeprom Pointer to store eeprom into \retval 0: all fine \retval -1: read failed + \retval -2: USB device unavailable */ -int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) +int ftdi_read_eeprom(struct ftdi_context *ftdi) { int i; + unsigned char *buf; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + buf = ftdi->eeprom->buf; - for (i = 0; i < ftdi->eeprom_size/2; i++) + for (i = 0; i < FTDI_MAX_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, + buf+(i*2), 2, ftdi->usb_read_timeout) != 2) ftdi_error_return(-1, "reading eeprom failed"); } + if (ftdi->type == TYPE_R) + ftdi->eeprom->size = 0x80; + /* Guesses size of eeprom by comparing halves + - will not work with blank eeprom */ + else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1)) + ftdi->eeprom->size = -1; + else if(memcmp(buf,&buf[0x80],0x80) == 0) + ftdi->eeprom->size = 0x80; + else if(memcmp(buf,&buf[0x40],0x40) == 0) + ftdi->eeprom->size = 0x40; + else + ftdi->eeprom->size = 0x100; return 0; } @@ -2248,15 +3055,19 @@ static unsigned char ftdi_read_chipid_shift(unsigned char value) \retval 0: all fine \retval -1: read failed + \retval -2: USB device unavailable */ int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid) { 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 (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + 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); @@ -2271,38 +3082,6 @@ int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid) } /** - Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom - Call this function then do a write then call again to see if size changes, if so write again. - - \param ftdi pointer to ftdi_context - \param eeprom Pointer to store eeprom into - \param maxsize the size of the buffer to read into - - \retval size of eeprom -*/ -int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize) -{ - int i=0,j,minsize=32; - int size=minsize; - - do - { - for (j = 0; i < maxsize/2 && jusb_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++; - } - size*=2; - } - while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0); - - return size/2; -} - -/** Write eeprom location \param ftdi pointer to ftdi_context @@ -2310,11 +3089,48 @@ int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, i \param eeprom_val Value to be written \retval 0: all fine - \retval -1: read failed + \retval -1: write failed + \retval -2: USB device unavailable + \retval -3: Invalid access to checksum protected area below 0x80 + \retval -4: Device can't access unprotected area + \retval -5: Reading chip type failed */ -int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val) +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, + int chip_type_location; + unsigned short chip_type; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + if(eeprom_addr <0x80) + ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80"); + + + switch (ftdi->type) + { + case TYPE_BM: + case TYPE_2232C: + chip_type_location = 0x14; + break; + case TYPE_2232H: + case TYPE_4232H: + chip_type_location = 0x18; + break; + default: + ftdi_error_return(-4, "Device can't access unprotected area"); + } + + if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type)) + ftdi_error_return(-5, "Reading failed failed"); + fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type); + if((chip_type & 0xff) != 0x66) + { + ftdi_error_return(-6, "EEPROM is not of 93x66"); + } + + 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"); @@ -2326,15 +3142,20 @@ int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsig Write eeprom \param ftdi pointer to ftdi_context - \param eeprom Pointer to read eeprom from - + \retval 0: all fine \retval -1: read failed + \retval -2: USB device unavailable */ -int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) +int ftdi_write_eeprom(struct ftdi_context *ftdi) { unsigned short usb_val, status; int i, ret; + unsigned char *eeprom; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + eeprom = ftdi->eeprom->buf; /* These commands were traced while running MProg */ if ((ret = ftdi_usb_reset(ftdi)) != 0) @@ -2344,13 +3165,13 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0) return ret; - for (i = 0; i < ftdi->eeprom_size/2; i++) + for (i = 0; i < ftdi->eeprom->size/2; i++) { usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; - if (usb_control_msg(ftdi->usb_dev, 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"); } @@ -2366,12 +3187,64 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) \retval 0: all fine \retval -1: erase failed + \retval -2: USB device unavailable + \retval -3: Writing magic failed + \retval -4: Read EEPROM failed + \retval -5: Unexpected EEPROM value */ +#define MAGIC 0x55aa 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) + unsigned short eeprom_value; + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + if(ftdi->type == TYPE_R) + { + ftdi->eeprom->chip = 0; + return 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"); + + /* detect chip type by writing 0x55AA as magic at word position 0xc0 + Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40 + Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80 + Chip is 93x66 if magic is only read at word position 0xc0*/ + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, + SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0, + NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-3, "Writing magic failed"); + if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + { + ftdi->eeprom->chip = 0x46; + } + else + { + if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + ftdi->eeprom->chip = 0x56; + else + { + if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + ftdi->eeprom->chip = 0x66; + else + { + ftdi->eeprom->chip = -1; + } + } + } + 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; } @@ -2384,6 +3257,9 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) */ char *ftdi_get_error_string (struct ftdi_context *ftdi) { + if (ftdi == NULL) + return ""; + return ftdi->error_str; }