* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
-
-#include <usb.h>
+#define _GNU_SOURCE
#include "ftdi.h"
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/* 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;
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
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;
}
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";
/*
+ 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;
}
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) {
// 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
//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;
}
}
-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;
}
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;
eeprom->use_serial = 0;
eeprom->change_usb_version = 0;
- eeprom->usb_version = 200;
+ eeprom->usb_version = 0x0200;
eeprom->max_power = 0;
eeprom->manufacturer = NULL;
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);
+}
git://developer.intra2net.com / libftdi / blobdiff