X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=a87d6537a1f700162360c78d631bb3ee50121270;hp=ca52acd1922bcb2f593e308cd0c6e1d3e66770aa;hb=0c93de8177ee7310292ac7eab4c2e3ff993b4f2f;hpb=5a2b51cb86894116e7452c330a2afb4ceaf14adc diff --git a/src/ftdi.c b/src/ftdi.c index ca52acd..a87d653 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -18,7 +18,7 @@ \mainpage libftdi API documentation Library to talk to FTDI chips. You find the latest versions of libftdi at - http://www.intra2net.com/de/produkte/opensource/ftdi/ + http://www.intra2net.com/en/developer/libftdi/ The library is easy to use. Have a look at this short example: \include simple.c @@ -31,17 +31,18 @@ #include #include #include +#include #include "ftdi.h" /* stuff needed for async write */ #ifdef LIBFTDI_LINUX_ASYNC_MODE - #include - #include - #include - #include - #include - #include +#include +#include +#include +#include +#include +#include #endif #define ftdi_error_return(code, str) do { \ @@ -49,6 +50,27 @@ return code; \ } while(0); +/** + Internal function to close usb device pointer. + Sets ftdi->usb_dev to NULL. + \internal + + \param ftdi pointer to ftdi_context + + \retval zero if all is fine, otherwise error code from usb_close() +*/ +static int ftdi_usb_close_internal (struct ftdi_context *ftdi) +{ + int ret = 0; + + if (ftdi->usb_dev) + { + ret = usb_close (ftdi->usb_dev); + ftdi->usb_dev = NULL; + } + + return ret; +} /** Initializes a ftdi_context. @@ -62,7 +84,7 @@ */ int ftdi_init(struct ftdi_context *ftdi) { - int i; + unsigned int i; ftdi->usb_dev = NULL; ftdi->usb_read_timeout = 5000; @@ -76,6 +98,7 @@ int ftdi_init(struct ftdi_context *ftdi) ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; ftdi->writebuffer_chunksize = 4096; + ftdi->max_packet_size = 0; ftdi->interface = 0; ftdi->index = 0; @@ -109,17 +132,19 @@ int ftdi_init(struct ftdi_context *ftdi) \return a pointer to a new ftdi_context, or NULL on failure */ -struct ftdi_context *ftdi_new() +struct ftdi_context *ftdi_new(void) { struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context)); - if (ftdi == NULL) { + if (ftdi == NULL) + { return NULL; } - if (ftdi_init(ftdi) != 0) { + if (ftdi_init(ftdi) != 0) + { free(ftdi); - return NULL; + return NULL; } return ftdi; @@ -129,26 +154,39 @@ struct ftdi_context *ftdi_new() Open selected channels on a chip, otherwise use first channel. \param ftdi pointer to ftdi_context - \param interface Interface to use for FT2232C chips. + \param interface Interface to use for FT2232C/2232H/4232H chips. \retval 0: all fine \retval -1: unknown interface */ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) { - switch (interface) { - case INTERFACE_ANY: - case INTERFACE_A: - /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */ - break; - case INTERFACE_B: - ftdi->interface = 1; - ftdi->index = INTERFACE_B; - ftdi->in_ep = 0x04; - ftdi->out_ep = 0x83; - break; - default: - ftdi_error_return(-1, "Unknown interface"); + switch (interface) + { + case INTERFACE_ANY: + case INTERFACE_A: + /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */ + break; + case INTERFACE_B: + ftdi->interface = 1; + ftdi->index = INTERFACE_B; + ftdi->in_ep = 0x04; + ftdi->out_ep = 0x83; + break; + case INTERFACE_C: + ftdi->interface = 2; + ftdi->index = INTERFACE_C; + ftdi->in_ep = 0x06; + ftdi->out_ep = 0x85; + break; + case INTERFACE_D: + ftdi->interface = 3; + ftdi->index = INTERFACE_D; + ftdi->in_ep = 0x08; + ftdi->out_ep = 0x87; + break; + default: + ftdi_error_return(-1, "Unknown interface"); } return 0; } @@ -160,12 +198,16 @@ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) */ void ftdi_deinit(struct ftdi_context *ftdi) { - if (ftdi->async_usb_buffer != NULL) { + ftdi_usb_close_internal (ftdi); + + if (ftdi->async_usb_buffer != NULL) + { free(ftdi->async_usb_buffer); ftdi->async_usb_buffer = NULL; } - if (ftdi->readbuffer != NULL) { + if (ftdi->readbuffer != NULL) + { free(ftdi->readbuffer); ftdi->readbuffer = NULL; } @@ -223,8 +265,10 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli curdev = devlist; *curdev = NULL; - for (bus = usb_busses; bus; bus = bus->next) { - for (dev = bus->devices; dev; dev = dev->next) { + for (bus = usb_get_busses(); bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) { @@ -253,7 +297,8 @@ void ftdi_list_free(struct ftdi_device_list **devlist) { struct ftdi_device_list *curdev, *next; - for (curdev = *devlist; curdev != NULL;) { + for (curdev = *devlist; curdev != NULL;) + { next = curdev->next; free(curdev); curdev = next; @@ -299,7 +344,7 @@ void ftdi_list_free2(struct ftdi_device_list *devlist) \retval -10: unable to close device */ int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev, - char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len) + char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len) { if ((ftdi==NULL) || (dev==NULL)) return -1; @@ -307,40 +352,86 @@ int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev, if (!(ftdi->usb_dev = usb_open(dev))) ftdi_error_return(-4, usb_strerror()); - if (manufacturer != NULL) { - if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0) { - usb_close (ftdi->usb_dev); + if (manufacturer != NULL) + { + if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0) + { + ftdi_usb_close_internal (ftdi); ftdi_error_return(-7, usb_strerror()); } } - if (description != NULL) { - if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0) { - usb_close (ftdi->usb_dev); + if (description != NULL) + { + if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0) + { + ftdi_usb_close_internal (ftdi); ftdi_error_return(-8, usb_strerror()); } } - if (serial != NULL) { - if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0) { - usb_close (ftdi->usb_dev); + if (serial != NULL) + { + if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0) + { + ftdi_usb_close_internal (ftdi); ftdi_error_return(-9, usb_strerror()); } } - if (usb_close (ftdi->usb_dev) != 0) + if (ftdi_usb_close_internal (ftdi) != 0) ftdi_error_return(-10, usb_strerror()); return 0; } /** + * Internal function to determine the maximum packet size. + * \param ftdi pointer to ftdi_context + * \param dev libusb usb_dev to use + * \retval Maximum packet size for this device + */ +static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, struct usb_device *dev) +{ + unsigned int packet_size; + + // Determine maximum packet size. Init with default value. + // New hi-speed devices from FTDI use a packet size of 512 bytes + // but could be connected to a normal speed USB hub -> 64 bytes packet size. + if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H) + packet_size = 512; + else + packet_size = 64; + + if (dev->descriptor.bNumConfigurations > 0 && dev->config) + { + struct usb_config_descriptor config = dev->config[0]; + + if (ftdi->interface < config.bNumInterfaces) + { + struct usb_interface interface = config.interface[ftdi->interface]; + if (interface.num_altsetting > 0) + { + struct usb_interface_descriptor descriptor = interface.altsetting[0]; + if (descriptor.bNumEndpoints > 0) + { + packet_size = descriptor.endpoint[0].wMaxPacketSize; + } + } + } + } + + return packet_size; +} + +/** Opens a ftdi device given by a usb_device. \param ftdi pointer to ftdi_context \param dev libusb usb_dev to use \retval 0: all fine + \retval -3: unable to config device \retval -4: unable to open device \retval -5: unable to claim device \retval -6: reset failed @@ -349,35 +440,68 @@ int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev, int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev) { int detach_errno = 0; + int config_val = 1; if (!(ftdi->usb_dev = usb_open(dev))) ftdi_error_return(-4, "usb_open() failed"); #ifdef LIBUSB_HAS_GET_DRIVER_NP - // Try to detach ftdi_sio kernel module - // Returns ENODATA if driver is not loaded + // Try to detach ftdi_sio kernel module. + // Returns ENODATA if driver is not loaded. + // + // The return code is kept in a separate variable and only parsed + // if usb_set_configuration() or usb_claim_interface() fails as the + // detach operation might be denied and everything still works fine. + // Likely scenario is a static ftdi_sio kernel module. if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA) detach_errno = errno; #endif - if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) { - usb_close (ftdi->usb_dev); - if (detach_errno == EPERM) { +#ifdef __WIN32__ + // 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) + { + // 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) + { + ftdi_usb_close_internal (ftdi); + if (detach_errno == EPERM) + { + ftdi_error_return(-8, "inappropriate permissions on device!"); + } + else + { + ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!"); + } + } + } +#endif + + if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) + { + ftdi_usb_close_internal (ftdi); + if (detach_errno == EPERM) + { ftdi_error_return(-8, "inappropriate permissions on device!"); - } else { + } + else + { ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!"); } } - if (ftdi_usb_reset (ftdi) != 0) { - usb_close (ftdi->usb_dev); + if (ftdi_usb_reset (ftdi) != 0) + { + ftdi_usb_close_internal (ftdi); ftdi_error_return(-6, "ftdi_usb_reset failed"); } - if (ftdi_set_baudrate (ftdi, 9600) != 0) { - usb_close (ftdi->usb_dev); - ftdi_error_return(-7, "set baudrate failed"); - } - // Try to guess chip type // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200 @@ -385,12 +509,36 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev) ftdi->type = TYPE_BM; else if (dev->descriptor.bcdDevice == 0x200) ftdi->type = TYPE_AM; - else if (dev->descriptor.bcdDevice == 0x500) { + else if (dev->descriptor.bcdDevice == 0x500) ftdi->type = TYPE_2232C; - if (!ftdi->index) - ftdi->index = INTERFACE_A; - } else if (dev->descriptor.bcdDevice == 0x600) + else if (dev->descriptor.bcdDevice == 0x600) ftdi->type = TYPE_R; + else if (dev->descriptor.bcdDevice == 0x700) + ftdi->type = TYPE_2232H; + else if (dev->descriptor.bcdDevice == 0x800) + ftdi->type = TYPE_4232H; + + // Set default interface on dual/quad type chips + switch(ftdi->type) + { + case TYPE_2232C: + case TYPE_2232H: + case TYPE_4232H: + if (!ftdi->index) + ftdi->index = INTERFACE_A; + break; + default: + break; + } + + // Determine maximum packet size + ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev); + + if (ftdi_set_baudrate (ftdi, 9600) != 0) + { + ftdi_usb_close_internal (ftdi); + ftdi_error_return(-7, "set baudrate failed"); + } ftdi_error_return(0, "all fine"); } @@ -445,37 +593,46 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, if (usb_find_devices() < 0) ftdi_error_return(-2, "usb_find_devices() failed"); - for (bus = usb_busses; bus; bus = bus->next) { - for (dev = bus->devices; dev; dev = dev->next) { + for (bus = usb_get_busses(); bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { if (dev->descriptor.idVendor == vendor - && dev->descriptor.idProduct == product) { + && dev->descriptor.idProduct == product) + { if (!(ftdi->usb_dev = usb_open(dev))) ftdi_error_return(-4, "usb_open() failed"); - if (description != NULL) { - if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) { - usb_close (ftdi->usb_dev); + if (description != NULL) + { + 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 (usb_close (ftdi->usb_dev) != 0) + if (strncmp(string, description, sizeof(string)) != 0) + { + if (ftdi_usb_close_internal (ftdi) != 0) ftdi_error_return(-10, "unable to close device"); continue; } } - if (serial != NULL) { - if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) { - usb_close (ftdi->usb_dev); + if (serial != NULL) + { + 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 (usb_close (ftdi->usb_dev) != 0) + if (strncmp(string, serial, sizeof(string)) != 0) + { + if (ftdi_usb_close_internal (ftdi) != 0) ftdi_error_return(-10, "unable to close device"); continue; } } - if (usb_close (ftdi->usb_dev) != 0) + if (ftdi_usb_close_internal (ftdi) != 0) ftdi_error_return(-10, "unable to close device"); return ftdi_usb_open_dev(ftdi, dev); @@ -497,7 +654,9 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, */ int ftdi_usb_reset(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + if (usb_control_msg(ftdi->usb_dev, 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 @@ -517,7 +676,9 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) */ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "FTDI purge of RX buffer failed"); // Invalidate data in the readbuffer @@ -537,7 +698,9 @@ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) */ int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + if (usb_control_msg(ftdi->usb_dev, 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; @@ -567,6 +730,8 @@ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) return 0; } + + /** Closes the ftdi device. Call ftdi_deinit() if you're cleaning up. @@ -585,10 +750,11 @@ int ftdi_usb_close(struct ftdi_context *ftdi) ftdi_async_complete(ftdi,1); #endif - if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0) - rtn = -1; + if (ftdi->usb_dev != NULL) + if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0) + rtn = -1; - if (usb_close (ftdi->usb_dev) != 0) + if (ftdi_usb_close_internal (ftdi) != 0) rtn = -2; return rtn; @@ -609,14 +775,16 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, unsigned long encoded_divisor; int i; - if (baudrate <= 0) { + if (baudrate <= 0) + { // Return error return -1; } divisor = 24000000 / baudrate; - if (ftdi->type == TYPE_AM) { + if (ftdi->type == TYPE_AM) + { // Round down to supported fraction (AM only) divisor -= am_adjust_dn[divisor & 7]; } @@ -625,31 +793,44 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, best_divisor = 0; best_baud = 0; best_baud_diff = 0; - for (i = 0; i < 2; i++) { + for (i = 0; i < 2; i++) + { int try_divisor = divisor + i; int baud_estimate; int baud_diff; // Round up to supported divisor value - if (try_divisor <= 8) { + if (try_divisor <= 8) + { // Round up to minimum supported divisor try_divisor = 8; - } else if (ftdi->type != TYPE_AM && try_divisor < 12) { + } + else if (ftdi->type != TYPE_AM && try_divisor < 12) + { // BM doesn't support divisors 9 through 11 inclusive try_divisor = 12; - } else if (divisor < 16) { + } + else if (divisor < 16) + { // AM doesn't support divisors 9 through 15 inclusive try_divisor = 16; - } else { - if (ftdi->type == TYPE_AM) { + } + else + { + if (ftdi->type == TYPE_AM) + { // Round up to supported fraction (AM only) try_divisor += am_adjust_up[try_divisor & 7]; - if (try_divisor > 0x1FFF8) { + if (try_divisor > 0x1FFF8) + { // Round down to maximum supported divisor value (for AM) try_divisor = 0x1FFF8; } - } else { - if (try_divisor > 0x1FFFF) { + } + else + { + if (try_divisor > 0x1FFFF) + { // Round down to maximum supported divisor value (for BM) try_divisor = 0x1FFFF; } @@ -658,17 +839,22 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, // Get estimated baud rate (to nearest integer) baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor; // Get absolute difference from requested baud rate - if (baud_estimate < baudrate) { + if (baud_estimate < baudrate) + { baud_diff = baudrate - baud_estimate; - } else { + } + else + { baud_diff = baud_estimate - baudrate; } - if (i == 0 || baud_diff < best_baud_diff) { + if (i == 0 || baud_diff < best_baud_diff) + { // Closest to requested baud rate so far best_divisor = try_divisor; best_baud = baud_estimate; best_baud_diff = baud_diff; - if (baud_diff == 0) { + if (baud_diff == 0) + { // Spot on! No point trying break; } @@ -677,14 +863,18 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, // Encode the best divisor value encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14); // Deal with special cases for encoded value - if (encoded_divisor == 1) { + if (encoded_divisor == 1) + { encoded_divisor = 0; // 3000000 baud - } else if (encoded_divisor == 0x4001) { + } + else if (encoded_divisor == 0x4001) + { encoded_divisor = 1; // 2000000 baud (BM only) } // Split into "value" and "index" values *value = (unsigned short)(encoded_divisor & 0xFFFF); - if(ftdi->type == TYPE_2232C) { + if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H) + { *index = (unsigned short)(encoded_divisor >> 8); *index &= 0xFF00; *index |= ftdi->index; @@ -711,7 +901,8 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) unsigned short value, index; int actual_baudrate; - if (ftdi->bitbang_enabled) { + if (ftdi->bitbang_enabled) + { baudrate = baudrate*4; } @@ -726,7 +917,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, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) + if (usb_control_msg(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; @@ -734,7 +927,9 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) } /** - Set (RS232) line characteristics by Alain Abbas + Set (RS232) line characteristics. + The break type can only be set via ftdi_set_line_property2() + and defaults to "off". \param ftdi pointer to ftdi_context \param bits Number of bits @@ -747,39 +942,72 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity) { + return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF); +} + +/** + Set (RS232) line characteristics + + \param ftdi pointer to ftdi_context + \param bits Number of bits + \param sbit Number of stop bits + \param parity Parity mode + \param break_type Break type + + \retval 0: all fine + \retval -1: Setting line property failed +*/ +int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, + enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, + enum ftdi_break_type break_type) +{ unsigned short value = bits; - switch(parity) { - case NONE: - value |= (0x00 << 8); - break; - case ODD: - value |= (0x01 << 8); - break; - case EVEN: - value |= (0x02 << 8); - break; - case MARK: - value |= (0x03 << 8); - break; - case SPACE: - value |= (0x04 << 8); - break; + switch (parity) + { + case NONE: + value |= (0x00 << 8); + break; + case ODD: + value |= (0x01 << 8); + break; + case EVEN: + value |= (0x02 << 8); + break; + case MARK: + value |= (0x03 << 8); + break; + case SPACE: + value |= (0x04 << 8); + break; + } + + switch (sbit) + { + case STOP_BIT_1: + value |= (0x00 << 11); + break; + case STOP_BIT_15: + value |= (0x01 << 11); + break; + case STOP_BIT_2: + value |= (0x02 << 11); + break; } - switch(sbit) { - case STOP_BIT_1: - value |= (0x00 << 11); - break; - case STOP_BIT_15: - value |= (0x01 << 11); - break; - case STOP_BIT_2: - value |= (0x02 << 11); - break; + switch (break_type) + { + case BREAK_OFF: + value |= (0x00 << 14); + break; + case BREAK_ON: + value |= (0x01 << 14); + break; } - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return (-1, "Setting new line property failed"); return 0; @@ -801,7 +1029,8 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) int offset = 0; int total_written = 0; - while (offset < size) { + while (offset < size) + { int write_size = ftdi->writebuffer_chunksize; if (offset+write_size > size) @@ -819,11 +1048,15 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) } #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 { - int fd; - // some other stuff coming here we don't need +struct usb_dev_handle +{ + int fd; + // some other stuff coming here we don't need }; /** @@ -834,9 +1067,10 @@ static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi) { struct usbdevfs_urb *urb; int pending=0; - int i; + unsigned int i; - for (i=0; i < ftdi->async_usb_buffer_size; i++) { + 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) pending++; @@ -857,46 +1091,52 @@ static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi) */ static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec) { - struct timeval tv; - struct usbdevfs_urb *urb=NULL; - int ret; - fd_set writefds; - int keep_going=0; - - FD_ZERO(&writefds); - FD_SET(ftdi->usb_dev->fd, &writefds); - - /* init timeout only once, select writes time left after call */ - tv.tv_sec = timeout_msec / 1000; - tv.tv_usec = (timeout_msec % 1000) * 1000; - - do { - while (_usb_get_async_urbs_pending(ftdi) - && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1 - && errno == EAGAIN) + struct timeval tv; + struct usbdevfs_urb *urb=NULL; + int ret; + fd_set writefds; + int keep_going=0; + + FD_ZERO(&writefds); + FD_SET(ftdi->usb_dev->fd, &writefds); + + /* init timeout only once, select writes time left after call */ + tv.tv_sec = timeout_msec / 1000; + tv.tv_usec = (timeout_msec % 1000) * 1000; + + do { - if (keep_going && !wait_for_more) { - /* don't wait if repeating only for keep_going */ - keep_going=0; - break; - } - - /* wait for timeout msec or something written ready */ - select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv); - } + 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; + } + + /* wait for timeout msec or something written ready */ + select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv); + } - if (ret == 0 && urb != NULL) { - /* got a free urb, mark it */ - urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE; + if (ret == 0 && urb != NULL) + { + /* got a free urb, mark it */ + urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE; - /* 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; + /* 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; + } } - } while (keep_going); + while (keep_going); } /** @@ -908,7 +1148,7 @@ static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int */ void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more) { - _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout); + _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout); } /** @@ -918,58 +1158,64 @@ void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more) */ static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size) { - struct usbdevfs_urb *urb; - int bytesdone = 0, requested; - int ret, i; - int cleanup_count; - - do { - /* find a free urb buffer we can use */ - urb=NULL; - for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++) + struct usbdevfs_urb *urb; + int bytesdone = 0, requested; + int ret, cleanup_count; + unsigned int i; + + do { - if (i==ftdi->async_usb_buffer_size) { - /* wait until some buffers are free */ - _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout); - } + /* 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); + } - 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; + 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; + } } - } - /* no free urb position found */ - if (urb==NULL) - return -1; + /* no free urb position found */ + if (urb==NULL) + return -1; + + requested = size - bytesdone; + if (requested > 4096) + requested = 4096; + + memset(urb,0,sizeof(urb)); + + 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; + + 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 */ - requested = size - bytesdone; - if (requested > 4096) - requested = 4096; - - memset(urb,0,sizeof(urb)); - - 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; - - 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 */ - - bytesdone += requested; - } while (bytesdone < size); - return bytesdone; + bytesdone += requested; + } + while (bytesdone < size); + return bytesdone; } /** @@ -996,7 +1242,8 @@ int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int siz int offset = 0; int total_written = 0; - while (offset < size) { + while (offset < size) + { int write_size = ftdi->writebuffer_chunksize; if (offset+write_size > size) @@ -1062,9 +1309,15 @@ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunk 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 packet_size = ftdi->max_packet_size; + + // Packet size sanity check (avoid division by zero) + if (packet_size == 0) + ftdi_error_return(-1, "max_packet_size is bogus (zero)"); // everything we want is still in the readbuffer? - if (size <= ftdi->readbuffer_remaining) { + if (size <= ftdi->readbuffer_remaining) + { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size); // Fix offsets @@ -1076,14 +1329,16 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return size; } // something still in the readbuffer, but not enough to satisfy 'size'? - if (ftdi->readbuffer_remaining != 0) { + if (ftdi->readbuffer_remaining != 0) + { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining); // Fix offset offset += ftdi->readbuffer_remaining; } // do the actual USB read - while (offset < size && ret > 0) { + while (offset < size && ret > 0) + { ftdi->readbuffer_remaining = 0; ftdi->readbuffer_offset = 0; /* returns how much received */ @@ -1091,36 +1346,44 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) if (ret < 0) ftdi_error_return(ret, "usb bulk read failed"); - if (ret > 2) { + if (ret > 2) + { // skip FTDI status bytes. // Maybe stored in the future to enable modem use - num_of_chunks = ret / 64; - chunk_remains = ret % 64; + 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); ftdi->readbuffer_offset += 2; ret -= 2; - if (ret > 62) { + if (ret > packet_size - 2) + { for (i = 1; i < num_of_chunks; i++) - memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i, - ftdi->readbuffer+ftdi->readbuffer_offset+64*i, - 62); - if (chunk_remains > 2) { - memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i, - ftdi->readbuffer+ftdi->readbuffer_offset+64*i, + memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i, + ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i, + 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); ret -= 2*num_of_chunks; - } else + } + else ret -= 2*(num_of_chunks-1)+chunk_remains; } - } else if (ret <= 2) { + } + else if (ret <= 2) + { // no more data to read? return offset; } - if (ret > 0) { + if (ret > 0) + { // data still fits in buf? - if (offset+ret <= size) { + if (offset+ret <= size) + { memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret); //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]); offset += ret; @@ -1130,7 +1393,9 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) //printf("read_data exact rem %d offset %d\n", //ftdi->readbuffer_remaining, offset); return offset; - } else { + } + else + { // only copy part of the data or size <= readbuffer_chunksize int part_size = size-offset; memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size); @@ -1213,7 +1478,9 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) /* FT2232C: Set bitbang_mode to 2 to enable SPI */ usb_val |= (ftdi->bitbang_mode << 8); - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?"); ftdi->bitbang_enabled = 1; @@ -1230,7 +1497,7 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) */ int ftdi_disable_bitbang(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?"); ftdi->bitbang_enabled = 0; @@ -1254,7 +1521,7 @@ int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned usb_val = bitmask; // low byte: bitmask usb_val |= (mode << 8); - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?"); ftdi->bitbang_mode = mode; @@ -1273,7 +1540,7 @@ int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned */ int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) { - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1) + 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) ftdi_error_return(-1, "read pins failed"); return 0; @@ -1301,7 +1568,7 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) ftdi_error_return(-1, "latency out of range. Only valid for 1-255"); usb_val = latency; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-2, "unable to set latency timer"); return 0; @@ -1319,7 +1586,7 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) { unsigned short usb_val; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) + 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) ftdi_error_return(-1, "reading latency timer failed"); *latency = (unsigned char)usb_val; @@ -1369,7 +1636,7 @@ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) { char usb_val[2]; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2) + 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) ftdi_error_return(-1, "getting modem status failed"); *status = (usb_val[1] << 8) | usb_val[0]; @@ -1378,6 +1645,110 @@ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) } /** + Set flowcontrol for ftdi chip + + \param ftdi pointer to ftdi_context + \param flowctrl flow control to use. should be + SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS + + \retval 0: all fine + \retval -1: set flow control failed +*/ +int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl) +{ + if (usb_control_msg(ftdi->usb_dev, 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; +} + +/** + Set dtr line + + \param ftdi pointer to ftdi_context + \param state state to set line to (1 or 0) + + \retval 0: all fine + \retval -1: set dtr failed +*/ +int ftdi_setdtr(struct ftdi_context *ftdi, int state) +{ + unsigned short usb_val; + + if (state) + usb_val = SIO_SET_DTR_HIGH; + else + usb_val = SIO_SET_DTR_LOW; + + if (usb_control_msg(ftdi->usb_dev, 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; +} + +/** + Set rts line + + \param ftdi pointer to ftdi_context + \param state state to set line to (1 or 0) + + \retval 0: all fine + \retval -1 set rts failed +*/ +int ftdi_setrts(struct ftdi_context *ftdi, int state) +{ + unsigned short usb_val; + + if (state) + usb_val = SIO_SET_RTS_HIGH; + else + usb_val = SIO_SET_RTS_LOW; + + if (usb_control_msg(ftdi->usb_dev, 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 + + \param ftdi pointer to ftdi_context + \param dtr DTR state to set line to (1 or 0) + \param rts RTS state to set line to (1 or 0) + + \retval 0: all fine + \retval -1 set dtr/rts failed + */ +int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts) +{ + unsigned short usb_val; + + if (dtr) + usb_val = SIO_SET_DTR_HIGH; + else + usb_val = SIO_SET_DTR_LOW; + + if (rts) + usb_val |= SIO_SET_RTS_HIGH; + else + usb_val |= SIO_SET_RTS_LOW; + + if (usb_control_msg(ftdi->usb_dev, 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; +} + +/** Set the special event character \param ftdi pointer to ftdi_context @@ -1388,7 +1759,7 @@ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) \retval -1: unable to set event character */ int ftdi_set_event_char(struct ftdi_context *ftdi, - unsigned char eventch, unsigned char enable) + unsigned char eventch, unsigned char enable) { unsigned short usb_val; @@ -1396,7 +1767,7 @@ int ftdi_set_event_char(struct ftdi_context *ftdi, if (enable) usb_val |= 1 << 8; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x06, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "setting event character failed"); return 0; @@ -1413,7 +1784,7 @@ int ftdi_set_event_char(struct ftdi_context *ftdi, \retval -1: unable to set error character */ int ftdi_set_error_char(struct ftdi_context *ftdi, - unsigned char errorch, unsigned char enable) + unsigned char errorch, unsigned char enable) { unsigned short usb_val; @@ -1421,7 +1792,7 @@ int ftdi_set_error_char(struct ftdi_context *ftdi, if (enable) usb_val |= 1 << 8; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x07, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "setting error character failed"); return 0; @@ -1437,8 +1808,8 @@ int ftdi_set_error_char(struct ftdi_context *ftdi, */ void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size) { - ftdi->eeprom_size=size; - eeprom->size=size; + ftdi->eeprom_size=size; + eeprom->size=size; } /** @@ -1498,11 +1869,11 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) 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 + // 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; + if (eeprom->size>=256)size_check = 120; size_check -= manufacturer_size*2; size_check -= product_size*2; size_check -= serial_size*2; @@ -1532,19 +1903,19 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x07] = 0x02; // Addr 08: Config descriptor - // Bit 1: remote wakeup if 1 - // Bit 0: self powered if 1 - // - j = 0; + // Bit 7: always 1 + // Bit 6: 1 if this device is self powered, 0 if bus powered + // Bit 5: 1 if this device uses remote wakeup + // Bit 4: 1 if this device is battery powered + j = 0x80; if (eeprom->self_powered == 1) - j = j | 1; + j |= 0x40; if (eeprom->remote_wakeup == 1) - j = j | 2; + j |= 0x20; output[0x08] = j; // Addr 09: Max power consumption: max power = value * 2 mA output[0x09] = eeprom->max_power; - ; // Addr 0A: Chip configuration // Bit 7: 0 - reserved @@ -1574,7 +1945,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // 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 (eeprom->change_usb_version == 1) + { output[0x0C] = eeprom->usb_version; output[0x0D] = eeprom->usb_version >> 8; } @@ -1594,14 +1966,15 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // Dynamic content i=0x14; - if(eeprom->size>=256) i = 0x80; + if (eeprom->size>=256) i = 0x80; - // Output manufacturer + // Output manufacturer output[0x0E] = i | 0x80; // calculate offset output[i++] = manufacturer_size*2 + 2; output[i++] = 0x03; // type: string - for (j = 0; j < manufacturer_size; j++) { + for (j = 0; j < manufacturer_size; j++) + { output[i] = eeprom->manufacturer[j], i++; output[i] = 0x00, i++; } @@ -1610,7 +1983,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x10] = i | 0x80; // calculate offset output[i] = product_size*2 + 2, i++; output[i] = 0x03, i++; - for (j = 0; j < product_size; j++) { + for (j = 0; j < product_size; j++) + { output[i] = eeprom->product[j], i++; output[i] = 0x00, i++; } @@ -1619,7 +1993,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x12] = i | 0x80; // calculate offset output[i] = serial_size*2 + 2, i++; output[i] = 0x03, i++; - for (j = 0; j < serial_size; j++) { + for (j = 0; j < serial_size; j++) + { output[i] = eeprom->serial[j], i++; output[i] = 0x00, i++; } @@ -1627,7 +2002,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // calculate checksum checksum = 0xAAAA; - for (i = 0; i < eeprom->size/2-1; i++) { + for (i = 0; i < eeprom->size/2-1; i++) + { value = output[i*2]; value += output[(i*2)+1] << 8; @@ -1642,6 +2018,190 @@ 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 + + \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) +{ + unsigned char i, j; + unsigned short checksum, eeprom_checksum, value; + unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; + int size_check; + int eeprom_size = 128; +#if 0 + size_check = eeprom->size; + size_check -= 28; // 28 are always in use (fixed) + + // Top half of a 256byte eeprom is used just for strings and checksum + // it seems that the FTDI chip will not read these strings from the lower half + // Each string starts with two bytes; offset and type (0x03 for string) + // the checksum needs two bytes, so without the string data that 8 bytes from the top half + if (eeprom->size>=256)size_check = 120; + size_check -= manufacturer_size*2; + size_check -= product_size*2; + size_check -= serial_size*2; + + // eeprom size exceeded? + if (size_check < 0) + return (-1); +#endif + + // empty eeprom struct + memset(eeprom, 0, sizeof(struct ftdi_eeprom)); + + // Addr 00: Stay 00 00 + + // Addr 02: Vendor ID + eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8); + + // Addr 04: Product ID + eeprom->product_id = buf[0x04] + (buf[0x05] << 8); + + 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; + } + + // Addr 08: Config descriptor + // Bit 7: always 1 + // Bit 6: 1 if this device is self powered, 0 if bus powered + // Bit 5: 1 if this device uses remote wakeup + // Bit 4: 1 if this device is battery powered + j = buf[0x08]; + if (j&0x40) eeprom->self_powered = 1; + if (j&0x20) eeprom->remote_wakeup = 1; + + // Addr 09: Max power consumption: max power = value * 2 mA + eeprom->max_power = buf[0x09]; + + // Addr 0A: Chip configuration + // Bit 7: 0 - reserved + // Bit 6: 0 - reserved + // Bit 5: 0 - reserved + // Bit 4: 1 - Change USB version + // Bit 3: 1 - Use the serial number string + // Bit 2: 1 - Enable suspend pull downs for lower power + // Bit 1: 1 - Out EndPoint is Isochronous + // Bit 0: 1 - In EndPoint is Isochronous + // + j = buf[0x0A]; + if (j&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; + + // 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 0E: Offset of the manufacturer string + 0x80, calculated later + // Addr 0F: Length of manufacturer string + manufacturer_size = buf[0x0F]/2; + if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size); + else eeprom->manufacturer = NULL; + + // Addr 10: Offset of the product string + 0x80, calculated later + // Addr 11: Length of product string + product_size = buf[0x11]/2; + if (product_size > 0) eeprom->product = malloc(product_size); + else eeprom->product = NULL; + + // Addr 12: Offset of the serial string + 0x80, calculated later + // Addr 13: Length of serial string + serial_size = buf[0x13]/2; + if (serial_size > 0) eeprom->serial = malloc(serial_size); + else eeprom->serial = NULL; + + // Decode manufacturer + i = buf[0x0E] & 0x7f; // offset + for (j=0;jmanufacturer[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[j] = '\0'; + + // verify checksum + checksum = 0xAAAA; + + for (i = 0; i < eeprom_size/2-1; i++) + { + value = buf[i*2]; + value += buf[(i*2)+1] << 8; + + checksum = value^checksum; + checksum = (checksum << 1) | (checksum >> 15); + } + + eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8); + + if (eeprom_checksum != checksum) + { + fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum); + return -1; + } + + return 0; +} + +/** + Read eeprom location + + \param ftdi pointer to ftdi_context + \param eeprom_addr Address of eeprom location to be read + \param eeprom_val Pointer to store read eeprom location + + \retval 0: all fine + \retval -1: read failed +*/ +int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val) +{ + if (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) + ftdi_error_return(-1, "reading eeprom failed"); + + return 0; +} + +/** Read eeprom \param ftdi pointer to ftdi_context @@ -1654,8 +2214,9 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) { int i; - for (i = 0; i < ftdi->eeprom_size/2; i++) { - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) + for (i = 0; i < ftdi->eeprom_size/2; i++) + { + if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) ftdi_error_return(-1, "reading eeprom failed"); } @@ -1670,13 +2231,13 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) static unsigned char ftdi_read_chipid_shift(unsigned char value) { return ((value & 1) << 1) | - ((value & 2) << 5) | - ((value & 4) >> 2) | - ((value & 8) << 4) | - ((value & 16) >> 1) | - ((value & 32) >> 1) | - ((value & 64) >> 4) | - ((value & 128) >> 2); + ((value & 2) << 5) | + ((value & 4) >> 2) | + ((value & 8) << 4) | + ((value & 16) >> 1) | + ((value & 32) >> 1) | + ((value & 64) >> 4) | + ((value & 128) >> 2); } /** @@ -1692,13 +2253,13 @@ int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid) { unsigned int a = 0, b = 0; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2) + 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) { a = a << 8 | a >> 8; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2) + 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) { b = b << 8 | b >> 8; - a = (a << 16) | b; + a = (a << 16) | (b & 0xFFFF); a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24; *chipid = a ^ 0xa5f0f7d1; @@ -1724,19 +2285,44 @@ int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, i int i=0,j,minsize=32; int size=minsize; - do{ - for (j = 0; i < maxsize/2 && jusb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) - ftdi_error_return(-1, "reading eeprom failed"); - i++; - } - size*=2; - }while(size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0); + 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 + \param eeprom_addr Address of eeprom location to be written + \param eeprom_val Value to be written + + \retval 0: all fine + \retval -1: read failed +*/ +int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val) +{ + if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, + SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr, + NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to write eeprom"); + + return 0; +} + +/** Write eeprom \param ftdi pointer to ftdi_context @@ -1747,13 +2333,24 @@ int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, i */ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) { - unsigned short usb_val; - int i; - - for (i = 0; i < ftdi->eeprom_size/2; i++) { + unsigned short usb_val, status; + int i, ret; + + /* These commands were traced while running MProg */ + if ((ret = ftdi_usb_reset(ftdi)) != 0) + return ret; + if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0) + return ret; + if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0) + return ret; + + for (i = 0; i < ftdi->eeprom_size/2; i++) + { usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) + 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) ftdi_error_return(-1, "unable to write eeprom"); } @@ -1763,6 +2360,8 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) /** Erase eeprom + This is not supported on FT232R/FT245R according to the MProg manual from FTDI. + \param ftdi pointer to ftdi_context \retval 0: all fine @@ -1770,7 +2369,7 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) */ int ftdi_erase_eeprom(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) + if (usb_control_msg(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; @@ -1788,80 +2387,4 @@ char *ftdi_get_error_string (struct ftdi_context *ftdi) return ftdi->error_str; } -/* - Flow control code by Lorenz Moesenlechner (lorenz@hcilab.org) - and Matthias Kranz (matthias@hcilab.org) -*/ -/** - Set flowcontrol for ftdi chip - - \param ftdi pointer to ftdi_context - \param flowctrl flow control to use. should be - SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS - - \retval 0: all fine - \retval -1: set flow control failed -*/ -int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl) -{ - if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE, - SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->interface), - NULL, 0, ftdi->usb_write_timeout) != 0) - ftdi_error_return(-1, "set flow control failed"); - - return 0; -} - -/** - Set dtr line - - \param ftdi pointer to ftdi_context - \param state state to set line to (1 or 0) - - \retval 0: all fine - \retval -1: set dtr failed -*/ -int ftdi_setdtr(struct ftdi_context *ftdi, int state) -{ - unsigned short usb_val; - - if (state) - usb_val = SIO_SET_DTR_HIGH; - else - usb_val = SIO_SET_DTR_LOW; - - if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE, - SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, - NULL, 0, ftdi->usb_write_timeout) != 0) - ftdi_error_return(-1, "set dtr failed"); - - return 0; -} - -/** - Set rts line - - \param ftdi pointer to ftdi_context - \param state state to set line to (1 or 0) - - \retval 0: all fine - \retval -1 set rts failed -*/ -int ftdi_setrts(struct ftdi_context *ftdi, int state) -{ - unsigned short usb_val; - - if (state) - usb_val = SIO_SET_RTS_HIGH; - else - usb_val = SIO_SET_RTS_LOW; - - if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE, - SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, - NULL, 0, ftdi->usb_write_timeout) != 0) - ftdi_error_return(-1, "set of rts failed"); - - return 0; -} - /* @} end of doxygen libftdi group */