X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=0a7fb274dd927d45615bbd26c11e950155164e46;hp=95028e52e64e0de7318a367638521ca990a45677;hb=0684c1b1be9ccb893829c20a8505c91e101bbf43;hpb=f37a15246fb738210ecc188d168039037adc50bf diff --git a/src/ftdi.c b/src/ftdi.c index 95028e5..0a7fb27 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2,8 +2,9 @@ ftdi.c - description ------------------- begin : Fri Apr 4 2003 - copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers + copyright : (C) 2003-2020 by Intra2net AG and the libftdi developers email : opensource@intra2net.com + SPDX-License-Identifier: LGPL-2.1-only ***************************************************************************/ /*************************************************************************** @@ -18,7 +19,7 @@ \mainpage libftdi API documentation Library to talk to FTDI chips. You find the latest versions of libftdi at - http://www.intra2net.com/en/developer/libftdi/ + https://www.intra2net.com/en/developer/libftdi/ The library is easy to use. Have a look at this short example: \include simple.c @@ -35,6 +36,8 @@ #include #include "ftdi_i.h" +/* Prevent deprecated messages when building library */ +#define _FTDI_DISABLE_DEPRECATED #include "ftdi.h" #include "ftdi_version_i.h" @@ -87,7 +90,7 @@ static void ftdi_usb_close_internal (struct ftdi_context *ftdi) */ int ftdi_init(struct ftdi_context *ftdi) { - struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom)); + struct ftdi_eeprom* eeprom; ftdi->usb_ctx = NULL; ftdi->usb_dev = NULL; ftdi->usb_read_timeout = 5000; @@ -111,6 +114,7 @@ int ftdi_init(struct ftdi_context *ftdi) ftdi_set_interface(ftdi, INTERFACE_ANY); ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */ + eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom)); if (eeprom == 0) ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom"); memset(eeprom, 0, sizeof(struct ftdi_eeprom)); @@ -278,7 +282,7 @@ void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb) * * @return ftdi_version_info Library version information **/ -struct ftdi_version_info ftdi_get_library_version() +struct ftdi_version_info ftdi_get_library_version(void) { struct ftdi_version_info ver; @@ -295,7 +299,7 @@ struct ftdi_version_info ftdi_get_library_version() Finds all ftdi devices with given VID:PID on the usb bus. Creates a new ftdi_device_list which needs to be deallocated by ftdi_list_free() after use. With VID:PID 0:0, search for the default devices - (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014) + (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014, 0x403:0x6015) \param ftdi pointer to ftdi_context \param devlist Pointer where to store list of found devices @@ -328,11 +332,12 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli if (libusb_get_device_descriptor(dev, &desc) < 0) ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs); - if (((vendor != 0 && product != 0) && - desc.idVendor == vendor && desc.idProduct == product) || - ((vendor == 0 && product == 0) && - (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010 - || desc.idProduct == 0x6011 || desc.idProduct == 0x6014))) + if (((vendor || product) && + desc.idVendor == vendor && desc.idProduct == product) || + (!(vendor || product) && + (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010 + || desc.idProduct == 0x6011 || desc.idProduct == 0x6014 + || desc.idProduct == 0x6015))) { *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list)); if (!*curdev) @@ -405,48 +410,122 @@ void ftdi_list_free2(struct ftdi_device_list *devlist) \retval -9: get serial number failed \retval -11: libusb_get_device_descriptor() failed */ -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) +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) +{ + int ret; + + if ((ftdi==NULL) || (dev==NULL)) + return -1; + + if (ftdi->usb_dev == NULL && libusb_open(dev, &ftdi->usb_dev) < 0) + ftdi_error_return(-4, "libusb_open() failed"); + + // ftdi->usb_dev will not be NULL when entering ftdi_usb_get_strings2(), so + // it won't be closed either. This allows us to close it whether we actually + // called libusb_open() up above or not. This matches the expected behavior + // (and note) for ftdi_usb_get_strings(). + ret = ftdi_usb_get_strings2(ftdi, dev, + manufacturer, mnf_len, + description, desc_len, + serial, serial_len); + + // only close it if it was successful, as all other return codes close + // before returning already. + if (ret == 0) + ftdi_usb_close_internal(ftdi); + + return ret; +} + +/** + Return device ID strings from the usb device. + + The parameters manufacturer, description and serial may be NULL + or pointer to buffers to store the fetched strings. + + \note The old function ftdi_usb_get_strings() always closes the device. + This version only closes the device if it was opened by it. + + \param ftdi pointer to ftdi_context + \param dev libusb usb_dev to use + \param manufacturer Store manufacturer string here if not NULL + \param mnf_len Buffer size of manufacturer string + \param description Store product description string here if not NULL + \param desc_len Buffer size of product description string + \param serial Store serial string here if not NULL + \param serial_len Buffer size of serial string + + \retval 0: all fine + \retval -1: wrong arguments + \retval -4: unable to open device + \retval -7: get product manufacturer failed + \retval -8: get product description failed + \retval -9: get serial number failed + \retval -11: libusb_get_device_descriptor() failed +*/ +int ftdi_usb_get_strings2(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; + char need_open; if ((ftdi==NULL) || (dev==NULL)) return -1; - if (libusb_open(dev, &ftdi->usb_dev) < 0) + need_open = (ftdi->usb_dev == NULL); + if (need_open && 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 (manufacturer != NULL && mnf_len > 0) { - if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0) + if (desc.iManufacturer == 0) + { + manufacturer[0] = '\0'; + } + else 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, "libusb_get_string_descriptor_ascii() failed"); } } - if (description != NULL) + if (description != NULL && desc_len > 0) { - if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0) + if (desc.iProduct == 0) + { + description[0] = '\0'; + } + else 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, "libusb_get_string_descriptor_ascii() failed"); } } - if (serial != NULL) + if (serial != NULL && serial_len > 0) { - if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0) + if (desc.iSerialNumber == 0) + { + serial[0] = '\0'; + } + else 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, "libusb_get_string_descriptor_ascii() failed"); } } - ftdi_usb_close_internal (ftdi); + if (need_open) + ftdi_usb_close_internal (ftdi); return 0; } @@ -470,7 +549,7 @@ static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, l // 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 || ftdi->type == TYPE_232H ) + if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H) packet_size = 512; else packet_size = 64; @@ -550,6 +629,11 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev) if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0) detach_errno = errno; } + else if (ftdi->module_detach_mode == AUTO_DETACH_REATACH_SIO_MODULE) + { + if (libusb_set_auto_detach_kernel_driver(ftdi->usb_dev, 1) != LIBUSB_SUCCESS) + detach_errno = errno; + } if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0) ftdi_error_return(-12, "libusb_get_configuration () failed"); @@ -608,6 +692,8 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev) ftdi->type = TYPE_4232H; else if (desc.bcdDevice == 0x900) ftdi->type = TYPE_232H; + else if (desc.bcdDevice == 0x1000) + ftdi->type = TYPE_230X; // Determine maximum packet size ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev); @@ -685,6 +771,7 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, \retval -9: get serial number failed \retval -10: unable to close device \retval -11: ftdi context invalid + \retval -12: libusb_get_device_list() failed */ int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, const char* description, const char* serial, unsigned int index) @@ -759,6 +846,54 @@ int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, } /** + Opens the device at a given USB bus and device address. + + \param ftdi pointer to ftdi_context + \param bus Bus number + \param addr Device address + + \retval 0: all fine + \retval -1: usb_find_busses() failed + \retval -2: usb_find_devices() failed + \retval -3: usb device not found + \retval -4: unable to open device + \retval -5: unable to claim device + \retval -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: ftdi context invalid + \retval -12: libusb_get_device_list() failed +*/ +int ftdi_usb_open_bus_addr(struct ftdi_context *ftdi, uint8_t bus, uint8_t addr) +{ + libusb_device *dev; + libusb_device **devs; + int i = 0; + + if (ftdi == NULL) + ftdi_error_return(-11, "ftdi context invalid"); + + if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0) + ftdi_error_return(-12, "libusb_get_device_list() failed"); + + while ((dev = devs[i++]) != NULL) + { + if (libusb_get_bus_number(dev) == bus && libusb_get_device_address(dev) == addr) + { + int res; + res = ftdi_usb_open_dev(ftdi, dev); + libusb_free_device_list(devs,1); + return res; + } + } + + // 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. @@ -896,6 +1031,7 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) /** Clears the read buffer on the chip and the internal read buffer. + This is the correct behavior for an RX flush. \param ftdi pointer to ftdi_context @@ -903,6 +1039,36 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) \retval -1: read buffer purge failed \retval -2: USB device unavailable */ +int ftdi_tciflush(struct ftdi_context *ftdi) +{ + 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_TCIFLUSH, + ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0) + ftdi_error_return(-1, "FTDI purge of RX buffer failed"); + + // Invalidate data in the readbuffer + ftdi->readbuffer_offset = 0; + ftdi->readbuffer_remaining = 0; + + return 0; +} + + +/** + Clears the write buffer on the chip and the internal read buffer. + This is incorrect behavior for an RX flush. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: write buffer purge failed + \retval -2: USB device unavailable + + \deprecated Use \ref ftdi_tciflush(struct ftdi_context *ftdi) +*/ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) { if (ftdi == NULL || ftdi->usb_dev == NULL) @@ -922,6 +1088,7 @@ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) /** Clears the write buffer on the chip. + This is correct behavior for a TX flush. \param ftdi pointer to ftdi_context @@ -929,6 +1096,32 @@ int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) \retval -1: write buffer purge failed \retval -2: USB device unavailable */ +int ftdi_tcoflush(struct ftdi_context *ftdi) +{ + 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_TCOFLUSH, + ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0) + ftdi_error_return(-1, "FTDI purge of TX buffer failed"); + + return 0; +} + + +/** + Clears the read buffer on the chip. + This is incorrect behavior for a TX flush. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: read buffer purge failed + \retval -2: USB device unavailable + + \deprecated Use \ref ftdi_tcoflush(struct ftdi_context *ftdi) +*/ int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) { if (ftdi == NULL || ftdi->usb_dev == NULL) @@ -943,7 +1136,37 @@ int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) } /** + Clears the RX and TX FIFOs on the chip and the internal read buffer. + This is correct behavior for both RX and TX flush. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: read buffer purge failed + \retval -2: write buffer purge failed + \retval -3: USB device unavailable +*/ +int ftdi_tcioflush(struct ftdi_context *ftdi) +{ + int result; + + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-3, "USB device unavailable"); + + result = ftdi_tcoflush(ftdi); + if (result < 0) + return -1; + + result = ftdi_tciflush(ftdi); + if (result < 0) + return -2; + + return 0; +} + +/** Clears the buffers on the chip and the internal read buffer. + While coded incorrectly, the result is satisfactory. \param ftdi pointer to ftdi_context @@ -951,6 +1174,8 @@ int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) \retval -1: read buffer purge failed \retval -2: write buffer purge failed \retval -3: USB device unavailable + + \deprecated Use \ref ftdi_tcioflush(struct ftdi_context *ftdi) */ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) { @@ -997,7 +1222,7 @@ int ftdi_usb_close(struct ftdi_context *ftdi) return rtn; } -/* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate +/* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate to encoded divisor and the achievable baudrate Function is only used internally \internal @@ -1016,8 +1241,8 @@ static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor) static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1}; static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3}; int divisor, best_divisor, best_baud, best_baud_diff; - divisor = 24000000 / baudrate; int i; + divisor = 24000000 / baudrate; // Round down to supported fraction (AM only) divisor -= am_adjust_dn[divisor & 7]; @@ -1109,13 +1334,13 @@ static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor) H Type have all features above with {index[8],value[15:14]} is the encoded subdivisor - FT232R, FT2232 and FT232BM have no option for 12 MHz and with + FT232R, FT2232 and FT232BM have no option for 12 MHz and with {index[0],value[15:14]} is the encoded subdivisor AM Type chips have only four fractional subdivisors at value[15:14] for subdivisors 0, 0.5, 0.25, 0.125 */ -static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor) +static int ftdi_to_clkbits(int baudrate, int clk, int clk_div, unsigned long *encoded_divisor) { static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7}; int best_baud = 0; @@ -1153,7 +1378,7 @@ static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14); } return best_baud; -} +} /** ftdi_convert_baudrate returns nearest supported baud rate to that requested. Function is only used internally @@ -1173,12 +1398,12 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, #define H_CLK 120000000 #define C_CLK 48000000 - if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H )) + if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H)) { if(baudrate*10 > H_CLK /0x3fff) { /* On H Devices, use 12 000 000 Baudrate when possible - We have a 14 bit divisor, a 1 bit divisor switch (10 or 16) + We have a 14 bit divisor, a 1 bit divisor switch (10 or 16) three fractional bits and a 120 MHz clock Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/ @@ -1188,7 +1413,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, else best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor); } - else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R )) + else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X)) { best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor); } @@ -1198,8 +1423,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, } // Split into "value" and "index" values *value = (unsigned short)(encoded_divisor & 0xFFFF); - if (ftdi->type == TYPE_2232H || - ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H ) + if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H) { *index = (unsigned short)(encoded_divisor >> 8); *index &= 0xFF00; @@ -1217,7 +1441,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, * Do not use, it's only for the unit test framework **/ int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi, - unsigned short *value, unsigned short *index) + unsigned short *value, unsigned short *index) { return ftdi_convert_baudrate(baudrate, ftdi, value, index); } @@ -1368,7 +1592,7 @@ int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, \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 ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size) { int offset = 0; int actual_length; @@ -1383,7 +1607,7 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) if (offset+write_size > size) write_size = size-offset; - if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0) + if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, (unsigned char *)buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0) ftdi_error_return(-1, "usb bulk write failed"); offset += actual_length; @@ -1392,7 +1616,7 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return offset; } -static void ftdi_read_data_cb(struct libusb_transfer *transfer) +static void LIBUSB_CALL ftdi_read_data_cb(struct libusb_transfer *transfer) { struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data; struct ftdi_context *ftdi = tc->ftdi; @@ -1468,13 +1692,19 @@ static void ftdi_read_data_cb(struct libusb_transfer *transfer) } } } - ret = libusb_submit_transfer (transfer); - if (ret < 0) - tc->completed = 1; + + if (transfer->status == LIBUSB_TRANSFER_CANCELLED) + tc->completed = LIBUSB_TRANSFER_CANCELLED; + else + { + ret = libusb_submit_transfer (transfer); + if (ret < 0) + tc->completed = 1; + } } -static void ftdi_write_data_cb(struct libusb_transfer *transfer) +static void LIBUSB_CALL 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; @@ -1495,9 +1725,15 @@ static void ftdi_write_data_cb(struct libusb_transfer *transfer) transfer->length = write_size; transfer->buffer = tc->buf + tc->offset; - ret = libusb_submit_transfer (transfer); - if (ret < 0) - tc->completed = 1; + + if (transfer->status == LIBUSB_TRANSFER_CANCELLED) + tc->completed = LIBUSB_TRANSFER_CANCELLED; + else + { + ret = libusb_submit_transfer (transfer); + if (ret < 0) + tc->completed = 1; + } } } @@ -1542,7 +1778,7 @@ struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, tc->size = size; tc->offset = 0; - if (size < ftdi->writebuffer_chunksize) + if (size < (int)ftdi->writebuffer_chunksize) write_size = size; else write_size = ftdi->writebuffer_chunksize; @@ -1595,7 +1831,7 @@ struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, u tc->buf = buf; tc->size = size; - if (size <= ftdi->readbuffer_remaining) + if (size <= (int)ftdi->readbuffer_remaining) { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size); @@ -1660,17 +1896,19 @@ struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, u int ftdi_transfer_data_done(struct ftdi_transfer_control *tc) { int ret; - + struct timeval to = { 0, 0 }; while (!tc->completed) { - ret = libusb_handle_events(tc->ftdi->usb_ctx); + ret = libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, + &to, &tc->completed); if (ret < 0) { if (ret == LIBUSB_ERROR_INTERRUPTED) continue; libusb_cancel_transfer(tc->transfer); while (!tc->completed) - if (libusb_handle_events(tc->ftdi->usb_ctx) < 0) + if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, + &to, &tc->completed) < 0) break; libusb_free_transfer(tc->transfer); free (tc); @@ -1694,6 +1932,39 @@ int ftdi_transfer_data_done(struct ftdi_transfer_control *tc) } /** + Cancel transfer and wait for completion. + + Use libusb 1.0 asynchronous API. + + \param tc pointer to ftdi_transfer_control + \param to pointer to timeout value or NULL for infinite +*/ + +void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc, + struct timeval * to) +{ + struct timeval tv = { 0, 0 }; + + if (!tc->completed && tc->transfer != NULL) + { + if (to == NULL) + to = &tv; + + libusb_cancel_transfer(tc->transfer); + while (!tc->completed) + { + if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, to, &tc->completed) < 0) + break; + } + } + + if (tc->transfer) + libusb_free_transfer(tc->transfer); + + free (tc); +} + +/** Configure write buffer chunk size. Default is 4096. @@ -1733,7 +2004,7 @@ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunk /** Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip. - Automatically strips the two modem status bytes transfered during every read. + Automatically strips the two modem status bytes transferred during every read. \param ftdi pointer to ftdi_context \param buf Buffer to store data in @@ -1748,18 +2019,19 @@ 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, i, num_of_chunks, chunk_remains; - int packet_size = ftdi->max_packet_size; + int 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) + packet_size = ftdi->max_packet_size; 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 <= (int)ftdi->readbuffer_remaining) { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size); @@ -2102,9 +2374,11 @@ int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) /** Set flowcontrol for ftdi chip + Note: Do not use this function to enable XON/XOFF mode, use ftdi_setflowctrl_xonxoff() instead. + \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 + SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS \retval 0: all fine \retval -1: set flow control failed @@ -2124,6 +2398,31 @@ int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl) } /** + Set XON/XOFF flowcontrol for ftdi chip + + \param ftdi pointer to ftdi_context + \param xon character code used to resume transmission + \param xoff character code used to pause transmission + + \retval 0: all fine + \retval -1: set flow control failed + \retval -2: USB device unavailable +*/ +int ftdi_setflowctrl_xonxoff(struct ftdi_context *ftdi, unsigned char xon, unsigned char xoff) +{ + if (ftdi == NULL || ftdi->usb_dev == NULL) + ftdi_error_return(-2, "USB device unavailable"); + + uint16_t xonxoff = xon | (xoff << 8); + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, + SIO_SET_FLOW_CTRL_REQUEST, xonxoff, (SIO_XON_XOFF_HS | 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 @@ -2289,8 +2588,8 @@ int ftdi_set_error_char(struct ftdi_context *ftdi, \retval -2: No struct ftdi_eeprom \retval -3: No connected device or device not yet opened */ -int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, - char * product, char * serial) +int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, const char * manufacturer, + const char * product, const char * serial) { struct ftdi_eeprom *eeprom; @@ -2307,7 +2606,7 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, ftdi_error_return(-3, "No connected device or device not yet opened"); eeprom->vendor_id = 0x0403; - eeprom->use_serial = 1; + eeprom->use_serial = (serial != NULL); if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) || (ftdi->type == TYPE_R)) eeprom->product_id = 0x6001; @@ -2315,8 +2614,11 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->product_id = 0x6011; else if (ftdi->type == TYPE_232H) eeprom->product_id = 0x6014; + else if (ftdi->type == TYPE_230X) + eeprom->product_id = 0x6015; else eeprom->product_id = 0x6010; + if (ftdi->type == TYPE_AM) eeprom->usb_version = 0x0101; else @@ -2328,7 +2630,7 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->manufacturer = NULL; if (manufacturer) { - eeprom->manufacturer = malloc(strlen(manufacturer)+1); + eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1); if (eeprom->manufacturer) strcpy(eeprom->manufacturer, manufacturer); } @@ -2338,7 +2640,7 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->product = NULL; if(product) { - eeprom->product = malloc(strlen(product)+1); + eeprom->product = (char *)malloc(strlen(product)+1); if (eeprom->product) strcpy(eeprom->product, product); } @@ -2347,17 +2649,18 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, const char* default_product; switch(ftdi->type) { - case TYPE_AM: default_product = "AM"; break; - case TYPE_BM: default_product = "BM"; break; - case TYPE_2232C: default_product = "Dual RS232"; break; - case TYPE_R: default_product = "FT232R USB UART"; break; - case TYPE_2232H: default_product = "Dual RS232-HS"; break; - case TYPE_4232H: default_product = "FT4232H"; break; - case TYPE_232H: default_product = "Single-RS232-HS"; break; - default: - ftdi_error_return(-3, "Unknown chip type"); + case TYPE_AM: default_product = "AM"; break; + case TYPE_BM: default_product = "BM"; break; + case TYPE_2232C: default_product = "Dual RS232"; break; + case TYPE_R: default_product = "FT232R USB UART"; break; + case TYPE_2232H: default_product = "Dual RS232-HS"; break; + case TYPE_4232H: default_product = "FT4232H"; break; + case TYPE_232H: default_product = "Single-RS232-HS"; break; + case TYPE_230X: default_product = "FT230X Basic UART"; break; + default: + ftdi_error_return(-3, "Unknown chip type"); } - eeprom->product = malloc(strlen(default_product) +1); + eeprom->product = (char *)malloc(strlen(default_product) +1); if (eeprom->product) strcpy(eeprom->product, default_product); } @@ -2367,7 +2670,7 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->serial = NULL; if (serial) { - eeprom->serial = malloc(strlen(serial)+1); + eeprom->serial = (char *)malloc(strlen(serial)+1); if (eeprom->serial) strcpy(eeprom->serial, serial); } @@ -2382,6 +2685,15 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->cbus_function[3] = CBUS_PWREN; eeprom->cbus_function[4] = CBUS_SLEEP; } + else if (ftdi->type == TYPE_230X) + { + eeprom->max_power = 90; + eeprom->size = 0x100; + eeprom->cbus_function[0] = CBUSX_TXDEN; + eeprom->cbus_function[1] = CBUSX_RXLED; + eeprom->cbus_function[2] = CBUSX_TXLED; + eeprom->cbus_function[3] = CBUSX_SLEEP; + } else { if(ftdi->type == TYPE_232H) @@ -2392,14 +2704,147 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, } eeprom->size = -1; } - eeprom->initialized_for_connected_device = 1; + switch (ftdi->type) + { + case TYPE_AM: + eeprom->release_number = 0x0200; + break; + case TYPE_BM: + eeprom->release_number = 0x0400; + break; + case TYPE_2232C: + eeprom->release_number = 0x0500; + break; + case TYPE_R: + eeprom->release_number = 0x0600; + break; + case TYPE_2232H: + eeprom->release_number = 0x0700; + break; + case TYPE_4232H: + eeprom->release_number = 0x0800; + break; + case TYPE_232H: + eeprom->release_number = 0x0900; + break; + case TYPE_230X: + eeprom->release_number = 0x1000; + break; + default: + eeprom->release_number = 0x00; + } + return 0; +} + +int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, const char * manufacturer, + const char * product, const char * serial) +{ + struct ftdi_eeprom *eeprom; + + if (ftdi == NULL) + ftdi_error_return(-1, "No struct ftdi_context"); + + if (ftdi->eeprom == NULL) + ftdi_error_return(-2,"No struct ftdi_eeprom"); + + eeprom = ftdi->eeprom; + + if (ftdi->usb_dev == NULL) + ftdi_error_return(-3, "No connected device or device not yet opened"); + + if (manufacturer) + { + if (eeprom->manufacturer) + free (eeprom->manufacturer); + eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1); + if (eeprom->manufacturer) + strcpy(eeprom->manufacturer, manufacturer); + } + + if(product) + { + if (eeprom->product) + free (eeprom->product); + eeprom->product = (char *)malloc(strlen(product)+1); + if (eeprom->product) + strcpy(eeprom->product, product); + } + + if (serial) + { + if (eeprom->serial) + free (eeprom->serial); + eeprom->serial = (char *)malloc(strlen(serial)+1); + if (eeprom->serial) + { + strcpy(eeprom->serial, serial); + eeprom->use_serial = 1; + } + } + return 0; +} + +/** + Return device ID strings from the eeprom. Device needs to be connected. + + The parameters manufacturer, description and serial may be NULL + or pointer to buffers to store the fetched strings. + + \param ftdi pointer to ftdi_context + \param manufacturer Store manufacturer string here if not NULL + \param mnf_len Buffer size of manufacturer string + \param product Store product description string here if not NULL + \param prod_len Buffer size of product description string + \param serial Store serial string here if not NULL + \param serial_len Buffer size of serial string + + \retval 0: all fine + \retval -1: ftdi context invalid + \retval -2: ftdi eeprom buffer invalid +*/ +int ftdi_eeprom_get_strings(struct ftdi_context *ftdi, + char *manufacturer, int mnf_len, + char *product, int prod_len, + char *serial, int serial_len) +{ + struct ftdi_eeprom *eeprom; + + if (ftdi == NULL) + ftdi_error_return(-1, "No struct ftdi_context"); + if (ftdi->eeprom == NULL) + ftdi_error_return(-2, "No struct ftdi_eeprom"); + + eeprom = ftdi->eeprom; + + if (manufacturer) + { + strncpy(manufacturer, eeprom->manufacturer, mnf_len); + if (mnf_len > 0) + manufacturer[mnf_len - 1] = '\0'; + } + + if (product) + { + strncpy(product, eeprom->product, prod_len); + if (prod_len > 0) + product[prod_len - 1] = '\0'; + } + + if (serial) + { + strncpy(serial, eeprom->serial, serial_len); + if (serial_len > 0) + serial[serial_len - 1] = '\0'; + } + return 0; } -/*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/ + +/*FTD2XX doesn't check for values not fitting in the ACBUS Signal options*/ void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output) { int i; - for(i=0; i<5;i++) + for(i=0; i<5; i++) { int mode_low, mode_high; if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5) @@ -2421,34 +2866,44 @@ static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip) { switch (chip) { - case TYPE_2232H: - case TYPE_2232C: - { - switch (type) + case TYPE_2232H: + case TYPE_2232C: { - case CHANNEL_IS_UART: return 0; - case CHANNEL_IS_FIFO: return 0x01; - case CHANNEL_IS_OPTO: return 0x02; - case CHANNEL_IS_CPU : return 0x04; - default: return 0; + switch (type) + { + case CHANNEL_IS_UART: return 0; + case CHANNEL_IS_FIFO: return 0x01; + case CHANNEL_IS_OPTO: return 0x02; + case CHANNEL_IS_CPU : return 0x04; + default: return 0; + } } - } - case TYPE_232H: - { - switch (type) + case TYPE_232H: { - case CHANNEL_IS_UART : return 0; - case CHANNEL_IS_FIFO : return 0x01; - case CHANNEL_IS_OPTO : return 0x02; - case CHANNEL_IS_CPU : return 0x04; - case CHANNEL_IS_FT1284 : return 0x08; - default: return 0; + switch (type) + { + case CHANNEL_IS_UART : return 0; + case CHANNEL_IS_FIFO : return 0x01; + case CHANNEL_IS_OPTO : return 0x02; + case CHANNEL_IS_CPU : return 0x04; + case CHANNEL_IS_FT1284 : return 0x08; + default: return 0; + } } - } - default: return 0; + case TYPE_R: + { + switch (type) + { + case CHANNEL_IS_UART : return 0; + case CHANNEL_IS_FIFO : return 0x01; + default: return 0; + } + } + case TYPE_230X: /* FT230X is only UART */ + default: return 0; } return 0; -} +} /** Build binary buffer from ftdi_eeprom structure. @@ -2469,7 +2924,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) unsigned char i, j, eeprom_size_mask; unsigned short checksum, value; unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; - int user_area_size; + int user_area_size, free_start, free_end; struct ftdi_eeprom *eeprom; unsigned char * output; @@ -2484,10 +2939,13 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) if (eeprom->chip == -1) ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown"); - if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) - eeprom->size = 0x100; - else - eeprom->size = 0x80; + if (eeprom->size == -1) + { + if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) + eeprom->size = 0x100; + else + eeprom->size = 0x80; + } if (eeprom->manufacturer != NULL) manufacturer_size = strlen(eeprom->manufacturer); @@ -2501,12 +2959,13 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) { case TYPE_AM: case TYPE_BM: + case TYPE_R: user_area_size = 96; // base size for strings (total of 48 characters) break; case TYPE_2232C: user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff break; - case TYPE_R: + case TYPE_230X: user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff break; case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff @@ -2526,7 +2985,17 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) ftdi_error_return(-1,"eeprom size exceeded"); // empty eeprom - memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE); + if (ftdi->type == TYPE_230X) + { + /* FT230X have a reserved section in the middle of the MTP, + which cannot be written to, but must be included in the checksum */ + memset(ftdi->eeprom->buf, 0, 0x80); + memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0)); + } + else + { + memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE); + } // Bytes and Bits set for all Types @@ -2539,33 +3008,8 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x05] = eeprom->product_id >> 8; // Addr 06: Device release number (0400h for BM features) - output[0x06] = 0x00; - 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; - case TYPE_232H: - output[0x07] = 0x09; - break; - default: - output[0x07] = 0x00; - } + output[0x06] = eeprom->release_number; + output[0x07] = eeprom->release_number >> 8; // Addr 08: Config descriptor // Bit 7: always 1 @@ -2573,16 +3017,16 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) // Bit 5: 1 if this device uses remote wakeup // Bit 4-0: reserved - 0 j = 0x80; - if (eeprom->self_powered == 1) + if (eeprom->self_powered) j |= 0x40; - if (eeprom->remote_wakeup == 1) + if (eeprom->remote_wakeup) j |= 0x20; output[0x08] = j; // Addr 09: Max power consumption: max power = value * 2 mA output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT; - if (ftdi->type != TYPE_AM) + if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X)) { // Addr 0A: Chip configuration // Bit 7: 0 - reserved @@ -2595,9 +3039,9 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) // Bit 0: 1 - In EndPoint is Isochronous // j = 0; - if (eeprom->in_is_isochronous == 1) + if (eeprom->in_is_isochronous) j = j | 1; - if (eeprom->out_is_isochronous == 1) + if (eeprom->out_is_isochronous) j = j | 2; output[0x0A] = j; } @@ -2609,21 +3053,28 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) i = 0; switch (ftdi->type) { - case TYPE_232H: - i += 2; case TYPE_2232H: case TYPE_4232H: i += 2; + /* Fall through*/ case TYPE_R: i += 2; + /* Fall through*/ case TYPE_2232C: i += 2; + /* Fall through*/ case TYPE_AM: case TYPE_BM: i += 0x94; + break; + case TYPE_232H: + case TYPE_230X: + i = 0xa0; + break; } /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */ eeprom_size_mask = eeprom->size -1; + free_end = i & eeprom_size_mask; // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string @@ -2650,19 +3101,23 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) } output[0x11] = product_size*2 + 2; - // Addr 12: Offset of the serial string + 0x80, calculated later - // Addr 13: Length of serial string - 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_size_mask] = eeprom->serial[j], i++; - output[i & eeprom_size_mask] = 0x00, i++; + if (eeprom->use_serial) { + // Addr 12: Offset of the serial string + 0x80, calculated later + // Addr 13: Length of serial string + 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_size_mask] = eeprom->serial[j], i++; + output[i & eeprom_size_mask] = 0x00, i++; + } + output[0x13] = serial_size*2 + 2; } // Legacy port name and PnP fields for FT2232 and newer chips - if (ftdi->type > TYPE_BM) + // It doesn't appear when written with FT_Prog for FT4232H chip. + if (ftdi->type > TYPE_BM && ftdi->type != TYPE_4232H) { output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */ i++; @@ -2672,8 +3127,6 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) i++; } - output[0x13] = serial_size*2 + 2; - if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */ { if (eeprom->use_serial) @@ -2691,7 +3144,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) case TYPE_BM: output[0x0C] = eeprom->usb_version & 0xff; output[0x0D] = (eeprom->usb_version>>8) & 0xff; - if (eeprom->use_usb_version == USE_USB_VERSION_BIT) + if (eeprom->use_usb_version) output[0x0A] |= USE_USB_VERSION_BIT; else output[0x0A] &= ~USE_USB_VERSION_BIT; @@ -2700,40 +3153,40 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) case TYPE_2232C: output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C); - if ( eeprom->channel_a_driver == DRIVER_VCP) + if (eeprom->channel_a_driver) output[0x00] |= DRIVER_VCP; else output[0x00] &= ~DRIVER_VCP; - if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE) + if (eeprom->high_current_a) output[0x00] |= HIGH_CURRENT_DRIVE; else output[0x00] &= ~HIGH_CURRENT_DRIVE; output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C); - if ( eeprom->channel_b_driver == DRIVER_VCP) + if (eeprom->channel_b_driver) output[0x01] |= DRIVER_VCP; else output[0x01] &= ~DRIVER_VCP; - if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE) + if (eeprom->high_current_b) output[0x01] |= HIGH_CURRENT_DRIVE; else output[0x01] &= ~HIGH_CURRENT_DRIVE; - if (eeprom->in_is_isochronous == 1) + if (eeprom->in_is_isochronous) output[0x0A] |= 0x1; else output[0x0A] &= ~0x1; - if (eeprom->out_is_isochronous == 1) + if (eeprom->out_is_isochronous) output[0x0A] |= 0x2; else output[0x0A] &= ~0x2; - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; - if (eeprom->use_usb_version == USE_USB_VERSION_BIT) + if (eeprom->use_usb_version) output[0x0A] |= USE_USB_VERSION_BIT; else output[0x0A] &= ~USE_USB_VERSION_BIT; @@ -2743,11 +3196,21 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x14] = eeprom->chip; break; case TYPE_R: - if (eeprom->high_current == HIGH_CURRENT_DRIVE_R) + output[0x00] = type2bit(eeprom->channel_a_type, TYPE_R); + if (eeprom->high_current) output[0x00] |= HIGH_CURRENT_DRIVE_R; + + /* Field is inverted for TYPE_R: Bit 00.3 set to 1 is D2XX, VCP is 0 */ + if (eeprom->channel_a_driver) + output[0x00] &= ~DRIVER_VCP; + else + output[0x00] |= DRIVER_VCP; + + if (eeprom->external_oscillator) + output[0x00] |= 0x02; output[0x01] = 0x40; /* Hard coded Endpoint Size*/ - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; @@ -2755,22 +3218,22 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x0C] = eeprom->usb_version & 0xff; output[0x0D] = (eeprom->usb_version>>8) & 0xff; - if (eeprom->cbus_function[0] > CBUS_BB) + if (eeprom->cbus_function[0] > CBUS_BB_RD) output[0x14] = CBUS_TXLED; else output[0x14] = eeprom->cbus_function[0]; - if (eeprom->cbus_function[1] > CBUS_BB) + if (eeprom->cbus_function[1] > CBUS_BB_RD) output[0x14] |= CBUS_RXLED<<4; else output[0x14] |= eeprom->cbus_function[1]<<4; - if (eeprom->cbus_function[2] > CBUS_BB) + if (eeprom->cbus_function[2] > CBUS_BB_RD) output[0x15] = CBUS_TXDEN; else output[0x15] = eeprom->cbus_function[2]; - if (eeprom->cbus_function[3] > CBUS_BB) + if (eeprom->cbus_function[3] > CBUS_BB_RD) output[0x15] |= CBUS_PWREN<<4; else output[0x15] |= eeprom->cbus_function[3]<<4; @@ -2782,22 +3245,23 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) break; case TYPE_2232H: output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H); - if ( eeprom->channel_a_driver == DRIVER_VCP) + if (eeprom->channel_a_driver) output[0x00] |= DRIVER_VCP; else output[0x00] &= ~DRIVER_VCP; output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H); - if ( eeprom->channel_b_driver == DRIVER_VCP) + if (eeprom->channel_b_driver) output[0x01] |= DRIVER_VCP; else output[0x01] &= ~DRIVER_VCP; - if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT) + + if (eeprom->suspend_dbus7) output[0x01] |= SUSPEND_DBUS7_BIT; else output[0x01] &= ~SUSPEND_DBUS7_BIT; - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; @@ -2806,60 +3270,60 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x0c] |= DRIVE_16MA; else output[0x0c] |= eeprom->group0_drive; - if (eeprom->group0_schmitt == IS_SCHMITT) + if (eeprom->group0_schmitt) output[0x0c] |= IS_SCHMITT; - if (eeprom->group0_slew == SLOW_SLEW) + if (eeprom->group0_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) + if (eeprom->group1_schmitt) output[0x0c] |= IS_SCHMITT<<4; - if (eeprom->group1_slew == SLOW_SLEW) + if (eeprom->group1_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) + if (eeprom->group2_schmitt) output[0x0d] |= IS_SCHMITT; - if (eeprom->group2_slew == SLOW_SLEW) + if (eeprom->group2_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) + if (eeprom->group3_schmitt) output[0x0d] |= IS_SCHMITT<<4; - if (eeprom->group3_slew == SLOW_SLEW) + if (eeprom->group3_slew) output[0x0d] |= SLOW_SLEW<<4; output[0x18] = eeprom->chip; break; case TYPE_4232H: - if (eeprom->channel_a_driver == DRIVER_VCP) + if (eeprom->channel_a_driver) output[0x00] |= DRIVER_VCP; else output[0x00] &= ~DRIVER_VCP; - if (eeprom->channel_b_driver == DRIVER_VCP) + if (eeprom->channel_b_driver) output[0x01] |= DRIVER_VCP; else output[0x01] &= ~DRIVER_VCP; - if (eeprom->channel_c_driver == DRIVER_VCP) + if (eeprom->channel_c_driver) output[0x00] |= (DRIVER_VCP << 4); else output[0x00] &= ~(DRIVER_VCP << 4); - if (eeprom->channel_d_driver == DRIVER_VCP) + if (eeprom->channel_d_driver) output[0x01] |= (DRIVER_VCP << 4); else output[0x01] &= ~(DRIVER_VCP << 4); - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0a] |= 0x4; else output[0x0a] &= ~0x4; @@ -2885,36 +3349,36 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x0c] |= DRIVE_16MA; else output[0x0c] |= eeprom->group0_drive; - if (eeprom->group0_schmitt == IS_SCHMITT) + if (eeprom->group0_schmitt) output[0x0c] |= IS_SCHMITT; - if (eeprom->group0_slew == SLOW_SLEW) + if (eeprom->group0_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) + if (eeprom->group1_schmitt) output[0x0c] |= IS_SCHMITT<<4; - if (eeprom->group1_slew == SLOW_SLEW) + if (eeprom->group1_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) + if (eeprom->group2_schmitt) output[0x0d] |= IS_SCHMITT; - if (eeprom->group2_slew == SLOW_SLEW) + if (eeprom->group2_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) + if (eeprom->group3_schmitt) output[0x0d] |= IS_SCHMITT<<4; - if (eeprom->group3_slew == SLOW_SLEW) + if (eeprom->group3_slew) output[0x0d] |= SLOW_SLEW<<4; output[0x18] = eeprom->chip; @@ -2922,14 +3386,21 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) break; case TYPE_232H: output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H); - if ( eeprom->channel_a_driver == DRIVER_VCP) + if (eeprom->channel_a_driver) output[0x00] |= DRIVER_VCPH; else output[0x00] &= ~DRIVER_VCPH; + if (eeprom->powersave) output[0x01] |= POWER_SAVE_DISABLE_H; else output[0x01] &= ~POWER_SAVE_DISABLE_H; + + if (eeprom->suspend_pull_downs) + output[0x0a] |= 0x4; + else + output[0x0a] &= ~0x4; + if (eeprom->clock_polarity) output[0x01] |= FT1284_CLK_IDLE_STATE; else @@ -2942,30 +3413,77 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x01] |= FT1284_FLOW_CONTROL; else output[0x01] &= ~FT1284_FLOW_CONTROL; + if (eeprom->group0_drive > DRIVE_16MA) output[0x0c] |= DRIVE_16MA; else output[0x0c] |= eeprom->group0_drive; - if (eeprom->group0_schmitt == IS_SCHMITT) + if (eeprom->group0_schmitt) output[0x0c] |= IS_SCHMITT; - if (eeprom->group0_slew == SLOW_SLEW) + if (eeprom->group0_slew) output[0x0c] |= SLOW_SLEW; if (eeprom->group1_drive > DRIVE_16MA) output[0x0d] |= DRIVE_16MA; else output[0x0d] |= eeprom->group1_drive; - if (eeprom->group1_schmitt == IS_SCHMITT) + if (eeprom->group1_schmitt) output[0x0d] |= IS_SCHMITT; - if (eeprom->group1_slew == SLOW_SLEW) + if (eeprom->group1_slew) output[0x0d] |= SLOW_SLEW; set_ft232h_cbus(eeprom, output); output[0x1e] = eeprom->chip; - fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n"); + /* FIXME: Build FT232H specific EEPROM settings */ + break; + case TYPE_230X: + output[0x00] = 0x80; /* Actually, leave the default value */ + /*FIXME: Make DBUS & CBUS Control configurable*/ + output[0x0c] = 0; /* DBUS drive 4mA, CBUS drive 4 mA like factory default */ + for (j = 0; j <= 6; j++) + { + output[0x1a + j] = eeprom->cbus_function[j]; + } + output[0x0b] = eeprom->invert; break; - + } + + /* First address without use */ + free_start = 0; + switch (ftdi->type) + { + case TYPE_230X: + free_start += 2; + /* Fall through*/ + case TYPE_232H: + free_start += 6; + /* Fall through*/ + case TYPE_2232H: + case TYPE_4232H: + free_start += 2; + /* Fall through*/ + case TYPE_R: + free_start += 2; + /* Fall through*/ + case TYPE_2232C: + free_start++; + /* Fall through*/ + case TYPE_AM: + case TYPE_BM: + free_start += 0x14; + } + + /* Arbitrary user data */ + if (eeprom->user_data && eeprom->user_data_size >= 0) + { + if (eeprom->user_data_addr < free_start) + fprintf(stderr,"Warning, user data starts inside the generated data!\n"); + if (eeprom->user_data_addr + eeprom->user_data_size >= free_end) + fprintf(stderr,"Warning, user data overlaps the strings area!\n"); + if (eeprom->user_data_addr + eeprom->user_data_size > eeprom->size) + ftdi_error_return(-1,"eeprom size exceeded"); + memcpy(output + eeprom->user_data_addr, eeprom->user_data, eeprom->user_data_size); } // calculate checksum @@ -2973,9 +3491,23 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) for (i = 0; i < eeprom->size/2-1; i++) { - value = output[i*2]; - value += output[(i*2)+1] << 8; - + if ((ftdi->type == TYPE_230X) && (i == 0x12)) + { + /* FT230X has a user section in the MTP which is not part of the checksum */ + i = 0x40; + } + if ((ftdi->type == TYPE_230X) && (i >= 0x40) && (i < 0x50)) { + uint16_t data; + if (ftdi_read_eeprom_location(ftdi, i, &data)) { + fprintf(stderr, "Reading Factory Configuration Data failed\n"); + i = 0x50; + } + value = data; + } + else { + value = output[i*2]; + value += output[(i*2)+1] << 8; + } checksum = value^checksum; checksum = (checksum << 1) | (checksum >> 15); } @@ -2983,9 +3515,10 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[eeprom->size-2] = checksum; output[eeprom->size-1] = checksum >> 8; + eeprom->initialized_for_connected_device = 1; return user_area_size; } -/* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted +/* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted * EEPROM structure * * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we @@ -2994,20 +3527,37 @@ static unsigned char bit2type(unsigned char bits) { switch (bits) { - case 0: return CHANNEL_IS_UART; - case 1: return CHANNEL_IS_FIFO; - case 2: return CHANNEL_IS_OPTO; - case 4: return CHANNEL_IS_CPU; - case 8: return CHANNEL_IS_FT1284; - default: - fprintf(stderr," Unexpected value %d for Hardware Interface type\n", - bits); + case 0: return CHANNEL_IS_UART; + case 1: return CHANNEL_IS_FIFO; + case 2: return CHANNEL_IS_OPTO; + case 4: return CHANNEL_IS_CPU; + case 8: return CHANNEL_IS_FT1284; + default: + fprintf(stderr," Unexpected value %d for Hardware Interface type\n", + bits); } return 0; } +/* Decode 230X / 232R type chips invert bits + * Prints directly to stdout. +*/ +static void print_inverted_bits(int invert) +{ + const char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"}; + int i; + + fprintf(stdout,"Inverted bits:"); + for (i=0; i<8; i++) + if ((invert & (1<eeprom->buf; - int release; + unsigned char *buf = NULL; if (ftdi == NULL) ftdi_error_return(-1,"No context"); @@ -3034,6 +3583,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom = ftdi->eeprom; eeprom_size = eeprom->size; + buf = ftdi->eeprom->buf; // Addr 02: Vendor ID eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8); @@ -3041,14 +3591,15 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) // Addr 04: Product ID eeprom->product_id = buf[0x04] + (buf[0x05] << 8); - release = buf[0x06] + (buf[0x07]<<8); + // Addr 06: Device release number + eeprom->release_number = 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 - eeprom->self_powered = buf[0x08] & 0x40; - eeprom->remote_wakeup = buf[0x08] & 0x20; + 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 = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09]; @@ -3063,11 +3614,11 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) // Bit 1: 1 - Out EndPoint is Isochronous // Bit 0: 1 - In EndPoint is Isochronous // - 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)?1:0; - eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT; + 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); + eeprom->use_usb_version = !!(buf[0x0A] & USE_USB_VERSION_BIT); // Addr 0C: USB version low byte when 0x0A // Addr 0D: USB version high byte when 0x0A @@ -3080,12 +3631,12 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) free(eeprom->manufacturer); if (manufacturer_size > 0) { - eeprom->manufacturer = malloc(manufacturer_size); + eeprom->manufacturer = (char *)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]; } @@ -3101,12 +3652,12 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) product_size = buf[0x11]/2; if (product_size > 0) { - eeprom->product = malloc(product_size); + eeprom->product = (char *)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]; } @@ -3122,12 +3673,12 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) serial_size = buf[0x13]/2; if (serial_size > 0) { - eeprom->serial = malloc(serial_size); + eeprom->serial = (char *)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]; } @@ -3141,6 +3692,11 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) for (i = 0; i < eeprom_size/2-1; i++) { + if ((ftdi->type == TYPE_230X) && (i == 0x12)) + { + /* FT230X has a user section in the MTP which is not part of the checksum */ + i = 0x40; + } value = buf[i*2]; value += buf[(i*2)+1] << 8; @@ -3164,18 +3720,19 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) else if (ftdi->type == TYPE_2232C) { eeprom->channel_a_type = bit2type(buf[0x00] & 0x7); - eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; - eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE; + 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->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; + /* TYPE_R flags D2XX, not VCP as all others */ + eeprom->channel_a_driver = !(buf[0x00] & DRIVER_VCP); /* note: inverted flag, use a single NOT */ + eeprom->high_current = !!(buf[0x00] & HIGH_CURRENT_DRIVE_R); + eeprom->external_oscillator = !!(buf[0x00] & 0x02); if ( (buf[0x01]&0x40) != 0x40) fprintf(stderr, "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size." @@ -3186,7 +3743,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom->chip = buf[0x16]; // Addr 0B: Invert data lines // Works only on FT232R, not FT245R, but no way to distinguish - eeprom->invert = buf[0x0B]; + eeprom->invert = buf[0x0B]; /* note: not a bitflag */ // Addr 14: CBUS function: CBUS0, CBUS1 // Addr 15: CBUS function: CBUS2, CBUS3 // Addr 16: CBUS function: CBUS5 @@ -3198,55 +3755,53 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) } else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H)) { - eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; - eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP; + eeprom->channel_a_driver = !!(buf[0x00] & DRIVER_VCP); + eeprom->channel_b_driver = !!(buf[0x01] & DRIVER_VCP); if (ftdi->type == TYPE_2232H) { eeprom->channel_a_type = bit2type(buf[0x00] & 0x7); eeprom->channel_b_type = bit2type(buf[0x01] & 0x7); - eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT; + eeprom->suspend_dbus7 = !!(buf[0x01] & SUSPEND_DBUS7_BIT); } else { - eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP; - eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP; - eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0); - eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1); - eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2); - eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3); + eeprom->channel_c_driver = !!((buf[0x00] >> 4) & DRIVER_VCP); + eeprom->channel_d_driver = !!((buf[0x01] >> 4) & DRIVER_VCP); + eeprom->channel_a_rs485enable = !!(buf[0x0b] & (CHANNEL_IS_RS485 << 0)); + eeprom->channel_b_rs485enable = !!(buf[0x0b] & (CHANNEL_IS_RS485 << 1)); + eeprom->channel_c_rs485enable = !!(buf[0x0b] & (CHANNEL_IS_RS485 << 2)); + eeprom->channel_d_rs485enable = !!(buf[0x0b] & (CHANNEL_IS_RS485 << 3)); } 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; + eeprom->group0_drive = buf[0x0c] & DRIVE_16MA; /* not a bitflag */ + eeprom->group0_schmitt = !!(buf[0x0c] & IS_SCHMITT); + eeprom->group0_slew = !!(buf[0x0c] & SLOW_SLEW); + eeprom->group1_drive = (buf[0x0c] >> 4) & DRIVE_16MA; /* not a bitflag */ + eeprom->group1_schmitt = !!((buf[0x0c] >> 4) & IS_SCHMITT); + eeprom->group1_slew = !!((buf[0x0c] >> 4) & SLOW_SLEW); + eeprom->group2_drive = buf[0x0d] & DRIVE_16MA; /* not a bitflag */ + eeprom->group2_schmitt = !!(buf[0x0d] & IS_SCHMITT); + eeprom->group2_slew = !!(buf[0x0d] & SLOW_SLEW); + eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA; /* not a bitflag */ + eeprom->group3_schmitt = !!((buf[0x0d] >> 4) & IS_SCHMITT); + eeprom->group3_slew = !!((buf[0x0d] >> 4) & SLOW_SLEW); } else if (ftdi->type == TYPE_232H) { - int i; - eeprom->channel_a_type = buf[0x00] & 0xf; - eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0; - eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE; - eeprom->data_order = buf[0x01] & FT1284_DATA_LSB; - eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL; - eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H; - 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[0x0d] & DRIVE_16MA; - eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT; - eeprom->group1_slew = buf[0x0d] & SLOW_SLEW; + eeprom->channel_a_driver = !!(buf[0x00] & DRIVER_VCPH); + eeprom->clock_polarity = !!(buf[0x01] & FT1284_CLK_IDLE_STATE); + eeprom->data_order = !!(buf[0x01] & FT1284_DATA_LSB); + eeprom->flow_control = !!(buf[0x01] & FT1284_FLOW_CONTROL); + eeprom->powersave = !!(buf[0x01] & POWER_SAVE_DISABLE_H); + eeprom->group0_drive = buf[0x0c] & DRIVE_16MA; /* not a bitflag */ + eeprom->group0_schmitt = !!(buf[0x0c] & IS_SCHMITT); + eeprom->group0_slew = !!(buf[0x0c] & SLOW_SLEW); + eeprom->group1_drive = buf[0x0d] & DRIVE_16MA; /* not a bitflag */ + eeprom->group1_schmitt = !!(buf[0x0d] & IS_SCHMITT); + eeprom->group1_slew = !!(buf[0x0d] & SLOW_SLEW); for(i=0; i<5; i++) { @@ -3256,13 +3811,28 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom->chip = buf[0x1e]; /*FIXME: Decipher more values*/ } + else if (ftdi->type == TYPE_230X) + { + for(i=0; i<4; i++) + { + eeprom->cbus_function[i] = buf[0x1a + i] & 0xFF; + } + eeprom->group0_drive = buf[0x0c] & DRIVE_16MA; /* not a bitflag */ + eeprom->group0_schmitt = !!(buf[0x0c] & IS_SCHMITT); + eeprom->group0_slew = !!(buf[0x0c] & SLOW_SLEW); + eeprom->group1_drive = (buf[0x0c] >> 4) & DRIVE_16MA; /* not a bitflag */ + eeprom->group1_schmitt = !!((buf[0x0c] >> 4) & IS_SCHMITT); + eeprom->group1_slew = !!((buf[0x0c] >> 4) & SLOW_SLEW); + + eeprom->invert = buf[0xb]; /* not a bitflag */ + } if (verbose) { - char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"}; + const char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"}; 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); + fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number); if (eeprom->self_powered) fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n"); @@ -3276,8 +3846,10 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) if (eeprom->serial) fprintf(stdout, "Serial: %s\n",eeprom->serial); fprintf(stdout, "Checksum : %04x\n", checksum); - if (ftdi->type == TYPE_R) + if (ftdi->type == TYPE_R) { fprintf(stdout, "Internal EEPROM\n"); + fprintf(stdout,"Oscillator: %s\n", eeprom->external_oscillator?"External":"Internal"); + } else if (eeprom->chip >= 0x46) fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip); if (eeprom->suspend_dbus7) @@ -3288,7 +3860,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { if(ftdi->type >= TYPE_232H) fprintf(stdout,"Enter low power state on ACBUS7\n"); - } + } if (eeprom->remote_wakeup) fprintf(stdout, "Enable Remote Wake Up\n"); fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1); @@ -3297,20 +3869,20 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) channel_mode[eeprom->channel_a_type], (eeprom->channel_a_driver)?" VCP":"", (eeprom->high_current_a)?" High Current IO":""); - if (ftdi->type >= TYPE_232H) + if (ftdi->type == TYPE_232H) { fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n", (eeprom->clock_polarity)?"HIGH":"LOW", (eeprom->data_order)?"LSB":"MSB", (eeprom->flow_control)?"":"No "); - } - if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H)) + } + if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H)) 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_BM) || (ftdi->type == TYPE_2232C)) && - eeprom->use_usb_version == USE_USB_VERSION_BIT) + eeprom->use_usb_version) fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version); if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H)) @@ -3338,11 +3910,10 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) } else if (ftdi->type == TYPE_232H) { - int i; - char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN", - "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", - "CLK30","CLK15","CLK7_5" - }; + const char *cbush_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN", + "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", + "CLK30","CLK15","CLK7_5" + }; fprintf(stdout,"ACBUS has %d mA drive%s%s\n", (eeprom->group0_drive+1) *4, (eeprom->group0_schmitt)?" Schmitt Input":"", @@ -3358,27 +3929,46 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) cbush_mux[eeprom->cbus_function[i]]); } } + else if (ftdi->type == TYPE_230X) + { + const char *cbusx_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN", + "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", + "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#", + "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#", + "BBRD#", "TIME_STAMP", "AWAKE#", + }; + fprintf(stdout,"DBUS has %d mA drive%s%s\n", + (eeprom->group0_drive+1) *4, + (eeprom->group0_schmitt)?" Schmitt Input":"", + (eeprom->group0_slew)?" Slow Slew":""); + fprintf(stdout,"CBUS has %d mA drive%s%s\n", + (eeprom->group1_drive+1) *4, + (eeprom->group1_schmitt)?" Schmitt Input":"", + (eeprom->group1_slew)?" Slow Slew":""); + for (i=0; i<4; i++) + { + if (eeprom->cbus_function[i]<= CBUSX_AWAKE) + fprintf(stdout,"CBUS%d Function: %s\n", i, cbusx_mux[eeprom->cbus_function[i]]); + } + + if (eeprom->invert) + print_inverted_bits(eeprom->invert); + } if (ftdi->type == TYPE_R) { - char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED", + const 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"}; + const char *cbus_BB[] = {"RXF","TXE","RD", "WR"}; 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<invert); + for (i=0; i<5; i++) { - if (eeprom->cbus_function[i]cbus_function[i]<=CBUS_BB_RD) fprintf(stdout,"C%d Function: %s\n", i, cbus_mux[eeprom->cbus_function[i]]); else @@ -3417,6 +4007,9 @@ int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case PRODUCT_ID: *value = ftdi->eeprom->product_id; break; + case RELEASE_NUMBER: + *value = ftdi->eeprom->release_number; + break; case SELF_POWERED: *value = ftdi->eeprom->self_powered; break; @@ -3508,7 +4101,7 @@ int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu *value = ftdi->eeprom->cbus_function[8]; break; case CBUS_FUNCTION_9: - *value = ftdi->eeprom->cbus_function[8]; + *value = ftdi->eeprom->cbus_function[9]; break; case HIGH_CURRENT: *value = ftdi->eeprom->high_current; @@ -3558,24 +4151,27 @@ int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case GROUP3_SLEW: *value = ftdi->eeprom->group3_slew; break; - case POWER_SAVE: + case POWER_SAVE: *value = ftdi->eeprom->powersave; break; - case CLOCK_POLARITY: + case CLOCK_POLARITY: *value = ftdi->eeprom->clock_polarity; break; - case DATA_ORDER: + case DATA_ORDER: *value = ftdi->eeprom->data_order; break; - case FLOW_CONTROL: + case FLOW_CONTROL: *value = ftdi->eeprom->flow_control; break; - case CHIP_TYPE: + case CHIP_TYPE: *value = ftdi->eeprom->chip; break; case CHIP_SIZE: *value = ftdi->eeprom->size; break; + case EXTERNAL_OSCILLATOR: + *value = ftdi->eeprom->external_oscillator; + break; default: ftdi_error_return(-1, "Request for unknown EEPROM value"); } @@ -3604,6 +4200,9 @@ int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case PRODUCT_ID: ftdi->eeprom->product_id = value; break; + case RELEASE_NUMBER: + ftdi->eeprom->release_number = value; + break; case SELF_POWERED: ftdi->eeprom->self_powered = value; break; @@ -3748,23 +4347,32 @@ int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case CHIP_TYPE: ftdi->eeprom->chip = value; break; - case POWER_SAVE: + case POWER_SAVE: ftdi->eeprom->powersave = value; break; - case CLOCK_POLARITY: + case CLOCK_POLARITY: ftdi->eeprom->clock_polarity = value; break; - case DATA_ORDER: + case DATA_ORDER: ftdi->eeprom->data_order = value; break; - case FLOW_CONTROL: + case FLOW_CONTROL: ftdi->eeprom->flow_control = value; break; case CHIP_SIZE: ftdi_error_return(-2, "EEPROM Value can't be changed"); + break; + case EXTERNAL_OSCILLATOR: + ftdi->eeprom->external_oscillator = value; + break; + case USER_DATA_ADDR: + ftdi->eeprom->user_data_addr = value; + break; + default : ftdi_error_return(-1, "Request to unknown EEPROM value"); } + ftdi->eeprom->initialized_for_connected_device = 0; return 0; } @@ -3802,7 +4410,7 @@ int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size \param size Size of buffer \retval 0: All fine - \retval -1: struct ftdi_contxt or ftdi_eeprom of buf missing + \retval -1: struct ftdi_context or ftdi_eeprom or buf missing */ int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size) { @@ -3818,6 +4426,25 @@ int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, in return 0; } +/** Set the EEPROM user data content from the user-supplied prefilled buffer + + \param ftdi pointer to ftdi_context + \param buf buffer to read EEPROM user data content + \param size Size of buffer + + \retval 0: All fine + \retval -1: struct ftdi_context or ftdi_eeprom or buf missing +*/ +int ftdi_set_eeprom_user_data(struct ftdi_context *ftdi, const char * buf, int size) +{ + if (!ftdi || !(ftdi->eeprom) || !buf) + ftdi_error_return(-1, "No appropriate structure"); + + ftdi->eeprom->user_data_size = size; + ftdi->eeprom->user_data = buf; + return 0; +} + /** Read eeprom location @@ -3831,12 +4458,16 @@ int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, in */ int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val) { + unsigned char buf[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) + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, buf, 2, ftdi->usb_read_timeout) != 2) ftdi_error_return(-1, "reading eeprom failed"); + *eeprom_val = (0xff & buf[0]) | (buf[1] << 8); + return 0; } @@ -3977,7 +4608,7 @@ int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, } if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type)) - ftdi_error_return(-5, "Reading failed failed"); + ftdi_error_return(-5, "Reading failed"); fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type); if ((chip_type & 0xff) != 0x66) { @@ -4026,6 +4657,11 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi) for (i = 0; i < ftdi->eeprom->size/2; i++) { + /* Do not try to write to reserved area */ + if ((ftdi->type == TYPE_230X) && (i == 0x40)) + { + i = 0x50; + } usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, @@ -4058,7 +4694,7 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) if (ftdi == NULL || ftdi->usb_dev == NULL) ftdi_error_return(-2, "USB device unavailable"); - if (ftdi->type == TYPE_R) + if ((ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X)) { ftdi->eeprom->chip = 0; return 0; @@ -4078,7 +4714,7 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) 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"); + ftdi_error_return(-4, "Reading failed"); if (eeprom_value == MAGIC) { ftdi->eeprom->chip = 0x46; @@ -4086,13 +4722,13 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) else { if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value)) - ftdi_error_return(-4, "Reading failed failed"); + ftdi_error_return(-4, "Reading 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"); + ftdi_error_return(-4, "Reading failed"); if (eeprom_value == MAGIC) ftdi->eeprom->chip = 0x66; else @@ -4114,7 +4750,7 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) \retval Pointer to error string */ -char *ftdi_get_error_string (struct ftdi_context *ftdi) +const char *ftdi_get_error_string (struct ftdi_context *ftdi) { if (ftdi == NULL) return "";