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
***************************************************************************/
#include <usb.h>
#include <string.h>
#include <errno.h>
-#include <sys/ioctl.h>
#include "ftdi.h"
+/* stuff needed for async write */
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <linux/usbdevice_fs.h>
+
#define ftdi_error_return(code, str) do { \
ftdi->error_str = str; \
return code; \
*/
int ftdi_init(struct ftdi_context *ftdi)
{
+ int i;
+
ftdi->usb_dev = NULL;
ftdi->usb_read_timeout = 5000;
ftdi->usb_write_timeout = 5000;
ftdi->error_str = NULL;
+ 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;
+
+ ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
+
/* All fine. Now allocate the readbuffer */
return ftdi_read_data_set_chunksize(ftdi, 4096);
}
*/
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;
{
int rtn = 0;
+ /* try to release some kernel resources */
+ ftdi_async_complete(ftdi,1);
+
if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
rtn = -1;
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 {
// 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
+/**
+ 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(usb_dev_handle *dev, int ep, char *bytes, int size)
+static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
{
- struct usb_urb urb;
+ struct usbdevfs_urb *urb;
int bytesdone = 0, requested;
- struct usb_urb *context;
- int ret, waiting;
+ int ret, i;
+ int cleanup_count;
do {
- fd_set writefds;
+ /* 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 > 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 (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 */
if (offset+write_size > size)
write_size = size-offset;
- ret = usb_bulk_write_async(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size);
+ 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");
}
/**
+ 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
eeprom->manufacturer = NULL;
eeprom->product = NULL;
eeprom->serial = NULL;
+
+ eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
}
/**
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;
return (-1);
// empty eeprom
- memset (output, 0, 128);
+ memset (output, 0, eeprom->size);
// Addr 00: Stay 00 00
// Addr 02: Vendor ID
}
- // 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;
output[0x13] = serial_size*2 + 2;
// Dynamic content
- output[0x14] = manufacturer_size*2 + 2;
- output[0x15] = 0x03; // type: string
-
- i = 0x16, j = 0;
-
- // Output manufacturer
+ i=0x14;
+ if(eeprom->size>=256) i = 0x80;
+
+
+ // 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++) {
}
// 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++) {
// 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;
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;
}
{
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");
}
}
/**
+ 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 && j<size; j++) {
+ 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");
+ 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
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)
git://developer.intra2net.com / libftdi / blobdiff