X-Git-Url: http://developer.intra2net.com/git/?a=blobdiff_plain;f=ftdi%2Fftdi.c;h=165c2bbeb60c1d89b24dcd994338d76178ebd93d;hb=0e302db669e822c7a2d4c00d0a59da9c17c51031;hp=e7aaae7c87cb48daaac5a8c573edb226805f9a01;hpb=948f9adab13f60df70132e658e5facf8e0e654a2;p=libftdi

diff --git a/ftdi/ftdi.c b/ftdi/ftdi.c
index e7aaae7..165c2bb 100644
--- a/ftdi/ftdi.c
+++ b/ftdi/ftdi.c
@@ -13,19 +13,31 @@
  *   version 2.1 as published by the Free Software Foundation;             *
  *                                                                         *
  ***************************************************************************/
+#define _GNU_SOURCE
 
-#include <usb.h>
- 
 #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 (64 byte) read buffer
+  -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_timeout = 5000;
+    ftdi->usb_read_timeout = 5000;
+    ftdi->usb_write_timeout = 5000;
 
+    ftdi->type = TYPE_BM;    /* chip type */
     ftdi->baudrate = -1;
     ftdi->bitbang_enabled = 0;
 
@@ -34,26 +46,44 @@ int ftdi_init(struct ftdi_context *ftdi) {
     ftdi->readbuffer_remaining = 0;
     ftdi->writebuffer_chunksize = 4096;
 
+    ftdi->interface = 0;
+    ftdi->index = 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;
+        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
@@ -85,16 +115,26 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
             if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
                 ftdi->usb_dev = usb_open(dev);
                 if (ftdi->usb_dev) {
-                    if (usb_claim_interface(ftdi->usb_dev, 0) != 0) {
-                        ftdi->error_str = "unable to claim usb device. You can still use it though...";
+                    if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
+                        ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
                         return -5;
                     }
 
                     if (ftdi_usb_reset (ftdi) != 0)
-                       return -6;
+                        return -6;
 
                     if (ftdi_set_baudrate (ftdi, 9600) != 0)
-                       return -7;
+                        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 {
@@ -112,25 +152,32 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
 
 
 int ftdi_usb_reset(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
+    // Invalidate data in the readbuffer
+    ftdi->readbuffer_offset = 0;
+    ftdi->readbuffer_remaining = 0;
 
     return 0;
 }
 
 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
+    // Invalidate data in the readbuffer
+    ftdi->readbuffer_offset = 0;
+    ftdi->readbuffer_remaining = 0;
 
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, 0, NULL, 0, ftdi->usb_timeout) != 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;
     }
 
+
     return 0;
 }
 
@@ -142,7 +189,7 @@ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
 int ftdi_usb_close(struct ftdi_context *ftdi) {
     int rtn = 0;
 
-    if (usb_release_interface(ftdi->usb_dev, 0) != 0)
+    if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
         rtn = -1;
 
     if (usb_close (ftdi->usb_dev) != 0)
@@ -153,64 +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;
     }
 
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, 0, NULL, 0, ftdi->usb_timeout) != 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;
+    }
+
+    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;
     }
@@ -223,22 +341,24 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
 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;
 
         if (offset+write_size > size)
             write_size = size-offset;
 
-        ret=usb_bulk_write(ftdi->usb_dev, 2, buf+offset, write_size, ftdi->usb_timeout);
+        ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
         if (ret == -1) {
-    	    ftdi->error_str = "bulk write failed";
+            ftdi->error_str = "bulk write failed";
             return -1;
-	}
+        }
+        total_written += ret;
 
         offset += write_size;
     }
 
-    return 0;
+    return total_written;
 }
 
 
@@ -255,77 +375,141 @@ 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) {
-	memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
-	
-	// Fix offsets
-	ftdi->readbuffer_remaining -= size;
-	ftdi->readbuffer_offset += size;
-	
-	// printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining);
-	
-	return size;
+        memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
+
+        // Fix offsets
+        ftdi->readbuffer_remaining -= size;
+        ftdi->readbuffer_offset += size;
+
+        /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
+
+        return size;
     }
-    
     // something still in the readbuffer, but not enough to satisfy 'size'?
     if (ftdi->readbuffer_remaining != 0) {
-	memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
+        memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
 
-	// printf("Got bytes from buffer: %d\n", ftdi->readbuffer_remaining);
-
-	// Fix offsets
-	offset += ftdi->readbuffer_remaining;
-	ftdi->readbuffer_remaining = 0;
-	ftdi->readbuffer_offset = 0;
+        // Fix offset
+        offset += ftdi->readbuffer_remaining;
     }
     
     // do the actual USB read
     while (offset < size && ret > 0) {
-	ftdi->readbuffer_remaining = 0;
-	ftdi->readbuffer_offset = 0;
-	ret = usb_bulk_read (ftdi->usb_dev, 0x81, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_timeout);
-
-	if (ret == -1) {
-    	    ftdi->error_str = "bulk read failed";
+        ftdi->readbuffer_remaining = 0;
+        ftdi->readbuffer_offset = 0;
+        
+        /*
+            // 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 > 2) {
-	    // skip FTDI status bytes.
-	    // Maybe stored in the future to enable modem use
-	    ftdi->readbuffer_offset += 2;
-	    ret -= 2;
-	} else if (ret <= 2) {
-	    // no more data to read?
-	    return offset;
-	}
-
-	if (ret > 0) {
-	    // data still fits in buf?
-	    if (offset+ret <= size) {
-		memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
-        	offset += ret;
-		
-		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;
-		
-		// printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n", part_size, size, offset, ret, ftdi->readbuffer_remaining);
-
-		return part_size;
-	    }
-	}
+        }
+        
+        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
+            ftdi->readbuffer_offset += 2;
+            ret -= 2;
+        } else if (ret <= 2) {
+            // no more data to read?
+            return offset;
+        }
+        if (ret > 0) {
+            // data still fits in buf?
+            if (offset+ret <= size) {
+                memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
+                //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
+                offset += ret;
+
+                /* 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); */
+
+                return offset;
+            }
+        }
     }
-
     // never reached
     return -2;
 }
@@ -338,10 +522,10 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi
 
     unsigned char *new_buf;
     if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) {
-	ftdi->error_str = "out of memory for readbuffer";
-	return -1;
+        ftdi->error_str = "out of memory for readbuffer";
+        return -1;
     }
-    
+
     ftdi->readbuffer = new_buf;
     ftdi->readbuffer_chunksize = chunksize;
 
@@ -349,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;
 }
@@ -359,20 +543,21 @@ int ftdi_readt_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunk
 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
     unsigned short usb_val;
 
-    usb_val = bitmask;	// low byte: bitmask
-    usb_val += 1 << 8;	// high byte: enable flag
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    usb_val = bitmask; // low byte: 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;
     }
-
     ftdi->bitbang_enabled = 1;
     return 0;
 }
 
 
 int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
@@ -384,7 +569,7 @@ int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
 
 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, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
+    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;
     }
@@ -398,14 +583,14 @@ 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;
+        ftdi->error_str = "Latency out of range. Only valid for 1-255";
+        return -1;
     }
 
     usb_val = latency;
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, 0, NULL, 0, ftdi->usb_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_str = "Unable to set latency timer";
+        return -2;
     }
     return 0;
 }
@@ -413,7 +598,7 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
 
 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, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
+    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;
     }
@@ -424,22 +609,22 @@ 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;
     eeprom->BM_type_chip = 1;
-    
+
     eeprom->in_is_isochronous = 0;
     eeprom->out_is_isochronous = 0;
     eeprom->suspend_pull_downs = 0;
-    
+
     eeprom->use_serial = 0;
     eeprom->change_usb_version = 0;
-    eeprom->usb_version = 200;
+    eeprom->usb_version = 0x0200;
     eeprom->max_power = 0;
-    
+
     eeprom->manufacturer = NULL;
     eeprom->product = NULL;
     eeprom->serial = NULL;
@@ -458,21 +643,21 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
     int size_check;
 
     if (eeprom->manufacturer != NULL)
-	manufacturer_size = strlen(eeprom->manufacturer);
+        manufacturer_size = strlen(eeprom->manufacturer);
     if (eeprom->product != NULL)
-	product_size = strlen(eeprom->product);
+        product_size = strlen(eeprom->product);
     if (eeprom->serial != NULL)
-	serial_size = strlen(eeprom->serial);
+        serial_size = strlen(eeprom->serial);
 
-    size_check = 128;	// eeprom is 128 bytes
-    size_check -= 28;	// 28 are always in use (fixed)
+    size_check = 128; // eeprom is 128 bytes
+    size_check -= 28; // 28 are always in use (fixed)
     size_check -= manufacturer_size*2;
     size_check -= product_size*2;
     size_check -= serial_size*2;
 
     // eeprom size exceeded?
     if (size_check < 0)
-	return (-1);
+        return (-1);
 
     // empty eeprom
     memset (output, 0, 128);
@@ -488,11 +673,11 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
 
     // Addr 06: Device release number (0400h for BM features)
     output[0x06] = 0x00;
-    
+
     if (eeprom->BM_type_chip == 1)
-	output[0x07] = 0x04;
+        output[0x07] = 0x04;
     else
-	output[0x07] = 0x02;
+        output[0x07] = 0x02;
 
     // Addr 08: Config descriptor
     // Bit 1: remote wakeup if 1
@@ -500,14 +685,15 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
     //
     j = 0;
     if (eeprom->self_powered == 1)
-	j = j | 1;
+        j = j | 1;
     if (eeprom->remote_wakeup == 1)
-	j = j | 2;
+        j = j | 2;
     output[0x08] = j;
 
     // Addr 09: Max power consumption: max power = value * 2 mA
-    output[0x09] = eeprom->max_power;;
-    
+    output[0x09] = eeprom->max_power;
+    ;
+
     // Addr 0A: Chip configuration
     // Bit 7: 0 - reserved
     // Bit 6: 0 - reserved
@@ -520,25 +706,25 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
     //
     j = 0;
     if (eeprom->in_is_isochronous == 1)
-	j = j | 1;
+        j = j | 1;
     if (eeprom->out_is_isochronous == 1)
-	j = j | 2;
+        j = j | 2;
     if (eeprom->suspend_pull_downs == 1)
-	j = j | 4;
+        j = j | 4;
     if (eeprom->use_serial == 1)
-	j = j | 8;
+        j = j | 8;
     if (eeprom->change_usb_version == 1)
-	j = j | 16;
+        j = j | 16;
     output[0x0A] = j;
-    
+
     // Addr 0B: reserved
     output[0x0B] = 0x00;
-    
+
     // Addr 0C: USB version low byte when 0x0A bit 4 is set
     // Addr 0D: USB version high byte when 0x0A bit 4 is set
     if (eeprom->change_usb_version == 1) {
         output[0x0C] = eeprom->usb_version;
-	output[0x0D] = eeprom->usb_version >> 8;
+        output[0x0D] = eeprom->usb_version >> 8;
     }
 
 
@@ -558,47 +744,47 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
 
     // Dynamic content
     output[0x14] = manufacturer_size*2 + 2;
-    output[0x15] = 0x03;	// type: string
-    
+    output[0x15] = 0x03; // type: string
+
     i = 0x16, j = 0;
-    
+
     // Output manufacturer
     for (j = 0; j < manufacturer_size; j++) {
-	output[i] = eeprom->manufacturer[j], i++;
-	output[i] = 0x00, i++;
+        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[i] = eeprom->product[j], i++;
-	output[i] = 0x00, i++;
+        output[i] = eeprom->product[j], i++;
+        output[i] = 0x00, i++;
     }
-    
+
     // 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++) {
-	output[i] = eeprom->serial[j], i++;
-	output[i] = 0x00, i++;
+        output[i] = eeprom->serial[j], i++;
+        output[i] = 0x00, i++;
     }
 
     // calculate checksum
     checksum = 0xAAAA;
-    
+
     for (i = 0; i < 63; i++) {
-	value = output[i*2];
-	value += output[(i*2)+1] << 8;
+        value = output[i*2];
+        value += output[(i*2)+1] << 8;
 
-	checksum = value^checksum;
-	checksum = (checksum << 1) | (checksum >> 15);	
+        checksum = value^checksum;
+        checksum = (checksum << 1) | (checksum >> 15);
     }
 
     output[0x7E] = checksum;
-    output[0x7F] = checksum >> 8;    
+    output[0x7F] = checksum >> 8;
 
     return size_check;
 }
@@ -608,9 +794,9 @@ 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_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_str = "Reading eeprom failed";
+            return -1;
         }
     }
 
@@ -623,12 +809,12 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
     int i;
 
     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_timeout) != 0) {
-          ftdi->error_str = "Unable to write eeprom";
-          return -1;
-       }
+        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;
+        }
     }
 
     return 0;
@@ -636,10 +822,31 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
 
 
 int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
 
     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);
+}