X-Git-Url: http://developer.intra2net.com/git/?a=blobdiff_plain;f=ftdi%2Fftdi.c;h=165c2bbeb60c1d89b24dcd994338d76178ebd93d;hb=0e302db669e822c7a2d4c00d0a59da9c17c51031;hp=18c4d1dc0a4d4ff606f83660a167e5db5362457b;hpb=3119537ff1cf8b9a6f945806dbb75d3bc71935e2;p=libftdi diff --git a/ftdi/ftdi.c b/ftdi/ftdi.c index 18c4d1d..165c2bb 100644 --- a/ftdi/ftdi.c +++ b/ftdi/ftdi.c @@ -13,20 +13,31 @@ * version 2.1 as published by the Free Software Foundation; * * * ***************************************************************************/ - -#include +#define _GNU_SOURCE #include "ftdi.h" +#include +#include +#include +#include + +/* Internal USB devfs functions. Do not use outside libftdi */ +static struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets); +static int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb); +static int ftdi_usbdev_reap_urb_ndelay(int fd, struct usbdevfs_urb **urb_return); + /* ftdi_init return codes: 0: all fine -1: couldn't allocate read buffer */ -int ftdi_init(struct ftdi_context *ftdi) { +int ftdi_init(struct ftdi_context *ftdi) +{ ftdi->usb_dev = NULL; ftdi->usb_read_timeout = 5000; ftdi->usb_write_timeout = 5000; + ftdi->type = TYPE_BM; /* chip type */ ftdi->baudrate = -1; ftdi->bitbang_enabled = 0; @@ -40,27 +51,39 @@ int ftdi_init(struct ftdi_context *ftdi) { ftdi->in_ep = 0x02; ftdi->out_ep = 0x81; ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */ - + ftdi->error_str = NULL; + ftdi->urb = ftdi_usbdev_alloc_urb(0); + if (!ftdi->urb) { + ftdi->error_str = "out of memory for read URB"; + return -1; + } + // all fine. Now allocate the readbuffer return ftdi_read_data_set_chunksize(ftdi, 4096); } -void ftdi_deinit(struct ftdi_context *ftdi) { +void ftdi_deinit(struct ftdi_context *ftdi) +{ if (ftdi->readbuffer != NULL) { free(ftdi->readbuffer); ftdi->readbuffer = NULL; } + + if (ftdi->urb != NULL) { + free (ftdi->urb); + ftdi->urb = NULL; + } } -void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) { +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 @@ -93,7 +116,7 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) { ftdi->usb_dev = usb_open(dev); if (ftdi->usb_dev) { if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) { - ftdi->error_str = "unable to claim usb device. You can still use it though..."; + ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!"; return -5; } @@ -103,6 +126,16 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) { if (ftdi_set_baudrate (ftdi, 9600) != 0) return -7; + // 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; } else { ftdi->error_str = "usb_open() failed"; @@ -167,65 +200,135 @@ int ftdi_usb_close(struct ftdi_context *ftdi) { /* + ftdi_convert_baudrate returns nearest supported baud rate to that requested. + Function is only used internally +*/ +static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, + unsigned short *value, unsigned short *index) { + 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}; + static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7}; + int divisor, best_divisor, best_baud, best_baud_diff; + unsigned long encoded_divisor; + int i; + + if (baudrate <= 0) { + // Return error + return -1; + } + + divisor = 24000000 / baudrate; + + if (ftdi->type == TYPE_AM) { + // Round down to supported fraction (AM only) + divisor -= am_adjust_dn[divisor & 7]; + } + + // Try this divisor and the one above it (because division rounds down) + best_divisor = 0; + best_baud = 0; + best_baud_diff = 0; + for (i = 0; i < 2; i++) { + int try_divisor = divisor + i; + int baud_estimate; + int baud_diff; + + // Round up to supported divisor value + if (try_divisor < 8) { + // Round up to minimum supported divisor + try_divisor = 8; + } else if (ftdi->type != TYPE_AM && try_divisor < 12) { + // BM doesn't support divisors 9 through 11 inclusive + try_divisor = 12; + } else if (divisor < 16) { + // AM doesn't support divisors 9 through 15 inclusive + try_divisor = 16; + } else { + if (ftdi->type == TYPE_AM) { + // Round up to supported fraction (AM only) + try_divisor += am_adjust_up[try_divisor & 7]; + if (try_divisor > 0x1FFF8) { + // Round down to maximum supported divisor value (for AM) + try_divisor = 0x1FFF8; + } + } else { + if (try_divisor > 0x1FFFF) { + // Round down to maximum supported divisor value (for BM) + try_divisor = 0x1FFFF; + } + } + } + // Get estimated baud rate (to nearest integer) + baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor; + // Get absolute difference from requested baud rate + if (baud_estimate < baudrate) { + baud_diff = baudrate - baud_estimate; + } else { + baud_diff = baud_estimate - baudrate; + } + if (i == 0 || baud_diff < best_baud_diff) { + // Closest to requested baud rate so far + best_divisor = try_divisor; + best_baud = baud_estimate; + best_baud_diff = baud_diff; + if (baud_diff == 0) { + // Spot on! No point trying + break; + } + } + } + // Encode the best divisor value + encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14); + // Deal with special cases for encoded value + if (encoded_divisor == 1) { + encoded_divisor = 0; // 3000000 baud + } else if (encoded_divisor == 0x4001) { + encoded_divisor = 1; // 2000000 baud (BM only) + } + // Split into "value" and "index" values + *value = (unsigned short)(encoded_divisor & 0xFFFF); + if(ftdi->type == TYPE_2232C) { + *index = (unsigned short)(encoded_divisor >> 8); + *index &= 0xFF00; + *index |= ftdi->interface; + } + 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 */ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) { - unsigned short ftdi_baudrate; + unsigned short value, index; + int actual_baudrate; if (ftdi->bitbang_enabled) { baudrate = baudrate*4; } - switch (baudrate) { - case 300: - ftdi_baudrate = 0x2710; - break; - case 600: - ftdi_baudrate = 0x1388; - break; - case 1200: - ftdi_baudrate = 0x09C4; - break; - case 2400: - ftdi_baudrate = 0x04E2; - break; - case 4800: - ftdi_baudrate = 0x0271; - break; - case 9600: - ftdi_baudrate = 0x4138; - break; - case 19200: - ftdi_baudrate = 0x809C; - break; - case 38400: - ftdi_baudrate = 0xC04E; - break; - case 57600: - ftdi_baudrate = 0x0034; - break; - case 115200: - ftdi_baudrate = 0x001A; - break; - case 230400: - ftdi_baudrate = 0x000D; - break; - case 460800: - ftdi_baudrate = 0x4006; - break; - case 921600: - ftdi_baudrate = 0x8003; - break; - default: - ftdi->error_str = "Unknown baudrate. Note: bitbang baudrates are automatically multiplied by 4"; + actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index); + if (actual_baudrate <= 0) { + ftdi->error_str = "Silly baudrate <= 0."; return -1; } + // 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; + } - if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) { + 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; } @@ -272,7 +375,9 @@ int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunk int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) { - int offset = 0, ret = 1; + struct timeval tv, tv_ref, tv_now; + struct usbdevfs_urb *returned_urb; + int offset = 0, ret = 1, waiting; // everything we want is still in the readbuffer? if (size <= ftdi->readbuffer_remaining) { @@ -293,18 +398,83 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) { // Fix offset offset += ftdi->readbuffer_remaining; } + // do the actual USB read while (offset < size && ret > 0) { ftdi->readbuffer_remaining = 0; ftdi->readbuffer_offset = 0; - /* returns how much received */ - ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout); - - if (ret == -1) { - ftdi->error_str = "bulk read failed"; + + /* + // Old read functions, not status byte safe! + // returns how much received + ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, + ftdi->readbuffer_chunksize, ftdi->usb_read_timeout); + */ + + /* Real userspace URB processing to cope with + a race condition where two or more status bytes + could already be in the kernel USB buffer */ + memset(ftdi->urb, 0, sizeof(struct usbdevfs_urb)); + + ftdi->urb->type = USBDEVFS_URB_TYPE_BULK; + ftdi->urb->endpoint = ftdi->out_ep | USB_DIR_IN; + ftdi->urb->buffer = ftdi->readbuffer; + ftdi->urb->buffer_length = ftdi->readbuffer_chunksize; + + /* Submit URB to USB layer */ + if (ftdi_usbdev_submit_urb(ftdi->usb_dev->fd, ftdi->urb) == -1) { + ftdi->error_str = "ftdi_usbdev_submit_urb for bulk read failed"; return -1; } - + + /* Wait for the result to come in. + Timer stuff is borrowed from libusb's interrupt transfer */ + gettimeofday(&tv_ref, NULL); + tv_ref.tv_sec = tv_ref.tv_sec + ftdi->usb_read_timeout / 1000; + tv_ref.tv_usec = tv_ref.tv_usec + (ftdi->usb_read_timeout % 1000) * 1000; + + if (tv_ref.tv_usec > 1e6) { + tv_ref.tv_usec -= 1e6; + tv_ref.tv_sec++; + } + + waiting = 1; + memset (&tv, 0, sizeof (struct timeval)); + while (((ret = ftdi_usbdev_reap_urb_ndelay(ftdi->usb_dev->fd, &returned_urb)) == -1) && waiting) { + tv.tv_sec = 0; + tv.tv_usec = 1000; // 1 msec + select(0, NULL, NULL, NULL, &tv); //sub second wait + + /* compare with actual time, as the select timeout is not that precise */ + gettimeofday(&tv_now, NULL); + + if ((tv_now.tv_sec > tv_ref.tv_sec) || + ((tv_now.tv_sec == tv_ref.tv_sec) && (tv_now.tv_usec >= tv_ref.tv_usec))) + waiting = 0; + } + + if (!waiting) { + ftdi->error_str = "timeout during ftdi_read_data"; + return -1; + } + + if (ret < 0) { + ftdi->error_str = "ftdi_usbdev_reap_urb for bulk read failed"; + return -1; + } + + if (returned_urb->status) { + ftdi->error_str = "URB return status not OK"; + return -1; + } + + /* Paranoia check */ + if (returned_urb->buffer != ftdi->readbuffer) { + ftdi->error_str = "buffer paranoia check failed"; + return -1; + } + + ret = returned_urb->actual_length; if (ret > 2) { // skip FTDI status bytes. // Maybe stored in the future to enable modem use @@ -321,20 +491,20 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) { //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]); offset += ret; - /* Did we read exactly the right amount of bytes? */ + /* Did we read exactly the right amount of bytes? */ if (offset == size) return offset; } else { // only copy part of the data or size <= readbuffer_chunksize int part_size = size-offset; memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size); - + ftdi->readbuffer_offset += part_size; ftdi->readbuffer_remaining = ret-part_size; offset += part_size; - /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n", - part_size, size, offset, ret, ftdi->readbuffer_remaining); */ + /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n", + part_size, size, offset, ret, ftdi->readbuffer_remaining); */ return offset; } @@ -363,7 +533,7 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi } -int ftdi_readt_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { +int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) { *chunksize = ftdi->readbuffer_chunksize; return 0; } @@ -439,8 +609,8 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) { void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) { - eeprom->vendor_id = 0403; - eeprom->product_id = 6001; + eeprom->vendor_id = 0x0403; + eeprom->product_id = 0x6001; eeprom->self_powered = 1; eeprom->remote_wakeup = 1; @@ -452,7 +622,7 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) { eeprom->use_serial = 0; eeprom->change_usb_version = 0; - eeprom->usb_version = 200; + eeprom->usb_version = 0x0200; eeprom->max_power = 0; eeprom->manufacturer = NULL; @@ -659,3 +829,24 @@ int ftdi_erase_eeprom(struct ftdi_context *ftdi) { return 0; } + + +/* Functions needed for userspace URB processing */ +static struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets) +{ + return calloc(sizeof(struct usbdevfs_urb) + + iso_packets * sizeof(struct usbdevfs_iso_packet_desc), + 1); +} + + +static int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb) +{ + return ioctl(fd, USBDEVFS_SUBMITURB, urb); +} + + +static int ftdi_usbdev_reap_urb_ndelay(int fd, struct usbdevfs_urb **urb_return) +{ + return ioctl(fd, USBDEVFS_REAPURBNDELAY, urb_return); +}