X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=3feb9b622d65b2dca5e77f00a78ff89114bc5a21;hp=8b9dd05f8091949fff8b89d5b342a1ae400aa2b3;hb=4e79ea5f1383b431a1361e201b0860e7c4d09af1;hpb=d2f10023a9c05f9d4a07f612b808084760350788 diff --git a/src/ftdi.c b/src/ftdi.c index 8b9dd05..3feb9b6 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2,7 +2,7 @@ ftdi.c - description ------------------- begin : Fri Apr 4 2003 - copyright : (C) 2003 by Intra2net AG + copyright : (C) 2003-2008 by Intra2net AG email : opensource@intra2net.com ***************************************************************************/ @@ -14,28 +14,56 @@ * * ***************************************************************************/ +/** + \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/ + + The library is easy to use. Have a look at this short example: + \include simple.c + + More examples can be found in the "examples" directory. +*/ +/** \addtogroup libftdi */ +/* @{ */ + #include #include #include #include "ftdi.h" +/* stuff needed for async write */ +#ifdef LIBFTDI_LINUX_ASYNC_MODE + #include + #include + #include + #include + #include + #include +#endif + #define ftdi_error_return(code, str) do { \ ftdi->error_str = str; \ return code; \ } while(0); -/* ftdi_init +/** + Initializes a ftdi_context. - Initializes a ftdi_context. + \param ftdi pointer to ftdi_context - Return codes: - 0: All fine - -1: Couldn't allocate read buffer + \retval 0: all fine + \retval -1: couldn't allocate read buffer + + \remark This should be called before all functions */ int ftdi_init(struct ftdi_context *ftdi) { + int i; + ftdi->usb_dev = NULL; ftdi->usb_read_timeout = 5000; ftdi->usb_write_timeout = 5000; @@ -57,17 +85,54 @@ int ftdi_init(struct ftdi_context *ftdi) ftdi->error_str = NULL; +#ifdef LIBFTDI_LINUX_ASYNC_MODE + ftdi->async_usb_buffer_size=10; + if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL) + ftdi_error_return(-1, "out of memory for async usb buffer"); + + /* initialize async usb buffer with unused-marker */ + for (i=0; i < ftdi->async_usb_buffer_size; i++) + ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE; +#else + ftdi->async_usb_buffer_size=0; + ftdi->async_usb_buffer = NULL; +#endif + + ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE; + /* All fine. Now allocate the readbuffer */ return ftdi_read_data_set_chunksize(ftdi, 4096); } -/* ftdi_set_interface - - Call after ftdi_init - - Open selected channels on a chip, otherwise use first channel - 0: all fine - -1: unknown interface +/** + Allocate and initialize a new ftdi_context + + \return a pointer to a new ftdi_context, or NULL on failure +*/ +struct ftdi_context *ftdi_new() +{ + struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context)); + + if (ftdi == NULL) { + return NULL; + } + + if (ftdi_init(ftdi) != 0) { + free(ftdi); + return NULL; + } + + return ftdi; +} + +/** + Open selected channels on a chip, otherwise use first channel. + + \param ftdi pointer to ftdi_context + \param interface Interface to use for FT2232C chips. + + \retval 0: all fine + \retval -1: unknown interface */ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) { @@ -88,21 +153,40 @@ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) return 0; } -/* ftdi_deinit +/** + Deinitializes a ftdi_context. - Deinitializes a ftdi_context. + \param ftdi pointer to ftdi_context */ void ftdi_deinit(struct ftdi_context *ftdi) { + if (ftdi->async_usb_buffer != NULL) { + free(ftdi->async_usb_buffer); + ftdi->async_usb_buffer = NULL; + } + if (ftdi->readbuffer != NULL) { free(ftdi->readbuffer); ftdi->readbuffer = NULL; } } -/* ftdi_set_usbdev - - Use an already open device. +/** + Deinitialize and free an ftdi_context. + + \param ftdi pointer to ftdi_context +*/ +void ftdi_free(struct ftdi_context *ftdi) +{ + ftdi_deinit(ftdi); + free(ftdi); +} + +/** + Use an already open libusb device. + + \param ftdi pointer to ftdi_context + \param usb libusb usb_dev_handle to use */ void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) { @@ -110,16 +194,19 @@ void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) } -/* ftdi_usb_find_all - - Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which - needs to be deallocated by ftdi_list_free after use. +/** + Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which + needs to be deallocated by ftdi_list_free() after use. + + \param ftdi pointer to ftdi_context + \param devlist Pointer where to store list of found devices + \param vendor Vendor ID to search for + \param product Product ID to search for - Return codes: - >0: number of devices found - -1: usb_find_busses() failed - -2: usb_find_devices() failed - -3: out of memory + \retval >0: number of devices found + \retval -1: usb_find_busses() failed + \retval -2: usb_find_devices() failed + \retval -3: out of memory */ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product) { @@ -135,7 +222,8 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli ftdi_error_return(-2, "usb_find_devices() failed"); curdev = devlist; - for (bus = usb_busses; bus; bus = bus->next) { + *curdev = NULL; + 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) @@ -156,31 +244,108 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli return count; } -/* ftdi_list_free +/** + Frees a usb device list. - Frees a created device list. + \param devlist USB device list created by ftdi_usb_find_all() */ void ftdi_list_free(struct ftdi_device_list **devlist) { - struct ftdi_device_list **curdev; - for (; *devlist == NULL; devlist = curdev) { - curdev = &(*devlist)->next; - free(*devlist); + struct ftdi_device_list *curdev, *next; + + for (curdev = *devlist; curdev != NULL;) { + next = curdev->next; + free(curdev); + curdev = next; } - devlist = NULL; + *devlist = NULL; } -/* ftdi_usb_open_dev +/** + Frees a usb device list. - Opens a ftdi device given by a usb_device. - - Return codes: - 0: all fine - -4: unable to open device - -5: unable to claim device - -6: reset failed - -7: set baudrate failed + \param devlist USB device list created by ftdi_usb_find_all() +*/ +void ftdi_list_free2(struct ftdi_device_list *devlist) +{ + ftdi_list_free(&devlist); +} + +/** + 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 Use this function only in combination with ftdi_usb_find_all() + as it closes the internal "usb_dev" after use. + + \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 -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) +{ + if ((ftdi==NULL) || (dev==NULL)) + return -1; + + 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); + 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); + 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); + ftdi_error_return(-9, usb_strerror()); + } + } + + if (usb_close (ftdi->usb_dev) != 0) + ftdi_error_return(-10, usb_strerror()); + + return 0; +} + +/** + 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 + \retval -7: set baudrate failed */ int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev) { @@ -189,12 +354,32 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *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 + // set configuration (needed especially for windows) + // tolerate EBUSY: one device with one configuration, but two interfaces + // and libftdi sessions to both interfaces (e.g. FT2232) + if (dev->descriptor.bNumConfigurations > 0 && + usb_set_configuration(ftdi->usb_dev, dev->config[0].bConfigurationValue) && + errno != EBUSY) + { + usb_close (ftdi->usb_dev); + 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!"); + } + } + if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) { usb_close (ftdi->usb_dev); if (detach_errno == EPERM) { @@ -225,40 +410,47 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev) ftdi->type = TYPE_2232C; if (!ftdi->index) ftdi->index = INTERFACE_A; - } + } else if (dev->descriptor.bcdDevice == 0x600) + ftdi->type = TYPE_R; ftdi_error_return(0, "all fine"); } -/* ftdi_usb_open - - Opens the first device with a given vendor and product ids. - - Return codes: - See ftdi_usb_open_desc() -*/ +/** + Opens the first device with a given vendor and product ids. + + \param ftdi pointer to ftdi_context + \param vendor Vendor ID + \param product Product ID + + \retval same as ftdi_usb_open_desc() +*/ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) { return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL); } -/* ftdi_usb_open_desc - - Opens the first device with a given, vendor id, product id, - description and serial. - - Return codes: - 0: all fine - -1: usb_find_busses() failed - -2: usb_find_devices() failed - -3: usb device not found - -4: unable to open device - -5: unable to claim device - -6: reset failed - -7: set baudrate failed - -8: get product description failed - -9: get serial number failed - -10: unable to close device +/** + Opens the first device with a given, vendor id, product id, + description and serial. + + \param ftdi pointer to ftdi_context + \param vendor Vendor ID + \param product Product ID + \param description Description to search for. Use NULL if not needed. + \param serial Serial to search for. Use NULL if not needed. + + \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 */ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, const char* description, const char* serial) @@ -274,7 +466,7 @@ 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 (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) { @@ -316,17 +508,19 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, ftdi_error_return(-3, "device not found"); } -/* ftdi_usb_reset +/** + Resets the ftdi device. + + \param ftdi pointer to ftdi_context - Resets the ftdi device. - - Return codes: - 0: all fine - -1: FTDI reset failed + \retval 0: all fine + \retval -1: FTDI reset failed */ 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, SIO_RESET_REQUEST_TYPE, + 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 @@ -336,43 +530,88 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) return 0; } -/* ftdi_usb_purge_buffers +/** + Clears the read buffer on the chip and the internal read buffer. - Cleans the buffers of the ftdi device. - - Return codes: - 0: all fine - -1: write buffer purge failed - -2: read buffer purge failed + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: read buffer purge failed */ -int ftdi_usb_purge_buffers(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, SIO_RESET_REQUEST_TYPE, + 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 ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) - ftdi_error_return(-2, "FTDI purge of TX buffer failed"); + return 0; +} + +/** + Clears the write buffer on the chip. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: write buffer purge failed +*/ +int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) +{ + if (usb_control_msg(ftdi->usb_dev, SIO_RESET_REQUEST_TYPE, + 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; +} + +/** + Clears the buffers on the chip and the internal read buffer. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: read buffer purge failed + \retval -2: write buffer purge failed +*/ +int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) +{ + int result; + + result = ftdi_usb_purge_rx_buffer(ftdi); + if (result < 0) + return -1; + + result = ftdi_usb_purge_tx_buffer(ftdi); + if (result < 0) + return -2; return 0; } -/* ftdi_usb_close - - Closes the ftdi device. - - Return codes: - 0: all fine - -1: usb_release failed - -2: usb_close failed +/** + Closes the ftdi device. Call ftdi_deinit() if you're cleaning up. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: usb_release failed + \retval -2: usb_close failed */ int ftdi_usb_close(struct ftdi_context *ftdi) { int rtn = 0; +#ifdef LIBFTDI_LINUX_ASYNC_MODE + /* try to release some kernel resources */ + ftdi_async_complete(ftdi,1); +#endif + if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0) rtn = -1; @@ -382,10 +621,10 @@ int ftdi_usb_close(struct ftdi_context *ftdi) return rtn; } - /* ftdi_convert_baudrate returns nearest supported baud rate to that requested. Function is only used internally + \internal */ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, unsigned short *value, unsigned short *index) @@ -484,15 +723,15 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, return best_baud; } -/* - ftdi_set_baudrate - - Sets the chip baudrate - - Return codes: - 0: all fine - -1: invalid baudrate - -2: setting baudrate failed +/** + Sets the chip baud rate + + \param ftdi pointer to ftdi_context + \param baudrate baud rate to set + + \retval 0: all fine + \retval -1: invalid baudrate + \retval -2: setting baudrate failed */ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) { @@ -514,25 +753,50 @@ 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, SIO_SET_BAUDRATE_REQUEST_TYPE, + SIO_SET_BAUDRATE_REQUEST, value, + index, NULL, 0, ftdi->usb_write_timeout) != 0) ftdi_error_return (-2, "Setting new baudrate failed"); ftdi->baudrate = baudrate; return 0; } -/* - ftdi_set_line_property +/** + 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 + \param sbit Number of stop bits + \param parity Parity mode - set (RS232) line characteristics by Alain Abbas - - Return codes: - 0: all fine - -1: Setting line property failed + \retval 0: all fine + \retval -1: Setting line property failed */ 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) { @@ -565,12 +829,33 @@ int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, break; } - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + switch(break_type) { + case BREAK_OFF: + value |= (0x00 << 14); + break; + case BREAK_ON: + value |= (0x01 << 14); + break; + } + + if (usb_control_msg(ftdi->usb_dev, SIO_SET_DATA_REQUEST_TYPE, + 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; } +/** + Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip + + \param ftdi pointer to ftdi_context + \param buf Buffer with the data + \param size Size of the buffer + + \retval <0: error code from usb_bulk_write() + \retval >0: number of bytes written +*/ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) { int ret; @@ -594,21 +879,247 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return total_written; } +#ifdef LIBFTDI_LINUX_ASYNC_MODE +/* this is strongly dependent on libusb using the same struct layout. If libusb + changes in some later version this may break horribly (this is for libusb 0.1.12) */ +struct usb_dev_handle { + int fd; + // some other stuff coming here we don't need +}; + +/** + Check for pending async urbs + \internal +*/ +static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi) +{ + struct usbdevfs_urb *urb; + int pending=0; + int 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++; + } + + return pending; +} + +/** + Wait until one or more async URBs are completed by the kernel and mark their + positions in the async-buffer as unused + + \param ftdi pointer to ftdi_context + \param wait_for_more if != 0 wait for more than one write to complete + \param timeout_msec max milliseconds to wait + + \internal +*/ +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) + { + 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; + + /* 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); +} + +/** + Wait until one or more async URBs are completed by the kernel and mark their + positions in the async-buffer as unused. + + \param ftdi pointer to ftdi_context + \param wait_for_more if != 0 wait for more than one write to complete (until write timeout) +*/ +void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more) +{ + _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout); +} + +/** + Stupid libusb does not offer async writes nor does it allow + access to its fd - so we need some hacks here. + \internal +*/ +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++) + { + 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; + } + } + + /* 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 */ + + bytesdone += requested; + } while (bytesdone < size); + return bytesdone; +} + +/** + Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip. + Does not wait for completion of the transfer nor does it make sure that + the transfer was successful. + + This function could be extended to use signals and callbacks to inform the + caller of completion or error - but this is not done yet, volunteers welcome. + + Works around libusb and directly accesses functions only available on Linux. + Only available if compiled with --with-async-mode. + + \param ftdi pointer to ftdi_context + \param buf Buffer with the data + \param size Size of the buffer + + \retval <0: error code from usb_bulk_write() + \retval >0: number of bytes written +*/ +int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size) +{ + int ret; + int offset = 0; + int total_written = 0; + + while (offset < size) { + int write_size = ftdi->writebuffer_chunksize; + + if (offset+write_size > size) + write_size = size-offset; + + ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size); + if (ret < 0) + ftdi_error_return(ret, "usb bulk write async failed"); + + total_written += ret; + offset += write_size; + } + + return total_written; +} +#endif // LIBFTDI_LINUX_ASYNC_MODE + +/** + Configure write buffer chunk size. + Default is 4096. + + \param ftdi pointer to ftdi_context + \param chunksize Chunk size + \retval 0: all fine +*/ int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) { ftdi->writebuffer_chunksize = chunksize; return 0; } +/** + Get write buffer chunk size. + \param ftdi pointer to ftdi_context + \param chunksize Pointer to store chunk size in + + \retval 0: all fine +*/ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { *chunksize = ftdi->writebuffer_chunksize; return 0; } +/** + Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip. + + Automatically strips the two modem status bytes transfered during every read. + \param ftdi pointer to ftdi_context + \param buf Buffer to store data in + \param size Size of the buffer + + \retval <0: error code from usb_bulk_read() + \retval 0: no data was available + \retval >0: number of bytes read + + \remark This function is not useful in bitbang mode. + Use ftdi_read_pins() to get the current state of the pins. +*/ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) { int offset = 0, ret = 1, i, num_of_chunks, chunk_remains; @@ -700,7 +1211,17 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return -127; } +/** + Configure read buffer chunk size. + Default is 4096. + Automatically reallocates the buffer. + + \param ftdi pointer to ftdi_context + \param chunksize Chunk size + + \retval 0: all fine +*/ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) { unsigned char *new_buf; @@ -718,7 +1239,14 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi return 0; } +/** + Get read buffer chunk size. + \param ftdi pointer to ftdi_context + \param chunksize Pointer to store chunk size in + + \retval 0: all fine +*/ int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { *chunksize = ftdi->readbuffer_chunksize; @@ -726,7 +1254,18 @@ int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunks } +/** + Enable bitbang mode. + + For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode(). + \param ftdi pointer to ftdi_context + \param bitmask Bitmask to configure lines. + HIGH/ON value configures a line as output. + + \retval 0: all fine + \retval -1: can't enable bitbang mode +*/ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) { unsigned short usb_val; @@ -742,7 +1281,14 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) return 0; } +/** + Disable bitbang mode. + + \param ftdi pointer to ftdi_context + \retval 0: all fine + \retval -1: can't disable bitbang mode +*/ 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) @@ -752,7 +1298,17 @@ int ftdi_disable_bitbang(struct ftdi_context *ftdi) return 0; } +/** + Enable advanced bitbang mode for FT2232C chips. + + \param ftdi pointer to ftdi_context + \param bitmask Bitmask to configure lines. + HIGH/ON value configures a line as output. + \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode + \retval 0: all fine + \retval -1: can't enable bitbang mode +*/ int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode) { unsigned short usb_val; @@ -767,17 +1323,37 @@ int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned return 0; } +/** + Directly read pin state. Useful for bitbang mode. + + \param ftdi pointer to ftdi_context + \param pins Pointer to store pins into + + \retval 0: all fine + \retval -1: read pins failed +*/ int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) { - unsigned short usb_val; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) + if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1) ftdi_error_return(-1, "read pins failed"); - *pins = (unsigned char)usb_val; return 0; } +/** + Set latency timer + The FTDI chip keeps data in the internal buffer for a specific + amount of time if the buffer is not full yet to decrease + load on the usb bus. + + \param ftdi pointer to ftdi_context + \param latency Value between 1 and 255 + + \retval 0: all fine + \retval -1: latency out of range + \retval -2: unable to set latency timer +*/ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) { unsigned short usb_val; @@ -792,7 +1368,15 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) return 0; } +/** + Get latency timer + \param ftdi pointer to ftdi_context + \param latency Pointer to store latency value in + + \retval 0: all fine + \retval -1: unable to get latency timer +*/ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) { unsigned short usb_val; @@ -803,7 +1387,230 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) return 0; } +/** + Poll modem status information + + This function allows the retrieve the two status bytes of the device. + The device sends these bytes also as a header for each read access + where they are discarded by ftdi_read_data(). The chip generates + the two stripped status bytes in the absence of data every 40 ms. + + Layout of the first byte: + - B0..B3 - must be 0 + - B4 Clear to send (CTS) + 0 = inactive + 1 = active + - B5 Data set ready (DTS) + 0 = inactive + 1 = active + - B6 Ring indicator (RI) + 0 = inactive + 1 = active + - B7 Receive line signal detect (RLSD) + 0 = inactive + 1 = active + + Layout of the second byte: + - B0 Data ready (DR) + - B1 Overrun error (OE) + - B2 Parity error (PE) + - B3 Framing error (FE) + - B4 Break interrupt (BI) + - B5 Transmitter holding register (THRE) + - B6 Transmitter empty (TEMT) + - B7 Error in RCVR FIFO + + \param ftdi pointer to ftdi_context + \param status Pointer to store status information in. Must be two bytes. + + \retval 0: all fine + \retval -1: unable to retrieve status information +*/ +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) + ftdi_error_return(-1, "getting modem status failed"); + + *status = (usb_val[1] << 8) | usb_val[0]; + + return 0; +} + +/** + 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->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, SIO_SET_MODEM_CTRL_REQUEST_TYPE, + 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, SIO_SET_MODEM_CTRL_REQUEST_TYPE, + 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, SIO_SET_MODEM_CTRL_REQUEST_TYPE, + 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 + \param eventch Event character + \param enable 0 to disable the event character, non-zero otherwise + + \retval 0: all fine + \retval -1: unable to set event character +*/ +int ftdi_set_event_char(struct ftdi_context *ftdi, + unsigned char eventch, unsigned char enable) +{ + unsigned short usb_val; + + usb_val = eventch; + 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) + ftdi_error_return(-1, "setting event character failed"); + + return 0; +} + +/** + Set error character + + \param ftdi pointer to ftdi_context + \param errorch Error character + \param enable 0 to disable the error character, non-zero otherwise + + \retval 0: all fine + \retval -1: unable to set error character +*/ +int ftdi_set_error_char(struct ftdi_context *ftdi, + unsigned char errorch, unsigned char enable) +{ + unsigned short usb_val; + + usb_val = errorch; + 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) + ftdi_error_return(-1, "setting error character failed"); + + return 0; +} + +/** + Set the eeprom size + + \param ftdi pointer to ftdi_context + \param eeprom Pointer to ftdi_eeprom + \param size +*/ +void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size) +{ + ftdi->eeprom_size=size; + eeprom->size=size; +} + +/** + Init eeprom with default values. + + \param eeprom Pointer to ftdi_eeprom +*/ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) { eeprom->vendor_id = 0x0403; @@ -825,18 +1632,19 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) eeprom->manufacturer = NULL; eeprom->product = NULL; eeprom->serial = NULL; + + eeprom->size = FTDI_DEFAULT_EEPROM_SIZE; } +/** + Build binary output from ftdi_eeprom structure. + Output is suitable for ftdi_write_eeprom(). -/* - ftdi_eeprom_build - - Build binary output from ftdi_eeprom structure. - Output is suitable for ftdi_write_eeprom. - - Return codes: - positive value: used eeprom size - -1: eeprom size (128 bytes) exceeded by custom strings + \param eeprom Pointer to ftdi_eeprom + \param output Buffer of 128 bytes to store eeprom image to + + \retval >0: used eeprom size + \retval -1: eeprom size (128 bytes) exceeded by custom strings */ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) { @@ -852,8 +1660,14 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) if (eeprom->serial != NULL) serial_size = strlen(eeprom->serial); - size_check = 128; // eeprom is 128 bytes + 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; @@ -863,7 +1677,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) return (-1); // empty eeprom - memset (output, 0, 128); + memset (output, 0, eeprom->size); // Addr 00: Stay 00 00 // Addr 02: Vendor ID @@ -883,19 +1697,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 @@ -931,9 +1745,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) } - // Addr 0E: Offset of the manufacturer string + 0x80 - output[0x0E] = 0x14 + 0x80; - + // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string output[0x0F] = manufacturer_size*2 + 2; @@ -946,19 +1758,21 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x13] = serial_size*2 + 2; // Dynamic content - output[0x14] = manufacturer_size*2 + 2; - output[0x15] = 0x03; // type: string + i=0x14; + if(eeprom->size>=256) i = 0x80; - i = 0x16, j = 0; - // 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++) { output[i] = eeprom->manufacturer[j], i++; output[i] = 0x00, i++; } // Output product name - output[0x10] = i + 0x80; // calculate offset + output[0x10] = i | 0x80; // calculate offset output[i] = product_size*2 + 2, i++; output[i] = 0x03, i++; for (j = 0; j < product_size; j++) { @@ -967,7 +1781,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) } // Output serial - output[0x12] = i + 0x80; // calculate offset + output[0x12] = i | 0x80; // calculate offset output[i] = serial_size*2 + 2, i++; output[i] = 0x03, i++; for (j = 0; j < serial_size; j++) { @@ -978,7 +1792,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // calculate checksum checksum = 0xAAAA; - for (i = 0; i < 63; i++) { + for (i = 0; i < eeprom->size/2-1; i++) { value = output[i*2]; value += output[(i*2)+1] << 8; @@ -986,18 +1800,26 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) checksum = (checksum << 1) | (checksum >> 15); } - output[0x7E] = checksum; - output[0x7F] = checksum >> 8; + output[eeprom->size-2] = checksum; + output[eeprom->size-1] = checksum >> 8; return size_check; } +/** + Read eeprom + \param ftdi pointer to ftdi_context + \param eeprom Pointer to store eeprom into + + \retval 0: all fine + \retval -1: read failed +*/ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) { int i; - for (i = 0; i < 64; 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) ftdi_error_return(-1, "reading eeprom failed"); } @@ -1005,13 +1827,95 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) return 0; } +/* + ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID + Function is only used internally + \internal +*/ +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); +} + +/** + Read the FTDIChip-ID from R-type devices + + \param ftdi pointer to ftdi_context + \param chipid Pointer to store FTDIChip-ID + + \retval 0: all fine + \retval -1: read failed +*/ +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) + { + a = a << 8 | a >> 8; + if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2) + { + b = b << 8 | b >> 8; + a = (a << 16) | b; + 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; + return 0; + } + } + + ftdi_error_return(-1, "read of FTDIChip-ID failed"); +} + +/** + Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom + Call this function then do a write then call again to see if size changes, if so write again. + + \param ftdi pointer to ftdi_context + \param eeprom Pointer to store eeprom into + \param maxsize the size of the buffer to read into + + \retval size of eeprom +*/ +int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize) +{ + int i=0,j,minsize=32; + int size=minsize; + + do{ + for (j = 0; i < maxsize/2 && jusb_dev, 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); + + return size/2; +} + +/** + Write eeprom + \param ftdi pointer to ftdi_context + \param eeprom Pointer to read eeprom from + + \retval 0: all fine + \retval -1: read failed +*/ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) { unsigned short usb_val; int i; - for (i = 0; i < 64; i++) { + for (i = 0; i < ftdi->eeprom_size/2; i++) { usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) @@ -1021,7 +1925,14 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) return 0; } +/** + Erase eeprom + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: erase failed +*/ 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) @@ -1030,53 +1941,16 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) return 0; } +/** + Get string representation for last error code + + \param ftdi pointer to ftdi_context + \retval Pointer to error string +*/ char *ftdi_get_error_string (struct ftdi_context *ftdi) { return ftdi->error_str; } - -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; -} - -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; -} - -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 */