X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=4b53ac310828cc4dc6e4ba4ebfe0171f4e029247;hp=b94b731ff2f1d5cc0514d086649d61e9e709be45;hb=4c9e381219d807ff74556eb35cae1c90986242bc;hpb=5cd68e239fa178a5d3c9c50763aa97bc1e4c2150 diff --git a/src/ftdi.c b/src/ftdi.c index b94b731..4b53ac3 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -14,14 +14,42 @@ * * ***************************************************************************/ +/** + \mainpage libftdi API documentation + + Library to talk to FTDI chips. You find the latest versions of libftdi at + http://www.intra2net.com/de/produkte/opensource/ftdi/ + + 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 #include "ftdi.h" -/* ftdi_init return codes: - 0: all fine - -1: couldn't allocate read buffer +#define ftdi_error_return(code, str) do { \ + ftdi->error_str = str; \ + return code; \ + } while(0); + + +/** + Initializes a ftdi_context. + + \param ftdi pointer to ftdi_context + + \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) { @@ -50,7 +78,39 @@ int ftdi_init(struct ftdi_context *ftdi) return ftdi_read_data_set_chunksize(ftdi, 4096); } +/** + 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) +{ + switch (interface) { + case INTERFACE_ANY: + case INTERFACE_A: + /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */ + break; + case INTERFACE_B: + ftdi->interface = 1; + ftdi->index = INTERFACE_B; + ftdi->in_ep = 0x04; + ftdi->out_ep = 0x83; + break; + default: + ftdi_error_return(-1, "Unknown interface"); + } + return 0; +} + +/** + Deinitializes a ftdi_context. + + \param ftdi pointer to ftdi_context +*/ void ftdi_deinit(struct ftdi_context *ftdi) { if (ftdi->readbuffer != NULL) { @@ -59,138 +119,314 @@ void ftdi_deinit(struct ftdi_context *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) { ftdi->usb_dev = usb; } -/* ftdi_usb_open 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 +/** + 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 + + \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) +{ + struct ftdi_device_list **curdev; + struct usb_bus *bus; + struct usb_device *dev; + int count = 0; + + usb_init(); + if (usb_find_busses() < 0) + ftdi_error_return(-1, "usb_find_busses() failed"); + if (usb_find_devices() < 0) + ftdi_error_return(-2, "usb_find_devices() failed"); + + curdev = devlist; + *curdev = NULL; + for (bus = usb_busses; bus; bus = bus->next) { + for (dev = bus->devices; dev; dev = dev->next) { + if (dev->descriptor.idVendor == vendor + && dev->descriptor.idProduct == product) + { + *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list)); + if (!*curdev) + ftdi_error_return(-3, "out of memory"); + + (*curdev)->next = NULL; + (*curdev)->dev = dev; + + curdev = &(*curdev)->next; + count++; + } + } + } + + return count; +} + +/** + Frees a usb 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, *next; + + for (curdev = *devlist; curdev != NULL;) { + next = curdev->next; + free(curdev); + curdev = next; + } + + *devlist = NULL; +} + +/** + 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 -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) +{ + int detach_errno = 0; + if (!(ftdi->usb_dev = usb_open(dev))) + ftdi_error_return(-4, "usb_open() failed"); + +#ifdef LIBUSB_HAS_GET_DRIVER_NP + // Try to detach ftdi_sio kernel module + // Returns ENODATA if driver is not loaded + if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA) + detach_errno = errno; +#endif + + if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) { + usb_close (ftdi->usb_dev); + if (detach_errno == EPERM) { + ftdi_error_return(-8, "inappropriate permissions on device!"); + } else { + ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!"); + } + } + + if (ftdi_usb_reset (ftdi) != 0) { + usb_close (ftdi->usb_dev); + ftdi_error_return(-6, "ftdi_usb_reset failed"); + } + + if (ftdi_set_baudrate (ftdi, 9600) != 0) { + usb_close (ftdi->usb_dev); + ftdi_error_return(-7, "set baudrate failed"); + } + + // Try to guess chip type + // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0 + if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200 + && dev->descriptor.iSerialNumber == 0)) + ftdi->type = TYPE_BM; + else if (dev->descriptor.bcdDevice == 0x200) + ftdi->type = TYPE_AM; + else if (dev->descriptor.bcdDevice == 0x500) { + 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"); +} + +/** + 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); } +/** + 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) { struct usb_bus *bus; struct usb_device *dev; + char string[256]; usb_init(); - if (usb_find_busses() < 0) { - ftdi->error_str = "usb_find_busses() failed"; - return -1; - } - - if (usb_find_devices() < 0) { - ftdi->error_str = "usb_find_devices() failed"; - return -2; - } + if (usb_find_busses() < 0) + ftdi_error_return(-1, "usb_find_busses() failed"); + if (usb_find_devices() < 0) + ftdi_error_return(-2, "usb_find_devices() failed"); for (bus = usb_busses; bus; bus = bus->next) { for (dev = bus->devices; dev; dev = dev->next) { if (dev->descriptor.idVendor == vendor - && dev->descriptor.idProduct == product) { - if (!(ftdi->usb_dev = usb_open(dev))) { - ftdi->error_str = "usb_open() failed"; - return -4; - } - - char string[256]; + && dev->descriptor.idProduct == product) { + if (!(ftdi->usb_dev = usb_open(dev))) + ftdi_error_return(-4, "usb_open() failed"); + if (description != NULL) { if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) { - ftdi->error_str = "unable to fetch product description\n"; - if (usb_close (ftdi->usb_dev) != 0) - return -10; - return -8; + usb_close (ftdi->usb_dev); + ftdi_error_return(-8, "unable to fetch product description"); } if (strncmp(string, description, sizeof(string)) != 0) { - ftdi->error_str = "product description not matching\n"; if (usb_close (ftdi->usb_dev) != 0) - return -10; + ftdi_error_return(-10, "unable to close device"); continue; } } if (serial != NULL) { if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) { - ftdi->error_str = "unable to fetch serial number\n"; - if (usb_close (ftdi->usb_dev) != 0) - return -10; - return -9; + usb_close (ftdi->usb_dev); + ftdi_error_return(-9, "unable to fetch serial number"); } if (strncmp(string, serial, sizeof(string)) != 0) { - ftdi->error_str = "serial number not matching\n"; if (usb_close (ftdi->usb_dev) != 0) - return -10; + ftdi_error_return(-10, "unable to close device"); continue; } } - if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) { - ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!"; - if (usb_close (ftdi->usb_dev) != 0) - return -10; - return -5; - } - - if (ftdi_usb_reset (ftdi) != 0) { - if (usb_close (ftdi->usb_dev) != 0) - return -10; - return -6; - } - - if (ftdi_set_baudrate (ftdi, 9600) != 0) { - if (usb_close (ftdi->usb_dev) != 0) - return -10; - return -7; - } + if (usb_close (ftdi->usb_dev) != 0) + ftdi_error_return(-10, "unable to close device"); - // Try to guess chip type - // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0 - if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200 - && dev->descriptor.iSerialNumber == 0)) - ftdi->type = TYPE_BM; - else if (dev->descriptor.bcdDevice == 0x200) - ftdi->type = TYPE_AM; - else if (dev->descriptor.bcdDevice == 0x500) - ftdi->type = TYPE_2232C; - - return 0; + return ftdi_usb_open_dev(ftdi, dev); } } } // device not found - return -3; + ftdi_error_return(-3, "device not found"); } +/** + Resets the ftdi device. + \param ftdi pointer to ftdi_context + + \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) { - ftdi->error_str = "FTDI reset failed"; - return -1; - } - - if (usb_reset(ftdi->usb_dev) != 0) { - ftdi->error_str = "USB reset failed"; - return -2; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1,"FTDI reset failed"); + // Invalidate data in the readbuffer ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; @@ -198,29 +434,38 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) return 0; } +/** + Clears the buffers on the chip. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: write buffer purge failed + \retval -2: read buffer purge failed +*/ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) { - if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) { - ftdi->error_str = "FTDI purge of RX buffer failed"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, 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_str = "FTDI purge of TX buffer failed"; - return -1; - } - + 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; } -/* ftdi_usb_close 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) { @@ -235,10 +480,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) @@ -272,7 +517,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, int baud_diff; // Round up to supported divisor value - if (try_divisor < 8) { + if (try_divisor <= 8) { // Round up to minimum supported divisor try_divisor = 8; } else if (ftdi->type != TYPE_AM && try_divisor < 12) { @@ -319,29 +564,33 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14); // Deal with special cases for encoded value if (encoded_divisor == 1) { - encoded_divisor = 0; // 3000000 baud + encoded_divisor = 0; // 3000000 baud } else if (encoded_divisor == 0x4001) { - encoded_divisor = 1; // 2000000 baud (BM only) + encoded_divisor = 1; // 2000000 baud (BM only) } // Split into "value" and "index" values *value = (unsigned short)(encoded_divisor & 0xFFFF); if(ftdi->type == TYPE_2232C) { *index = (unsigned short)(encoded_divisor >> 8); *index &= 0xFF00; - *index |= ftdi->interface; + *index |= ftdi->index; } else *index = (unsigned short)(encoded_divisor >> 16); - + // Return the nearest baud rate return best_baud; } -/* - ftdi_set_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) { @@ -353,35 +602,91 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) } actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index); - if (actual_baudrate <= 0) { - ftdi->error_str = "Silly baudrate <= 0."; - return -1; - } + if (actual_baudrate <= 0) + ftdi_error_return (-1, "Silly baudrate <= 0."); // Check within tolerance (about 5%) if ((actual_baudrate * 2 < baudrate /* Catch overflows */ ) || ((actual_baudrate < baudrate) ? (actual_baudrate * 21 < baudrate * 20) - : (baudrate * 21 < actual_baudrate * 20))) { - ftdi->error_str = "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4"; - return -1; + : (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) + ftdi_error_return (-2, "Setting new baudrate failed"); + + ftdi->baudrate = baudrate; + return 0; +} + +/** + Set (RS232) line characteristics by Alain Abbas + + \param ftdi pointer to ftdi_context + \param bits Number of bits + \param sbit Number of stop bits + \param parity Parity mode + + \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) +{ + unsigned short value = bits; + + switch(parity) { + case NONE: + value |= (0x00 << 8); + break; + case ODD: + value |= (0x01 << 8); + break; + case EVEN: + value |= (0x02 << 8); + break; + case MARK: + value |= (0x03 << 8); + break; + case SPACE: + value |= (0x04 << 8); + break; } - if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) { - ftdi->error_str = "Setting new baudrate failed"; - return -2; + switch(sbit) { + case STOP_BIT_1: + value |= (0x00 << 11); + break; + case STOP_BIT_15: + value |= (0x01 << 11); + break; + case STOP_BIT_2: + value |= (0x02 << 11); + break; } - ftdi->baudrate = baudrate; + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x04, 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; int offset = 0; int total_written = 0; + while (offset < size) { int write_size = ftdi->writebuffer_chunksize; @@ -389,15 +694,125 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) write_size = size-offset; ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout); - if (ret < 0) { - if (ret == -1) - ftdi->error_str = "bulk write failed"; - else - ftdi->error_str = "usb failed"; - return ret; - } + if (ret < 0) + ftdi_error_return(ret, "usb bulk write failed"); + total_written += ret; + offset += write_size; + } + return total_written; +} + +/* these structs are stolen from libusb linux implementation + they are needed to directly access usbfs and offer async + writing */ + +struct usb_iso_packet_desc { + unsigned int length; + unsigned int actual_length; + unsigned int status; +}; + +struct usb_urb { + unsigned char type; + unsigned char endpoint; + int status; + unsigned int flags; + void *buffer; + int buffer_length; + int actual_length; + int start_frame; + int number_of_packets; + int error_count; + unsigned int signr; /* signal to be sent on error, -1 if none should be sent */ + void *usercontext; + struct usb_iso_packet_desc iso_frame_desc[0]; +}; + +/* 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 +}; + +// some defines for direct usb access, taken from libusb +#define MAX_READ_WRITE (16 * 1024) +#define IOCTL_USB_SUBMITURB _IOR('U', 10, struct usb_urb) +#define USB_URB_TYPE_BULK 3 + +/** + Stupid libusb does not offer async writes nor does it allow + access to its fd - so we need some hacks here. +*/ +static int usb_bulk_write_async(usb_dev_handle *dev, int ep, char *bytes, int size) +{ + struct usb_urb urb; + int bytesdone = 0, requested; + struct usb_urb *context; + int ret, waiting; + + do { + fd_set writefds; + + requested = size - bytesdone; + if (requested > MAX_READ_WRITE) + requested = MAX_READ_WRITE; + + urb.type = USB_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; /* don't do isochronous yet */ + urb.usercontext = (void*)1000; /* use something else than libusb... */ + + ret = ioctl(dev->fd, IOCTL_USB_SUBMITURB, &urb); + 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. + + \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->usb_dev, 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; } @@ -405,20 +820,51 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) } +/** + 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; @@ -448,14 +894,8 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) ftdi->readbuffer_offset = 0; /* returns how much received */ ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout); - - if (ret < 0) { - if (ret == -1) - ftdi->error_str = "bulk read failed"; - else - ftdi->error_str = "usb failed"; - return ret; - } + if (ret < 0) + ftdi_error_return(ret, "usb bulk read failed"); if (ret > 2) { // skip FTDI status bytes. @@ -467,7 +907,7 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) ftdi->readbuffer_offset += 2; ret -= 2; - if (ret > 64) { + if (ret > 62) { for (i = 1; i < num_of_chunks; i++) memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i, ftdi->readbuffer+ftdi->readbuffer_offset+64*i, @@ -493,6 +933,8 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) /* Did we read exactly the right amount of bytes? */ if (offset == size) + //printf("read_data exact rem %d offset %d\n", + //ftdi->readbuffer_remaining, offset); return offset; } else { // only copy part of the data or size <= readbuffer_chunksize @@ -514,7 +956,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; @@ -523,10 +975,8 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; - if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) { - ftdi->error_str = "out of memory for readbuffer"; - return -1; - } + if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) + ftdi_error_return(-1, "out of memory for readbuffer"); ftdi->readbuffer = new_buf; ftdi->readbuffer_chunksize = chunksize; @@ -534,7 +984,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; @@ -542,7 +999,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; @@ -551,71 +1019,124 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) /* FT2232C: Set bitbang_mode to 2 to enable SPI */ usb_val |= (ftdi->bitbang_mode << 8); - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) { - ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?"); + ftdi->bitbang_enabled = 1; 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) { - ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?"); ftdi->bitbang_enabled = 0; return 0; } +/** + Enable advanced bitbang mode for FT2232C chips. -int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) + \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; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) { - ftdi->error_str = "Read pins failed"; - return -1; - } - *pins = (unsigned char)usb_val; + usb_val = bitmask; // low byte: bitmask + usb_val |= (mode << 8); + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?"); + + ftdi->bitbang_mode = mode; + ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0; + 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) +{ + 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"); + 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; - if (latency < 1) { - ftdi->error_str = "Latency out of range. Only valid for 1-255"; - return -1; - } + if (latency < 1) + ftdi_error_return(-1, "latency out of range. Only valid for 1-255"); usb_val = latency; - if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) { - ftdi->error_str = "Unable to set latency timer"; - return -2; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-2, "unable to set latency timer"); + 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; - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) { - ftdi->error_str = "Reading latency timer failed"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) + ftdi_error_return(-1, "reading latency timer failed"); *latency = (unsigned char)usb_val; return 0; } +/** + Init eeprom with default values. + \param eeprom Pointer to ftdi_eeprom +*/ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) { eeprom->vendor_id = 0x0403; @@ -639,11 +1160,15 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) eeprom->serial = NULL; } +/** + Build binary output from ftdi_eeprom structure. + Output is suitable for ftdi_write_eeprom(). -/* - ftdi_eeprom_build 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) { @@ -799,22 +1324,83 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) 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++) { - if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) { - ftdi->error_str = "Reading eeprom failed"; - return -1; - } + 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"); } 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"); +} + +/** + 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; @@ -823,22 +1409,115 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) for (i = 0; i < 64; 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) { - ftdi->error_str = "Unable to write eeprom"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to write 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) { - ftdi->error_str = "Unable to erase eeprom"; - return -1; - } + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "unable to erase eeprom"); + + 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; +} + +/* + Flow control code by Lorenz Moesenlechner (lorenz@hcilab.org) + and Matthias Kranz (matthias@hcilab.org) +*/ +/** + Set flowcontrol for ftdi chip + + \param ftdi pointer to ftdi_context + \param flowctrl flow control to use. should be + SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS + + \retval 0: all fine + \retval -1: set flow control failed +*/ +int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl) +{ + if (usb_control_msg(ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE, + SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->interface), + NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "set flow control failed"); + + return 0; +} + +/** + Set dtr line + + \param ftdi pointer to ftdi_context + \param state state to set line to (1 or 0) + + \retval 0: all fine + \retval -1: set dtr failed +*/ +int ftdi_setdtr(struct ftdi_context *ftdi, int state) +{ + unsigned short usb_val; + + if (state) + usb_val = SIO_SET_DTR_HIGH; + else + usb_val = SIO_SET_DTR_LOW; + + if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE, + SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, + NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "set dtr failed"); + + return 0; +} + +/** + Set rts line + + \param ftdi pointer to ftdi_context + \param state state to set line to (1 or 0) + + \retval 0: all fine + \retval -1 set rts failed +*/ +int ftdi_setrts(struct ftdi_context *ftdi, int state) +{ + unsigned short usb_val; + + if (state) + usb_val = SIO_SET_RTS_HIGH; + else + usb_val = SIO_SET_RTS_LOW; + + if (usb_control_msg(ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE, + SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, + NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "set of rts failed"); return 0; } + +/* @} end of doxygen libftdi group */