105 files changed, 12399 insertions, 4299 deletions

diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 8e184e2641cb..79861ee12a29 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -715,13 +715,11 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance,
                         usb_dev, usb_rcvintpipe(usb_dev, CXACRU_EP_CMD),
                         instance->rcv_buf, PAGE_SIZE,
                         cxacru_blocking_completion, &instance->rcv_done, 1);
-        instance->rcv_urb->transfer_flags |= URB_ASYNC_UNLINK;
 
         usb_fill_int_urb(instance->snd_urb,
                         usb_dev, usb_sndintpipe(usb_dev, CXACRU_EP_CMD),
                         instance->snd_buf, PAGE_SIZE,
                         cxacru_blocking_completion, &instance->snd_done, 4);
-        instance->snd_urb->transfer_flags |= URB_ASYNC_UNLINK;
 
         init_MUTEX(&instance->cm_serialize);
 
diff --git a/drivers/usb/class/Kconfig b/drivers/usb/class/Kconfig
index 0561d0234f23..333e39bb105f 100644
--- a/drivers/usb/class/Kconfig
+++ b/drivers/usb/class/Kconfig
@@ -4,9 +4,22 @@
 comment "USB Device Class drivers"
         depends on USB
 
+config OBSOLETE_OSS_USB_DRIVER
+        bool "Obsolete OSS USB drivers"
+        depends on USB && SOUND
+        help
+          This option enables support for the obsolete USB Audio and Midi
+          drivers that are scheduled for removal in the near future since
+          there are ALSA drivers for the same hardware.
+
+          Please contact Adrian Bunk <bunk@stusta.de> if you had to
+          say Y here because of missing support in the ALSA drivers.
+
+          If unsure, say N.
+
 config USB_AUDIO
         tristate "USB Audio support"
-        depends on USB && SOUND
+        depends on USB && SOUND && OBSOLETE_OSS_USB_DRIVER
         help
           Say Y here if you want to connect USB audio equipment such as
           speakers to your computer's USB port. You only need this if you use
@@ -40,10 +53,12 @@ config USB_BLUETOOTH_TTY
 
 config USB_MIDI
         tristate "USB MIDI support"
-        depends on USB && SOUND
+        depends on USB && SOUND && OBSOLETE_OSS_USB_DRIVER
         ---help---
           Say Y here if you want to connect a USB MIDI device to your
-          computer's USB port. This driver is for devices that comply with
+          computer's USB port.  You only need this if you use the OSS
+          sound system; USB MIDI devices are supported by ALSA's USB
+          audio driver. This driver is for devices that comply with
           'Universal Serial Bus Device Class Definition for MIDI Device'.
 
           The following devices are known to work:
diff --git a/drivers/usb/class/audio.c b/drivers/usb/class/audio.c
index f8f21567cc22..50858273f8d3 100644
--- a/drivers/usb/class/audio.c
+++ b/drivers/usb/class/audio.c
@@ -631,8 +631,10 @@ static void usbin_stop(struct usb_audiodev *as)
         i = u->flags;
         spin_unlock_irqrestore(&as->lock, flags);
         while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
-                set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
+                if (notkilled)
+                        schedule_timeout_interruptible(1);
+                else
+                        schedule_timeout_uninterruptible(1);
                 spin_lock_irqsave(&as->lock, flags);
                 i = u->flags;
                 spin_unlock_irqrestore(&as->lock, flags);
@@ -1102,8 +1104,10 @@ static void usbout_stop(struct usb_audiodev *as)
         i = u->flags;
         spin_unlock_irqrestore(&as->lock, flags);
         while (i & (FLG_URB0RUNNING|FLG_URB1RUNNING|FLG_SYNC0RUNNING|FLG_SYNC1RUNNING)) {
-                set_current_state(notkilled ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
-                schedule_timeout(1);
+                if (notkilled)
+                        schedule_timeout_interruptible(1);
+                else
+                        schedule_timeout_uninterruptible(1);
                 spin_lock_irqsave(&as->lock, flags);
                 i = u->flags;
                 spin_unlock_irqrestore(&as->lock, flags);
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 7ce43fb8118a..e195709c9c7f 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -310,8 +310,9 @@ static int usblp_check_status(struct usblp *usblp, int err)
 
         error = usblp_read_status (usblp, usblp->statusbuf);
         if (error < 0) {
-                err("usblp%d: error %d reading printer status",
-                        usblp->minor, error);
+                if (printk_ratelimit())
+                        err("usblp%d: error %d reading printer status",
+                                usblp->minor, error);
                 return 0;
         }
 
@@ -604,7 +605,9 @@ static int usblp_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
                         case LPGETSTATUS:
                                 if (usblp_read_status(usblp, usblp->statusbuf)) {
-                                        err("usblp%d: failed reading printer status", usblp->minor);
+                                        if (printk_ratelimit())
+                                                err("usblp%d: failed reading printer status",
+                                                        usblp->minor);
                                         retval = -EIO;
                                         goto done;
                                 }
diff --git a/drivers/usb/core/Makefile b/drivers/usb/core/Makefile
index 9e8c377b8161..d5503cf0bf74 100644
--- a/drivers/usb/core/Makefile
+++ b/drivers/usb/core/Makefile
@@ -3,14 +3,14 @@
 #
 
 usbcore-objs    := usb.o hub.o hcd.o urb.o message.o \
-                        config.o file.o buffer.o sysfs.o
+                        config.o file.o buffer.o sysfs.o devio.o
 
 ifeq ($(CONFIG_PCI),y)
         usbcore-objs    += hcd-pci.o
 endif
 
 ifeq ($(CONFIG_USB_DEVICEFS),y)
-        usbcore-objs    += devio.o inode.o devices.o
+        usbcore-objs    += inode.o devices.o
 endif
 
 obj-$(CONFIG_USB)       += usbcore.o
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index f86bf1454e21..b4265aa7d45e 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -43,6 +43,7 @@
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
+#include <linux/cdev.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 #include <linux/moduleparam.h>
@@ -50,6 +51,10 @@
 #include "hcd.h"        /* for usbcore internals */
 #include "usb.h"
 
+#define USB_MAXBUS                      64
+#define USB_DEVICE_MAX                  USB_MAXBUS * 128
+static struct class *usb_device_class;
+
 struct async {
         struct list_head asynclist;
         struct dev_state *ps;
@@ -71,6 +76,8 @@ MODULE_PARM_DESC (usbfs_snoop, "true to log all usbfs traffic");
                         dev_info( dev , format , ## arg);       \
         } while (0)
 
+#define USB_DEVICE_DEV          MKDEV(USB_DEVICE_MAJOR, 0)
+
 
 #define MAX_USBFS_BUFFER_SIZE   16384
 
@@ -487,7 +494,7 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsig
  */
 static int usbdev_open(struct inode *inode, struct file *file)
 {
-        struct usb_device *dev;
+        struct usb_device *dev = NULL;
         struct dev_state *ps;
         int ret;
 
@@ -501,11 +508,16 @@ static int usbdev_open(struct inode *inode, struct file *file)
 
         lock_kernel();
         ret = -ENOENT;
-        dev = usb_get_dev(inode->u.generic_ip);
+        /* check if we are called from a real node or usbfs */
+        if (imajor(inode) == USB_DEVICE_MAJOR)
+                dev = usbdev_lookup_minor(iminor(inode));
+        if (!dev)
+                dev = inode->u.generic_ip;
         if (!dev) {
                 kfree(ps);
                 goto out;
         }
+        usb_get_dev(dev);
         ret = 0;
         ps->dev = dev;
         ps->file = file;
@@ -1226,7 +1238,6 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg)
         int                     retval = 0;
         struct usb_interface    *intf = NULL;
         struct usb_driver       *driver = NULL;
-        int                     i;
 
         /* get input parameters and alloc buffer */
         if (copy_from_user(&ctrl, arg, sizeof (ctrl)))
@@ -1258,15 +1269,6 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg)
         /* disconnect kernel driver from interface */
         case USBDEVFS_DISCONNECT:
 
-                /* don't allow the user to unbind the hub driver from
-                 * a hub with children to manage */
-                for (i = 0; i < ps->dev->maxchild; ++i) {
-                        if (ps->dev->children[i])
-                                retval = -EBUSY;
-                }
-                if (retval)
-                        break;
-
                 down_write(&usb_bus_type.subsys.rwsem);
                 if (intf->dev.driver) {
                         driver = to_usb_driver(intf->dev.driver);
@@ -1477,3 +1479,79 @@ struct file_operations usbfs_device_file_operations = {
         .open =         usbdev_open,
         .release =      usbdev_release,
 };
+
+struct usb_device *usbdev_lookup_minor(int minor)
+{
+        struct class_device *class_dev;
+        struct usb_device *dev = NULL;
+
+        down(&usb_device_class->sem);
+        list_for_each_entry(class_dev, &usb_device_class->children, node) {
+                if (class_dev->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
+                        dev = class_dev->class_data;
+                        break;
+                }
+        }
+        up(&usb_device_class->sem);
+
+        return dev;
+};
+
+void usbdev_add(struct usb_device *dev)
+{
+        int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
+
+        dev->class_dev = class_device_create(usb_device_class,
+                                MKDEV(USB_DEVICE_MAJOR, minor), &dev->dev,
+                                "usbdev%d.%d", dev->bus->busnum, dev->devnum);
+
+        dev->class_dev->class_data = dev;
+}
+
+void usbdev_remove(struct usb_device *dev)
+{
+        class_device_unregister(dev->class_dev);
+}
+
+static struct cdev usb_device_cdev = {
+        .kobj   = {.name = "usb_device", },
+        .owner  = THIS_MODULE,
+};
+
+int __init usbdev_init(void)
+{
+        int retval;
+
+        retval = register_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX,
+                        "usb_device");
+        if (retval) {
+                err("unable to register minors for usb_device");
+                goto out;
+        }
+        cdev_init(&usb_device_cdev, &usbfs_device_file_operations);
+        retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
+        if (retval) {
+                err("unable to get usb_device major %d", USB_DEVICE_MAJOR);
+                unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
+                goto out;
+        }
+        usb_device_class = class_create(THIS_MODULE, "usb_device");
+        if (IS_ERR(usb_device_class)) {
+                err("unable to register usb_device class");
+                retval = PTR_ERR(usb_device_class);
+                usb_device_class = NULL;
+                cdev_del(&usb_device_cdev);
+                unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
+        }
+
+out:
+        return retval;
+}
+
+void usbdev_cleanup(void)
+{
+        class_destroy(usb_device_class);
+        cdev_del(&usb_device_cdev);
+        unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
+}
+
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index fc056062c960..cbb451d227d2 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -121,10 +121,6 @@ int usb_hcd_pci_probe (struct pci_dev *dev, const struct pci_device_id *id)
                 }
         }
 
-#ifdef CONFIG_PCI_NAMES
-        hcd->product_desc = dev->pretty_name;
-#endif
-
         pci_set_master (dev);
 
         retval = usb_add_hcd (hcd, dev->irq, SA_SHIRQ);
@@ -264,8 +260,10 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message)
                 retval = pci_set_power_state (dev, PCI_D3hot);
                 if (retval == 0) {
                         dev_dbg (hcd->self.controller, "--> PCI D3\n");
-                        pci_enable_wake (dev, PCI_D3hot, hcd->remote_wakeup);
-                        pci_enable_wake (dev, PCI_D3cold, hcd->remote_wakeup);
+                        retval = pci_enable_wake (dev, PCI_D3hot, hcd->remote_wakeup);
+                        if (retval)
+                                break;
+                        retval = pci_enable_wake (dev, PCI_D3cold, hcd->remote_wakeup);
                 } else if (retval < 0) {
                         dev_dbg (&dev->dev, "PCI D3 suspend fail, %d\n",
                                         retval);
@@ -339,8 +337,20 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
                                 dev->current_state);
                 }
 #endif
-                pci_enable_wake (dev, dev->current_state, 0);
-                pci_enable_wake (dev, PCI_D3cold, 0);
+                retval = pci_enable_wake (dev, dev->current_state, 0);
+                if (retval) {
+                        dev_err(hcd->self.controller,
+                                "can't enable_wake to %d, %d!\n",
+                                dev->current_state, retval);
+                        return retval;
+                }
+                retval = pci_enable_wake (dev, PCI_D3cold, 0);
+                if (retval) {
+                        dev_err(hcd->self.controller,
+                                "can't enable_wake to %d, %d!\n",
+                                PCI_D3cold, retval);
+                        return retval;
+                }
         } else {
                 /* Same basic cases: clean (powered/not), dirty */
                 dev_dbg(hcd->self.controller, "PCI legacy resume\n");
@@ -380,7 +390,7 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
                 usb_hc_died (hcd);
         }
 
-        pci_enable_device(dev);
+        retval = pci_enable_device(dev);
         return retval;
 }
 EXPORT_SYMBOL (usb_hcd_pci_resume);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 12ecdb03ee5f..1017a97a418b 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1606,7 +1606,7 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd, struct pt_regs * r)
                 return IRQ_NONE;
 
         hcd->saw_irq = 1;
-        if (hcd->state != start && hcd->state == HC_STATE_HALT)
+        if (hcd->state == HC_STATE_HALT)
                 usb_hc_died (hcd);
         return IRQ_HANDLED;
 }
@@ -1630,7 +1630,6 @@ void usb_hc_died (struct usb_hcd *hcd)
         spin_lock_irqsave (&hcd_root_hub_lock, flags);
         if (hcd->rh_registered) {
                 hcd->poll_rh = 0;
-                del_timer(&hcd->rh_timer);
 
                 /* make khubd clean up old urbs and devices */
                 usb_set_device_state (hcd->self.root_hub,
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 28055f95645b..ac451fa7e4d2 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -339,11 +339,11 @@ extern int usb_check_bandwidth (struct usb_device *dev, struct urb *urb);
  * to preallocate bandwidth)
  */
 #define USB2_HOST_DELAY 5       /* nsec, guess */
-#define HS_NSECS(bytes) ( ((55 * 8 * 2083)/1000) \
-        + ((2083UL * (3167 + BitTime (bytes)))/1000) \
+#define HS_NSECS(bytes) ( ((55 * 8 * 2083) \
+        + (2083UL * (3 + BitTime(bytes))))/1000 \
         + USB2_HOST_DELAY)
-#define HS_NSECS_ISO(bytes) ( ((38 * 8 * 2083)/1000) \
-        + ((2083UL * (3167 + BitTime (bytes)))/1000) \
+#define HS_NSECS_ISO(bytes) ( ((38 * 8 * 2083) \
+        + (2083UL * (3 + BitTime(bytes))))/1000 \
         + USB2_HOST_DELAY)
 #define HS_USECS(bytes) NS_TO_US (HS_NSECS(bytes))
 #define HS_USECS_ISO(bytes) NS_TO_US (HS_NSECS_ISO(bytes))
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index c9412daff682..a12cab5314e9 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -435,6 +435,7 @@ void usb_hub_tt_clear_buffer (struct usb_device *udev, int pipe)
 static void hub_power_on(struct usb_hub *hub)
 {
         int port1;
+        unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
 
         /* if hub supports power switching, enable power on each port */
         if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
@@ -444,8 +445,8 @@ static void hub_power_on(struct usb_hub *hub)
                                         USB_PORT_FEAT_POWER);
         }
 
-        /* Wait for power to be enabled */
-        msleep(hub->descriptor->bPwrOn2PwrGood * 2);
+        /* Wait at least 100 msec for power to become stable */
+        msleep(max(pgood_delay, (unsigned) 100));
 }
 
 static void hub_quiesce(struct usb_hub *hub)
@@ -492,6 +493,23 @@ static int hub_hub_status(struct usb_hub *hub,
         return ret;
 }
 
+static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
+{
+        struct usb_device *hdev = hub->hdev;
+        int ret;
+
+        if (hdev->children[port1-1] && set_state) {
+                usb_set_device_state(hdev->children[port1-1],
+                                USB_STATE_NOTATTACHED);
+        }
+        ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
+        if (ret)
+                dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
+                        port1, ret);
+
+        return ret;
+}
+
 static int hub_configure(struct usb_hub *hub,
         struct usb_endpoint_descriptor *endpoint)
 {
@@ -610,19 +628,33 @@ static int hub_configure(struct usb_hub *hub,
                         break;
         }
 
+        /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
         switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
-                case 0x00:
-                        if (hdev->descriptor.bDeviceProtocol != 0)
-                                dev_dbg(hub_dev, "TT requires at most 8 FS bit times\n");
+                case HUB_TTTT_8_BITS:
+                        if (hdev->descriptor.bDeviceProtocol != 0) {
+                                hub->tt.think_time = 666;
+                                dev_dbg(hub_dev, "TT requires at most %d "
+                                                "FS bit times (%d ns)\n",
+                                        8, hub->tt.think_time);
+                        }
                         break;
-                case 0x20:
-                        dev_dbg(hub_dev, "TT requires at most 16 FS bit times\n");
+                case HUB_TTTT_16_BITS:
+                        hub->tt.think_time = 666 * 2;
+                        dev_dbg(hub_dev, "TT requires at most %d "
+                                        "FS bit times (%d ns)\n",
+                                16, hub->tt.think_time);
                         break;
-                case 0x40:
-                        dev_dbg(hub_dev, "TT requires at most 24 FS bit times\n");
+                case HUB_TTTT_24_BITS:
+                        hub->tt.think_time = 666 * 3;
+                        dev_dbg(hub_dev, "TT requires at most %d "
+                                        "FS bit times (%d ns)\n",
+                                24, hub->tt.think_time);
                         break;
-                case 0x60:
-                        dev_dbg(hub_dev, "TT requires at most 32 FS bit times\n");
+                case HUB_TTTT_32_BITS:
+                        hub->tt.think_time = 666 * 4;
+                        dev_dbg(hub_dev, "TT requires at most %d "
+                                        "FS bit times (%d ns)\n",
+                                32, hub->tt.think_time);
                         break;
         }
 
@@ -712,20 +744,36 @@ fail:
 
 static unsigned highspeed_hubs;
 
+/* Called after the hub driver is unbound from a hub with children */
+static void hub_remove_children_work(void *__hub)
+{
+        struct usb_hub          *hub = __hub;
+        struct usb_device       *hdev = hub->hdev;
+        int                     i;
+
+        kfree(hub);
+
+        usb_lock_device(hdev);
+        for (i = 0; i < hdev->maxchild; ++i) {
+                if (hdev->children[i])
+                        usb_disconnect(&hdev->children[i]);
+        }
+        usb_unlock_device(hdev);
+        usb_put_dev(hdev);
+}
+
 static void hub_disconnect(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata (intf);
         struct usb_device *hdev;
+        int n, port1;
 
-        if (!hub)
-                return;
+        usb_set_intfdata (intf, NULL);
         hdev = hub->hdev;
 
         if (hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
-        usb_set_intfdata (intf, NULL);
-
         hub_quiesce(hub);
         usb_free_urb(hub->urb);
         hub->urb = NULL;
@@ -746,8 +794,27 @@ static void hub_disconnect(struct usb_interface *intf)
                 hub->buffer = NULL;
         }
 
-        /* Free the memory */
-        kfree(hub);
+        /* If there are any children then this is an unbind only, not a
+         * physical disconnection.  The active ports must be disabled
+         * and later on we must call usb_disconnect().  We can't call
+         * it now because we may not hold the hub's device lock.
+         */
+        n = 0;
+        for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
+                if (hdev->children[port1 - 1]) {
+                        ++n;
+                        hub_port_disable(hub, port1, 1);
+                }
+        }
+
+        if (n == 0)
+                kfree(hub);
+        else {
+                /* Reuse the hub->leds work_struct for our own purposes */
+                INIT_WORK(&hub->leds, hub_remove_children_work, hub);
+                schedule_work(&hub->leds);
+                usb_get_dev(hdev);
+        }
 }
 
 static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
@@ -1051,6 +1118,7 @@ void usb_disconnect(struct usb_device **pdev)
         dev_dbg (&udev->dev, "unregistering device\n");
         release_address(udev);
         usbfs_remove_device(udev);
+        usbdev_remove(udev);
         usb_remove_sysfs_dev_files(udev);
 
         /* Avoid races with recursively_mark_NOTATTACHED() */
@@ -1290,6 +1358,7 @@ int usb_new_device(struct usb_device *udev)
         /* USB device state == configured ... usable */
 
         /* add a /proc/bus/usb entry */
+        usbdev_add(udev);
         usbfs_add_device(udev);
         return 0;
 
@@ -1392,7 +1461,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                                         port1, status);
                 else {
                         status = hub_port_wait_reset(hub, port1, udev, delay);
-                        if (status)
+                        if (status && status != -ENOTCONN)
                                 dev_dbg(hub->intfdev,
                                                 "port_wait_reset: err = %d\n",
                                                 status);
@@ -1401,8 +1470,8 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 /* return on disconnect or reset */
                 switch (status) {
                 case 0:
-                        /* TRSTRCY = 10 ms */
-                        msleep(10);
+                        /* TRSTRCY = 10 ms; plus some extra */
+                        msleep(10 + 40);
                         /* FALL THROUGH */
                 case -ENOTCONN:
                 case -ENODEV:
@@ -1428,23 +1497,6 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
         return status;
 }
 
-static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
-{
-        struct usb_device *hdev = hub->hdev;
-        int ret;
-
-        if (hdev->children[port1-1] && set_state) {
-                usb_set_device_state(hdev->children[port1-1],
-                                USB_STATE_NOTATTACHED);
-        }
-        ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
-        if (ret)
-                dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
-                        port1, ret);
-
-        return ret;
-}
-
 /*
  * Disable a port and mark a logical connnect-change event, so that some
  * time later khubd will disconnect() any existing usb_device on the port
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index 53bf5649621e..e7fa9b5a521e 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -157,6 +157,12 @@ enum hub_led_mode {
 
 struct usb_device;
 
+/* Transaction Translator Think Times, in bits */
+#define HUB_TTTT_8_BITS         0x00
+#define HUB_TTTT_16_BITS        0x20
+#define HUB_TTTT_24_BITS        0x40
+#define HUB_TTTT_32_BITS        0x60
+
 /*
  * As of USB 2.0, full/low speed devices are segregated into trees.
  * One type grows from USB 1.1 host controllers (OHCI, UHCI etc).
@@ -170,6 +176,7 @@ struct usb_device;
 struct usb_tt {
         struct usb_device       *hub;   /* upstream highspeed hub */
         int                     multi;  /* true means one TT per port */
+        unsigned                think_time;     /* think time in ns */
 
         /* for control/bulk error recovery (CLEAR_TT_BUFFER) */
         spinlock_t              lock;
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index c3e3a95d3804..640f41e47029 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -728,15 +728,9 @@ int __init usbfs_init(void)
 {
         int retval;
 
-        retval = usb_register(&usbfs_driver);
-        if (retval)
-                return retval;
-
         retval = register_filesystem(&usb_fs_type);
-        if (retval) {
-                usb_deregister(&usbfs_driver);
+        if (retval)
                 return retval;
-        }
 
         /* create mount point for usbfs */
         usbdir = proc_mkdir("usb", proc_bus);
@@ -746,7 +740,6 @@ int __init usbfs_init(void)
 
 void usbfs_cleanup(void)
 {
-        usb_deregister(&usbfs_driver);
         unregister_filesystem(&usb_fs_type);
         if (usbdir)
                 remove_proc_entry("usb", proc_bus);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 88d1b376f67c..c47c8052b486 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -48,7 +48,6 @@ static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)
 
         init_completion(&done);         
         urb->context = &done;
-        urb->transfer_flags |= URB_ASYNC_UNLINK;
         urb->actual_length = 0;
         status = usb_submit_urb(urb, GFP_NOIO);
 
@@ -266,7 +265,9 @@ static void sg_complete (struct urb *urb, struct pt_regs *regs)
                                 continue;
                         if (found) {
                                 status = usb_unlink_urb (io->urbs [i]);
-                                if (status != -EINPROGRESS && status != -EBUSY)
+                                if (status != -EINPROGRESS
+                                                && status != -ENODEV
+                                                && status != -EBUSY)
                                         dev_err (&io->dev->dev,
                                                 "%s, unlink --> %d\n",
                                                 __FUNCTION__, status);
@@ -357,8 +358,7 @@ int usb_sg_init (
         if (!io->urbs)
                 goto nomem;
 
-        urb_flags = URB_ASYNC_UNLINK | URB_NO_TRANSFER_DMA_MAP
-                        | URB_NO_INTERRUPT;
+        urb_flags = URB_NO_TRANSFER_DMA_MAP | URB_NO_INTERRUPT;
         if (usb_pipein (pipe))
                 urb_flags |= URB_SHORT_NOT_OK;
 
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index c0feee25ff0a..c846fefb7386 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -309,9 +309,8 @@ int usb_submit_urb(struct urb *urb, unsigned mem_flags)
         unsigned int    allowed;
 
         /* enforce simple/standard policy */
-        allowed = URB_ASYNC_UNLINK;     // affects later unlinks
-        allowed |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
-        allowed |= URB_NO_INTERRUPT;
+        allowed = (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP |
+                        URB_NO_INTERRUPT);
         switch (temp) {
         case PIPE_BULK:
                 if (is_out)
@@ -400,14 +399,8 @@ int usb_submit_urb(struct urb *urb, unsigned mem_flags)
  * canceled (rather than any other code) and will quickly be removed
  * from host controller data structures.
  *
- * In the past, clearing the URB_ASYNC_UNLINK transfer flag for the
- * URB indicated that the request was synchronous.  This usage is now
- * deprecated; if the flag is clear the call will be forwarded to
- * usb_kill_urb() and the return value will be 0.  In the future, drivers
- * should call usb_kill_urb() directly for synchronous unlinking.
- *
- * When the URB_ASYNC_UNLINK transfer flag for the URB is set, this
- * request is asynchronous.  Success is indicated by returning -EINPROGRESS,
+ * This request is always asynchronous.
+ * Success is indicated by returning -EINPROGRESS,
  * at which time the URB will normally have been unlinked but not yet
  * given back to the device driver.  When it is called, the completion
  * function will see urb->status == -ECONNRESET.  Failure is indicated
@@ -453,17 +446,6 @@ int usb_unlink_urb(struct urb *urb)
 {
         if (!urb)
                 return -EINVAL;
-        if (!(urb->transfer_flags & URB_ASYNC_UNLINK)) {
-#ifdef CONFIG_DEBUG_KERNEL
-                if (printk_ratelimit()) {
-                        printk(KERN_NOTICE "usb_unlink_urb() is deprecated for "
-                                "synchronous unlinks.  Use usb_kill_urb() instead.\n");
-                        WARN_ON(1);
-                }
-#endif
-                usb_kill_urb(urb);
-                return 0;
-        }
         if (!(urb->dev && urb->dev->bus && urb->dev->bus->op))
                 return -ENODEV;
         return urb->dev->bus->op->unlink_urb(urb, -ECONNRESET);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 2cddd8a00437..087af73a59dd 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -65,6 +65,16 @@ static int generic_probe (struct device *dev)
 }
 static int generic_remove (struct device *dev)
 {
+        struct usb_device *udev = to_usb_device(dev);
+
+        /* if this is only an unbind, not a physical disconnect, then
+         * unconfigure the device */
+        if (udev->state == USB_STATE_CONFIGURED)
+                usb_set_configuration(udev, 0);
+
+        /* in case the call failed or the device was suspended */
+        if (udev->state >= USB_STATE_CONFIGURED)
+                usb_disable_device(udev, 0);
         return 0;
 }
 
@@ -912,7 +922,7 @@ int usb_trylock_device(struct usb_device *udev)
  * is neither BINDING nor BOUND.  Rather than sleeping to wait for the
  * lock, the routine polls repeatedly.  This is to prevent deadlock with
  * disconnect; in some drivers (such as usb-storage) the disconnect()
- * callback will block waiting for a device reset to complete.
+ * or suspend() method will block waiting for a device reset to complete.
  *
  * Returns a negative error code for failure, otherwise 1 or 0 to indicate
  * that the device will or will not have to be unlocked.  (0 can be
@@ -922,6 +932,8 @@ int usb_trylock_device(struct usb_device *udev)
 int usb_lock_device_for_reset(struct usb_device *udev,
                 struct usb_interface *iface)
 {
+        unsigned long jiffies_expire = jiffies + HZ;
+
         if (udev->state == USB_STATE_NOTATTACHED)
                 return -ENODEV;
         if (udev->state == USB_STATE_SUSPENDED)
@@ -938,6 +950,12 @@ int usb_lock_device_for_reset(struct usb_device *udev,
         }
 
         while (!usb_trylock_device(udev)) {
+
+                /* If we can't acquire the lock after waiting one second,
+                 * we're probably deadlocked */
+                if (time_after(jiffies, jiffies_expire))
+                        return -EBUSY;
+
                 msleep(15);
                 if (udev->state == USB_STATE_NOTATTACHED)
                         return -ENODEV;
@@ -1478,13 +1496,18 @@ static int __init usb_init(void)
         retval = usb_major_init();
         if (retval)
                 goto major_init_failed;
+        retval = usb_register(&usbfs_driver);
+        if (retval)
+                goto driver_register_failed;
+        retval = usbdev_init();
+        if (retval)
+                goto usbdevice_init_failed;
         retval = usbfs_init();
         if (retval)
                 goto fs_init_failed;
         retval = usb_hub_init();
         if (retval)
                 goto hub_init_failed;
-
         retval = driver_register(&usb_generic_driver);
         if (!retval)
                 goto out;
@@ -1493,7 +1516,11 @@ static int __init usb_init(void)
 hub_init_failed:
         usbfs_cleanup();
 fs_init_failed:
-        usb_major_cleanup();    
+        usbdev_cleanup();
+usbdevice_init_failed:
+        usb_deregister(&usbfs_driver);
+driver_register_failed:
+        usb_major_cleanup();
 major_init_failed:
         usb_host_cleanup();
 host_init_failed:
@@ -1514,6 +1541,8 @@ static void __exit usb_exit(void)
         driver_unregister(&usb_generic_driver);
         usb_major_cleanup();
         usbfs_cleanup();
+        usb_deregister(&usbfs_driver);
+        usbdev_cleanup();
         usb_hub_cleanup();
         usb_host_cleanup();
         bus_unregister(&usb_bus_type);
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 2c690f6d4c18..83d48c8133af 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -37,6 +37,11 @@ extern struct file_operations usbfs_devices_fops;
 extern struct file_operations usbfs_device_file_operations;
 extern void usbfs_conn_disc_event(void);
 
+extern int usbdev_init(void);
+extern void usbdev_cleanup(void);
+extern void usbdev_add(struct usb_device *dev);
+extern void usbdev_remove(struct usb_device *dev);
+extern struct usb_device *usbdev_lookup_minor(int minor);
 
 struct dev_state {
         struct list_head list;      /* state list */
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 8509e955007d..49459e33e952 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -2181,6 +2181,7 @@ eth_bind (struct usb_gadget *gadget)
         u8                      cdc = 1, zlp = 1, rndis = 1;
         struct usb_ep           *in_ep, *out_ep, *status_ep = NULL;
         int                     status = -ENOMEM;
+        int                     gcnum;
 
         /* these flags are only ever cleared; compiler take note */
 #ifndef DEV_CONFIG_CDC
@@ -2194,44 +2195,26 @@ eth_bind (struct usb_gadget *gadget)
          * standard protocol is _strongly_ preferred for interop purposes.
          * (By everyone except Microsoft.)
          */
-        if (gadget_is_net2280 (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
-        } else if (gadget_is_dummy (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0202);
-        } else if (gadget_is_pxa (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0203);
+        if (gadget_is_pxa (gadget)) {
                 /* pxa doesn't support altsettings */
                 cdc = 0;
         } else if (gadget_is_sh(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0204);
                 /* sh doesn't support multiple interfaces or configs */
                 cdc = 0;
                 rndis = 0;
         } else if (gadget_is_sa1100 (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0205);
                 /* hardware can't write zlps */
                 zlp = 0;
                 /* sa1100 CAN do CDC, without status endpoint ... we use
                  * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
                  */
                 cdc = 0;
-        } else if (gadget_is_goku (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0206);
-        } else if (gadget_is_mq11xx (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0207);
-        } else if (gadget_is_omap (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0208);
-        } else if (gadget_is_lh7a40x(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0209);
-        } else if (gadget_is_n9604(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210);
-        } else if (gadget_is_pxa27x(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211);
-        } else if (gadget_is_s3c2410(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212);
-        } else if (gadget_is_at91(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213);
-        } else {
+        }
+
+        gcnum = usb_gadget_controller_number (gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
+        else {
                 /* can't assume CDC works.  don't want to default to
                  * anything less functional on CDC-capable hardware,
                  * so we fail in this case.
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 4f57085619b4..a41d9d4baee3 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -3713,6 +3713,7 @@ static void fsg_unbind(struct usb_gadget *gadget)
 static int __init check_parameters(struct fsg_dev *fsg)
 {
         int     prot;
+        int     gcnum;
 
         /* Store the default values */
         mod_data.transport_type = USB_PR_BULK;
@@ -3724,33 +3725,13 @@ static int __init check_parameters(struct fsg_dev *fsg)
                 mod_data.can_stall = 0;
 
         if (mod_data.release == 0xffff) {       // Parameter wasn't set
-                if (gadget_is_net2280(fsg->gadget))
-                        mod_data.release = 0x0301;
-                else if (gadget_is_dummy(fsg->gadget))
-                        mod_data.release = 0x0302;
-                else if (gadget_is_pxa(fsg->gadget))
-                        mod_data.release = 0x0303;
-                else if (gadget_is_sh(fsg->gadget))
-                        mod_data.release = 0x0304;
-
                 /* The sa1100 controller is not supported */
-
-                else if (gadget_is_goku(fsg->gadget))
-                        mod_data.release = 0x0306;
-                else if (gadget_is_mq11xx(fsg->gadget))
-                        mod_data.release = 0x0307;
-                else if (gadget_is_omap(fsg->gadget))
-                        mod_data.release = 0x0308;
-                else if (gadget_is_lh7a40x(fsg->gadget))
-                        mod_data.release = 0x0309;
-                else if (gadget_is_n9604(fsg->gadget))
-                        mod_data.release = 0x0310;
-                else if (gadget_is_pxa27x(fsg->gadget))
-                        mod_data.release = 0x0311;
-                else if (gadget_is_s3c2410(gadget))
-                        mod_data.release = 0x0312;
-                else if (gadget_is_at91(fsg->gadget))
-                        mod_data.release = 0x0313;
+                if (gadget_is_sa1100(fsg->gadget))
+                        gcnum = -1;
+                else
+                        gcnum = usb_gadget_controller_number(fsg->gadget);
+                if (gcnum >= 0)
+                        mod_data.release = 0x0300 + gcnum;
                 else {
                         WARN(fsg, "controller '%s' not recognized\n",
                                 fsg->gadget->name);
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index ea2eb52c766d..8cbae21d84b9 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -5,6 +5,7 @@
  *
  * This could eventually work like the ARM mach_is_*() stuff, driven by
  * some config file that gets updated as new hardware is supported.
+ * (And avoiding the runtime comparisons in typical one-choice cases.)
  *
  * NOTE:  some of these controller drivers may not be available yet.
  */
@@ -86,7 +87,61 @@
 #define gadget_is_at91(g)       0
 #endif
 
+#ifdef CONFIG_USB_GADGET_IMX
+#define gadget_is_imx(g)        !strcmp("imx_udc", (g)->name)
+#else
+#define gadget_is_imx(g)        0
+#endif
+
 // CONFIG_USB_GADGET_SX2
 // CONFIG_USB_GADGET_AU1X00
 // ...
 
+
+/**
+ * usb_gadget_controller_number - support bcdDevice id convention
+ * @gadget: the controller being driven
+ *
+ * Return a 2-digit BCD value associated with the peripheral controller,
+ * suitable for use as part of a bcdDevice value, or a negative error code.
+ *
+ * NOTE:  this convention is purely optional, and has no meaning in terms of
+ * any USB specification.  If you want to use a different convention in your
+ * gadget driver firmware -- maybe a more formal revision ID -- feel free.
+ *
+ * Hosts see these bcdDevice numbers, and are allowed (but not encouraged!)
+ * to change their behavior accordingly.  For example it might help avoiding
+ * some chip bug.
+ */
+static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
+{
+        if (gadget_is_net2280(gadget))
+                return 0x01;
+        else if (gadget_is_dummy(gadget))
+                return 0x02;
+        else if (gadget_is_pxa(gadget))
+                return 0x03;
+        else if (gadget_is_sh(gadget))
+                return 0x04;
+        else if (gadget_is_sa1100(gadget))
+                return 0x05;
+        else if (gadget_is_goku(gadget))
+                return 0x06;
+        else if (gadget_is_mq11xx(gadget))
+                return 0x07;
+        else if (gadget_is_omap(gadget))
+                return 0x08;
+        else if (gadget_is_lh7a40x(gadget))
+                return 0x09;
+        else if (gadget_is_n9604(gadget))
+                return 0x10;
+        else if (gadget_is_pxa27x(gadget))
+                return 0x11;
+        else if (gadget_is_s3c2410(gadget))
+                return 0x12;
+        else if (gadget_is_at91(gadget))
+                return 0x13;
+        else if (gadget_is_imx(gadget))
+                return 0x14;
+        return -ENOENT;
+}
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index 020815397a49..5c40980a5bd9 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -483,6 +483,7 @@ ep_release (struct inode *inode, struct file *fd)
                 data->state = STATE_EP_DISABLED;
                 data->desc.bDescriptorType = 0;
                 data->hs_desc.bDescriptorType = 0;
+                usb_ep_disable(data->ep);
         }
         put_ep (data);
         return 0;
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 9e4f1c6935a5..c925d9222f53 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -1422,49 +1422,20 @@ static int gs_bind(struct usb_gadget *gadget)
         int ret;
         struct usb_ep *ep;
         struct gs_dev *dev;
+        int gcnum;
 
-        /* device specific */
-        if (gadget_is_net2280(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0001);
-        } else if (gadget_is_pxa(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0002);
-        } else if (gadget_is_sh(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0003);
-                /* sh doesn't support multiple interfaces or configs */
+        /* Some controllers can't support CDC ACM:
+         * - sh doesn't support multiple interfaces or configs;
+         * - sa1100 doesn't have a third interrupt endpoint
+         */
+        if (gadget_is_sh(gadget) || gadget_is_sa1100(gadget))
                 use_acm = 0;
-        } else if (gadget_is_sa1100(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0004);
-                /* sa1100 doesn't support necessary endpoints */
-                use_acm = 0;
-        } else if (gadget_is_goku(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0005);
-        } else if (gadget_is_mq11xx(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0006);
-        } else if (gadget_is_omap(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0007);
-        } else if (gadget_is_lh7a40x(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0008);
-        } else if (gadget_is_n9604(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0009);
-        } else if (gadget_is_pxa27x(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0011);
-        } else if (gadget_is_s3c2410(gadget)) {
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0012);
-        } else if (gadget_is_at91(gadget)) {
+
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
                 gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0013);
-        } else {
+                                cpu_to_le16(GS_VERSION_NUM | gcnum);
+        else {
                 printk(KERN_WARNING "gs_bind: controller '%s' not recognized\n",
                         gadget->name);
                 /* unrecognized, but safe unless bulk is REALLY quirky */
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index bb9b2d94eed5..6890e773b2a2 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -1139,6 +1139,13 @@ zero_bind (struct usb_gadget *gadget)
 {
         struct zero_dev         *dev;
         struct usb_ep           *ep;
+        int                     gcnum;
+
+        /* FIXME this can't yet work right with SH ... it has only
+         * one configuration, numbered one.
+         */
+        if (gadget_is_sh(gadget))
+                return -ENODEV;
 
         /* Bulk-only drivers like this one SHOULD be able to
          * autoconfigure on any sane usb controller driver,
@@ -1161,43 +1168,10 @@ autoconf_fail:
         EP_OUT_NAME = ep->name;
         ep->driver_data = ep;   /* claim */
 
-
-        /*
-         * DRIVER POLICY CHOICE:  you may want to do this differently.
-         * One thing to avoid is reusing a bcdDevice revision code
-         * with different host-visible configurations or behavior
-         * restrictions -- using ep1in/ep2out vs ep1out/ep3in, etc
-         */
-        if (gadget_is_net2280 (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0201);
-        } else if (gadget_is_pxa (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0203);
-#if 0
-        } else if (gadget_is_sh(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0204);
-                /* SH has only one configuration; see "loopdefault" */
-                device_desc.bNumConfigurations = 1;
-                /* FIXME make 1 == default.bConfigurationValue */
-#endif
-        } else if (gadget_is_sa1100 (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0205);
-        } else if (gadget_is_goku (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0206);
-        } else if (gadget_is_mq11xx (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0207);
-        } else if (gadget_is_omap (gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0208);
-        } else if (gadget_is_lh7a40x(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0209);
-        } else if (gadget_is_n9604(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0210);
-        } else if (gadget_is_pxa27x(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0211);
-        } else if (gadget_is_s3c2410(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0212);
-        } else if (gadget_is_at91(gadget)) {
-                device_desc.bcdDevice = __constant_cpu_to_le16 (0x0213);
-        } else {
+        gcnum = usb_gadget_controller_number (gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
+        else {
                 /* gadget zero is so simple (for now, no altsettings) that
                  * it SHOULD NOT have problems with bulk-capable hardware.
                  * so warn about unrcognized controllers, don't panic.
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 149b13fc0a71..b948ffd94f45 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -400,6 +400,23 @@ static int ehci_hc_reset (struct usb_hcd *hcd)
                                 return -EIO;
                         }
                         break;
+                case PCI_VENDOR_ID_NVIDIA:
+                        /* NVidia reports that certain chips don't handle
+                         * QH, ITD, or SITD addresses above 2GB.  (But TD,
+                         * data buffer, and periodic schedule are normal.)
+                         */
+                        switch (pdev->device) {
+                        case 0x003c:    /* MCP04 */
+                        case 0x005b:    /* CK804 */
+                        case 0x00d8:    /* CK8 */
+                        case 0x00e8:    /* CK8S */
+                                if (pci_set_consistent_dma_mask(pdev,
+                                                        DMA_31BIT_MASK) < 0)
+                                        ehci_warn (ehci, "can't enable NVidia "
+                                                "workaround for >2GB RAM\n");
+                                break;
+                        }
+                        break;
                 }
 
                 /* optional debug port, normally in the first BAR */
@@ -549,7 +566,9 @@ static int ehci_start (struct usb_hcd *hcd)
                 hcd->can_wakeup = (port_wake & 1) != 0;
 
                 /* help hc dma work well with cachelines */
-                pci_set_mwi (pdev);
+                retval = pci_set_mwi(pdev);
+                if (retval)
+                        ehci_dbg(ehci, "unable to enable MWI - not fatal.\n");
         }
 #endif
 
@@ -757,12 +776,16 @@ static int ehci_resume (struct usb_hcd *hcd)
         if (time_before (jiffies, ehci->next_statechange))
                 msleep (100);
 
-        /* If any port is suspended, we know we can/must resume the HC. */
+        /* If any port is suspended (or owned by the companion),
+         * we know we can/must resume the HC (and mustn't reset it).
+         */
         for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; ) {
                 u32     status;
                 port--;
                 status = readl (&ehci->regs->port_status [port]);
-                if (status & PORT_SUSPEND) {
+                if (!(status & PORT_POWER))
+                        continue;
+                if (status & (PORT_SUSPEND | PORT_OWNER)) {
                         down (&hcd->self.root_hub->serialize);
                         retval = ehci_hub_resume (hcd);
                         up (&hcd->self.root_hub->serialize);
@@ -1124,8 +1147,7 @@ rescan:
         case QH_STATE_UNLINK:           /* wait for hw to finish? */
 idle_timeout:
                 spin_unlock_irqrestore (&ehci->lock, flags);
-                set_current_state (TASK_UNINTERRUPTIBLE);
-                schedule_timeout (1);
+                schedule_timeout_uninterruptible(1);
                 goto rescan;
         case QH_STATE_IDLE:             /* fully unlinked */
                 if (list_empty (&qh->qtd_list)) {
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 36cc1f2218d5..18d3f2270316 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -54,7 +54,7 @@ static int ehci_hub_suspend (struct usb_hcd *hcd)
         /* suspend any active/unsuspended ports, maybe allow wakeup */
         while (port--) {
                 u32 __iomem     *reg = &ehci->regs->port_status [port];
-                u32             t1 = readl (reg);
+                u32             t1 = readl (reg) & ~PORT_RWC_BITS;
                 u32             t2 = t1;
 
                 if ((t1 & PORT_PE) && !(t1 & PORT_OWNER))
@@ -115,7 +115,8 @@ static int ehci_hub_resume (struct usb_hcd *hcd)
         i = HCS_N_PORTS (ehci->hcs_params);
         while (i--) {
                 temp = readl (&ehci->regs->port_status [i]);
-                temp &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E);
+                temp &= ~(PORT_RWC_BITS
+                        | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E);
                 if (temp & PORT_SUSPEND) {
                         ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
                         temp |= PORT_RESUME;
@@ -128,7 +129,7 @@ static int ehci_hub_resume (struct usb_hcd *hcd)
                 temp = readl (&ehci->regs->port_status [i]);
                 if ((temp & PORT_SUSPEND) == 0)
                         continue;
-                temp &= ~PORT_RESUME;
+                temp &= ~(PORT_RWC_BITS | PORT_RESUME);
                 writel (temp, &ehci->regs->port_status [i]);
                 ehci_vdbg (ehci, "resumed port %d\n", i + 1);
         }
@@ -191,6 +192,7 @@ static int check_reset_complete (
 
                 // what happens if HCS_N_CC(params) == 0 ?
                 port_status |= PORT_OWNER;
+                port_status &= ~PORT_RWC_BITS;
                 writel (port_status, &ehci->regs->port_status [index]);
 
         } else
@@ -233,7 +235,8 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
                 if (temp & PORT_OWNER) {
                         /* don't report this in GetPortStatus */
                         if (temp & PORT_CSC) {
-                                temp &= ~PORT_CSC;
+                                temp &= ~PORT_RWC_BITS;
+                                temp |= PORT_CSC;
                                 writel (temp, &ehci->regs->port_status [i]);
                         }
                         continue;
@@ -343,7 +346,7 @@ static int ehci_hub_control (
                                 &ehci->regs->port_status [wIndex]);
                         break;
                 case USB_PORT_FEAT_C_ENABLE:
-                        writel (temp | PORT_PEC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_PEC,
                                 &ehci->regs->port_status [wIndex]);
                         break;
                 case USB_PORT_FEAT_SUSPEND:
@@ -353,7 +356,8 @@ static int ehci_hub_control (
                                 if ((temp & PORT_PE) == 0)
                                         goto error;
                                 /* resume signaling for 20 msec */
-                                writel ((temp & ~PORT_WAKE_BITS) | PORT_RESUME,
+                                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                                writel (temp | PORT_RESUME,
                                         &ehci->regs->port_status [wIndex]);
                                 ehci->reset_done [wIndex] = jiffies
                                                 + msecs_to_jiffies (20);
@@ -364,15 +368,15 @@ static int ehci_hub_control (
                         break;
                 case USB_PORT_FEAT_POWER:
                         if (HCS_PPC (ehci->hcs_params))
-                                writel (temp & ~PORT_POWER,
+                                writel (temp & ~(PORT_RWC_BITS | PORT_POWER),
                                         &ehci->regs->port_status [wIndex]);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
-                        writel (temp | PORT_CSC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_CSC,
                                 &ehci->regs->port_status [wIndex]);
                         break;
                 case USB_PORT_FEAT_C_OVER_CURRENT:
-                        writel (temp | PORT_OCC,
+                        writel((temp & ~PORT_RWC_BITS) | PORT_OCC,
                                 &ehci->regs->port_status [wIndex]);
                         break;
                 case USB_PORT_FEAT_C_RESET:
@@ -416,7 +420,7 @@ static int ehci_hub_control (
 
                         /* stop resume signaling */
                         temp = readl (&ehci->regs->port_status [wIndex]);
-                        writel (temp & ~PORT_RESUME,
+                        writel (temp & ~(PORT_RWC_BITS | PORT_RESUME),
                                 &ehci->regs->port_status [wIndex]);
                         retval = handshake (
                                         &ehci->regs->port_status [wIndex],
@@ -437,7 +441,7 @@ static int ehci_hub_control (
                         ehci->reset_done [wIndex] = 0;
 
                         /* force reset to complete */
-                        writel (temp & ~PORT_RESET,
+                        writel (temp & ~(PORT_RWC_BITS | PORT_RESET),
                                         &ehci->regs->port_status [wIndex]);
                         /* REVISIT:  some hardware needs 550+ usec to clear
                          * this bit; seems too long to spin routinely...
@@ -500,6 +504,7 @@ static int ehci_hub_control (
                 if (temp & PORT_OWNER)
                         break;
 
+                temp &= ~PORT_RWC_BITS;
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
                         if ((temp & PORT_PE) == 0
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index 20df01a79b2e..940d38ca7d91 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -677,6 +677,9 @@ qh_make (
                                 goto done;
                         }
                 } else {
+                        struct usb_tt   *tt = urb->dev->tt;
+                        int             think_time;
+
                         /* gap is f(FS/LS transfer times) */
                         qh->gap_uf = 1 + usb_calc_bus_time (urb->dev->speed,
                                         is_input, 0, maxp) / (125 * 1000);
@@ -690,6 +693,10 @@ qh_make (
                                 qh->c_usecs = HS_USECS (0);
                         }
 
+                        think_time = tt ? tt->think_time : 0;
+                        qh->tt_usecs = NS_TO_US (think_time +
+                                        usb_calc_bus_time (urb->dev->speed,
+                                        is_input, 0, max_packet (maxp)));
                         qh->period = urb->interval;
                 }
         }
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 4c972b57c7c3..ccc7300baa6d 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -700,6 +700,7 @@ iso_stream_init (
 
         } else {
                 u32             addr;
+                int             think_time;
 
                 addr = dev->ttport << 24;
                 if (!ehci_is_TDI(ehci)
@@ -709,6 +710,9 @@ iso_stream_init (
                 addr |= epnum << 8;
                 addr |= dev->devnum;
                 stream->usecs = HS_USECS_ISO (maxp);
+                think_time = dev->tt ? dev->tt->think_time : 0;
+                stream->tt_usecs = NS_TO_US (think_time + usb_calc_bus_time (
+                                dev->speed, is_input, 1, maxp));
                 if (is_input) {
                         u32     tmp;
 
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index a7542157534c..f34a0516d35f 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -263,6 +263,7 @@ struct ehci_regs {
 #define PORT_PE         (1<<2)          /* port enable */
 #define PORT_CSC        (1<<1)          /* connect status change */
 #define PORT_CONNECT    (1<<0)          /* device connected */
+#define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_OCC)
 } __attribute__ ((packed));
 
 /* Appendix C, Debug port ... intended for use with special "debug devices"
@@ -421,6 +422,7 @@ struct ehci_qh {
         u8                      usecs;          /* intr bandwidth */
         u8                      gap_uf;         /* uframes split/csplit gap */
         u8                      c_usecs;        /* ... split completion bw */
+        u16                     tt_usecs;       /* tt downstream bandwidth */
         unsigned short          period;         /* polling interval */
         unsigned short          start;          /* where polling starts */
 #define NO_FRAME ((unsigned short)~0)                   /* pick new start */
@@ -479,6 +481,7 @@ struct ehci_iso_stream {
          */
         u8                      interval;
         u8                      usecs, c_usecs;
+        u16                     tt_usecs;
         u16                     maxp;
         u16                     raw_mask;
         unsigned                bandwidth;
diff --git a/drivers/usb/host/hc_crisv10.c b/drivers/usb/host/hc_crisv10.c
index 81f8f6b7fdce..a8267cf17db4 100644
--- a/drivers/usb/host/hc_crisv10.c
+++ b/drivers/usb/host/hc_crisv10.c
@@ -178,8 +178,8 @@ static __u8 root_hub_hub_des[] =
         0xff   /*  __u8  PortPwrCtrlMask; *** 7 ports max *** */
 };
 
-static struct timer_list bulk_start_timer = TIMER_INITIALIZER(NULL, 0, 0);
-static struct timer_list bulk_eot_timer = TIMER_INITIALIZER(NULL, 0, 0);
+static DEFINE_TIMER(bulk_start_timer, NULL, 0, 0);
+static DEFINE_TIMER(bulk_eot_timer, NULL, 0, 0);
 
 /* We want the start timer to expire before the eot timer, because the former might start
    traffic, thus making it unnecessary for the latter to time out. */
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 75128c371800..41bbae83fc71 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -83,7 +83,7 @@
 #include "../core/hcd.h"
 #include "isp116x.h"
 
-#define DRIVER_VERSION  "08 Apr 2005"
+#define DRIVER_VERSION  "05 Aug 2005"
 #define DRIVER_DESC     "ISP116x USB Host Controller Driver"
 
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -629,14 +629,12 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                         ERR("Unrecoverable error\n");
                         /* What should we do here? Reset?  */
                 }
-                if (intstat & HCINT_RHSC) {
-                        isp116x->rhstatus =
-                            isp116x_read_reg32(isp116x, HCRHSTATUS);
-                        isp116x->rhport[0] =
-                            isp116x_read_reg32(isp116x, HCRHPORT1);
-                        isp116x->rhport[1] =
-                            isp116x_read_reg32(isp116x, HCRHPORT2);
-                }
+                if (intstat & HCINT_RHSC)
+                        /* When root hub or any of its ports is going
+                           to come out of suspend, it may take more
+                           than 10ms for status bits to stabilize. */
+                        mod_timer(&hcd->rh_timer, jiffies
+                                  + msecs_to_jiffies(20) + 1);
                 if (intstat & HCINT_RD) {
                         DBG("---- remote wakeup\n");
                         schedule_work(&isp116x->rh_resume);
@@ -925,20 +923,27 @@ static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
         int ports, i, changed = 0;
+        unsigned long flags;
 
         if (!HC_IS_RUNNING(hcd->state))
                 return -ESHUTDOWN;
 
-        ports = isp116x->rhdesca & RH_A_NDP;
+        /* Report no status change now, if we are scheduled to be
+           called later */
+        if (timer_pending(&hcd->rh_timer))
+                return 0;
 
-        /* init status */
+        ports = isp116x->rhdesca & RH_A_NDP;
+        spin_lock_irqsave(&isp116x->lock, flags);
+        isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
         if (isp116x->rhstatus & (RH_HS_LPSC | RH_HS_OCIC))
                 buf[0] = changed = 1;
         else
                 buf[0] = 0;
 
         for (i = 0; i < ports; i++) {
-                u32 status = isp116x->rhport[i];
+                u32 status = isp116x->rhport[i] =
+                    isp116x_read_reg32(isp116x, i ? HCRHPORT2 : HCRHPORT1);
 
                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
                               | RH_PS_OCIC | RH_PS_PRSC)) {
@@ -947,6 +952,7 @@ static int isp116x_hub_status_data(struct usb_hcd *hcd, char *buf)
                         continue;
                 }
         }
+        spin_unlock_irqrestore(&isp116x->lock, flags);
         return changed;
 }
 
@@ -1463,10 +1469,6 @@ static int isp116x_sw_reset(struct isp116x *isp116x)
         return ret;
 }
 
-/*
-  Reset. Tries to perform platform-specific hardware
-  reset first; falls back to software reset.
-*/
 static int isp116x_reset(struct usb_hcd *hcd)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
@@ -1474,17 +1476,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
         u16 clkrdy = 0;
         int ret = 0, timeout = 15 /* ms */ ;
 
-        if (isp116x->board && isp116x->board->reset) {
-                /* Hardware reset */
-                isp116x->board->reset(hcd->self.controller, 1);
-                msleep(10);
-                if (isp116x->board->clock)
-                        isp116x->board->clock(hcd->self.controller, 1);
-                msleep(1);
-                isp116x->board->reset(hcd->self.controller, 0);
-        } else
-                ret = isp116x_sw_reset(isp116x);
-
+        ret = isp116x_sw_reset(isp116x);
         if (ret)
                 return ret;
 
@@ -1501,10 +1493,7 @@ static int isp116x_reset(struct usb_hcd *hcd)
                 ERR("Clock not ready after 20ms\n");
                 /* After sw_reset the clock won't report to be ready, if
                    H_WAKEUP pin is high. */
-                if (!isp116x->board || !isp116x->board->reset)
-                        ERR("The driver does not support hardware wakeup.\n");
-                        ERR("Please make sure that the H_WAKEUP pin "
-                                "is pulled low!\n");
+                ERR("Please make sure that the H_WAKEUP pin is pulled low!\n");
                 ret = -ENODEV;
         }
         return ret;
@@ -1527,15 +1516,7 @@ static void isp116x_stop(struct usb_hcd *hcd)
         isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
         spin_unlock_irqrestore(&isp116x->lock, flags);
 
-        /* Put the chip into reset state */
-        if (isp116x->board && isp116x->board->reset)
-                isp116x->board->reset(hcd->self.controller, 0);
-        else
-                isp116x_sw_reset(isp116x);
-
-        /* Stop the clock */
-        if (isp116x->board && isp116x->board->clock)
-                isp116x->board->clock(hcd->self.controller, 0);
+        isp116x_sw_reset(isp116x);
 }
 
 /*
@@ -1561,6 +1542,9 @@ static int isp116x_start(struct usb_hcd *hcd)
                 return -ENODEV;
         }
 
+        /* To be removed in future */
+        hcd->uses_new_polling = 1;
+
         isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
         isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
 
@@ -1569,7 +1553,7 @@ static int isp116x_start(struct usb_hcd *hcd)
         if (board->sel15Kres)
                 val |= HCHWCFG_15KRSEL;
         /* Remote wakeup won't work without working clock */
-        if (board->clknotstop || board->remote_wakeup_enable)
+        if (board->remote_wakeup_enable)
                 val |= HCHWCFG_CLKNOTSTOP;
         if (board->oc_enable)
                 val |= HCHWCFG_ANALOG_OC;
@@ -1580,16 +1564,13 @@ static int isp116x_start(struct usb_hcd *hcd)
         isp116x_write_reg16(isp116x, HCHWCFG, val);
 
         /* ----- Root hub conf */
-        val = 0;
-        /* AN10003_1.pdf recommends NPS to be always 1 */
-        if (board->no_power_switching)
-                val |= RH_A_NPS;
-        if (board->power_switching_mode)
-                val |= RH_A_PSM;
-        if (board->potpg)
-                val |= (board->potpg << 24) & RH_A_POTPGT;
-        else
-                val |= (25 << 24) & RH_A_POTPGT;
+        val = (25 << 24) & RH_A_POTPGT;
+        /* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
+           be always set. Yet, instead, we request individual port
+           power switching. */
+        val |= RH_A_PSM;
+        /* Report overcurrent per port */
+        val |= RH_A_OCPM;
         isp116x_write_reg32(isp116x, HCRHDESCA, val);
         isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
 
@@ -1619,9 +1600,6 @@ static int isp116x_start(struct usb_hcd *hcd)
 
         /* Go operational */
         val = HCCONTROL_USB_OPER;
-        /* Remote wakeup connected - NOT SUPPORTED */
-        /*  if (board->remote_wakeup_connected)
-           val |= HCCONTROL_RWC;  */
         if (board->remote_wakeup_enable)
                 val |= HCCONTROL_RWE;
         isp116x_write_reg32(isp116x, HCCONTROL, val);
@@ -1670,7 +1648,7 @@ static int __init_or_module isp116x_remove(struct device *dev)
         struct platform_device *pdev;
         struct resource *res;
 
-        if(!hcd)
+        if (!hcd)
                 return 0;
         isp116x = hcd_to_isp116x(hcd);
         pdev = container_of(dev, struct platform_device, dev);
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 447f488f5d93..7924c74f958e 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -228,23 +228,22 @@ ohci_dump_roothub (
         char **next,
         unsigned *size)
 {
-        u32                     temp, ndp, i;
+        u32                     temp, i;
 
         temp = roothub_a (controller);
         if (temp == ~(u32)0)
                 return;
-        ndp = (temp & RH_A_NDP);
 
         if (verbose) {
                 ohci_dbg_sw (controller, next, size,
-                        "roothub.a %08x POTPGT=%d%s%s%s%s%s NDP=%d\n", temp,
+                        "roothub.a %08x POTPGT=%d%s%s%s%s%s NDP=%d(%d)\n", temp,
                         ((temp & RH_A_POTPGT) >> 24) & 0xff,
                         (temp & RH_A_NOCP) ? " NOCP" : "",
                         (temp & RH_A_OCPM) ? " OCPM" : "",
                         (temp & RH_A_DT) ? " DT" : "",
                         (temp & RH_A_NPS) ? " NPS" : "",
                         (temp & RH_A_PSM) ? " PSM" : "",
-                        ndp
+                        (temp & RH_A_NDP), controller->num_ports
                         );
                 temp = roothub_b (controller);
                 ohci_dbg_sw (controller, next, size,
@@ -266,7 +265,7 @@ ohci_dump_roothub (
                         );
         }
 
-        for (i = 0; i < ndp; i++) {
+        for (i = 0; i < controller->num_ports; i++) {
                 temp = roothub_portstatus (controller, i);
                 dbg_port_sw (controller, i, temp, next, size);
         }
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 56b43f2a0e52..67c1aa5eb1c1 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -382,8 +382,7 @@ sanitize:
                         goto sanitize;
                 }
                 spin_unlock_irqrestore (&ohci->lock, flags);
-                set_current_state (TASK_UNINTERRUPTIBLE);
-                schedule_timeout (1);
+                schedule_timeout_uninterruptible(1);
                 goto rescan;
         case ED_IDLE:           /* fully unlinked */
                 if (list_empty (&ed->td_list)) {
@@ -485,6 +484,10 @@ static int ohci_init (struct ohci_hcd *ohci)
         // flush the writes
         (void) ohci_readl (ohci, &ohci->regs->control);
 
+        /* Read the number of ports unless overridden */
+        if (ohci->num_ports == 0)
+                ohci->num_ports = roothub_a(ohci) & RH_A_NDP;
+
         if (ohci->hcca)
                 return 0;
 
@@ -561,10 +564,8 @@ static int ohci_run (struct ohci_hcd *ohci)
         msleep(temp);
         temp = roothub_a (ohci);
         if (!(temp & RH_A_NPS)) {
-                unsigned ports = temp & RH_A_NDP; 
-
                 /* power down each port */
-                for (temp = 0; temp < ports; temp++)
+                for (temp = 0; temp < ohci->num_ports; temp++)
                         ohci_writel (ohci, RH_PS_LSDA,
                                 &ohci->regs->roothub.portstatus [temp]);
         }
@@ -720,6 +721,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd, struct pt_regs *ptregs)
 
         if (ints & OHCI_INTR_RD) {
                 ohci_vdbg (ohci, "resume detect\n");
+                ohci_writel (ohci, OHCI_INTR_RD, &regs->intrstatus);
                 if (hcd->state != HC_STATE_QUIESCING)
                         schedule_work(&ohci->rh_resume);
         }
@@ -861,7 +863,7 @@ static int ohci_restart (struct ohci_hcd *ohci)
                  * and that if we try to turn them back on the root hub
                  * will respond to CSC processing.
                  */
-                i = roothub_a (ohci) & RH_A_NDP;
+                i = ohci->num_ports;
                 while (i--)
                         ohci_writel (ohci, RH_PS_PSS,
                                 &ohci->regs->roothub.portstatus [temp]);
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 83ca4549a50e..ce7b28da7a15 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -184,7 +184,7 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
         if (status != -EINPROGRESS)
                 return status;
 
-        temp = roothub_a (ohci) & RH_A_NDP;
+        temp = ohci->num_ports;
         enables = 0;
         while (temp--) {
                 u32 stat = ohci_readl (ohci,
@@ -304,7 +304,7 @@ static int
 ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
 {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ports, i, changed = 0, length = 1;
+        int             i, changed = 0, length = 1;
         int             can_suspend = hcd->can_wakeup;
         unsigned long   flags;
 
@@ -319,9 +319,10 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
                 goto done;
         }
 
-        ports = roothub_a (ohci) & RH_A_NDP; 
-        if (ports > MAX_ROOT_PORTS) {
-                ohci_err (ohci, "bogus NDP=%d, rereads as NDP=%d\n", ports,
+        /* undocumented erratum seen on at least rev D */
+        if ((ohci->flags & OHCI_QUIRK_AMD756)
+                        && (roothub_a (ohci) & RH_A_NDP) > MAX_ROOT_PORTS) {
+                ohci_warn (ohci, "bogus NDP, rereads as NDP=%d\n",
                           ohci_readl (ohci, &ohci->regs->roothub.a) & RH_A_NDP);
                 /* retry later; "should not happen" */
                 goto done;
@@ -332,13 +333,13 @@ ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
                 buf [0] = changed = 1;
         else
                 buf [0] = 0;
-        if (ports > 7) {
+        if (ohci->num_ports > 7) {
                 buf [1] = 0;
                 length++;
         }
 
         /* look at each port */
-        for (i = 0; i < ports; i++) {
+        for (i = 0; i < ohci->num_ports; i++) {
                 u32     status = roothub_portstatus (ohci, i);
 
                 if (status & (RH_PS_CSC | RH_PS_PESC | RH_PS_PSSC
@@ -395,15 +396,14 @@ ohci_hub_descriptor (
         struct usb_hub_descriptor       *desc
 ) {
         u32             rh = roothub_a (ohci);
-        int             ports = rh & RH_A_NDP; 
         u16             temp;
 
         desc->bDescriptorType = 0x29;
         desc->bPwrOn2PwrGood = (rh & RH_A_POTPGT) >> 24;
         desc->bHubContrCurrent = 0;
 
-        desc->bNbrPorts = ports;
-        temp = 1 + (ports / 8);
+        desc->bNbrPorts = ohci->num_ports;
+        temp = 1 + (ohci->num_ports / 8);
         desc->bDescLength = 7 + 2 * temp;
 
         temp = 0;
@@ -421,7 +421,7 @@ ohci_hub_descriptor (
         rh = roothub_b (ohci);
         memset(desc->bitmap, 0xff, sizeof(desc->bitmap));
         desc->bitmap [0] = rh & RH_B_DR;
-        if (ports > 7) {
+        if (ohci->num_ports > 7) {
                 desc->bitmap [1] = (rh & RH_B_DR) >> 8;
                 desc->bitmap [2] = 0xff;
         } else
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 17964c39d06a..251533363028 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -14,8 +14,6 @@
  * This file is licenced under the GPL.
  */
 
-#include <asm/usb.h>
-
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
 
@@ -23,9 +21,7 @@
  * usb_hcd_ppc_soc_probe - initialize On-Chip HCDs
  * Context: !in_interrupt()
  *
- * Allocates basic resources for this USB host controller, and
- * then invokes the start() method for the HCD associated with it
- * through the hotplug entry's driver_data.
+ * Allocates basic resources for this USB host controller.
  *
  * Store this function in the HCD's struct pci_driver as probe().
  */
@@ -37,7 +33,6 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
         struct ohci_hcd *ohci;
         struct resource *res;
         int irq;
-        struct usb_hcd_platform_data *pd = pdev->dev.platform_data;
 
         pr_debug("initializing PPC-SOC USB Controller\n");
 
@@ -73,9 +68,6 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
                 goto err2;
         }
 
-        if (pd->start && (retval = pd->start(pdev)))
-                goto err3;
-
         ohci = hcd_to_ohci(hcd);
         ohci->flags |= OHCI_BIG_ENDIAN;
         ohci_hcd_init(ohci);
@@ -85,9 +77,7 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
                 return retval;
 
         pr_debug("Removing PPC-SOC USB Controller\n");
-        if (pd && pd->stop)
-                pd->stop(pdev);
- err3:
+
         iounmap(hcd->regs);
  err2:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
@@ -105,25 +95,21 @@ static int usb_hcd_ppc_soc_probe(const struct hc_driver *driver,
  * @pdev: USB Host Controller being removed
  * Context: !in_interrupt()
  *
- * Reverses the effect of usb_hcd_ppc_soc_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
+ * Reverses the effect of usb_hcd_ppc_soc_probe().
+ * It is always called from a thread
  * context, normally "rmmod", "apmd", or something similar.
  *
  */
 static void usb_hcd_ppc_soc_remove(struct usb_hcd *hcd,
                 struct platform_device *pdev)
 {
-        struct usb_hcd_platform_data *pd = pdev->dev.platform_data;
-
         usb_remove_hcd(hcd);
 
         pr_debug("stopping PPC-SOC USB Controller\n");
-        if (pd && pd->stop)
-                pd->stop(pdev);
 
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_hcd_put(hcd);
+        usb_put_hcd(hcd);
 }
 
 static int __devinit
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index e5bc1789d18a..2fdb262d4726 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -75,33 +75,6 @@ static int pxa27x_ohci_select_pmm( int mode )
         return 0;
 }
 
-/*
-  If you select PMM_PERPORT_MODE, you should set the port power
- */
-static int pxa27x_ohci_set_port_power( int port )
-{
-        if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE)
-             && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
-                UHCRHPS(port) |= 0x100;
-                return 0;
-        }
-        return -1;
-}
-
-/*
-  If you select PMM_PERPORT_MODE, you should set the port power
- */
-static int pxa27x_ohci_clear_port_power( int port )
-{
-        if ( (pxa27x_ohci_pmm_state==PMM_PERPORT_MODE) 
-             && (port>0) && (port<PXA_UHC_MAX_PORTNUM) ) {
-                UHCRHPS(port) |= 0x200;
-                return 0;
-        }
-         
-        return -1;
-}
-
 extern int usb_disabled(void);
 
 /*-------------------------------------------------------------------------*/
@@ -130,11 +103,17 @@ static void pxa27x_start_hc(struct platform_device *dev)
                    Polarity Low to active low. Supply power to USB ports. */
                 UHCHR = (UHCHR | UHCHR_PCPL | UHCHR_PSPL) &
                         ~(UHCHR_SSEP1 | UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE);
+
+                pxa27x_ohci_pmm_state = PMM_PERPORT_MODE;
         }
 
         UHCHR &= ~UHCHR_SSE;
 
         UHCHIE = (UHCHIE_UPRIE | UHCHIE_RWIE);
+
+        /* Clear any OTG Pin Hold */
+        if (PSSR & PSSR_OTGPH)
+                PSSR |= PSSR_OTGPH;
 }
 
 static void pxa27x_stop_hc(struct platform_device *dev)
@@ -198,17 +177,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver,
         pxa27x_start_hc(dev);
 
         /* Select Power Management Mode */
-        pxa27x_ohci_select_pmm( PMM_PERPORT_MODE );
-
-        /* If choosing PMM_PERPORT_MODE, we should set the port power before we use it. */
-        if (pxa27x_ohci_set_port_power(1) < 0)
-                printk(KERN_ERR "Setting port 1 power failed.\n");
-
-        if (pxa27x_ohci_clear_port_power(2) < 0)
-                printk(KERN_ERR "Setting port 2 power failed.\n");
-
-        if (pxa27x_ohci_clear_port_power(3) < 0)
-                printk(KERN_ERR "Setting port 3 power failed.\n");
+        pxa27x_ohci_select_pmm(pxa27x_ohci_pmm_state);
 
         ohci_hcd_init(hcd_to_ohci(hcd));
 
@@ -258,6 +227,9 @@ ohci_pxa27x_start (struct usb_hcd *hcd)
 
         ohci_dbg (ohci, "ohci_pxa27x_start, ohci:%p", ohci);
 
+        /* The value of NDP in roothub_a is incorrect on this hardware */
+        ohci->num_ports = 3;
+
         if ((ret = ohci_init(ohci)) < 0)
                 return ret;
 
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index e9401662503c..3d9bcf78a9a4 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -129,7 +129,7 @@ static void s3c2410_usb_set_power(struct s3c2410_hcd_info *info,
 
         if (info->power_control != NULL) {
                 info->port[port-1].power = to;
-                (info->power_control)(port, to);
+                (info->power_control)(port-1, to);
         }
 }
 
@@ -339,8 +339,8 @@ int usb_hcd_s3c2410_probe (const struct hc_driver *driver,
         struct usb_hcd *hcd = NULL;
         int retval;
 
-        s3c2410_usb_set_power(dev->dev.platform_data, 0, 1);
         s3c2410_usb_set_power(dev->dev.platform_data, 1, 1);
+        s3c2410_usb_set_power(dev->dev.platform_data, 2, 1);
 
         hcd = usb_create_hcd(driver, &dev->dev, "s3c24xx");
         if (hcd == NULL)
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 71cdd2262860..8a9b9d9209e9 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -383,6 +383,7 @@ struct ohci_hcd {
         /*
          * driver state
          */
+        int                     num_ports;
         int                     load [NUM_INTS];
         u32                     hc_control;     /* copy of hc control reg */
         unsigned long           next_statechange;       /* suspend/resume */
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 0d5d2545bf07..0c024898cbea 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -97,14 +97,9 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
 /* to make sure it doesn't hog all of the bandwidth */
 #define DEPTH_INTERVAL 5
 
-static inline void restart_timer(struct uhci_hcd *uhci)
-{
-        mod_timer(&uhci->stall_timer, jiffies + msecs_to_jiffies(100));
-}
-
-#include "uhci-hub.c"
 #include "uhci-debug.c"
 #include "uhci-q.c"
+#include "uhci-hub.c"
 
 /*
  * Make sure the controller is completely inactive, unable to
@@ -160,7 +155,6 @@ static void hc_died(struct uhci_hcd *uhci)
 {
         reset_hc(uhci);
         uhci->hc_inaccessible = 1;
-        del_timer(&uhci->stall_timer);
 }
 
 /*
@@ -287,8 +281,11 @@ __acquires(uhci->lock)
         /* Enable resume-detect interrupts if they work.
          * Then enter Global Suspend mode, still configured.
          */
-        int_enable = (resume_detect_interrupts_are_broken(uhci) ?
-                        0 : USBINTR_RESUME);
+        uhci->working_RD = 1;
+        int_enable = USBINTR_RESUME;
+        if (resume_detect_interrupts_are_broken(uhci)) {
+                uhci->working_RD = int_enable = 0;
+        }
         outw(int_enable, uhci->io_addr + USBINTR);
         outw(USBCMD_EGSM | USBCMD_CF, uhci->io_addr + USBCMD);
         mb();
@@ -315,7 +312,6 @@ __acquires(uhci->lock)
 
         uhci->rh_state = new_state;
         uhci->is_stopped = UHCI_IS_STOPPED;
-        del_timer(&uhci->stall_timer);
         uhci_to_hcd(uhci)->poll_rh = !int_enable;
 
         uhci_scan_schedule(uhci, NULL);
@@ -335,7 +331,6 @@ static void start_rh(struct uhci_hcd *uhci)
         mb();
         uhci->rh_state = UHCI_RH_RUNNING;
         uhci_to_hcd(uhci)->poll_rh = 1;
-        restart_timer(uhci);
 }
 
 static void wakeup_rh(struct uhci_hcd *uhci)
@@ -374,20 +369,6 @@ __acquires(uhci->lock)
         mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
 }
 
-static void stall_callback(unsigned long _uhci)
-{
-        struct uhci_hcd *uhci = (struct uhci_hcd *) _uhci;
-        unsigned long flags;
-
-        spin_lock_irqsave(&uhci->lock, flags);
-        uhci_scan_schedule(uhci, NULL);
-        check_fsbr(uhci);
-
-        if (!uhci->is_stopped)
-                restart_timer(uhci);
-        spin_unlock_irqrestore(&uhci->lock, flags);
-}
-
 static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
 {
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
@@ -418,8 +399,10 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                                         "host controller halted, "
                                         "very bad!\n");
                                 hc_died(uhci);
-                                spin_unlock_irqrestore(&uhci->lock, flags);
-                                return IRQ_HANDLED;
+
+                                /* Force a callback in case there are
+                                 * pending unlinks */
+                                mod_timer(&hcd->rh_timer, jiffies);
                         }
                         spin_unlock_irqrestore(&uhci->lock, flags);
                 }
@@ -427,10 +410,11 @@ static irqreturn_t uhci_irq(struct usb_hcd *hcd, struct pt_regs *regs)
 
         if (status & USBSTS_RD)
                 usb_hcd_poll_rh_status(hcd);
-
-        spin_lock_irqsave(&uhci->lock, flags);
-        uhci_scan_schedule(uhci, regs);
-        spin_unlock_irqrestore(&uhci->lock, flags);
+        else {
+                spin_lock_irqsave(&uhci->lock, flags);
+                uhci_scan_schedule(uhci, regs);
+                spin_unlock_irqrestore(&uhci->lock, flags);
+        }
 
         return IRQ_HANDLED;
 }
@@ -595,10 +579,6 @@ static int uhci_start(struct usb_hcd *hcd)
 
         init_waitqueue_head(&uhci->waitqh);
 
-        init_timer(&uhci->stall_timer);
-        uhci->stall_timer.function = stall_callback;
-        uhci->stall_timer.data = (unsigned long) uhci;
-
         uhci->fl = dma_alloc_coherent(uhci_dev(uhci), sizeof(*uhci->fl),
                         &dma_handle, 0);
         if (!uhci->fl) {
@@ -745,11 +725,11 @@ static void uhci_stop(struct usb_hcd *hcd)
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
 
         spin_lock_irq(&uhci->lock);
-        reset_hc(uhci);
+        if (!uhci->hc_inaccessible)
+                reset_hc(uhci);
         uhci_scan_schedule(uhci, NULL);
         spin_unlock_irq(&uhci->lock);
 
-        del_timer_sync(&uhci->stall_timer);
         release_uhci(uhci);
 }
 
@@ -811,13 +791,12 @@ static int uhci_suspend(struct usb_hcd *hcd, pm_message_t message)
          */
         pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP, 0);
         uhci->hc_inaccessible = 1;
+        hcd->poll_rh = 0;
 
         /* FIXME: Enable non-PME# remote wakeup? */
 
 done:
         spin_unlock_irq(&uhci->lock);
-        if (rc == 0)
-                del_timer_sync(&hcd->rh_timer);
         return rc;
 }
 
@@ -850,8 +829,11 @@ static int uhci_resume(struct usb_hcd *hcd)
 
         spin_unlock_irq(&uhci->lock);
 
-        if (hcd->poll_rh)
+        if (!uhci->working_RD) {
+                /* Suspended root hub needs to be polled */
+                hcd->poll_rh = 1;
                 usb_hcd_poll_rh_status(hcd);
+        }
         return 0;
 }
 #endif
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index bf9c5f9b508b..282f40b75881 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -345,9 +345,6 @@ enum uhci_rh_state {
 
 /*
  * This describes the full uhci information.
- *
- * Note how the "proper" USB information is just
- * a subset of what the full implementation needs.
  */
 struct uhci_hcd {
 
@@ -360,8 +357,6 @@ struct uhci_hcd {
         struct dma_pool *qh_pool;
         struct dma_pool *td_pool;
 
-        struct usb_bus *bus;
-
         struct uhci_td *term_td;        /* Terminating TD, see UHCI bug */
         struct uhci_qh *skelqh[UHCI_NUM_SKELQH];        /* Skeleton QH's */
 
@@ -380,6 +375,8 @@ struct uhci_hcd {
         unsigned int scan_in_progress:1;        /* Schedule scan is running */
         unsigned int need_rescan:1;             /* Redo the schedule scan */
         unsigned int hc_inaccessible:1;         /* HC is suspended or dead */
+        unsigned int working_RD:1;              /* Suspended root hub doesn't
+                                                   need to be polled */
 
         /* Support for port suspend/resume/reset */
         unsigned long port_c_suspend;           /* Bit-arrays of ports */
@@ -405,9 +402,7 @@ struct uhci_hcd {
         /* List of URB's awaiting completion callback */
         struct list_head complete_list;         /* P: uhci->lock */
 
-        int rh_numports;
-
-        struct timer_list stall_timer;
+        int rh_numports;                        /* Number of root-hub ports */
 
         wait_queue_head_t waitqh;               /* endpoint_disable waiters */
 };
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 4eace2b19ddb..a71e48a66805 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -145,15 +145,16 @@ static int uhci_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
         unsigned long flags;
-        int status;
+        int status = 0;
 
         spin_lock_irqsave(&uhci->lock, flags);
-        if (uhci->hc_inaccessible) {
-                status = 0;
-                goto done;
-        }
 
+        uhci_scan_schedule(uhci, NULL);
+        if (uhci->hc_inaccessible)
+                goto done;
+        check_fsbr(uhci);
         uhci_check_ports(uhci);
+
         status = get_hub_status_data(uhci, buf);
 
         switch (uhci->rh_state) {
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index bbb36cd6ed61..ea0d168a8c67 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -33,7 +33,7 @@ static void uhci_free_pending_tds(struct uhci_hcd *uhci);
 static inline void uhci_set_next_interrupt(struct uhci_hcd *uhci)
 {
         if (uhci->is_stopped)
-                mod_timer(&uhci->stall_timer, jiffies);
+                mod_timer(&uhci_to_hcd(uhci)->rh_timer, jiffies);
         uhci->term_td->status |= cpu_to_le32(TD_CTRL_IOC); 
 }
 
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index 298e4a25e3d3..1e53934907c0 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -230,6 +230,20 @@ config USB_EGALAX
           To compile this driver as a module, choose M here: the
           module will be called touchkitusb.
 
+config USB_YEALINK
+        tristate "Yealink usb-p1k voip phone"
+        depends on USB && INPUT && EXPERIMENTAL
+        ---help---
+          Say Y here if you want to enable keyboard and LCD functions of the
+          Yealink usb-p1k usb phones. The audio part is enabled by the generic
+          usb sound driver, so you might want to enable that as well.
+
+          For information about how to use these additional functions, see
+          <file:Documentation/input/yealink.txt>.
+
+          To compile this driver as a module, choose M here: the module will be
+          called yealink.
+
 config USB_XPAD
         tristate "X-Box gamepad support"
         depends on USB && INPUT
@@ -272,3 +286,23 @@ config USB_KEYSPAN_REMOTE
 
           To compile this driver as a module, choose M here: the module will
           be called keyspan_remote.
+
+config USB_APPLETOUCH
+        tristate "Apple USB Touchpad support"
+        depends on USB && INPUT
+        ---help---
+          Say Y here if you want to use an Apple USB Touchpad.
+
+          These are the touchpads that can be found on post-February 2005
+          Apple Powerbooks (prior models have a Synaptics touchpad connected
+          to the ADB bus).
+
+          This driver provides a basic mouse driver but can be interfaced
+          with the synaptics X11 driver to provide acceleration and
+          scrolling in X11.
+
+          For further information, see
+          <file:Documentation/input/appletouch.txt>.
+
+          To compile this driver as a module, choose M here: the
+          module will be called appletouch.
diff --git a/drivers/usb/input/Makefile b/drivers/usb/input/Makefile
index f1547be632d4..5e03b93f29f6 100644
--- a/drivers/usb/input/Makefile
+++ b/drivers/usb/input/Makefile
@@ -39,4 +39,6 @@ obj-$(CONFIG_USB_EGALAX)	+= touchkitusb.o
 obj-$(CONFIG_USB_POWERMATE)     += powermate.o
 obj-$(CONFIG_USB_WACOM)         += wacom.o
 obj-$(CONFIG_USB_ACECAD)        += acecad.o
+obj-$(CONFIG_USB_YEALINK)       += yealink.o
 obj-$(CONFIG_USB_XPAD)          += xpad.o
+obj-$(CONFIG_USB_APPLETOUCH)    += appletouch.o
diff --git a/drivers/usb/input/appletouch.c b/drivers/usb/input/appletouch.c
new file mode 100644
index 000000000000..e03c1c567a14
--- /dev/null
+++ b/drivers/usb/input/appletouch.c
@@ -0,0 +1,469 @@
+/*
+ * Apple USB Touchpad (for post-February 2005 PowerBooks) driver
+ *
+ * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 2005      Johannes Berg (johannes@sipsolutions.net)
+ * Copyright (C) 2005      Stelian Pop (stelian@popies.net)
+ * Copyright (C) 2005      Frank Arnold (frank@scirocco-5v-turbo.de)
+ * Copyright (C) 2005      Peter Osterlund (petero2@telia.com)
+ *
+ * Thanks to Alex Harper <basilisk@foobox.net> for his inputs.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/input.h>
+#include <linux/usb_input.h>
+
+/* Apple has powerbooks which have the keyboard with different Product IDs */
+#define APPLE_VENDOR_ID         0x05AC
+
+#define ATP_DEVICE(prod)                                        \
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE |             \
+                       USB_DEVICE_ID_MATCH_INT_CLASS |          \
+                       USB_DEVICE_ID_MATCH_INT_PROTOCOL,        \
+        .idVendor = APPLE_VENDOR_ID,                            \
+        .idProduct = (prod),                                    \
+        .bInterfaceClass = 0x03,                                \
+        .bInterfaceProtocol = 0x02
+
+/* table of devices that work with this driver */
+static struct usb_device_id atp_table [] = {
+        { ATP_DEVICE(0x020E) },
+        { ATP_DEVICE(0x020F) },
+        { ATP_DEVICE(0x030A) },
+        { ATP_DEVICE(0x030B) },
+        { }                                     /* Terminating entry */
+};
+MODULE_DEVICE_TABLE (usb, atp_table);
+
+/* size of a USB urb transfer */
+#define ATP_DATASIZE    81
+
+/*
+ * number of sensors. Note that only 16 instead of 26 X (horizontal)
+ * sensors exist on 12" and 15" PowerBooks. All models have 16 Y
+ * (vertical) sensors.
+ */
+#define ATP_XSENSORS    26
+#define ATP_YSENSORS    16
+
+/* amount of fuzz this touchpad generates */
+#define ATP_FUZZ        16
+
+/* maximum pressure this driver will report */
+#define ATP_PRESSURE    300
+/*
+ * multiplication factor for the X and Y coordinates.
+ * We try to keep the touchpad aspect ratio while still doing only simple
+ * arithmetics.
+ * The factors below give coordinates like:
+ *      0 <= x <  960 on 12" and 15" Powerbooks
+ *      0 <= x < 1600 on 17" Powerbooks
+ *      0 <= y <  646
+ */
+#define ATP_XFACT       64
+#define ATP_YFACT       43
+
+/*
+ * Threshold for the touchpad sensors. Any change less than ATP_THRESHOLD is
+ * ignored.
+ */
+#define ATP_THRESHOLD    5
+
+/* Structure to hold all of our device specific stuff */
+struct atp {
+        struct usb_device *     udev;           /* usb device */
+        struct urb *            urb;            /* usb request block */
+        signed char *           data;           /* transferred data */
+        int                     open;           /* non-zero if opened */
+        struct input_dev        input;          /* input dev */
+        int                     valid;          /* are the sensors valid ? */
+        int                     x_old;          /* last reported x/y, */
+        int                     y_old;          /* used for smoothing */
+                                                /* current value of the sensors */
+        signed char             xy_cur[ATP_XSENSORS + ATP_YSENSORS];
+                                                /* last value of the sensors */
+        signed char             xy_old[ATP_XSENSORS + ATP_YSENSORS];
+                                                /* accumulated sensors */
+        int                     xy_acc[ATP_XSENSORS + ATP_YSENSORS];
+};
+
+#define dbg_dump(msg, tab) \
+        if (debug > 1) {                                                \
+                int i;                                                  \
+                printk("appletouch: %s %lld", msg, (long long)jiffies); \
+                for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++)       \
+                        printk(" %02x", tab[i]);                        \
+                printk("\n");                                           \
+        }
+
+#define dprintk(format, a...)                                           \
+        do {                                                            \
+                if (debug) printk(format, ##a);                         \
+        } while (0)
+
+MODULE_AUTHOR("Johannes Berg, Stelian Pop, Frank Arnold");
+MODULE_DESCRIPTION("Apple PowerBooks USB touchpad driver");
+MODULE_LICENSE("GPL");
+
+static int debug = 1;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Activate debugging output");
+
+static int atp_calculate_abs(int *xy_sensors, int nb_sensors, int fact,
+                             int *z, int *fingers)
+{
+        int i;
+        /* values to calculate mean */
+        int pcum = 0, psum = 0;
+
+        *fingers = 0;
+
+        for (i = 0; i < nb_sensors; i++) {
+                if (xy_sensors[i] < ATP_THRESHOLD)
+                        continue;
+                if ((i - 1 < 0) || (xy_sensors[i - 1] < ATP_THRESHOLD))
+                        (*fingers)++;
+                pcum += xy_sensors[i] * i;
+                psum += xy_sensors[i];
+        }
+
+        if (psum > 0) {
+                *z = psum;
+                return pcum * fact / psum;
+        }
+
+        return 0;
+}
+
+static inline void atp_report_fingers(struct input_dev *input, int fingers)
+{
+        input_report_key(input, BTN_TOOL_FINGER, fingers == 1);
+        input_report_key(input, BTN_TOOL_DOUBLETAP, fingers == 2);
+        input_report_key(input, BTN_TOOL_TRIPLETAP, fingers > 2);
+}
+
+static void atp_complete(struct urb* urb, struct pt_regs* regs)
+{
+        int x, y, x_z, y_z, x_f, y_f;
+        int retval, i;
+        struct atp *dev = urb->context;
+
+        switch (urb->status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* This urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __FUNCTION__, urb->status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __FUNCTION__, urb->status);
+                goto exit;
+        }
+
+        /* drop incomplete datasets */
+        if (dev->urb->actual_length != ATP_DATASIZE) {
+                dprintk("appletouch: incomplete data package.\n");
+                goto exit;
+        }
+
+        /* reorder the sensors values */
+        for (i = 0; i < 8; i++) {
+                /* X values */
+                dev->xy_cur[i     ] = dev->data[5 * i +  2];
+                dev->xy_cur[i +  8] = dev->data[5 * i +  4];
+                dev->xy_cur[i + 16] = dev->data[5 * i + 42];
+                if (i < 2)
+                        dev->xy_cur[i + 24] = dev->data[5 * i + 44];
+
+                /* Y values */
+                dev->xy_cur[i + 26] = dev->data[5 * i +  1];
+                dev->xy_cur[i + 34] = dev->data[5 * i +  3];
+        }
+
+        dbg_dump("sample", dev->xy_cur);
+
+        if (!dev->valid) {
+                /* first sample */
+                dev->valid = 1;
+                dev->x_old = dev->y_old = -1;
+                memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
+
+                /* 17" Powerbooks have 10 extra X sensors */
+                for (i = 16; i < ATP_XSENSORS; i++)
+                        if (dev->xy_cur[i]) {
+                                printk("appletouch: 17\" model detected.\n");
+                                input_set_abs_params(&dev->input, ABS_X, 0,
+                                                     (ATP_XSENSORS - 1) *
+                                                     ATP_XFACT - 1,
+                                                     ATP_FUZZ, 0);
+                                break;
+                        }
+
+                goto exit;
+        }
+
+        for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
+                /* accumulate the change */
+                signed char change = dev->xy_old[i] - dev->xy_cur[i];
+                dev->xy_acc[i] -= change;
+
+                /* prevent down drifting */
+                if (dev->xy_acc[i] < 0)
+                        dev->xy_acc[i] = 0;
+        }
+
+        memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
+
+        dbg_dump("accumulator", dev->xy_acc);
+
+        x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
+                              ATP_XFACT, &x_z, &x_f);
+        y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
+                              ATP_YFACT, &y_z, &y_f);
+
+        if (x && y) {
+                if (dev->x_old != -1) {
+                        x = (dev->x_old * 3 + x) >> 2;
+                        y = (dev->y_old * 3 + y) >> 2;
+                        dev->x_old = x;
+                        dev->y_old = y;
+
+                        if (debug > 1)
+                                printk("appletouch: X: %3d Y: %3d "
+                                       "Xz: %3d Yz: %3d\n",
+                                       x, y, x_z, y_z);
+
+                        input_report_key(&dev->input, BTN_TOUCH, 1);
+                        input_report_abs(&dev->input, ABS_X, x);
+                        input_report_abs(&dev->input, ABS_Y, y);
+                        input_report_abs(&dev->input, ABS_PRESSURE,
+                                         min(ATP_PRESSURE, x_z + y_z));
+                        atp_report_fingers(&dev->input, max(x_f, y_f));
+                }
+                dev->x_old = x;
+                dev->y_old = y;
+        }
+        else if (!x && !y) {
+
+                dev->x_old = dev->y_old = -1;
+                input_report_key(&dev->input, BTN_TOUCH, 0);
+                input_report_abs(&dev->input, ABS_PRESSURE, 0);
+                atp_report_fingers(&dev->input, 0);
+
+                /* reset the accumulator on release */
+                memset(dev->xy_acc, 0, sizeof(dev->xy_acc));
+        }
+
+        input_report_key(&dev->input, BTN_LEFT, !!dev->data[80]);
+
+        input_sync(&dev->input);
+
+exit:
+        retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
+        if (retval) {
+                err("%s - usb_submit_urb failed with result %d",
+                    __FUNCTION__, retval);
+        }
+}
+
+static int atp_open(struct input_dev *input)
+{
+        struct atp *dev = input->private;
+
+        if (usb_submit_urb(dev->urb, GFP_ATOMIC))
+                return -EIO;
+
+        dev->open = 1;
+        return 0;
+}
+
+static void atp_close(struct input_dev *input)
+{
+        struct atp *dev = input->private;
+
+        usb_kill_urb(dev->urb);
+        dev->open = 0;
+}
+
+static int atp_probe(struct usb_interface *iface, const struct usb_device_id *id)
+{
+        struct atp *dev = NULL;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint;
+        int int_in_endpointAddr = 0;
+        int i, retval = -ENOMEM;
+
+        /* allocate memory for our device state and initialize it */
+        dev = kmalloc(sizeof(struct atp), GFP_KERNEL);
+        if (dev == NULL) {
+                err("Out of memory");
+                goto err_kmalloc;
+        }
+        memset(dev, 0, sizeof(struct atp));
+
+        dev->udev = interface_to_usbdev(iface);
+
+        /* set up the endpoint information */
+        /* use only the first interrupt-in endpoint */
+        iface_desc = iface->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; i++) {
+                endpoint = &iface_desc->endpoint[i].desc;
+                if (!int_in_endpointAddr &&
+                    (endpoint->bEndpointAddress & USB_DIR_IN) &&
+                    ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                                        == USB_ENDPOINT_XFER_INT)) {
+                        /* we found an interrupt in endpoint */
+                        int_in_endpointAddr = endpoint->bEndpointAddress;
+                        break;
+                }
+        }
+        if (!int_in_endpointAddr) {
+                retval = -EIO;
+                err("Could not find int-in endpoint");
+                goto err_endpoint;
+        }
+
+        /* save our data pointer in this interface device */
+        usb_set_intfdata(iface, dev);
+
+        dev->urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!dev->urb) {
+                retval = -ENOMEM;
+                goto err_usballoc;
+        }
+        dev->data = usb_buffer_alloc(dev->udev, ATP_DATASIZE, GFP_KERNEL,
+                                     &dev->urb->transfer_dma);
+        if (!dev->data) {
+                retval = -ENOMEM;
+                goto err_usbbufalloc;
+        }
+        usb_fill_int_urb(dev->urb, dev->udev,
+                         usb_rcvintpipe(dev->udev, int_in_endpointAddr),
+                         dev->data, ATP_DATASIZE, atp_complete, dev, 1);
+
+        init_input_dev(&dev->input);
+        dev->input.name = "appletouch";
+        dev->input.dev = &iface->dev;
+        dev->input.private = dev;
+        dev->input.open = atp_open;
+        dev->input.close = atp_close;
+
+        usb_to_input_id(dev->udev, &dev->input.id);
+
+        set_bit(EV_ABS, dev->input.evbit);
+
+        /*
+         * 12" and 15" Powerbooks only have 16 x sensors,
+         * 17" models are detected later.
+         */
+        input_set_abs_params(&dev->input, ABS_X, 0,
+                             (16 - 1) * ATP_XFACT - 1, ATP_FUZZ, 0);
+        input_set_abs_params(&dev->input, ABS_Y, 0,
+                             (ATP_YSENSORS - 1) * ATP_YFACT - 1, ATP_FUZZ, 0);
+        input_set_abs_params(&dev->input, ABS_PRESSURE, 0, ATP_PRESSURE, 0, 0);
+
+        set_bit(EV_KEY, dev->input.evbit);
+        set_bit(BTN_TOUCH, dev->input.keybit);
+        set_bit(BTN_TOOL_FINGER, dev->input.keybit);
+        set_bit(BTN_TOOL_DOUBLETAP, dev->input.keybit);
+        set_bit(BTN_TOOL_TRIPLETAP, dev->input.keybit);
+        set_bit(BTN_LEFT, dev->input.keybit);
+
+        input_register_device(&dev->input);
+
+        printk(KERN_INFO "input: appletouch connected\n");
+
+        return 0;
+
+err_usbbufalloc:
+        usb_free_urb(dev->urb);
+err_usballoc:
+        usb_set_intfdata(iface, NULL);
+err_endpoint:
+        kfree(dev);
+err_kmalloc:
+        return retval;
+}
+
+static void atp_disconnect(struct usb_interface *iface)
+{
+        struct atp *dev = usb_get_intfdata(iface);
+
+        usb_set_intfdata(iface, NULL);
+        if (dev) {
+                usb_kill_urb(dev->urb);
+                input_unregister_device(&dev->input);
+                usb_free_urb(dev->urb);
+                usb_buffer_free(dev->udev, ATP_DATASIZE,
+                                dev->data, dev->urb->transfer_dma);
+                kfree(dev);
+        }
+        printk(KERN_INFO "input: appletouch disconnected\n");
+}
+
+static int atp_suspend(struct usb_interface *iface, pm_message_t message)
+{
+        struct atp *dev = usb_get_intfdata(iface);
+        usb_kill_urb(dev->urb);
+        dev->valid = 0;
+        return 0;
+}
+
+static int atp_resume(struct usb_interface *iface)
+{
+        struct atp *dev = usb_get_intfdata(iface);
+        if (dev->open && usb_submit_urb(dev->urb, GFP_ATOMIC))
+                return -EIO;
+
+        return 0;
+}
+
+static struct usb_driver atp_driver = {
+        .owner          = THIS_MODULE,
+        .name           = "appletouch",
+        .probe          = atp_probe,
+        .disconnect     = atp_disconnect,
+        .suspend        = atp_suspend,
+        .resume         = atp_resume,
+        .id_table       = atp_table,
+};
+
+static int __init atp_init(void)
+{
+        return usb_register(&atp_driver);
+}
+
+static void __exit atp_exit(void)
+{
+        usb_deregister(&atp_driver);
+}
+
+module_init(atp_init);
+module_exit(atp_exit);
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index b2cb2b35892e..a99865c689c5 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -2,7 +2,8 @@
  *  USB HID support for Linux
  *
  *  Copyright (c) 1999 Andreas Gal
- *  Copyright (c) 2000-2001 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
+ *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  */
 
 /*
@@ -38,7 +39,7 @@
  * Version Information
  */
 
-#define DRIVER_VERSION "v2.01"
+#define DRIVER_VERSION "v2.6"
 #define DRIVER_AUTHOR "Andreas Gal, Vojtech Pavlik"
 #define DRIVER_DESC "USB HID core driver"
 #define DRIVER_LICENSE "GPL"
@@ -1058,8 +1059,8 @@ static int hid_submit_ctrl(struct hid_device *hid)
                 if (maxpacket > 0) {
                         padlen = (len + maxpacket - 1) / maxpacket;
                         padlen *= maxpacket;
-                        if (padlen > HID_BUFFER_SIZE)
-                                padlen = HID_BUFFER_SIZE;
+                        if (padlen > hid->bufsize)
+                                padlen = hid->bufsize;
                 } else
                         padlen = 0;
                 hid->urbctrl->transfer_buffer_length = padlen;
@@ -1096,6 +1097,7 @@ static void hid_irq_out(struct urb *urb, struct pt_regs *regs)
 
         switch (urb->status) {
                 case 0:                 /* success */
+                        break;
                 case -ESHUTDOWN:        /* unplug */
                 case -EILSEQ:           /* unplug timeout on uhci */
                         unplug = 1;
@@ -1143,6 +1145,7 @@ static void hid_ctrl(struct urb *urb, struct pt_regs *regs)
                 case 0:                 /* success */
                         if (hid->ctrl[hid->ctrltail].dir == USB_DIR_IN)
                                 hid_input_report(hid->ctrl[hid->ctrltail].report->type, urb, 0, regs);
+                        break;
                 case -ESHUTDOWN:        /* unplug */
                 case -EILSEQ:           /* unplug timectrl on uhci */
                         unplug = 1;
@@ -1284,13 +1287,8 @@ void hid_init_reports(struct hid_device *hid)
         struct hid_report *report;
         int err, ret;
 
-        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list) {
-                int size = ((report->size - 1) >> 3) + 1 + hid->report_enum[HID_INPUT_REPORT].numbered;
-                if (size > HID_BUFFER_SIZE) size = HID_BUFFER_SIZE;
-                if (size > hid->urbin->transfer_buffer_length)
-                        hid->urbin->transfer_buffer_length = size;
+        list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
                 hid_submit_report(hid, report, USB_DIR_IN);
-        }
 
         list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
                 hid_submit_report(hid, report, USB_DIR_IN);
@@ -1372,12 +1370,14 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_VENDOR_ID_A4TECH            0x09da
 #define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
 
-#define USB_VENDOR_ID_AASHIMA           0x06D6
+#define USB_VENDOR_ID_AASHIMA           0x06d6
 #define USB_DEVICE_ID_AASHIMA_GAMEPAD   0x0025
+#define USB_DEVICE_ID_AASHIMA_PREDATOR  0x0026
 
 #define USB_VENDOR_ID_CYPRESS           0x04b4
 #define USB_DEVICE_ID_CYPRESS_MOUSE     0x0001
 #define USB_DEVICE_ID_CYPRESS_HIDCOM    0x5500
+#define USB_DEVICE_ID_CYPRESS_ULTRAMOUSE        0x7417
 
 #define USB_VENDOR_ID_BERKSHIRE         0x0c98
 #define USB_DEVICE_ID_BERKSHIRE_PCWD    0x1140
@@ -1432,7 +1432,7 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_DEVICE_ID_VERNIER_CYCLOPS   0x0004
 
 #define USB_VENDOR_ID_LD                0x0f11
-#define USB_DEVICE_ID_CASSY             0x1000
+#define USB_DEVICE_ID_CASSY             0x1000
 #define USB_DEVICE_ID_POCKETCASSY       0x1010
 #define USB_DEVICE_ID_MOBILECASSY       0x1020
 #define USB_DEVICE_ID_JWM               0x1080
@@ -1444,6 +1444,8 @@ void hid_init_reports(struct hid_device *hid)
 #define USB_DEVICE_ID_NETWORKANALYSER   0x2020
 #define USB_DEVICE_ID_POWERCONTROL      0x2030
 
+#define USB_VENDOR_ID_APPLE             0x05ac
+#define USB_DEVICE_ID_APPLE_POWERMOUSE  0x0304
 
 /*
  * Alphabetically sorted blacklist by quirk type.
@@ -1468,6 +1470,7 @@ static struct hid_blacklist {
         { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW48, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_CODEMERCS, USB_DEVICE_ID_CODEMERCS_IOW28, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_HIDCOM, HID_QUIRK_IGNORE },
+        { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_ULTRAMOUSE, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EARTHMATE, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_DELORME, USB_DEVICE_ID_DELORME_EM_LT20, HID_QUIRK_IGNORE },
         { USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5, HID_QUIRK_IGNORE },
@@ -1548,10 +1551,12 @@ static struct hid_blacklist {
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_USBHUB_KB, HID_QUIRK_NOGET},
         { USB_VENDOR_ID_TANGTOP, USB_DEVICE_ID_TANGTOP_USBPS2, HID_QUIRK_NOGET },
 
+        { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_POWERMOUSE, HID_QUIRK_2WHEEL_POWERMOUSE },
         { USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU, HID_QUIRK_2WHEEL_MOUSE_HACK_7 },
         { USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE, HID_QUIRK_2WHEEL_MOUSE_HACK_5 },
 
         { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_GAMEPAD, HID_QUIRK_BADPAD },
+        { USB_VENDOR_ID_AASHIMA, USB_DEVICE_ID_AASHIMA_PREDATOR, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_ALPS, USB_DEVICE_ID_IBM_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
@@ -1564,15 +1569,32 @@ static struct hid_blacklist {
         { 0, 0 }
 };
 
+/*
+ * Traverse the supplied list of reports and find the longest
+ */
+static void hid_find_max_report(struct hid_device *hid, unsigned int type, int *max)
+{
+        struct hid_report *report;
+        int size;
+
+        list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
+                size = ((report->size - 1) >> 3) + 1;
+                if (type == HID_INPUT_REPORT && hid->report_enum[type].numbered)
+                        size++;
+                if (*max < size)
+                        *max = size;
+        }
+}
+
 static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
 {
-        if (!(hid->inbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->inbuf_dma)))
+        if (!(hid->inbuf = usb_buffer_alloc(dev, hid->bufsize, SLAB_ATOMIC, &hid->inbuf_dma)))
                 return -1;
-        if (!(hid->outbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->outbuf_dma)))
+        if (!(hid->outbuf = usb_buffer_alloc(dev, hid->bufsize, SLAB_ATOMIC, &hid->outbuf_dma)))
                 return -1;
         if (!(hid->cr = usb_buffer_alloc(dev, sizeof(*(hid->cr)), SLAB_ATOMIC, &hid->cr_dma)))
                 return -1;
-        if (!(hid->ctrlbuf = usb_buffer_alloc(dev, HID_BUFFER_SIZE, SLAB_ATOMIC, &hid->ctrlbuf_dma)))
+        if (!(hid->ctrlbuf = usb_buffer_alloc(dev, hid->bufsize, SLAB_ATOMIC, &hid->ctrlbuf_dma)))
                 return -1;
 
         return 0;
@@ -1581,13 +1603,13 @@ static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
 static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
 {
         if (hid->inbuf)
-                usb_buffer_free(dev, HID_BUFFER_SIZE, hid->inbuf, hid->inbuf_dma);
+                usb_buffer_free(dev, hid->bufsize, hid->inbuf, hid->inbuf_dma);
         if (hid->outbuf)
-                usb_buffer_free(dev, HID_BUFFER_SIZE, hid->outbuf, hid->outbuf_dma);
+                usb_buffer_free(dev, hid->bufsize, hid->outbuf, hid->outbuf_dma);
         if (hid->cr)
                 usb_buffer_free(dev, sizeof(*(hid->cr)), hid->cr, hid->cr_dma);
         if (hid->ctrlbuf)
-                usb_buffer_free(dev, HID_BUFFER_SIZE, hid->ctrlbuf, hid->ctrlbuf_dma);
+                usb_buffer_free(dev, hid->bufsize, hid->ctrlbuf, hid->ctrlbuf_dma);
 }
 
 static struct hid_device *usb_hid_configure(struct usb_interface *intf)
@@ -1598,7 +1620,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         struct hid_device *hid;
         unsigned quirks = 0, rsize = 0;
         char *buf, *rdesc;
-        int n;
+        int n, insize = 0;
 
         for (n = 0; hid_blacklist[n].idVendor; n++)
                 if ((hid_blacklist[n].idVendor == le16_to_cpu(dev->descriptor.idVendor)) &&
@@ -1652,6 +1674,19 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         kfree(rdesc);
         hid->quirks = quirks;
 
+        hid->bufsize = HID_MIN_BUFFER_SIZE;
+        hid_find_max_report(hid, HID_INPUT_REPORT, &hid->bufsize);
+        hid_find_max_report(hid, HID_OUTPUT_REPORT, &hid->bufsize);
+        hid_find_max_report(hid, HID_FEATURE_REPORT, &hid->bufsize);
+
+        if (hid->bufsize > HID_MAX_BUFFER_SIZE)
+                hid->bufsize = HID_MAX_BUFFER_SIZE;
+
+        hid_find_max_report(hid, HID_INPUT_REPORT, &insize);
+
+        if (insize > HID_MAX_BUFFER_SIZE)
+                insize = HID_MAX_BUFFER_SIZE;
+
         if (hid_alloc_buffers(dev, hid)) {
                 hid_free_buffers(dev, hid);
                 goto fail;
@@ -1682,10 +1717,10 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                         if (!(hid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
                                 goto fail;
                         pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
-                        usb_fill_int_urb(hid->urbin, dev, pipe, hid->inbuf, 0,
+                        usb_fill_int_urb(hid->urbin, dev, pipe, hid->inbuf, insize,
                                          hid_irq_in, hid, interval);
                         hid->urbin->transfer_dma = hid->inbuf_dma;
-                        hid->urbin->transfer_flags |=(URB_NO_TRANSFER_DMA_MAP | URB_ASYNC_UNLINK);
+                        hid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
                 } else {
                         if (hid->urbout)
                                 continue;
@@ -1695,7 +1730,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                         usb_fill_int_urb(hid->urbout, dev, pipe, hid->outbuf, 0,
                                          hid_irq_out, hid, interval);
                         hid->urbout->transfer_dma = hid->outbuf_dma;
-                        hid->urbout->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_ASYNC_UNLINK);
+                        hid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
                 }
         }
 
@@ -1747,7 +1782,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
                              hid->ctrlbuf, 1, hid_ctrl, hid);
         hid->urbctrl->setup_dma = hid->cr_dma;
         hid->urbctrl->transfer_dma = hid->ctrlbuf_dma;
-        hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP | URB_ASYNC_UNLINK);
+        hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
 
         return hid;
 
diff --git a/drivers/usb/input/hid-debug.h b/drivers/usb/input/hid-debug.h
index 52437e5e2e78..ceebab99eff2 100644
--- a/drivers/usb/input/hid-debug.h
+++ b/drivers/usb/input/hid-debug.h
@@ -85,6 +85,23 @@ static const struct hid_usage_entry hid_usage_table[] = {
       {0, 0x91, "D-PadDown"},
       {0, 0x92, "D-PadRight"},
       {0, 0x93, "D-PadLeft"},
+  {  2, 0, "Simulation" },
+      {0, 0xb0, "Aileron"},
+      {0, 0xb1, "AileronTrim"},
+      {0, 0xb2, "Anti-Torque"},
+      {0, 0xb3, "Autopilot"},
+      {0, 0xb4, "Chaff"},
+      {0, 0xb5, "Collective"},
+      {0, 0xb6, "DiveBrake"},
+      {0, 0xb7, "ElectronicCountermeasures"},
+      {0, 0xb8, "Elevator"},
+      {0, 0xb9, "ElevatorTrim"},
+      {0, 0xba, "Rudder"},
+      {0, 0xbb, "Throttle"},
+      {0, 0xbc, "FlightCommunications"},
+      {0, 0xbd, "FlareRelease"},
+      {0, 0xbe, "LandingGear"},
+      {0, 0xbf, "ToeBrake"},
   {  7, 0, "Keyboard" },
   {  8, 0, "LED" },
       {0, 0x01, "NumLock"},
@@ -92,6 +109,7 @@ static const struct hid_usage_entry hid_usage_table[] = {
       {0, 0x03, "ScrollLock"},
       {0, 0x04, "Compose"},
       {0, 0x05, "Kana"},
+      {0, 0x4b, "GenericIndicator"},
   {  9, 0, "Button" },
   { 10, 0, "Ordinal" },
   { 12, 0, "Consumer" },
@@ -574,7 +592,8 @@ static char *keys[KEY_MAX + 1] = {
         [KEY_EXIT] = "Exit",                    [KEY_MOVE] = "Move",
         [KEY_EDIT] = "Edit",                    [KEY_SCROLLUP] = "ScrollUp",
         [KEY_SCROLLDOWN] = "ScrollDown",        [KEY_KPLEFTPAREN] = "KPLeftParenthesis",
-        [KEY_KPRIGHTPAREN] = "KPRightParenthesis", [KEY_F13] = "F13",
+        [KEY_KPRIGHTPAREN] = "KPRightParenthesis", [KEY_NEW] = "New",
+        [KEY_REDO] = "Redo",                    [KEY_F13] = "F13",
         [KEY_F14] = "F14",                      [KEY_F15] = "F15",
         [KEY_F16] = "F16",                      [KEY_F17] = "F17",
         [KEY_F18] = "F18",                      [KEY_F19] = "F19",
@@ -584,15 +603,15 @@ static char *keys[KEY_MAX + 1] = {
         [KEY_PAUSECD] = "PauseCD",              [KEY_PROG3] = "Prog3",
         [KEY_PROG4] = "Prog4",                  [KEY_SUSPEND] = "Suspend",
         [KEY_CLOSE] = "Close",                  [KEY_PLAY] = "Play",
-        [KEY_FASTFORWARD] = "Fast Forward",     [KEY_BASSBOOST] = "Bass Boost",
+        [KEY_FASTFORWARD] = "FastForward",      [KEY_BASSBOOST] = "BassBoost",
         [KEY_PRINT] = "Print",                  [KEY_HP] = "HP",
         [KEY_CAMERA] = "Camera",                [KEY_SOUND] = "Sound",
         [KEY_QUESTION] = "Question",            [KEY_EMAIL] = "Email",
         [KEY_CHAT] = "Chat",                    [KEY_SEARCH] = "Search",
         [KEY_CONNECT] = "Connect",              [KEY_FINANCE] = "Finance",
         [KEY_SPORT] = "Sport",                  [KEY_SHOP] = "Shop",
-        [KEY_ALTERASE] = "Alternate Erase",     [KEY_CANCEL] = "Cancel",
-        [KEY_BRIGHTNESSDOWN] = "Brightness down", [KEY_BRIGHTNESSUP] = "Brightness up",
+        [KEY_ALTERASE] = "AlternateErase",      [KEY_CANCEL] = "Cancel",
+        [KEY_BRIGHTNESSDOWN] = "BrightnessDown", [KEY_BRIGHTNESSUP] = "BrightnessUp",
         [KEY_MEDIA] = "Media",                  [KEY_UNKNOWN] = "Unknown",
         [BTN_0] = "Btn0",                       [BTN_1] = "Btn1",
         [BTN_2] = "Btn2",                       [BTN_3] = "Btn3",
@@ -622,8 +641,8 @@ static char *keys[KEY_MAX + 1] = {
         [BTN_TOOL_AIRBRUSH] = "ToolAirbrush",   [BTN_TOOL_FINGER] = "ToolFinger",
         [BTN_TOOL_MOUSE] = "ToolMouse",         [BTN_TOOL_LENS] = "ToolLens",
         [BTN_TOUCH] = "Touch",                  [BTN_STYLUS] = "Stylus",
-        [BTN_STYLUS2] = "Stylus2",              [BTN_TOOL_DOUBLETAP] = "Tool Doubletap",
-        [BTN_TOOL_TRIPLETAP] = "Tool Tripletap", [BTN_GEAR_DOWN] = "WheelBtn",
+        [BTN_STYLUS2] = "Stylus2",              [BTN_TOOL_DOUBLETAP] = "ToolDoubleTap",
+        [BTN_TOOL_TRIPLETAP] = "ToolTripleTap", [BTN_GEAR_DOWN] = "WheelBtn",
         [BTN_GEAR_UP] = "Gear up",              [KEY_OK] = "Ok",
         [KEY_SELECT] = "Select",                [KEY_GOTO] = "Goto",
         [KEY_CLEAR] = "Clear",                  [KEY_POWER2] = "Power2",
@@ -659,6 +678,9 @@ static char *keys[KEY_MAX + 1] = {
         [KEY_TWEN] = "TWEN",                    [KEY_DEL_EOL] = "DeleteEOL",
         [KEY_DEL_EOS] = "DeleteEOS",            [KEY_INS_LINE] = "InsertLine",
         [KEY_DEL_LINE] = "DeleteLine",
+        [KEY_SEND] = "Send",                    [KEY_REPLY] = "Reply",
+        [KEY_FORWARDMAIL] = "ForwardMail",      [KEY_SAVE] = "Save",
+        [KEY_DOCUMENTS] = "Documents",
 };
 
 static char *relatives[REL_MAX + 1] = {
diff --git a/drivers/usb/input/hid-input.c b/drivers/usb/input/hid-input.c
index 63a4db721f7e..0b6452248a39 100644
--- a/drivers/usb/input/hid-input.c
+++ b/drivers/usb/input/hid-input.c
@@ -78,8 +78,8 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
 {
         struct input_dev *input = &hidinput->input;
         struct hid_device *device = hidinput->input.private;
-        int max, code;
-        unsigned long *bit;
+        int max = 0, code;
+        unsigned long *bit = NULL;
 
         field->hidinput = hidinput;
 
@@ -131,6 +131,15 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                         map_key(code);
                         break;
 
+
+                case HID_UP_SIMULATION:
+
+                        switch (usage->hid & 0xffff) {
+                                case 0xba: map_abs(ABS_RUDDER); break;
+                                case 0xbb: map_abs(ABS_THROTTLE); break;
+                        }
+                        break;
+
                 case HID_UP_GENDESK:
 
                         if ((usage->hid & 0xf0) == 0x80) {      /* SystemControl */
@@ -238,8 +247,12 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x000: goto ignore;
                                 case 0x034: map_key_clear(KEY_SLEEP);           break;
                                 case 0x036: map_key_clear(BTN_MISC);            break;
+                                case 0x045: map_key_clear(KEY_RADIO);           break;
                                 case 0x08a: map_key_clear(KEY_WWW);             break;
+                                case 0x08d: map_key_clear(KEY_PROGRAM);         break;
                                 case 0x095: map_key_clear(KEY_HELP);            break;
+                                case 0x09c: map_key_clear(KEY_CHANNELUP);       break;
+                                case 0x09d: map_key_clear(KEY_CHANNELDOWN);     break;
                                 case 0x0b0: map_key_clear(KEY_PLAY);            break;
                                 case 0x0b1: map_key_clear(KEY_PAUSE);           break;
                                 case 0x0b2: map_key_clear(KEY_RECORD);          break;
@@ -259,6 +272,11 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x18a: map_key_clear(KEY_MAIL);            break;
                                 case 0x192: map_key_clear(KEY_CALC);            break;
                                 case 0x194: map_key_clear(KEY_FILE);            break;
+                                case 0x1a7: map_key_clear(KEY_DOCUMENTS);       break;
+                                case 0x201: map_key_clear(KEY_NEW);             break;
+                                case 0x207: map_key_clear(KEY_SAVE);            break;
+                                case 0x208: map_key_clear(KEY_PRINT);           break;
+                                case 0x209: map_key_clear(KEY_PROPS);           break;
                                 case 0x21a: map_key_clear(KEY_UNDO);            break;
                                 case 0x21b: map_key_clear(KEY_COPY);            break;
                                 case 0x21c: map_key_clear(KEY_CUT);             break;
@@ -271,7 +289,11 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                                 case 0x227: map_key_clear(KEY_REFRESH);         break;
                                 case 0x22a: map_key_clear(KEY_BOOKMARKS);       break;
                                 case 0x238: map_rel(REL_HWHEEL);                break;
-                                default:    goto unknown;
+                                case 0x279: map_key_clear(KEY_REDO);            break;
+                                case 0x289: map_key_clear(KEY_REPLY);           break;
+                                case 0x28b: map_key_clear(KEY_FORWARDMAIL);     break;
+                                case 0x28c: map_key_clear(KEY_SEND);            break;
+                                default:    goto ignore;
                         }
                         break;
 
@@ -296,9 +318,42 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                         break;
 
                 case HID_UP_MSVENDOR:
-
                         goto ignore;
 
+                case HID_UP_CUSTOM: /* Reported on Logitech and Powerbook USB keyboards */
+
+                        set_bit(EV_REP, input->evbit);
+                        switch(usage->hid & HID_USAGE) {
+                                case 0x003: map_key_clear(KEY_FN);              break;
+                                default:    goto ignore;
+                        }
+                        break;
+
+                case HID_UP_LOGIVENDOR: /* Reported on Logitech Ultra X Media Remote */
+
+                        set_bit(EV_REP, input->evbit);
+                        switch(usage->hid & HID_USAGE) {
+                                case 0x004: map_key_clear(KEY_AGAIN);           break;
+                                case 0x00d: map_key_clear(KEY_HOME);            break;
+                                case 0x024: map_key_clear(KEY_SHUFFLE);         break;
+                                case 0x025: map_key_clear(KEY_TV);              break;
+                                case 0x026: map_key_clear(KEY_MENU);            break;
+                                case 0x031: map_key_clear(KEY_AUDIO);           break;
+                                case 0x032: map_key_clear(KEY_SUBTITLE);        break;
+                                case 0x033: map_key_clear(KEY_LAST);            break;
+                                case 0x047: map_key_clear(KEY_MP3);             break;
+                                case 0x048: map_key_clear(KEY_DVD);             break;
+                                case 0x049: map_key_clear(KEY_MEDIA);           break;
+                                case 0x04a: map_key_clear(KEY_VIDEO);           break;
+                                case 0x04b: map_key_clear(KEY_ANGLE);           break;
+                                case 0x04c: map_key_clear(KEY_LANGUAGE);        break;
+                                case 0x04d: map_key_clear(KEY_SUBTITLE);        break;
+                                case 0x051: map_key_clear(KEY_RED);             break;
+                                case 0x052: map_key_clear(KEY_CLOSE);           break;
+                                default:    goto ignore;
+                        }
+                        break;
+
                 case HID_UP_PID:
 
                         set_bit(EV_FF, input->evbit);
@@ -349,6 +404,9 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
         if (usage->code > max)
                 goto ignore;
 
+        if (((device->quirks & (HID_QUIRK_2WHEEL_POWERMOUSE)) && (usage->hid == 0x00010032)))
+                map_rel(REL_HWHEEL);
+
         if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5)) &&
                  (usage->type == EV_REL) && (usage->code == REL_WHEEL))
                         set_bit(REL_HWHEEL, bit);
diff --git a/drivers/usb/input/hid.h b/drivers/usb/input/hid.h
index c1b6b69bc4a4..ec2412c42f1e 100644
--- a/drivers/usb/input/hid.h
+++ b/drivers/usb/input/hid.h
@@ -173,6 +173,7 @@ struct hid_item {
 
 #define HID_UP_UNDEFINED        0x00000000
 #define HID_UP_GENDESK          0x00010000
+#define HID_UP_SIMULATION       0x00020000
 #define HID_UP_KEYBOARD         0x00070000
 #define HID_UP_LED              0x00080000
 #define HID_UP_BUTTON           0x00090000
@@ -182,6 +183,8 @@ struct hid_item {
 #define HID_UP_PID              0x000f0000
 #define HID_UP_HPVENDOR         0xff7f0000
 #define HID_UP_MSVENDOR         0xff000000
+#define HID_UP_CUSTOM           0x00ff0000
+#define HID_UP_LOGIVENDOR       0xffbc0000
 
 #define HID_USAGE               0x0000ffff
 
@@ -242,6 +245,7 @@ struct hid_item {
 #define HID_QUIRK_2WHEEL_MOUSE_HACK_7           0x080
 #define HID_QUIRK_2WHEEL_MOUSE_HACK_5           0x100
 #define HID_QUIRK_2WHEEL_MOUSE_HACK_ON          0x200
+#define HID_QUIRK_2WHEEL_POWERMOUSE             0x400
 
 /*
  * This is the global environment of the parser. This information is
@@ -348,7 +352,8 @@ struct hid_report_enum {
 
 #define HID_REPORT_TYPES 3
 
-#define HID_BUFFER_SIZE         64              /* use 64 for compatibility with all possible packetlen */
+#define HID_MIN_BUFFER_SIZE     64              /* make sure there is at least a packet size of space */
+#define HID_MAX_BUFFER_SIZE     4096            /* 4kb */
 #define HID_CONTROL_FIFO_SIZE   256             /* to init devices with >100 reports */
 #define HID_OUTPUT_FIFO_SIZE    64
 
@@ -386,6 +391,8 @@ struct hid_device {							/* device report descriptor */
 
         unsigned long iofl;                                             /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
 
+        unsigned int bufsize;                                           /* URB buffer size */
+
         struct urb *urbin;                                              /* Input URB */
         char *inbuf;                                                    /* Input buffer */
         dma_addr_t inbuf_dma;                                           /* Input buffer dma */
diff --git a/drivers/usb/input/hiddev.c b/drivers/usb/input/hiddev.c
index 4c13331b5f41..d32427818af7 100644
--- a/drivers/usb/input/hiddev.c
+++ b/drivers/usb/input/hiddev.c
@@ -507,6 +507,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                         return -EINVAL;
 
                 hid_submit_report(hid, report, USB_DIR_OUT);
+                hid_wait_io(hid);
 
                 return 0;
 
diff --git a/drivers/usb/input/keyspan_remote.c b/drivers/usb/input/keyspan_remote.c
index 67dc93685203..99de1b33c07d 100644
--- a/drivers/usb/input/keyspan_remote.c
+++ b/drivers/usb/input/keyspan_remote.c
@@ -431,11 +431,6 @@ static int keyspan_probe(struct usb_interface *interface, const struct usb_devic
         struct usb_endpoint_descriptor *endpoint;
         struct usb_device *udev = usb_get_dev(interface_to_usbdev(interface));
 
-        /* See if the offered device matches what we can accept */
-        if ((udev->descriptor.idVendor != USB_KEYSPAN_VENDOR_ID) ||
-            (udev->descriptor.idProduct != USB_KEYSPAN_PRODUCT_UIA11) )
-                return -ENODEV;
-
         /* allocate memory for our device state and initialize it */
         remote = kmalloc(sizeof(*remote), GFP_KERNEL);
         if (remote == NULL) {
diff --git a/drivers/usb/input/map_to_7segment.h b/drivers/usb/input/map_to_7segment.h
new file mode 100644
index 000000000000..52ff27f15127
--- /dev/null
+++ b/drivers/usb/input/map_to_7segment.h
@@ -0,0 +1,189 @@
+/*
+ * drivers/usb/input/map_to_7segment.h
+ *
+ * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef MAP_TO_7SEGMENT_H
+#define MAP_TO_7SEGMENT_H
+
+/* This file provides translation primitives and tables for the conversion
+ * of (ASCII) characters to a 7-segments notation.
+ *
+ * The 7 segment's wikipedia notation below is used as standard.
+ * See: http://en.wikipedia.org/wiki/Seven_segment_display
+ *
+ * Notation:    +-a-+
+ *              f   b
+ *              +-g-+
+ *              e   c
+ *              +-d-+
+ *
+ * Usage:
+ *
+ *   Register a map variable, and fill it with a character set:
+ *      static SEG7_DEFAULT_MAP(map_seg7);
+ *
+ *
+ *   Then use for conversion:
+ *      seg7 = map_to_seg7(&map_seg7, some_char);
+ *      ...
+ *
+ * In device drivers it is recommended, if required, to make the char map
+ * accessible via the sysfs interface using the following scheme:
+ *
+ * static ssize_t show_map(struct device *dev, char *buf) {
+ *      memcpy(buf, &map_seg7, sizeof(map_seg7));
+ *      return sizeof(map_seg7);
+ * }
+ * static ssize_t store_map(struct device *dev, const char *buf, size_t cnt) {
+ *      if(cnt != sizeof(map_seg7))
+ *              return -EINVAL;
+ *      memcpy(&map_seg7, buf, cnt);
+ *      return cnt;
+ * }
+ * static DEVICE_ATTR(map_seg7, PERMS_RW, show_map, store_map);
+ *
+ * History:
+ * 2005-05-31   RFC linux-kernel@vger.kernel.org
+ */
+#include <linux/errno.h>
+
+
+#define BIT_SEG7_A              0
+#define BIT_SEG7_B              1
+#define BIT_SEG7_C              2
+#define BIT_SEG7_D              3
+#define BIT_SEG7_E              4
+#define BIT_SEG7_F              5
+#define BIT_SEG7_G              6
+#define BIT_SEG7_RESERVED       7
+
+struct seg7_conversion_map {
+        unsigned char   table[128];
+};
+
+static inline int map_to_seg7(struct seg7_conversion_map *map, int c)
+{
+        return c & 0x7f ? map->table[c] : -EINVAL;
+}
+
+#define SEG7_CONVERSION_MAP(_name, _map)        \
+        struct seg7_conversion_map _name = { .table = { _map } }
+
+/*
+ * It is recommended to use a facility that allows user space to redefine
+ * custom character sets for LCD devices. Please use a sysfs interface
+ * as described above.
+ */
+#define MAP_TO_SEG7_SYSFS_FILE  "map_seg7"
+
+/*******************************************************************************
+ * ASCII conversion table
+ ******************************************************************************/
+
+#define _SEG7(l,a,b,c,d,e,f,g)  \
+      ( a<<BIT_SEG7_A | b<<BIT_SEG7_B | c<<BIT_SEG7_C | d<<BIT_SEG7_D | \
+        e<<BIT_SEG7_E | f<<BIT_SEG7_F | g<<BIT_SEG7_G )
+
+#define _MAP_0_32_ASCII_SEG7_NON_PRINTABLE      \
+        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+
+#define _MAP_33_47_ASCII_SEG7_SYMBOL            \
+ _SEG7('!',0,0,0,0,1,1,0), _SEG7('"',0,1,0,0,0,1,0), _SEG7('#',0,1,1,0,1,1,0),\
+ _SEG7('$',1,0,1,1,0,1,1), _SEG7('%',0,0,1,0,0,1,0), _SEG7('&',1,0,1,1,1,1,1),\
+ _SEG7('\'',0,0,0,0,0,1,0),_SEG7('(',1,0,0,1,1,1,0), _SEG7(')',1,1,1,1,0,0,0),\
+ _SEG7('*',0,1,1,0,1,1,1), _SEG7('+',0,1,1,0,0,0,1), _SEG7(',',0,0,0,0,1,0,0),\
+ _SEG7('-',0,0,0,0,0,0,1), _SEG7('.',0,0,0,0,1,0,0), _SEG7('/',0,1,0,0,1,0,1),
+
+#define _MAP_48_57_ASCII_SEG7_NUMERIC           \
+ _SEG7('0',1,1,1,1,1,1,0), _SEG7('1',0,1,1,0,0,0,0), _SEG7('2',1,1,0,1,1,0,1),\
+ _SEG7('3',1,1,1,1,0,0,1), _SEG7('4',0,1,1,0,0,1,1), _SEG7('5',1,0,1,1,0,1,1),\
+ _SEG7('6',1,0,1,1,1,1,1), _SEG7('7',1,1,1,0,0,0,0), _SEG7('8',1,1,1,1,1,1,1),\
+ _SEG7('9',1,1,1,1,0,1,1),
+
+#define _MAP_58_64_ASCII_SEG7_SYMBOL            \
+ _SEG7(':',0,0,0,1,0,0,1), _SEG7(';',0,0,0,1,0,0,1), _SEG7('<',1,0,0,0,0,1,1),\
+ _SEG7('=',0,0,0,1,0,0,1), _SEG7('>',1,1,0,0,0,0,1), _SEG7('?',1,1,1,0,0,1,0),\
+ _SEG7('@',1,1,0,1,1,1,1),
+
+#define _MAP_65_90_ASCII_SEG7_ALPHA_UPPR        \
+ _SEG7('A',1,1,1,0,1,1,1), _SEG7('B',1,1,1,1,1,1,1), _SEG7('C',1,0,0,1,1,1,0),\
+ _SEG7('D',1,1,1,1,1,1,0), _SEG7('E',1,0,0,1,1,1,1), _SEG7('F',1,0,0,0,1,1,1),\
+ _SEG7('G',1,1,1,1,0,1,1), _SEG7('H',0,1,1,0,1,1,1), _SEG7('I',0,1,1,0,0,0,0),\
+ _SEG7('J',0,1,1,1,0,0,0), _SEG7('K',0,1,1,0,1,1,1), _SEG7('L',0,0,0,1,1,1,0),\
+ _SEG7('M',1,1,1,0,1,1,0), _SEG7('N',1,1,1,0,1,1,0), _SEG7('O',1,1,1,1,1,1,0),\
+ _SEG7('P',1,1,0,0,1,1,1), _SEG7('Q',1,1,1,1,1,1,0), _SEG7('R',1,1,1,0,1,1,1),\
+ _SEG7('S',1,0,1,1,0,1,1), _SEG7('T',0,0,0,1,1,1,1), _SEG7('U',0,1,1,1,1,1,0),\
+ _SEG7('V',0,1,1,1,1,1,0), _SEG7('W',0,1,1,1,1,1,1), _SEG7('X',0,1,1,0,1,1,1),\
+ _SEG7('Y',0,1,1,0,0,1,1), _SEG7('Z',1,1,0,1,1,0,1),
+
+#define _MAP_91_96_ASCII_SEG7_SYMBOL            \
+ _SEG7('[',1,0,0,1,1,1,0), _SEG7('\\',0,0,1,0,0,1,1),_SEG7(']',1,1,1,1,0,0,0),\
+ _SEG7('^',1,1,0,0,0,1,0), _SEG7('_',0,0,0,1,0,0,0), _SEG7('`',0,1,0,0,0,0,0),
+
+#define _MAP_97_122_ASCII_SEG7_ALPHA_LOWER      \
+ _SEG7('A',1,1,1,0,1,1,1), _SEG7('b',0,0,1,1,1,1,1), _SEG7('c',0,0,0,1,1,0,1),\
+ _SEG7('d',0,1,1,1,1,0,1), _SEG7('E',1,0,0,1,1,1,1), _SEG7('F',1,0,0,0,1,1,1),\
+ _SEG7('G',1,1,1,1,0,1,1), _SEG7('h',0,0,1,0,1,1,1), _SEG7('i',0,0,1,0,0,0,0),\
+ _SEG7('j',0,0,1,1,0,0,0), _SEG7('k',0,0,1,0,1,1,1), _SEG7('L',0,0,0,1,1,1,0),\
+ _SEG7('M',1,1,1,0,1,1,0), _SEG7('n',0,0,1,0,1,0,1), _SEG7('o',0,0,1,1,1,0,1),\
+ _SEG7('P',1,1,0,0,1,1,1), _SEG7('q',1,1,1,0,0,1,1), _SEG7('r',0,0,0,0,1,0,1),\
+ _SEG7('S',1,0,1,1,0,1,1), _SEG7('T',0,0,0,1,1,1,1), _SEG7('u',0,0,1,1,1,0,0),\
+ _SEG7('v',0,0,1,1,1,0,0), _SEG7('W',0,1,1,1,1,1,1), _SEG7('X',0,1,1,0,1,1,1),\
+ _SEG7('y',0,1,1,1,0,1,1), _SEG7('Z',1,1,0,1,1,0,1),
+
+#define _MAP_123_126_ASCII_SEG7_SYMBOL          \
+ _SEG7('{',1,0,0,1,1,1,0), _SEG7('|',0,0,0,0,1,1,0), _SEG7('}',1,1,1,1,0,0,0),\
+ _SEG7('~',1,0,0,0,0,0,0),
+
+/* Maps */
+
+/* This set tries to map as close as possible to the visible characteristics
+ * of the ASCII symbol, lowercase and uppercase letters may differ in
+ * presentation on the display.
+ */
+#define MAP_ASCII7SEG_ALPHANUM                  \
+        _MAP_0_32_ASCII_SEG7_NON_PRINTABLE      \
+        _MAP_33_47_ASCII_SEG7_SYMBOL            \
+        _MAP_48_57_ASCII_SEG7_NUMERIC           \
+        _MAP_58_64_ASCII_SEG7_SYMBOL            \
+        _MAP_65_90_ASCII_SEG7_ALPHA_UPPR        \
+        _MAP_91_96_ASCII_SEG7_SYMBOL            \
+        _MAP_97_122_ASCII_SEG7_ALPHA_LOWER      \
+        _MAP_123_126_ASCII_SEG7_SYMBOL
+
+/* This set tries to map as close as possible to the symbolic characteristics
+ * of the ASCII character for maximum discrimination.
+ * For now this means all alpha chars are in lower case representations.
+ * (This for example facilitates the use of hex numbers with uppercase input.)
+ */
+#define MAP_ASCII7SEG_ALPHANUM_LC                       \
+        _MAP_0_32_ASCII_SEG7_NON_PRINTABLE      \
+        _MAP_33_47_ASCII_SEG7_SYMBOL            \
+        _MAP_48_57_ASCII_SEG7_NUMERIC           \
+        _MAP_58_64_ASCII_SEG7_SYMBOL            \
+        _MAP_97_122_ASCII_SEG7_ALPHA_LOWER      \
+        _MAP_91_96_ASCII_SEG7_SYMBOL            \
+        _MAP_97_122_ASCII_SEG7_ALPHA_LOWER      \
+        _MAP_123_126_ASCII_SEG7_SYMBOL
+
+#define SEG7_DEFAULT_MAP(_name)         \
+        SEG7_CONVERSION_MAP(_name,MAP_ASCII7SEG_ALPHANUM)
+
+#endif  /* MAP_TO_7SEGMENT_H */
+
diff --git a/drivers/usb/input/yealink.c b/drivers/usb/input/yealink.c
new file mode 100644
index 000000000000..58a176ef96a5
--- /dev/null
+++ b/drivers/usb/input/yealink.c
@@ -0,0 +1,1013 @@
+/*
+ * drivers/usb/input/yealink.c
+ *
+ * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+/*
+ * Description:
+ *   Driver for the USB-P1K voip usb phone.
+ *   This device is produced by Yealink Network Technology Co Ltd
+ *   but may be branded under several names:
+ *      - Yealink usb-p1k
+ *      - Tiptel 115
+ *      - ...
+ *
+ * This driver is based on:
+ *   - the usbb2k-api   http://savannah.nongnu.org/projects/usbb2k-api/
+ *   - information from http://memeteau.free.fr/usbb2k
+ *   - the xpad-driver  drivers/usb/input/xpad.c
+ *
+ * Thanks to:
+ *   - Olivier Vandorpe, for providing the usbb2k-api.
+ *   - Martin Diehl, for spotting my memory allocation bug.
+ *
+ * History:
+ *   20050527 henk      First version, functional keyboard. Keyboard events
+ *                      will pop-up on the ../input/eventX bus.
+ *   20050531 henk      Added led, LCD, dialtone and sysfs interface.
+ *   20050610 henk      Cleanups, make it ready for public consumption.
+ *   20050630 henk      Cleanups, fixes in response to comments.
+ *   20050701 henk      sysfs write serialisation, fix potential unload races
+ *   20050801 henk      Added ringtone, restructure USB
+ *   20050816 henk      Merge 2.6.13-rc6
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/input.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/rwsem.h>
+#include <linux/usb.h>
+
+#include "map_to_7segment.h"
+#include "yealink.h"
+
+#define DRIVER_VERSION "yld-20050816"
+#define DRIVER_AUTHOR "Henk Vergonet"
+#define DRIVER_DESC "Yealink phone driver"
+
+#define YEALINK_POLLING_FREQUENCY       10      /* in [Hz] */
+
+struct yld_status {
+        u8      lcd[24];
+        u8      led;
+        u8      dialtone;
+        u8      ringtone;
+        u8      keynum;
+} __attribute__ ((packed));
+
+/*
+ * Register the LCD segment and icon map
+ */
+#define _LOC(k,l)       { .a = (k), .m = (l) }
+#define _SEG(t, a, am, b, bm, c, cm, d, dm, e, em, f, fm, g, gm)        \
+        { .type = (t),                                                  \
+          .u = { .s = { _LOC(a, am), _LOC(b, bm), _LOC(c, cm),          \
+                        _LOC(d, dm), _LOC(e, em), _LOC(g, gm),          \
+                        _LOC(f, fm) } } }
+#define _PIC(t, h, hm, n)                                               \
+        { .type = (t),                                                  \
+          .u = { .p = { .name = (n), .a = (h), .m = (hm) } } }
+
+static const struct lcd_segment_map {
+        char    type;
+        union {
+                struct pictogram_map {
+                        u8      a,m;
+                        char    name[10];
+                }       p;
+                struct segment_map {
+                        u8      a,m;
+                } s[7];
+        } u;
+} lcdMap[] = {
+#include "yealink.h"
+};
+
+struct yealink_dev {
+        struct input_dev idev;          /* input device */
+        struct usb_device *udev;        /* usb device */
+
+        /* irq input channel */
+        struct yld_ctl_packet   *irq_data;
+        dma_addr_t              irq_dma;
+        struct urb              *urb_irq;
+
+        /* control output channel */
+        struct yld_ctl_packet   *ctl_data;
+        dma_addr_t              ctl_dma;
+        struct usb_ctrlrequest  *ctl_req;
+        dma_addr_t              ctl_req_dma;
+        struct urb              *urb_ctl;
+
+        char phys[64];                  /* physical device path */
+
+        u8 lcdMap[ARRAY_SIZE(lcdMap)];  /* state of LCD, LED ... */
+        int key_code;                   /* last reported key     */
+
+        int     stat_ix;
+        union {
+                struct yld_status s;
+                u8                b[sizeof(struct yld_status)];
+        } master, copy;
+};
+
+
+/*******************************************************************************
+ * Yealink lcd interface
+ ******************************************************************************/
+
+/*
+ * Register a default 7 segment character set
+ */
+static SEG7_DEFAULT_MAP(map_seg7);
+
+ /* Display a char,
+  * char '\9' and '\n' are placeholders and do not overwrite the original text.
+  * A space will always hide an icon.
+  */
+static int setChar(struct yealink_dev *yld, int el, int chr)
+{
+        int i, a, m, val;
+
+        if (el >= ARRAY_SIZE(lcdMap))
+                return -EINVAL;
+
+        if (chr == '\t' || chr == '\n')
+            return 0;
+
+        yld->lcdMap[el] = chr;
+
+        if (lcdMap[el].type == '.') {
+                a = lcdMap[el].u.p.a;
+                m = lcdMap[el].u.p.m;
+                if (chr != ' ')
+                        yld->master.b[a] |= m;
+                else
+                        yld->master.b[a] &= ~m;
+                return 0;
+        }
+
+        val = map_to_seg7(&map_seg7, chr);
+        for (i = 0; i < ARRAY_SIZE(lcdMap[0].u.s); i++) {
+                m = lcdMap[el].u.s[i].m;
+
+                if (m == 0)
+                        continue;
+
+                a = lcdMap[el].u.s[i].a;
+                if (val & 1)
+                        yld->master.b[a] |= m;
+                else
+                        yld->master.b[a] &= ~m;
+                val = val >> 1;
+        }
+        return 0;
+};
+
+/*******************************************************************************
+ * Yealink key interface
+ ******************************************************************************/
+
+/* Map device buttons to internal key events.
+ *
+ * USB-P1K button layout:
+ *
+ *             up
+ *       IN           OUT
+ *            down
+ *
+ *     pickup   C    hangup
+ *       1      2      3
+ *       4      5      6
+ *       7      8      9
+ *       *      0      #
+ *
+ * The "up" and "down" keys, are symbolised by arrows on the button.
+ * The "pickup" and "hangup" keys are symbolised by a green and red phone
+ * on the button.
+ */
+static int map_p1k_to_key(int scancode)
+{
+        switch(scancode) {              /* phone key:   */
+        case 0x23: return KEY_LEFT;     /*   IN         */
+        case 0x33: return KEY_UP;       /*   up         */
+        case 0x04: return KEY_RIGHT;    /*   OUT        */
+        case 0x24: return KEY_DOWN;     /*   down       */
+        case 0x03: return KEY_ENTER;    /*   pickup     */
+        case 0x14: return KEY_BACKSPACE; /*  C          */
+        case 0x13: return KEY_ESC;      /*   hangup     */
+        case 0x00: return KEY_1;        /*   1          */
+        case 0x01: return KEY_2;        /*   2          */
+        case 0x02: return KEY_3;        /*   3          */
+        case 0x10: return KEY_4;        /*   4          */
+        case 0x11: return KEY_5;        /*   5          */
+        case 0x12: return KEY_6;        /*   6          */
+        case 0x20: return KEY_7;        /*   7          */
+        case 0x21: return KEY_8;        /*   8          */
+        case 0x22: return KEY_9;        /*   9          */
+        case 0x30: return KEY_KPASTERISK; /* *          */
+        case 0x31: return KEY_0;        /*   0          */
+        case 0x32: return KEY_LEFTSHIFT |
+                          KEY_3 << 8;   /*   #          */
+        }
+        return -EINVAL;
+}
+
+/* Completes a request by converting the data into events for the
+ * input subsystem.
+ *
+ * The key parameter can be cascaded: key2 << 8 | key1
+ */
+static void report_key(struct yealink_dev *yld, int key, struct pt_regs *regs)
+{
+        struct input_dev *idev = &yld->idev;
+
+        input_regs(idev, regs);
+        if (yld->key_code >= 0) {
+                /* old key up */
+                input_report_key(idev, yld->key_code & 0xff, 0);
+                if (yld->key_code >> 8)
+                        input_report_key(idev, yld->key_code >> 8, 0);
+        }
+
+        yld->key_code = key;
+        if (key >= 0) {
+                /* new valid key */
+                input_report_key(idev, key & 0xff, 1);
+                if (key >> 8)
+                        input_report_key(idev, key >> 8, 1);
+        }
+        input_sync(idev);
+}
+
+/*******************************************************************************
+ * Yealink usb communication interface
+ ******************************************************************************/
+
+static int yealink_cmd(struct yealink_dev *yld, struct yld_ctl_packet *p)
+{
+        u8      *buf = (u8 *)p;
+        int     i;
+        u8      sum = 0;
+
+        for(i=0; i<USB_PKT_LEN-1; i++)
+                sum -= buf[i];
+        p->sum = sum;
+        return usb_control_msg(yld->udev,
+                        usb_sndctrlpipe(yld->udev, 0),
+                        USB_REQ_SET_CONFIGURATION,
+                        USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
+                        0x200, 3,
+                        p, sizeof(*p),
+                        USB_CTRL_SET_TIMEOUT);
+}
+
+static u8 default_ringtone[] = {
+        0xEF,                   /* volume [0-255] */
+        0xFB, 0x1E, 0x00, 0x0C, /* 1250 [hz], 12/100 [s] */
+        0xFC, 0x18, 0x00, 0x0C, /* 1000 [hz], 12/100 [s] */
+        0xFB, 0x1E, 0x00, 0x0C,
+        0xFC, 0x18, 0x00, 0x0C,
+        0xFB, 0x1E, 0x00, 0x0C,
+        0xFC, 0x18, 0x00, 0x0C,
+        0xFB, 0x1E, 0x00, 0x0C,
+        0xFC, 0x18, 0x00, 0x0C,
+        0xFF, 0xFF, 0x01, 0x90, /* silent, 400/100 [s] */
+        0x00, 0x00              /* end of sequence */
+};
+
+static int yealink_set_ringtone(struct yealink_dev *yld, u8 *buf, size_t size)
+{
+        struct yld_ctl_packet *p = yld->ctl_data;
+        int     ix, len;
+
+        if (size <= 0)
+                return -EINVAL;
+
+        /* Set the ringtone volume */
+        memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+        yld->ctl_data->cmd      = CMD_RING_VOLUME;
+        yld->ctl_data->size     = 1;
+        yld->ctl_data->data[0]  = buf[0];
+        yealink_cmd(yld, p);
+
+        buf++;
+        size--;
+
+        p->cmd = CMD_RING_NOTE;
+        ix = 0;
+        while (size != ix) {
+                len = size - ix;
+                if (len > sizeof(p->data))
+                        len = sizeof(p->data);
+                p->size   = len;
+                p->offset = cpu_to_be16(ix);
+                memcpy(p->data, &buf[ix], len);
+                yealink_cmd(yld, p);
+                ix += len;
+        }
+        return 0;
+}
+
+/* keep stat_master & stat_copy in sync.
+ */
+static int yealink_do_idle_tasks(struct yealink_dev *yld)
+{
+        u8 val;
+        int i, ix, len;
+
+        ix = yld->stat_ix;
+
+        memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+        yld->ctl_data->cmd  = CMD_KEYPRESS;
+        yld->ctl_data->size = 1;
+        yld->ctl_data->sum  = 0xff - CMD_KEYPRESS;
+
+        /* If state update pointer wraps do a KEYPRESS first. */
+        if (ix >= sizeof(yld->master)) {
+                yld->stat_ix = 0;
+                return 0;
+        }
+
+        /* find update candidates: copy != master */
+        do {
+                val = yld->master.b[ix];
+                if (val != yld->copy.b[ix])
+                        goto send_update;
+        } while (++ix < sizeof(yld->master));
+
+        /* nothing todo, wait a bit and poll for a KEYPRESS */
+        yld->stat_ix = 0;
+        /* TODO how can we wait abit. ??
+         * msleep_interruptible(1000 / YEALINK_POLLING_FREQUENCY);
+         */
+        return 0;
+
+send_update:
+
+        /* Setup an appropriate update request */
+        yld->copy.b[ix] = val;
+        yld->ctl_data->data[0] = val;
+
+        switch(ix) {
+        case offsetof(struct yld_status, led):
+                yld->ctl_data->cmd      = CMD_LED;
+                yld->ctl_data->sum      = -1 - CMD_LED - val;
+                break;
+        case offsetof(struct yld_status, dialtone):
+                yld->ctl_data->cmd      = CMD_DIALTONE;
+                yld->ctl_data->sum      = -1 - CMD_DIALTONE - val;
+                break;
+        case offsetof(struct yld_status, ringtone):
+                yld->ctl_data->cmd      = CMD_RINGTONE;
+                yld->ctl_data->sum      = -1 - CMD_RINGTONE - val;
+                break;
+        case offsetof(struct yld_status, keynum):
+                val--;
+                val &= 0x1f;
+                yld->ctl_data->cmd      = CMD_SCANCODE;
+                yld->ctl_data->offset   = cpu_to_be16(val);
+                yld->ctl_data->data[0]  = 0;
+                yld->ctl_data->sum      = -1 - CMD_SCANCODE - val;
+                break;
+        default:
+                len = sizeof(yld->master.s.lcd) - ix;
+                if (len > sizeof(yld->ctl_data->data))
+                        len = sizeof(yld->ctl_data->data);
+
+                /* Combine up to <len> consecutive LCD bytes in a singe request
+                 */
+                yld->ctl_data->cmd      = CMD_LCD;
+                yld->ctl_data->offset   = cpu_to_be16(ix);
+                yld->ctl_data->size     = len;
+                yld->ctl_data->sum      = -CMD_LCD - ix - val - len;
+                for(i=1; i<len; i++) {
+                        ix++;
+                        val = yld->master.b[ix];
+                        yld->copy.b[ix]         = val;
+                        yld->ctl_data->data[i]  = val;
+                        yld->ctl_data->sum     -= val;
+                }
+        }
+        yld->stat_ix = ix + 1;
+        return 1;
+}
+
+/* Decide on how to handle responses
+ *
+ * The state transition diagram is somethhing like:
+ *
+ *          syncState<--+
+ *               |      |
+ *               |    idle
+ *              \|/     |
+ * init --ok--> waitForKey --ok--> getKey
+ *  ^               ^                |
+ *  |               +-------ok-------+
+ * error,start
+ *
+ */
+static void urb_irq_callback(struct urb *urb, struct pt_regs *regs)
+{
+        struct yealink_dev *yld = urb->context;
+        int ret;
+
+        if (urb->status)
+                err("%s - urb status %d", __FUNCTION__, urb->status);
+
+        switch (yld->irq_data->cmd) {
+        case CMD_KEYPRESS:
+
+                yld->master.s.keynum = yld->irq_data->data[0];
+                break;
+
+        case CMD_SCANCODE:
+                dbg("get scancode %x", yld->irq_data->data[0]);
+
+                report_key(yld, map_p1k_to_key(yld->irq_data->data[0]), regs);
+                break;
+
+        default:
+                err("unexpected response %x", yld->irq_data->cmd);
+        }
+
+        yealink_do_idle_tasks(yld);
+
+        ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+        if (ret)
+                err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
+}
+
+static void urb_ctl_callback(struct urb *urb, struct pt_regs *regs)
+{
+        struct yealink_dev *yld = urb->context;
+        int ret;
+
+        if (urb->status)
+                err("%s - urb status %d", __FUNCTION__, urb->status);
+
+        switch (yld->ctl_data->cmd) {
+        case CMD_KEYPRESS:
+        case CMD_SCANCODE:
+                /* ask for a response */
+                ret = usb_submit_urb(yld->urb_irq, GFP_ATOMIC);
+                break;
+        default:
+                /* send new command */
+                yealink_do_idle_tasks(yld);
+                ret = usb_submit_urb(yld->urb_ctl, GFP_ATOMIC);
+        }
+
+        if (ret)
+                err("%s - usb_submit_urb failed %d", __FUNCTION__, ret);
+}
+
+/*******************************************************************************
+ * input event interface
+ ******************************************************************************/
+
+/* TODO should we issue a ringtone on a SND_BELL event?
+static int input_ev(struct input_dev *dev, unsigned int type,
+                unsigned int code, int value)
+{
+
+        if (type != EV_SND)
+                return -EINVAL;
+
+        switch (code) {
+        case SND_BELL:
+        case SND_TONE:
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+*/
+
+static int input_open(struct input_dev *dev)
+{
+        struct yealink_dev *yld = dev->private;
+        int i, ret;
+
+        dbg("%s", __FUNCTION__);
+
+        /* force updates to device */
+        for (i = 0; i<sizeof(yld->master); i++)
+                yld->copy.b[i] = ~yld->master.b[i];
+        yld->key_code = -1;     /* no keys pressed */
+
+        yealink_set_ringtone(yld, default_ringtone, sizeof(default_ringtone));
+
+        /* issue INIT */
+        memset(yld->ctl_data, 0, sizeof(*(yld->ctl_data)));
+        yld->ctl_data->cmd      = CMD_INIT;
+        yld->ctl_data->size     = 10;
+        yld->ctl_data->sum      = 0x100-CMD_INIT-10;
+        if ((ret = usb_submit_urb(yld->urb_ctl, GFP_KERNEL)) != 0) {
+                dbg("%s - usb_submit_urb failed with result %d",
+                     __FUNCTION__, ret);
+                return ret;
+        }
+        return 0;
+}
+
+static void input_close(struct input_dev *dev)
+{
+        struct yealink_dev *yld = dev->private;
+
+        usb_kill_urb(yld->urb_ctl);
+        usb_kill_urb(yld->urb_irq);
+}
+
+/*******************************************************************************
+ * sysfs interface
+ ******************************************************************************/
+
+static DECLARE_RWSEM(sysfs_rwsema);
+
+/* Interface to the 7-segments translation table aka. char set.
+ */
+static ssize_t show_map(struct device *dev, struct device_attribute *attr,
+                                char *buf)
+{
+        memcpy(buf, &map_seg7, sizeof(map_seg7));
+        return sizeof(map_seg7);
+}
+
+static ssize_t store_map(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t cnt)
+{
+        if (cnt != sizeof(map_seg7))
+                return -EINVAL;
+        memcpy(&map_seg7, buf, sizeof(map_seg7));
+        return sizeof(map_seg7);
+}
+
+/* Interface to the LCD.
+ */
+
+/* Reading /sys/../lineX will return the format string with its settings:
+ *
+ * Example:
+ * cat ./line3
+ * 888888888888
+ * Linux Rocks!
+ */
+static ssize_t show_line(struct device *dev, char *buf, int a, int b)
+{
+        struct yealink_dev *yld;
+        int i;
+
+        down_read(&sysfs_rwsema);
+        yld = dev_get_drvdata(dev);
+        if (yld == NULL) {
+                up_read(&sysfs_rwsema);
+                return -ENODEV;
+        }
+
+        for (i = a; i < b; i++)
+                *buf++ = lcdMap[i].type;
+        *buf++ = '\n';
+        for (i = a; i < b; i++)
+                *buf++ = yld->lcdMap[i];
+        *buf++ = '\n';
+        *buf = 0;
+
+        up_read(&sysfs_rwsema);
+        return 3 + ((b - a) << 1);
+}
+
+static ssize_t show_line1(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        return show_line(dev, buf, LCD_LINE1_OFFSET, LCD_LINE2_OFFSET);
+}
+
+static ssize_t show_line2(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        return show_line(dev, buf, LCD_LINE2_OFFSET, LCD_LINE3_OFFSET);
+}
+
+static ssize_t show_line3(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        return show_line(dev, buf, LCD_LINE3_OFFSET, LCD_LINE4_OFFSET);
+}
+
+/* Writing to /sys/../lineX will set the coresponding LCD line.
+ * - Excess characters are ignored.
+ * - If less characters are written than allowed, the remaining digits are
+ *   unchanged.
+ * - The '\n' or '\t' char is a placeholder, it does not overwrite the
+ *   original content.
+ */
+static ssize_t store_line(struct device *dev, const char *buf, size_t count,
+                int el, size_t len)
+{
+        struct yealink_dev *yld;
+        int i;
+
+        down_write(&sysfs_rwsema);
+        yld = dev_get_drvdata(dev);
+        if (yld == NULL) {
+                up_write(&sysfs_rwsema);
+                return -ENODEV;
+        }
+
+        if (len > count)
+                len = count;
+        for (i = 0; i < len; i++)
+                setChar(yld, el++, buf[i]);
+
+        up_write(&sysfs_rwsema);
+        return count;
+}
+
+static ssize_t store_line1(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        return store_line(dev, buf, count, LCD_LINE1_OFFSET, LCD_LINE1_SIZE);
+}
+
+static ssize_t store_line2(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        return store_line(dev, buf, count, LCD_LINE2_OFFSET, LCD_LINE2_SIZE);
+}
+
+static ssize_t store_line3(struct device *dev, struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        return store_line(dev, buf, count, LCD_LINE3_OFFSET, LCD_LINE3_SIZE);
+}
+
+/* Interface to visible and audible "icons", these include:
+ * pictures on the LCD, the LED, and the dialtone signal.
+ */
+
+/* Get a list of "switchable elements" with their current state. */
+static ssize_t get_icons(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct yealink_dev *yld;
+        int i, ret = 1;
+
+        down_read(&sysfs_rwsema);
+        yld = dev_get_drvdata(dev);
+        if (yld == NULL) {
+                up_read(&sysfs_rwsema);
+                return -ENODEV;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
+                if (lcdMap[i].type != '.')
+                        continue;
+                ret += sprintf(&buf[ret], "%s %s\n",
+                                yld->lcdMap[i] == ' ' ? "  " : "on",
+                                lcdMap[i].u.p.name);
+        }
+        up_read(&sysfs_rwsema);
+        return ret;
+}
+
+/* Change the visibility of a particular element. */
+static ssize_t set_icon(struct device *dev, const char *buf, size_t count,
+                        int chr)
+{
+        struct yealink_dev *yld;
+        int i;
+
+        down_write(&sysfs_rwsema);
+        yld = dev_get_drvdata(dev);
+        if (yld == NULL) {
+                up_write(&sysfs_rwsema);
+                return -ENODEV;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(lcdMap); i++) {
+                if (lcdMap[i].type != '.')
+                        continue;
+                if (strncmp(buf, lcdMap[i].u.p.name, count) == 0) {
+                        setChar(yld, i, chr);
+                        break;
+                }
+        }
+
+        up_write(&sysfs_rwsema);
+        return count;
+}
+
+static ssize_t show_icon(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        return set_icon(dev, buf, count, buf[0]);
+}
+
+static ssize_t hide_icon(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        return set_icon(dev, buf, count, ' ');
+}
+
+/* Upload a ringtone to the device.
+ */
+
+/* Stores raw ringtone data in the phone */
+static ssize_t store_ringtone(struct device *dev,
+                struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct yealink_dev *yld;
+
+        down_write(&sysfs_rwsema);
+        yld = dev_get_drvdata(dev);
+        if (yld == NULL) {
+                up_write(&sysfs_rwsema);
+                return -ENODEV;
+        }
+
+        /* TODO locking with async usb control interface??? */
+        yealink_set_ringtone(yld, (char *)buf, count);
+        up_write(&sysfs_rwsema);
+        return count;
+}
+
+#define _M444   S_IRUGO
+#define _M664   S_IRUGO|S_IWUSR|S_IWGRP
+#define _M220   S_IWUSR|S_IWGRP
+
+static DEVICE_ATTR(map_seg7     , _M664, show_map       , store_map     );
+static DEVICE_ATTR(line1        , _M664, show_line1     , store_line1   );
+static DEVICE_ATTR(line2        , _M664, show_line2     , store_line2   );
+static DEVICE_ATTR(line3        , _M664, show_line3     , store_line3   );
+static DEVICE_ATTR(get_icons    , _M444, get_icons      , NULL          );
+static DEVICE_ATTR(show_icon    , _M220, NULL           , show_icon     );
+static DEVICE_ATTR(hide_icon    , _M220, NULL           , hide_icon     );
+static DEVICE_ATTR(ringtone     , _M220, NULL           , store_ringtone);
+
+static struct attribute *yld_attributes[] = {
+        &dev_attr_line1.attr,
+        &dev_attr_line2.attr,
+        &dev_attr_line3.attr,
+        &dev_attr_get_icons.attr,
+        &dev_attr_show_icon.attr,
+        &dev_attr_hide_icon.attr,
+        &dev_attr_map_seg7.attr,
+        &dev_attr_ringtone.attr,
+        NULL
+};
+
+static struct attribute_group yld_attr_group = {
+        .attrs = yld_attributes
+};
+
+/*******************************************************************************
+ * Linux interface and usb initialisation
+ ******************************************************************************/
+
+static const struct yld_device {
+        u16 idVendor;
+        u16 idProduct;
+        char *name;
+} yld_device[] = {
+        { 0x6993, 0xb001, "Yealink usb-p1k" },
+};
+
+static struct usb_device_id usb_table [] = {
+        { USB_INTERFACE_INFO(USB_CLASS_HID, 0, 0) },
+        { }
+};
+
+static int usb_cleanup(struct yealink_dev *yld, int err)
+{
+        if (yld == NULL)
+                return err;
+
+        if (yld->urb_irq) {
+                usb_kill_urb(yld->urb_irq);
+                usb_free_urb(yld->urb_irq);
+        }
+        if (yld->urb_ctl)
+                usb_free_urb(yld->urb_ctl);
+        if (yld->idev.dev)
+                input_unregister_device(&yld->idev);
+        if (yld->ctl_req)
+                usb_buffer_free(yld->udev, sizeof(*(yld->ctl_req)),
+                                yld->ctl_req, yld->ctl_req_dma);
+        if (yld->ctl_data)
+                usb_buffer_free(yld->udev, USB_PKT_LEN,
+                                yld->ctl_data, yld->ctl_dma);
+        if (yld->irq_data)
+                usb_buffer_free(yld->udev, USB_PKT_LEN,
+                                yld->irq_data, yld->irq_dma);
+        kfree(yld);
+        return err;
+}
+
+static void usb_disconnect(struct usb_interface *intf)
+{
+        struct yealink_dev *yld;
+
+        down_write(&sysfs_rwsema);
+        yld = usb_get_intfdata(intf);
+        sysfs_remove_group(&intf->dev.kobj, &yld_attr_group);
+        usb_set_intfdata(intf, NULL);
+        up_write(&sysfs_rwsema);
+
+        usb_cleanup(yld, 0);
+}
+
+static int usb_match(struct usb_device *udev)
+{
+        int i;
+        u16 idVendor = le16_to_cpu(udev->descriptor.idVendor);
+        u16 idProduct = le16_to_cpu(udev->descriptor.idProduct);
+
+        for (i = 0; i < ARRAY_SIZE(yld_device); i++) {
+                if ((idVendor == yld_device[i].idVendor) &&
+                    (idProduct == yld_device[i].idProduct))
+                        return i;
+        }
+        return -ENODEV;
+}
+
+static int usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev (intf);
+        struct usb_host_interface *interface;
+        struct usb_endpoint_descriptor *endpoint;
+        struct yealink_dev *yld;
+        char path[64];
+        int ret, pipe, i;
+
+        i = usb_match(udev);
+        if (i < 0)
+                return -ENODEV;
+
+        interface = intf->cur_altsetting;
+        endpoint = &interface->endpoint[0].desc;
+        if (!(endpoint->bEndpointAddress & 0x80))
+                return -EIO;
+        if ((endpoint->bmAttributes & 3) != 3)
+                return -EIO;
+
+        if ((yld = kmalloc(sizeof(struct yealink_dev), GFP_KERNEL)) == NULL)
+                return -ENOMEM;
+
+        memset(yld, 0, sizeof(*yld));
+        yld->udev = udev;
+
+        /* allocate usb buffers */
+        yld->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN,
+                                        SLAB_ATOMIC, &yld->irq_dma);
+        if (yld->irq_data == NULL)
+                return usb_cleanup(yld, -ENOMEM);
+
+        yld->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN,
+                                        SLAB_ATOMIC, &yld->ctl_dma);
+        if (!yld->ctl_data)
+                return usb_cleanup(yld, -ENOMEM);
+
+        yld->ctl_req = usb_buffer_alloc(udev, sizeof(*(yld->ctl_req)),
+                                        SLAB_ATOMIC, &yld->ctl_req_dma);
+        if (yld->ctl_req == NULL)
+                return usb_cleanup(yld, -ENOMEM);
+
+        /* allocate urb structures */
+        yld->urb_irq = usb_alloc_urb(0, GFP_KERNEL);
+        if (yld->urb_irq == NULL)
+                return usb_cleanup(yld, -ENOMEM);
+
+        yld->urb_ctl = usb_alloc_urb(0, GFP_KERNEL);
+        if (yld->urb_ctl == NULL)
+                return usb_cleanup(yld, -ENOMEM);
+
+        /* get a handle to the interrupt data pipe */
+        pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
+        ret = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+        if (ret != USB_PKT_LEN)
+                err("invalid payload size %d, expected %d", ret, USB_PKT_LEN);
+
+        /* initialise irq urb */
+        usb_fill_int_urb(yld->urb_irq, udev, pipe, yld->irq_data,
+                        USB_PKT_LEN,
+                        urb_irq_callback,
+                        yld, endpoint->bInterval);
+        yld->urb_irq->transfer_dma = yld->irq_dma;
+        yld->urb_irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        yld->urb_irq->dev = udev;
+
+        /* initialise ctl urb */
+        yld->ctl_req->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE |
+                                      USB_DIR_OUT;
+        yld->ctl_req->bRequest  = USB_REQ_SET_CONFIGURATION;
+        yld->ctl_req->wValue    = cpu_to_le16(0x200);
+        yld->ctl_req->wIndex    = cpu_to_le16(interface->desc.bInterfaceNumber);
+        yld->ctl_req->wLength   = cpu_to_le16(USB_PKT_LEN);
+
+        usb_fill_control_urb(yld->urb_ctl, udev, usb_sndctrlpipe(udev, 0),
+                        (void *)yld->ctl_req, yld->ctl_data, USB_PKT_LEN,
+                        urb_ctl_callback, yld);
+        yld->urb_ctl->setup_dma = yld->ctl_req_dma;
+        yld->urb_ctl->transfer_dma      = yld->ctl_dma;
+        yld->urb_ctl->transfer_flags    |= URB_NO_SETUP_DMA_MAP |
+                                        URB_NO_TRANSFER_DMA_MAP;
+        yld->urb_ctl->dev = udev;
+
+        /* find out the physical bus location */
+        if (usb_make_path(udev, path, sizeof(path)) > 0)
+                snprintf(yld->phys, sizeof(yld->phys)-1,  "%s/input0", path);
+
+        /* register settings for the input device */
+        init_input_dev(&yld->idev);
+        yld->idev.private       = yld;
+        yld->idev.id.bustype    = BUS_USB;
+        yld->idev.id.vendor     = le16_to_cpu(udev->descriptor.idVendor);
+        yld->idev.id.product    = le16_to_cpu(udev->descriptor.idProduct);
+        yld->idev.id.version    = le16_to_cpu(udev->descriptor.bcdDevice);
+        yld->idev.dev           = &intf->dev;
+        yld->idev.name          = yld_device[i].name;
+        yld->idev.phys          = yld->phys;
+        /* yld->idev.event              = input_ev;     TODO */
+        yld->idev.open          = input_open;
+        yld->idev.close         = input_close;
+
+        /* register available key events */
+        yld->idev.evbit[0] = BIT(EV_KEY);
+        for (i = 0; i < 256; i++) {
+                int k = map_p1k_to_key(i);
+                if (k >= 0) {
+                        set_bit(k & 0xff, yld->idev.keybit);
+                        if (k >> 8)
+                                set_bit(k >> 8, yld->idev.keybit);
+                }
+        }
+
+        printk(KERN_INFO "input: %s on %s\n", yld->idev.name, path);
+
+        input_register_device(&yld->idev);
+
+        usb_set_intfdata(intf, yld);
+
+        /* clear visible elements */
+        for (i=0; i<ARRAY_SIZE(lcdMap); i++)
+                setChar(yld, i, ' ');
+
+        /* display driver version on LCD line 3 */
+        store_line3(&intf->dev, NULL,
+                        DRIVER_VERSION, sizeof(DRIVER_VERSION));
+
+        /* Register sysfs hooks (don't care about failure) */
+        sysfs_create_group(&intf->dev.kobj, &yld_attr_group);
+        return 0;
+}
+
+static struct usb_driver yealink_driver = {
+        .owner          = THIS_MODULE,
+        .name           = "yealink",
+        .probe          = usb_probe,
+        .disconnect     = usb_disconnect,
+        .id_table       = usb_table,
+};
+
+static int __init yealink_dev_init(void)
+{
+        int ret = usb_register(&yealink_driver);
+        if (ret == 0)
+                info(DRIVER_DESC ":" DRIVER_VERSION);
+        return ret;
+}
+
+static void __exit yealink_dev_exit(void)
+{
+        usb_deregister(&yealink_driver);
+}
+
+module_init(yealink_dev_init);
+module_exit(yealink_dev_exit);
+
+MODULE_DEVICE_TABLE (usb, usb_table);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/input/yealink.h b/drivers/usb/input/yealink.h
new file mode 100644
index 000000000000..48af0be9cbdf
--- /dev/null
+++ b/drivers/usb/input/yealink.h
@@ -0,0 +1,220 @@
+/*
+ * drivers/usb/input/yealink.h
+ *
+ * Copyright (c) 2005 Henk Vergonet <Henk.Vergonet@gmail.com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#ifndef INPUT_YEALINK_H
+#define INPUT_YEALINK_H
+
+/* Using the control channel on interface 3 various aspects of the phone
+ * can be controlled like LCD, LED, dialtone and the ringtone.
+ */
+
+struct yld_ctl_packet {
+        u8      cmd;            /* command code, see below */
+        u8      size;           /* 1-11, size of used data bytes. */
+        u16     offset;         /* internal packet offset */
+        u8      data[11];
+        s8      sum;            /* negative sum of 15 preceding bytes */
+} __attribute__ ((packed));
+
+#define USB_PKT_LEN     sizeof(struct yld_ctl_packet)
+
+/* The following yld_ctl_packet's are available: */
+
+/* Init registers
+ *
+ * cmd          0x8e
+ * size         10
+ * offset       0
+ * data         0,0,0,0....
+ */
+#define CMD_INIT                0x8e
+
+/* Request key scan
+ *
+ * cmd          0x80
+ * size         1
+ * offset       0
+ * data[0]      on return returns the key number, if it changes there's a new
+ *              key pressed.
+ */
+#define CMD_KEYPRESS            0x80
+
+/* Request scancode
+ *
+ * cmd          0x81
+ * size         1
+ * offset       key number [0-1f]
+ * data[0]      on return returns the scancode
+ */
+#define CMD_SCANCODE            0x81
+
+/* Set LCD
+ *
+ * cmd          0x04
+ * size         1-11
+ * offset       0-23
+ * data         segment bits
+ */
+#define CMD_LCD                 0x04
+
+/* Set led
+ *
+ * cmd          0x05
+ * size         1
+ * offset       0
+ * data[0]      0 OFF / 1 ON
+ */
+#define CMD_LED                 0x05
+
+/* Set ringtone volume
+ *
+ * cmd          0x11
+ * size         1
+ * offset       0
+ * data[0]      0-0xff  volume
+ */
+#define CMD_RING_VOLUME         0x11
+
+/* Set ringtone notes
+ *
+ * cmd          0x02
+ * size         1-11
+ * offset       0->
+ * data         binary representation LE16(-freq), LE16(duration) ....
+ */
+#define CMD_RING_NOTE           0x02
+
+/* Sound ringtone via the speaker on the back
+ *
+ * cmd          0x03
+ * size         1
+ * offset       0
+ * data[0]      0 OFF / 0x24 ON
+ */
+#define CMD_RINGTONE            0x03
+
+/* Sound dial tone via the ear speaker
+ *
+ * cmd          0x09
+ * size         1
+ * offset       0
+ * data[0]      0 OFF / 1 ON
+ */
+#define CMD_DIALTONE            0x09
+
+#endif /* INPUT_YEALINK_H */
+
+
+#if defined(_SEG) && defined(_PIC)
+/* This table maps the LCD segments onto individual bit positions in the
+ * yld_status struct.
+ */
+
+/* LCD, each segment must be driven seperately.
+ *
+ * Layout:
+ *
+ *   |[]   [][]   [][]   [][]   in   |[][]
+ *   |[] M [][] D [][] : [][]   out  |[][]
+ *                             store
+ *
+ *    NEW REP         SU MO TU WE TH FR SA
+ *
+ *    [] [] [] [] [] [] [] [] [] [] [] []
+ *    [] [] [] [] [] [] [] [] [] [] [] []
+ */
+
+/* Line 1
+ *      Format          : 18.e8.M8.88...188
+ *      Icon names      : M D : IN OUT STORE
+ */
+#define LCD_LINE1_OFFSET        0
+#define LCD_LINE1_SIZE          17
+
+/* Note: first g then f =>                             !      !      */
+/* _SEG(    type    a      b      c      d      e      g      f   )  */
+        _SEG('1',  0,0 , 22,2 , 22,2 ,  0,0 ,  0,0 ,  0,0 ,  0,0        ),
+        _SEG('8', 20,1 , 20,2 , 20,4 , 20,8 , 21,4 , 21,2 , 21,1        ),
+        _PIC('.', 22,1 , "M"                                            ),
+        _SEG('e', 18,1 , 18,2 , 18,4 , 18,1 , 19,2 , 18,1 , 19,1        ),
+        _SEG('8', 16,1 , 16,2 , 16,4 , 16,8 , 17,4 , 17,2 , 17,1        ),
+        _PIC('.', 15,8 , "D"                                            ),
+        _SEG('M', 14,1 , 14,2 , 14,4 , 14,1 , 15,4 , 15,2 , 15,1        ),
+        _SEG('8', 12,1 , 12,2 , 12,4 , 12,8 , 13,4 , 13,2 , 13,1        ),
+        _PIC('.', 11,8 , ":"                                            ),
+        _SEG('8', 10,1 , 10,2 , 10,4 , 10,8 , 11,4 , 11,2 , 11,1        ),
+        _SEG('8',  8,1 ,  8,2 ,  8,4 ,  8,8 ,  9,4 ,  9,2 ,  9,1        ),
+        _PIC('.',  7,1 , "IN"                                           ),
+        _PIC('.',  7,2 , "OUT"                                          ),
+        _PIC('.',  7,4 , "STORE"                                        ),
+        _SEG('1',  0,0 ,  5,1 ,  5,1 ,  0,0 ,  0,0 ,  0,0 ,  0,0        ),
+        _SEG('8',  4,1 ,  4,2 ,  4,4 ,  4,8 ,  5,8 ,  5,4 ,  5,2        ),
+        _SEG('8',  2,1 ,  2,2 ,  2,4 ,  2,8 ,  3,4 ,  3,2 ,  3,1        ),
+
+/* Line 2
+ *      Format          : .........
+ *      Pict. name      : NEW REP SU MO TU WE TH FR SA
+ */
+#define LCD_LINE2_OFFSET        LCD_LINE1_OFFSET + LCD_LINE1_SIZE
+#define LCD_LINE2_SIZE          9
+
+        _PIC('.', 23,2 , "NEW"  ),
+        _PIC('.', 23,4 , "REP"  ),
+        _PIC('.',  1,8 , "SU"   ),
+        _PIC('.',  1,4 , "MO"   ),
+        _PIC('.',  1,2 , "TU"   ),
+        _PIC('.',  1,1 , "WE"   ),
+        _PIC('.',  0,1 , "TH"   ),
+        _PIC('.',  0,2 , "FR"   ),
+        _PIC('.',  0,4 , "SA"   ),
+
+/* Line 3
+ *      Format          : 888888888888
+ */
+#define LCD_LINE3_OFFSET        LCD_LINE2_OFFSET + LCD_LINE2_SIZE
+#define LCD_LINE3_SIZE          12
+
+        _SEG('8', 22,16, 22,32, 22,64, 22,128, 23,128, 23,64, 23,32  ),
+        _SEG('8', 20,16, 20,32, 20,64, 20,128, 21,128, 21,64, 21,32  ),
+        _SEG('8', 18,16, 18,32, 18,64, 18,128, 19,128, 19,64, 19,32  ),
+        _SEG('8', 16,16, 16,32, 16,64, 16,128, 17,128, 17,64, 17,32  ),
+        _SEG('8', 14,16, 14,32, 14,64, 14,128, 15,128, 15,64, 15,32  ),
+        _SEG('8', 12,16, 12,32, 12,64, 12,128, 13,128, 13,64, 13,32  ),
+        _SEG('8', 10,16, 10,32, 10,64, 10,128, 11,128, 11,64, 11,32  ),
+        _SEG('8',  8,16,  8,32,  8,64,  8,128,  9,128,  9,64,  9,32  ),
+        _SEG('8',  6,16,  6,32,  6,64,  6,128,  7,128,  7,64,  7,32  ),
+        _SEG('8',  4,16,  4,32,  4,64,  4,128,  5,128,  5,64,  5,32  ),
+        _SEG('8',  2,16,  2,32,  2,64,  2,128,  3,128,  3,64,  3,32  ),
+        _SEG('8',  0,16,  0,32,  0,64,  0,128,  1,128,  1,64,  1,32  ),
+
+/* Line 4
+ *
+ * The LED, DIALTONE and RINGTONE are implemented as icons and use the same
+ * sysfs interface.
+ */
+#define LCD_LINE4_OFFSET        LCD_LINE3_OFFSET + LCD_LINE3_SIZE
+
+        _PIC('.', offsetof(struct yld_status, led)      , 0x01, "LED" ),
+        _PIC('.', offsetof(struct yld_status, dialtone) , 0x01, "DIALTONE" ),
+        _PIC('.', offsetof(struct yld_status, ringtone) , 0x24, "RINGTONE" ),
+
+#undef _SEG
+#undef _PIC
+#endif /* _SEG && _PIC */
diff --git a/drivers/usb/media/stv680.c b/drivers/usb/media/stv680.c
index 7398a7f19c1e..0fd0fa9fec21 100644
--- a/drivers/usb/media/stv680.c
+++ b/drivers/usb/media/stv680.c
@@ -260,7 +260,7 @@ static int stv_stop_video (struct usb_stv *dev)
                         PDEBUG (0, "STV(i): Camera set to original resolution");
         }
         /* origMode */
-        kfree (buf);
+        kfree(buf);
         return i;
 }
 
@@ -276,7 +276,7 @@ static int stv_set_video_mode (struct usb_stv *dev)
         }
 
         if ((i = stv_set_config (dev, 1, 0, 0)) < 0) {
-                kfree (buf);
+                kfree(buf);
                 return i;
         }
 
@@ -301,13 +301,13 @@ static int stv_set_video_mode (struct usb_stv *dev)
         goto exit;
 
 error:
-        kfree (buf);
+        kfree(buf);
         if (stop_video == 1)
                 stv_stop_video (dev);
         return -1;
 
 exit:
-        kfree (buf);
+        kfree(buf);
         return 0;
 }
 
@@ -327,7 +327,7 @@ static int stv_init (struct usb_stv *stv680)
 
         /* set config 1, interface 0, alternate 0 */
         if ((i = stv_set_config (stv680, 1, 0, 0)) < 0) {
-                kfree (buffer);
+                kfree(buffer);
                 PDEBUG (0, "STV(e): set config 1,0,0 failed");
                 return -1;
         }
@@ -435,11 +435,11 @@ static int stv_init (struct usb_stv *stv680)
 error:
         i = stv_sndctrl (0, stv680, 0x80, 0, buffer, 0x02);     /* Get Last Error */
         PDEBUG (1, "STV(i): last error: %i,  command = 0x%x", buffer[0], buffer[1]);
-        kfree (buffer);
+        kfree(buffer);
         return -1;
 
 exit:
-        kfree (buffer);
+        kfree(buffer);
 
         /* video = 320x240, 352x288 */
         if (stv680->CIF == 1) {
@@ -708,10 +708,10 @@ static int stv680_stop_stream (struct usb_stv *stv680)
                         usb_kill_urb (stv680->urb[i]);
                         usb_free_urb (stv680->urb[i]);
                         stv680->urb[i] = NULL;
-                        kfree (stv680->sbuf[i].data);
+                        kfree(stv680->sbuf[i].data);
                 }
         for (i = 0; i < STV680_NUMSCRATCH; i++) {
-                kfree (stv680->scratch[i].data);
+                kfree(stv680->scratch[i].data);
                 stv680->scratch[i].data = NULL;
         }
 
@@ -1068,7 +1068,7 @@ static int stv_close (struct inode *inode, struct file *file)
         stv680->user = 0;
 
         if (stv680->removed) {
-                kfree (stv680);
+                kfree(stv680);
                 stv680 = NULL;
                 PDEBUG (0, "STV(i): device unregistered");
         }
@@ -1445,14 +1445,14 @@ static inline void usb_stv680_remove_disconnected (struct usb_stv *stv680)
                         usb_kill_urb (stv680->urb[i]);
                         usb_free_urb (stv680->urb[i]);
                         stv680->urb[i] = NULL;
-                        kfree (stv680->sbuf[i].data);
+                        kfree(stv680->sbuf[i].data);
                 }
         for (i = 0; i < STV680_NUMSCRATCH; i++)
-                kfree (stv680->scratch[i].data);
+                kfree(stv680->scratch[i].data);
         PDEBUG (0, "STV(i): %s disconnected", stv680->camera_name);
 
         /* Free the memory */
-        kfree (stv680);
+        kfree(stv680);
 }
 
 static void stv680_disconnect (struct usb_interface *intf)
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index 6f7994f5a714..ae4681f9f0ea 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -426,7 +426,7 @@ static int auerchain_submit_urb (pauerchain_t acp, struct urb * urb)
 
 /* cancel an urb which is submitted to the chain
    the result is 0 if the urb is cancelled, or -EINPROGRESS if
-   URB_ASYNC_UNLINK is set and the function is successfully started.
+   the function is successfully started.
 */
 static int auerchain_unlink_urb (pauerchain_t acp, struct urb * urb)
 {
@@ -515,7 +515,6 @@ static void auerchain_unlink_all (pauerchain_t acp)
         acep = acp->active;
         if (acep) {
                 urbp = acep->urbp;
-                urbp->transfer_flags &= ~URB_ASYNC_UNLINK;
                 dbg ("unlink active urb");
                 usb_kill_urb (urbp);
         }
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index ad17892aac9e..7e93ac96490f 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -464,7 +464,7 @@ static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
         actual_buffer = (size_t*)(dev->ring_buffer + dev->ring_tail*(sizeof(size_t)+dev->interrupt_in_endpoint_size));
         bytes_to_read = min(count, *actual_buffer);
         if (bytes_to_read < *actual_buffer)
-                dev_warn(&dev->intf->dev, "Read buffer overflow, %d bytes dropped\n",
+                dev_warn(&dev->intf->dev, "Read buffer overflow, %zd bytes dropped\n",
                          *actual_buffer-bytes_to_read);
 
         /* copy one interrupt_in_buffer from ring_buffer into userspace */
@@ -528,8 +528,8 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
         /* write the data into interrupt_out_buffer from userspace */
         bytes_to_write = min(count, write_buffer_size*dev->interrupt_out_endpoint_size);
         if (bytes_to_write < count)
-                dev_warn(&dev->intf->dev, "Write buffer overflow, %d bytes dropped\n",count-bytes_to_write);
-        dbg_info(&dev->intf->dev, "%s: count = %d, bytes_to_write = %d\n", __FUNCTION__, count, bytes_to_write);
+                dev_warn(&dev->intf->dev, "Write buffer overflow, %zd bytes dropped\n",count-bytes_to_write);
+        dbg_info(&dev->intf->dev, "%s: count = %zd, bytes_to_write = %zd\n", __FUNCTION__, count, bytes_to_write);
 
         if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
                 retval = -EFAULT;
diff --git a/drivers/usb/misc/sisusbvga/Kconfig b/drivers/usb/misc/sisusbvga/Kconfig
index 3957e144caf7..7603cbe0865d 100644
--- a/drivers/usb/misc/sisusbvga/Kconfig
+++ b/drivers/usb/misc/sisusbvga/Kconfig
@@ -4,11 +4,43 @@ config USB_SISUSBVGA
         depends on USB && USB_EHCI_HCD
         ---help---
           Say Y here if you intend to attach a USB2VGA dongle based on a
-          Net2280 and a SiS315 chip. 
-          
-          Note that this device requires a USB 2.0 host controller. It will not 
+          Net2280 and a SiS315 chip.
+
+          Note that this device requires a USB 2.0 host controller. It will not
           work with USB 1.x controllers.
 
-          To compile this driver as a module, choose M here: the module will be
-          called sisusb.  If unsure, say N.
+          To compile this driver as a module, choose M here; the module will be
+          called sisusbvga. If unsure, say N.
+
+config USB_SISUSBVGA_CON
+        bool "Text console and mode switching support" if USB_SISUSBVGA
+        depends on VT
+        select FONT_8x16
+        ---help---
+          Say Y here if you want a VGA text console via the USB dongle or
+          want to support userland applications that utilize the driver's
+          display mode switching capabilities.
+
+          Note that this console supports VGA/EGA text mode only.
+
+          By default, the console part of the driver will not kick in when
+          the driver is initialized. If you want the driver to take over
+          one or more of the consoles, you need to specify the number of
+          the first and last consoles (starting at 1) as driver parameters.
+
+          For example, if the driver is compiled as a module:
+
+             modprobe sisusbvga first=1 last=5
+
+          If you use hotplug, add this to your modutils config files with
+          the "options" keyword, such as eg.
+
+             options sisusbvga first=1 last=5
+
+          If the driver is compiled into the kernel image, the parameters
+          must be given in the kernel command like, such as
+
+             sisusbvga.first=1 sisusbvga.last=5
+
+
 
diff --git a/drivers/usb/misc/sisusbvga/Makefile b/drivers/usb/misc/sisusbvga/Makefile
index 76f1643ceaf8..7f934cfc906c 100644
--- a/drivers/usb/misc/sisusbvga/Makefile
+++ b/drivers/usb/misc/sisusbvga/Makefile
@@ -2,5 +2,7 @@
 # Makefile for the sisusb driver (if driver is inside kernel tree).
 #
 
-obj-$(CONFIG_USB_SISUSBVGA) += sisusb.o
+obj-$(CONFIG_USB_SISUSBVGA) += sisusbvga.o
+
+sisusbvga-objs := sisusb.o sisusb_init.o sisusb_con.o
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 2fd12264fd53..39db3155723a 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -1,6 +1,8 @@
 /*
  * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
  *
+ * Main part
+ *
  * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
  *
  * If distributed as part of the Linux kernel, this code is licensed under the
@@ -48,16 +50,60 @@
 #include <linux/kref.h>
 #include <linux/usb.h>
 #include <linux/smp_lock.h>
+#include <linux/vmalloc.h>
 
 #include "sisusb.h"
 
+#ifdef INCL_SISUSB_CON
+#include <linux/font.h>
+#endif
+
 #define SISUSB_DONTSYNC
 
 /* Forward declarations / clean-up routines */
 
+#ifdef INCL_SISUSB_CON
+int     sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data);
+int     sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data);
+int     sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 data);
+int     sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 *data);
+int     sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port, u8 idx, u8 myand, u8 myor);
+int     sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port, u8 index, u8 myor);
+int     sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port, u8 idx, u8 myand);
+
+int     sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data);
+int     sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data);
+int     sisusb_writew(struct sisusb_usb_data *sisusb, u32 adr, u16 data);
+int     sisusb_readw(struct sisusb_usb_data *sisusb, u32 adr, u16 *data);
+int     sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
+                        u32 dest, int length, size_t *bytes_written);
+
+int     sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init);
+
+extern int  SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo);
+extern int  SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo);
+
+extern void sisusb_init_concode(void);
+extern int  sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last);
+extern void sisusb_console_exit(struct sisusb_usb_data *sisusb);
+
+extern void sisusb_set_cursor(struct sisusb_usb_data *sisusb, unsigned int location);
+
+extern int  sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
+                u8 *arg, int cmapsz, int ch512, int dorecalc,
+                struct vc_data *c, int fh, int uplock);
+
+static int sisusb_first_vc = 0;
+static int sisusb_last_vc = 0;
+module_param_named(first, sisusb_first_vc, int, 0);
+module_param_named(last, sisusb_last_vc, int, 0);
+MODULE_PARM_DESC(first, "Number of first console to take over (1 - MAX_NR_CONSOLES)");
+MODULE_PARM_DESC(last, "Number of last console to take over (1 - MAX_NR_CONSOLES)");
+#endif
+
 static struct usb_driver sisusb_driver;
 
-static DECLARE_MUTEX(disconnect_sem);
+DECLARE_MUTEX(disconnect_sem);
 
 static void
 sisusb_free_buffers(struct sisusb_usb_data *sisusb)
@@ -229,7 +275,7 @@ sisusb_bulkout_msg(struct sisusb_usb_data *sisusb, int index, unsigned int pipe,
         usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
                 sisusb_bulk_completeout, &sisusb->urbout_context[index]);
 
-        urb->transfer_flags |= (tflags | URB_ASYNC_UNLINK);
+        urb->transfer_flags |= tflags;
         urb->actual_length = 0;
 
         if ((urb->transfer_dma = transfer_dma))
@@ -295,7 +341,7 @@ sisusb_bulkin_msg(struct sisusb_usb_data *sisusb, unsigned int pipe, void *data,
         usb_fill_bulk_urb(urb, sisusb->sisusb_dev, pipe, data, len,
                         sisusb_bulk_completein, sisusb);
 
-        urb->transfer_flags |= (tflags | URB_ASYNC_UNLINK);
+        urb->transfer_flags |= tflags;
         urb->actual_length = 0;
 
         if ((urb->transfer_dma = transfer_dma))
@@ -639,7 +685,10 @@ static int sisusb_send_bridge_packet(struct sisusb_usb_data *sisusb, int len,
 
 /* The following routines assume being used to transfer byte, word,
  * long etc.
- * This means that they assume "data" in machine endianness format.
+ * This means that
+ *   - the write routines expect "data" in machine endianness format.
+ *     The data will be converted to leXX in sisusb_xxx_packet.
+ *   - the read routines can expect read data in machine-endianess.
  */
 
 static int sisusb_write_memio_byte(struct sisusb_usb_data *sisusb, int type,
@@ -839,7 +888,7 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                                 if (get_user(swap16, (u16 __user *)userbuffer))
                                         return -EFAULT;
                         } else
-                                swap16 = (kernbuffer[0] << 8) | kernbuffer[1];
+                                swap16 = *((u16 *)kernbuffer);
 
                         ret = sisusb_write_memio_word(sisusb,
                                                         SISUSB_TYPE_MEM,
@@ -855,14 +904,25 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                         if (userbuffer) {
                                 if (copy_from_user(&buf, userbuffer, 3))
                                         return -EFAULT;
-
+#ifdef __BIG_ENDIAN
                                 swap32 = (buf[0] << 16) |
                                          (buf[1] <<  8) |
                                          buf[2];
+#else
+                                swap32 = (buf[2] << 16) |
+                                         (buf[1] <<  8) |
+                                         buf[0];
+#endif
                         } else
+#ifdef __BIG_ENDIAN
                                 swap32 = (kernbuffer[0] << 16) |
                                          (kernbuffer[1] <<  8) |
                                          kernbuffer[2];
+#else
+                                swap32 = (kernbuffer[2] << 16) |
+                                         (kernbuffer[1] <<  8) |
+                                         kernbuffer[0];
+#endif
 
                         ret = sisusb_write_memio_24bit(sisusb,
                                                         SISUSB_TYPE_MEM,
@@ -879,10 +939,7 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                                 if (get_user(swap32, (u32 __user *)userbuffer))
                                         return -EFAULT;
                         } else
-                                swap32 = (kernbuffer[0] << 24) |
-                                         (kernbuffer[1] << 16) |
-                                         (kernbuffer[2] <<  8) |
-                                         kernbuffer[3];
+                                swap32 = *((u32 *)kernbuffer);
 
                         ret = sisusb_write_memio_long(sisusb,
                                                         SISUSB_TYPE_MEM,
@@ -1005,6 +1062,10 @@ static int sisusb_write_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
         return ret ? -EIO : 0;
 }
 
+/* Remember: Read data in packet is in machine-endianess! So for
+ * byte, word, 24bit, long no endian correction is necessary.
+ */
+
 static int sisusb_read_memio_byte(struct sisusb_usb_data *sisusb, int type,
                                                         u32 addr, u8 *data)
 {
@@ -1191,8 +1252,7 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                                                 (u16 __user *)userbuffer))
                                                 return -EFAULT;
                                 } else {
-                                        kernbuffer[0] = swap16 >> 8;
-                                        kernbuffer[1] = swap16 & 0xff;
+                                        *((u16 *)kernbuffer) = swap16;
                                 }
                         }
                         return ret;
@@ -1202,9 +1262,15 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
                                                                 addr, &swap32);
                         if (!ret) {
                                 (*bytes_read) += 3;
+#ifdef __BIG_ENDIAN
                                 buf[0] = (swap32 >> 16) & 0xff;
                                 buf[1] = (swap32 >> 8) & 0xff;
                                 buf[2] = swap32 & 0xff;
+#else
+                                buf[2] = (swap32 >> 16) & 0xff;
+                                buf[1] = (swap32 >> 8) & 0xff;
+                                buf[0] = swap32 & 0xff;
+#endif
                                 if (userbuffer) {
                                         if (copy_to_user(userbuffer, &buf[0], 3))
                                                 return -EFAULT;
@@ -1228,10 +1294,7 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
 
                                         userbuffer += 4;
                                 } else {
-                                        kernbuffer[0] = (swap32 >> 24) & 0xff;
-                                        kernbuffer[1] = (swap32 >> 16) & 0xff;
-                                        kernbuffer[2] = (swap32 >> 8) & 0xff;
-                                        kernbuffer[3] = swap32 & 0xff;
+                                        *((u32 *)kernbuffer) = swap32;
                                         kernbuffer += 4;
                                 }
                                 addr += 4;
@@ -1289,7 +1352,24 @@ static int sisusb_read_mem_bulk(struct sisusb_usb_data *sisusb, u32 addr,
 
 /* High level: Gfx (indexed) register access */
 
-static int
+#ifdef INCL_SISUSB_CON
+int
+sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data)
+{
+        return sisusb_write_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
+}
+
+int
+sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data)
+{
+        return sisusb_read_memio_byte(sisusb, SISUSB_TYPE_IO, port, data);
+}
+#endif
+
+#ifndef INCL_SISUSB_CON
+static
+#endif
+int
 sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 data)
 {
         int ret;
@@ -1298,7 +1378,10 @@ sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 data)
         return ret;
 }
 
-static int
+#ifndef INCL_SISUSB_CON
+static
+#endif
+int
 sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 *data)
 {
         int ret;
@@ -1307,7 +1390,10 @@ sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port, u8 index, u8 *data)
         return ret;
 }
 
-static int
+#ifndef INCL_SISUSB_CON
+static
+#endif
+int
 sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port, u8 idx,
                                                         u8 myand, u8 myor)
 {
@@ -1336,18 +1422,89 @@ sisusb_setidxregmask(struct sisusb_usb_data *sisusb, int port, u8 idx,
         return ret;
 }
 
-static int
+#ifndef INCL_SISUSB_CON
+static
+#endif
+int
 sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port, u8 index, u8 myor)
 {
         return(sisusb_setidxregandor(sisusb, port, index, 0xff, myor));
 }
 
-static int
+#ifndef INCL_SISUSB_CON
+static
+#endif
+int
 sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port, u8 idx, u8 myand)
 {
         return(sisusb_setidxregandor(sisusb, port, idx, myand, 0x00));
 }
 
+/* Write/read video ram */
+
+#ifdef INCL_SISUSB_CON
+int
+sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data)
+{
+        return(sisusb_write_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
+}
+
+int
+sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data)
+{
+        return(sisusb_read_memio_byte(sisusb, SISUSB_TYPE_MEM, adr, data));
+}
+
+int
+sisusb_writew(struct sisusb_usb_data *sisusb, u32 adr, u16 data)
+{
+        return(sisusb_write_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
+}
+
+int
+sisusb_readw(struct sisusb_usb_data *sisusb, u32 adr, u16 *data)
+{
+        return(sisusb_read_memio_word(sisusb, SISUSB_TYPE_MEM, adr, data));
+}
+
+int
+sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
+                        u32 dest, int length, size_t *bytes_written)
+{
+        return(sisusb_write_mem_bulk(sisusb, dest, src, length, NULL, 0, bytes_written));
+}
+
+#ifdef SISUSBENDIANTEST
+int
+sisusb_read_memory(struct sisusb_usb_data *sisusb, char *dest,
+                        u32 src, int length, size_t *bytes_written)
+{
+        return(sisusb_read_mem_bulk(sisusb, src, dest, length, NULL, bytes_written));
+}
+#endif
+#endif
+
+#ifdef SISUSBENDIANTEST
+static void
+sisusb_testreadwrite(struct sisusb_usb_data *sisusb)
+{
+    static char srcbuffer[] = { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
+    char destbuffer[10];
+    size_t dummy;
+    int i,j;
+
+    sisusb_copy_memory(sisusb, srcbuffer, sisusb->vrambase, 7, &dummy);
+
+    for(i = 1; i <= 7; i++) {
+        printk(KERN_DEBUG "sisusb: rwtest %d bytes\n", i);
+        sisusb_read_memory(sisusb, destbuffer, sisusb->vrambase, i, &dummy);
+        for(j = 0; j < i; j++) {
+             printk(KERN_DEBUG "sisusb: rwtest read[%d] = %x\n", j, destbuffer[j]);
+        }
+    }
+}
+#endif
+
 /* access pci config registers (reg numbers 0, 4, 8, etc) */
 
 static int
@@ -2270,6 +2427,129 @@ sisusb_init_gfxdevice(struct sisusb_usb_data *sisusb, int initscreen)
         return ret;
 }
 
+
+#ifdef INCL_SISUSB_CON
+
+/* Set up default text mode:
+   - Set text mode (0x03)
+   - Upload default font
+   - Upload user font (if available)
+*/
+
+int
+sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init)
+{
+        int ret = 0, slot = sisusb->font_slot, i;
+        struct font_desc *myfont;
+        u8 *tempbuf;
+        u16 *tempbufb;
+        size_t written;
+        static char bootstring[] = "SiSUSB VGA text console, (C) 2005 Thomas Winischhofer.";
+        static char bootlogo[] = "(o_ //\\ V_/_";
+
+        /* sisusb->lock is down */
+
+        if (!sisusb->SiS_Pr)
+                return 1;
+
+        sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
+        sisusb->SiS_Pr->sisusb = (void *)sisusb;
+
+        /* Set mode 0x03 */
+        SiSUSBSetMode(sisusb->SiS_Pr, 0x03);
+
+        if (!(myfont = find_font("VGA8x16")))
+                return 1;
+
+        if (!(tempbuf = vmalloc(8192)))
+                return 1;
+
+        for (i = 0; i < 256; i++)
+                memcpy(tempbuf + (i * 32), myfont->data + (i * 16), 16);
+
+        /* Upload default font */
+        ret = sisusbcon_do_font_op(sisusb, 1, 0, tempbuf, 8192, 0, 1, NULL, 16, 0);
+
+        vfree(tempbuf);
+
+        /* Upload user font (and reset current slot) */
+        if (sisusb->font_backup) {
+                ret |= sisusbcon_do_font_op(sisusb, 1, 2, sisusb->font_backup,
+                                8192, sisusb->font_backup_512, 1, NULL,
+                                sisusb->font_backup_height, 0);
+                if (slot != 2)
+                        sisusbcon_do_font_op(sisusb, 1, 0, NULL, 0, 0, 1,
+                                        NULL, 16, 0);
+        }
+
+        if (init && !sisusb->scrbuf) {
+
+                if ((tempbuf = vmalloc(8192))) {
+
+                        i = 4096;
+                        tempbufb = (u16 *)tempbuf;
+                        while (i--)
+                                *(tempbufb++) = 0x0720;
+
+                        i = 0;
+                        tempbufb = (u16 *)tempbuf;
+                        while (bootlogo[i]) {
+                                *(tempbufb++) = 0x0700 | bootlogo[i++];
+                                if (!(i % 4))
+                                        tempbufb += 76;
+                        }
+
+                        i = 0;
+                        tempbufb = (u16 *)tempbuf + 6;
+                        while (bootstring[i])
+                                *(tempbufb++) = 0x0700 | bootstring[i++];
+
+                        ret |= sisusb_copy_memory(sisusb, tempbuf,
+                                sisusb->vrambase, 8192, &written);
+
+                        vfree(tempbuf);
+
+                }
+
+        } else if (sisusb->scrbuf) {
+
+                ret |= sisusb_copy_memory(sisusb, (char *)sisusb->scrbuf,
+                                sisusb->vrambase, sisusb->scrbuf_size, &written);
+
+        }
+
+        if (sisusb->sisusb_cursor_size_from >= 0 &&
+            sisusb->sisusb_cursor_size_to >= 0) {
+                sisusb_setidxreg(sisusb, SISCR, 0x0a,
+                                sisusb->sisusb_cursor_size_from);
+                sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0,
+                                sisusb->sisusb_cursor_size_to);
+        } else {
+                sisusb_setidxreg(sisusb, SISCR, 0x0a, 0x2d);
+                sisusb_setidxreg(sisusb, SISCR, 0x0b, 0x0e);
+                sisusb->sisusb_cursor_size_to = -1;
+        }
+
+        slot = sisusb->sisusb_cursor_loc;
+        if(slot < 0) slot = 0;
+
+        sisusb->sisusb_cursor_loc = -1;
+        sisusb->bad_cursor_pos = 1;
+
+        sisusb_set_cursor(sisusb, slot);
+
+        sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
+        sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
+
+        sisusb->textmodedestroyed = 0;
+
+        /* sisusb->lock is down */
+
+        return ret;
+}
+
+#endif
+
 /* fops */
 
 static int
@@ -2329,7 +2609,7 @@ sisusb_open(struct inode *inode, struct file *file)
                 }
         }
 
-        /* increment usage count for the device */
+        /* Increment usage count for our sisusb */
         kref_get(&sisusb->kref);
 
         sisusb->isopen = 1;
@@ -2340,12 +2620,10 @@ sisusb_open(struct inode *inode, struct file *file)
 
         up(&disconnect_sem);
 
-        printk(KERN_DEBUG "sisusbvga[%d]: opened", sisusb->minor);
-
         return 0;
 }
 
-static void
+void
 sisusb_delete(struct kref *kref)
 {
         struct sisusb_usb_data *sisusb = to_sisusb_dev(kref);
@@ -2359,6 +2637,9 @@ sisusb_delete(struct kref *kref)
         sisusb->sisusb_dev = NULL;
         sisusb_free_buffers(sisusb);
         sisusb_free_urbs(sisusb);
+#ifdef INCL_SISUSB_CON
+        kfree(sisusb->SiS_Pr);
+#endif
         kfree(sisusb);
 }
 
@@ -2395,8 +2676,6 @@ sisusb_release(struct inode *inode, struct file *file)
 
         up(&disconnect_sem);
 
-        printk(KERN_DEBUG "sisusbvga[%d]: released", myminor);
-
         return 0;
 }
 
@@ -2733,6 +3012,12 @@ sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
         int     retval, port, length;
         u32     address;
 
+        /* All our commands require the device
+         * to be initialized.
+         */
+        if (!sisusb->devinit)
+                return -ENODEV;
+
         port = y->data3 -
                 SISUSB_PCI_PSEUDO_IOPORTBASE +
                 SISUSB_PCI_IOPORTBASE;
@@ -2774,6 +3059,10 @@ sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
                         break;
 
                 case SUCMD_CLRSCR:
+                        /* Gfx core must be initialized */
+                        if (!sisusb->gfxinit)
+                                return -ENODEV;
+
                         length = (y->data0 << 16) | (y->data1 << 8) | y->data2;
                         address = y->data3 -
                                 SISUSB_PCI_PSEUDO_MEMBASE +
@@ -2781,11 +3070,61 @@ sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
                         retval = sisusb_clear_vram(sisusb, address, length);
                         break;
 
+                case SUCMD_HANDLETEXTMODE:
+                        retval = 0;
+#ifdef INCL_SISUSB_CON
+                        /* Gfx core must be initialized, SiS_Pr must exist */
+                        if (!sisusb->gfxinit || !sisusb->SiS_Pr)
+                                return -ENODEV;
+
+                        switch (y->data0) {
+                        case 0:
+                                retval = sisusb_reset_text_mode(sisusb, 0);
+                                break;
+                        case 1:
+                                sisusb->textmodedestroyed = 1;
+                                break;
+                        }
+#endif
+                        break;
+
+#ifdef INCL_SISUSB_CON
+                case SUCMD_SETMODE:
+                        /* Gfx core must be initialized, SiS_Pr must exist */
+                        if (!sisusb->gfxinit || !sisusb->SiS_Pr)
+                                return -ENODEV;
+
+                        retval = 0;
+
+                        sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
+                        sisusb->SiS_Pr->sisusb = (void *)sisusb;
+
+                        if (SiSUSBSetMode(sisusb->SiS_Pr, y->data3))
+                                retval = -EINVAL;
+
+                        break;
+
+                case SUCMD_SETVESAMODE:
+                        /* Gfx core must be initialized, SiS_Pr must exist */
+                        if (!sisusb->gfxinit || !sisusb->SiS_Pr)
+                                return -ENODEV;
+
+                        retval = 0;
+
+                        sisusb->SiS_Pr->IOAddress = SISUSB_PCI_IOPORTBASE + 0x30;
+                        sisusb->SiS_Pr->sisusb = (void *)sisusb;
+
+                        if (SiSUSBSetVESAMode(sisusb->SiS_Pr, y->data3))
+                                retval = -EINVAL;
+
+                        break;
+#endif
+
                 default:
                         retval = -EINVAL;
         }
 
-        if(retval > 0)
+        if (retval > 0)
                 retval = -EIO;
 
         return retval;
@@ -2835,6 +3174,11 @@ sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                         x.sisusb_vramsize   = sisusb->vramsize;
                         x.sisusb_minor      = sisusb->minor;
                         x.sisusb_fbdevactive= 0;
+#ifdef INCL_SISUSB_CON
+                        x.sisusb_conactive  = sisusb->haveconsole ? 1 : 0;
+#else
+                        x.sisusb_conactive  = 0;
+#endif
 
                         if (copy_to_user((void __user *)arg, &x, sizeof(x)))
                                 retval = -EFAULT;
@@ -2895,9 +3239,13 @@ static struct file_operations usb_sisusb_fops = {
 };
 
 static struct usb_class_driver usb_sisusb_class = {
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
         .name =         "usb/sisusbvga%d",
-        .fops =         &usb_sisusb_fops,
         .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
+#else
+        .name =         "sisusbvga%d",
+#endif
+        .fops =         &usb_sisusb_fops,
         .minor_base =   SISUSB_MINOR
 };
 
@@ -2994,12 +3342,25 @@ static int sisusb_probe(struct usb_interface *intf,
         printk(KERN_INFO "sisusbvga[%d]: Allocated %d output buffers\n",
                                         sisusb->minor, sisusb->numobufs);
 
+#ifdef INCL_SISUSB_CON
+        /* Allocate our SiS_Pr */
+        if (!(sisusb->SiS_Pr = kmalloc(sizeof(struct SiS_Private), GFP_KERNEL))) {
+                printk(KERN_ERR
+                        "sisusbvga[%d]: Failed to allocate SiS_Pr\n",
+                        sisusb->minor);
+        }
+#endif
+
         /* Do remaining init stuff */
 
         init_waitqueue_head(&sisusb->wait_q);
 
         usb_set_intfdata(intf, sisusb);
 
+        usb_get_dev(sisusb->sisusb_dev);
+
+        sisusb->present = 1;
+
 #ifdef SISUSB_OLD_CONFIG_COMPAT
         {
         int ret;
@@ -3014,14 +3375,19 @@ static int sisusb_probe(struct usb_interface *intf,
                         sisusb->minor);
         else
                 sisusb->ioctl32registered = 1;
-
         }
 #endif
 
-        sisusb->present = 1;
-
         if (dev->speed == USB_SPEED_HIGH) {
-                if (sisusb_init_gfxdevice(sisusb, 1))
+                int initscreen = 1;
+#ifdef INCL_SISUSB_CON
+                if (sisusb_first_vc > 0 &&
+                    sisusb_last_vc > 0 &&
+                    sisusb_first_vc <= sisusb_last_vc &&
+                    sisusb_last_vc <= MAX_NR_CONSOLES)
+                        initscreen = 0;
+#endif
+                if (sisusb_init_gfxdevice(sisusb, initscreen))
                         printk(KERN_ERR
                                 "sisusbvga[%d]: Failed to early "
                                 "initialize device\n",
@@ -3035,6 +3401,16 @@ static int sisusb_probe(struct usb_interface *intf,
 
         sisusb->ready = 1;
 
+#ifdef SISUSBENDIANTEST
+        printk(KERN_DEBUG "sisusb: *** RWTEST ***\n");
+        sisusb_testreadwrite(sisusb);
+        printk(KERN_DEBUG "sisusb: *** RWTEST END ***\n");
+#endif
+
+#ifdef INCL_SISUSB_CON
+        sisusb_console_init(sisusb, sisusb_first_vc, sisusb_last_vc);
+#endif
+
         return 0;
 
 error_4:
@@ -3053,13 +3429,20 @@ static void sisusb_disconnect(struct usb_interface *intf)
         struct sisusb_usb_data *sisusb;
         int minor;
 
-        down(&disconnect_sem);
-
         /* This should *not* happen */
-        if (!(sisusb = usb_get_intfdata(intf))) {
-                up(&disconnect_sem);
+        if (!(sisusb = usb_get_intfdata(intf)))
                 return;
-        }
+
+#ifdef INCL_SISUSB_CON
+        sisusb_console_exit(sisusb);
+#endif
+
+        /* The above code doesn't need the disconnect
+         * semaphore to be down; its meaning is to
+         * protect all other routines from the disconnect
+         * case, not the other way round.
+         */
+        down(&disconnect_sem);
 
         down(&sisusb->lock);
 
@@ -3123,11 +3506,17 @@ static int __init usb_sisusb_init(void)
 {
         int retval;
 
+#ifdef INCL_SISUSB_CON
+        sisusb_init_concode();
+#endif
+
         if (!(retval = usb_register(&sisusb_driver))) {
+
                 printk(KERN_INFO "sisusb: Driver version %d.%d.%d\n",
                         SISUSB_VERSION, SISUSB_REVISION, SISUSB_PATCHLEVEL);
                 printk(KERN_INFO
                         "sisusb: Copyright (C) 2005 Thomas Winischhofer\n");
+
         }
 
         return retval;
@@ -3142,6 +3531,6 @@ module_init(usb_sisusb_init);
 module_exit(usb_sisusb_exit);
 
 MODULE_AUTHOR("Thomas Winischhofer <thomas@winischhofer.net>");
-MODULE_DESCRIPTION("sisusb - Driver for Net2280/SiS315-based USB2VGA dongles");
+MODULE_DESCRIPTION("sisusbvga - Driver for Net2280/SiS315-based USB2VGA dongles");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb.h b/drivers/usb/misc/sisusbvga/sisusb.h
index 1306d006a25a..401ff21d7881 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.h
+++ b/drivers/usb/misc/sisusbvga/sisusb.h
@@ -46,15 +46,36 @@
 #endif
 #endif
 
+/* For older kernels, support for text consoles is by default
+ * off. To ensable text console support, change the following:
+ */
+#if 0
+#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
+#define CONFIG_USB_SISUSBVGA_CON
+#endif
+#endif
+
 /* Version Information */
 
 #define SISUSB_VERSION          0
 #define SISUSB_REVISION         0
-#define SISUSB_PATCHLEVEL       7
+#define SISUSB_PATCHLEVEL       8
+
+/* Include console and mode switching code? */
+
+#ifdef CONFIG_USB_SISUSBVGA_CON
+#define INCL_SISUSB_CON         1
+#endif
+
+#ifdef INCL_SISUSB_CON
+#include <linux/console.h>
+#include <linux/vt_kern.h>
+#include "sisusb_struct.h"
+#endif
 
 /* USB related */
 
-#define SISUSB_MINOR    133             /* FIXME */
+#define SISUSB_MINOR            133     /* official */
 
 /* Size of the sisusb input/output buffers */
 #define SISUSB_IBUF_SIZE  0x01000
@@ -131,6 +152,26 @@ struct sisusb_usb_data {
         unsigned char gfxinit;          /* graphics core initialized? */
         unsigned short chipid, chipvendor;
         unsigned short chiprevision;
+#ifdef INCL_SISUSB_CON
+        struct SiS_Private *SiS_Pr;
+        unsigned long scrbuf;
+        unsigned int scrbuf_size;
+        int haveconsole, con_first, con_last;
+        int havethisconsole[MAX_NR_CONSOLES];
+        int textmodedestroyed;
+        unsigned int sisusb_num_columns; /* real number, not vt's idea */
+        int cur_start_addr, con_rolled_over;
+        int sisusb_cursor_loc, bad_cursor_pos;
+        int sisusb_cursor_size_from;
+        int sisusb_cursor_size_to;
+        int current_font_height, current_font_512;
+        int font_backup_size, font_backup_height, font_backup_512;
+        char *font_backup;
+        int font_slot;
+        struct vc_data *sisusb_display_fg;
+        int is_gfx;
+        int con_blanked;
+#endif
 };
 
 #define to_sisusb_dev(d) container_of(d, struct sisusb_usb_data, kref)
@@ -249,7 +290,9 @@ struct sisusb_info {
 
         __u32   sisusb_fbdevactive;     /* != 0 if framebuffer device active */
 
-        __u8    sisusb_reserved[32];    /* for future use */
+        __u32   sisusb_conactive;       /* != 0 if console driver active */
+
+        __u8    sisusb_reserved[28];    /* for future use */
 };
 
 struct sisusb_command {
@@ -261,18 +304,24 @@ struct sisusb_command {
         __u32  data4;           /* for future use */
 };
 
-#define SUCMD_GET      0x01     /* for all: data0 = index, data3 = port */
-#define SUCMD_SET      0x02     /* data1 = value */
-#define SUCMD_SETOR    0x03     /* data1 = or */
-#define SUCMD_SETAND   0x04     /* data1 = and */
-#define SUCMD_SETANDOR 0x05     /* data1 = and, data2 = or */
-#define SUCMD_SETMASK  0x06     /* data1 = data, data2 = mask */
+#define SUCMD_GET       0x01    /* for all: data0 = index, data3 = port */
+#define SUCMD_SET       0x02    /* data1 = value */
+#define SUCMD_SETOR     0x03    /* data1 = or */
+#define SUCMD_SETAND    0x04    /* data1 = and */
+#define SUCMD_SETANDOR  0x05    /* data1 = and, data2 = or */
+#define SUCMD_SETMASK   0x06    /* data1 = data, data2 = mask */
 
-#define SUCMD_CLRSCR   0x07     /* data0:1:2 = length, data3 = address */
+#define SUCMD_CLRSCR    0x07    /* data0:1:2 = length, data3 = address */
+
+#define SUCMD_HANDLETEXTMODE 0x08 /* Reset/destroy text mode */
+
+#define SUCMD_SETMODE   0x09    /* Set a display mode (data3 = SiS mode) */
+#define SUCMD_SETVESAMODE 0x0a  /* Set a display mode (data3 = VESA mode) */
 
 #define SISUSB_COMMAND          _IOWR(0xF3,0x3D,struct sisusb_command)
-#define SISUSB_GET_CONFIG_SIZE  _IOR(0xF3,0x3E,__u32)
-#define SISUSB_GET_CONFIG       _IOR(0xF3,0x3F,struct sisusb_info)
+#define SISUSB_GET_CONFIG_SIZE  _IOR(0xF3,0x3E,__u32)
+#define SISUSB_GET_CONFIG       _IOR(0xF3,0x3F,struct sisusb_info)
+
 
 #endif /* SISUSB_H */
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb_con.c b/drivers/usb/misc/sisusbvga/sisusb_con.c
new file mode 100644
index 000000000000..24584463553d
--- /dev/null
+++ b/drivers/usb/misc/sisusbvga/sisusb_con.c
@@ -0,0 +1,1658 @@
+/*
+ * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
+ *
+ * VGA text mode console part
+ *
+ * Copyright (C) 2005 by Thomas Winischhofer, Vienna, Austria
+ *
+ * If distributed as part of the Linux kernel, this code is licensed under the
+ * terms of the GPL v2.
+ *
+ * Otherwise, the following license terms apply:
+ *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * * 1) Redistributions of source code must retain the above copyright
+ * *    notice, this list of conditions and the following disclaimer.
+ * * 2) Redistributions in binary form must reproduce the above copyright
+ * *    notice, this list of conditions and the following disclaimer in the
+ * *    documentation and/or other materials provided with the distribution.
+ * * 3) The name of the author may not be used to endorse or promote products
+ * *    derived from this software without specific psisusbr written permission.
+ * *
+ * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESSED OR
+ * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author: Thomas Winischhofer <thomas@winischhofer.net>
+ *
+ * Portions based on vgacon.c which are
+ *      Created 28 Sep 1997 by Geert Uytterhoeven
+ *      Rewritten by Martin Mares <mj@ucw.cz>, July 1998
+ *      based on code Copyright (C) 1991, 1992  Linus Torvalds
+ *                          1995  Jay Estabrook
+ *
+ * A note on using in_atomic() in here: We can't handle console
+ * calls from non-schedulable context due to our USB-dependend
+ * nature. For now, this driver just ignores any calls if it
+ * detects this state.
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/fs.h>
+#include <linux/tty.h>
+#include <linux/console.h>
+#include <linux/string.h>
+#include <linux/kd.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/vt_kern.h>
+#include <linux/selection.h>
+#include <linux/spinlock.h>
+#include <linux/kref.h>
+#include <linux/smp_lock.h>
+#include <linux/ioport.h>
+#include <linux/interrupt.h>
+#include <linux/vmalloc.h>
+
+#include "sisusb.h"
+
+#ifdef INCL_SISUSB_CON
+extern int sisusb_setreg(struct sisusb_usb_data *, int, u8);
+extern int sisusb_getreg(struct sisusb_usb_data *, int, u8 *);
+extern int sisusb_setidxreg(struct sisusb_usb_data *, int, u8, u8);
+extern int sisusb_getidxreg(struct sisusb_usb_data *, int, u8, u8 *);
+extern int sisusb_setidxregor(struct sisusb_usb_data *, int, u8, u8);
+extern int sisusb_setidxregand(struct sisusb_usb_data *, int, u8, u8);
+extern int sisusb_setidxregandor(struct sisusb_usb_data *, int, u8, u8, u8);
+
+extern int sisusb_writeb(struct sisusb_usb_data *sisusb, u32 adr, u8 data);
+extern int sisusb_readb(struct sisusb_usb_data *sisusb, u32 adr, u8 *data);
+extern int sisusb_writew(struct sisusb_usb_data *sisusb, u32 adr, u16 data);
+extern int sisusb_readw(struct sisusb_usb_data *sisusb, u32 adr, u16 *data);
+extern int sisusb_copy_memory(struct sisusb_usb_data *sisusb, char *src,
+                        u32 dest, int length, size_t *bytes_written);
+
+extern void sisusb_delete(struct kref *kref);
+extern int sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init);
+
+extern int SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo);
+
+#define sisusbcon_writew(val, addr)     (*(addr) = (val))
+#define sisusbcon_readw(addr)           (*(addr))
+#define sisusbcon_memmovew(d, s, c)     memmove(d, s, c)
+#define sisusbcon_memcpyw(d, s, c)      memcpy(d, s, c)
+
+/* vc_data -> sisusb conversion table */
+static struct sisusb_usb_data *mysisusbs[MAX_NR_CONSOLES];
+
+/* Forward declaration */
+static const struct consw sisusb_con;
+
+extern struct semaphore disconnect_sem;
+
+static inline void
+sisusbcon_memsetw(u16 *s, u16 c, unsigned int count)
+{
+        count /= 2;
+        while (count--)
+                sisusbcon_writew(c, s++);
+}
+
+static inline void
+sisusb_initialize(struct sisusb_usb_data *sisusb)
+{
+        /* Reset cursor and start address */
+        if (sisusb_setidxreg(sisusb, SISCR, 0x0c, 0x00))
+                return;
+        if (sisusb_setidxreg(sisusb, SISCR, 0x0d, 0x00))
+                return;
+        if (sisusb_setidxreg(sisusb, SISCR, 0x0e, 0x00))
+                return;
+        sisusb_setidxreg(sisusb, SISCR, 0x0f, 0x00);
+}
+
+static inline void
+sisusbcon_set_start_address(struct sisusb_usb_data *sisusb, struct vc_data *c)
+{
+        sisusb->cur_start_addr = (c->vc_visible_origin - sisusb->scrbuf) / 2;
+
+        sisusb_setidxreg(sisusb, SISCR, 0x0c, (sisusb->cur_start_addr >> 8));
+        sisusb_setidxreg(sisusb, SISCR, 0x0d, (sisusb->cur_start_addr & 0xff));
+}
+
+void
+sisusb_set_cursor(struct sisusb_usb_data *sisusb, unsigned int location)
+{
+        if (sisusb->sisusb_cursor_loc == location)
+                return;
+
+        sisusb->sisusb_cursor_loc = location;
+
+        /* Hardware bug: Text cursor appears twice or not at all
+         * at some positions. Work around it with the cursor skew
+         * bits.
+         */
+
+        if ((location & 0x0007) == 0x0007) {
+                sisusb->bad_cursor_pos = 1;
+                location--;
+                if (sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0x1f, 0x20))
+                        return;
+        } else if (sisusb->bad_cursor_pos) {
+                if (sisusb_setidxregand(sisusb, SISCR, 0x0b, 0x1f))
+                        return;
+                sisusb->bad_cursor_pos = 0;
+        }
+
+        if (sisusb_setidxreg(sisusb, SISCR, 0x0e, (location >> 8)))
+                return;
+        sisusb_setidxreg(sisusb, SISCR, 0x0f, (location & 0xff));
+}
+
+static inline struct sisusb_usb_data *
+sisusb_get_sisusb(unsigned short console)
+{
+        return mysisusbs[console];
+}
+
+static inline int
+sisusb_sisusb_valid(struct sisusb_usb_data *sisusb)
+{
+        if (!sisusb->present || !sisusb->ready || !sisusb->sisusb_dev)
+                return 0;
+
+        return 1;
+}
+
+static struct sisusb_usb_data *
+sisusb_get_sisusb_lock_and_check(unsigned short console)
+{
+        struct sisusb_usb_data *sisusb;
+
+        /* We can't handle console calls in non-schedulable
+         * context due to our locks and the USB transport.
+         * So we simply ignore them. This should only affect
+         * some calls to printk.
+         */
+        if (in_atomic())
+                return NULL;
+
+        if (!(sisusb = sisusb_get_sisusb(console)))
+                return NULL;
+
+        down(&sisusb->lock);
+
+        if (!sisusb_sisusb_valid(sisusb) ||
+            !sisusb->havethisconsole[console]) {
+                up(&sisusb->lock);
+                return NULL;
+        }
+
+        return sisusb;
+}
+
+static int
+sisusb_is_inactive(struct vc_data *c, struct sisusb_usb_data *sisusb)
+{
+        if (sisusb->is_gfx ||
+            sisusb->textmodedestroyed ||
+            c->vc_mode != KD_TEXT)
+                return 1;
+
+        return 0;
+}
+
+/* con_startup console interface routine */
+static const char *
+sisusbcon_startup(void)
+{
+        return "SISUSBCON";
+}
+
+/* con_init console interface routine */
+static void
+sisusbcon_init(struct vc_data *c, int init)
+{
+        struct sisusb_usb_data *sisusb;
+        int cols, rows;
+
+        /* This is called by take_over_console(),
+         * ie by us/under our control. It is
+         * only called after text mode and fonts
+         * are set up/restored.
+         */
+
+        down(&disconnect_sem);
+
+        if (!(sisusb = sisusb_get_sisusb(c->vc_num))) {
+                up(&disconnect_sem);
+                return;
+        }
+
+        down(&sisusb->lock);
+
+        if (!sisusb_sisusb_valid(sisusb)) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                return;
+        }
+
+        c->vc_can_do_color = 1;
+
+        c->vc_complement_mask = 0x7700;
+
+        c->vc_hi_font_mask = sisusb->current_font_512 ? 0x0800 : 0;
+
+        sisusb->haveconsole = 1;
+
+        sisusb->havethisconsole[c->vc_num] = 1;
+
+        /* We only support 640x400 */
+        c->vc_scan_lines = 400;
+
+        c->vc_font.height = sisusb->current_font_height;
+
+        /* We only support width = 8 */
+        cols = 80;
+        rows = c->vc_scan_lines / c->vc_font.height;
+
+        /* Increment usage count for our sisusb.
+         * Doing so saves us from upping/downing
+         * the disconnect semaphore; we can't
+         * lose our sisusb until this is undone
+         * in con_deinit. For all other console
+         * interface functions, it suffices to
+         * use sisusb->lock and do a quick check
+         * of sisusb for device disconnection.
+         */
+        kref_get(&sisusb->kref);
+
+        if (!*c->vc_uni_pagedir_loc)
+                con_set_default_unimap(c);
+
+        up(&sisusb->lock);
+
+        up(&disconnect_sem);
+
+        if (init) {
+                c->vc_cols = cols;
+                c->vc_rows = rows;
+        } else
+                vc_resize(c, cols, rows);
+}
+
+/* con_deinit console interface routine */
+static void
+sisusbcon_deinit(struct vc_data *c)
+{
+        struct sisusb_usb_data *sisusb;
+        int i;
+
+        /* This is called by take_over_console()
+         * and others, ie not under our control.
+         */
+
+        down(&disconnect_sem);
+
+        if (!(sisusb = sisusb_get_sisusb(c->vc_num))) {
+                up(&disconnect_sem);
+                return;
+        }
+
+        down(&sisusb->lock);
+
+        /* Clear ourselves in mysisusbs */
+        mysisusbs[c->vc_num] = NULL;
+
+        sisusb->havethisconsole[c->vc_num] = 0;
+
+        /* Free our font buffer if all consoles are gone */
+        if (sisusb->font_backup) {
+                for(i = 0; i < MAX_NR_CONSOLES; i++) {
+                        if (sisusb->havethisconsole[c->vc_num])
+                                break;
+                }
+                if (i == MAX_NR_CONSOLES) {
+                        vfree(sisusb->font_backup);
+                        sisusb->font_backup = NULL;
+                }
+        }
+
+        up(&sisusb->lock);
+
+        /* decrement the usage count on our sisusb */
+        kref_put(&sisusb->kref, sisusb_delete);
+
+        up(&disconnect_sem);
+}
+
+/* interface routine */
+static u8
+sisusbcon_build_attr(struct vc_data *c, u8 color, u8 intensity,
+                            u8 blink, u8 underline, u8 reverse)
+{
+        u8 attr = color;
+
+        if (underline)
+                attr = (attr & 0xf0) | c->vc_ulcolor;
+        else if (intensity == 0)
+                attr = (attr & 0xf0) | c->vc_halfcolor;
+
+        if (reverse)
+                attr = ((attr) & 0x88) |
+                       ((((attr) >> 4) |
+                       ((attr) << 4)) & 0x77);
+
+        if (blink)
+                attr ^= 0x80;
+
+        if (intensity == 2)
+                attr ^= 0x08;
+
+        return attr;
+}
+
+/* Interface routine */
+static void
+sisusbcon_invert_region(struct vc_data *vc, u16 *p, int count)
+{
+        /* Invert a region. This is called with a pointer
+         * to the console's internal screen buffer. So we
+         * simply do the inversion there and rely on
+         * a call to putc(s) to update the real screen.
+         */
+
+        while (count--) {
+                u16 a = sisusbcon_readw(p);
+
+                a = ((a) & 0x88ff)        |
+                    (((a) & 0x7000) >> 4) |
+                    (((a) & 0x0700) << 4);
+
+                sisusbcon_writew(a, p++);
+        }
+}
+
+#define SISUSB_VADDR(x,y) \
+        ((u16 *)c->vc_origin + \
+        (y) * sisusb->sisusb_num_columns + \
+        (x))
+
+#define SISUSB_HADDR(x,y) \
+        ((u16 *)(sisusb->vrambase + (c->vc_origin - sisusb->scrbuf)) + \
+        (y) * sisusb->sisusb_num_columns + \
+        (x))
+
+/* Interface routine */
+static void
+sisusbcon_putc(struct vc_data *c, int ch, int y, int x)
+{
+        struct sisusb_usb_data *sisusb;
+        ssize_t written;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        /* Don't need to put the character into buffer ourselves,
+         * because the vt does this BEFORE calling us.
+         */
+#if 0
+        sisusbcon_writew(ch, SISUSB_VADDR(x, y));
+#endif
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+
+        sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
+                                (u32)SISUSB_HADDR(x, y), 2, &written);
+
+        up(&sisusb->lock);
+}
+
+/* Interface routine */
+static void
+sisusbcon_putcs(struct vc_data *c, const unsigned short *s,
+                         int count, int y, int x)
+{
+        struct sisusb_usb_data *sisusb;
+        ssize_t written;
+        u16 *dest;
+        int i;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        /* Need to put the characters into the buffer ourselves,
+         * because the vt does this AFTER calling us.
+         */
+
+        dest = SISUSB_VADDR(x, y);
+
+        for (i = count; i > 0; i--)
+                sisusbcon_writew(sisusbcon_readw(s++), dest++);
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+        sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(x, y),
+                                (u32)SISUSB_HADDR(x, y), count * 2, &written);
+
+        up(&sisusb->lock);
+}
+
+/* Interface routine */
+static void
+sisusbcon_clear(struct vc_data *c, int y, int x, int height, int width)
+{
+        struct sisusb_usb_data *sisusb;
+        u16 eattr = c->vc_video_erase_char;
+        ssize_t written;
+        int i, length, cols;
+        u16 *dest;
+
+        if (width <= 0 || height <= 0)
+                return;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        /* Need to clear buffer ourselves, because the vt does
+         * this AFTER calling us.
+         */
+
+        dest = SISUSB_VADDR(x, y);
+
+        cols = sisusb->sisusb_num_columns;
+
+        if (width > cols)
+                width = cols;
+
+        if (x == 0 && width >= c->vc_cols) {
+
+                sisusbcon_memsetw(dest, eattr, height * cols * 2);
+
+        } else {
+
+                for (i = height; i > 0; i--, dest += cols)
+                        sisusbcon_memsetw(dest, eattr, width * 2);
+
+        }
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+        length = ((height * cols) - x - (cols - width - x)) * 2;
+
+
+        sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(x, y),
+                                (u32)SISUSB_HADDR(x, y), length, &written);
+
+        up(&sisusb->lock);
+}
+
+/* Interface routine */
+static void
+sisusbcon_bmove(struct vc_data *c, int sy, int sx,
+                         int dy, int dx, int height, int width)
+{
+        struct sisusb_usb_data *sisusb;
+        ssize_t written;
+        int cols, length;
+#if 0
+        u16 *src, *dest;
+        int i;
+#endif
+
+        if (width <= 0 || height <= 0)
+                return;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        cols = sisusb->sisusb_num_columns;
+
+        /* Don't need to move data outselves, because
+         * vt does this BEFORE calling us.
+         * This is only used by vt's insert/deletechar.
+         */
+#if 0
+        if (sx == 0 && dx == 0 && width >= c->vc_cols && width <= cols) {
+
+                sisusbcon_memmovew(SISUSB_VADDR(0, dy), SISUSB_VADDR(0, sy),
+                                        height * width * 2);
+
+        } else if (dy < sy || (dy == sy && dx < sx)) {
+
+                src  = SISUSB_VADDR(sx, sy);
+                dest = SISUSB_VADDR(dx, dy);
+
+                for (i = height; i > 0; i--) {
+                        sisusbcon_memmovew(dest, src, width * 2);
+                        src  += cols;
+                        dest += cols;
+                }
+
+        } else {
+
+                src  = SISUSB_VADDR(sx, sy + height - 1);
+                dest = SISUSB_VADDR(dx, dy + height - 1);
+
+                for (i = height; i > 0; i--) {
+                        sisusbcon_memmovew(dest, src, width * 2);
+                        src  -= cols;
+                        dest -= cols;
+                }
+
+        }
+#endif
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+        length = ((height * cols) - dx - (cols - width - dx)) * 2;
+
+
+        sisusb_copy_memory(sisusb, (unsigned char *)SISUSB_VADDR(dx, dy),
+                                (u32)SISUSB_HADDR(dx, dy), length, &written);
+
+        up(&sisusb->lock);
+}
+
+/* interface routine */
+static int
+sisusbcon_switch(struct vc_data *c)
+{
+        struct sisusb_usb_data *sisusb;
+        ssize_t written;
+        int length;
+
+        /* Returnvalue 0 means we have fully restored screen,
+         *      and vt doesn't need to call do_update_region().
+         * Returnvalue != 0 naturally means the opposite.
+         */
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return 0;
+
+        /* sisusb->lock is down */
+
+        /* Don't write to screen if in gfx mode */
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        /* That really should not happen. It would mean we are
+         * being called while the vc is using its private buffer
+         * as origin.
+         */
+        if (c->vc_origin == (unsigned long)c->vc_screenbuf) {
+                up(&sisusb->lock);
+                printk(KERN_DEBUG "sisusb: ASSERT ORIGIN != SCREENBUF!\n");
+                return 0;
+        }
+
+        /* Check that we don't copy too much */
+        length = min((int)c->vc_screenbuf_size,
+                        (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
+
+        /* Restore the screen contents */
+        sisusbcon_memcpyw((u16 *)c->vc_origin, (u16 *)c->vc_screenbuf,
+                                                                length);
+
+        sisusb_copy_memory(sisusb, (unsigned char *)c->vc_origin,
+                                (u32)SISUSB_HADDR(0, 0),
+                                length, &written);
+
+        up(&sisusb->lock);
+
+        return 0;
+}
+
+/* interface routine */
+static void
+sisusbcon_save_screen(struct vc_data *c)
+{
+        struct sisusb_usb_data *sisusb;
+        int length;
+
+        /* Save the current screen contents to vc's private
+         * buffer.
+         */
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+        /* Check that we don't copy too much */
+        length = min((int)c->vc_screenbuf_size,
+                        (int)(sisusb->scrbuf + sisusb->scrbuf_size - c->vc_origin));
+
+        /* Save the screen contents to vc's private buffer */
+        sisusbcon_memcpyw((u16 *)c->vc_screenbuf, (u16 *)c->vc_origin,
+                                                                length);
+
+        up(&sisusb->lock);
+}
+
+/* interface routine */
+static int
+sisusbcon_set_palette(struct vc_data *c, unsigned char *table)
+{
+        struct sisusb_usb_data *sisusb;
+        int i, j;
+
+        /* Return value not used by vt */
+
+        if (!CON_IS_VISIBLE(c))
+                return -EINVAL;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return -EINVAL;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return -EINVAL;
+        }
+
+        for (i = j = 0; i < 16; i++) {
+                if (sisusb_setreg(sisusb, SISCOLIDX, table[i]))
+                        break;
+                if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
+                        break;
+                if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
+                        break;
+                if (sisusb_setreg(sisusb, SISCOLDATA, c->vc_palette[j++] >> 2))
+                        break;
+        }
+
+        up(&sisusb->lock);
+
+        return 0;
+}
+
+/* interface routine */
+static int
+sisusbcon_blank(struct vc_data *c, int blank, int mode_switch)
+{
+        struct sisusb_usb_data *sisusb;
+        u8 sr1, cr17, pmreg, cr63;
+        ssize_t written;
+        int ret = 0;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return 0;
+
+        /* sisusb->lock is down */
+
+        if (mode_switch)
+                sisusb->is_gfx = blank ? 1 : 0;
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        switch (blank) {
+
+        case 1:         /* Normal blanking: Clear screen */
+        case -1:
+                sisusbcon_memsetw((u16 *)c->vc_origin,
+                                c->vc_video_erase_char,
+                                c->vc_screenbuf_size);
+                sisusb_copy_memory(sisusb,
+                                (unsigned char *)c->vc_origin,
+                                (u32)(sisusb->vrambase +
+                                        (c->vc_origin - sisusb->scrbuf)),
+                                c->vc_screenbuf_size, &written);
+                sisusb->con_blanked = 1;
+                ret = 1;
+                break;
+
+        default:        /* VESA blanking */
+                switch (blank) {
+                case 0: /* Unblank */
+                        sr1   = 0x00;
+                        cr17  = 0x80;
+                        pmreg = 0x00;
+                        cr63  = 0x00;
+                        ret = 1;
+                        sisusb->con_blanked = 0;
+                        break;
+                case VESA_VSYNC_SUSPEND + 1:
+                        sr1   = 0x20;
+                        cr17  = 0x80;
+                        pmreg = 0x80;
+                        cr63  = 0x40;
+                        break;
+                case VESA_HSYNC_SUSPEND + 1:
+                        sr1   = 0x20;
+                        cr17  = 0x80;
+                        pmreg = 0x40;
+                        cr63  = 0x40;
+                        break;
+                case VESA_POWERDOWN + 1:
+                        sr1   = 0x20;
+                        cr17  = 0x00;
+                        pmreg = 0xc0;
+                        cr63  = 0x40;
+                        break;
+                default:
+                        up(&sisusb->lock);
+                        return -EINVAL;
+                }
+
+                sisusb_setidxregandor(sisusb, SISSR, 0x01, ~0x20, sr1);
+                sisusb_setidxregandor(sisusb, SISCR, 0x17, 0x7f, cr17);
+                sisusb_setidxregandor(sisusb, SISSR, 0x1f, 0x3f, pmreg);
+                sisusb_setidxregandor(sisusb, SISCR, 0x63, 0xbf, cr63);
+
+        }
+
+        up(&sisusb->lock);
+
+        return ret;
+}
+
+/* interface routine */
+static int
+sisusbcon_scrolldelta(struct vc_data *c, int lines)
+{
+        struct sisusb_usb_data *sisusb;
+        int margin = c->vc_size_row * 4;
+        int ul, we, p, st;
+
+        /* The return value does not seem to be used */
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return 0;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        if (!lines)             /* Turn scrollback off */
+                c->vc_visible_origin = c->vc_origin;
+        else {
+
+                if (sisusb->con_rolled_over >
+                                (c->vc_scr_end - sisusb->scrbuf) + margin) {
+
+                        ul = c->vc_scr_end - sisusb->scrbuf;
+                        we = sisusb->con_rolled_over + c->vc_size_row;
+
+                } else {
+
+                        ul = 0;
+                        we = sisusb->scrbuf_size;
+
+                }
+
+                p = (c->vc_visible_origin - sisusb->scrbuf - ul + we) % we +
+                                lines * c->vc_size_row;
+
+                st = (c->vc_origin - sisusb->scrbuf - ul + we) % we;
+
+                if (st < 2 * margin)
+                        margin = 0;
+
+                if (p < margin)
+                        p = 0;
+
+                if (p > st - margin)
+                        p = st;
+
+                c->vc_visible_origin = sisusb->scrbuf + (p + ul) % we;
+        }
+
+        sisusbcon_set_start_address(sisusb, c);
+
+        up(&sisusb->lock);
+
+        return 1;
+}
+
+/* Interface routine */
+static void
+sisusbcon_cursor(struct vc_data *c, int mode)
+{
+        struct sisusb_usb_data *sisusb;
+        int from, to, baseline;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return;
+        }
+
+        if (c->vc_origin != c->vc_visible_origin) {
+                c->vc_visible_origin = c->vc_origin;
+                sisusbcon_set_start_address(sisusb, c);
+        }
+
+        if (mode == CM_ERASE) {
+                sisusb_setidxregor(sisusb, SISCR, 0x0a, 0x20);
+                sisusb->sisusb_cursor_size_to = -1;
+                up(&sisusb->lock);
+                return;
+        }
+
+        sisusb_set_cursor(sisusb, (c->vc_pos - sisusb->scrbuf) / 2);
+
+        baseline = c->vc_font.height - (c->vc_font.height < 10 ? 1 : 2);
+
+        switch (c->vc_cursor_type & 0x0f) {
+                case CUR_BLOCK:         from = 1;
+                                        to   = c->vc_font.height;
+                                        break;
+                case CUR_TWO_THIRDS:    from = c->vc_font.height / 3;
+                                        to   = baseline;
+                                        break;
+                case CUR_LOWER_HALF:    from = c->vc_font.height / 2;
+                                        to   = baseline;
+                                        break;
+                case CUR_LOWER_THIRD:   from = (c->vc_font.height * 2) / 3;
+                                        to   = baseline;
+                                        break;
+                case CUR_NONE:          from = 31;
+                                        to = 30;
+                                        break;
+                default:
+                case CUR_UNDERLINE:     from = baseline - 1;
+                                        to   = baseline;
+                                        break;
+        }
+
+        if (sisusb->sisusb_cursor_size_from != from ||
+            sisusb->sisusb_cursor_size_to != to) {
+
+                sisusb_setidxreg(sisusb, SISCR, 0x0a, from);
+                sisusb_setidxregandor(sisusb, SISCR, 0x0b, 0xe0, to);
+
+                sisusb->sisusb_cursor_size_from = from;
+                sisusb->sisusb_cursor_size_to   = to;
+        }
+
+        up(&sisusb->lock);
+}
+
+static int
+sisusbcon_scroll_area(struct vc_data *c, struct sisusb_usb_data *sisusb,
+                                        int t, int b, int dir, int lines)
+{
+        int cols = sisusb->sisusb_num_columns;
+        int length = ((b - t) * cols) * 2;
+        u16 eattr = c->vc_video_erase_char;
+        ssize_t written;
+
+        /* sisusb->lock is down */
+
+        /* Scroll an area which does not match the
+         * visible screen's dimensions. This needs
+         * to be done separately, as it does not
+         * use hardware panning.
+         */
+
+        switch (dir) {
+
+                case SM_UP:
+                        sisusbcon_memmovew(SISUSB_VADDR(0, t),
+                                           SISUSB_VADDR(0, t + lines),
+                                           (b - t - lines) * cols * 2);
+                        sisusbcon_memsetw(SISUSB_VADDR(0, b - lines), eattr,
+                                          lines * cols * 2);
+                        break;
+
+                case SM_DOWN:
+                        sisusbcon_memmovew(SISUSB_VADDR(0, t + lines),
+                                           SISUSB_VADDR(0, t),
+                                           (b - t - lines) * cols * 2);
+                        sisusbcon_memsetw(SISUSB_VADDR(0, t), eattr,
+                                          lines * cols * 2);
+                        break;
+        }
+
+        sisusb_copy_memory(sisusb, (char *)SISUSB_VADDR(0, t),
+                                (u32)SISUSB_HADDR(0, t), length, &written);
+
+        up(&sisusb->lock);
+
+        return 1;
+}
+
+/* Interface routine */
+static int
+sisusbcon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
+{
+        struct sisusb_usb_data *sisusb;
+        u16 eattr = c->vc_video_erase_char;
+        ssize_t written;
+        int copyall = 0;
+        unsigned long oldorigin;
+        unsigned int delta = lines * c->vc_size_row;
+        u32 originoffset;
+
+        /* Returning != 0 means we have done the scrolling successfully.
+         * Returning 0 makes vt do the scrolling on its own.
+         * Note that con_scroll is only called if the console is
+         * visible. In that case, the origin should be our buffer,
+         * not the vt's private one.
+         */
+
+        if (!lines)
+                return 1;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return 0;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb)) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        /* Special case */
+        if (t || b != c->vc_rows)
+                return sisusbcon_scroll_area(c, sisusb, t, b, dir, lines);
+
+        if (c->vc_origin != c->vc_visible_origin) {
+                c->vc_visible_origin = c->vc_origin;
+                sisusbcon_set_start_address(sisusb, c);
+        }
+
+        /* limit amount to maximum realistic size */
+        if (lines > c->vc_rows)
+                lines = c->vc_rows;
+
+        oldorigin = c->vc_origin;
+
+        switch (dir) {
+
+        case SM_UP:
+
+                if (c->vc_scr_end + delta >=
+                                sisusb->scrbuf + sisusb->scrbuf_size) {
+                        sisusbcon_memcpyw((u16 *)sisusb->scrbuf,
+                                          (u16 *)(oldorigin + delta),
+                                          c->vc_screenbuf_size - delta);
+                        c->vc_origin = sisusb->scrbuf;
+                        sisusb->con_rolled_over = oldorigin - sisusb->scrbuf;
+                        copyall = 1;
+                } else
+                        c->vc_origin += delta;
+
+                sisusbcon_memsetw(
+                        (u16 *)(c->vc_origin + c->vc_screenbuf_size - delta),
+                                        eattr, delta);
+
+                break;
+
+        case SM_DOWN:
+
+                if (oldorigin - delta < sisusb->scrbuf) {
+                        sisusbcon_memmovew((u16 *)(sisusb->scrbuf +
+                                                        sisusb->scrbuf_size -
+                                                        c->vc_screenbuf_size +
+                                                        delta),
+                                           (u16 *)oldorigin,
+                                           c->vc_screenbuf_size - delta);
+                        c->vc_origin = sisusb->scrbuf +
+                                        sisusb->scrbuf_size -
+                                        c->vc_screenbuf_size;
+                        sisusb->con_rolled_over = 0;
+                        copyall = 1;
+                } else
+                        c->vc_origin -= delta;
+
+                c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
+
+                scr_memsetw((u16 *)(c->vc_origin), eattr, delta);
+
+                break;
+        }
+
+        originoffset = (u32)(c->vc_origin - sisusb->scrbuf);
+
+        if (copyall)
+                sisusb_copy_memory(sisusb,
+                        (char *)c->vc_origin,
+                        (u32)(sisusb->vrambase + originoffset),
+                        c->vc_screenbuf_size, &written);
+        else if (dir == SM_UP)
+                sisusb_copy_memory(sisusb,
+                        (char *)c->vc_origin + c->vc_screenbuf_size - delta,
+                        (u32)sisusb->vrambase + originoffset +
+                                        c->vc_screenbuf_size - delta,
+                        delta, &written);
+        else
+                sisusb_copy_memory(sisusb,
+                        (char *)c->vc_origin,
+                        (u32)(sisusb->vrambase + originoffset),
+                        delta, &written);
+
+        c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
+        c->vc_visible_origin = c->vc_origin;
+
+        sisusbcon_set_start_address(sisusb, c);
+
+        c->vc_pos = c->vc_pos - oldorigin + c->vc_origin;
+
+        up(&sisusb->lock);
+
+        return 1;
+}
+
+/* Interface routine */
+static int
+sisusbcon_set_origin(struct vc_data *c)
+{
+        struct sisusb_usb_data *sisusb;
+
+        /* Returning != 0 means we were successful.
+         * Returning 0 will vt make to use its own
+         *      screenbuffer as the origin.
+         */
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return 0;
+
+        /* sisusb->lock is down */
+
+        if (sisusb_is_inactive(c, sisusb) || sisusb->con_blanked) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        c->vc_origin = c->vc_visible_origin = sisusb->scrbuf;
+
+        sisusbcon_set_start_address(sisusb, c);
+
+        sisusb->con_rolled_over = 0;
+
+        up(&sisusb->lock);
+
+        return 1;
+}
+
+/* Interface routine */
+static int
+sisusbcon_resize(struct vc_data *c, unsigned int newcols, unsigned int newrows)
+{
+        struct sisusb_usb_data *sisusb;
+        int fh;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return -ENODEV;
+
+        fh = sisusb->current_font_height;
+
+        up(&sisusb->lock);
+
+        /* We are quite unflexible as regards resizing. The vt code
+         * handles sizes where the line length isn't equal the pitch
+         * quite badly. As regards the rows, our panning tricks only
+         * work well if the number of rows equals the visible number
+         * of rows.
+         */
+
+        if (newcols != 80 || c->vc_scan_lines / fh != newrows)
+                return -EINVAL;
+
+        return 0;
+}
+
+int
+sisusbcon_do_font_op(struct sisusb_usb_data *sisusb, int set, int slot,
+                        u8 *arg, int cmapsz, int ch512, int dorecalc,
+                        struct vc_data *c, int fh, int uplock)
+{
+        int font_select = 0x00, i, err = 0;
+        u32 offset = 0;
+        u8 dummy;
+
+        /* sisusb->lock is down */
+
+        /*
+         * The default font is kept in slot 0.
+         * A user font is loaded in slot 2 (256 ch)
+         * or 2+3 (512 ch).
+         */
+
+        if ((slot != 0 && slot != 2) || !fh) {
+                if (uplock)
+                        up(&sisusb->lock);
+                return -EINVAL;
+        }
+
+        if (set)
+                sisusb->font_slot = slot;
+
+        /* Default font is always 256 */
+        if (slot == 0)
+                ch512 = 0;
+        else
+                offset = 4 * cmapsz;
+
+        font_select = (slot == 0) ? 0x00 : (ch512 ? 0x0e : 0x0a);
+
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x04); /* Write to plane 2 */
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x07); /* Memory mode a0-bf */
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset */
+
+        if (err)
+                goto font_op_error;
+
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x03); /* Select plane read 2 */
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x00); /* Disable odd/even */
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x00); /* Address range a0-bf */
+
+        if (err)
+                goto font_op_error;
+
+        if (arg) {
+                if (set)
+                        for (i = 0; i < cmapsz; i++) {
+                                err |= sisusb_writeb(sisusb,
+                                        sisusb->vrambase + offset + i,
+                                        arg[i]);
+                                if (err)
+                                        break;
+                        }
+                else
+                        for (i = 0; i < cmapsz; i++) {
+                                err |= sisusb_readb(sisusb,
+                                        sisusb->vrambase + offset + i,
+                                        &arg[i]);
+                                if (err)
+                                        break;
+                        }
+
+                /*
+                 * In 512-character mode, the character map is not contiguous if
+                 * we want to remain EGA compatible -- which we do
+                 */
+
+                if (ch512) {
+                        if (set)
+                                for (i = 0; i < cmapsz; i++) {
+                                        err |= sisusb_writeb(sisusb,
+                                                sisusb->vrambase + offset +
+                                                        (2 * cmapsz) + i,
+                                                arg[cmapsz + i]);
+                                        if (err)
+                                                break;
+                                }
+                        else
+                                for (i = 0; i < cmapsz; i++) {
+                                        err |= sisusb_readb(sisusb,
+                                                sisusb->vrambase + offset +
+                                                        (2 * cmapsz) + i,
+                                                &arg[cmapsz + i]);
+                                        if (err)
+                                                break;
+                                }
+                }
+        }
+
+        if (err)
+                goto font_op_error;
+
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x01); /* Reset */
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x02, 0x03); /* Write to planes 0+1 */
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x04, 0x03); /* Memory mode a0-bf */
+        if (set)
+                sisusb_setidxreg(sisusb, SISSR, 0x03, font_select);
+        err |= sisusb_setidxreg(sisusb, SISSR, 0x00, 0x03); /* Reset end */
+
+        if (err)
+                goto font_op_error;
+
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x04, 0x00); /* Select plane read 0 */
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x05, 0x10); /* Enable odd/even */
+        err |= sisusb_setidxreg(sisusb, SISGR, 0x06, 0x06); /* Address range b8-bf */
+
+        if (err)
+                goto font_op_error;
+
+        if ((set) && (ch512 != sisusb->current_font_512)) {
+
+                /* Font is shared among all our consoles.
+                 * And so is the hi_font_mask.
+                 */
+                for (i = 0; i < MAX_NR_CONSOLES; i++) {
+                        struct vc_data *c = vc_cons[i].d;
+                        if (c && c->vc_sw == &sisusb_con)
+                                c->vc_hi_font_mask = ch512 ? 0x0800 : 0;
+                }
+
+                sisusb->current_font_512 = ch512;
+
+                /* color plane enable register:
+                        256-char: enable intensity bit
+                        512-char: disable intensity bit */
+                sisusb_getreg(sisusb, SISINPSTAT, &dummy);
+                sisusb_setreg(sisusb, SISAR, 0x12);
+                sisusb_setreg(sisusb, SISAR, ch512 ? 0x07 : 0x0f);
+
+                sisusb_getreg(sisusb, SISINPSTAT, &dummy);
+                sisusb_setreg(sisusb, SISAR, 0x20);
+                sisusb_getreg(sisusb, SISINPSTAT, &dummy);
+        }
+
+        if (dorecalc) {
+
+                /*
+                 * Adjust the screen to fit a font of a certain height
+                 */
+
+                unsigned char ovr, vde, fsr;
+                int rows = 0, maxscan = 0;
+
+                if (c) {
+
+                        /* Number of video rows */
+                        rows = c->vc_scan_lines / fh;
+                        /* Scan lines to actually display-1 */
+                        maxscan = rows * fh - 1;
+
+                        /*printk(KERN_DEBUG "sisusb recalc rows %d maxscan %d fh %d sl %d\n",
+                                rows, maxscan, fh, c->vc_scan_lines);*/
+
+                        sisusb_getidxreg(sisusb, SISCR, 0x07, &ovr);
+                        vde = maxscan & 0xff;
+                        ovr = (ovr & 0xbd) |
+                              ((maxscan & 0x100) >> 7) |
+                              ((maxscan & 0x200) >> 3);
+                        sisusb_setidxreg(sisusb, SISCR, 0x07, ovr);
+                        sisusb_setidxreg(sisusb, SISCR, 0x12, vde);
+
+                }
+
+                sisusb_getidxreg(sisusb, SISCR, 0x09, &fsr);
+                fsr = (fsr & 0xe0) | (fh - 1);
+                sisusb_setidxreg(sisusb, SISCR, 0x09, fsr);
+                sisusb->current_font_height = fh;
+
+                sisusb->sisusb_cursor_size_from = -1;
+                sisusb->sisusb_cursor_size_to   = -1;
+
+        }
+
+        if (uplock)
+                up(&sisusb->lock);
+
+        if (dorecalc && c) {
+                int i, rows = c->vc_scan_lines / fh;
+
+                /* Now adjust our consoles' size */
+
+                for (i = 0; i < MAX_NR_CONSOLES; i++) {
+                        struct vc_data *vc = vc_cons[i].d;
+
+                        if (vc && vc->vc_sw == &sisusb_con) {
+                                if (CON_IS_VISIBLE(vc)) {
+                                        vc->vc_sw->con_cursor(vc, CM_DRAW);
+                                }
+                                vc->vc_font.height = fh;
+                                vc_resize(vc, 0, rows);
+                        }
+                }
+        }
+
+        return 0;
+
+font_op_error:
+        if (uplock)
+                up(&sisusb->lock);
+
+        return -EIO;
+}
+
+/* Interface routine */
+static int
+sisusbcon_font_set(struct vc_data *c, struct console_font *font,
+                                                        unsigned flags)
+{
+        struct sisusb_usb_data *sisusb;
+        unsigned charcount = font->charcount;
+
+        if (font->width != 8 || (charcount != 256 && charcount != 512))
+                return -EINVAL;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return -ENODEV;
+
+        /* sisusb->lock is down */
+
+        /* Save the user-provided font into a buffer. This
+         * is used for restoring text mode after quitting
+         * from X and for the con_getfont routine.
+         */
+        if (sisusb->font_backup) {
+                if (sisusb->font_backup_size < charcount) {
+                        vfree(sisusb->font_backup);
+                        sisusb->font_backup = NULL;
+                }
+        }
+
+        if (!sisusb->font_backup)
+                sisusb->font_backup = vmalloc(charcount * 32);
+
+        if (sisusb->font_backup) {
+                memcpy(sisusb->font_backup, font->data, charcount * 32);
+                sisusb->font_backup_size = charcount;
+                sisusb->font_backup_height = font->height;
+                sisusb->font_backup_512 = (charcount == 512) ? 1 : 0;
+        }
+
+        /* do_font_op ups sisusb->lock */
+
+        return sisusbcon_do_font_op(sisusb, 1, 2, font->data,
+                        8192, (charcount == 512),
+                        (!(flags & KD_FONT_FLAG_DONT_RECALC)) ? 1 : 0,
+                        c, font->height, 1);
+}
+
+/* Interface routine */
+static int
+sisusbcon_font_get(struct vc_data *c, struct console_font *font)
+{
+        struct sisusb_usb_data *sisusb;
+
+        if (!(sisusb = sisusb_get_sisusb_lock_and_check(c->vc_num)))
+                return -ENODEV;
+
+        /* sisusb->lock is down */
+
+        font->width = 8;
+        font->height = c->vc_font.height;
+        font->charcount = 256;
+
+        if (!font->data) {
+                up(&sisusb->lock);
+                return 0;
+        }
+
+        if (!sisusb->font_backup) {
+                up(&sisusb->lock);
+                return -ENODEV;
+        }
+
+        /* Copy 256 chars only, like vgacon */
+        memcpy(font->data, sisusb->font_backup, 256 * 32);
+
+        up(&sisusb->lock);
+
+        return 0;
+}
+
+/*
+ *  The console `switch' structure for the sisusb console
+ */
+
+static const struct consw sisusb_con = {
+        .owner =                THIS_MODULE,
+        .con_startup =          sisusbcon_startup,
+        .con_init =             sisusbcon_init,
+        .con_deinit =           sisusbcon_deinit,
+        .con_clear =            sisusbcon_clear,
+        .con_putc =             sisusbcon_putc,
+        .con_putcs =            sisusbcon_putcs,
+        .con_cursor =           sisusbcon_cursor,
+        .con_scroll =           sisusbcon_scroll,
+        .con_bmove =            sisusbcon_bmove,
+        .con_switch =           sisusbcon_switch,
+        .con_blank =            sisusbcon_blank,
+        .con_font_set =         sisusbcon_font_set,
+        .con_font_get =         sisusbcon_font_get,
+        .con_set_palette =      sisusbcon_set_palette,
+        .con_scrolldelta =      sisusbcon_scrolldelta,
+        .con_build_attr =       sisusbcon_build_attr,
+        .con_invert_region =    sisusbcon_invert_region,
+        .con_set_origin =       sisusbcon_set_origin,
+        .con_save_screen =      sisusbcon_save_screen,
+        .con_resize =           sisusbcon_resize,
+};
+
+/* Our very own dummy console driver */
+
+static const char *sisusbdummycon_startup(void)
+{
+    return "SISUSBVGADUMMY";
+}
+
+static void sisusbdummycon_init(struct vc_data *vc, int init)
+{
+    vc->vc_can_do_color = 1;
+    if (init) {
+        vc->vc_cols = 80;
+        vc->vc_rows = 25;
+    } else
+        vc_resize(vc, 80, 25);
+}
+
+static int sisusbdummycon_dummy(void)
+{
+    return 0;
+}
+
+#define SISUSBCONDUMMY  (void *)sisusbdummycon_dummy
+
+const struct consw sisusb_dummy_con = {
+        .owner =                THIS_MODULE,
+        .con_startup =          sisusbdummycon_startup,
+        .con_init =             sisusbdummycon_init,
+        .con_deinit =           SISUSBCONDUMMY,
+        .con_clear =            SISUSBCONDUMMY,
+        .con_putc =             SISUSBCONDUMMY,
+        .con_putcs =            SISUSBCONDUMMY,
+        .con_cursor =           SISUSBCONDUMMY,
+        .con_scroll =           SISUSBCONDUMMY,
+        .con_bmove =            SISUSBCONDUMMY,
+        .con_switch =           SISUSBCONDUMMY,
+        .con_blank =            SISUSBCONDUMMY,
+        .con_font_set =         SISUSBCONDUMMY,
+        .con_font_get =         SISUSBCONDUMMY,
+        .con_font_default =     SISUSBCONDUMMY,
+        .con_font_copy =        SISUSBCONDUMMY,
+        .con_set_palette =      SISUSBCONDUMMY,
+        .con_scrolldelta =      SISUSBCONDUMMY,
+};
+
+int
+sisusb_console_init(struct sisusb_usb_data *sisusb, int first, int last)
+{
+        int i, ret, minor = sisusb->minor;
+
+        down(&disconnect_sem);
+
+        down(&sisusb->lock);
+
+        /* Erm.. that should not happen */
+        if (sisusb->haveconsole || !sisusb->SiS_Pr) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                return 1;
+        }
+
+        sisusb->con_first = first;
+        sisusb->con_last  = last;
+
+        if (first > last ||
+            first > MAX_NR_CONSOLES ||
+            last > MAX_NR_CONSOLES) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                return 1;
+        }
+
+        /* If gfxcore not initialized or no consoles given, quit graciously */
+        if (!sisusb->gfxinit || first < 1 || last < 1) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                return 0;
+        }
+
+        sisusb->sisusb_cursor_loc       = -1;
+        sisusb->sisusb_cursor_size_from = -1;
+        sisusb->sisusb_cursor_size_to   = -1;
+
+        /* Set up text mode (and upload  default font) */
+        if (sisusb_reset_text_mode(sisusb, 1)) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                printk(KERN_ERR
+                        "sisusbvga[%d]: Failed to set up text mode\n",
+                        minor);
+                return 1;
+        }
+
+        /* Initialize some gfx registers */
+        sisusb_initialize(sisusb);
+
+        for (i = first - 1; i <= last - 1; i++) {
+                /* Save sisusb for our interface routines */
+                mysisusbs[i] = sisusb;
+        }
+
+        /* Initial console setup */
+        sisusb->sisusb_num_columns = 80;
+
+        /* Use a 32K buffer (matches b8000-bffff area) */
+        sisusb->scrbuf_size = 32 * 1024;
+
+        /* Allocate screen buffer */
+        if (!(sisusb->scrbuf = (unsigned long)vmalloc(sisusb->scrbuf_size))) {
+                up(&sisusb->lock);
+                up(&disconnect_sem);
+                printk(KERN_ERR
+                        "sisusbvga[%d]: Failed to allocate screen buffer\n",
+                        minor);
+                return 1;
+        }
+
+        up(&sisusb->lock);
+        up(&disconnect_sem);
+
+        /* Now grab the desired console(s) */
+        ret = take_over_console(&sisusb_con, first - 1, last - 1, 0);
+
+        if (!ret)
+                sisusb->haveconsole = 1;
+        else {
+                for (i = first - 1; i <= last - 1; i++)
+                        mysisusbs[i] = NULL;
+        }
+
+        return ret;
+}
+
+void
+sisusb_console_exit(struct sisusb_usb_data *sisusb)
+{
+        int i;
+
+        /* This is called if the device is disconnected
+         * and while disconnect and lock semaphores
+         * are up. This should be save because we
+         * can't lose our sisusb any other way but by
+         * disconnection (and hence, the disconnect
+         * sema is for protecting all other access
+         * functions from disconnection, not the
+         * other way round).
+         */
+
+        /* Now what do we do in case of disconnection:
+         * One alternative would be to simply call
+         * give_up_console(). Nah, not a good idea.
+         * give_up_console() is obviously buggy as it
+         * only discards the consw pointer from the
+         * driver_map, but doesn't adapt vc->vc_sw
+         * of the affected consoles. Hence, the next
+         * call to any of the console functions will
+         * eventually take a trip to oops county.
+         * Also, give_up_console for some reason
+         * doesn't decrement our module refcount.
+         * Instead, we switch our consoles to a private
+         * dummy console. This, of course, keeps our
+         * refcount up as well, but it works perfectly.
+         */
+
+        if (sisusb->haveconsole) {
+                for (i = 0; i < MAX_NR_CONSOLES; i++)
+                        if (sisusb->havethisconsole[i])
+                                take_over_console(&sisusb_dummy_con, i, i, 0);
+                                /* At this point, con_deinit for all our
+                                 * consoles is executed by take_over_console().
+                                 */
+                sisusb->haveconsole = 0;
+        }
+
+        vfree((void *)sisusb->scrbuf);
+        sisusb->scrbuf = 0;
+
+        vfree(sisusb->font_backup);
+        sisusb->font_backup = NULL;
+}
+
+void __init sisusb_init_concode(void)
+{
+        int i;
+
+        for (i = 0; i < MAX_NR_CONSOLES; i++)
+                mysisusbs[i] = NULL;
+}
+
+#endif /* INCL_CON */
+
+
+
diff --git a/drivers/usb/misc/sisusbvga/sisusb_init.c b/drivers/usb/misc/sisusbvga/sisusb_init.c
new file mode 100644
index 000000000000..f28bc240f9b6
--- /dev/null
+++ b/drivers/usb/misc/sisusbvga/sisusb_init.c
@@ -0,0 +1,1047 @@
+/*
+ * sisusb - usb kernel driver for SiS315(E) based USB2VGA dongles
+ *
+ * Display mode initializing code
+ *
+ * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
+ *
+ * If distributed as part of the Linux kernel, this code is licensed under the
+ * terms of the GPL v2.
+ *
+ * Otherwise, the following license terms apply:
+ *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * * 1) Redistributions of source code must retain the above copyright
+ * *    notice, this list of conditions and the following disclaimer.
+ * * 2) Redistributions in binary form must reproduce the above copyright
+ * *    notice, this list of conditions and the following disclaimer in the
+ * *    documentation and/or other materials provided with the distribution.
+ * * 3) The name of the author may not be used to endorse or promote products
+ * *    derived from this software without specific prior written permission.
+ * *
+ * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/poll.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/kref.h>
+
+#include "sisusb.h"
+
+#ifdef INCL_SISUSB_CON
+
+#include "sisusb_init.h"
+
+/*********************************************/
+/*         POINTER INITIALIZATION            */
+/*********************************************/
+
+static void
+SiSUSB_InitPtr(struct SiS_Private *SiS_Pr)
+{
+        SiS_Pr->SiS_ModeResInfo   = SiSUSB_ModeResInfo;
+        SiS_Pr->SiS_StandTable    = SiSUSB_StandTable;
+
+        SiS_Pr->SiS_SModeIDTable  = SiSUSB_SModeIDTable;
+        SiS_Pr->SiS_EModeIDTable  = SiSUSB_EModeIDTable;
+        SiS_Pr->SiS_RefIndex      = SiSUSB_RefIndex;
+        SiS_Pr->SiS_CRT1Table     = SiSUSB_CRT1Table;
+
+        SiS_Pr->SiS_VCLKData      = SiSUSB_VCLKData;
+}
+
+/*********************************************/
+/*            HELPER: Get ModeID             */
+/*********************************************/
+
+unsigned short
+SiSUSB_GetModeID(int HDisplay, int VDisplay, int Depth)
+{
+        unsigned short ModeIndex = 0;
+
+        switch (HDisplay)
+        {
+                case 320:
+                        if (VDisplay == 200)
+                                ModeIndex = ModeIndex_320x200[Depth];
+                        else if (VDisplay == 240)
+                                ModeIndex = ModeIndex_320x240[Depth];
+                        break;
+                case 400:
+                        if (VDisplay == 300)
+                                ModeIndex = ModeIndex_400x300[Depth];
+                        break;
+                case 512:
+                        if (VDisplay == 384)
+                                ModeIndex = ModeIndex_512x384[Depth];
+                        break;
+                case 640:
+                        if (VDisplay == 480)
+                                ModeIndex = ModeIndex_640x480[Depth];
+                        else if (VDisplay == 400)
+                                ModeIndex = ModeIndex_640x400[Depth];
+                        break;
+                case 720:
+                        if (VDisplay == 480)
+                                ModeIndex = ModeIndex_720x480[Depth];
+                        else if (VDisplay == 576)
+                                ModeIndex = ModeIndex_720x576[Depth];
+                        break;
+                case 768:
+                        if (VDisplay == 576)
+                                ModeIndex = ModeIndex_768x576[Depth];
+                        break;
+                case 800:
+                        if (VDisplay == 600)
+                                ModeIndex = ModeIndex_800x600[Depth];
+                        else if (VDisplay == 480)
+                                ModeIndex = ModeIndex_800x480[Depth];
+                        break;
+                case 848:
+                        if (VDisplay == 480)
+                                ModeIndex = ModeIndex_848x480[Depth];
+                        break;
+                case 856:
+                        if (VDisplay == 480)
+                                ModeIndex = ModeIndex_856x480[Depth];
+                        break;
+                case 960:
+                        if (VDisplay == 540)
+                                ModeIndex = ModeIndex_960x540[Depth];
+                        else if (VDisplay == 600)
+                                ModeIndex = ModeIndex_960x600[Depth];
+                        break;
+                case 1024:
+                        if (VDisplay == 576)
+                                ModeIndex = ModeIndex_1024x576[Depth];
+                        else if (VDisplay == 768)
+                                ModeIndex = ModeIndex_1024x768[Depth];
+                        break;
+                case 1152:
+                        if (VDisplay == 864)
+                                ModeIndex = ModeIndex_1152x864[Depth];
+                        break;
+                case 1280:
+                        switch (VDisplay) {
+                                case 720:
+                                        ModeIndex = ModeIndex_1280x720[Depth];
+                                        break;
+                                case 768:
+                                        ModeIndex = ModeIndex_1280x768[Depth];
+                                        break;
+                                case 1024:
+                                        ModeIndex = ModeIndex_1280x1024[Depth];
+                                        break;
+                        }
+        }
+
+        return ModeIndex;
+}
+
+/*********************************************/
+/*          HELPER: SetReg, GetReg           */
+/*********************************************/
+
+static void
+SiS_SetReg(struct SiS_Private *SiS_Pr, unsigned long port,
+                        unsigned short index, unsigned short data)
+{
+        sisusb_setidxreg(SiS_Pr->sisusb, port, index, data);
+}
+
+static void
+SiS_SetRegByte(struct SiS_Private *SiS_Pr, unsigned long port,
+                                                unsigned short data)
+{
+        sisusb_setreg(SiS_Pr->sisusb, port, data);
+}
+
+static unsigned char
+SiS_GetReg(struct SiS_Private *SiS_Pr, unsigned long port,
+                                                unsigned short index)
+{
+        u8 data;
+
+        sisusb_getidxreg(SiS_Pr->sisusb, port, index, &data);
+
+        return data;
+}
+
+static unsigned char
+SiS_GetRegByte(struct SiS_Private *SiS_Pr, unsigned long port)
+{
+        u8 data;
+
+        sisusb_getreg(SiS_Pr->sisusb, port, &data);
+
+        return data;
+}
+
+static void
+SiS_SetRegANDOR(struct SiS_Private *SiS_Pr, unsigned long port,
+                        unsigned short index, unsigned short DataAND,
+                                                unsigned short DataOR)
+{
+        sisusb_setidxregandor(SiS_Pr->sisusb, port, index, DataAND, DataOR);
+}
+
+static void
+SiS_SetRegAND(struct SiS_Private *SiS_Pr, unsigned long port,
+                        unsigned short index, unsigned short DataAND)
+{
+        sisusb_setidxregand(SiS_Pr->sisusb, port, index, DataAND);
+}
+
+static void
+SiS_SetRegOR(struct SiS_Private *SiS_Pr,unsigned long port,
+                        unsigned short index, unsigned short DataOR)
+{
+        sisusb_setidxregor(SiS_Pr->sisusb, port, index, DataOR);
+}
+
+/*********************************************/
+/*      HELPER: DisplayOn, DisplayOff        */
+/*********************************************/
+
+static void
+SiS_DisplayOn(struct SiS_Private *SiS_Pr)
+{
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0xDF);
+}
+
+/*********************************************/
+/*        HELPER: Init Port Addresses        */
+/*********************************************/
+
+void
+SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr)
+{
+        SiS_Pr->SiS_P3c4 = BaseAddr + 0x14;
+        SiS_Pr->SiS_P3d4 = BaseAddr + 0x24;
+        SiS_Pr->SiS_P3c0 = BaseAddr + 0x10;
+        SiS_Pr->SiS_P3ce = BaseAddr + 0x1e;
+        SiS_Pr->SiS_P3c2 = BaseAddr + 0x12;
+        SiS_Pr->SiS_P3ca = BaseAddr + 0x1a;
+        SiS_Pr->SiS_P3c6 = BaseAddr + 0x16;
+        SiS_Pr->SiS_P3c7 = BaseAddr + 0x17;
+        SiS_Pr->SiS_P3c8 = BaseAddr + 0x18;
+        SiS_Pr->SiS_P3c9 = BaseAddr + 0x19;
+        SiS_Pr->SiS_P3cb = BaseAddr + 0x1b;
+        SiS_Pr->SiS_P3cc = BaseAddr + 0x1c;
+        SiS_Pr->SiS_P3cd = BaseAddr + 0x1d;
+        SiS_Pr->SiS_P3da = BaseAddr + 0x2a;
+        SiS_Pr->SiS_Part1Port = BaseAddr + SIS_CRT2_PORT_04;
+}
+
+/*********************************************/
+/*             HELPER: GetSysFlags           */
+/*********************************************/
+
+static void
+SiS_GetSysFlags(struct SiS_Private *SiS_Pr)
+{
+        SiS_Pr->SiS_MyCR63 = 0x63;
+}
+
+/*********************************************/
+/*         HELPER: Init PCI & Engines        */
+/*********************************************/
+
+static void
+SiSInitPCIetc(struct SiS_Private *SiS_Pr)
+{
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x20, 0xa1);
+        /*  - Enable 2D (0x40)
+         *  - Enable 3D (0x02)
+         *  - Enable 3D vertex command fetch (0x10)
+         *  - Enable 3D command parser (0x08)
+         *  - Enable 3D G/L transformation engine (0x80)
+         */
+        SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1E, 0xDA);
+}
+
+/*********************************************/
+/*        HELPER: SET SEGMENT REGISTERS      */
+/*********************************************/
+
+static void
+SiS_SetSegRegLower(struct SiS_Private *SiS_Pr, unsigned short value)
+{
+        unsigned short temp;
+
+        value &= 0x00ff;
+        temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0xf0;
+        temp |= (value >> 4);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
+        temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0xf0;
+        temp |= (value & 0x0f);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
+}
+
+static void
+SiS_SetSegRegUpper(struct SiS_Private *SiS_Pr, unsigned short value)
+{
+        unsigned short temp;
+
+        value &= 0x00ff;
+        temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb) & 0x0f;
+        temp |= (value & 0xf0);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cb, temp);
+        temp = SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd) & 0x0f;
+        temp |= (value << 4);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3cd, temp);
+}
+
+static void
+SiS_SetSegmentReg(struct SiS_Private *SiS_Pr, unsigned short value)
+{
+        SiS_SetSegRegLower(SiS_Pr, value);
+        SiS_SetSegRegUpper(SiS_Pr, value);
+}
+
+static void
+SiS_ResetSegmentReg(struct SiS_Private *SiS_Pr)
+{
+        SiS_SetSegmentReg(SiS_Pr, 0);
+}
+
+static void
+SiS_SetSegmentRegOver(struct SiS_Private *SiS_Pr, unsigned short value)
+{
+        unsigned short temp = value >> 8;
+
+        temp &= 0x07;
+        temp |= (temp << 4);
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1d, temp);
+        SiS_SetSegmentReg(SiS_Pr, value);
+}
+
+static void
+SiS_ResetSegmentRegOver(struct SiS_Private *SiS_Pr)
+{
+        SiS_SetSegmentRegOver(SiS_Pr, 0);
+}
+
+static void
+SiS_ResetSegmentRegisters(struct SiS_Private *SiS_Pr)
+{
+        SiS_ResetSegmentReg(SiS_Pr);
+        SiS_ResetSegmentRegOver(SiS_Pr);
+}
+
+/*********************************************/
+/*           HELPER: SearchModeID            */
+/*********************************************/
+
+static int
+SiS_SearchModeID(struct SiS_Private *SiS_Pr, unsigned short *ModeNo,
+                                                unsigned short *ModeIdIndex)
+{
+        if ((*ModeNo) <= 0x13) {
+
+                if ((*ModeNo) != 0x03)
+                        return 0;
+
+                (*ModeIdIndex) = 0;
+
+        } else {
+
+                for(*ModeIdIndex = 0; ;(*ModeIdIndex)++) {
+
+                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == (*ModeNo))
+                                break;
+
+                        if (SiS_Pr->SiS_EModeIDTable[*ModeIdIndex].Ext_ModeID == 0xFF)
+                                return 0;
+                }
+
+        }
+
+        return 1;
+}
+
+/*********************************************/
+/*            HELPER: ENABLE CRT1            */
+/*********************************************/
+
+static void
+SiS_HandleCRT1(struct SiS_Private *SiS_Pr)
+{
+        /* Enable CRT1 gating */
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, SiS_Pr->SiS_MyCR63, 0xbf);
+}
+
+/*********************************************/
+/*           HELPER: GetColorDepth           */
+/*********************************************/
+
+static unsigned short
+SiS_GetColorDepth(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                unsigned short ModeIdIndex)
+{
+        static const unsigned short ColorDepth[6] = { 1, 2, 4, 4, 6, 8};
+        unsigned short modeflag;
+        short index;
+
+        if (ModeNo <= 0x13) {
+                modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
+        } else {
+                modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
+        }
+
+        index = (modeflag & ModeTypeMask) - ModeEGA;
+        if (index < 0) index = 0;
+        return ColorDepth[index];
+}
+
+/*********************************************/
+/*             HELPER: GetOffset             */
+/*********************************************/
+
+static unsigned short
+SiS_GetOffset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                unsigned short ModeIdIndex, unsigned short rrti)
+{
+        unsigned short xres, temp, colordepth, infoflag;
+
+        infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
+        xres = SiS_Pr->SiS_RefIndex[rrti].XRes;
+
+        colordepth = SiS_GetColorDepth(SiS_Pr, ModeNo, ModeIdIndex);
+
+        temp = xres / 16;
+
+        if (infoflag & InterlaceMode)
+                temp <<= 1;
+
+        temp *= colordepth;
+
+        if (xres % 16)
+                temp += (colordepth >> 1);
+
+        return temp;
+}
+
+/*********************************************/
+/*                   SEQ                     */
+/*********************************************/
+
+static void
+SiS_SetSeqRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
+{
+        unsigned char SRdata;
+        int i;
+
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x00, 0x03);
+
+        SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[0] | 0x20;
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, SRdata);
+
+        for(i = 2; i <= 4; i++) {
+                SRdata = SiS_Pr->SiS_StandTable[StandTableIndex].SR[i-1];
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, SRdata);
+        }
+}
+
+/*********************************************/
+/*                  MISC                     */
+/*********************************************/
+
+static void
+SiS_SetMiscRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
+{
+        unsigned char Miscdata = SiS_Pr->SiS_StandTable[StandTableIndex].MISC;
+
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, Miscdata);
+}
+
+/*********************************************/
+/*                  CRTC                     */
+/*********************************************/
+
+static void
+SiS_SetCRTCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
+{
+        unsigned char CRTCdata;
+        unsigned short i;
+
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4, 0x11, 0x7f);
+
+        for(i = 0; i <= 0x18; i++) {
+                CRTCdata = SiS_Pr->SiS_StandTable[StandTableIndex].CRTC[i];
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, i, CRTCdata);
+        }
+}
+
+/*********************************************/
+/*                   ATT                     */
+/*********************************************/
+
+static void
+SiS_SetATTRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
+{
+        unsigned char ARdata;
+        unsigned short i;
+
+        for(i = 0; i <= 0x13; i++) {
+                ARdata = SiS_Pr->SiS_StandTable[StandTableIndex].ATTR[i];
+                SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
+                SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, i);
+                SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, ARdata);
+        }
+        SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x14);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x00);
+
+        SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c0, 0x20);
+        SiS_GetRegByte(SiS_Pr, SiS_Pr->SiS_P3da);
+}
+
+/*********************************************/
+/*                   GRC                     */
+/*********************************************/
+
+static void
+SiS_SetGRCRegs(struct SiS_Private *SiS_Pr, unsigned short StandTableIndex)
+{
+        unsigned char GRdata;
+        unsigned short i;
+
+        for(i = 0; i <= 0x08; i++) {
+                GRdata = SiS_Pr->SiS_StandTable[StandTableIndex].GRC[i];
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3ce, i, GRdata);
+        }
+
+        if (SiS_Pr->SiS_ModeType > ModeVGA) {
+                /* 256 color disable */
+                SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3ce, 0x05, 0xBF);
+        }
+}
+
+/*********************************************/
+/*          CLEAR EXTENDED REGISTERS         */
+/*********************************************/
+
+static void
+SiS_ClearExt1Regs(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
+{
+        int i;
+
+        for(i = 0x0A; i <= 0x0E; i++) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, i, 0x00);
+        }
+
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x37, 0xFE);
+}
+
+/*********************************************/
+/*              Get rate index               */
+/*********************************************/
+
+static unsigned short
+SiS_GetRatePtr(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                                        unsigned short ModeIdIndex)
+{
+        unsigned short rrti, i, index, temp;
+
+        if (ModeNo <= 0x13)
+                return 0xFFFF;
+
+        index = SiS_GetReg(SiS_Pr,SiS_Pr->SiS_P3d4, 0x33) & 0x0F;
+        if (index > 0) index--;
+
+        rrti = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].REFindex;
+        ModeNo = SiS_Pr->SiS_RefIndex[rrti].ModeID;
+
+        i = 0;
+        do {
+                if (SiS_Pr->SiS_RefIndex[rrti + i].ModeID != ModeNo)
+                        break;
+
+                temp = SiS_Pr->SiS_RefIndex[rrti + i].Ext_InfoFlag & ModeTypeMask;
+                if (temp < SiS_Pr->SiS_ModeType)
+                        break;
+
+                i++;
+                index--;
+        } while(index != 0xFFFF);
+
+        i--;
+
+        return (rrti + i);
+}
+
+/*********************************************/
+/*                  SYNC                     */
+/*********************************************/
+
+static void
+SiS_SetCRT1Sync(struct SiS_Private *SiS_Pr, unsigned short rrti)
+{
+        unsigned short sync = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag >> 8;
+        sync &= 0xC0;
+        sync |= 0x2f;
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c2, sync);
+}
+
+/*********************************************/
+/*                  CRTC/2                   */
+/*********************************************/
+
+static void
+SiS_SetCRT1CRTC(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                        unsigned short ModeIdIndex, unsigned short rrti)
+{
+        unsigned char  index;
+        unsigned short temp, i, j, modeflag;
+
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3d4,0x11,0x7f);
+
+        modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
+
+        index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRT1CRTC;
+
+        for(i = 0,j = 0; i <= 7; i++, j++) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
+                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+        }
+        for(j = 0x10; i <= 10; i++, j++) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
+                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+        }
+        for(j = 0x15; i <= 12; i++, j++) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, j,
+                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+        }
+        for(j = 0x0A; i <= 15; i++, j++) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, j,
+                                SiS_Pr->SiS_CRT1Table[index].CR[i]);
+        }
+
+        temp = SiS_Pr->SiS_CRT1Table[index].CR[16] & 0xE0;
+        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4, 0x0E, temp);
+
+        temp = ((SiS_Pr->SiS_CRT1Table[index].CR[16]) & 0x01) << 5;
+        if (modeflag & DoubleScanMode)  temp |= 0x80;
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x09, 0x5F, temp);
+
+        if (SiS_Pr->SiS_ModeType > ModeVGA)
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x14, 0x4F);
+}
+
+/*********************************************/
+/*               OFFSET & PITCH              */
+/*********************************************/
+/*  (partly overruled by SetPitch() in XF86) */
+/*********************************************/
+
+static void
+SiS_SetCRT1Offset(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                        unsigned short ModeIdIndex, unsigned short rrti)
+{
+        unsigned short du = SiS_GetOffset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
+        unsigned short infoflag =  SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
+        unsigned short temp;
+
+        temp = (du >> 8) & 0x0f;
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0E, 0xF0, temp);
+
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x13, (du & 0xFF));
+
+        if (infoflag & InterlaceMode) du >>= 1;
+
+        du <<= 5;
+        temp = (du >> 8) & 0xff;
+        if (du & 0xff) temp++;
+        temp++;
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x10, temp);
+}
+
+/*********************************************/
+/*                  VCLK                     */
+/*********************************************/
+
+static void
+SiS_SetCRT1VCLK(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                                                unsigned short rrti)
+{
+        unsigned short index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
+        unsigned short clka = SiS_Pr->SiS_VCLKData[index].SR2B;
+        unsigned short clkb = SiS_Pr->SiS_VCLKData[index].SR2C;
+
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4,0x31,0xCF);
+
+        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2B,clka);
+        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2C,clkb);
+        SiS_SetReg(SiS_Pr,SiS_Pr->SiS_P3c4,0x2D,0x01);
+}
+
+/*********************************************/
+/*                  FIFO                     */
+/*********************************************/
+
+static void
+SiS_SetCRT1FIFO_310(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                                                        unsigned short mi)
+{
+        unsigned short modeflag = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
+
+        /* disable auto-threshold */
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0xFE);
+
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0xAE);
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x09, 0xF0);
+
+        if (ModeNo <= 0x13)
+                return;
+
+        if ((!(modeflag & DoubleScanMode)) || (!(modeflag & HalfDCLK))) {
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x08, 0x34);
+                SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x3D, 0x01);
+        }
+}
+
+/*********************************************/
+/*              MODE REGISTERS               */
+/*********************************************/
+
+static void
+SiS_SetVCLKState(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                                                        unsigned short rrti)
+{
+        unsigned short data = 0, VCLK = 0, index = 0;
+
+        if (ModeNo > 0x13) {
+                index = SiS_Pr->SiS_RefIndex[rrti].Ext_CRTVCLK;
+                VCLK = SiS_Pr->SiS_VCLKData[index].CLOCK;
+        }
+
+        if (VCLK >= 166) data |= 0x0c;
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x32, 0xf3, data);
+
+        if (VCLK >= 166)
+                SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1f, 0xe7);
+
+        /* DAC speed */
+        data = 0x03;
+        if (VCLK >= 260)
+                data = 0x00;
+        else if (VCLK >= 160)
+                data = 0x01;
+        else if (VCLK >= 135)
+                data = 0x02;
+
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x07, 0xF8, data);
+}
+
+static void
+SiS_SetCRT1ModeRegs(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                        unsigned short ModeIdIndex, unsigned short rrti)
+{
+        unsigned short data, infoflag = 0, modeflag;
+
+        if (ModeNo <= 0x13)
+                modeflag = SiS_Pr->SiS_SModeIDTable[ModeIdIndex].St_ModeFlag;
+        else {
+                modeflag = SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag;
+                infoflag = SiS_Pr->SiS_RefIndex[rrti].Ext_InfoFlag;
+        }
+
+        /* Disable DPMS */
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x1F, 0x3F);
+
+        data = 0;
+        if (ModeNo > 0x13) {
+                if (SiS_Pr->SiS_ModeType > ModeEGA) {
+                        data |= 0x02;
+                        data |= ((SiS_Pr->SiS_ModeType - ModeVGA) << 2);
+                }
+                if (infoflag & InterlaceMode) data |= 0x20;
+        }
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x06, 0xC0, data);
+
+        data = 0;
+        if (infoflag & InterlaceMode) {
+                /* data = (Hsync / 8) - ((Htotal / 8) / 2) + 3 */
+                unsigned short hrs = (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x04) |
+                        ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0xc0) << 2)) - 3;
+                unsigned short hto = (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x00) |
+                        ((SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0b) & 0x03) << 8)) + 5;
+                data = hrs - (hto >> 1) + 3;
+        }
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x19, (data & 0xFF));
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3d4, 0x1a, 0xFC, (data >> 8));
+
+        if (modeflag & HalfDCLK)
+                SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x01, 0x08);
+
+        data = 0;
+        if (modeflag & LineCompareOff)
+                data = 0x08;
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0xB7, data);
+
+        if ((SiS_Pr->SiS_ModeType == ModeEGA) && (ModeNo > 0x13))
+                SiS_SetRegOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x0F, 0x40);
+
+        SiS_SetRegAND(SiS_Pr, SiS_Pr->SiS_P3c4, 0x31, 0xfb);
+
+        data = 0x60;
+        if (SiS_Pr->SiS_ModeType != ModeText) {
+                data ^= 0x60;
+                if (SiS_Pr->SiS_ModeType != ModeEGA)
+                        data ^= 0xA0;
+        }
+        SiS_SetRegANDOR(SiS_Pr, SiS_Pr->SiS_P3c4, 0x21, 0x1F, data);
+
+        SiS_SetVCLKState(SiS_Pr, ModeNo, rrti);
+
+        if (SiS_GetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x31) & 0x40)
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x2c);
+        else
+                SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x52, 0x6c);
+}
+
+/*********************************************/
+/*                 LOAD DAC                  */
+/*********************************************/
+
+static void
+SiS_WriteDAC(struct SiS_Private *SiS_Pr, unsigned long DACData,
+                unsigned short shiftflag, unsigned short dl, unsigned short ah,
+                unsigned short al, unsigned short dh)
+{
+        unsigned short d1, d2, d3;
+
+        switch (dl) {
+                case  0:
+                        d1 = dh; d2 = ah; d3 = al;
+                        break;
+                case  1:
+                        d1 = ah; d2 = al; d3 = dh;
+                        break;
+                default:
+                        d1 = al; d2 = dh; d3 = ah;
+        }
+        SiS_SetRegByte(SiS_Pr, DACData, (d1 << shiftflag));
+        SiS_SetRegByte(SiS_Pr, DACData, (d2 << shiftflag));
+        SiS_SetRegByte(SiS_Pr, DACData, (d3 << shiftflag));
+}
+
+static void
+SiS_LoadDAC(struct SiS_Private *SiS_Pr, unsigned short ModeNo, unsigned short mi)
+{
+        unsigned short data, data2, time, i, j, k, m, n, o;
+        unsigned short si, di, bx, sf;
+        unsigned long DACAddr, DACData;
+        const unsigned char *table = NULL;
+
+        if (ModeNo < 0x13)
+                data = SiS_Pr->SiS_SModeIDTable[mi].St_ModeFlag;
+        else
+                data = SiS_Pr->SiS_EModeIDTable[mi].Ext_ModeFlag;
+
+        data &= DACInfoFlag;
+
+        j = time = 64;
+        if (data == 0x00)
+                table = SiS_MDA_DAC;
+        else if (data == 0x08)
+                table = SiS_CGA_DAC;
+        else if (data == 0x10)
+                table = SiS_EGA_DAC;
+        else {
+                j = 16;
+                time = 256;
+                table = SiS_VGA_DAC;
+        }
+
+        DACAddr = SiS_Pr->SiS_P3c8;
+        DACData = SiS_Pr->SiS_P3c9;
+        sf = 0;
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
+
+        SiS_SetRegByte(SiS_Pr, DACAddr, 0x00);
+
+        for(i = 0; i < j; i++) {
+                data = table[i];
+                for(k = 0; k < 3; k++) {
+                        data2 = 0;
+                        if (data & 0x01) data2 += 0x2A;
+                        if (data & 0x02) data2 += 0x15;
+                        SiS_SetRegByte(SiS_Pr, DACData, (data2 << sf));
+                        data >>= 2;
+                }
+        }
+
+        if (time == 256) {
+                for(i = 16; i < 32; i++) {
+                        data = table[i] << sf;
+                        for(k = 0; k < 3; k++)
+                                SiS_SetRegByte(SiS_Pr, DACData, data);
+                }
+                si = 32;
+                for(m = 0; m < 9; m++) {
+                        di = si;
+                        bx = si + 4;
+                        for(n = 0; n < 3; n++) {
+                                for(o = 0; o < 5; o++) {
+                                        SiS_WriteDAC(SiS_Pr, DACData, sf, n,
+                                                table[di], table[bx], table[si]);
+                                        si++;
+                                }
+                                si -= 2;
+                                for(o = 0; o < 3; o++) {
+                                        SiS_WriteDAC(SiS_Pr, DACData, sf, n,
+                                                table[di], table[si], table[bx]);
+                                        si--;
+                                }
+                        }
+                si += 5;
+                }
+        }
+}
+
+/*********************************************/
+/*         SET CRT1 REGISTER GROUP           */
+/*********************************************/
+
+static void
+SiS_SetCRT1Group(struct SiS_Private *SiS_Pr, unsigned short ModeNo,
+                                        unsigned short ModeIdIndex)
+{
+        unsigned short StandTableIndex, rrti;
+
+        SiS_Pr->SiS_CRT1Mode = ModeNo;
+
+        if (ModeNo <= 0x13)
+                StandTableIndex = 0;
+        else
+                StandTableIndex = 1;
+
+        SiS_ResetSegmentRegisters(SiS_Pr);
+        SiS_SetSeqRegs(SiS_Pr, StandTableIndex);
+        SiS_SetMiscRegs(SiS_Pr, StandTableIndex);
+        SiS_SetCRTCRegs(SiS_Pr, StandTableIndex);
+        SiS_SetATTRegs(SiS_Pr, StandTableIndex);
+        SiS_SetGRCRegs(SiS_Pr, StandTableIndex);
+        SiS_ClearExt1Regs(SiS_Pr, ModeNo);
+
+        rrti = SiS_GetRatePtr(SiS_Pr, ModeNo, ModeIdIndex);
+
+        if (rrti != 0xFFFF) {
+                SiS_SetCRT1Sync(SiS_Pr, rrti);
+                SiS_SetCRT1CRTC(SiS_Pr, ModeNo, ModeIdIndex, rrti);
+                SiS_SetCRT1Offset(SiS_Pr, ModeNo, ModeIdIndex, rrti);
+                SiS_SetCRT1VCLK(SiS_Pr, ModeNo, rrti);
+        }
+
+        SiS_SetCRT1FIFO_310(SiS_Pr, ModeNo, ModeIdIndex);
+
+        SiS_SetCRT1ModeRegs(SiS_Pr, ModeNo, ModeIdIndex, rrti);
+
+        SiS_LoadDAC(SiS_Pr, ModeNo, ModeIdIndex);
+
+        SiS_DisplayOn(SiS_Pr);
+}
+
+/*********************************************/
+/*                 SiSSetMode()              */
+/*********************************************/
+
+int
+SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo)
+{
+        unsigned short ModeIdIndex;
+        unsigned long  BaseAddr = SiS_Pr->IOAddress;
+
+        SiSUSB_InitPtr(SiS_Pr);
+        SiSUSBRegInit(SiS_Pr, BaseAddr);
+        SiS_GetSysFlags(SiS_Pr);
+
+        if (!(SiS_SearchModeID(SiS_Pr, &ModeNo, &ModeIdIndex)))
+                return 0;
+
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3c4, 0x05, 0x86);
+
+        SiSInitPCIetc(SiS_Pr);
+
+        ModeNo &= 0x7f;
+
+        SiS_Pr->SiS_ModeType =
+                SiS_Pr->SiS_EModeIDTable[ModeIdIndex].Ext_ModeFlag & ModeTypeMask;
+
+        SiS_Pr->SiS_SetFlag = LowModeTests;
+
+        /* Set mode on CRT1 */
+        SiS_SetCRT1Group(SiS_Pr, ModeNo, ModeIdIndex);
+
+        SiS_HandleCRT1(SiS_Pr);
+
+        SiS_DisplayOn(SiS_Pr);
+        SiS_SetRegByte(SiS_Pr, SiS_Pr->SiS_P3c6, 0xFF);
+
+        /* Store mode number */
+        SiS_SetReg(SiS_Pr, SiS_Pr->SiS_P3d4, 0x34, ModeNo);
+
+        return 1;
+}
+
+int
+SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo)
+{
+        unsigned short ModeNo = 0;
+        int i;
+
+        SiSUSB_InitPtr(SiS_Pr);
+
+        if (VModeNo == 0x03) {
+
+                ModeNo = 0x03;
+
+        } else {
+
+                i = 0;
+                do {
+
+                        if (SiS_Pr->SiS_EModeIDTable[i].Ext_VESAID == VModeNo) {
+                                ModeNo = SiS_Pr->SiS_EModeIDTable[i].Ext_ModeID;
+                                break;
+                        }
+
+                } while (SiS_Pr->SiS_EModeIDTable[i++].Ext_ModeID != 0xff);
+
+        }
+
+        if (!ModeNo)
+                return 0;
+
+        return SiSUSBSetMode(SiS_Pr, ModeNo);
+}
+
+#endif /* INCL_SISUSB_CON */
+
+
+
+
diff --git a/drivers/usb/misc/sisusbvga/sisusb_init.h b/drivers/usb/misc/sisusbvga/sisusb_init.h
new file mode 100644
index 000000000000..5b11577835c8
--- /dev/null
+++ b/drivers/usb/misc/sisusbvga/sisusb_init.h
@@ -0,0 +1,830 @@
+/* $XFree86$ */
+/* $XdotOrg$ */
+/*
+ * Data and prototypes for init.c
+ *
+ * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
+ *
+ * If distributed as part of the Linux kernel, the following license terms
+ * apply:
+ *
+ * * This program is free software; you can redistribute it and/or modify
+ * * it under the terms of the GNU General Public License as published by
+ * * the Free Software Foundation; either version 2 of the named License,
+ * * or any later version.
+ * *
+ * * This program is distributed in the hope that it will be useful,
+ * * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * * GNU General Public License for more details.
+ * *
+ * * You should have received a copy of the GNU General Public License
+ * * along with this program; if not, write to the Free Software
+ * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
+ *
+ * Otherwise, the following license terms apply:
+ *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * * 1) Redistributions of source code must retain the above copyright
+ * *    notice, this list of conditions and the following disclaimer.
+ * * 2) Redistributions in binary form must reproduce the above copyright
+ * *    notice, this list of conditions and the following disclaimer in the
+ * *    documentation and/or other materials provided with the distribution.
+ * * 3) The name of the author may not be used to endorse or promote products
+ * *    derived from this software without specific prior written permission.
+ * *
+ * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ *
+ */
+
+#ifndef _SISUSB_INIT_H_
+#define _SISUSB_INIT_H_
+
+/* SiS_ModeType */
+#define ModeText                0x00
+#define ModeCGA                 0x01
+#define ModeEGA                 0x02
+#define ModeVGA                 0x03
+#define Mode15Bpp               0x04
+#define Mode16Bpp               0x05
+#define Mode24Bpp               0x06
+#define Mode32Bpp               0x07
+
+#define ModeTypeMask            0x07
+#define IsTextMode              0x07
+
+#define DACInfoFlag             0x0018
+#define MemoryInfoFlag          0x01E0
+#define MemorySizeShift         5
+
+/* modeflag */
+#define Charx8Dot               0x0200
+#define LineCompareOff          0x0400
+#define CRT2Mode                0x0800
+#define HalfDCLK                0x1000
+#define NoSupportSimuTV         0x2000
+#define NoSupportLCDScale       0x4000 /* SiS bridge: No scaling possible (no matter what panel) */
+#define DoubleScanMode          0x8000
+
+/* Infoflag */
+#define SupportTV               0x0008
+#define SupportTV1024           0x0800
+#define SupportCHTV             0x0800
+#define Support64048060Hz       0x0800  /* Special for 640x480 LCD */
+#define SupportHiVision         0x0010
+#define SupportYPbPr750p        0x1000
+#define SupportLCD              0x0020
+#define SupportRAMDAC2          0x0040  /* All           (<= 100Mhz) */
+#define SupportRAMDAC2_135      0x0100  /* All except DH (<= 135Mhz) */
+#define SupportRAMDAC2_162      0x0200  /* B, C          (<= 162Mhz) */
+#define SupportRAMDAC2_202      0x0400  /* C             (<= 202Mhz) */
+#define InterlaceMode           0x0080
+#define SyncPP                  0x0000
+#define SyncPN                  0x4000
+#define SyncNP                  0x8000
+#define SyncNN                  0xc000
+
+/* SetFlag */
+#define ProgrammingCRT2         0x0001
+#define LowModeTests            0x0002
+#define LCDVESATiming           0x0008
+#define EnableLVDSDDA           0x0010
+#define SetDispDevSwitchFlag    0x0020
+#define CheckWinDos             0x0040
+#define SetDOSMode              0x0080
+
+/* Index in ModeResInfo table */
+#define SIS_RI_320x200          0
+#define SIS_RI_320x240          1
+#define SIS_RI_320x400          2
+#define SIS_RI_400x300          3
+#define SIS_RI_512x384          4
+#define SIS_RI_640x400          5
+#define SIS_RI_640x480          6
+#define SIS_RI_800x600          7
+#define SIS_RI_1024x768         8
+#define SIS_RI_1280x1024        9
+#define SIS_RI_1600x1200        10
+#define SIS_RI_1920x1440        11
+#define SIS_RI_2048x1536        12
+#define SIS_RI_720x480          13
+#define SIS_RI_720x576          14
+#define SIS_RI_1280x960         15
+#define SIS_RI_800x480          16
+#define SIS_RI_1024x576         17
+#define SIS_RI_1280x720         18
+#define SIS_RI_856x480          19
+#define SIS_RI_1280x768         20
+#define SIS_RI_1400x1050        21
+#define SIS_RI_1152x864         22  /* Up to here SiS conforming */
+#define SIS_RI_848x480          23
+#define SIS_RI_1360x768         24
+#define SIS_RI_1024x600         25
+#define SIS_RI_1152x768         26
+#define SIS_RI_768x576          27
+#define SIS_RI_1360x1024        28
+#define SIS_RI_1680x1050        29
+#define SIS_RI_1280x800         30
+#define SIS_RI_1920x1080        31
+#define SIS_RI_960x540          32
+#define SIS_RI_960x600          33
+
+#define SIS_VIDEO_CAPTURE       0x00 - 0x30
+#define SIS_VIDEO_PLAYBACK      0x02 - 0x30
+#define SIS_CRT2_PORT_04        0x04 - 0x30
+
+/* Mode numbers */
+static const unsigned short ModeIndex_320x200[]   = {0x59, 0x41, 0x00, 0x4f};
+static const unsigned short ModeIndex_320x240[]   = {0x50, 0x56, 0x00, 0x53};
+static const unsigned short ModeIndex_400x300[]   = {0x51, 0x57, 0x00, 0x54};
+static const unsigned short ModeIndex_512x384[]   = {0x52, 0x58, 0x00, 0x5c};
+static const unsigned short ModeIndex_640x400[]   = {0x2f, 0x5d, 0x00, 0x5e};
+static const unsigned short ModeIndex_640x480[]   = {0x2e, 0x44, 0x00, 0x62};
+static const unsigned short ModeIndex_720x480[]   = {0x31, 0x33, 0x00, 0x35};
+static const unsigned short ModeIndex_720x576[]   = {0x32, 0x34, 0x00, 0x36};
+static const unsigned short ModeIndex_768x576[]   = {0x5f, 0x60, 0x00, 0x61};
+static const unsigned short ModeIndex_800x480[]   = {0x70, 0x7a, 0x00, 0x76};
+static const unsigned short ModeIndex_800x600[]   = {0x30, 0x47, 0x00, 0x63};
+static const unsigned short ModeIndex_848x480[]   = {0x39, 0x3b, 0x00, 0x3e};
+static const unsigned short ModeIndex_856x480[]   = {0x3f, 0x42, 0x00, 0x45};
+static const unsigned short ModeIndex_960x540[]   = {0x1d, 0x1e, 0x00, 0x1f};
+static const unsigned short ModeIndex_960x600[]   = {0x20, 0x21, 0x00, 0x22};
+static const unsigned short ModeIndex_1024x768[]  = {0x38, 0x4a, 0x00, 0x64};
+static const unsigned short ModeIndex_1024x576[]  = {0x71, 0x74, 0x00, 0x77};
+static const unsigned short ModeIndex_1152x864[]  = {0x29, 0x2a, 0x00, 0x2b};
+static const unsigned short ModeIndex_1280x720[]  = {0x79, 0x75, 0x00, 0x78};
+static const unsigned short ModeIndex_1280x768[]  = {0x23, 0x24, 0x00, 0x25};
+static const unsigned short ModeIndex_1280x1024[] = {0x3a, 0x4d, 0x00, 0x65};
+
+static const unsigned char SiS_MDA_DAC[] =
+{
+        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
+        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
+        0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,
+        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
+        0x15,0x15,0x15,0x15,0x15,0x15,0x15,0x15,
+        0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F,0x3F
+};
+
+static const unsigned char SiS_CGA_DAC[] =
+{
+        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
+        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
+        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
+        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F
+};
+
+static const unsigned char SiS_EGA_DAC[] =
+{
+        0x00,0x10,0x04,0x14,0x01,0x11,0x05,0x15,
+        0x20,0x30,0x24,0x34,0x21,0x31,0x25,0x35,
+        0x08,0x18,0x0C,0x1C,0x09,0x19,0x0D,0x1D,
+        0x28,0x38,0x2C,0x3C,0x29,0x39,0x2D,0x3D,
+        0x02,0x12,0x06,0x16,0x03,0x13,0x07,0x17,
+        0x22,0x32,0x26,0x36,0x23,0x33,0x27,0x37,
+        0x0A,0x1A,0x0E,0x1E,0x0B,0x1B,0x0F,0x1F,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F
+};
+
+static const unsigned char SiS_VGA_DAC[] =
+{
+        0x00,0x10,0x04,0x14,0x01,0x11,0x09,0x15,
+        0x2A,0x3A,0x2E,0x3E,0x2B,0x3B,0x2F,0x3F,
+        0x00,0x05,0x08,0x0B,0x0E,0x11,0x14,0x18,
+        0x1C,0x20,0x24,0x28,0x2D,0x32,0x38,0x3F,
+        0x00,0x10,0x1F,0x2F,0x3F,0x1F,0x27,0x2F,
+        0x37,0x3F,0x2D,0x31,0x36,0x3A,0x3F,0x00,
+        0x07,0x0E,0x15,0x1C,0x0E,0x11,0x15,0x18,
+        0x1C,0x14,0x16,0x18,0x1A,0x1C,0x00,0x04,
+        0x08,0x0C,0x10,0x08,0x0A,0x0C,0x0E,0x10,
+        0x0B,0x0C,0x0D,0x0F,0x10
+};
+
+static const struct SiS_St SiSUSB_SModeIDTable[] =
+{
+        {0x03,0x0010,0x18,0x02,0x02,0x00,0x01,0x03,0x40},
+        {0xff,0x0000,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
+};
+
+static const struct SiS_StResInfo_S SiSUSB_StResInfo[] =
+{
+        { 640,400},
+        { 640,350},
+        { 720,400},
+        { 720,350},
+        { 640,480}
+};
+
+static const struct SiS_ModeResInfo SiSUSB_ModeResInfo[] =
+{
+        {  320, 200, 8, 8},   /* 0x00 */
+        {  320, 240, 8, 8},   /* 0x01 */
+        {  320, 400, 8, 8},   /* 0x02 */
+        {  400, 300, 8, 8},   /* 0x03 */
+        {  512, 384, 8, 8},   /* 0x04 */
+        {  640, 400, 8,16},   /* 0x05 */
+        {  640, 480, 8,16},   /* 0x06 */
+        {  800, 600, 8,16},   /* 0x07 */
+        { 1024, 768, 8,16},   /* 0x08 */
+        { 1280,1024, 8,16},   /* 0x09 */
+        { 1600,1200, 8,16},   /* 0x0a */
+        { 1920,1440, 8,16},   /* 0x0b */
+        { 2048,1536, 8,16},   /* 0x0c */
+        {  720, 480, 8,16},   /* 0x0d */
+        {  720, 576, 8,16},   /* 0x0e */
+        { 1280, 960, 8,16},   /* 0x0f */
+        {  800, 480, 8,16},   /* 0x10 */
+        { 1024, 576, 8,16},   /* 0x11 */
+        { 1280, 720, 8,16},   /* 0x12 */
+        {  856, 480, 8,16},   /* 0x13 */
+        { 1280, 768, 8,16},   /* 0x14 */
+        { 1400,1050, 8,16},   /* 0x15 */
+        { 1152, 864, 8,16},   /* 0x16 */
+        {  848, 480, 8,16},   /* 0x17 */
+        { 1360, 768, 8,16},   /* 0x18 */
+        { 1024, 600, 8,16},   /* 0x19 */
+        { 1152, 768, 8,16},   /* 0x1a */
+        {  768, 576, 8,16},   /* 0x1b */
+        { 1360,1024, 8,16},   /* 0x1c */
+        { 1680,1050, 8,16},   /* 0x1d */
+        { 1280, 800, 8,16},   /* 0x1e */
+        { 1920,1080, 8,16},   /* 0x1f */
+        {  960, 540, 8,16},   /* 0x20 */
+        {  960, 600, 8,16}    /* 0x21 */
+};
+
+static const struct SiS_StandTable SiSUSB_StandTable[] =
+{
+        /* MD_3_400 - mode 0x03 - 400 */
+        {
+                0x50,0x18,0x10,0x1000,
+                { 0x00,0x03,0x00,0x02 },
+                0x67,
+                { 0x5f,0x4f,0x50,0x82,0x55,0x81,0xbf,0x1f,
+                  0x00,0x4f,0x0d,0x0e,0x00,0x00,0x00,0x00,
+                  0x9c,0x8e,0x8f,0x28,0x1f,0x96,0xb9,0xa3,
+                  0xff },
+                { 0x00,0x01,0x02,0x03,0x04,0x05,0x14,0x07,
+                  0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
+                  0x0c,0x00,0x0f,0x08 },
+                { 0x00,0x00,0x00,0x00,0x00,0x10,0x0e,0x00, 0xff }
+        },
+        /* Generic for VGA and higher */
+        {
+                0x00,0x00,0x00,0x0000,
+                { 0x01,0x0f,0x00,0x0e },
+                0x23,
+                { 0x5f,0x4f,0x50,0x82,0x54,0x80,0x0b,0x3e,
+                  0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
+                  0xea,0x8c,0xdf,0x28,0x40,0xe7,0x04,0xa3,
+                  0xff },
+                { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+                  0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,
+                  0x01,0x00,0x00,0x00 },
+                { 0x00,0x00,0x00,0x00,0x00,0x40,0x05,0x0f, 0xff }
+        }
+};
+
+static const struct SiS_Ext SiSUSB_EModeIDTable[] =
+{
+        {0x2e,0x0a1b,0x0101,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x8 */
+        {0x2f,0x0a1b,0x0100,SIS_RI_640x400,  0x00,0x00,0x05,0x05,0x10, 0}, /* 640x400x8 */
+        {0x30,0x2a1b,0x0103,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x8 */
+        {0x31,0x4a1b,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x8 */
+        {0x32,0x4a1b,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x8 */
+        {0x33,0x4a1d,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x16 */
+        {0x34,0x6a1d,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x16 */
+        {0x35,0x4a1f,0x0000,SIS_RI_720x480,  0x00,0x00,0x06,0x06,0x11,-1}, /* 720x480x32 */
+        {0x36,0x6a1f,0x0000,SIS_RI_720x576,  0x00,0x00,0x06,0x06,0x12,-1}, /* 720x576x32 */
+        {0x38,0x0a1b,0x0105,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x8 */
+        {0x3a,0x0e3b,0x0107,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x8 */
+        {0x41,0x9a1d,0x010e,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x16 */
+        {0x44,0x0a1d,0x0111,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x16 */
+        {0x47,0x2a1d,0x0114,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x16 */
+        {0x4a,0x0a3d,0x0117,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x16 */
+        {0x4d,0x0e7d,0x011a,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x16 */
+        {0x50,0x9a1b,0x0132,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x8  */
+        {0x51,0xba1b,0x0133,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x8  */
+        {0x52,0xba1b,0x0134,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x8  */
+        {0x56,0x9a1d,0x0135,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x16 */
+        {0x57,0xba1d,0x0136,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x16 */
+        {0x58,0xba1d,0x0137,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x16 */
+        {0x59,0x9a1b,0x0138,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x8  */
+        {0x5c,0xba1f,0x0000,SIS_RI_512x384,  0x00,0x00,0x00,0x00,0x1d, 4}, /* 512x384x32 */
+        {0x5d,0x0a1d,0x0139,SIS_RI_640x400,  0x00,0x00,0x05,0x07,0x10, 0}, /* 640x400x16 */
+        {0x5e,0x0a1f,0x0000,SIS_RI_640x400,  0x00,0x00,0x05,0x07,0x10, 0}, /* 640x400x32 */
+        {0x62,0x0a3f,0x013a,SIS_RI_640x480,  0x00,0x00,0x05,0x05,0x08, 2}, /* 640x480x32 */
+        {0x63,0x2a3f,0x013b,SIS_RI_800x600,  0x00,0x00,0x07,0x06,0x00, 3}, /* 800x600x32 */
+        {0x64,0x0a7f,0x013c,SIS_RI_1024x768, 0x00,0x00,0x08,0x07,0x13, 4}, /* 1024x768x32 */
+        {0x65,0x0eff,0x013d,SIS_RI_1280x1024,0x00,0x00,0x00,0x00,0x2f, 8}, /* 1280x1024x32 */
+        {0x70,0x6a1b,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x8 */
+        {0x71,0x4a1b,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x8 */
+        {0x74,0x4a1d,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x16 */
+        {0x75,0x0a3d,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x16 */
+        {0x76,0x6a1f,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x32 */
+        {0x77,0x4a1f,0x0000,SIS_RI_1024x576, 0x00,0x00,0x00,0x00,0x21,-1}, /* 1024x576x32 */
+        {0x78,0x0a3f,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x32 */
+        {0x79,0x0a3b,0x0000,SIS_RI_1280x720, 0x00,0x00,0x00,0x00,0x24, 5}, /* 1280x720x8 */
+        {0x7a,0x6a1d,0x0000,SIS_RI_800x480,  0x00,0x00,0x07,0x07,0x1e,-1}, /* 800x480x16 */
+        {0x23,0x0e3b,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x8 */
+        {0x24,0x0e7d,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x16 */
+        {0x25,0x0eff,0x0000,SIS_RI_1280x768, 0x00,0x00,0x00,0x00,0x27, 6}, /* 1280x768x32 */
+        {0x39,0x6a1b,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1}, /* 848x480 */
+        {0x3b,0x6a3d,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1},
+        {0x3e,0x6a7f,0x0000,SIS_RI_848x480,  0x00,0x00,0x00,0x00,0x28,-1},
+        {0x3f,0x6a1b,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1}, /* 856x480 */
+        {0x42,0x6a3d,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1},
+        {0x45,0x6a7f,0x0000,SIS_RI_856x480,  0x00,0x00,0x00,0x00,0x2a,-1},
+        {0x4f,0x9a1f,0x0000,SIS_RI_320x200,  0x00,0x00,0x04,0x04,0x1a, 0}, /* 320x200x32 */
+        {0x53,0x9a1f,0x0000,SIS_RI_320x240,  0x00,0x00,0x04,0x04,0x1b, 2}, /* 320x240x32 */
+        {0x54,0xba1f,0x0000,SIS_RI_400x300,  0x00,0x00,0x07,0x07,0x1c, 3}, /* 400x300x32 */
+        {0x5f,0x6a1b,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1}, /* 768x576 */
+        {0x60,0x6a1d,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1},
+        {0x61,0x6a3f,0x0000,SIS_RI_768x576,  0x00,0x00,0x06,0x06,0x2c,-1},
+        {0x1d,0x6a1b,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1}, /* 960x540 */
+        {0x1e,0x6a3d,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1},
+        {0x1f,0x6a7f,0x0000,SIS_RI_960x540,  0x00,0x00,0x00,0x00,0x2d,-1},
+        {0x20,0x6a1b,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1}, /* 960x600 */
+        {0x21,0x6a3d,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1},
+        {0x22,0x6a7f,0x0000,SIS_RI_960x600,  0x00,0x00,0x00,0x00,0x2e,-1},
+        {0x29,0x4e1b,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1}, /* 1152x864 */
+        {0x2a,0x4e3d,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1},
+        {0x2b,0x4e7f,0x0000,SIS_RI_1152x864, 0x00,0x00,0x00,0x00,0x33,-1},
+        {0xff,0x0000,0x0000,0,               0x00,0x00,0x00,0x00,0x00,-1}
+};
+
+static const struct SiS_Ext2 SiSUSB_RefIndex[] =
+{
+        {0x085f,0x0d,0x03,0x05,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x0 */
+        {0x0067,0x0e,0x04,0x05,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x1 */
+        {0x0067,0x0f,0x08,0x48,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x2 */
+        {0x0067,0x10,0x07,0x8b,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x3 */
+        {0x0047,0x11,0x0a,0x00,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x4 */
+        {0x0047,0x12,0x0d,0x00,0x05,0x30, 800, 600, 0x40, 0x00, 0x00}, /* 0x5 */
+        {0x0047,0x13,0x13,0x00,0x05,0x30, 800, 600, 0x20, 0x00, 0x00}, /* 0x6 */
+        {0x0107,0x14,0x1c,0x00,0x05,0x30, 800, 600, 0x20, 0x00, 0x00}, /* 0x7 */
+        {0xc85f,0x05,0x00,0x04,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0x8 */
+        {0xc067,0x06,0x02,0x04,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0x9 */
+        {0xc067,0x07,0x02,0x47,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xa */
+        {0xc067,0x08,0x03,0x8a,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xb */
+        {0xc047,0x09,0x05,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xc */
+        {0xc047,0x0a,0x09,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xd */
+        {0xc047,0x0b,0x0e,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xe */
+        {0xc047,0x0c,0x15,0x00,0x04,0x2e, 640, 480, 0x40, 0x00, 0x00}, /* 0xf */
+        {0x487f,0x04,0x00,0x00,0x00,0x2f, 640, 400, 0x30, 0x55, 0x6e}, /* 0x10 */
+        {0xc06f,0x3c,0x01,0x06,0x13,0x31, 720, 480, 0x30, 0x00, 0x00}, /* 0x11 */
+        {0x006f,0x3d,0x6f,0x06,0x14,0x32, 720, 576, 0x30, 0x00, 0x00}, /* 0x12 (6f was 03) */
+        {0x0087,0x15,0x06,0x00,0x06,0x38,1024, 768, 0x30, 0x00, 0x00}, /* 0x13 */
+        {0xc877,0x16,0x0b,0x06,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x14 */
+        {0xc067,0x17,0x0f,0x49,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x15 */
+        {0x0067,0x18,0x11,0x00,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x16 */
+        {0x0047,0x19,0x16,0x8c,0x06,0x38,1024, 768, 0x20, 0x00, 0x00}, /* 0x17 */
+        {0x0107,0x1a,0x1b,0x00,0x06,0x38,1024, 768, 0x10, 0x00, 0x00}, /* 0x18 */
+        {0x0107,0x1b,0x1f,0x00,0x06,0x38,1024, 768, 0x10, 0x00, 0x00}, /* 0x19 */
+        {0x407f,0x00,0x00,0x00,0x00,0x41, 320, 200, 0x30, 0x56, 0x4e}, /* 0x1a */
+        {0xc07f,0x01,0x00,0x04,0x04,0x50, 320, 240, 0x30, 0x00, 0x00}, /* 0x1b */
+        {0x007f,0x02,0x04,0x05,0x05,0x51, 400, 300, 0x30, 0x00, 0x00}, /* 0x1c */
+        {0xc077,0x03,0x0b,0x06,0x06,0x52, 512, 384, 0x30, 0x00, 0x00}, /* 0x1d */
+        {0x0077,0x32,0x40,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x1e */
+        {0x0047,0x33,0x07,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x1f */
+        {0x0047,0x34,0x0a,0x08,0x18,0x70, 800, 480, 0x30, 0x00, 0x00}, /* 0x20 */
+        {0x0077,0x35,0x0b,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x21 */
+        {0x0047,0x36,0x11,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x22 */
+        {0x0047,0x37,0x16,0x09,0x19,0x71,1024, 576, 0x30, 0x00, 0x00}, /* 0x23 */
+        {0x1137,0x38,0x19,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x24 */
+        {0x1107,0x39,0x1e,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x25 */
+        {0x1307,0x3a,0x20,0x0a,0x0c,0x75,1280, 720, 0x30, 0x00, 0x00}, /* 0x26 */
+        {0x0077,0x42,0x5b,0x08,0x11,0x23,1280, 768, 0x30, 0x00, 0x00}, /* 0x27 */
+        {0x0087,0x45,0x57,0x00,0x16,0x39, 848, 480, 0x30, 0x00, 0x00}, /* 0x28 38Hzi  */
+        {0xc067,0x46,0x55,0x0b,0x16,0x39, 848, 480, 0x30, 0x00, 0x00}, /* 0x29 848x480-60Hz   */
+        {0x0087,0x47,0x57,0x00,0x17,0x3f, 856, 480, 0x30, 0x00, 0x00}, /* 0x2a 856x480-38Hzi  */
+        {0xc067,0x48,0x57,0x00,0x17,0x3f, 856, 480, 0x30, 0x00, 0x00}, /* 0x2b 856x480-60Hz   */
+        {0x006f,0x4d,0x71,0x06,0x15,0x5f, 768, 576, 0x30, 0x00, 0x00}, /* 0x2c 768x576-56Hz   */
+        {0x0067,0x52,0x6a,0x00,0x1c,0x1d, 960, 540, 0x30, 0x00, 0x00}, /* 0x2d 960x540 60Hz */
+        {0x0077,0x53,0x6b,0x0b,0x1d,0x20, 960, 600, 0x30, 0x00, 0x00}, /* 0x2e 960x600 60Hz */
+        {0x0087,0x1c,0x11,0x00,0x07,0x3a,1280,1024, 0x30, 0x00, 0x00}, /* 0x2f */
+        {0x0137,0x1d,0x19,0x07,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x30 */
+        {0x0107,0x1e,0x1e,0x00,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x31 */
+        {0x0207,0x1f,0x20,0x00,0x07,0x3a,1280,1024, 0x00, 0x00, 0x00}, /* 0x32 */
+        {0x0127,0x54,0x6d,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x33 1152x864-60Hz  */
+        {0x0127,0x44,0x19,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x34 1152x864-75Hz  */
+        {0x0127,0x4a,0x1e,0x00,0x1a,0x29,1152, 864, 0x30, 0x00, 0x00}, /* 0x35 1152x864-85Hz  */
+        {0xffff,0x00,0x00,0x00,0x00,0x00,   0,   0,    0, 0x00, 0x00}
+};
+
+static const struct SiS_CRT1Table SiSUSB_CRT1Table[] =
+{
+ {{0x2d,0x27,0x28,0x90,0x2c,0x80,0xbf,0x1f,
+   0x9c,0x8e,0x8f,0x96,0xb9,0x30,0x00,0x00,
+   0x00}}, /* 0x0 */
+ {{0x2d,0x27,0x28,0x90,0x2c,0x80,0x0b,0x3e,
+   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x00,
+   0x00}}, /* 0x1 */
+ {{0x3d,0x31,0x31,0x81,0x37,0x1f,0x72,0xf0,
+   0x58,0x8c,0x57,0x57,0x73,0x20,0x00,0x05,
+   0x01}}, /* 0x2 */
+ {{0x4f,0x3f,0x3f,0x93,0x45,0x0d,0x24,0xf5,
+   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x01,
+   0x01}}, /* 0x3 */
+ {{0x5f,0x4f,0x50,0x82,0x55,0x81,0xbf,0x1f,
+   0x9c,0x8e,0x8f,0x96,0xb9,0x30,0x00,0x05,
+   0x00}}, /* 0x4 */
+ {{0x5f,0x4f,0x4f,0x83,0x55,0x81,0x0b,0x3e,
+   0xe9,0x8b,0xdf,0xe8,0x0c,0x00,0x00,0x05,
+   0x00}}, /* 0x5 */
+ {{0x63,0x4f,0x4f,0x87,0x56,0x9b,0x06,0x3e,
+   0xe8,0x8a,0xdf,0xe7,0x07,0x00,0x00,0x01,
+   0x00}}, /* 0x6 */
+ {{0x64,0x4f,0x4f,0x88,0x55,0x9d,0xf2,0x1f,
+   0xe0,0x83,0xdf,0xdf,0xf3,0x10,0x00,0x01,
+   0x00}}, /* 0x7 */
+ {{0x63,0x4f,0x4f,0x87,0x5a,0x81,0xfb,0x1f,
+   0xe0,0x83,0xdf,0xdf,0xfc,0x10,0x00,0x05,
+   0x00}}, /* 0x8 */
+ {{0x65,0x4f,0x4f,0x89,0x58,0x80,0xfb,0x1f,
+   0xe0,0x83,0xdf,0xdf,0xfc,0x10,0x00,0x05,
+   0x61}}, /* 0x9 */
+ {{0x65,0x4f,0x4f,0x89,0x58,0x80,0x01,0x3e,
+   0xe0,0x83,0xdf,0xdf,0x02,0x00,0x00,0x05,
+   0x61}}, /* 0xa */
+ {{0x67,0x4f,0x4f,0x8b,0x58,0x81,0x0d,0x3e,
+   0xe0,0x83,0xdf,0xdf,0x0e,0x00,0x00,0x05,
+   0x61}}, /* 0xb */
+ {{0x65,0x4f,0x4f,0x89,0x57,0x9f,0xfb,0x1f,
+   0xe6,0x8a,0xdf,0xdf,0xfc,0x10,0x00,0x01,
+   0x00}}, /* 0xc */
+ {{0x7b,0x63,0x63,0x9f,0x6a,0x93,0x6f,0xf0,
+   0x58,0x8a,0x57,0x57,0x70,0x20,0x00,0x05,
+   0x01}}, /* 0xd */
+ {{0x7f,0x63,0x63,0x83,0x6c,0x1c,0x72,0xf0,
+   0x58,0x8c,0x57,0x57,0x73,0x20,0x00,0x06,
+   0x01}}, /* 0xe */
+ {{0x7d,0x63,0x63,0x81,0x6e,0x1d,0x98,0xf0,
+   0x7c,0x82,0x57,0x57,0x99,0x00,0x00,0x06,
+   0x01}}, /* 0xf */
+ {{0x7f,0x63,0x63,0x83,0x69,0x13,0x6f,0xf0,
+   0x58,0x8b,0x57,0x57,0x70,0x20,0x00,0x06,
+   0x01}}, /* 0x10 */
+ {{0x7e,0x63,0x63,0x82,0x6b,0x13,0x75,0xf0,
+   0x58,0x8b,0x57,0x57,0x76,0x20,0x00,0x06,
+   0x01}}, /* 0x11 */
+ {{0x81,0x63,0x63,0x85,0x6d,0x18,0x7a,0xf0,
+   0x58,0x8b,0x57,0x57,0x7b,0x20,0x00,0x06,
+   0x61}}, /* 0x12 */
+ {{0x83,0x63,0x63,0x87,0x6e,0x19,0x81,0xf0,
+   0x58,0x8b,0x57,0x57,0x82,0x20,0x00,0x06,
+   0x61}}, /* 0x13 */
+ {{0x85,0x63,0x63,0x89,0x6f,0x1a,0x91,0xf0,
+   0x58,0x8b,0x57,0x57,0x92,0x20,0x00,0x06,
+   0x61}}, /* 0x14 */
+ {{0x99,0x7f,0x7f,0x9d,0x84,0x1a,0x96,0x1f,
+   0x7f,0x83,0x7f,0x7f,0x97,0x10,0x00,0x02,
+   0x00}}, /* 0x15 */
+ {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf5,
+   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
+   0x01}}, /* 0x16 */
+ {{0xa1,0x7f,0x7f,0x85,0x86,0x97,0x24,0xf5,
+   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
+   0x01}}, /* 0x17 */
+ {{0x9f,0x7f,0x7f,0x83,0x85,0x91,0x1e,0xf5,
+   0x00,0x83,0xff,0xff,0x1f,0x10,0x00,0x02,
+   0x01}}, /* 0x18 */
+ {{0xa7,0x7f,0x7f,0x8b,0x89,0x95,0x26,0xf5,
+   0x00,0x83,0xff,0xff,0x27,0x10,0x00,0x02,
+   0x01}}, /* 0x19 */
+ {{0xa9,0x7f,0x7f,0x8d,0x8c,0x9a,0x2c,0xf5,
+   0x00,0x83,0xff,0xff,0x2d,0x14,0x00,0x02,
+   0x62}}, /* 0x1a */
+ {{0xab,0x7f,0x7f,0x8f,0x8d,0x9b,0x35,0xf5,
+   0x00,0x83,0xff,0xff,0x36,0x14,0x00,0x02,
+   0x62}}, /* 0x1b */
+ {{0xcf,0x9f,0x9f,0x93,0xb2,0x01,0x14,0xba,
+   0x00,0x83,0xff,0xff,0x15,0x00,0x00,0x03,
+   0x00}}, /* 0x1c */
+ {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x28,0x5a,
+   0x00,0x83,0xff,0xff,0x29,0x09,0x00,0x07,
+   0x01}}, /* 0x1d */
+ {{0xce,0x9f,0x9f,0x92,0xa5,0x17,0x28,0x5a,
+   0x00,0x83,0xff,0xff,0x29,0x09,0x00,0x07,
+   0x01}}, /* 0x1e */
+ {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0x2e,0x5a,
+   0x00,0x83,0xff,0xff,0x2f,0x09,0x00,0x07,
+   0x01}}, /* 0x1f */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x20 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x21 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x22 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x23 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x24 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x25 */
+ {{0x09,0xc7,0xc7,0x8d,0xd3,0x0b,0xe0,0x10,
+   0xb0,0x83,0xaf,0xaf,0xe1,0x2f,0x01,0x04,
+   0x00}}, /* 0x26 */
+ {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
+   0x00}}, /* 0x27 */
+ {{0x43,0xef,0xef,0x87,0x06,0x00,0xd4,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xd5,0x1f,0x41,0x05,
+   0x63}}, /* 0x28 */
+ {{0x45,0xef,0xef,0x89,0x07,0x01,0xd9,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xda,0x1f,0x41,0x05,
+   0x63}}, /* 0x29 */
+ {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
+   0x00}}, /* 0x2a */
+ {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
+   0x00}}, /* 0x2b */
+ {{0x40,0xef,0xef,0x84,0x03,0x1d,0xda,0x1f,
+   0xa0,0x83,0x9f,0x9f,0xdb,0x1f,0x41,0x01,
+   0x00}}, /* 0x2c */
+ {{0x59,0xff,0xff,0x9d,0x17,0x13,0x33,0xba,
+   0x00,0x83,0xff,0xff,0x34,0x0f,0x41,0x05,
+   0x44}}, /* 0x2d */
+ {{0x5b,0xff,0xff,0x9f,0x18,0x14,0x38,0xba,
+   0x00,0x83,0xff,0xff,0x39,0x0f,0x41,0x05,
+   0x44}}, /* 0x2e */
+ {{0x5b,0xff,0xff,0x9f,0x18,0x14,0x3d,0xba,
+   0x00,0x83,0xff,0xff,0x3e,0x0f,0x41,0x05,
+   0x44}}, /* 0x2f */
+ {{0x5d,0xff,0xff,0x81,0x19,0x95,0x41,0xba,
+   0x00,0x84,0xff,0xff,0x42,0x0f,0x41,0x05,
+   0x44}}, /* 0x30 */
+ {{0x55,0xff,0xff,0x99,0x0d,0x0c,0x3e,0xba,
+   0x00,0x84,0xff,0xff,0x3f,0x0f,0x41,0x05,
+   0x00}}, /* 0x31 */
+ {{0x7f,0x63,0x63,0x83,0x6c,0x1c,0x72,0xba,
+   0x27,0x8b,0xdf,0xdf,0x73,0x00,0x00,0x06,
+   0x01}}, /* 0x32 */
+ {{0x7f,0x63,0x63,0x83,0x69,0x13,0x6f,0xba,
+   0x26,0x89,0xdf,0xdf,0x6f,0x00,0x00,0x06,
+   0x01}}, /* 0x33 */
+ {{0x7f,0x63,0x63,0x82,0x6b,0x13,0x75,0xba,
+   0x29,0x8c,0xdf,0xdf,0x75,0x00,0x00,0x06,
+   0x01}}, /* 0x34 */
+ {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf1,
+   0xaf,0x85,0x3f,0x3f,0x25,0x30,0x00,0x02,
+   0x01}}, /* 0x35 */
+ {{0x9f,0x7f,0x7f,0x83,0x85,0x91,0x1e,0xf1,
+   0xad,0x81,0x3f,0x3f,0x1f,0x30,0x00,0x02,
+   0x01}}, /* 0x36 */
+ {{0xa7,0x7f,0x7f,0x88,0x89,0x95,0x26,0xf1,
+   0xb1,0x85,0x3f,0x3f,0x27,0x30,0x00,0x02,
+   0x01}}, /* 0x37 */
+ {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x28,0xc4,
+   0x7a,0x8e,0xcf,0xcf,0x29,0x21,0x00,0x07,
+   0x01}}, /* 0x38 */
+ {{0xce,0x9f,0x9f,0x92,0xa5,0x17,0x28,0xd4,
+   0x7a,0x8e,0xcf,0xcf,0x29,0x21,0x00,0x07,
+   0x01}}, /* 0x39 */
+ {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0x2e,0xd4,
+   0x7d,0x81,0xcf,0xcf,0x2f,0x21,0x00,0x07,
+   0x01}}, /* 0x3a */
+ {{0xdc,0x9f,0x9f,0x80,0xaf,0x9d,0xe6,0xff,
+   0xc0,0x83,0xbf,0xbf,0xe7,0x10,0x00,0x07,
+   0x01}}, /* 0x3b */
+ {{0x6b,0x59,0x59,0x8f,0x5e,0x8c,0x0b,0x3e,
+   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x05,
+   0x00}}, /* 0x3c */
+ {{0x6d,0x59,0x59,0x91,0x60,0x89,0x53,0xf0,
+   0x41,0x84,0x3f,0x3f,0x54,0x00,0x00,0x05,
+   0x41}}, /* 0x3d */
+ {{0x86,0x6a,0x6a,0x8a,0x74,0x06,0x8c,0x15,
+   0x4f,0x83,0xef,0xef,0x8d,0x30,0x00,0x02,
+   0x00}}, /* 0x3e */
+ {{0x81,0x6a,0x6a,0x85,0x70,0x00,0x0f,0x3e,
+   0xeb,0x8e,0xdf,0xdf,0x10,0x00,0x00,0x02,
+   0x00}}, /* 0x3f */
+ {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x1e,0xf1,
+   0xae,0x85,0x57,0x57,0x1f,0x30,0x00,0x02,
+   0x01}},  /* 0x40 */
+ {{0xa3,0x7f,0x7f,0x87,0x86,0x97,0x24,0xf5,
+   0x02,0x88,0xff,0xff,0x25,0x10,0x00,0x02,
+   0x01}},  /* 0x41 */
+ {{0xce,0x9f,0x9f,0x92,0xa9,0x17,0x20,0xf5,
+   0x03,0x88,0xff,0xff,0x21,0x10,0x00,0x07,
+   0x01}},  /* 0x42 */
+ {{0xe6,0xae,0xae,0x8a,0xbd,0x90,0x3d,0x10,
+   0x1a,0x8d,0x19,0x19,0x3e,0x2f,0x00,0x03,
+   0x00}},  /* 0x43 */
+ {{0xc3,0x8f,0x8f,0x87,0x9b,0x0b,0x82,0xef,
+   0x60,0x83,0x5f,0x5f,0x83,0x10,0x00,0x07,
+   0x01}},  /* 0x44 */
+ {{0x86,0x69,0x69,0x8A,0x74,0x06,0x8C,0x15,
+   0x4F,0x83,0xEF,0xEF,0x8D,0x30,0x00,0x02,
+   0x00}},  /* 0x45 */
+ {{0x83,0x69,0x69,0x87,0x6f,0x1d,0x03,0x3E,
+   0xE5,0x8d,0xDF,0xe4,0x04,0x00,0x00,0x06,
+   0x00}},  /* 0x46 */
+ {{0x86,0x6A,0x6A,0x8A,0x74,0x06,0x8C,0x15,
+   0x4F,0x83,0xEF,0xEF,0x8D,0x30,0x00,0x02,
+   0x00}},  /* 0x47 */
+ {{0x81,0x6A,0x6A,0x85,0x70,0x00,0x0F,0x3E,
+   0xEB,0x8E,0xDF,0xDF,0x10,0x00,0x00,0x02,
+   0x00}},  /* 0x48 */
+ {{0xdd,0xa9,0xa9,0x81,0xb4,0x97,0x26,0xfd,
+   0x01,0x8d,0xff,0x00,0x27,0x10,0x00,0x03,
+   0x01}},  /* 0x49 */
+ {{0xd9,0x8f,0x8f,0x9d,0xba,0x0a,0x8a,0xff,
+   0x60,0x8b,0x5f,0x5f,0x8b,0x10,0x00,0x03,
+   0x01}},  /* 0x4a */
+ {{0xea,0xae,0xae,0x8e,0xba,0x82,0x40,0x10,
+   0x1b,0x87,0x19,0x1a,0x41,0x0f,0x00,0x03,
+   0x00}},  /* 0x4b */
+ {{0xd3,0x9f,0x9f,0x97,0xab,0x1f,0xf1,0xff,
+   0xc0,0x83,0xbf,0xbf,0xf2,0x10,0x00,0x07,
+   0x01}},  /* 0x4c */
+ {{0x75,0x5f,0x5f,0x99,0x66,0x90,0x53,0xf0,
+   0x41,0x84,0x3f,0x3f,0x54,0x00,0x00,0x05,
+   0x41}},
+ {{0x2d,0x27,0x28,0x90,0x2c,0x80,0x0b,0x3e,
+   0xe9,0x8b,0xdf,0xe7,0x04,0x00,0x00,0x00,
+   0x00}},  /* 0x4e */
+ {{0xcd,0x9f,0x9f,0x91,0xab,0x1c,0x3a,0xff,
+   0x20,0x83,0x1f,0x1f,0x3b,0x10,0x00,0x07,
+   0x21}},  /* 0x4f */
+ {{0x15,0xd1,0xd1,0x99,0xe2,0x19,0x3d,0x10,
+   0x1a,0x8d,0x19,0x19,0x3e,0x2f,0x01,0x0c,
+   0x20}},  /* 0x50 */
+ {{0x0e,0xef,0xef,0x92,0xfe,0x03,0x30,0xf0,
+   0x1e,0x83,0x1b,0x1c,0x31,0x00,0x01,0x00,
+   0x61}},  /* 0x51 */
+ {{0x85,0x77,0x77,0x89,0x7d,0x01,0x31,0xf0,
+   0x1e,0x84,0x1b,0x1c,0x32,0x00,0x00,0x02,
+   0x41}},  /* 0x52 */
+ {{0x87,0x77,0x77,0x8b,0x81,0x0b,0x68,0xf0,
+   0x5a,0x80,0x57,0x57,0x69,0x00,0x00,0x02,
+   0x01}},  /* 0x53 */
+ {{0xcd,0x8f,0x8f,0x91,0x9b,0x1b,0x7a,0xff,
+   0x64,0x8c,0x5f,0x62,0x7b,0x10,0x00,0x07,
+   0x41}}   /* 0x54 */
+};
+
+static struct SiS_VCLKData SiSUSB_VCLKData[] =
+{
+        { 0x1b,0xe1, 25}, /* 0x00 */
+        { 0x4e,0xe4, 28}, /* 0x01 */
+        { 0x57,0xe4, 31}, /* 0x02 */
+        { 0xc3,0xc8, 36}, /* 0x03 */
+        { 0x42,0xe2, 40}, /* 0x04 */
+        { 0xfe,0xcd, 43}, /* 0x05 */
+        { 0x5d,0xc4, 44}, /* 0x06 */
+        { 0x52,0xe2, 49}, /* 0x07 */
+        { 0x53,0xe2, 50}, /* 0x08 */
+        { 0x74,0x67, 52}, /* 0x09 */
+        { 0x6d,0x66, 56}, /* 0x0a */
+        { 0x5a,0x64, 65}, /* 0x0b */
+        { 0x46,0x44, 67}, /* 0x0c */
+        { 0xb1,0x46, 68}, /* 0x0d */
+        { 0xd3,0x4a, 72}, /* 0x0e */
+        { 0x29,0x61, 75}, /* 0x0f */
+        { 0x6e,0x46, 76}, /* 0x10 */
+        { 0x2b,0x61, 78}, /* 0x11 */
+        { 0x31,0x42, 79}, /* 0x12 */
+        { 0xab,0x44, 83}, /* 0x13 */
+        { 0x46,0x25, 84}, /* 0x14 */
+        { 0x78,0x29, 86}, /* 0x15 */
+        { 0x62,0x44, 94}, /* 0x16 */
+        { 0x2b,0x41,104}, /* 0x17 */
+        { 0x3a,0x23,105}, /* 0x18 */
+        { 0x70,0x44,108}, /* 0x19 */
+        { 0x3c,0x23,109}, /* 0x1a */
+        { 0x5e,0x43,113}, /* 0x1b */
+        { 0xbc,0x44,116}, /* 0x1c */
+        { 0xe0,0x46,132}, /* 0x1d */
+        { 0x54,0x42,135}, /* 0x1e */
+        { 0xea,0x2a,139}, /* 0x1f */
+        { 0x41,0x22,157}, /* 0x20 */
+        { 0x70,0x24,162}, /* 0x21 */
+        { 0x30,0x21,175}, /* 0x22 */
+        { 0x4e,0x22,189}, /* 0x23 */
+        { 0xde,0x26,194}, /* 0x24 */
+        { 0x62,0x06,202}, /* 0x25 */
+        { 0x3f,0x03,229}, /* 0x26 */
+        { 0xb8,0x06,234}, /* 0x27 */
+        { 0x34,0x02,253}, /* 0x28 */
+        { 0x58,0x04,255}, /* 0x29 */
+        { 0x24,0x01,265}, /* 0x2a */
+        { 0x9b,0x02,267}, /* 0x2b */
+        { 0x70,0x05,270}, /* 0x2c */
+        { 0x25,0x01,272}, /* 0x2d */
+        { 0x9c,0x02,277}, /* 0x2e */
+        { 0x27,0x01,286}, /* 0x2f */
+        { 0x3c,0x02,291}, /* 0x30 */
+        { 0xef,0x0a,292}, /* 0x31 */
+        { 0xf6,0x0a,310}, /* 0x32 */
+        { 0x95,0x01,315}, /* 0x33 */
+        { 0xf0,0x09,324}, /* 0x34 */
+        { 0xfe,0x0a,331}, /* 0x35 */
+        { 0xf3,0x09,332}, /* 0x36 */
+        { 0xea,0x08,340}, /* 0x37 */
+        { 0xe8,0x07,376}, /* 0x38 */
+        { 0xde,0x06,389}, /* 0x39 */
+        { 0x52,0x2a, 54}, /* 0x3a 301 TV */
+        { 0x52,0x6a, 27}, /* 0x3b 301 TV */
+        { 0x62,0x24, 70}, /* 0x3c 301 TV */
+        { 0x62,0x64, 70}, /* 0x3d 301 TV */
+        { 0xa8,0x4c, 30}, /* 0x3e 301 TV */
+        { 0x20,0x26, 33}, /* 0x3f 301 TV */
+        { 0x31,0xc2, 39}, /* 0x40 */
+        { 0x60,0x36, 30}, /* 0x41 Chrontel */
+        { 0x40,0x4a, 28}, /* 0x42 Chrontel */
+        { 0x9f,0x46, 44}, /* 0x43 Chrontel */
+        { 0x97,0x2c, 26}, /* 0x44 */
+        { 0x44,0xe4, 25}, /* 0x45 Chrontel */
+        { 0x7e,0x32, 47}, /* 0x46 Chrontel */
+        { 0x8a,0x24, 31}, /* 0x47 Chrontel */
+        { 0x97,0x2c, 26}, /* 0x48 Chrontel */
+        { 0xce,0x3c, 39}, /* 0x49 */
+        { 0x52,0x4a, 36}, /* 0x4a Chrontel */
+        { 0x34,0x61, 95}, /* 0x4b */
+        { 0x78,0x27,108}, /* 0x4c - was 102 */
+        { 0x66,0x43,123}, /* 0x4d Modes 0x26-0x28 (1400x1050) */
+        { 0x41,0x4e, 21}, /* 0x4e */
+        { 0xa1,0x4a, 29}, /* 0x4f Chrontel */
+        { 0x19,0x42, 42}, /* 0x50 */
+        { 0x54,0x46, 58}, /* 0x51 Chrontel */
+        { 0x25,0x42, 61}, /* 0x52 */
+        { 0x44,0x44, 66}, /* 0x53 Chrontel */
+        { 0x3a,0x62, 70}, /* 0x54 Chrontel */
+        { 0x62,0xc6, 34}, /* 0x55 848x480-60 */
+        { 0x6a,0xc6, 37}, /* 0x56 848x480-75 - TEMP */
+        { 0xbf,0xc8, 35}, /* 0x57 856x480-38i,60 */
+        { 0x30,0x23, 88}, /* 0x58 1360x768-62 (is 60Hz!) */
+        { 0x52,0x07,149}, /* 0x59 1280x960-85 */
+        { 0x56,0x07,156}, /* 0x5a 1400x1050-75 */
+        { 0x70,0x29, 81}, /* 0x5b 1280x768 LCD */
+        { 0x45,0x25, 83}, /* 0x5c 1280x800  */
+        { 0x70,0x0a,147}, /* 0x5d 1680x1050 */
+        { 0x70,0x24,162}, /* 0x5e 1600x1200 */
+        { 0x5a,0x64, 65}, /* 0x5f 1280x720 - temp */
+        { 0x63,0x46, 68}, /* 0x60 1280x768_2 */
+        { 0x31,0x42, 79}, /* 0x61 1280x768_3 - temp */
+        {    0,   0,  0}, /* 0x62 - custom (will be filled out at run-time) */
+        { 0x5a,0x64, 65}, /* 0x63 1280x720 (LCD LVDS) */
+        { 0x70,0x28, 90}, /* 0x64 1152x864@60 */
+        { 0x41,0xc4, 32}, /* 0x65 848x480@60 */
+        { 0x5c,0xc6, 32}, /* 0x66 856x480@60 */
+        { 0x76,0xe7, 27}, /* 0x67 720x480@60 */
+        { 0x5f,0xc6, 33}, /* 0x68 720/768x576@60 */
+        { 0x52,0x27, 75}, /* 0x69 1920x1080i 60Hz interlaced */
+        { 0x7c,0x6b, 38}, /* 0x6a 960x540@60 */
+        { 0xe3,0x56, 41}, /* 0x6b 960x600@60 */
+        { 0x45,0x25, 83}, /* 0x6c 1280x800 */
+        { 0x70,0x28, 90}, /* 0x6d 1152x864@60 */
+        { 0x15,0xe1, 20}, /* 0x6e 640x400@60 (fake, not actually used) */
+        { 0x5f,0xc6, 33}, /* 0x6f 720x576@60 */
+        { 0x37,0x5a, 10}, /* 0x70 320x200@60 (fake, not actually used) */
+        { 0x2b,0xc2, 35}  /* 0x71 768@576@60 */
+};
+
+void            SiSUSBRegInit(struct SiS_Private *SiS_Pr, unsigned long BaseAddr);
+unsigned short  SiSUSB_GetModeID(int HDisplay, int VDisplay, int Depth);
+int             SiSUSBSetMode(struct SiS_Private *SiS_Pr, unsigned short ModeNo);
+int             SiSUSBSetVESAMode(struct SiS_Private *SiS_Pr, unsigned short VModeNo);
+
+extern int      sisusb_setreg(struct sisusb_usb_data *sisusb, int port, u8 data);
+extern int      sisusb_getreg(struct sisusb_usb_data *sisusb, int port, u8 *data);
+extern int      sisusb_setidxreg(struct sisusb_usb_data *sisusb, int port,
+                                        u8 index, u8 data);
+extern int      sisusb_getidxreg(struct sisusb_usb_data *sisusb, int port,
+                                        u8 index, u8 *data);
+extern int      sisusb_setidxregandor(struct sisusb_usb_data *sisusb, int port,
+                                        u8 idx, u8 myand, u8 myor);
+extern int      sisusb_setidxregor(struct sisusb_usb_data *sisusb, int port,
+                                        u8 index, u8 myor);
+extern int      sisusb_setidxregand(struct sisusb_usb_data *sisusb, int port,
+                                        u8 idx, u8 myand);
+
+#endif
+
diff --git a/drivers/usb/misc/sisusbvga/sisusb_struct.h b/drivers/usb/misc/sisusbvga/sisusb_struct.h
new file mode 100644
index 000000000000..94edd4726c42
--- /dev/null
+++ b/drivers/usb/misc/sisusbvga/sisusb_struct.h
@@ -0,0 +1,169 @@
+/*
+ * General structure definitions for universal mode switching modules
+ *
+ * Copyright (C) 2001-2005 by Thomas Winischhofer, Vienna, Austria
+ *
+ * If distributed as part of the Linux kernel, the following license terms
+ * apply:
+ *
+ * * This program is free software; you can redistribute it and/or modify
+ * * it under the terms of the GNU General Public License as published by
+ * * the Free Software Foundation; either version 2 of the named License,
+ * * or any later version.
+ * *
+ * * This program is distributed in the hope that it will be useful,
+ * * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * * GNU General Public License for more details.
+ * *
+ * * You should have received a copy of the GNU General Public License
+ * * along with this program; if not, write to the Free Software
+ * * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA
+ *
+ * Otherwise, the following license terms apply:
+ *
+ * * Redistribution and use in source and binary forms, with or without
+ * * modification, are permitted provided that the following conditions
+ * * are met:
+ * * 1) Redistributions of source code must retain the above copyright
+ * *    notice, this list of conditions and the following disclaimer.
+ * * 2) Redistributions in binary form must reproduce the above copyright
+ * *    notice, this list of conditions and the following disclaimer in the
+ * *    documentation and/or other materials provided with the distribution.
+ * * 3) The name of the author may not be used to endorse or promote products
+ * *    derived from this software without specific prior written permission.
+ * *
+ * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Author:      Thomas Winischhofer <thomas@winischhofer.net>
+ *
+ */
+
+#ifndef _SISUSB_STRUCT_H_
+#define _SISUSB_STRUCT_H_
+
+struct SiS_St {
+        unsigned char   St_ModeID;
+        unsigned short  St_ModeFlag;
+        unsigned char   St_StTableIndex;
+        unsigned char   St_CRT2CRTC;
+        unsigned char   St_ResInfo;
+        unsigned char   VB_StTVFlickerIndex;
+        unsigned char   VB_StTVEdgeIndex;
+        unsigned char   VB_StTVYFilterIndex;
+        unsigned char   St_PDC;
+};
+
+struct SiS_StandTable
+{
+        unsigned char   CRT_COLS;
+        unsigned char   ROWS;
+        unsigned char   CHAR_HEIGHT;
+        unsigned short  CRT_LEN;
+        unsigned char   SR[4];
+        unsigned char   MISC;
+        unsigned char   CRTC[0x19];
+        unsigned char   ATTR[0x14];
+        unsigned char   GRC[9];
+};
+
+struct SiS_StResInfo_S {
+        unsigned short  HTotal;
+        unsigned short  VTotal;
+};
+
+struct SiS_Ext
+{
+        unsigned char   Ext_ModeID;
+        unsigned short  Ext_ModeFlag;
+        unsigned short  Ext_VESAID;
+        unsigned char   Ext_RESINFO;
+        unsigned char   VB_ExtTVFlickerIndex;
+        unsigned char   VB_ExtTVEdgeIndex;
+        unsigned char   VB_ExtTVYFilterIndex;
+        unsigned char   VB_ExtTVYFilterIndexROM661;
+        unsigned char   REFindex;
+        char            ROMMODEIDX661;
+};
+
+struct SiS_Ext2
+{
+        unsigned short  Ext_InfoFlag;
+        unsigned char   Ext_CRT1CRTC;
+        unsigned char   Ext_CRTVCLK;
+        unsigned char   Ext_CRT2CRTC;
+        unsigned char   Ext_CRT2CRTC_NS;
+        unsigned char   ModeID;
+        unsigned short  XRes;
+        unsigned short  YRes;
+        unsigned char   Ext_PDC;
+        unsigned char   Ext_FakeCRT2CRTC;
+        unsigned char   Ext_FakeCRT2Clk;
+};
+
+struct SiS_CRT1Table
+{
+        unsigned char   CR[17];
+};
+
+struct SiS_VCLKData
+{
+        unsigned char   SR2B,SR2C;
+        unsigned short  CLOCK;
+};
+
+struct SiS_ModeResInfo
+{
+        unsigned short  HTotal;
+        unsigned short  VTotal;
+        unsigned char   XChar;
+        unsigned char   YChar;
+};
+
+struct SiS_Private
+{
+        void *sisusb;
+
+        unsigned long IOAddress;
+
+        unsigned long SiS_P3c4;
+        unsigned long SiS_P3d4;
+        unsigned long SiS_P3c0;
+        unsigned long SiS_P3ce;
+        unsigned long SiS_P3c2;
+        unsigned long SiS_P3ca;
+        unsigned long SiS_P3c6;
+        unsigned long SiS_P3c7;
+        unsigned long SiS_P3c8;
+        unsigned long SiS_P3c9;
+        unsigned long SiS_P3cb;
+        unsigned long SiS_P3cc;
+        unsigned long SiS_P3cd;
+        unsigned long SiS_P3da;
+        unsigned long SiS_Part1Port;
+
+        unsigned char   SiS_MyCR63;
+        unsigned short  SiS_CRT1Mode;
+        unsigned short  SiS_ModeType;
+        unsigned short  SiS_SetFlag;
+
+        const struct SiS_StandTable     *SiS_StandTable;
+        const struct SiS_St             *SiS_SModeIDTable;
+        const struct SiS_Ext            *SiS_EModeIDTable;
+        const struct SiS_Ext2           *SiS_RefIndex;
+        const struct SiS_CRT1Table      *SiS_CRT1Table;
+        struct SiS_VCLKData             *SiS_VCLKData;
+        const struct SiS_ModeResInfo    *SiS_ModeResInfo;
+};
+
+#endif
+
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index fd7fb98e4b20..54799eb0bc60 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -986,7 +986,6 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
 
                 u->context = &context;
                 u->complete = ctrl_complete;
-                u->transfer_flags |= URB_ASYNC_UNLINK;
         }
 
         /* queue the urbs */
@@ -1052,7 +1051,6 @@ static int unlink1 (struct usbtest_dev *dev, int pipe, int size, int async)
         urb = simple_alloc_urb (testdev_to_usbdev (dev), pipe, size);
         if (!urb)
                 return -ENOMEM;
-        urb->transfer_flags |= URB_ASYNC_UNLINK;
         urb->context = &completion;
         urb->complete = unlink1_callback;
 
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index faa74436de52..03fb70ef2eb3 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -3,8 +3,8 @@
 /*
  *      uss720.c  --  USS720 USB Parport Cable.
  *
- *      Copyright (C) 1999
- *          Thomas Sailer (sailer@ife.ee.ethz.ch)
+ *      Copyright (C) 1999, 2005
+ *          Thomas Sailer (t.sailer@alumni.ethz.ch)
  *
  *      This program is free software; you can redistribute it and/or modify
  *      it under the terms of the GNU General Public License as published by
@@ -23,103 +23,240 @@
  *  Based on parport_pc.c
  *
  *  History:
- *   0.1  04.08.99  Created
- *   0.2  07.08.99  Some fixes mainly suggested by Tim Waugh
- *                  Interrupt handling currently disabled because
- *                  usb_request_irq crashes somewhere within ohci.c
- *                  for no apparent reason (that is for me, anyway)
- *                  ECP currently untested
- *   0.3  10.08.99  fixing merge errors
- *   0.4  13.08.99  Added Vendor/Product ID of Brad Hard's cable
- *   0.5  20.09.99  usb_control_msg wrapper used
- *        Nov01.00  usb_device_table support by Adam J. Richter
- *        08.04.01  Identify version on module load.  gb
+ *   0.1  04.08.1999  Created
+ *   0.2  07.08.1999  Some fixes mainly suggested by Tim Waugh
+ *                    Interrupt handling currently disabled because
+ *                    usb_request_irq crashes somewhere within ohci.c
+ *                    for no apparent reason (that is for me, anyway)
+ *                    ECP currently untested
+ *   0.3  10.08.1999  fixing merge errors
+ *   0.4  13.08.1999  Added Vendor/Product ID of Brad Hard's cable
+ *   0.5  20.09.1999  usb_control_msg wrapper used
+ *        Nov01.2000  usb_device_table support by Adam J. Richter
+ *        08.04.2001  Identify version on module load.  gb
+ *   0.6  02.09.2005  Fix "scheduling in interrupt" problem by making save/restore
+ *                    context asynchronous
  *
  */
 
 /*****************************************************************************/
 
+#define DEBUG
+
 #include <linux/module.h>
 #include <linux/socket.h>
 #include <linux/parport.h>
 #include <linux/init.h>
 #include <linux/usb.h>
 #include <linux/delay.h>
+#include <linux/completion.h>
+#include <linux/kref.h>
 
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.5"
-#define DRIVER_AUTHOR "Thomas M. Sailer, sailer@ife.ee.ethz.ch"
+#define DRIVER_VERSION "v0.6"
+#define DRIVER_AUTHOR "Thomas M. Sailer, t.sailer@alumni.ethz.ch"
 #define DRIVER_DESC "USB Parport Cable driver for Cables using the Lucent Technologies USS720 Chip"
 
 /* --------------------------------------------------------------------- */
 
 struct parport_uss720_private {
         struct usb_device *usbdev;
-        void *irqhandle;
-        unsigned int irqpipe;
-        unsigned char reg[7];  /* USB registers */
+        struct parport *pp;
+        struct kref ref_count;
+        __u8 reg[7];  /* USB registers */
+        struct list_head asynclist;
+        spinlock_t asynclock;
+};
+
+struct uss720_async_request {
+        struct parport_uss720_private *priv;
+        struct kref ref_count;
+        struct list_head asynclist;
+        struct completion compl;
+        struct urb *urb;
+        struct usb_ctrlrequest dr;
+        __u8 reg[7];
 };
 
 /* --------------------------------------------------------------------- */
 
-static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val)
+static void destroy_priv(struct kref *kref)
 {
-        struct parport_uss720_private *priv = pp->private_data;
-        struct usb_device *usbdev = priv->usbdev;
-        static const unsigned char regindex[9] = {
-                4, 0, 1, 5, 5, 0, 2, 3, 6
-        };
-        int ret;
+        struct parport_uss720_private *priv = container_of(kref, struct parport_uss720_private, ref_count);
 
-        if (!usbdev)
-                return -1;
-        ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev,0), 3, 0xc0, ((unsigned int)reg) << 8, 0, priv->reg, 7, 1000);
-        if (ret != 7) {
-                printk(KERN_DEBUG "uss720: get_1284_register(%d) failed, status 0x%x expected 7\n",
-                       (unsigned int)reg, ret);
-                ret = -1;
-        } else {
+        usb_put_dev(priv->usbdev);
+        kfree(priv);
+        dbg("destroying priv datastructure");
+}
+
+static void destroy_async(struct kref *kref)
+{
+        struct uss720_async_request *rq = container_of(kref, struct uss720_async_request, ref_count);
+        struct parport_uss720_private *priv = rq->priv;
+        unsigned long flags;
+
+        if (likely(rq->urb))
+                usb_free_urb(rq->urb);
+        spin_lock_irqsave(&priv->asynclock, flags);
+        list_del_init(&rq->asynclist);
+        spin_unlock_irqrestore(&priv->asynclock, flags);
+        kfree(rq);
+        kref_put(&priv->ref_count, destroy_priv);
+}
+
+/* --------------------------------------------------------------------- */
+
+static void async_complete(struct urb *urb, struct pt_regs *ptregs)
+{
+        struct uss720_async_request *rq;
+        struct parport *pp;
+        struct parport_uss720_private *priv;
+
+        rq = urb->context;
+        priv = rq->priv;
+        pp = priv->pp;
+        if (urb->status) {
+                err("async_complete: urb error %d", urb->status);
+        } else if (rq->dr.bRequest == 3) {
+                memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 #if 0
-                printk(KERN_DEBUG "uss720: get_1284_register(%d) return %02x %02x %02x %02x %02x %02x %02x\n",
-                       (unsigned int)reg, (unsigned int)priv->reg[0], (unsigned int)priv->reg[1],
-                       (unsigned int)priv->reg[2], (unsigned int)priv->reg[3], (unsigned int)priv->reg[4],
-                       (unsigned int)priv->reg[5], (unsigned int)priv->reg[6]);
+                dbg("async_complete regs %02x %02x %02x %02x %02x %02x %02x",
+                    (unsigned int)priv->reg[0], (unsigned int)priv->reg[1], (unsigned int)priv->reg[2],
+                    (unsigned int)priv->reg[3], (unsigned int)priv->reg[4], (unsigned int)priv->reg[5],
+                    (unsigned int)priv->reg[6]);
 #endif
                 /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
-                if (priv->reg[2] & priv->reg[1] & 0x10)
+                if (rq->reg[2] & rq->reg[1] & 0x10 && pp)
                         parport_generic_irq(0, pp, NULL);
-                ret = 0;
         }
-        if (val)
-                *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
-        return ret;
+        complete(&rq->compl);
+        kref_put(&rq->ref_count, destroy_async);
 }
 
-static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val)
+static struct uss720_async_request *submit_async_request(struct parport_uss720_private *priv,
+                                                         __u8 request, __u8 requesttype, __u16 value, __u16 index,
+                                                         unsigned int mem_flags)
 {
-        struct parport_uss720_private *priv = pp->private_data;
-        struct usb_device *usbdev = priv->usbdev;
+        struct usb_device *usbdev;
+        struct uss720_async_request *rq;
+        unsigned long flags;
         int ret;
 
+        if (!priv)
+                return NULL;
+        usbdev = priv->usbdev;
         if (!usbdev)
-                return -1;
-        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev,0), 4, 0x40, (((unsigned int)reg) << 8) | val, 0, NULL, 0, 1000);
-        if (ret) {
-                printk(KERN_DEBUG "uss720: set_1284_register(%u,0x%02x) failed, status 0x%x\n", 
-                       (unsigned int)reg, (unsigned int)val, ret);
-        } else {
-#if 0
-                printk(KERN_DEBUG "uss720: set_1284_register(%u,0x%02x)\n", 
-                       (unsigned int)reg, (unsigned int)val);
-#endif
+                return NULL;
+        rq = kmalloc(sizeof(struct uss720_async_request), mem_flags);
+        if (!rq) {
+                err("submit_async_request out of memory");
+                return NULL;
+        }
+        kref_init(&rq->ref_count);
+        INIT_LIST_HEAD(&rq->asynclist);
+        init_completion(&rq->compl);
+        kref_get(&priv->ref_count);
+        rq->priv = priv;
+        rq->urb = usb_alloc_urb(0, mem_flags);
+        if (!rq->urb) {
+                kref_put(&rq->ref_count, destroy_async);
+                err("submit_async_request out of memory");
+                return NULL;
+        }
+        rq->dr.bRequestType = requesttype;
+        rq->dr.bRequest = request;
+        rq->dr.wValue = cpu_to_le16(value);
+        rq->dr.wIndex = cpu_to_le16(index);
+        rq->dr.wLength = cpu_to_le16((request == 3) ? sizeof(rq->reg) : 0);
+        usb_fill_control_urb(rq->urb, usbdev, (requesttype & 0x80) ? usb_rcvctrlpipe(usbdev, 0) : usb_sndctrlpipe(usbdev, 0),
+                             (unsigned char *)&rq->dr,
+                             (request == 3) ? rq->reg : NULL, (request == 3) ? sizeof(rq->reg) : 0, async_complete, rq);
+        /* rq->urb->transfer_flags |= URB_ASYNC_UNLINK; */
+        spin_lock_irqsave(&priv->asynclock, flags);
+        list_add_tail(&rq->asynclist, &priv->asynclist);
+        spin_unlock_irqrestore(&priv->asynclock, flags);
+        ret = usb_submit_urb(rq->urb, mem_flags);
+        if (!ret) {
+                kref_get(&rq->ref_count);
+                return rq;
         }
+        kref_put(&rq->ref_count, destroy_async);
+        err("submit_async_request submit_urb failed with %d", ret);
+        return NULL;
+}
+
+static unsigned int kill_all_async_requests_priv(struct parport_uss720_private *priv)
+{
+        struct uss720_async_request *rq;
+        unsigned long flags;
+        unsigned int ret = 0;
+
+        spin_lock_irqsave(&priv->asynclock, flags);
+        list_for_each_entry(rq, &priv->asynclist, asynclist) {
+                usb_unlink_urb(rq->urb);
+                ret++;
+        }
+        spin_unlock_irqrestore(&priv->asynclock, flags);
         return ret;
 }
 
 /* --------------------------------------------------------------------- */
 
+static int get_1284_register(struct parport *pp, unsigned char reg, unsigned char *val, unsigned int mem_flags)
+{
+        struct parport_uss720_private *priv;
+        struct uss720_async_request *rq;
+        static const unsigned char regindex[9] = {
+                4, 0, 1, 5, 5, 0, 2, 3, 6
+        };
+        int ret;
+
+        if (!pp)
+                return -EIO;
+        priv = pp->private_data;
+        rq = submit_async_request(priv, 3, 0xc0, ((unsigned int)reg) << 8, 0, mem_flags);
+        if (!rq) {
+                err("get_1284_register(%u) failed", (unsigned int)reg);
+                return -EIO;
+        }
+        if (!val) {
+                kref_put(&rq->ref_count, destroy_async);
+                return 0;
+        }
+        if (wait_for_completion_timeout(&rq->compl, HZ)) {
+                ret = rq->urb->status;
+                *val = priv->reg[(reg >= 9) ? 0 : regindex[reg]];
+                if (ret)
+                        warn("get_1284_register: usb error %d", ret);
+                kref_put(&rq->ref_count, destroy_async);
+                return ret;
+        }
+        warn("get_1284_register timeout");
+        kill_all_async_requests_priv(priv);
+        return -EIO;
+}
+
+static int set_1284_register(struct parport *pp, unsigned char reg, unsigned char val, unsigned int mem_flags)
+{
+        struct parport_uss720_private *priv;
+        struct uss720_async_request *rq;
+
+        if (!pp)
+                return -EIO;
+        priv = pp->private_data;
+        rq = submit_async_request(priv, 4, 0x40, (((unsigned int)reg) << 8) | val, 0, mem_flags);
+        if (!rq) {
+                err("set_1284_register(%u,%u) failed", (unsigned int)reg, (unsigned int)val);
+                return -EIO;
+        }
+        kref_put(&rq->ref_count, destroy_async);
+        return 0;
+}
+
+/* --------------------------------------------------------------------- */
+
 /* ECR modes */
 #define ECR_SPP 00
 #define ECR_PS2 01
@@ -132,8 +269,9 @@ static int change_mode(struct parport *pp, int m)
 {
         struct parport_uss720_private *priv = pp->private_data;
         int mode;
+        __u8 reg;
 
-        if (get_1284_register(pp, 6, NULL))
+        if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
                 return -EIO;
         /* Bits <7:5> contain the mode. */
         mode = (priv->reg[2] >> 5) & 0x7;
@@ -153,7 +291,7 @@ static int change_mode(struct parport *pp, int m)
                 case ECR_ECP: /* ECP Parallel Port mode */
                         /* Poll slowly. */
                         for (;;) {
-                                if (get_1284_register(pp, 6, NULL))
+                                if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
                                         return -EIO;
                                 if (priv->reg[2] & 0x01)
                                         break;
@@ -167,7 +305,9 @@ static int change_mode(struct parport *pp, int m)
                 }
         }
         /* Set the mode. */
-        if (set_1284_register(pp, 6, m << 5))
+        if (set_1284_register(pp, 6, m << 5, GFP_KERNEL))
+                return -EIO;
+        if (get_1284_register(pp, 6, &reg, GFP_KERNEL))
                 return -EIO;
         return 0;
 }
@@ -179,7 +319,7 @@ static int clear_epp_timeout(struct parport *pp)
 {
         unsigned char stat;
 
-        if (get_1284_register(pp, 1, &stat))
+        if (get_1284_register(pp, 1, &stat, GFP_KERNEL))
                 return 1;
         return stat & 1;
 }
@@ -205,14 +345,14 @@ static int uss720_irq(int usbstatus, void *buffer, int len, void *dev_id)
 
 static void parport_uss720_write_data(struct parport *pp, unsigned char d)
 {
-        set_1284_register(pp, 0, d);
+        set_1284_register(pp, 0, d, GFP_KERNEL);
 }
 
 static unsigned char parport_uss720_read_data(struct parport *pp)
 {
         unsigned char ret;
 
-        if (get_1284_register(pp, 0, &ret))
+        if (get_1284_register(pp, 0, &ret, GFP_KERNEL))
                 return 0;
         return ret;
 }
@@ -222,7 +362,7 @@ static void parport_uss720_write_control(struct parport *pp, unsigned char d)
         struct parport_uss720_private *priv = pp->private_data; 
 
         d = (d & 0xf) | (priv->reg[1] & 0xf0);
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return;
         priv->reg[1] = d;
 }
@@ -241,7 +381,7 @@ static unsigned char parport_uss720_frob_control(struct parport *pp, unsigned ch
         mask &= 0x0f;
         val &= 0x0f;
         d = (priv->reg[1] & (~mask)) ^ val;
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return 0;
         priv->reg[1] = d;
         return d & 0xf;
@@ -251,7 +391,7 @@ static unsigned char parport_uss720_read_status(struct parport *pp)
 {
         unsigned char ret;
 
-        if (get_1284_register(pp, 1, &ret))
+        if (get_1284_register(pp, 1, &ret, GFP_KERNEL))
                 return 0;
         return ret & 0xf8;
 }
@@ -262,7 +402,7 @@ static void parport_uss720_disable_irq(struct parport *pp)
         unsigned char d;
 
         d = priv->reg[1] & ~0x10;
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return;
         priv->reg[1] = d;
 }
@@ -273,7 +413,7 @@ static void parport_uss720_enable_irq(struct parport *pp)
         unsigned char d;
 
         d = priv->reg[1] | 0x10;
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return;
         priv->reg[1] = d;
 }
@@ -284,7 +424,7 @@ static void parport_uss720_data_forward (struct parport *pp)
         unsigned char d;
 
         d = priv->reg[1] & ~0x20;
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return;
         priv->reg[1] = d;
 }
@@ -295,7 +435,7 @@ static void parport_uss720_data_reverse (struct parport *pp)
         unsigned char d;
 
         d = priv->reg[1] | 0x20;
-        if (set_1284_register(pp, 2, d))
+        if (set_1284_register(pp, 2, d, GFP_KERNEL))
                 return;
         priv->reg[1] = d;
 }
@@ -310,17 +450,23 @@ static void parport_uss720_save_state(struct parport *pp, struct parport_state *
 {
         struct parport_uss720_private *priv = pp->private_data; 
 
-        if (get_1284_register(pp, 2, NULL))
+#if 0
+        if (get_1284_register(pp, 2, NULL, GFP_ATOMIC))
                 return;
+#endif
         s->u.pc.ctr = priv->reg[1];
         s->u.pc.ecr = priv->reg[2];
 }
 
 static void parport_uss720_restore_state(struct parport *pp, struct parport_state *s)
 {
-        set_1284_register(pp, 2, s->u.pc.ctr);
-        set_1284_register(pp, 6, s->u.pc.ecr);
-        get_1284_register(pp, 2, NULL);
+        struct parport_uss720_private *priv = pp->private_data;
+
+        set_1284_register(pp, 2, s->u.pc.ctr, GFP_ATOMIC);
+        set_1284_register(pp, 6, s->u.pc.ecr, GFP_ATOMIC);
+        get_1284_register(pp, 2, NULL, GFP_ATOMIC);
+        priv->reg[1] = s->u.pc.ctr;
+        priv->reg[2] = s->u.pc.ecr;
 }
 
 static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t length, int flags)
@@ -331,7 +477,7 @@ static size_t parport_uss720_epp_read_data(struct parport *pp, void *buf, size_t
         if (change_mode(pp, ECR_EPP))
                 return 0;
         for (; got < length; got++) {
-                if (get_1284_register(pp, 4, (char *)buf))
+                if (get_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
                         break;
                 buf++;
                 if (priv->reg[0] & 0x01) {
@@ -352,10 +498,10 @@ static size_t parport_uss720_epp_write_data(struct parport *pp, const void *buf,
         if (change_mode(pp, ECR_EPP))
                 return 0;
         for (; written < length; written++) {
-                if (set_1284_register(pp, 4, (char *)buf))
+                if (set_1284_register(pp, 4, (char *)buf, GFP_KERNEL))
                         break;
                 ((char*)buf)++;
-                if (get_1284_register(pp, 1, NULL))
+                if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
                         break;
                 if (priv->reg[0] & 0x01) {
                         clear_epp_timeout(pp);
@@ -390,7 +536,7 @@ static size_t parport_uss720_epp_read_addr(struct parport *pp, void *buf, size_t
         if (change_mode(pp, ECR_EPP))
                 return 0;
         for (; got < length; got++) {
-                if (get_1284_register(pp, 3, (char *)buf))
+                if (get_1284_register(pp, 3, (char *)buf, GFP_KERNEL))
                         break;
                 buf++;
                 if (priv->reg[0] & 0x01) {
@@ -410,10 +556,10 @@ static size_t parport_uss720_epp_write_addr(struct parport *pp, const void *buf,
         if (change_mode(pp, ECR_EPP))
                 return 0;
         for (; written < length; written++) {
-                if (set_1284_register(pp, 3, *(char *)buf))
+                if (set_1284_register(pp, 3, *(char *)buf, GFP_KERNEL))
                         break;
                 buf++;
-                if (get_1284_register(pp, 1, NULL))
+                if (get_1284_register(pp, 1, NULL, GFP_KERNEL))
                         break;
                 if (priv->reg[0] & 0x01) {
                         clear_epp_timeout(pp);
@@ -467,7 +613,7 @@ static size_t parport_uss720_ecp_write_addr(struct parport *pp, const void *buff
         if (change_mode(pp, ECR_ECP))
                 return 0;
         for (; written < len; written++) {
-                if (set_1284_register(pp, 5, *(char *)buffer))
+                if (set_1284_register(pp, 5, *(char *)buffer, GFP_KERNEL))
                         break;
                 buffer++;
         }
@@ -536,93 +682,91 @@ static struct parport_operations parport_uss720_ops =
 static int uss720_probe(struct usb_interface *intf,
                         const struct usb_device_id *id)
 {
-        struct usb_device *usbdev = interface_to_usbdev(intf);
+        struct usb_device *usbdev = usb_get_dev(interface_to_usbdev(intf));
         struct usb_host_interface *interface;
         struct usb_host_endpoint *endpoint;
         struct parport_uss720_private *priv;
         struct parport *pp;
+        unsigned char reg;
         int i;
 
-        printk(KERN_DEBUG "uss720: probe: vendor id 0x%x, device id 0x%x\n",
-               le16_to_cpu(usbdev->descriptor.idVendor),
-               le16_to_cpu(usbdev->descriptor.idProduct));
+        dbg("probe: vendor id 0x%x, device id 0x%x\n",
+            le16_to_cpu(usbdev->descriptor.idVendor),
+            le16_to_cpu(usbdev->descriptor.idProduct));
 
         /* our known interfaces have 3 alternate settings */
-        if (intf->num_altsetting != 3)
+        if (intf->num_altsetting != 3) {
+                usb_put_dev(usbdev);
                 return -ENODEV;
-
+        }
         i = usb_set_interface(usbdev, intf->altsetting->desc.bInterfaceNumber, 2);
-        printk(KERN_DEBUG "uss720: set inteface result %d\n", i);
+        dbg("set inteface result %d", i);
 
         interface = intf->cur_altsetting;
 
         /*
          * Allocate parport interface 
          */
-        printk(KERN_INFO "uss720: (C) 1999 by Thomas Sailer, <sailer@ife.ee.ethz.ch>\n");
-
-        if (!(priv = kmalloc(sizeof(struct parport_uss720_private), GFP_KERNEL)))
+        if (!(priv = kcalloc(sizeof(struct parport_uss720_private), 1, GFP_KERNEL))) {
+                usb_put_dev(usbdev);
                 return -ENOMEM;
+        }
+        priv->pp = NULL;
+        priv->usbdev = usbdev;
+        kref_init(&priv->ref_count);
+        spin_lock_init(&priv->asynclock);
+        INIT_LIST_HEAD(&priv->asynclist);
         if (!(pp = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, &parport_uss720_ops))) {
-                printk(KERN_WARNING "usb-uss720: could not register parport\n");
+                warn("could not register parport");
                 goto probe_abort;
         }
 
+        priv->pp = pp;
         pp->private_data = priv;
-        priv->usbdev = usbdev;
         pp->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_TRISTATE | PARPORT_MODE_EPP | PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
 
         /* set the USS720 control register to manual mode, no ECP compression, enable all ints */
-        set_1284_register(pp, 7, 0x00);
-        set_1284_register(pp, 6, 0x30);  /* PS/2 mode */
-        set_1284_register(pp, 2, 0x0c);
+        set_1284_register(pp, 7, 0x00, GFP_KERNEL);
+        set_1284_register(pp, 6, 0x30, GFP_KERNEL);  /* PS/2 mode */
+        set_1284_register(pp, 2, 0x0c, GFP_KERNEL);
         /* debugging */
-        get_1284_register(pp, 0, NULL);
-        printk("uss720: reg: %02x %02x %02x %02x %02x %02x %02x\n",
-               priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
+        get_1284_register(pp, 0, &reg, GFP_KERNEL);
+        dbg("reg: %02x %02x %02x %02x %02x %02x %02x",
+            priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3], priv->reg[4], priv->reg[5], priv->reg[6]);
 
         endpoint = &interface->endpoint[2];
-        printk(KERN_DEBUG "uss720: epaddr %d interval %d\n", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
-#if 0
-        priv->irqpipe = usb_rcvctrlpipe(usbdev, endpoint->bEndpointAddress);
-        i = usb_request_irq(usbdev, priv->irqpipe,
-                                  uss720_irq, endpoint->bInterval,
-                                  pp, &priv->irqhandle);
-        if (i) {
-                printk (KERN_WARNING "usb-uss720: usb_request_irq failed (0x%x)\n", i);
-                goto probe_abort_port;
-        }
-#endif
+        dbg("epaddr %d interval %d", endpoint->desc.bEndpointAddress, endpoint->desc.bInterval);
         parport_announce_port(pp);
 
-        usb_set_intfdata (intf, pp);
+        usb_set_intfdata(intf, pp);
         return 0;
 
-#if 0
-probe_abort_port:
-        parport_put_port(pp);
-#endif
 probe_abort:
-        kfree(priv);
+        kill_all_async_requests_priv(priv);
+        kref_put(&priv->ref_count, destroy_priv);
         return -ENODEV;
 }
 
 static void uss720_disconnect(struct usb_interface *intf)
 {
-        struct parport *pp = usb_get_intfdata (intf);
+        struct parport *pp = usb_get_intfdata(intf);
         struct parport_uss720_private *priv;
+        struct usb_device *usbdev;
 
-        usb_set_intfdata (intf, NULL);
+        dbg("disconnect");
+        usb_set_intfdata(intf, NULL);
         if (pp) {
                 priv = pp->private_data;
-                parport_remove_port(pp);
-#if 0
-                usb_release_irq(usbdev, priv->irqhandle, priv->irqpipe);
-#endif
+                usbdev = priv->usbdev;
                 priv->usbdev = NULL;
+                priv->pp = NULL;
+                dbg("parport_remove_port");
+                parport_remove_port(pp);
                 parport_put_port(pp);
-                kfree(priv);
+                kill_all_async_requests_priv(priv);
+                kref_put(&priv->ref_count, destroy_priv);
         }
+        dbg("disconnect done");
 }
 
 /* table of cables that work through this driver */
@@ -647,8 +791,8 @@ static struct usb_driver uss720_driver = {
 
 /* --------------------------------------------------------------------- */
 
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 static int __init uss720_init(void)
@@ -659,6 +803,9 @@ static int __init uss720_init(void)
                 goto out;
 
         info(DRIVER_VERSION ":" DRIVER_DESC);
+        info("NOTE: this is a special purpose driver to allow nonstandard");
+        info("protocols (eg. bitbang) over USS720 usb to parallel cables");
+        info("If you just want to connect to a printer, use usblp instead");
 out:
         return retval;
 }
diff --git a/drivers/usb/mon/Makefile b/drivers/usb/mon/Makefile
index b0015b8a1d1f..3cf3ea3a88ed 100644
--- a/drivers/usb/mon/Makefile
+++ b/drivers/usb/mon/Makefile
@@ -2,7 +2,7 @@
 # Makefile for USB Core files and filesystem
 #
 
-usbmon-objs     := mon_main.o mon_stat.o mon_text.o
+usbmon-objs     := mon_main.o mon_stat.o mon_text.o mon_dma.o
 
 # This does not use CONFIG_USB_MON because we want this to use a tristate.
 obj-$(CONFIG_USB)       += usbmon.o
diff --git a/drivers/usb/mon/mon_dma.c b/drivers/usb/mon/mon_dma.c
new file mode 100644
index 000000000000..0a1367b760a0
--- /dev/null
+++ b/drivers/usb/mon/mon_dma.c
@@ -0,0 +1,55 @@
+/*
+ * The USB Monitor, inspired by Dave Harding's USBMon.
+ *
+ * mon_dma.c: Library which snoops on DMA areas.
+ *
+ * Copyright (C) 2005 Pete Zaitcev (zaitcev@redhat.com)
+ */
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/highmem.h>
+#include <asm/page.h>
+
+#include <linux/usb.h>  /* Only needed for declarations in usb_mon.h */
+#include "usb_mon.h"
+
+#ifdef __i386__         /* CONFIG_ARCH_I386 does not exit */
+#define MON_HAS_UNMAP 1
+
+#define phys_to_page(phys)      pfn_to_page((phys) >> PAGE_SHIFT)
+
+char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len)
+{
+        struct page *pg;
+        unsigned long flags;
+        unsigned char *map;
+        unsigned char *ptr;
+
+        /*
+         * On i386, a DMA handle is the "physical" address of a page.
+         * In other words, the bus address is equal to physical address.
+         * There is no IOMMU.
+         */
+        pg = phys_to_page(dma_addr);
+
+        /*
+         * We are called from hardware IRQs in case of callbacks.
+         * But we can be called from softirq or process context in case
+         * of submissions. In such case, we need to protect KM_IRQ0.
+         */
+        local_irq_save(flags);
+        map = kmap_atomic(pg, KM_IRQ0);
+        ptr = map + (dma_addr & (PAGE_SIZE-1));
+        memcpy(dst, ptr, len);
+        kunmap_atomic(map, KM_IRQ0);
+        local_irq_restore(flags);
+        return 0;
+}
+#endif /* __i386__ */
+
+#ifndef MON_HAS_UNMAP
+char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len)
+{
+        return 'D';
+}
+#endif
diff --git a/drivers/usb/mon/mon_text.c b/drivers/usb/mon/mon_text.c
index 26266b30028e..17d0190ef64e 100644
--- a/drivers/usb/mon/mon_text.c
+++ b/drivers/usb/mon/mon_text.c
@@ -79,7 +79,7 @@ static inline char mon_text_get_setup(struct mon_event_text *ep,
                 return '-';
 
         if (urb->transfer_flags & URB_NO_SETUP_DMA_MAP)
-                return 'D';
+                return mon_dmapeek(ep->setup, urb->setup_dma, SETUP_MAX);
         if (urb->setup_packet == NULL)
                 return 'Z';     /* '0' would be not as pretty. */
 
@@ -91,25 +91,11 @@ static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
     int len, char ev_type)
 {
         int pipe = urb->pipe;
-        unsigned char *data;
-
-        /*
-         * The check to see if it's safe to poke at data has an enormous
-         * number of corner cases, but it seems that the following is
-         * more or less safe.
-         *
-         * We do not even try to look transfer_buffer, because it can
-         * contain non-NULL garbage in case the upper level promised to
-         * set DMA for the HCD.
-         */
-        if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
-                return 'D';
 
         if (len <= 0)
                 return 'L';
-
-        if ((data = urb->transfer_buffer) == NULL)
-                return 'Z';     /* '0' would be not as pretty. */
+        if (len >= DATA_MAX)
+                len = DATA_MAX;
 
         /*
          * Bulk is easy to shortcut reliably. 
@@ -126,8 +112,21 @@ static inline char mon_text_get_data(struct mon_event_text *ep, struct urb *urb,
                 }
         }
 
-        if (len >= DATA_MAX)
-                len = DATA_MAX;
+        /*
+         * The check to see if it's safe to poke at data has an enormous
+         * number of corner cases, but it seems that the following is
+         * more or less safe.
+         *
+         * We do not even try to look transfer_buffer, because it can
+         * contain non-NULL garbage in case the upper level promised to
+         * set DMA for the HCD.
+         */
+        if (urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
+                return mon_dmapeek(ep->data, urb->transfer_dma, len);
+
+        if (urb->transfer_buffer == NULL)
+                return 'Z';     /* '0' would be not as pretty. */
+
         memcpy(ep->data, urb->transfer_buffer, len);
         return 0;
 }
diff --git a/drivers/usb/mon/usb_mon.h b/drivers/usb/mon/usb_mon.h
index 9b06784d2c48..4be0f9346071 100644
--- a/drivers/usb/mon/usb_mon.h
+++ b/drivers/usb/mon/usb_mon.h
@@ -45,6 +45,10 @@ struct mon_reader {
 void mon_reader_add(struct mon_bus *mbus, struct mon_reader *r);
 void mon_reader_del(struct mon_bus *mbus, struct mon_reader *r);
 
+/*
+ */
+extern char mon_dmapeek(unsigned char *dst, dma_addr_t dma_addr, int len);
+
 extern struct semaphore mon_lock;
 
 extern struct file_operations mon_fops_text;
diff --git a/drivers/usb/net/Kconfig b/drivers/usb/net/Kconfig
index b104430e2c6a..8c010bb44eb8 100644
--- a/drivers/usb/net/Kconfig
+++ b/drivers/usb/net/Kconfig
@@ -99,7 +99,7 @@ config USB_USBNET
           with "minidrivers" built around a common network driver core
           that supports deep queues for efficient transfers.  (This gives
           better performance with small packets and at high speeds).
-          
+
           The USB host runs "usbnet", and the other end of the link might be:
 
           - Another USB host, when using USB "network" or "data transfer"
@@ -125,38 +125,63 @@ config USB_USBNET
           To compile this driver as a module, choose M here: the
           module will be called usbnet.
 
-comment "USB Host-to-Host Cables"
-        depends on USB_USBNET
-
-config USB_ALI_M5632
-        boolean "ALi M5632 based 'USB 2.0 Data Link' cables"
-        depends on USB_USBNET
+config USB_NET_AX8817X
+        tristate "ASIX AX88xxx Based USB 2.0 Ethernet Adapters"
+        depends on USB_USBNET && NET_ETHERNET
+        select CRC32
+        select MII
         default y
         help
-          Choose this option if you're using a host-to-host cable
-          based on this design, which supports USB 2.0 high speed.
+          This option adds support for ASIX AX88xxx based USB 2.0
+          10/100 Ethernet adapters.
 
-config USB_AN2720
-        boolean "AnchorChips 2720 based cables (Xircom PGUNET, ...)"
-        depends on USB_USBNET
-        default y
-        help
-          Choose this option if you're using a host-to-host cable
-          based on this design.  Note that AnchorChips is now a
-          Cypress brand.
+          This driver should work with at least the following devices:
+            * Aten UC210T
+            * ASIX AX88172
+            * Billionton Systems, USB2AR
+            * Buffalo LUA-U2-KTX
+            * Corega FEther USB2-TX
+            * D-Link DUB-E100
+            * Hawking UF200
+            * Linksys USB200M
+            * Netgear FA120
+            * Sitecom LN-029
+            * Intellinet USB 2.0 Ethernet
+            * ST Lab USB 2.0 Ethernet
+            * TrendNet TU2-ET100
 
-config USB_BELKIN
-        boolean "eTEK based host-to-host cables (Advance, Belkin, ...)"
+          This driver creates an interface named "ethX", where X depends on
+          what other networking devices you have in use.
+
+
+config USB_NET_CDCETHER
+        tristate "CDC Ethernet support (smart devices such as cable modems)"
         depends on USB_USBNET
         default y
         help
-          Choose this option if you're using a host-to-host cable
-          based on this design:  two NetChip 2890 chips and an Atmel
-          microcontroller, with LEDs that indicate traffic.
+          This option supports devices conforming to the Communication Device
+          Class (CDC) Ethernet Control Model, a specification that's easy to
+          implement in device firmware.  The CDC specifications are available
+          from <http://www.usb.org/>.
 
-config USB_GENESYS
-        boolean "GeneSys GL620USB-A based cables"
-        default y
+          CDC Ethernet is an implementation option for DOCSIS cable modems
+          that support USB connectivity, used for non-Microsoft USB hosts.
+          The Linux-USB CDC Ethernet Gadget driver is an open implementation.
+          This driver should work with at least the following devices:
+
+            * Ericsson PipeRider (all variants)
+            * Motorola (DM100 and SB4100)
+            * Broadcom Cable Modem (reference design)
+            * Toshiba PCX1100U
+            * ...
+
+          This driver creates an interface named "ethX", where X depends on
+          what other networking devices you have in use.  However, if the
+          IEEE 802 "local assignment" bit is set in the address, a "usbX"
+          name is used instead.
+
+config USB_NET_GL620A
+        tristate "GeneSys GL620USB-A based cables"
         depends on USB_USBNET
         help
           Choose this option if you're using a host-to-host cable,
@@ -164,38 +189,78 @@ config USB_GENESYS
 
           Note that the half-duplex "GL620USB" is not supported.
 
-config USB_NET1080
-        boolean "NetChip 1080 based cables (Laplink, ...)"
+config USB_NET_NET1080
+        tristate "NetChip 1080 based cables (Laplink, ...)"
         default y
         depends on USB_USBNET
         help
           Choose this option if you're using a host-to-host cable based
-          on this design:  one NetChip 1080 chips and supporting logic,
-          supporting LEDs that indicate traffic
+          on this design:  one NetChip 1080 chip and supporting logic,
+          optionally with LEDs that indicate traffic
 
-config USB_PL2301
-        boolean "Prolific PL-2301/2302 based cables"
-        default y
-        # handshake/init/reset problems, from original 'plusb' driver
+config USB_NET_PLUSB
+        tristate "Prolific PL-2301/2302 based cables"
+        # if the handshake/init/reset problems, from original 'plusb',
+        # are ever resolved ... then remove "experimental"
         depends on USB_USBNET && EXPERIMENTAL
         help
           Choose this option if you're using a host-to-host cable
           with one of these chips.
 
-config USB_KC2190
-        boolean "KT Technology KC2190 based cables (InstaNet)"
-        default y
+config USB_NET_RNDIS_HOST
+        tristate "Host for RNDIS devices (EXPERIMENTAL)"
         depends on USB_USBNET && EXPERIMENTAL
+        select USB_NET_CDCETHER
         help
-          Choose this option if you're using a host-to-host cable
-          with one of these chips.
+          This option enables hosting "Remote NDIS" USB networking links,
+          as encouraged by Microsoft (instead of CDC Ethernet!) for use in
+          various devices that may only support this protocol.
 
-comment "Intelligent USB Devices/Gadgets"
+          Avoid using this protocol unless you have no better options.
+          The protocol specification is incomplete, and is controlled by
+          (and for) Microsoft; it isn't an "Open" ecosystem or market.
+
+config USB_NET_CDC_SUBSET
+        tristate "Simple USB Network Links (CDC Ethernet subset)"
         depends on USB_USBNET
+        help
+          This driver module supports USB network devices that can work
+          without any device-specific information.  Select it if you have
+          one of these drivers.
+
+          Note that while many USB host-to-host cables can work in this mode,
+          that may mean not being able to talk to Win32 systems or more
+          commonly not being able to handle certain events (like replugging
+          the host on the other end) very well.  Also, these devices will
+          not generally have permanently assigned Ethernet addresses.
+
+config USB_ALI_M5632
+        boolean "ALi M5632 based 'USB 2.0 Data Link' cables"
+        depends on USB_NET_CDC_SUBSET
+        help
+          Choose this option if you're using a host-to-host cable
+          based on this design, which supports USB 2.0 high speed.
+
+config USB_AN2720
+        boolean "AnchorChips 2720 based cables (Xircom PGUNET, ...)"
+        depends on USB_NET_CDC_SUBSET
+        help
+          Choose this option if you're using a host-to-host cable
+          based on this design.  Note that AnchorChips is now a
+          Cypress brand.
+
+config USB_BELKIN
+        boolean "eTEK based host-to-host cables (Advance, Belkin, ...)"
+        depends on USB_NET_CDC_SUBSET
+        default y
+        help
+          Choose this option if you're using a host-to-host cable
+          based on this design:  two NetChip 2890 chips and an Atmel
+          microcontroller, with LEDs that indicate traffic.
 
 config USB_ARMLINUX
         boolean "Embedded ARM Linux links (iPaq, ...)"
-        depends on USB_USBNET
+        depends on USB_NET_CDC_SUBSET
         default y
         help
           Choose this option to support the "usb-eth" networking driver
@@ -212,15 +277,15 @@ config USB_ARMLINUX
 
 config USB_EPSON2888
         boolean "Epson 2888 based firmware (DEVELOPMENT)"
-        depends on USB_USBNET
-        default y
+        depends on USB_NET_CDC_SUBSET
         help
           Choose this option to support the usb networking links used
           by some sample firmware from Epson.
 
-config USB_ZAURUS
-        boolean "Sharp Zaurus (stock ROMs) and compatible"
+config USB_NET_ZAURUS
+        tristate "Sharp Zaurus (stock ROMs) and compatible"
         depends on USB_USBNET
+        select USB_NET_CDCETHER
         select CRC32
         default y
         help
@@ -235,61 +300,6 @@ config USB_ZAURUS
           really need this non-conformant variant of CDC Ethernet (or in
           some cases CDC MDLM) protocol, not "g_ether".
 
-config USB_CDCETHER
-        boolean "CDC Ethernet support (smart devices such as cable modems)"
-        depends on USB_USBNET
-        default y
-        help
-          This option supports devices conforming to the Communication Device
-          Class (CDC) Ethernet Control Model, a specification that's easy to
-          implement in device firmware.  The CDC specifications are available
-          from <http://www.usb.org/>.
-          
-          CDC Ethernet is an implementation option for DOCSIS cable modems
-          that support USB connectivity, used for non-Microsoft USB hosts.
-          This driver should work with at least the following devices:
-
-            * Ericsson PipeRider (all variants)
-            * Motorola (DM100 and SB4100)
-            * Broadcom Cable Modem (reference design)
-            * Toshiba PCX1100U
-            * ...
-
-          This driver creates an interface named "ethX", where X depends on
-          what other networking devices you have in use.  However, if the
-          IEEE 802 "local assignment" bit is set in the address, a "usbX"
-          name is used instead.
-
-comment "USB Network Adapters"
-        depends on USB_USBNET
-
-config USB_AX8817X
-        boolean "ASIX AX88xxx Based USB 2.0 Ethernet Devices"
-        depends on USB_USBNET && NET_ETHERNET
-        select CRC32
-        select MII
-        default y
-        help
-          This option adds support for ASIX AX88xxx based USB 2.0
-          10/100 Ethernet devices.
-
-          This driver should work with at least the following devices:
-            * Aten UC210T
-            * ASIX AX88172
-            * Billionton Systems, USB2AR 
-            * Buffalo LUA-U2-KTX
-            * Corega FEther USB2-TX
-            * D-Link DUB-E100
-            * Hawking UF200
-            * Linksys USB200M
-            * Netgear FA120
-            * Sitecom LN-029
-            * Intellinet USB 2.0 Ethernet
-            * ST Lab USB 2.0 Ethernet
-            * TrendNet TU2-ET100
-
-          This driver creates an interface named "ethX", where X depends on
-          what other networking devices you have in use.  
 
 config USB_ZD1201
         tristate "USB ZD1201 based Wireless device support"
diff --git a/drivers/usb/net/Makefile b/drivers/usb/net/Makefile
index fe3fd4115e1e..222c0495f791 100644
--- a/drivers/usb/net/Makefile
+++ b/drivers/usb/net/Makefile
@@ -6,5 +6,13 @@ obj-$(CONFIG_USB_CATC)		+= catc.o
 obj-$(CONFIG_USB_KAWETH)        += kaweth.o
 obj-$(CONFIG_USB_PEGASUS)       += pegasus.o
 obj-$(CONFIG_USB_RTL8150)       += rtl8150.o
+obj-$(CONFIG_USB_NET_AX8817X)   += asix.o
+obj-$(CONFIG_USB_NET_CDCETHER)  += cdc_ether.o
+obj-$(CONFIG_USB_NET_GL620A)    += gl620a.o
+obj-$(CONFIG_USB_NET_NET1080)   += net1080.o
+obj-$(CONFIG_USB_NET_PLUSB)     += plusb.o
+obj-$(CONFIG_USB_NET_RNDIS_HOST)        += rndis_host.o
+obj-$(CONFIG_USB_NET_CDC_SUBSET)        += cdc_subset.o
+obj-$(CONFIG_USB_NET_ZAURUS)    += zaurus.o
 obj-$(CONFIG_USB_USBNET)        += usbnet.o
 obj-$(CONFIG_USB_ZD1201)        += zd1201.o
diff --git a/drivers/usb/net/asix.c b/drivers/usb/net/asix.c
new file mode 100644
index 000000000000..861f00a43750
--- /dev/null
+++ b/drivers/usb/net/asix.c
@@ -0,0 +1,948 @@
+/*
+ * ASIX AX8817X based USB 2.0 Ethernet Devices
+ * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
+ * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
+ * Copyright (c) 2002-2003 TiVo Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/kmod.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/crc32.h>
+
+#include "usbnet.h"
+
+
+/* ASIX AX8817X based USB 2.0 Ethernet Devices */
+
+#define AX_CMD_SET_SW_MII               0x06
+#define AX_CMD_READ_MII_REG             0x07
+#define AX_CMD_WRITE_MII_REG            0x08
+#define AX_CMD_SET_HW_MII               0x0a
+#define AX_CMD_READ_EEPROM              0x0b
+#define AX_CMD_WRITE_EEPROM             0x0c
+#define AX_CMD_WRITE_ENABLE             0x0d
+#define AX_CMD_WRITE_DISABLE            0x0e
+#define AX_CMD_WRITE_RX_CTL             0x10
+#define AX_CMD_READ_IPG012              0x11
+#define AX_CMD_WRITE_IPG0               0x12
+#define AX_CMD_WRITE_IPG1               0x13
+#define AX_CMD_WRITE_IPG2               0x14
+#define AX_CMD_WRITE_MULTI_FILTER       0x16
+#define AX_CMD_READ_NODE_ID             0x17
+#define AX_CMD_READ_PHY_ID              0x19
+#define AX_CMD_READ_MEDIUM_STATUS       0x1a
+#define AX_CMD_WRITE_MEDIUM_MODE        0x1b
+#define AX_CMD_READ_MONITOR_MODE        0x1c
+#define AX_CMD_WRITE_MONITOR_MODE       0x1d
+#define AX_CMD_WRITE_GPIOS              0x1f
+#define AX_CMD_SW_RESET                 0x20
+#define AX_CMD_SW_PHY_STATUS            0x21
+#define AX_CMD_SW_PHY_SELECT            0x22
+#define AX88772_CMD_READ_NODE_ID        0x13
+
+#define AX_MONITOR_MODE                 0x01
+#define AX_MONITOR_LINK                 0x02
+#define AX_MONITOR_MAGIC                0x04
+#define AX_MONITOR_HSFS                 0x10
+
+/* AX88172 Medium Status Register values */
+#define AX_MEDIUM_FULL_DUPLEX           0x02
+#define AX_MEDIUM_TX_ABORT_ALLOW        0x04
+#define AX_MEDIUM_FLOW_CONTROL_EN       0x10
+
+#define AX_MCAST_FILTER_SIZE            8
+#define AX_MAX_MCAST                    64
+
+#define AX_EEPROM_LEN                   0x40
+
+#define AX_SWRESET_CLEAR                0x00
+#define AX_SWRESET_RR                   0x01
+#define AX_SWRESET_RT                   0x02
+#define AX_SWRESET_PRTE                 0x04
+#define AX_SWRESET_PRL                  0x08
+#define AX_SWRESET_BZ                   0x10
+#define AX_SWRESET_IPRL                 0x20
+#define AX_SWRESET_IPPD                 0x40
+
+#define AX88772_IPG0_DEFAULT            0x15
+#define AX88772_IPG1_DEFAULT            0x0c
+#define AX88772_IPG2_DEFAULT            0x12
+
+#define AX88772_MEDIUM_FULL_DUPLEX      0x0002
+#define AX88772_MEDIUM_RESERVED         0x0004
+#define AX88772_MEDIUM_RX_FC_ENABLE     0x0010
+#define AX88772_MEDIUM_TX_FC_ENABLE     0x0020
+#define AX88772_MEDIUM_PAUSE_FORMAT     0x0080
+#define AX88772_MEDIUM_RX_ENABLE        0x0100
+#define AX88772_MEDIUM_100MB            0x0200
+#define AX88772_MEDIUM_DEFAULT  \
+        (AX88772_MEDIUM_FULL_DUPLEX | AX88772_MEDIUM_RX_FC_ENABLE | \
+         AX88772_MEDIUM_TX_FC_ENABLE | AX88772_MEDIUM_100MB | \
+         AX88772_MEDIUM_RESERVED | AX88772_MEDIUM_RX_ENABLE )
+
+#define AX_EEPROM_MAGIC                 0xdeadbeef
+
+/* This structure cannot exceed sizeof(unsigned long [5]) AKA 20 bytes */
+struct ax8817x_data {
+        u8 multi_filter[AX_MCAST_FILTER_SIZE];
+};
+
+struct ax88172_int_data {
+        u16 res1;
+        u8 link;
+        u16 res2;
+        u8 status;
+        u16 res3;
+} __attribute__ ((packed));
+
+static int ax8817x_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
+                            u16 size, void *data)
+{
+        return usb_control_msg(
+                dev->udev,
+                usb_rcvctrlpipe(dev->udev, 0),
+                cmd,
+                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                value,
+                index,
+                data,
+                size,
+                USB_CTRL_GET_TIMEOUT);
+}
+
+static int ax8817x_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
+                             u16 size, void *data)
+{
+        return usb_control_msg(
+                dev->udev,
+                usb_sndctrlpipe(dev->udev, 0),
+                cmd,
+                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                value,
+                index,
+                data,
+                size,
+                USB_CTRL_SET_TIMEOUT);
+}
+
+static void ax8817x_async_cmd_callback(struct urb *urb, struct pt_regs *regs)
+{
+        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
+
+        if (urb->status < 0)
+                printk(KERN_DEBUG "ax8817x_async_cmd_callback() failed with %d",
+                        urb->status);
+
+        kfree(req);
+        usb_free_urb(urb);
+}
+
+static void ax8817x_status(struct usbnet *dev, struct urb *urb)
+{
+        struct ax88172_int_data *event;
+        int link;
+
+        if (urb->actual_length < 8)
+                return;
+
+        event = urb->transfer_buffer;
+        link = event->link & 0x01;
+        if (netif_carrier_ok(dev->net) != link) {
+                if (link) {
+                        netif_carrier_on(dev->net);
+                        usbnet_defer_kevent (dev, EVENT_LINK_RESET );
+                } else
+                        netif_carrier_off(dev->net);
+                devdbg(dev, "ax8817x - Link Status is: %d", link);
+        }
+}
+
+static void
+ax8817x_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
+                                    u16 size, void *data)
+{
+        struct usb_ctrlrequest *req;
+        int status;
+        struct urb *urb;
+
+        if ((urb = usb_alloc_urb(0, GFP_ATOMIC)) == NULL) {
+                devdbg(dev, "Error allocating URB in write_cmd_async!");
+                return;
+        }
+
+        if ((req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC)) == NULL) {
+                deverr(dev, "Failed to allocate memory for control request");
+                usb_free_urb(urb);
+                return;
+        }
+
+        req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
+        req->bRequest = cmd;
+        req->wValue = cpu_to_le16(value);
+        req->wIndex = cpu_to_le16(index);
+        req->wLength = cpu_to_le16(size);
+
+        usb_fill_control_urb(urb, dev->udev,
+                             usb_sndctrlpipe(dev->udev, 0),
+                             (void *)req, data, size,
+                             ax8817x_async_cmd_callback, req);
+
+        if((status = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
+                deverr(dev, "Error submitting the control message: status=%d",
+                                status);
+                kfree(req);
+                usb_free_urb(urb);
+        }
+}
+
+static void ax8817x_set_multicast(struct net_device *net)
+{
+        struct usbnet *dev = netdev_priv(net);
+        struct ax8817x_data *data = (struct ax8817x_data *)&dev->data;
+        u8 rx_ctl = 0x8c;
+
+        if (net->flags & IFF_PROMISC) {
+                rx_ctl |= 0x01;
+        } else if (net->flags & IFF_ALLMULTI
+                   || net->mc_count > AX_MAX_MCAST) {
+                rx_ctl |= 0x02;
+        } else if (net->mc_count == 0) {
+                /* just broadcast and directed */
+        } else {
+                /* We use the 20 byte dev->data
+                 * for our 8 byte filter buffer
+                 * to avoid allocating memory that
+                 * is tricky to free later */
+                struct dev_mc_list *mc_list = net->mc_list;
+                u32 crc_bits;
+                int i;
+
+                memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
+
+                /* Build the multicast hash filter. */
+                for (i = 0; i < net->mc_count; i++) {
+                        crc_bits =
+                            ether_crc(ETH_ALEN,
+                                      mc_list->dmi_addr) >> 26;
+                        data->multi_filter[crc_bits >> 3] |=
+                            1 << (crc_bits & 7);
+                        mc_list = mc_list->next;
+                }
+
+                ax8817x_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
+                                   AX_MCAST_FILTER_SIZE, data->multi_filter);
+
+                rx_ctl |= 0x10;
+        }
+
+        ax8817x_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
+}
+
+static int ax8817x_mdio_read(struct net_device *netdev, int phy_id, int loc)
+{
+        struct usbnet *dev = netdev_priv(netdev);
+        u16 res;
+        u8 buf[1];
+
+        ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII, 0, 0, 0, &buf);
+        ax8817x_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id,
+                                (__u16)loc, 2, (u16 *)&res);
+        ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf);
+
+        return res & 0xffff;
+}
+
+/* same as above, but converts resulting value to cpu byte order */
+static int ax8817x_mdio_read_le(struct net_device *netdev, int phy_id, int loc)
+{
+        return le16_to_cpu(ax8817x_mdio_read(netdev,phy_id, loc));
+}
+
+static void
+ax8817x_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
+{
+        struct usbnet *dev = netdev_priv(netdev);
+        u16 res = val;
+        u8 buf[1];
+
+        ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII, 0, 0, 0, &buf);
+        ax8817x_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id,
+                                (__u16)loc, 2, (u16 *)&res);
+        ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf);
+}
+
+/* same as above, but converts new value to le16 byte order before writing */
+static void
+ax8817x_mdio_write_le(struct net_device *netdev, int phy_id, int loc, int val)
+{
+        ax8817x_mdio_write( netdev, phy_id, loc, cpu_to_le16(val) );
+}
+
+static int ax88172_link_reset(struct usbnet *dev)
+{
+        u16 lpa;
+        u16 adv;
+        u16 res;
+        u8 mode;
+
+        mode = AX_MEDIUM_TX_ABORT_ALLOW | AX_MEDIUM_FLOW_CONTROL_EN;
+        lpa = ax8817x_mdio_read_le(dev->net, dev->mii.phy_id, MII_LPA);
+        adv = ax8817x_mdio_read_le(dev->net, dev->mii.phy_id, MII_ADVERTISE);
+        res = mii_nway_result(lpa|adv);
+        if (res & LPA_DUPLEX)
+                mode |= AX_MEDIUM_FULL_DUPLEX;
+        ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
+
+        return 0;
+}
+
+static void
+ax8817x_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
+{
+        struct usbnet *dev = netdev_priv(net);
+        u8 opt;
+
+        if (ax8817x_read_cmd(dev, AX_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
+                wolinfo->supported = 0;
+                wolinfo->wolopts = 0;
+                return;
+        }
+        wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
+        wolinfo->wolopts = 0;
+        if (opt & AX_MONITOR_MODE) {
+                if (opt & AX_MONITOR_LINK)
+                        wolinfo->wolopts |= WAKE_PHY;
+                if (opt & AX_MONITOR_MAGIC)
+                        wolinfo->wolopts |= WAKE_MAGIC;
+        }
+}
+
+static int
+ax8817x_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
+{
+        struct usbnet *dev = netdev_priv(net);
+        u8 opt = 0;
+        u8 buf[1];
+
+        if (wolinfo->wolopts & WAKE_PHY)
+                opt |= AX_MONITOR_LINK;
+        if (wolinfo->wolopts & WAKE_MAGIC)
+                opt |= AX_MONITOR_MAGIC;
+        if (opt != 0)
+                opt |= AX_MONITOR_MODE;
+
+        if (ax8817x_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
+                              opt, 0, 0, &buf) < 0)
+                return -EINVAL;
+
+        return 0;
+}
+
+static int ax8817x_get_eeprom_len(struct net_device *net)
+{
+        return AX_EEPROM_LEN;
+}
+
+static int ax8817x_get_eeprom(struct net_device *net,
+                              struct ethtool_eeprom *eeprom, u8 *data)
+{
+        struct usbnet *dev = netdev_priv(net);
+        u16 *ebuf = (u16 *)data;
+        int i;
+
+        /* Crude hack to ensure that we don't overwrite memory
+         * if an odd length is supplied
+         */
+        if (eeprom->len % 2)
+                return -EINVAL;
+
+        eeprom->magic = AX_EEPROM_MAGIC;
+
+        /* ax8817x returns 2 bytes from eeprom on read */
+        for (i=0; i < eeprom->len / 2; i++) {
+                if (ax8817x_read_cmd(dev, AX_CMD_READ_EEPROM,
+                        eeprom->offset + i, 0, 2, &ebuf[i]) < 0)
+                        return -EINVAL;
+        }
+        return 0;
+}
+
+static void ax8817x_get_drvinfo (struct net_device *net,
+                                 struct ethtool_drvinfo *info)
+{
+        /* Inherit standard device info */
+        usbnet_get_drvinfo(net, info);
+        info->eedump_len = 0x3e;
+}
+
+static int ax8817x_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
+{
+        struct usbnet *dev = netdev_priv(net);
+
+        return mii_ethtool_gset(&dev->mii,cmd);
+}
+
+static int ax8817x_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
+{
+        struct usbnet *dev = netdev_priv(net);
+
+        return mii_ethtool_sset(&dev->mii,cmd);
+}
+
+/* We need to override some ethtool_ops so we require our
+   own structure so we don't interfere with other usbnet
+   devices that may be connected at the same time. */
+static struct ethtool_ops ax8817x_ethtool_ops = {
+        .get_drvinfo            = ax8817x_get_drvinfo,
+        .get_link               = ethtool_op_get_link,
+        .get_msglevel           = usbnet_get_msglevel,
+        .set_msglevel           = usbnet_set_msglevel,
+        .get_wol                = ax8817x_get_wol,
+        .set_wol                = ax8817x_set_wol,
+        .get_eeprom_len         = ax8817x_get_eeprom_len,
+        .get_eeprom             = ax8817x_get_eeprom,
+        .get_settings           = ax8817x_get_settings,
+        .set_settings           = ax8817x_set_settings,
+};
+
+static int ax8817x_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
+{
+        struct usbnet *dev = netdev_priv(net);
+
+        return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
+}
+
+static int ax8817x_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int ret = 0;
+        void *buf;
+        int i;
+        unsigned long gpio_bits = dev->driver_info->data;
+
+        usbnet_get_endpoints(dev,intf);
+
+        buf = kmalloc(ETH_ALEN, GFP_KERNEL);
+        if(!buf) {
+                ret = -ENOMEM;
+                goto out1;
+        }
+
+        /* Toggle the GPIOs in a manufacturer/model specific way */
+        for (i = 2; i >= 0; i--) {
+                if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_GPIOS,
+                                        (gpio_bits >> (i * 8)) & 0xff, 0, 0,
+                                        buf)) < 0)
+                        goto out2;
+                msleep(5);
+        }
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL,
+                                0x80, 0, 0, buf)) < 0) {
+                dbg("send AX_CMD_WRITE_RX_CTL failed: %d", ret);
+                goto out2;
+        }
+
+        /* Get the MAC address */
+        memset(buf, 0, ETH_ALEN);
+        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_NODE_ID,
+                                0, 0, 6, buf)) < 0) {
+                dbg("read AX_CMD_READ_NODE_ID failed: %d", ret);
+                goto out2;
+        }
+        memcpy(dev->net->dev_addr, buf, ETH_ALEN);
+
+        /* Get the PHY id */
+        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_PHY_ID,
+                                0, 0, 2, buf)) < 0) {
+                dbg("error on read AX_CMD_READ_PHY_ID: %02x", ret);
+                goto out2;
+        } else if (ret < 2) {
+                /* this should always return 2 bytes */
+                dbg("AX_CMD_READ_PHY_ID returned less than 2 bytes: ret=%02x",
+                                ret);
+                ret = -EIO;
+                goto out2;
+        }
+
+        /* Initialize MII structure */
+        dev->mii.dev = dev->net;
+        dev->mii.mdio_read = ax8817x_mdio_read;
+        dev->mii.mdio_write = ax8817x_mdio_write;
+        dev->mii.phy_id_mask = 0x3f;
+        dev->mii.reg_num_mask = 0x1f;
+        dev->mii.phy_id = *((u8 *)buf + 1);
+        dev->net->do_ioctl = ax8817x_ioctl;
+
+        dev->net->set_multicast_list = ax8817x_set_multicast;
+        dev->net->ethtool_ops = &ax8817x_ethtool_ops;
+
+        ax8817x_mdio_write_le(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
+        ax8817x_mdio_write_le(dev->net, dev->mii.phy_id, MII_ADVERTISE,
+                ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
+        mii_nway_restart(&dev->mii);
+
+        return 0;
+out2:
+        kfree(buf);
+out1:
+        return ret;
+}
+
+static struct ethtool_ops ax88772_ethtool_ops = {
+        .get_drvinfo            = ax8817x_get_drvinfo,
+        .get_link               = ethtool_op_get_link,
+        .get_msglevel           = usbnet_get_msglevel,
+        .set_msglevel           = usbnet_set_msglevel,
+        .get_wol                = ax8817x_get_wol,
+        .set_wol                = ax8817x_set_wol,
+        .get_eeprom_len         = ax8817x_get_eeprom_len,
+        .get_eeprom             = ax8817x_get_eeprom,
+        .get_settings           = ax8817x_get_settings,
+        .set_settings           = ax8817x_set_settings,
+};
+
+static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int ret;
+        void *buf;
+
+        usbnet_get_endpoints(dev,intf);
+
+        buf = kmalloc(6, GFP_KERNEL);
+        if(!buf) {
+                dbg ("Cannot allocate memory for buffer");
+                ret = -ENOMEM;
+                goto out1;
+        }
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_GPIOS,
+                                     0x00B0, 0, 0, buf)) < 0)
+                goto out2;
+
+        msleep(5);
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_PHY_SELECT,
+                                0x0001, 0, 0, buf)) < 0) {
+                dbg("Select PHY #1 failed: %d", ret);
+                goto out2;
+        }
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_IPPD,
+                                0, 0, buf)) < 0) {
+                dbg("Failed to power down internal PHY: %d", ret);
+                goto out2;
+        }
+
+        msleep(150);
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_CLEAR,
+                                0, 0, buf)) < 0) {
+                dbg("Failed to perform software reset: %d", ret);
+                goto out2;
+        }
+
+        msleep(150);
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_RESET,
+                                AX_SWRESET_IPRL | AX_SWRESET_PRL,
+                                0, 0, buf)) < 0) {
+                dbg("Failed to set Internal/External PHY reset control: %d",
+                                        ret);
+                goto out2;
+        }
+
+        msleep(150);
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL,
+                                0x0000, 0, 0, buf)) < 0) {
+                dbg("Failed to reset RX_CTL: %d", ret);
+                goto out2;
+        }
+
+        /* Get the MAC address */
+        memset(buf, 0, ETH_ALEN);
+        if ((ret = ax8817x_read_cmd(dev, AX88772_CMD_READ_NODE_ID,
+                                0, 0, ETH_ALEN, buf)) < 0) {
+                dbg("Failed to read MAC address: %d", ret);
+                goto out2;
+        }
+        memcpy(dev->net->dev_addr, buf, ETH_ALEN);
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII,
+                                0, 0, 0, buf)) < 0) {
+                dbg("Enabling software MII failed: %d", ret);
+                goto out2;
+        }
+
+        if (((ret = ax8817x_read_cmd(dev, AX_CMD_READ_MII_REG,
+                                0x0010, 2, 2, buf)) < 0)
+                        || (*((u16 *)buf) != 0x003b)) {
+                dbg("Read PHY register 2 must be 0x3b00: %d", ret);
+                goto out2;
+        }
+
+        /* Initialize MII structure */
+        dev->mii.dev = dev->net;
+        dev->mii.mdio_read = ax8817x_mdio_read;
+        dev->mii.mdio_write = ax8817x_mdio_write;
+        dev->mii.phy_id_mask = 0xff;
+        dev->mii.reg_num_mask = 0xff;
+        dev->net->do_ioctl = ax8817x_ioctl;
+
+        /* Get the PHY id */
+        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_PHY_ID,
+                        0, 0, 2, buf)) < 0) {
+                dbg("Error reading PHY ID: %02x", ret);
+                goto out2;
+        } else if (ret < 2) {
+                /* this should always return 2 bytes */
+                dbg("AX_CMD_READ_PHY_ID returned less than 2 bytes: ret=%02x",
+                    ret);
+                ret = -EIO;
+                goto out2;
+        }
+        dev->mii.phy_id = *((u8 *)buf + 1);
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_PRL,
+                                0, 0, buf)) < 0) {
+                dbg("Set external PHY reset pin level: %d", ret);
+                goto out2;
+        }
+        msleep(150);
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_RESET,
+                                AX_SWRESET_IPRL | AX_SWRESET_PRL,
+                                0, 0, buf)) < 0) {
+                dbg("Set Internal/External PHY reset control: %d", ret);
+                goto out2;
+        }
+        msleep(150);
+
+
+        dev->net->set_multicast_list = ax8817x_set_multicast;
+        dev->net->ethtool_ops = &ax88772_ethtool_ops;
+
+        ax8817x_mdio_write_le(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
+        ax8817x_mdio_write_le(dev->net, dev->mii.phy_id, MII_ADVERTISE,
+                        ADVERTISE_ALL | ADVERTISE_CSMA);
+        mii_nway_restart(&dev->mii);
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE,
+                                AX88772_MEDIUM_DEFAULT, 0, 0, buf)) < 0) {
+                dbg("Write medium mode register: %d", ret);
+                goto out2;
+        }
+
+        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_IPG0,
+                                AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,
+                                AX88772_IPG2_DEFAULT, 0, buf)) < 0) {
+                dbg("Write IPG,IPG1,IPG2 failed: %d", ret);
+                goto out2;
+        }
+        if ((ret =
+             ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf)) < 0) {
+                dbg("Failed to set hardware MII: %02x", ret);
+                goto out2;
+        }
+
+        /* Set RX_CTL to default values with 2k buffer, and enable cactus */
+        if ((ret =
+             ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL, 0x0088, 0, 0,
+                               buf)) < 0) {
+                dbg("Reset RX_CTL failed: %d", ret);
+                goto out2;
+        }
+
+        kfree(buf);
+
+        /* Asix framing packs multiple eth frames into a 2K usb bulk transfer */
+        if (dev->driver_info->flags & FLAG_FRAMING_AX) {
+                /* hard_mtu  is still the default - the device does not support
+                   jumbo eth frames */
+                dev->rx_urb_size = 2048;
+        }
+
+        return 0;
+
+out2:
+        kfree(buf);
+out1:
+        return ret;
+}
+
+static int ax88772_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        u8  *head;
+        u32  header;
+        char *packet;
+        struct sk_buff *ax_skb;
+        u16 size;
+
+        head = (u8 *) skb->data;
+        memcpy(&header, head, sizeof(header));
+        le32_to_cpus(&header);
+        packet = head + sizeof(header);
+
+        skb_pull(skb, 4);
+
+        while (skb->len > 0) {
+                if ((short)(header & 0x0000ffff) !=
+                    ~((short)((header & 0xffff0000) >> 16))) {
+                        devdbg(dev,"header length data is error");
+                }
+                /* get the packet length */
+                size = (u16) (header & 0x0000ffff);
+
+                if ((skb->len) - ((size + 1) & 0xfffe) == 0)
+                        return 2;
+                if (size > ETH_FRAME_LEN) {
+                        devdbg(dev,"invalid rx length %d", size);
+                        return 0;
+                }
+                ax_skb = skb_clone(skb, GFP_ATOMIC);
+                if (ax_skb) {
+                        ax_skb->len = size;
+                        ax_skb->data = packet;
+                        ax_skb->tail = packet + size;
+                        usbnet_skb_return(dev, ax_skb);
+                } else {
+                        return 0;
+                }
+
+                skb_pull(skb, (size + 1) & 0xfffe);
+
+                if (skb->len == 0)
+                        break;
+
+                head = (u8 *) skb->data;
+                memcpy(&header, head, sizeof(header));
+                le32_to_cpus(&header);
+                packet = head + sizeof(header);
+                skb_pull(skb, 4);
+        }
+
+        if (skb->len < 0) {
+                devdbg(dev,"invalid rx length %d", skb->len);
+                return 0;
+        }
+        return 1;
+}
+
+static struct sk_buff *ax88772_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
+                                        unsigned flags)
+{
+        int padlen;
+        int headroom = skb_headroom(skb);
+        int tailroom = skb_tailroom(skb);
+        u32 packet_len;
+        u32 padbytes = 0xffff0000;
+
+        padlen = ((skb->len + 4) % 512) ? 0 : 4;
+
+        if ((!skb_cloned(skb))
+            && ((headroom + tailroom) >= (4 + padlen))) {
+                if ((headroom < 4) || (tailroom < padlen)) {
+                        skb->data = memmove(skb->head + 4, skb->data, skb->len);
+                        skb->tail = skb->data + skb->len;
+                }
+        } else {
+                struct sk_buff *skb2;
+                skb2 = skb_copy_expand(skb, 4, padlen, flags);
+                dev_kfree_skb_any(skb);
+                skb = skb2;
+                if (!skb)
+                        return NULL;
+        }
+
+        skb_push(skb, 4);
+        packet_len = (((skb->len - 4) ^ 0x0000ffff) << 16) + (skb->len - 4);
+        memcpy(skb->data, &packet_len, sizeof(packet_len));
+
+        if ((skb->len % 512) == 0) {
+                memcpy( skb->tail, &padbytes, sizeof(padbytes));
+                skb_put(skb, sizeof(padbytes));
+        }
+        return skb;
+}
+
+static int ax88772_link_reset(struct usbnet *dev)
+{
+        u16 lpa;
+        u16 adv;
+        u16 res;
+        u16 mode;
+
+        mode = AX88772_MEDIUM_DEFAULT;
+        lpa = ax8817x_mdio_read_le(dev->net, dev->mii.phy_id, MII_LPA);
+        adv = ax8817x_mdio_read_le(dev->net, dev->mii.phy_id, MII_ADVERTISE);
+        res = mii_nway_result(lpa|adv);
+
+        if ((res & LPA_DUPLEX) == 0)
+                mode &= ~AX88772_MEDIUM_FULL_DUPLEX;
+        if ((res & LPA_100) == 0)
+                mode &= ~AX88772_MEDIUM_100MB;
+        ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
+
+        return 0;
+}
+
+static const struct driver_info ax8817x_info = {
+        .description = "ASIX AX8817x USB 2.0 Ethernet",
+        .bind = ax8817x_bind,
+        .status = ax8817x_status,
+        .link_reset = ax88172_link_reset,
+        .reset = ax88172_link_reset,
+        .flags =  FLAG_ETHER,
+        .data = 0x00130103,
+};
+
+static const struct driver_info dlink_dub_e100_info = {
+        .description = "DLink DUB-E100 USB Ethernet",
+        .bind = ax8817x_bind,
+        .status = ax8817x_status,
+        .link_reset = ax88172_link_reset,
+        .reset = ax88172_link_reset,
+        .flags =  FLAG_ETHER,
+        .data = 0x009f9d9f,
+};
+
+static const struct driver_info netgear_fa120_info = {
+        .description = "Netgear FA-120 USB Ethernet",
+        .bind = ax8817x_bind,
+        .status = ax8817x_status,
+        .link_reset = ax88172_link_reset,
+        .reset = ax88172_link_reset,
+        .flags =  FLAG_ETHER,
+        .data = 0x00130103,
+};
+
+static const struct driver_info hawking_uf200_info = {
+        .description = "Hawking UF200 USB Ethernet",
+        .bind = ax8817x_bind,
+        .status = ax8817x_status,
+        .link_reset = ax88172_link_reset,
+        .reset = ax88172_link_reset,
+        .flags =  FLAG_ETHER,
+        .data = 0x001f1d1f,
+};
+
+static const struct driver_info ax88772_info = {
+        .description = "ASIX AX88772 USB 2.0 Ethernet",
+        .bind = ax88772_bind,
+        .status = ax8817x_status,
+        .link_reset = ax88772_link_reset,
+        .reset = ax88772_link_reset,
+        .flags = FLAG_ETHER | FLAG_FRAMING_AX,
+        .rx_fixup = ax88772_rx_fixup,
+        .tx_fixup = ax88772_tx_fixup,
+        .data = 0x00130103,
+};
+
+static const struct usb_device_id       products [] = {
+{
+        // Linksys USB200M
+        USB_DEVICE (0x077b, 0x2226),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // Netgear FA120
+        USB_DEVICE (0x0846, 0x1040),
+        .driver_info =  (unsigned long) &netgear_fa120_info,
+}, {
+        // DLink DUB-E100
+        USB_DEVICE (0x2001, 0x1a00),
+        .driver_info =  (unsigned long) &dlink_dub_e100_info,
+}, {
+        // Intellinet, ST Lab USB Ethernet
+        USB_DEVICE (0x0b95, 0x1720),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // Hawking UF200, TrendNet TU2-ET100
+        USB_DEVICE (0x07b8, 0x420a),
+        .driver_info =  (unsigned long) &hawking_uf200_info,
+}, {
+        // Billionton Systems, USB2AR
+        USB_DEVICE (0x08dd, 0x90ff),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // ATEN UC210T
+        USB_DEVICE (0x0557, 0x2009),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // Buffalo LUA-U2-KTX
+        USB_DEVICE (0x0411, 0x003d),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // Sitecom LN-029 "USB 2.0 10/100 Ethernet adapter"
+        USB_DEVICE (0x6189, 0x182d),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // corega FEther USB2-TX
+        USB_DEVICE (0x07aa, 0x0017),
+        .driver_info =  (unsigned long) &ax8817x_info,
+}, {
+        // Surecom EP-1427X-2
+        USB_DEVICE (0x1189, 0x0893),
+        .driver_info = (unsigned long) &ax8817x_info,
+}, {
+        // goodway corp usb gwusb2e
+        USB_DEVICE (0x1631, 0x6200),
+        .driver_info = (unsigned long) &ax8817x_info,
+}, {
+        // ASIX AX88772 10/100
+        USB_DEVICE (0x0b95, 0x7720),
+        .driver_info = (unsigned long) &ax88772_info,
+},
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver asix_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "asix",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+        .disconnect =   usbnet_disconnect,
+};
+
+static int __init asix_init(void)
+{
+        return usb_register(&asix_driver);
+}
+module_init(asix_init);
+
+static void __exit asix_exit(void)
+{
+        usb_deregister(&asix_driver);
+}
+module_exit(asix_exit);
+
+MODULE_AUTHOR("David Hollis");
+MODULE_DESCRIPTION("ASIX AX8817X based USB 2.0 Ethernet Devices");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/usb/net/catc.c b/drivers/usb/net/catc.c
index c8be912f24e1..37ef365a2472 100644
--- a/drivers/usb/net/catc.c
+++ b/drivers/usb/net/catc.c
@@ -383,7 +383,6 @@ static void catc_tx_done(struct urb *urb, struct pt_regs *regs)
 
         if (urb->status == -ECONNRESET) {
                 dbg("Tx Reset.");
-                urb->transfer_flags &= ~URB_ASYNC_UNLINK;
                 urb->status = 0;
                 catc->netdev->trans_start = jiffies;
                 catc->stats.tx_errors++;
@@ -445,7 +444,6 @@ static void catc_tx_timeout(struct net_device *netdev)
         struct catc *catc = netdev_priv(netdev);
 
         warn("Transmit timed out.");
-        catc->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
         usb_unlink_urb(catc->tx_urb);
 }
 
diff --git a/drivers/usb/net/cdc_ether.c b/drivers/usb/net/cdc_ether.c
new file mode 100644
index 000000000000..652b04bbf6af
--- /dev/null
+++ b/drivers/usb/net/cdc_ether.c
@@ -0,0 +1,509 @@
+/*
+ * CDC Ethernet based networking peripherals
+ * Copyright (C) 2003-2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ctype.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/usb_cdc.h>
+
+#include "usbnet.h"
+
+
+/*
+ * probes control interface, claims data interface, collects the bulk
+ * endpoints, activates data interface (if needed), maybe sets MTU.
+ * all pure cdc, except for certain firmware workarounds, and knowing
+ * that rndis uses one different rule.
+ */
+int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        u8                              *buf = intf->cur_altsetting->extra;
+        int                             len = intf->cur_altsetting->extralen;
+        struct usb_interface_descriptor *d;
+        struct cdc_state                *info = (void *) &dev->data;
+        int                             status;
+        int                             rndis;
+        struct usb_driver               *driver = driver_of(intf);
+
+        if (sizeof dev->data < sizeof *info)
+                return -EDOM;
+
+        /* expect strict spec conformance for the descriptors, but
+         * cope with firmware which stores them in the wrong place
+         */
+        if (len == 0 && dev->udev->actconfig->extralen) {
+                /* Motorola SB4100 (and others: Brad Hards says it's
+                 * from a Broadcom design) put CDC descriptors here
+                 */
+                buf = dev->udev->actconfig->extra;
+                len = dev->udev->actconfig->extralen;
+                if (len)
+                        dev_dbg(&intf->dev,
+                                "CDC descriptors on config\n");
+        }
+
+        /* this assumes that if there's a non-RNDIS vendor variant
+         * of cdc-acm, it'll fail RNDIS requests cleanly.
+         */
+        rndis = (intf->cur_altsetting->desc.bInterfaceProtocol == 0xff);
+
+        memset(info, 0, sizeof *info);
+        info->control = intf;
+        while (len > 3) {
+                if (buf [1] != USB_DT_CS_INTERFACE)
+                        goto next_desc;
+
+                /* use bDescriptorSubType to identify the CDC descriptors.
+                 * We expect devices with CDC header and union descriptors.
+                 * For CDC Ethernet we need the ethernet descriptor.
+                 * For RNDIS, ignore two (pointless) CDC modem descriptors
+                 * in favor of a complicated OID-based RPC scheme doing what
+                 * CDC Ethernet achieves with a simple descriptor.
+                 */
+                switch (buf [2]) {
+                case USB_CDC_HEADER_TYPE:
+                        if (info->header) {
+                                dev_dbg(&intf->dev, "extra CDC header\n");
+                                goto bad_desc;
+                        }
+                        info->header = (void *) buf;
+                        if (info->header->bLength != sizeof *info->header) {
+                                dev_dbg(&intf->dev, "CDC header len %u\n",
+                                        info->header->bLength);
+                                goto bad_desc;
+                        }
+                        break;
+                case USB_CDC_UNION_TYPE:
+                        if (info->u) {
+                                dev_dbg(&intf->dev, "extra CDC union\n");
+                                goto bad_desc;
+                        }
+                        info->u = (void *) buf;
+                        if (info->u->bLength != sizeof *info->u) {
+                                dev_dbg(&intf->dev, "CDC union len %u\n",
+                                        info->u->bLength);
+                                goto bad_desc;
+                        }
+
+                        /* we need a master/control interface (what we're
+                         * probed with) and a slave/data interface; union
+                         * descriptors sort this all out.
+                         */
+                        info->control = usb_ifnum_to_if(dev->udev,
+                                                info->u->bMasterInterface0);
+                        info->data = usb_ifnum_to_if(dev->udev,
+                                                info->u->bSlaveInterface0);
+                        if (!info->control || !info->data) {
+                                dev_dbg(&intf->dev,
+                                        "master #%u/%p slave #%u/%p\n",
+                                        info->u->bMasterInterface0,
+                                        info->control,
+                                        info->u->bSlaveInterface0,
+                                        info->data);
+                                goto bad_desc;
+                        }
+                        if (info->control != intf) {
+                                dev_dbg(&intf->dev, "bogus CDC Union\n");
+                                /* Ambit USB Cable Modem (and maybe others)
+                                 * interchanges master and slave interface.
+                                 */
+                                if (info->data == intf) {
+                                        info->data = info->control;
+                                        info->control = intf;
+                                } else
+                                        goto bad_desc;
+                        }
+
+                        /* a data interface altsetting does the real i/o */
+                        d = &info->data->cur_altsetting->desc;
+                        if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
+                                dev_dbg(&intf->dev, "slave class %u\n",
+                                        d->bInterfaceClass);
+                                goto bad_desc;
+                        }
+                        break;
+                case USB_CDC_ETHERNET_TYPE:
+                        if (info->ether) {
+                                dev_dbg(&intf->dev, "extra CDC ether\n");
+                                goto bad_desc;
+                        }
+                        info->ether = (void *) buf;
+                        if (info->ether->bLength != sizeof *info->ether) {
+                                dev_dbg(&intf->dev, "CDC ether len %u\n",
+                                        info->ether->bLength);
+                                goto bad_desc;
+                        }
+                        dev->hard_mtu = le16_to_cpu(
+                                                info->ether->wMaxSegmentSize);
+                        /* because of Zaurus, we may be ignoring the host
+                         * side link address we were given.
+                         */
+                        break;
+                }
+next_desc:
+                len -= buf [0]; /* bLength */
+                buf += buf [0];
+        }
+
+        if (!info->header || !info->u || (!rndis && !info->ether)) {
+                dev_dbg(&intf->dev, "missing cdc %s%s%sdescriptor\n",
+                        info->header ? "" : "header ",
+                        info->u ? "" : "union ",
+                        info->ether ? "" : "ether ");
+                goto bad_desc;
+        }
+
+        /* claim data interface and set it up ... with side effects.
+         * network traffic can't flow until an altsetting is enabled.
+         */
+        status = usb_driver_claim_interface(driver, info->data, dev);
+        if (status < 0)
+                return status;
+        status = usbnet_get_endpoints(dev, info->data);
+        if (status < 0) {
+                /* ensure immediate exit from usbnet_disconnect */
+                usb_set_intfdata(info->data, NULL);
+                usb_driver_release_interface(driver, info->data);
+                return status;
+        }
+
+        /* status endpoint: optional for CDC Ethernet, not RNDIS (or ACM) */
+        dev->status = NULL;
+        if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
+                struct usb_endpoint_descriptor  *desc;
+
+                dev->status = &info->control->cur_altsetting->endpoint [0];
+                desc = &dev->status->desc;
+                if (desc->bmAttributes != USB_ENDPOINT_XFER_INT
+                                || !(desc->bEndpointAddress & USB_DIR_IN)
+                                || (le16_to_cpu(desc->wMaxPacketSize)
+                                        < sizeof(struct usb_cdc_notification))
+                                || !desc->bInterval) {
+                        dev_dbg(&intf->dev, "bad notification endpoint\n");
+                        dev->status = NULL;
+                }
+        }
+        if (rndis && !dev->status) {
+                dev_dbg(&intf->dev, "missing RNDIS status endpoint\n");
+                usb_set_intfdata(info->data, NULL);
+                usb_driver_release_interface(driver, info->data);
+                return -ENODEV;
+        }
+        return 0;
+
+bad_desc:
+        dev_info(&dev->udev->dev, "bad CDC descriptors\n");
+        return -ENODEV;
+}
+EXPORT_SYMBOL_GPL(usbnet_generic_cdc_bind);
+
+void usbnet_cdc_unbind(struct usbnet *dev, struct usb_interface *intf)
+{
+        struct cdc_state                *info = (void *) &dev->data;
+        struct usb_driver               *driver = driver_of(intf);
+
+        /* disconnect master --> disconnect slave */
+        if (intf == info->control && info->data) {
+                /* ensure immediate exit from usbnet_disconnect */
+                usb_set_intfdata(info->data, NULL);
+                usb_driver_release_interface(driver, info->data);
+                info->data = NULL;
+        }
+
+        /* and vice versa (just in case) */
+        else if (intf == info->data && info->control) {
+                /* ensure immediate exit from usbnet_disconnect */
+                usb_set_intfdata(info->control, NULL);
+                usb_driver_release_interface(driver, info->control);
+                info->control = NULL;
+        }
+}
+EXPORT_SYMBOL_GPL(usbnet_cdc_unbind);
+
+
+/*-------------------------------------------------------------------------
+ *
+ * Communications Device Class, Ethernet Control model
+ *
+ * Takes two interfaces.  The DATA interface is inactive till an altsetting
+ * is selected.  Configuration data includes class descriptors.  There's
+ * an optional status endpoint on the control interface.
+ *
+ * This should interop with whatever the 2.4 "CDCEther.c" driver
+ * (by Brad Hards) talked with, with more functionality.
+ *
+ *-------------------------------------------------------------------------*/
+
+static void dumpspeed(struct usbnet *dev, __le32 *speeds)
+{
+        if (netif_msg_timer(dev))
+                devinfo(dev, "link speeds: %u kbps up, %u kbps down",
+                        __le32_to_cpu(speeds[0]) / 1000,
+                __le32_to_cpu(speeds[1]) / 1000);
+}
+
+static void cdc_status(struct usbnet *dev, struct urb *urb)
+{
+        struct usb_cdc_notification     *event;
+
+        if (urb->actual_length < sizeof *event)
+                return;
+
+        /* SPEED_CHANGE can get split into two 8-byte packets */
+        if (test_and_clear_bit(EVENT_STS_SPLIT, &dev->flags)) {
+                dumpspeed(dev, (__le32 *) urb->transfer_buffer);
+                return;
+        }
+
+        event = urb->transfer_buffer;
+        switch (event->bNotificationType) {
+        case USB_CDC_NOTIFY_NETWORK_CONNECTION:
+                if (netif_msg_timer(dev))
+                        devdbg(dev, "CDC: carrier %s",
+                                        event->wValue ? "on" : "off");
+                if (event->wValue)
+                        netif_carrier_on(dev->net);
+                else
+                        netif_carrier_off(dev->net);
+                break;
+        case USB_CDC_NOTIFY_SPEED_CHANGE:       /* tx/rx rates */
+                if (netif_msg_timer(dev))
+                        devdbg(dev, "CDC: speed change (len %d)",
+                                        urb->actual_length);
+                if (urb->actual_length != (sizeof *event + 8))
+                        set_bit(EVENT_STS_SPLIT, &dev->flags);
+                else
+                        dumpspeed(dev, (__le32 *) &event[1]);
+                break;
+        /* USB_CDC_NOTIFY_RESPONSE_AVAILABLE can happen too (e.g. RNDIS),
+         * but there are no standard formats for the response data.
+         */
+        default:
+                deverr(dev, "CDC: unexpected notification %02x!",
+                                 event->bNotificationType);
+                break;
+        }
+}
+
+static u8 nibble(unsigned char c)
+{
+        if (likely(isdigit(c)))
+                return c - '0';
+        c = toupper(c);
+        if (likely(isxdigit(c)))
+                return 10 + c - 'A';
+        return 0;
+}
+
+static inline int
+get_ethernet_addr(struct usbnet *dev, struct usb_cdc_ether_desc *e)
+{
+        int             tmp, i;
+        unsigned char   buf [13];
+
+        tmp = usb_string(dev->udev, e->iMACAddress, buf, sizeof buf);
+        if (tmp != 12) {
+                dev_dbg(&dev->udev->dev,
+                        "bad MAC string %d fetch, %d\n", e->iMACAddress, tmp);
+                if (tmp >= 0)
+                        tmp = -EINVAL;
+                return tmp;
+        }
+        for (i = tmp = 0; i < 6; i++, tmp += 2)
+                dev->net->dev_addr [i] =
+                        (nibble(buf [tmp]) << 4) + nibble(buf [tmp + 1]);
+        return 0;
+}
+
+static int cdc_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int                             status;
+        struct cdc_state                *info = (void *) &dev->data;
+
+        status = usbnet_generic_cdc_bind(dev, intf);
+        if (status < 0)
+                return status;
+
+        status = get_ethernet_addr(dev, info->ether);
+        if (status < 0) {
+                usb_set_intfdata(info->data, NULL);
+                usb_driver_release_interface(driver_of(intf), info->data);
+                return status;
+        }
+
+        /* FIXME cdc-ether has some multicast code too, though it complains
+         * in routine cases.  info->ether describes the multicast support.
+         * Implement that here, manipulating the cdc filter as needed.
+         */
+        return 0;
+}
+
+static const struct driver_info cdc_info = {
+        .description =  "CDC Ethernet Device",
+        .flags =        FLAG_ETHER,
+        // .check_connect = cdc_check_connect,
+        .bind =         cdc_bind,
+        .unbind =       usbnet_cdc_unbind,
+        .status =       cdc_status,
+};
+
+/*-------------------------------------------------------------------------*/
+
+
+static const struct usb_device_id       products [] = {
+/*
+ * BLACKLIST !!
+ *
+ * First blacklist any products that are egregiously nonconformant
+ * with the CDC Ethernet specs.  Minor braindamage we cope with; when
+ * they're not even trying, needing a separate driver is only the first
+ * of the differences to show up.
+ */
+
+#define ZAURUS_MASTER_INTERFACE \
+        .bInterfaceClass        = USB_CLASS_COMM, \
+        .bInterfaceSubClass     = USB_CDC_SUBCLASS_ETHERNET, \
+        .bInterfaceProtocol     = USB_CDC_PROTO_NONE
+
+/* SA-1100 based Sharp Zaurus ("collie"), or compatible;
+ * wire-incompatible with true CDC Ethernet implementations.
+ * (And, it seems, needlessly so...)
+ */
+{
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8004,
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+},
+
+/* PXA-25x based Sharp Zaurii.  Note that it seems some of these
+ * (later models especially) may have shipped only with firmware
+ * advertising false "CDC MDLM" compatibility ... but we're not
+ * clear which models did that, so for now let's assume the worst.
+ */
+{
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8005,       /* A-300 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8006,       /* B-500/SL-5600 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                  | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8007,       /* C-700 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x9031,       /* C-750 C-760 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x9032,       /* SL-6000 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        /* reported with some C860 units */
+        .idProduct              = 0x9050,       /* C-860 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info            = 0,
+},
+
+/*
+ * WHITELIST!!!
+ *
+ * CDC Ether uses two interfaces, not necessarily consecutive.
+ * We match the main interface, ignoring the optional device
+ * class so we could handle devices that aren't exclusively
+ * CDC ether.
+ *
+ * NOTE:  this match must come AFTER entries blacklisting devices
+ * because of bugs/quirks in a given product (like Zaurus, above).
+ */
+{
+        USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
+                        USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &cdc_info,
+},
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver cdc_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "cdc_ether",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+
+static int __init cdc_init(void)
+{
+        BUG_ON((sizeof(((struct usbnet *)0)->data)
+                        < sizeof(struct cdc_state)));
+
+        return usb_register(&cdc_driver);
+}
+module_init(cdc_init);
+
+static void __exit cdc_exit(void)
+{
+        usb_deregister(&cdc_driver);
+}
+module_exit(cdc_exit);
+
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("USB CDC Ethernet devices");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/cdc_subset.c b/drivers/usb/net/cdc_subset.c
new file mode 100644
index 000000000000..f1730b685fd2
--- /dev/null
+++ b/drivers/usb/net/cdc_subset.c
@@ -0,0 +1,335 @@
+/*
+ * Simple "CDC Subset" USB Networking Links
+ * Copyright (C) 2000-2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/kmod.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+
+#include "usbnet.h"
+
+
+/*
+ * This supports simple USB network links that don't require any special
+ * framing or hardware control operations.  The protocol used here is a
+ * strict subset of CDC Ethernet, with three basic differences reflecting
+ * the goal that almost any hardware should run it:
+ *
+ *  - Minimal runtime control:  one interface, no altsettings, and
+ *    no vendor or class specific control requests.  If a device is
+ *    configured, it is allowed to exchange packets with the host.
+ *    Fancier models would mean not working on some hardware.
+ *
+ *  - Minimal manufacturing control:  no IEEE "Organizationally
+ *    Unique ID" required, or an EEPROMs to store one.  Each host uses
+ *    one random "locally assigned" Ethernet address instead, which can
+ *    of course be overridden using standard tools like "ifconfig".
+ *    (With 2^46 such addresses, same-net collisions are quite rare.)
+ *
+ *  - There is no additional framing data for USB.  Packets are written
+ *    exactly as in CDC Ethernet, starting with an Ethernet header and
+ *    terminated by a short packet.  However, the host will never send a
+ *    zero length packet; some systems can't handle those robustly.
+ *
+ * Anything that can transmit and receive USB bulk packets can implement
+ * this protocol.  That includes both smart peripherals and quite a lot
+ * of "host-to-host" USB cables (which embed two devices back-to-back).
+ *
+ * Note that although Linux may use many of those host-to-host links
+ * with this "cdc_subset" framing, that doesn't mean there may not be a
+ * better approach.  Handling the "other end unplugs/replugs" scenario
+ * well tends to require chip-specific vendor requests.  Also, Windows
+ * peers at the other end of host-to-host cables may expect their own
+ * framing to be used rather than this "cdc_subset" model.
+ */
+
+#if defined(CONFIG_USB_EPSON2888) || defined(CONFIG_USB_ARMLINUX)
+/* PDA style devices are always connected if present */
+static int always_connected (struct usbnet *dev)
+{
+        return 0;
+}
+#endif
+
+#ifdef  CONFIG_USB_ALI_M5632
+#define HAVE_HARDWARE
+
+/*-------------------------------------------------------------------------
+ *
+ * ALi M5632 driver ... does high speed
+ *
+ *-------------------------------------------------------------------------*/
+
+static const struct driver_info ali_m5632_info = {
+        .description =  "ALi M5632",
+};
+
+
+#endif
+
+
+#ifdef  CONFIG_USB_AN2720
+#define HAVE_HARDWARE
+
+/*-------------------------------------------------------------------------
+ *
+ * AnchorChips 2720 driver ... http://www.cypress.com
+ *
+ * This doesn't seem to have a way to detect whether the peer is
+ * connected, or need any reset handshaking.  It's got pretty big
+ * internal buffers (handles most of a frame's worth of data).
+ * Chip data sheets don't describe any vendor control messages.
+ *
+ *-------------------------------------------------------------------------*/
+
+static const struct driver_info an2720_info = {
+        .description =  "AnchorChips/Cypress 2720",
+        // no reset available!
+        // no check_connect available!
+
+        .in = 2, .out = 2,              // direction distinguishes these
+};
+
+#endif  /* CONFIG_USB_AN2720 */
+
+
+#ifdef  CONFIG_USB_BELKIN
+#define HAVE_HARDWARE
+
+/*-------------------------------------------------------------------------
+ *
+ * Belkin F5U104 ... two NetChip 2280 devices + Atmel AVR microcontroller
+ *
+ * ... also two eTEK designs, including one sold as "Advance USBNET"
+ *
+ *-------------------------------------------------------------------------*/
+
+static const struct driver_info belkin_info = {
+        .description =  "Belkin, eTEK, or compatible",
+};
+
+#endif  /* CONFIG_USB_BELKIN */
+
+
+
+#ifdef  CONFIG_USB_EPSON2888
+#define HAVE_HARDWARE
+
+/*-------------------------------------------------------------------------
+ *
+ * EPSON USB clients
+ *
+ * This is the same idea as Linux PDAs (below) except the firmware in the
+ * device might not be Tux-powered.  Epson provides reference firmware that
+ * implements this interface.  Product developers can reuse or modify that
+ * code, such as by using their own product and vendor codes.
+ *
+ * Support was from Juro Bystricky <bystricky.juro@erd.epson.com>
+ *
+ *-------------------------------------------------------------------------*/
+
+static const struct driver_info epson2888_info = {
+        .description =  "Epson USB Device",
+        .check_connect = always_connected,
+
+        .in = 4, .out = 3,
+};
+
+#endif  /* CONFIG_USB_EPSON2888 */
+
+
+#ifdef CONFIG_USB_KC2190
+#define HAVE_HARDWARE
+static const struct driver_info kc2190_info = {
+        .description =  "KC Technology KC-190",
+};
+#endif /* CONFIG_USB_KC2190 */
+
+
+#ifdef  CONFIG_USB_ARMLINUX
+#define HAVE_HARDWARE
+
+/*-------------------------------------------------------------------------
+ *
+ * Intel's SA-1100 chip integrates basic USB support, and is used
+ * in PDAs like some iPaqs, the Yopy, some Zaurus models, and more.
+ * When they run Linux, arch/arm/mach-sa1100/usb-eth.c may be used to
+ * network using minimal USB framing data.
+ *
+ * This describes the driver currently in standard ARM Linux kernels.
+ * The Zaurus uses a different driver (see later).
+ *
+ * PXA25x and PXA210 use XScale cores (ARM v5TE) with better USB support
+ * and different USB endpoint numbering than the SA1100 devices.  The
+ * mach-pxa/usb-eth.c driver re-uses the device ids from mach-sa1100
+ * so we rely on the endpoint descriptors.
+ *
+ *-------------------------------------------------------------------------*/
+
+static const struct driver_info linuxdev_info = {
+        .description =  "Linux Device",
+        .check_connect = always_connected,
+};
+
+static const struct driver_info yopy_info = {
+        .description =  "Yopy",
+        .check_connect = always_connected,
+};
+
+static const struct driver_info blob_info = {
+        .description =  "Boot Loader OBject",
+        .check_connect = always_connected,
+};
+
+#endif  /* CONFIG_USB_ARMLINUX */
+
+
+/*-------------------------------------------------------------------------*/
+
+#ifndef HAVE_HARDWARE
+#error You need to configure some hardware for this driver
+#endif
+
+/*
+ * chip vendor names won't normally be on the cables, and
+ * may not be on the device.
+ */
+
+static const struct usb_device_id       products [] = {
+
+#ifdef  CONFIG_USB_ALI_M5632
+{
+        USB_DEVICE (0x0402, 0x5632),    // ALi defaults
+        .driver_info =  (unsigned long) &ali_m5632_info,
+},
+#endif
+
+#ifdef  CONFIG_USB_AN2720
+{
+        USB_DEVICE (0x0547, 0x2720),    // AnchorChips defaults
+        .driver_info =  (unsigned long) &an2720_info,
+}, {
+        USB_DEVICE (0x0547, 0x2727),    // Xircom PGUNET
+        .driver_info =  (unsigned long) &an2720_info,
+},
+#endif
+
+#ifdef  CONFIG_USB_BELKIN
+{
+        USB_DEVICE (0x050d, 0x0004),    // Belkin
+        .driver_info =  (unsigned long) &belkin_info,
+}, {
+        USB_DEVICE (0x056c, 0x8100),    // eTEK
+        .driver_info =  (unsigned long) &belkin_info,
+}, {
+        USB_DEVICE (0x0525, 0x9901),    // Advance USBNET (eTEK)
+        .driver_info =  (unsigned long) &belkin_info,
+},
+#endif
+
+#ifdef  CONFIG_USB_EPSON2888
+{
+        USB_DEVICE (0x0525, 0x2888),    // EPSON USB client
+        .driver_info    = (unsigned long) &epson2888_info,
+},
+#endif
+
+#ifdef CONFIG_USB_KC2190
+{
+        USB_DEVICE (0x050f, 0x0190),    // KC-190
+        .driver_info =  (unsigned long) &kc2190_info,
+},
+#endif
+
+#ifdef  CONFIG_USB_ARMLINUX
+/*
+ * SA-1100 using standard ARM Linux kernels, or compatible.
+ * Often used when talking to Linux PDAs (iPaq, Yopy, etc).
+ * The sa-1100 "usb-eth" driver handles the basic framing.
+ *
+ * PXA25x or PXA210 ...  these use a "usb-eth" driver much like
+ * the sa1100 one, but hardware uses different endpoint numbers.
+ *
+ * Or the Linux "Ethernet" gadget on hardware that can't talk
+ * CDC Ethernet (e.g., no altsettings), in either of two modes:
+ *  - acting just like the old "usb-eth" firmware, though
+ *    the implementation is different
+ *  - supporting RNDIS as the first/default configuration for
+ *    MS-Windows interop; Linux needs to use the other config
+ */
+{
+        // 1183 = 0x049F, both used as hex values?
+        // Compaq "Itsy" vendor/product id
+        USB_DEVICE (0x049F, 0x505A),    // usb-eth, or compatible
+        .driver_info =  (unsigned long) &linuxdev_info,
+}, {
+        USB_DEVICE (0x0E7E, 0x1001),    // G.Mate "Yopy"
+        .driver_info =  (unsigned long) &yopy_info,
+}, {
+        USB_DEVICE (0x8086, 0x07d3),    // "blob" bootloader
+        .driver_info =  (unsigned long) &blob_info,
+}, {
+        // Linux Ethernet/RNDIS gadget on pxa210/25x/26x, second config
+        // e.g. Gumstix, current OpenZaurus, ...
+        USB_DEVICE_VER (0x0525, 0xa4a2, 0x0203, 0x0203),
+        .driver_info =  (unsigned long) &linuxdev_info,
+},
+#endif
+
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_driver cdc_subset_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "cdc_subset",
+        .probe =        usbnet_probe,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+        .disconnect =   usbnet_disconnect,
+        .id_table =     products,
+};
+
+static int __init cdc_subset_init(void)
+{
+        return usb_register(&cdc_subset_driver);
+}
+module_init(cdc_subset_init);
+
+static void __exit cdc_subset_exit(void)
+{
+        usb_deregister(&cdc_subset_driver);
+}
+module_exit(cdc_subset_exit);
+
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("Simple 'CDC Subset' USB networking links");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/gl620a.c b/drivers/usb/net/gl620a.c
new file mode 100644
index 000000000000..c8763ae33c73
--- /dev/null
+++ b/drivers/usb/net/gl620a.c
@@ -0,0 +1,407 @@
+/*
+ * GeneSys GL620USB-A based links
+ * Copyright (C) 2001 by Jiun-Jie Huang <huangjj@genesyslogic.com.tw>
+ * Copyright (C) 2001 by Stanislav Brabec <utx@penguin.cz>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+
+#include "usbnet.h"
+
+
+/*
+ * GeneSys GL620USB-A (www.genesyslogic.com.tw)
+ *
+ * ... should partially interop with the Win32 driver for this hardware.
+ * The GeneSys docs imply there's some NDIS issue motivating this framing.
+ *
+ * Some info from GeneSys:
+ *  - GL620USB-A is full duplex; GL620USB is only half duplex for bulk.
+ *    (Some cables, like the BAFO-100c, use the half duplex version.)
+ *  - For the full duplex model, the low bit of the version code says
+ *    which side is which ("left/right").
+ *  - For the half duplex type, a control/interrupt handshake settles
+ *    the transfer direction.  (That's disabled here, partially coded.)
+ *    A control URB would block until other side writes an interrupt.
+ *
+ * Original code from Jiun-Jie Huang <huangjj@genesyslogic.com.tw>
+ * and merged into "usbnet" by Stanislav Brabec <utx@penguin.cz>.
+ */
+
+// control msg write command
+#define GENELINK_CONNECT_WRITE                  0xF0
+// interrupt pipe index
+#define GENELINK_INTERRUPT_PIPE                 0x03
+// interrupt read buffer size
+#define INTERRUPT_BUFSIZE                       0x08
+// interrupt pipe interval value
+#define GENELINK_INTERRUPT_INTERVAL             0x10
+// max transmit packet number per transmit
+#define GL_MAX_TRANSMIT_PACKETS                 32
+// max packet length
+#define GL_MAX_PACKET_LEN                       1514
+// max receive buffer size
+#define GL_RCV_BUF_SIZE         \
+        (((GL_MAX_PACKET_LEN + 4) * GL_MAX_TRANSMIT_PACKETS) + 4)
+
+struct gl_packet {
+        u32             packet_length;
+        char            packet_data [1];
+};
+
+struct gl_header {
+        u32                     packet_count;
+        struct gl_packet        packets;
+};
+
+#ifdef  GENELINK_ACK
+
+// FIXME:  this code is incomplete, not debugged; it doesn't
+// handle interrupts correctly; it should use the generic
+// status IRQ code (which didn't exist back in 2001).
+
+struct gl_priv {
+        struct urb      *irq_urb;
+        char            irq_buf [INTERRUPT_BUFSIZE];
+};
+
+static inline int gl_control_write(struct usbnet *dev, u8 request, u16 value)
+{
+        int retval;
+
+        retval = usb_control_msg(dev->udev,
+                      usb_sndctrlpipe(dev->udev, 0),
+                      request,
+                      USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                      value,
+                      0,                        // index
+                      0,                        // data buffer
+                      0,                        // size
+                      USB_CTRL_SET_TIMEOUT);
+        return retval;
+}
+
+static void gl_interrupt_complete(struct urb *urb, struct pt_regs *regs)
+{
+        int status = urb->status;
+
+        switch (status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                                __FUNCTION__, status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                                __FUNCTION__, urb->status);
+        }
+
+        status = usb_submit_urb(urb, GFP_ATOMIC);
+        if (status)
+                err("%s - usb_submit_urb failed with result %d",
+                     __FUNCTION__, status);
+}
+
+static int gl_interrupt_read(struct usbnet *dev)
+{
+        struct gl_priv  *priv = dev->priv_data;
+        int             retval;
+
+        // issue usb interrupt read
+        if (priv && priv->irq_urb) {
+                // submit urb
+                if ((retval = usb_submit_urb(priv->irq_urb, GFP_KERNEL)) != 0)
+                        dbg("gl_interrupt_read: submit fail - %X...", retval);
+                else
+                        dbg("gl_interrupt_read: submit success...");
+        }
+
+        return 0;
+}
+
+// check whether another side is connected
+static int genelink_check_connect(struct usbnet *dev)
+{
+        int                     retval;
+
+        dbg("genelink_check_connect...");
+
+        // detect whether another side is connected
+        if ((retval = gl_control_write(dev, GENELINK_CONNECT_WRITE, 0)) != 0) {
+                dbg("%s: genelink_check_connect write fail - %X",
+                        dev->net->name, retval);
+                return retval;
+        }
+
+        // usb interrupt read to ack another side
+        if ((retval = gl_interrupt_read(dev)) != 0) {
+                dbg("%s: genelink_check_connect read fail - %X",
+                        dev->net->name, retval);
+                return retval;
+        }
+
+        dbg("%s: genelink_check_connect read success", dev->net->name);
+        return 0;
+}
+
+// allocate and initialize the private data for genelink
+static int genelink_init(struct usbnet *dev)
+{
+        struct gl_priv *priv;
+
+        // allocate the private data structure
+        if ((priv = kmalloc(sizeof *priv, GFP_KERNEL)) == 0) {
+                dbg("%s: cannot allocate private data per device",
+                        dev->net->name);
+                return -ENOMEM;
+        }
+
+        // allocate irq urb
+        if ((priv->irq_urb = usb_alloc_urb(0, GFP_KERNEL)) == 0) {
+                dbg("%s: cannot allocate private irq urb per device",
+                        dev->net->name);
+                kfree(priv);
+                return -ENOMEM;
+        }
+
+        // fill irq urb
+        usb_fill_int_urb(priv->irq_urb, dev->udev,
+                usb_rcvintpipe(dev->udev, GENELINK_INTERRUPT_PIPE),
+                priv->irq_buf, INTERRUPT_BUFSIZE,
+                gl_interrupt_complete, 0,
+                GENELINK_INTERRUPT_INTERVAL);
+
+        // set private data pointer
+        dev->priv_data = priv;
+
+        return 0;
+}
+
+// release the private data
+static int genelink_free(struct usbnet *dev)
+{
+        struct gl_priv  *priv = dev->priv_data;
+
+        if (!priv)
+                return 0;
+
+// FIXME:  can't cancel here; it's synchronous, and
+// should have happened earlier in any case (interrupt
+// handling needs to be generic)
+
+        // cancel irq urb first
+        usb_kill_urb(priv->irq_urb);
+
+        // free irq urb
+        usb_free_urb(priv->irq_urb);
+
+        // free the private data structure
+        kfree(priv);
+
+        return 0;
+}
+
+#endif
+
+static int genelink_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        struct gl_header        *header;
+        struct gl_packet        *packet;
+        struct sk_buff          *gl_skb;
+        u32                     size;
+
+        header = (struct gl_header *) skb->data;
+
+        // get the packet count of the received skb
+        le32_to_cpus(&header->packet_count);
+        if ((header->packet_count > GL_MAX_TRANSMIT_PACKETS)
+                        || (header->packet_count < 0)) {
+                dbg("genelink: invalid received packet count %d",
+                        header->packet_count);
+                return 0;
+        }
+
+        // set the current packet pointer to the first packet
+        packet = &header->packets;
+
+        // decrement the length for the packet count size 4 bytes
+        skb_pull(skb, 4);
+
+        while (header->packet_count > 1) {
+                // get the packet length
+                size = le32_to_cpu(packet->packet_length);
+
+                // this may be a broken packet
+                if (size > GL_MAX_PACKET_LEN) {
+                        dbg("genelink: invalid rx length %d", size);
+                        return 0;
+                }
+
+                // allocate the skb for the individual packet
+                gl_skb = alloc_skb(size, GFP_ATOMIC);
+                if (gl_skb) {
+
+                        // copy the packet data to the new skb
+                        memcpy(skb_put(gl_skb, size),
+                                        packet->packet_data, size);
+                        usbnet_skb_return(dev, gl_skb);
+                }
+
+                // advance to the next packet
+                packet = (struct gl_packet *)
+                        &packet->packet_data [size];
+                header->packet_count--;
+
+                // shift the data pointer to the next gl_packet
+                skb_pull(skb, size + 4);
+        }
+
+        // skip the packet length field 4 bytes
+        skb_pull(skb, 4);
+
+        if (skb->len > GL_MAX_PACKET_LEN) {
+                dbg("genelink: invalid rx length %d", skb->len);
+                return 0;
+        }
+        return 1;
+}
+
+static struct sk_buff *
+genelink_tx_fixup(struct usbnet *dev, struct sk_buff *skb, unsigned flags)
+{
+        int     padlen;
+        int     length = skb->len;
+        int     headroom = skb_headroom(skb);
+        int     tailroom = skb_tailroom(skb);
+        u32     *packet_count;
+        u32     *packet_len;
+
+        // FIXME:  magic numbers, bleech
+        padlen = ((skb->len + (4 + 4*1)) % 64) ? 0 : 1;
+
+        if ((!skb_cloned(skb))
+                        && ((headroom + tailroom) >= (padlen + (4 + 4*1)))) {
+                if ((headroom < (4 + 4*1)) || (tailroom < padlen)) {
+                        skb->data = memmove(skb->head + (4 + 4*1),
+                                             skb->data, skb->len);
+                        skb->tail = skb->data + skb->len;
+                }
+        } else {
+                struct sk_buff  *skb2;
+                skb2 = skb_copy_expand(skb, (4 + 4*1) , padlen, flags);
+                dev_kfree_skb_any(skb);
+                skb = skb2;
+                if (!skb)
+                        return NULL;
+        }
+
+        // attach the packet count to the header
+        packet_count = (u32 *) skb_push(skb, (4 + 4*1));
+        packet_len = packet_count + 1;
+
+        *packet_count = cpu_to_le32(1);
+        *packet_len = cpu_to_le32(length);
+
+        // add padding byte
+        if ((skb->len % dev->maxpacket) == 0)
+                skb_put(skb, 1);
+
+        return skb;
+}
+
+static int genelink_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        dev->hard_mtu = GL_RCV_BUF_SIZE;
+        dev->net->hard_header_len += 4;
+        dev->in = usb_rcvbulkpipe(dev->udev, dev->driver_info->in);
+        dev->out = usb_sndbulkpipe(dev->udev, dev->driver_info->out);
+        return 0;
+}
+
+static const struct driver_info genelink_info = {
+        .description =  "Genesys GeneLink",
+        .flags =        FLAG_FRAMING_GL | FLAG_NO_SETINT,
+        .bind =         genelink_bind,
+        .rx_fixup =     genelink_rx_fixup,
+        .tx_fixup =     genelink_tx_fixup,
+
+        .in = 1, .out = 2,
+
+#ifdef  GENELINK_ACK
+        .check_connect =genelink_check_connect,
+#endif
+};
+
+static const struct usb_device_id       products [] = {
+
+{
+        USB_DEVICE(0x05e3, 0x0502),     // GL620USB-A
+        .driver_info =  (unsigned long) &genelink_info,
+},
+        /* NOT: USB_DEVICE(0x05e3, 0x0501),     // GL620USB
+         * that's half duplex, not currently supported
+         */
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver gl620a_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "gl620a",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+static int __init usbnet_init(void)
+{
+        return usb_register(&gl620a_driver);
+}
+module_init(usbnet_init);
+
+static void __exit usbnet_exit(void)
+{
+        usb_deregister(&gl620a_driver);
+}
+module_exit(usbnet_exit);
+
+MODULE_AUTHOR("Jiun-Jie Huang");
+MODULE_DESCRIPTION("GL620-USB-A Host-to-Host Link cables");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/usb/net/kaweth.c b/drivers/usb/net/kaweth.c
index 7ffa99b9760f..e04b0ce3611a 100644
--- a/drivers/usb/net/kaweth.c
+++ b/drivers/usb/net/kaweth.c
@@ -787,7 +787,6 @@ static int kaweth_start_xmit(struct sk_buff *skb, struct net_device *net)
                       kaweth_usb_transmit_complete,
                       kaweth);
         kaweth->end = 0;
-        kaweth->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
 
         if((res = usb_submit_urb(kaweth->tx_urb, GFP_ATOMIC)))
         {
diff --git a/drivers/usb/net/net1080.c b/drivers/usb/net/net1080.c
new file mode 100644
index 000000000000..a4309c4a491b
--- /dev/null
+++ b/drivers/usb/net/net1080.c
@@ -0,0 +1,622 @@
+/*
+ * Net1080 based USB host-to-host cables
+ * Copyright (C) 2000-2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+
+#include <asm/unaligned.h>
+
+#include "usbnet.h"
+
+
+/*
+ * Netchip 1080 driver ... http://www.netchip.com
+ * (Sept 2004:  End-of-life announcement has been sent.)
+ * Used in (some) LapLink cables
+ */
+
+#define frame_errors    data[1]
+
+/*
+ * NetChip framing of ethernet packets, supporting additional error
+ * checks for links that may drop bulk packets from inside messages.
+ * Odd USB length == always short read for last usb packet.
+ *      - nc_header
+ *      - Ethernet header (14 bytes)
+ *      - payload
+ *      - (optional padding byte, if needed so length becomes odd)
+ *      - nc_trailer
+ *
+ * This framing is to be avoided for non-NetChip devices.
+ */
+
+struct nc_header {              // packed:
+        __le16  hdr_len;                // sizeof nc_header (LE, all)
+        __le16  packet_len;             // payload size (including ethhdr)
+        __le16  packet_id;              // detects dropped packets
+#define MIN_HEADER      6
+
+        // all else is optional, and must start with:
+        // __le16       vendorId;       // from usb-if
+        // __le16       productId;
+} __attribute__((__packed__));
+
+#define PAD_BYTE        ((unsigned char)0xAC)
+
+struct nc_trailer {
+        __le16  packet_id;
+} __attribute__((__packed__));
+
+// packets may use FLAG_FRAMING_NC and optional pad
+#define FRAMED_SIZE(mtu) (sizeof (struct nc_header) \
+                                + sizeof (struct ethhdr) \
+                                + (mtu) \
+                                + 1 \
+                                + sizeof (struct nc_trailer))
+
+#define MIN_FRAMED      FRAMED_SIZE(0)
+
+/* packets _could_ be up to 64KB... */
+#define NC_MAX_PACKET   32767
+
+
+/*
+ * Zero means no timeout; else, how long a 64 byte bulk packet may be queued
+ * before the hardware drops it.  If that's done, the driver will need to
+ * frame network packets to guard against the dropped USB packets.  The win32
+ * driver sets this for both sides of the link.
+ */
+#define NC_READ_TTL_MS  ((u8)255)       // ms
+
+/*
+ * We ignore most registers and EEPROM contents.
+ */
+#define REG_USBCTL      ((u8)0x04)
+#define REG_TTL         ((u8)0x10)
+#define REG_STATUS      ((u8)0x11)
+
+/*
+ * Vendor specific requests to read/write data
+ */
+#define REQUEST_REGISTER        ((u8)0x10)
+#define REQUEST_EEPROM          ((u8)0x11)
+
+static int
+nc_vendor_read(struct usbnet *dev, u8 req, u8 regnum, u16 *retval_ptr)
+{
+        int status = usb_control_msg(dev->udev,
+                usb_rcvctrlpipe(dev->udev, 0),
+                req,
+                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                0, regnum,
+                retval_ptr, sizeof *retval_ptr,
+                USB_CTRL_GET_TIMEOUT);
+        if (status > 0)
+                status = 0;
+        if (!status)
+                le16_to_cpus(retval_ptr);
+        return status;
+}
+
+static inline int
+nc_register_read(struct usbnet *dev, u8 regnum, u16 *retval_ptr)
+{
+        return nc_vendor_read(dev, REQUEST_REGISTER, regnum, retval_ptr);
+}
+
+// no retval ... can become async, usable in_interrupt()
+static void
+nc_vendor_write(struct usbnet *dev, u8 req, u8 regnum, u16 value)
+{
+        usb_control_msg(dev->udev,
+                usb_sndctrlpipe(dev->udev, 0),
+                req,
+                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                value, regnum,
+                NULL, 0,                        // data is in setup packet
+                USB_CTRL_SET_TIMEOUT);
+}
+
+static inline void
+nc_register_write(struct usbnet *dev, u8 regnum, u16 value)
+{
+        nc_vendor_write(dev, REQUEST_REGISTER, regnum, value);
+}
+
+
+#if 0
+static void nc_dump_registers(struct usbnet *dev)
+{
+        u8      reg;
+        u16     *vp = kmalloc(sizeof (u16));
+
+        if (!vp) {
+                dbg("no memory?");
+                return;
+        }
+
+        dbg("%s registers:", dev->net->name);
+        for (reg = 0; reg < 0x20; reg++) {
+                int retval;
+
+                // reading some registers is trouble
+                if (reg >= 0x08 && reg <= 0xf)
+                        continue;
+                if (reg >= 0x12 && reg <= 0x1e)
+                        continue;
+
+                retval = nc_register_read(dev, reg, vp);
+                if (retval < 0)
+                        dbg("%s reg [0x%x] ==> error %d",
+                                dev->net->name, reg, retval);
+                else
+                        dbg("%s reg [0x%x] = 0x%x",
+                                dev->net->name, reg, *vp);
+        }
+        kfree(vp);
+}
+#endif
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Control register
+ */
+
+#define USBCTL_WRITABLE_MASK    0x1f0f
+// bits 15-13 reserved, r/o
+#define USBCTL_ENABLE_LANG      (1 << 12)
+#define USBCTL_ENABLE_MFGR      (1 << 11)
+#define USBCTL_ENABLE_PROD      (1 << 10)
+#define USBCTL_ENABLE_SERIAL    (1 << 9)
+#define USBCTL_ENABLE_DEFAULTS  (1 << 8)
+// bits 7-4 reserved, r/o
+#define USBCTL_FLUSH_OTHER      (1 << 3)
+#define USBCTL_FLUSH_THIS       (1 << 2)
+#define USBCTL_DISCONN_OTHER    (1 << 1)
+#define USBCTL_DISCONN_THIS     (1 << 0)
+
+static inline void nc_dump_usbctl(struct usbnet *dev, u16 usbctl)
+{
+        if (!netif_msg_link(dev))
+                return;
+        devdbg(dev, "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s;"
+                        " this%s%s;"
+                        " other%s%s; r/o 0x%x",
+                dev->udev->bus->bus_name, dev->udev->devpath,
+                usbctl,
+                (usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
+                (usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
+                (usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
+                (usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
+                (usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",
+
+                (usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
+                (usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",
+                (usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
+                (usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",
+                usbctl & ~USBCTL_WRITABLE_MASK
+                );
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Status register
+ */
+
+#define STATUS_PORT_A           (1 << 15)
+
+#define STATUS_CONN_OTHER       (1 << 14)
+#define STATUS_SUSPEND_OTHER    (1 << 13)
+#define STATUS_MAILBOX_OTHER    (1 << 12)
+#define STATUS_PACKETS_OTHER(n) (((n) >> 8) && 0x03)
+
+#define STATUS_CONN_THIS        (1 << 6)
+#define STATUS_SUSPEND_THIS     (1 << 5)
+#define STATUS_MAILBOX_THIS     (1 << 4)
+#define STATUS_PACKETS_THIS(n)  (((n) >> 0) && 0x03)
+
+#define STATUS_UNSPEC_MASK      0x0c8c
+#define STATUS_NOISE_MASK       ((u16)~(0x0303|STATUS_UNSPEC_MASK))
+
+
+static inline void nc_dump_status(struct usbnet *dev, u16 status)
+{
+        if (!netif_msg_link(dev))
+                return;
+        devdbg(dev, "net1080 %s-%s status 0x%x:"
+                        " this (%c) PKT=%d%s%s%s;"
+                        " other PKT=%d%s%s%s; unspec 0x%x",
+                dev->udev->bus->bus_name, dev->udev->devpath,
+                status,
+
+                // XXX the packet counts don't seem right
+                // (1 at reset, not 0); maybe UNSPEC too
+
+                (status & STATUS_PORT_A) ? 'A' : 'B',
+                STATUS_PACKETS_THIS(status),
+                (status & STATUS_CONN_THIS) ? " CON" : "",
+                (status & STATUS_SUSPEND_THIS) ? " SUS" : "",
+                (status & STATUS_MAILBOX_THIS) ? " MBOX" : "",
+
+                STATUS_PACKETS_OTHER(status),
+                (status & STATUS_CONN_OTHER) ? " CON" : "",
+                (status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
+                (status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",
+
+                status & STATUS_UNSPEC_MASK
+                );
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * TTL register
+ */
+
+#define TTL_THIS(ttl)   (0x00ff & ttl)
+#define TTL_OTHER(ttl)  (0x00ff & (ttl >> 8))
+#define MK_TTL(this,other)      ((u16)(((other)<<8)|(0x00ff&(this))))
+
+static inline void nc_dump_ttl(struct usbnet *dev, u16 ttl)
+{
+        if (netif_msg_link(dev))
+                devdbg(dev, "net1080 %s-%s ttl 0x%x this = %d, other = %d",
+                        dev->udev->bus->bus_name, dev->udev->devpath,
+                        ttl, TTL_THIS(ttl), TTL_OTHER(ttl));
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int net1080_reset(struct usbnet *dev)
+{
+        u16             usbctl, status, ttl;
+        u16             *vp = kmalloc(sizeof (u16), GFP_KERNEL);
+        int             retval;
+
+        if (!vp)
+                return -ENOMEM;
+
+        // nc_dump_registers(dev);
+
+        if ((retval = nc_register_read(dev, REG_STATUS, vp)) < 0) {
+                dbg("can't read %s-%s status: %d",
+                        dev->udev->bus->bus_name, dev->udev->devpath, retval);
+                goto done;
+        }
+        status = *vp;
+        nc_dump_status(dev, status);
+
+        if ((retval = nc_register_read(dev, REG_USBCTL, vp)) < 0) {
+                dbg("can't read USBCTL, %d", retval);
+                goto done;
+        }
+        usbctl = *vp;
+        nc_dump_usbctl(dev, usbctl);
+
+        nc_register_write(dev, REG_USBCTL,
+                        USBCTL_FLUSH_THIS | USBCTL_FLUSH_OTHER);
+
+        if ((retval = nc_register_read(dev, REG_TTL, vp)) < 0) {
+                dbg("can't read TTL, %d", retval);
+                goto done;
+        }
+        ttl = *vp;
+        // nc_dump_ttl(dev, ttl);
+
+        nc_register_write(dev, REG_TTL,
+                        MK_TTL(NC_READ_TTL_MS, TTL_OTHER(ttl)) );
+        dbg("%s: assigned TTL, %d ms", dev->net->name, NC_READ_TTL_MS);
+
+        if (netif_msg_link(dev))
+                devinfo(dev, "port %c, peer %sconnected",
+                        (status & STATUS_PORT_A) ? 'A' : 'B',
+                        (status & STATUS_CONN_OTHER) ? "" : "dis"
+                        );
+        retval = 0;
+
+done:
+        kfree(vp);
+        return retval;
+}
+
+static int net1080_check_connect(struct usbnet *dev)
+{
+        int                     retval;
+        u16                     status;
+        u16                     *vp = kmalloc(sizeof (u16), GFP_KERNEL);
+
+        if (!vp)
+                return -ENOMEM;
+        retval = nc_register_read(dev, REG_STATUS, vp);
+        status = *vp;
+        kfree(vp);
+        if (retval != 0) {
+                dbg("%s net1080_check_conn read - %d", dev->net->name, retval);
+                return retval;
+        }
+        if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
+                return -ENOLINK;
+        return 0;
+}
+
+static void nc_flush_complete(struct urb *urb, struct pt_regs *regs)
+{
+        kfree(urb->context);
+        usb_free_urb(urb);
+}
+
+static void nc_ensure_sync(struct usbnet *dev)
+{
+        dev->frame_errors++;
+        if (dev->frame_errors > 5) {
+                struct urb              *urb;
+                struct usb_ctrlrequest  *req;
+                int                     status;
+
+                /* Send a flush */
+                urb = usb_alloc_urb(0, SLAB_ATOMIC);
+                if (!urb)
+                        return;
+
+                req = kmalloc(sizeof *req, GFP_ATOMIC);
+                if (!req) {
+                        usb_free_urb(urb);
+                        return;
+                }
+
+                req->bRequestType = USB_DIR_OUT
+                        | USB_TYPE_VENDOR
+                        | USB_RECIP_DEVICE;
+                req->bRequest = REQUEST_REGISTER;
+                req->wValue = cpu_to_le16(USBCTL_FLUSH_THIS
+                                | USBCTL_FLUSH_OTHER);
+                req->wIndex = cpu_to_le16(REG_USBCTL);
+                req->wLength = cpu_to_le16(0);
+
+                /* queue an async control request, we don't need
+                 * to do anything when it finishes except clean up.
+                 */
+                usb_fill_control_urb(urb, dev->udev,
+                        usb_sndctrlpipe(dev->udev, 0),
+                        (unsigned char *) req,
+                        NULL, 0,
+                        nc_flush_complete, req);
+                status = usb_submit_urb(urb, GFP_ATOMIC);
+                if (status) {
+                        kfree(req);
+                        usb_free_urb(urb);
+                        return;
+                }
+
+                if (netif_msg_rx_err(dev))
+                        devdbg(dev, "flush net1080; too many framing errors");
+                dev->frame_errors = 0;
+        }
+}
+
+static int net1080_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        struct nc_header        *header;
+        struct nc_trailer       *trailer;
+        u16                     hdr_len, packet_len;
+
+        if (!(skb->len & 0x01)) {
+#ifdef DEBUG
+                struct net_device       *net = dev->net;
+                dbg("rx framesize %d range %d..%d mtu %d", skb->len,
+                        net->hard_header_len, dev->hard_mtu, net->mtu);
+#endif
+                dev->stats.rx_frame_errors++;
+                nc_ensure_sync(dev);
+                return 0;
+        }
+
+        header = (struct nc_header *) skb->data;
+        hdr_len = le16_to_cpup(&header->hdr_len);
+        packet_len = le16_to_cpup(&header->packet_len);
+        if (FRAMED_SIZE(packet_len) > NC_MAX_PACKET) {
+                dev->stats.rx_frame_errors++;
+                dbg("packet too big, %d", packet_len);
+                nc_ensure_sync(dev);
+                return 0;
+        } else if (hdr_len < MIN_HEADER) {
+                dev->stats.rx_frame_errors++;
+                dbg("header too short, %d", hdr_len);
+                nc_ensure_sync(dev);
+                return 0;
+        } else if (hdr_len > MIN_HEADER) {
+                // out of band data for us?
+                dbg("header OOB, %d bytes", hdr_len - MIN_HEADER);
+                nc_ensure_sync(dev);
+                // switch (vendor/product ids) { ... }
+        }
+        skb_pull(skb, hdr_len);
+
+        trailer = (struct nc_trailer *)
+                (skb->data + skb->len - sizeof *trailer);
+        skb_trim(skb, skb->len - sizeof *trailer);
+
+        if ((packet_len & 0x01) == 0) {
+                if (skb->data [packet_len] != PAD_BYTE) {
+                        dev->stats.rx_frame_errors++;
+                        dbg("bad pad");
+                        return 0;
+                }
+                skb_trim(skb, skb->len - 1);
+        }
+        if (skb->len != packet_len) {
+                dev->stats.rx_frame_errors++;
+                dbg("bad packet len %d (expected %d)",
+                        skb->len, packet_len);
+                nc_ensure_sync(dev);
+                return 0;
+        }
+        if (header->packet_id != get_unaligned(&trailer->packet_id)) {
+                dev->stats.rx_fifo_errors++;
+                dbg("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
+                        le16_to_cpu(header->packet_id),
+                        le16_to_cpu(trailer->packet_id));
+                return 0;
+        }
+#if 0
+        devdbg(dev, "frame <rx h %d p %d id %d", header->hdr_len,
+                header->packet_len, header->packet_id);
+#endif
+        dev->frame_errors = 0;
+        return 1;
+}
+
+static struct sk_buff *
+net1080_tx_fixup(struct usbnet *dev, struct sk_buff *skb, unsigned flags)
+{
+        int                     padlen;
+        struct sk_buff          *skb2;
+        struct nc_header        *header = NULL;
+        struct nc_trailer       *trailer = NULL;
+        int                     len = skb->len;
+
+        padlen = ((len + sizeof (struct nc_header)
+                        + sizeof (struct nc_trailer)) & 0x01) ? 0 : 1;
+        if (!skb_cloned(skb)) {
+                int     headroom = skb_headroom(skb);
+                int     tailroom = skb_tailroom(skb);
+
+                if ((padlen + sizeof (struct nc_trailer)) <= tailroom
+                            && sizeof (struct nc_header) <= headroom)
+                        /* There's enough head and tail room */
+                        goto encapsulate;
+
+                if ((sizeof (struct nc_header) + padlen
+                                        + sizeof (struct nc_trailer)) <
+                                (headroom + tailroom)) {
+                        /* There's enough total room, so just readjust */
+                        skb->data = memmove(skb->head
+                                                + sizeof (struct nc_header),
+                                            skb->data, skb->len);
+                        skb->tail = skb->data + len;
+                        goto encapsulate;
+                }
+        }
+
+        /* Create a new skb to use with the correct size */
+        skb2 = skb_copy_expand(skb,
+                                sizeof (struct nc_header),
+                                sizeof (struct nc_trailer) + padlen,
+                                flags);
+        dev_kfree_skb_any(skb);
+        if (!skb2)
+                return skb2;
+        skb = skb2;
+
+encapsulate:
+        /* header first */
+        header = (struct nc_header *) skb_push(skb, sizeof *header);
+        header->hdr_len = cpu_to_le16(sizeof (*header));
+        header->packet_len = cpu_to_le16(len);
+        header->packet_id = cpu_to_le16((u16)dev->xid++);
+
+        /* maybe pad; then trailer */
+        if (!((skb->len + sizeof *trailer) & 0x01))
+                *skb_put(skb, 1) = PAD_BYTE;
+        trailer = (struct nc_trailer *) skb_put(skb, sizeof *trailer);
+        put_unaligned(header->packet_id, &trailer->packet_id);
+#if 0
+        devdbg(dev, "frame >tx h %d p %d id %d",
+                header->hdr_len, header->packet_len,
+                header->packet_id);
+#endif
+        return skb;
+}
+
+static int net1080_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        unsigned        extra = sizeof (struct nc_header)
+                                + 1
+                                + sizeof (struct nc_trailer);
+
+        dev->net->hard_header_len += extra;
+        dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
+        dev->hard_mtu = NC_MAX_PACKET;
+        return usbnet_get_endpoints (dev, intf);
+}
+
+static const struct driver_info net1080_info = {
+        .description =  "NetChip TurboCONNECT",
+        .flags =        FLAG_FRAMING_NC,
+        .bind =         net1080_bind,
+        .reset =        net1080_reset,
+        .check_connect = net1080_check_connect,
+        .rx_fixup =     net1080_rx_fixup,
+        .tx_fixup =     net1080_tx_fixup,
+};
+
+static const struct usb_device_id       products [] = {
+{
+        USB_DEVICE(0x0525, 0x1080),     // NetChip ref design
+        .driver_info =  (unsigned long) &net1080_info,
+}, {
+        USB_DEVICE(0x06D0, 0x0622),     // Laplink Gold
+        .driver_info =  (unsigned long) &net1080_info,
+},
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver net1080_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "net1080",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+static int __init net1080_init(void)
+{
+        return usb_register(&net1080_driver);
+}
+module_init(net1080_init);
+
+static void __exit net1080_exit(void)
+{
+        usb_deregister(&net1080_driver);
+}
+module_exit(net1080_exit);
+
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("NetChip 1080 based USB Host-to-Host Links");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/pegasus.c b/drivers/usb/net/pegasus.c
index fcd6d3ccef44..7484d34780fc 100644
--- a/drivers/usb/net/pegasus.c
+++ b/drivers/usb/net/pegasus.c
@@ -825,7 +825,6 @@ static void pegasus_tx_timeout(struct net_device *net)
         pegasus_t *pegasus = netdev_priv(net);
         if (netif_msg_timer(pegasus))
                 printk(KERN_WARNING "%s: tx timeout\n", net->name);
-        pegasus->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
         usb_unlink_urb(pegasus->tx_urb);
         pegasus->stats.tx_errors++;
 }
diff --git a/drivers/usb/net/plusb.c b/drivers/usb/net/plusb.c
new file mode 100644
index 000000000000..74c2b3581c76
--- /dev/null
+++ b/drivers/usb/net/plusb.c
@@ -0,0 +1,156 @@
+/*
+ * PL-2301/2302 USB host-to-host link cables
+ * Copyright (C) 2000-2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+
+#include "usbnet.h"
+
+
+/*
+ * Prolific PL-2301/PL-2302 driver ... http://www.prolifictech.com
+ *
+ * The protocol and handshaking used here should be bug-compatible
+ * with the Linux 2.2 "plusb" driver, by Deti Fliegl.
+ *
+ * HEADS UP:  this handshaking isn't all that robust.  This driver
+ * gets confused easily if you unplug one end of the cable then
+ * try to connect it again; you'll need to restart both ends. The
+ * "naplink" software (used by some PlayStation/2 deveopers) does
+ * the handshaking much better!   Also, sometimes this hardware
+ * seems to get wedged under load.  Prolific docs are weak, and
+ * don't identify differences between PL2301 and PL2302, much less
+ * anything to explain the different PL2302 versions observed.
+ */
+
+/*
+ * Bits 0-4 can be used for software handshaking; they're set from
+ * one end, cleared from the other, "read" with the interrupt byte.
+ */
+#define PL_S_EN         (1<<7)          /* (feature only) suspend enable */
+/* reserved bit -- rx ready (6) ? */
+#define PL_TX_READY     (1<<5)          /* (interrupt only) transmit ready */
+#define PL_RESET_OUT    (1<<4)          /* reset output pipe */
+#define PL_RESET_IN     (1<<3)          /* reset input pipe */
+#define PL_TX_C         (1<<2)          /* transmission complete */
+#define PL_TX_REQ       (1<<1)          /* transmission received */
+#define PL_PEER_E       (1<<0)          /* peer exists */
+
+static inline int
+pl_vendor_req(struct usbnet *dev, u8 req, u8 val, u8 index)
+{
+        return usb_control_msg(dev->udev,
+                usb_rcvctrlpipe(dev->udev, 0),
+                req,
+                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                val, index,
+                NULL, 0,
+                USB_CTRL_GET_TIMEOUT);
+}
+
+static inline int
+pl_clear_QuickLink_features(struct usbnet *dev, int val)
+{
+        return pl_vendor_req(dev, 1, (u8) val, 0);
+}
+
+static inline int
+pl_set_QuickLink_features(struct usbnet *dev, int val)
+{
+        return pl_vendor_req(dev, 3, (u8) val, 0);
+}
+
+static int pl_reset(struct usbnet *dev)
+{
+        /* some units seem to need this reset, others reject it utterly.
+         * FIXME be more like "naplink" or windows drivers.
+         */
+        (void) pl_set_QuickLink_features(dev,
+                PL_S_EN|PL_RESET_OUT|PL_RESET_IN|PL_PEER_E);
+        return 0;
+}
+
+static const struct driver_info prolific_info = {
+        .description =  "Prolific PL-2301/PL-2302",
+        .flags =        FLAG_NO_SETINT,
+                /* some PL-2302 versions seem to fail usb_set_interface() */
+        .reset =        pl_reset,
+};
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Proilific's name won't normally be on the cables, and
+ * may not be on the device.
+ */
+
+static const struct usb_device_id       products [] = {
+
+{
+        USB_DEVICE(0x067b, 0x0000),     // PL-2301
+        .driver_info =  (unsigned long) &prolific_info,
+}, {
+        USB_DEVICE(0x067b, 0x0001),     // PL-2302
+        .driver_info =  (unsigned long) &prolific_info,
+},
+
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver plusb_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "plusb",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+static int __init plusb_init(void)
+{
+        return usb_register(&plusb_driver);
+}
+module_init(plusb_init);
+
+static void __exit plusb_exit(void)
+{
+        usb_deregister(&plusb_driver);
+}
+module_exit(plusb_exit);
+
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("Prolific PL-2301/2302 USB Host to Host Link Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/rndis_host.c b/drivers/usb/net/rndis_host.c
new file mode 100644
index 000000000000..2ed2e5fb7778
--- /dev/null
+++ b/drivers/usb/net/rndis_host.c
@@ -0,0 +1,615 @@
+/*
+ * Host Side support for RNDIS Networking Links
+ * Copyright (C) 2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/usb.h>
+#include <linux/usb_cdc.h>
+
+#include "usbnet.h"
+
+
+/*
+ * RNDIS is NDIS remoted over USB.  It's a MSFT variant of CDC ACM ... of
+ * course ACM was intended for modems, not Ethernet links!  USB's standard
+ * for Ethernet links is "CDC Ethernet", which is significantly simpler.
+ */
+
+/*
+ * CONTROL uses CDC "encapsulated commands" with funky notifications.
+ *  - control-out:  SEND_ENCAPSULATED
+ *  - interrupt-in:  RESPONSE_AVAILABLE
+ *  - control-in:  GET_ENCAPSULATED
+ *
+ * We'll try to ignore the RESPONSE_AVAILABLE notifications.
+ */
+struct rndis_msg_hdr {
+        __le32  msg_type;                       /* RNDIS_MSG_* */
+        __le32  msg_len;
+        // followed by data that varies between messages
+        __le32  request_id;
+        __le32  status;
+        // ... and more
+} __attribute__ ((packed));
+
+/* RNDIS defines this (absurdly huge) control timeout */
+#define RNDIS_CONTROL_TIMEOUT_MS        (10 * 1000)
+
+
+#define ccpu2 __constant_cpu_to_le32
+
+#define RNDIS_MSG_COMPLETION    ccpu2(0x80000000)
+
+/* codes for "msg_type" field of rndis messages;
+ * only the data channel uses packet messages (maybe batched);
+ * everything else goes on the control channel.
+ */
+#define RNDIS_MSG_PACKET        ccpu2(0x00000001)       /* 1-N packets */
+#define RNDIS_MSG_INIT          ccpu2(0x00000002)
+#define RNDIS_MSG_INIT_C        (RNDIS_MSG_INIT|RNDIS_MSG_COMPLETION)
+#define RNDIS_MSG_HALT          ccpu2(0x00000003)
+#define RNDIS_MSG_QUERY         ccpu2(0x00000004)
+#define RNDIS_MSG_QUERY_C       (RNDIS_MSG_QUERY|RNDIS_MSG_COMPLETION)
+#define RNDIS_MSG_SET           ccpu2(0x00000005)
+#define RNDIS_MSG_SET_C         (RNDIS_MSG_SET|RNDIS_MSG_COMPLETION)
+#define RNDIS_MSG_RESET         ccpu2(0x00000006)
+#define RNDIS_MSG_RESET_C       (RNDIS_MSG_RESET|RNDIS_MSG_COMPLETION)
+#define RNDIS_MSG_INDICATE      ccpu2(0x00000007)
+#define RNDIS_MSG_KEEPALIVE     ccpu2(0x00000008)
+#define RNDIS_MSG_KEEPALIVE_C   (RNDIS_MSG_KEEPALIVE|RNDIS_MSG_COMPLETION)
+
+/* codes for "status" field of completion messages */
+#define RNDIS_STATUS_SUCCESS            ccpu2(0x00000000)
+#define RNDIS_STATUS_FAILURE            ccpu2(0xc0000001)
+#define RNDIS_STATUS_INVALID_DATA       ccpu2(0xc0010015)
+#define RNDIS_STATUS_NOT_SUPPORTED      ccpu2(0xc00000bb)
+#define RNDIS_STATUS_MEDIA_CONNECT      ccpu2(0x4001000b)
+#define RNDIS_STATUS_MEDIA_DISCONNECT   ccpu2(0x4001000c)
+
+
+struct rndis_data_hdr {
+        __le32  msg_type;               /* RNDIS_MSG_PACKET */
+        __le32  msg_len;                // rndis_data_hdr + data_len + pad
+        __le32  data_offset;            // 36 -- right after header
+        __le32  data_len;               // ... real packet size
+
+        __le32  oob_data_offset;        // zero
+        __le32  oob_data_len;           // zero
+        __le32  num_oob;                // zero
+        __le32  packet_data_offset;     // zero
+
+        __le32  packet_data_len;        // zero
+        __le32  vc_handle;              // zero
+        __le32  reserved;               // zero
+} __attribute__ ((packed));
+
+struct rndis_init {             /* OUT */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_INIT */
+        __le32  msg_len;                        // 24
+        __le32  request_id;
+        __le32  major_version;                  // of rndis (1.0)
+        __le32  minor_version;
+        __le32  max_transfer_size;
+} __attribute__ ((packed));
+
+struct rndis_init_c {           /* IN */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_INIT_C */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  status;
+        __le32  major_version;                  // of rndis (1.0)
+        __le32  minor_version;
+        __le32  device_flags;
+        __le32  medium;                         // zero == 802.3
+        __le32  max_packets_per_message;
+        __le32  max_transfer_size;
+        __le32  packet_alignment;               // max 7; (1<<n) bytes
+        __le32  af_list_offset;                 // zero
+        __le32  af_list_size;                   // zero
+} __attribute__ ((packed));
+
+struct rndis_halt {             /* OUT (no reply) */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_HALT */
+        __le32  msg_len;
+        __le32  request_id;
+} __attribute__ ((packed));
+
+struct rndis_query {            /* OUT */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_QUERY */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  oid;
+        __le32  len;
+        __le32  offset;
+/*?*/   __le32  handle;                         // zero
+} __attribute__ ((packed));
+
+struct rndis_query_c {          /* IN */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_QUERY_C */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  status;
+        __le32  len;
+        __le32  offset;
+} __attribute__ ((packed));
+
+struct rndis_set {              /* OUT */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_SET */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  oid;
+        __le32  len;
+        __le32  offset;
+/*?*/   __le32  handle;                         // zero
+} __attribute__ ((packed));
+
+struct rndis_set_c {            /* IN */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_SET_C */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  status;
+} __attribute__ ((packed));
+
+struct rndis_reset {            /* IN */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_RESET */
+        __le32  msg_len;
+        __le32  reserved;
+} __attribute__ ((packed));
+
+struct rndis_reset_c {          /* OUT */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_RESET_C */
+        __le32  msg_len;
+        __le32  status;
+        __le32  addressing_lost;
+} __attribute__ ((packed));
+
+struct rndis_indicate {         /* IN (unrequested) */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_INDICATE */
+        __le32  msg_len;
+        __le32  status;
+        __le32  length;
+        __le32  offset;
+/**/    __le32  diag_status;
+        __le32  error_offset;
+/**/    __le32  message;
+} __attribute__ ((packed));
+
+struct rndis_keepalive {        /* OUT (optionally IN) */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_KEEPALIVE */
+        __le32  msg_len;
+        __le32  request_id;
+} __attribute__ ((packed));
+
+struct rndis_keepalive_c {      /* IN (optionally OUT) */
+        // header and:
+        __le32  msg_type;                       /* RNDIS_MSG_KEEPALIVE_C */
+        __le32  msg_len;
+        __le32  request_id;
+        __le32  status;
+} __attribute__ ((packed));
+
+/* NOTE:  about 30 OIDs are "mandatory" for peripherals to support ... and
+ * there are gobs more that may optionally be supported.  We'll avoid as much
+ * of that mess as possible.
+ */
+#define OID_802_3_PERMANENT_ADDRESS     ccpu2(0x01010101)
+#define OID_GEN_CURRENT_PACKET_FILTER   ccpu2(0x0001010e)
+
+/*
+ * RNDIS notifications from device: command completion; "reverse"
+ * keepalives; etc
+ */
+static void rndis_status(struct usbnet *dev, struct urb *urb)
+{
+        devdbg(dev, "rndis status urb, len %d stat %d",
+                urb->actual_length, urb->status);
+        // FIXME for keepalives, respond immediately (asynchronously)
+        // if not an RNDIS status, do like cdc_status(dev,urb) does
+}
+
+/*
+ * RPC done RNDIS-style.  Caller guarantees:
+ * - message is properly byteswapped
+ * - there's no other request pending
+ * - buf can hold up to 1KB response (required by RNDIS spec)
+ * On return, the first few entries are already byteswapped.
+ *
+ * Call context is likely probe(), before interface name is known,
+ * which is why we won't try to use it in the diagnostics.
+ */
+static int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf)
+{
+        struct cdc_state        *info = (void *) &dev->data;
+        int                     retval;
+        unsigned                count;
+        __le32                  rsp;
+        u32                     xid = 0, msg_len, request_id;
+
+        /* REVISIT when this gets called from contexts other than probe() or
+         * disconnect(): either serialize, or dispatch responses on xid
+         */
+
+        /* Issue the request; don't bother byteswapping our xid */
+        if (likely(buf->msg_type != RNDIS_MSG_HALT
+                        && buf->msg_type != RNDIS_MSG_RESET)) {
+                xid = dev->xid++;
+                if (!xid)
+                        xid = dev->xid++;
+                buf->request_id = (__force __le32) xid;
+        }
+        retval = usb_control_msg(dev->udev,
+                usb_sndctrlpipe(dev->udev, 0),
+                USB_CDC_SEND_ENCAPSULATED_COMMAND,
+                USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                0, info->u->bMasterInterface0,
+                buf, le32_to_cpu(buf->msg_len),
+                RNDIS_CONTROL_TIMEOUT_MS);
+        if (unlikely(retval < 0 || xid == 0))
+                return retval;
+
+        // FIXME Seems like some devices discard responses when
+        // we time out and cancel our "get response" requests...
+        // so, this is fragile.  Probably need to poll for status.
+
+        /* ignore status endpoint, just poll the control channel;
+         * the request probably completed immediately
+         */
+        rsp = buf->msg_type | RNDIS_MSG_COMPLETION;
+        for (count = 0; count < 10; count++) {
+                memset(buf, 0, 1024);
+                retval = usb_control_msg(dev->udev,
+                        usb_rcvctrlpipe(dev->udev, 0),
+                        USB_CDC_GET_ENCAPSULATED_RESPONSE,
+                        USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                        0, info->u->bMasterInterface0,
+                        buf, 1024,
+                        RNDIS_CONTROL_TIMEOUT_MS);
+                if (likely(retval >= 8)) {
+                        msg_len = le32_to_cpu(buf->msg_len);
+                        request_id = (__force u32) buf->request_id;
+                        if (likely(buf->msg_type == rsp)) {
+                                if (likely(request_id == xid)) {
+                                        if (unlikely(rsp == RNDIS_MSG_RESET_C))
+                                                return 0;
+                                        if (likely(RNDIS_STATUS_SUCCESS
+                                                        == buf->status))
+                                                return 0;
+                                        dev_dbg(&info->control->dev,
+                                                "rndis reply status %08x\n",
+                                                le32_to_cpu(buf->status));
+                                        return -EL3RST;
+                                }
+                                dev_dbg(&info->control->dev,
+                                        "rndis reply id %d expected %d\n",
+                                        request_id, xid);
+                                /* then likely retry */
+                        } else switch (buf->msg_type) {
+                        case RNDIS_MSG_INDICATE: {      /* fault */
+                                // struct rndis_indicate *msg = (void *)buf;
+                                dev_info(&info->control->dev,
+                                         "rndis fault indication\n");
+                                }
+                                break;
+                        case RNDIS_MSG_KEEPALIVE: {     /* ping */
+                                struct rndis_keepalive_c *msg = (void *)buf;
+
+                                msg->msg_type = RNDIS_MSG_KEEPALIVE_C;
+                                msg->msg_len = ccpu2(sizeof *msg);
+                                msg->status = RNDIS_STATUS_SUCCESS;
+                                retval = usb_control_msg(dev->udev,
+                                        usb_sndctrlpipe(dev->udev, 0),
+                                        USB_CDC_SEND_ENCAPSULATED_COMMAND,
+                                        USB_TYPE_CLASS | USB_RECIP_INTERFACE,
+                                        0, info->u->bMasterInterface0,
+                                        msg, sizeof *msg,
+                                        RNDIS_CONTROL_TIMEOUT_MS);
+                                if (unlikely(retval < 0))
+                                        dev_dbg(&info->control->dev,
+                                                "rndis keepalive err %d\n",
+                                                retval);
+                                }
+                                break;
+                        default:
+                                dev_dbg(&info->control->dev,
+                                        "unexpected rndis msg %08x len %d\n",
+                                        le32_to_cpu(buf->msg_type), msg_len);
+                        }
+                } else {
+                        /* device probably issued a protocol stall; ignore */
+                        dev_dbg(&info->control->dev,
+                                "rndis response error, code %d\n", retval);
+                }
+                msleep(2);
+        }
+        dev_dbg(&info->control->dev, "rndis response timeout\n");
+        return -ETIMEDOUT;
+}
+
+static int rndis_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        int                     retval;
+        struct net_device       *net = dev->net;
+        union {
+                void                    *buf;
+                struct rndis_msg_hdr    *header;
+                struct rndis_init       *init;
+                struct rndis_init_c     *init_c;
+                struct rndis_query      *get;
+                struct rndis_query_c    *get_c;
+                struct rndis_set        *set;
+                struct rndis_set_c      *set_c;
+        } u;
+        u32                     tmp;
+
+        /* we can't rely on i/o from stack working, or stack allocation */
+        u.buf = kmalloc(1024, GFP_KERNEL);
+        if (!u.buf)
+                return -ENOMEM;
+        retval = usbnet_generic_cdc_bind(dev, intf);
+        if (retval < 0)
+                goto done;
+
+        net->hard_header_len += sizeof (struct rndis_data_hdr);
+
+        /* initialize; max transfer is 16KB at full speed */
+        u.init->msg_type = RNDIS_MSG_INIT;
+        u.init->msg_len = ccpu2(sizeof *u.init);
+        u.init->major_version = ccpu2(1);
+        u.init->minor_version = ccpu2(0);
+        u.init->max_transfer_size = ccpu2(net->mtu + net->hard_header_len);
+
+        retval = rndis_command(dev, u.header);
+        if (unlikely(retval < 0)) {
+                /* it might not even be an RNDIS device!! */
+                dev_err(&intf->dev, "RNDIS init failed, %d\n", retval);
+fail:
+                usb_driver_release_interface(driver_of(intf),
+                        ((struct cdc_state *)&(dev->data))->data);
+                goto done;
+        }
+        dev->hard_mtu = le32_to_cpu(u.init_c->max_transfer_size);
+        /* REVISIT:  peripheral "alignment" request is ignored ... */
+        dev_dbg(&intf->dev, "hard mtu %u, align %d\n", dev->hard_mtu,
+                1 << le32_to_cpu(u.init_c->packet_alignment));
+
+        /* get designated host ethernet address */
+        memset(u.get, 0, sizeof *u.get);
+        u.get->msg_type = RNDIS_MSG_QUERY;
+        u.get->msg_len = ccpu2(sizeof *u.get);
+        u.get->oid = OID_802_3_PERMANENT_ADDRESS;
+
+        retval = rndis_command(dev, u.header);
+        if (unlikely(retval < 0)) {
+                dev_err(&intf->dev, "rndis get ethaddr, %d\n", retval);
+                goto fail;
+        }
+        tmp = le32_to_cpu(u.get_c->offset);
+        if (unlikely((tmp + 8) > (1024 - ETH_ALEN)
+                        || u.get_c->len != ccpu2(ETH_ALEN))) {
+                dev_err(&intf->dev, "rndis ethaddr off %d len %d ?\n",
+                        tmp, le32_to_cpu(u.get_c->len));
+                retval = -EDOM;
+                goto fail;
+        }
+        memcpy(net->dev_addr, tmp + (char *)&u.get_c->request_id, ETH_ALEN);
+
+        /* set a nonzero filter to enable data transfers */
+        memset(u.set, 0, sizeof *u.set);
+        u.set->msg_type = RNDIS_MSG_SET;
+        u.set->msg_len = ccpu2(4 + sizeof *u.set);
+        u.set->oid = OID_GEN_CURRENT_PACKET_FILTER;
+        u.set->len = ccpu2(4);
+        u.set->offset = ccpu2((sizeof *u.set) - 8);
+        *(__le32 *)(u.buf + sizeof *u.set) = ccpu2(DEFAULT_FILTER);
+
+        retval = rndis_command(dev, u.header);
+        if (unlikely(retval < 0)) {
+                dev_err(&intf->dev, "rndis set packet filter, %d\n", retval);
+                goto fail;
+        }
+
+        retval = 0;
+done:
+        kfree(u.buf);
+        return retval;
+}
+
+static void rndis_unbind(struct usbnet *dev, struct usb_interface *intf)
+{
+        struct rndis_halt       *halt;
+
+        /* try to clear any rndis state/activity (no i/o from stack!) */
+        halt = kcalloc(1, sizeof *halt, SLAB_KERNEL);
+        if (halt) {
+                halt->msg_type = RNDIS_MSG_HALT;
+                halt->msg_len = ccpu2(sizeof *halt);
+                (void) rndis_command(dev, (void *)halt);
+                kfree(halt);
+        }
+
+        return usbnet_cdc_unbind(dev, intf);
+}
+
+/*
+ * DATA -- host must not write zlps
+ */
+static int rndis_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
+{
+        /* peripheral may have batched packets to us... */
+        while (likely(skb->len)) {
+                struct rndis_data_hdr   *hdr = (void *)skb->data;
+                struct sk_buff          *skb2;
+                u32                     msg_len, data_offset, data_len;
+
+                msg_len = le32_to_cpu(hdr->msg_len);
+                data_offset = le32_to_cpu(hdr->data_offset);
+                data_len = le32_to_cpu(hdr->data_len);
+
+                /* don't choke if we see oob, per-packet data, etc */
+                if (unlikely(hdr->msg_type != RNDIS_MSG_PACKET
+                                || skb->len < msg_len
+                                || (data_offset + data_len + 8) > msg_len)) {
+                        dev->stats.rx_frame_errors++;
+                        devdbg(dev, "bad rndis message %d/%d/%d/%d, len %d",
+                                le32_to_cpu(hdr->msg_type),
+                                msg_len, data_offset, data_len, skb->len);
+                        return 0;
+                }
+                skb_pull(skb, 8 + data_offset);
+
+                /* at most one packet left? */
+                if (likely((data_len - skb->len) <= sizeof *hdr)) {
+                        skb_trim(skb, data_len);
+                        break;
+                }
+
+                /* try to return all the packets in the batch */
+                skb2 = skb_clone(skb, GFP_ATOMIC);
+                if (unlikely(!skb2))
+                        break;
+                skb_pull(skb, msg_len - sizeof *hdr);
+                skb_trim(skb2, data_len);
+                usbnet_skb_return(dev, skb2);
+        }
+
+        /* caller will usbnet_skb_return the remaining packet */
+        return 1;
+}
+
+static struct sk_buff *
+rndis_tx_fixup(struct usbnet *dev, struct sk_buff *skb, unsigned flags)
+{
+        struct rndis_data_hdr   *hdr;
+        struct sk_buff          *skb2;
+        unsigned                len = skb->len;
+
+        if (likely(!skb_cloned(skb))) {
+                int     room = skb_headroom(skb);
+
+                /* enough head room as-is? */
+                if (unlikely((sizeof *hdr) <= room))
+                        goto fill;
+
+                /* enough room, but needs to be readjusted? */
+                room += skb_tailroom(skb);
+                if (likely((sizeof *hdr) <= room)) {
+                        skb->data = memmove(skb->head + sizeof *hdr,
+                                            skb->data, len);
+                        skb->tail = skb->data + len;
+                        goto fill;
+                }
+        }
+
+        /* create a new skb, with the correct size (and tailpad) */
+        skb2 = skb_copy_expand(skb, sizeof *hdr, 1, flags);
+        dev_kfree_skb_any(skb);
+        if (unlikely(!skb2))
+                return skb2;
+        skb = skb2;
+
+        /* fill out the RNDIS header.  we won't bother trying to batch
+         * packets; Linux minimizes wasted bandwidth through tx queues.
+         */
+fill:
+        hdr = (void *) __skb_push(skb, sizeof *hdr);
+        memset(hdr, 0, sizeof *hdr);
+        hdr->msg_type = RNDIS_MSG_PACKET;
+        hdr->msg_len = cpu_to_le32(skb->len);
+        hdr->data_offset = ccpu2(sizeof(*hdr) - 8);
+        hdr->data_len = cpu_to_le32(len);
+
+        /* FIXME make the last packet always be short ... */
+        return skb;
+}
+
+
+static const struct driver_info rndis_info = {
+        .description =  "RNDIS device",
+        .flags =        FLAG_ETHER | FLAG_FRAMING_RN,
+        .bind =         rndis_bind,
+        .unbind =       rndis_unbind,
+        .status =       rndis_status,
+        .rx_fixup =     rndis_rx_fixup,
+        .tx_fixup =     rndis_tx_fixup,
+};
+
+#undef ccpu2
+
+
+/*-------------------------------------------------------------------------*/
+
+static const struct usb_device_id       products [] = {
+{
+        /* RNDIS is MSFT's un-official variant of CDC ACM */
+        USB_INTERFACE_INFO(USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
+        .driver_info = (unsigned long) &rndis_info,
+},
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver rndis_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "rndis_host",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+static int __init rndis_init(void)
+{
+        return usb_register(&rndis_driver);
+}
+module_init(rndis_init);
+
+static void __exit rndis_exit(void)
+{
+        usb_deregister(&rndis_driver);
+}
+module_exit(rndis_exit);
+
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("USB Host side RNDIS driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/rtl8150.c b/drivers/usb/net/rtl8150.c
index 59ab40ebb394..c3d4e3589e30 100644
--- a/drivers/usb/net/rtl8150.c
+++ b/drivers/usb/net/rtl8150.c
@@ -653,7 +653,6 @@ static void rtl8150_tx_timeout(struct net_device *netdev)
 {
         rtl8150_t *dev = netdev_priv(netdev);
         warn("%s: Tx timeout.", netdev->name);
-        dev->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
         usb_unlink_urb(dev->tx_urb);
         dev->stats.tx_errors++;
 }
diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c
index a2f67245f6da..6c460918d54f 100644
--- a/drivers/usb/net/usbnet.c
+++ b/drivers/usb/net/usbnet.c
@@ -1,10 +1,7 @@
 /*
- * USB Networking Links
- * Copyright (C) 2000-2005 by David Brownell <dbrownell@users.sourceforge.net>
- * Copyright (C) 2002 Pavel Machek <pavel@ucw.cz>
+ * USB Network driver infrastructure
+ * Copyright (C) 2000-2005 by David Brownell
  * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
- * Copyright (C) 2005 Phil Chang <pchang23@sbcglobal.net>
- * Copyright (c) 2002-2003 TiVo Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,95 +20,15 @@
 
 /*
  * This is a generic "USB networking" framework that works with several
- * kinds of full and high speed networking devices:
- *
- *   + USB host-to-host "network cables", used for IP-over-USB links.
- *     These are often used for Laplink style connectivity products.
- *      - AnchorChip 2720
- *      - Belkin, eTEK (interops with Win32 drivers)
- *      - GeneSys GL620USB-A
- *      - NetChip 1080 (interoperates with NetChip Win32 drivers)
- *      - Prolific PL-2301/2302 (replaces "plusb" driver)
- *      - KC Technology KC2190
- *
- *   + Smart USB devices can support such links directly, using Internet
- *     standard protocols instead of proprietary host-to-device links.
- *      - Linux PDAs like iPaq, Yopy, and Zaurus
- *      - The BLOB boot loader (for diskless booting)
- *      - Linux "gadgets", perhaps using PXA-2xx or Net2280 controllers
- *      - Devices using EPSON's sample USB firmware
- *      - CDC-Ethernet class devices, such as many cable modems
- *
- *   + Adapters to networks such as Ethernet.
- *      - AX8817X based USB 2.0 products
- *
- * Links to these devices can be bridged using Linux Ethernet bridging.
- * With minor exceptions, these all use similar USB framing for network
- * traffic, but need different protocols for control traffic.
- *
- * USB devices can implement their side of this protocol at the cost
- * of two bulk endpoints; it's not restricted to "cable" applications.
- * See the SA1110, Zaurus, or EPSON device/client support in this driver;
- * slave/target drivers such as "usb-eth" (on most SA-1100 PDAs) or
- * "g_ether" (in the Linux "gadget" framework) implement that behavior
- * within devices.
- *
- *
- * CHANGELOG:
- *
- * 13-sep-2000  experimental, new
- * 10-oct-2000  usb_device_id table created. 
- * 28-oct-2000  misc fixes; mostly, discard more TTL-mangled rx packets.
- * 01-nov-2000  usb_device_id table and probing api update by
- *              Adam J. Richter <adam@yggdrasil.com>.
- * 18-dec-2000  (db) tx watchdog, "net1080" renaming to "usbnet", device_info
- *              and prolific support, isolate net1080-specific bits, cleanup.
- *              fix unlink_urbs oops in D3 PM resume code path.
- *
- * 02-feb-2001  (db) fix tx skb sharing, packet length, match_flags, ...
- * 08-feb-2001  stubbed in "linuxdev", maybe the SA-1100 folk can use it;
- *              AnchorChips 2720 support (from spec) for testing;
- *              fix bit-ordering problem with ethernet multicast addr
- * 19-feb-2001  Support for clearing halt conditions. SA1100 UDC support
- *              updates. Oleg Drokin (green@iXcelerator.com)
- * 25-mar-2001  More SA-1100 updates, including workaround for ip problem
- *              expecting cleared skb->cb and framing change to match latest
- *              handhelds.org version (Oleg).  Enable device IDs from the
- *              Win32 Belkin driver; other cleanups (db).
- * 16-jul-2001  Bugfixes for uhci oops-on-unplug, Belkin support, various
- *              cleanups for problems not yet seen in the field. (db)
- * 17-oct-2001  Handle "Advance USBNET" product, like Belkin/eTEK devices,
- *              from Ioannis Mavroukakis <i.mavroukakis@btinternet.com>;
- *              rx unlinks somehow weren't async; minor cleanup.
- * 03-nov-2001  Merged GeneSys driver; original code from Jiun-Jie Huang
- *              <huangjj@genesyslogic.com.tw>, updated by Stanislav Brabec
- *              <utx@penguin.cz>.  Made framing options (NetChip/GeneSys)
- *              tie mostly to (sub)driver info.  Workaround some PL-2302
- *              chips that seem to reject SET_INTERFACE requests.
- *
- * 06-apr-2002  Added ethtool support, based on a patch from Brad Hards.
- *              Level of diagnostics is more configurable; they use device
- *              location (usb_device->devpath) instead of address (2.5).
- *              For tx_fixup, memflags can't be NOIO.
- * 07-may-2002  Generalize/cleanup keventd support, handling rx stalls (mostly
- *              for USB 2.0 TTs) and memory shortages (potential) too. (db)
- *              Use "locally assigned" IEEE802 address space. (Brad Hards)
- * 18-oct-2002  Support for Zaurus (Pavel Machek), related cleanup (db).
- * 14-dec-2002  Remove Zaurus-private crc32 code (Pavel); 2.5 oops fix,
- *              cleanups and stubbed PXA-250 support (db), fix for framing
- *              issues on Z, net1080, and gl620a (Toby Milne)
- *
- * 31-mar-2003  Use endpoint descriptors:  high speed support, simpler sa1100
- *              vs pxa25x, and CDC Ethernet.  Throttle down log floods on
- *              disconnect; other cleanups. (db)  Flush net1080 fifos
- *              after several sequential framing errors. (Johannes Erdfelt)
- * 22-aug-2003  AX8817X support (Dave Hollis).
- * 14-jun-2004  Trivial patch for AX8817X based Buffalo LUA-U2-KTX in Japan
- *              (Neil Bortnak)
- * 03-nov-2004  Trivial patch for KC2190 (KC-190) chip. (Jonathan McDowell)
- *
- * 01-feb-2005  AX88772 support (Phil Chang & Dave Hollis)
- *-------------------------------------------------------------------------*/
+ * kinds of full and high speed networking devices:  host-to-host cables,
+ * smart usb peripherals, and actual Ethernet adapters.
+ *
+ * These devices usually differ in terms of control protocols (if they
+ * even have one!) and sometimes they define new framing to wrap or batch
+ * Ethernet packets.  Otherwise, they talk to USB pretty much the same,
+ * so interface (un)binding, endpoint I/O queues, fault handling, and other
+ * issues can usefully be addressed by this framework.
+ */
 
 // #define      DEBUG                   // error path messages, extra info
 // #define      VERBOSE                 // more; success messages
@@ -121,24 +38,18 @@
 #   define DEBUG
 #endif
 #include <linux/module.h>
-#include <linux/kmod.h>
 #include <linux/sched.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
-#include <linux/random.h>
 #include <linux/ethtool.h>
 #include <linux/workqueue.h>
 #include <linux/mii.h>
-#include <asm/uaccess.h>
-#include <asm/unaligned.h>
 #include <linux/usb.h>
-#include <asm/io.h>
-#include <asm/scatterlist.h>
-#include <linux/mm.h>
-#include <linux/dma-mapping.h>
 
-#define DRIVER_VERSION          "03-Nov-2004"
+#include "usbnet.h"
+
+#define DRIVER_VERSION          "22-Aug-2005"
 
 
 /*-------------------------------------------------------------------------*/
@@ -149,15 +60,14 @@
  * One maximum size Ethernet packet takes twenty four of them.
  * For high speed, each frame comfortably fits almost 36 max size
  * Ethernet packets (so queues should be bigger).
+ *
+ * REVISIT qlens should be members of 'struct usbnet'; the goal is to
+ * let the USB host controller be busy for 5msec or more before an irq
+ * is required, under load.  Jumbograms change the equation.
  */
 #define RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? 60 : 4)
 #define TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? 60 : 4)
 
-// packets are always ethernet inside
-// ... except they can be bigger (limit of 64K with NetChip framing)
-#define MIN_PACKET      sizeof(struct ethhdr)
-#define MAX_PACKET      32768
-
 // reawaken network queue this soon after stopping; else watchdog barks
 #define TX_TIMEOUT_JIFFIES      (5*HZ)
 
@@ -165,9 +75,6 @@
 // us (it polls at HZ/4 usually) before we report too many false errors.
 #define THROTTLE_JIFFIES        (HZ/8)
 
-// for vendor-specific control operations
-#define CONTROL_TIMEOUT_MS      500
-
 // between wakeups
 #define UNLINK_TIMEOUT_MS       3
 
@@ -176,109 +83,6 @@
 // randomly generated ethernet address
 static u8       node_id [ETH_ALEN];
 
-// state we keep for each device we handle
-struct usbnet {
-        // housekeeping
-        struct usb_device       *udev;
-        struct driver_info      *driver_info;
-        wait_queue_head_t       *wait;
-
-        // i/o info: pipes etc
-        unsigned                in, out;
-        struct usb_host_endpoint *status;
-        unsigned                maxpacket;
-        struct timer_list       delay;
-
-        // protocol/interface state
-        struct net_device       *net;
-        struct net_device_stats stats;
-        int                     msg_enable;
-        unsigned long           data [5];
-
-        struct mii_if_info      mii;
-
-        // various kinds of pending driver work
-        struct sk_buff_head     rxq;
-        struct sk_buff_head     txq;
-        struct sk_buff_head     done;
-        struct urb              *interrupt;
-        struct tasklet_struct   bh;
-
-        struct work_struct      kevent;
-        unsigned long           flags;
-#               define EVENT_TX_HALT    0
-#               define EVENT_RX_HALT    1
-#               define EVENT_RX_MEMORY  2
-#               define EVENT_STS_SPLIT  3
-#               define EVENT_LINK_RESET 4
-};
-
-// device-specific info used by the driver
-struct driver_info {
-        char            *description;
-
-        int             flags;
-/* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */
-#define FLAG_FRAMING_NC 0x0001          /* guard against device dropouts */ 
-#define FLAG_FRAMING_GL 0x0002          /* genelink batches packets */
-#define FLAG_FRAMING_Z  0x0004          /* zaurus adds a trailer */
-#define FLAG_FRAMING_RN 0x0008          /* RNDIS batches, plus huge header */
-
-#define FLAG_NO_SETINT  0x0010          /* device can't set_interface() */
-#define FLAG_ETHER      0x0020          /* maybe use "eth%d" names */
-
-#define FLAG_FRAMING_AX 0x0040          /* AX88772/178 packets */
-
-        /* init device ... can sleep, or cause probe() failure */
-        int     (*bind)(struct usbnet *, struct usb_interface *);
-
-        /* cleanup device ... can sleep, but can't fail */
-        void    (*unbind)(struct usbnet *, struct usb_interface *);
-
-        /* reset device ... can sleep */
-        int     (*reset)(struct usbnet *);
-
-        /* see if peer is connected ... can sleep */
-        int     (*check_connect)(struct usbnet *);
-
-        /* for status polling */
-        void    (*status)(struct usbnet *, struct urb *);
-
-        /* link reset handling, called from defer_kevent */
-        int     (*link_reset)(struct usbnet *);
-
-        /* fixup rx packet (strip framing) */
-        int     (*rx_fixup)(struct usbnet *dev, struct sk_buff *skb);
-
-        /* fixup tx packet (add framing) */
-        struct sk_buff  *(*tx_fixup)(struct usbnet *dev,
-                                struct sk_buff *skb, int flags);
-
-        // FIXME -- also an interrupt mechanism
-        // useful for at least PL2301/2302 and GL620USB-A
-        // and CDC use them to report 'is it connected' changes
-
-        /* for new devices, use the descriptor-reading code instead */
-        int             in;             /* rx endpoint */
-        int             out;            /* tx endpoint */
-
-        unsigned long   data;           /* Misc driver specific data */
-};
-
-// we record the state for each of our queued skbs
-enum skb_state {
-        illegal = 0,
-        tx_start, tx_done,
-        rx_start, rx_done, rx_cleanup
-};
-
-struct skb_data {       // skb->cb is one of these
-        struct urb              *urb;
-        struct usbnet           *dev;
-        enum skb_state          state;
-        size_t                  length;
-};
-
 static const char driver_name [] = "usbnet";
 
 /* use ethtool to change the level for any given device */
@@ -286,39 +90,10 @@ static int msg_level = -1;
 module_param (msg_level, int, 0);
 MODULE_PARM_DESC (msg_level, "Override default message level");
 
-
-#ifdef DEBUG
-#define devdbg(usbnet, fmt, arg...) \
-        printk(KERN_DEBUG "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
-#else
-#define devdbg(usbnet, fmt, arg...) do {} while(0)
-#endif
-
-#define deverr(usbnet, fmt, arg...) \
-        printk(KERN_ERR "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
-#define devwarn(usbnet, fmt, arg...) \
-        printk(KERN_WARNING "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
-
-#define devinfo(usbnet, fmt, arg...) \
-        printk(KERN_INFO "%s: " fmt "\n" , (usbnet)->net->name , ## arg); \
-
 /*-------------------------------------------------------------------------*/
 
-static void usbnet_get_drvinfo (struct net_device *, struct ethtool_drvinfo *);
-static u32 usbnet_get_link (struct net_device *);
-static u32 usbnet_get_msglevel (struct net_device *);
-static void usbnet_set_msglevel (struct net_device *, u32);
-static void defer_kevent (struct usbnet *, int);
-
-/* mostly for PDA style devices, which are always connected if present */
-static int always_connected (struct usbnet *dev)
-{
-        return 0;
-}
-
 /* handles CDC Ethernet and many other network "bulk data" interfaces */
-static int
-get_endpoints (struct usbnet *dev, struct usb_interface *intf)
+int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
 {
         int                             tmp;
         struct usb_host_interface       *alt = NULL;
@@ -382,6 +157,7 @@ get_endpoints (struct usbnet *dev, struct usb_interface *intf)
         dev->status = status;
         return 0;
 }
+EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
 
 static void intr_complete (struct urb *urb, struct pt_regs *regs);
 
@@ -421,7 +197,11 @@ static int init_status (struct usbnet *dev, struct usb_interface *intf)
         return  0;
 }
 
-static void skb_return (struct usbnet *dev, struct sk_buff *skb)
+/* Passes this packet up the stack, updating its accounting.
+ * Some link protocols batch packets, so their rx_fixup paths
+ * can return clones as well as just modify the original skb.
+ */
+void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
 {
         int     status;
 
@@ -438,2425 +218,7 @@ static void skb_return (struct usbnet *dev, struct sk_buff *skb)
         if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev))
                 devdbg (dev, "netif_rx status %d", status);
 }
-
-
-#ifdef  CONFIG_USB_ALI_M5632
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * ALi M5632 driver ... does high speed
- *
- *-------------------------------------------------------------------------*/
-
-static const struct driver_info ali_m5632_info = {
-        .description =  "ALi M5632",
-};
-
-
-#endif
-
-
-#ifdef  CONFIG_USB_AN2720
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * AnchorChips 2720 driver ... http://www.cypress.com
- *
- * This doesn't seem to have a way to detect whether the peer is
- * connected, or need any reset handshaking.  It's got pretty big
- * internal buffers (handles most of a frame's worth of data).
- * Chip data sheets don't describe any vendor control messages.
- *
- *-------------------------------------------------------------------------*/
-
-static const struct driver_info an2720_info = {
-        .description =  "AnchorChips/Cypress 2720",
-        // no reset available!
-        // no check_connect available!
-
-        .in = 2, .out = 2,              // direction distinguishes these
-};
-
-#endif  /* CONFIG_USB_AN2720 */
-
-
-#ifdef CONFIG_USB_AX8817X
-/* ASIX AX8817X based USB 2.0 Ethernet Devices */
-
-#define HAVE_HARDWARE
-#define NEED_MII
-
-#include <linux/crc32.h>
-
-#define AX_CMD_SET_SW_MII               0x06
-#define AX_CMD_READ_MII_REG             0x07
-#define AX_CMD_WRITE_MII_REG            0x08
-#define AX_CMD_SET_HW_MII               0x0a
-#define AX_CMD_READ_EEPROM              0x0b
-#define AX_CMD_WRITE_EEPROM             0x0c
-#define AX_CMD_WRITE_ENABLE             0x0d
-#define AX_CMD_WRITE_DISABLE            0x0e
-#define AX_CMD_WRITE_RX_CTL             0x10
-#define AX_CMD_READ_IPG012              0x11
-#define AX_CMD_WRITE_IPG0               0x12
-#define AX_CMD_WRITE_IPG1               0x13
-#define AX_CMD_WRITE_IPG2               0x14
-#define AX_CMD_WRITE_MULTI_FILTER       0x16
-#define AX_CMD_READ_NODE_ID             0x17
-#define AX_CMD_READ_PHY_ID              0x19
-#define AX_CMD_READ_MEDIUM_STATUS       0x1a
-#define AX_CMD_WRITE_MEDIUM_MODE        0x1b
-#define AX_CMD_READ_MONITOR_MODE        0x1c
-#define AX_CMD_WRITE_MONITOR_MODE       0x1d
-#define AX_CMD_WRITE_GPIOS              0x1f
-#define AX_CMD_SW_RESET                 0x20
-#define AX_CMD_SW_PHY_STATUS            0x21
-#define AX_CMD_SW_PHY_SELECT            0x22
-#define AX88772_CMD_READ_NODE_ID        0x13
-
-#define AX_MONITOR_MODE                 0x01
-#define AX_MONITOR_LINK                 0x02
-#define AX_MONITOR_MAGIC                0x04
-#define AX_MONITOR_HSFS                 0x10
-
-/* AX88172 Medium Status Register values */
-#define AX_MEDIUM_FULL_DUPLEX           0x02
-#define AX_MEDIUM_TX_ABORT_ALLOW        0x04
-#define AX_MEDIUM_FLOW_CONTROL_EN       0x10
-
-#define AX_MCAST_FILTER_SIZE            8
-#define AX_MAX_MCAST                    64
-
-#define AX_EEPROM_LEN                   0x40
-
-#define AX_SWRESET_CLEAR                0x00
-#define AX_SWRESET_RR                   0x01
-#define AX_SWRESET_RT                   0x02
-#define AX_SWRESET_PRTE                 0x04
-#define AX_SWRESET_PRL                  0x08
-#define AX_SWRESET_BZ                   0x10
-#define AX_SWRESET_IPRL                 0x20
-#define AX_SWRESET_IPPD                 0x40
-
-#define AX88772_IPG0_DEFAULT            0x15
-#define AX88772_IPG1_DEFAULT            0x0c
-#define AX88772_IPG2_DEFAULT            0x12
-
-#define AX88772_MEDIUM_FULL_DUPLEX      0x0002
-#define AX88772_MEDIUM_RESERVED         0x0004
-#define AX88772_MEDIUM_RX_FC_ENABLE     0x0010
-#define AX88772_MEDIUM_TX_FC_ENABLE     0x0020
-#define AX88772_MEDIUM_PAUSE_FORMAT     0x0080
-#define AX88772_MEDIUM_RX_ENABLE        0x0100
-#define AX88772_MEDIUM_100MB            0x0200
-#define AX88772_MEDIUM_DEFAULT  \
-        (AX88772_MEDIUM_FULL_DUPLEX | AX88772_MEDIUM_RX_FC_ENABLE | \
-         AX88772_MEDIUM_TX_FC_ENABLE | AX88772_MEDIUM_100MB | \
-         AX88772_MEDIUM_RESERVED | AX88772_MEDIUM_RX_ENABLE )
-
-#define AX_EEPROM_MAGIC                 0xdeadbeef
-
-/* This structure cannot exceed sizeof(unsigned long [5]) AKA 20 bytes */
-struct ax8817x_data {
-        u8 multi_filter[AX_MCAST_FILTER_SIZE];
-};
-
-struct ax88172_int_data {
-        u16 res1;
-        u8 link;
-        u16 res2;
-        u8 status;
-        u16 res3;
-} __attribute__ ((packed));
-
-static int ax8817x_read_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
-                            u16 size, void *data)
-{
-        return usb_control_msg(
-                dev->udev,
-                usb_rcvctrlpipe(dev->udev, 0),
-                cmd,
-                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                value,
-                index,
-                data,
-                size,
-                CONTROL_TIMEOUT_MS);
-}
-
-static int ax8817x_write_cmd(struct usbnet *dev, u8 cmd, u16 value, u16 index,
-                             u16 size, void *data)
-{
-        return usb_control_msg(
-                dev->udev,
-                usb_sndctrlpipe(dev->udev, 0),
-                cmd,
-                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                value,
-                index,
-                data,
-                size,
-                CONTROL_TIMEOUT_MS);
-}
-
-static void ax8817x_async_cmd_callback(struct urb *urb, struct pt_regs *regs)
-{
-        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
-
-        if (urb->status < 0)
-                printk(KERN_DEBUG "ax8817x_async_cmd_callback() failed with %d",
-                        urb->status);
-
-        kfree(req);
-        usb_free_urb(urb);
-}
-
-static void ax8817x_status(struct usbnet *dev, struct urb *urb)
-{
-        struct ax88172_int_data *event;
-        int link;
-
-        if (urb->actual_length < 8)
-                return;
-
-        event = urb->transfer_buffer;
-        link = event->link & 0x01;
-        if (netif_carrier_ok(dev->net) != link) {
-                if (link) {
-                        netif_carrier_on(dev->net);
-                        defer_kevent (dev, EVENT_LINK_RESET );
-                } else
-                        netif_carrier_off(dev->net);
-                devdbg(dev, "ax8817x - Link Status is: %d", link);
-        }
-}
-
-static void ax8817x_write_cmd_async(struct usbnet *dev, u8 cmd, u16 value, u16 index,
-                                    u16 size, void *data)
-{
-        struct usb_ctrlrequest *req;
-        int status;
-        struct urb *urb;
-
-        if ((urb = usb_alloc_urb(0, GFP_ATOMIC)) == NULL) {
-                devdbg(dev, "Error allocating URB in write_cmd_async!");
-                return;
-        }
-
-        if ((req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC)) == NULL) {
-                deverr(dev, "Failed to allocate memory for control request");
-                usb_free_urb(urb);
-                return;
-        }
-
-        req->bRequestType = USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
-        req->bRequest = cmd;
-        req->wValue = cpu_to_le16(value);
-        req->wIndex = cpu_to_le16(index); 
-        req->wLength = cpu_to_le16(size);
-
-        usb_fill_control_urb(urb, dev->udev,
-                             usb_sndctrlpipe(dev->udev, 0),
-                             (void *)req, data, size,
-                             ax8817x_async_cmd_callback, req);
-
-        if((status = usb_submit_urb(urb, GFP_ATOMIC)) < 0) {
-                deverr(dev, "Error submitting the control message: status=%d", status);
-                kfree(req);
-                usb_free_urb(urb);
-        }
-}
-
-static void ax8817x_set_multicast(struct net_device *net)
-{
-        struct usbnet *dev = netdev_priv(net);
-        struct ax8817x_data *data = (struct ax8817x_data *)&dev->data;
-        u8 rx_ctl = 0x8c;
-
-        if (net->flags & IFF_PROMISC) {
-                rx_ctl |= 0x01;
-        } else if (net->flags & IFF_ALLMULTI
-                   || net->mc_count > AX_MAX_MCAST) {
-                rx_ctl |= 0x02;
-        } else if (net->mc_count == 0) {
-                /* just broadcast and directed */
-        } else {
-                /* We use the 20 byte dev->data
-                 * for our 8 byte filter buffer
-                 * to avoid allocating memory that
-                 * is tricky to free later */
-                struct dev_mc_list *mc_list = net->mc_list;
-                u32 crc_bits;
-                int i;
-
-                memset(data->multi_filter, 0, AX_MCAST_FILTER_SIZE);
-
-                /* Build the multicast hash filter. */
-                for (i = 0; i < net->mc_count; i++) {
-                        crc_bits =
-                            ether_crc(ETH_ALEN,
-                                      mc_list->dmi_addr) >> 26;
-                        data->multi_filter[crc_bits >> 3] |=
-                            1 << (crc_bits & 7);
-                        mc_list = mc_list->next;
-                }
-
-                ax8817x_write_cmd_async(dev, AX_CMD_WRITE_MULTI_FILTER, 0, 0,
-                                   AX_MCAST_FILTER_SIZE, data->multi_filter);
-
-                rx_ctl |= 0x10;
-        }
-
-        ax8817x_write_cmd_async(dev, AX_CMD_WRITE_RX_CTL, rx_ctl, 0, 0, NULL);
-}
-
-static int ax8817x_mdio_read(struct net_device *netdev, int phy_id, int loc)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        u16 res;
-        u8 buf[1];
-
-        ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII, 0, 0, 0, &buf);
-        ax8817x_read_cmd(dev, AX_CMD_READ_MII_REG, phy_id, (__u16)loc, 2, (u16 *)&res);
-        ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf);
-
-        return res & 0xffff;
-}
-
-static void ax8817x_mdio_write(struct net_device *netdev, int phy_id, int loc, int val)
-{
-        struct usbnet *dev = netdev_priv(netdev);
-        u16 res = val;
-        u8 buf[1];
-
-        ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII, 0, 0, 0, &buf);
-        ax8817x_write_cmd(dev, AX_CMD_WRITE_MII_REG, phy_id, (__u16)loc, 2, (u16 *)&res);
-        ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf);
-}
-
-static int ax88172_link_reset(struct usbnet *dev)
-{
-        u16 lpa;
-        u8 mode;
-
-        mode = AX_MEDIUM_TX_ABORT_ALLOW | AX_MEDIUM_FLOW_CONTROL_EN;
-        lpa = ax8817x_mdio_read(dev->net, dev->mii.phy_id, MII_LPA);
-        if (lpa & LPA_DUPLEX)
-                mode |= AX_MEDIUM_FULL_DUPLEX;
-        ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
-
-        return 0;
-}
-
-static void ax8817x_get_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
-{
-        struct usbnet *dev = netdev_priv(net);
-        u8 opt;
-
-        if (ax8817x_read_cmd(dev, AX_CMD_READ_MONITOR_MODE, 0, 0, 1, &opt) < 0) {
-                wolinfo->supported = 0;
-                wolinfo->wolopts = 0;
-                return;
-        }
-        wolinfo->supported = WAKE_PHY | WAKE_MAGIC;
-        wolinfo->wolopts = 0;
-        if (opt & AX_MONITOR_MODE) {
-                if (opt & AX_MONITOR_LINK)
-                        wolinfo->wolopts |= WAKE_PHY;
-                if (opt & AX_MONITOR_MAGIC)
-                        wolinfo->wolopts |= WAKE_MAGIC;
-        }
-}
-
-static int ax8817x_set_wol(struct net_device *net, struct ethtool_wolinfo *wolinfo)
-{
-        struct usbnet *dev = netdev_priv(net);
-        u8 opt = 0;
-        u8 buf[1];
-
-        if (wolinfo->wolopts & WAKE_PHY)
-                opt |= AX_MONITOR_LINK;
-        if (wolinfo->wolopts & WAKE_MAGIC)
-                opt |= AX_MONITOR_MAGIC;
-        if (opt != 0)
-                opt |= AX_MONITOR_MODE;
-
-        if (ax8817x_write_cmd(dev, AX_CMD_WRITE_MONITOR_MODE,
-                              opt, 0, 0, &buf) < 0)
-                return -EINVAL;
-
-        return 0;
-}
-
-static int ax8817x_get_eeprom_len(struct net_device *net)
-{
-        return AX_EEPROM_LEN;
-}
-
-static int ax8817x_get_eeprom(struct net_device *net,
-                              struct ethtool_eeprom *eeprom, u8 *data)
-{
-        struct usbnet *dev = netdev_priv(net);
-        u16 *ebuf = (u16 *)data;
-        int i;
-
-        /* Crude hack to ensure that we don't overwrite memory
-         * if an odd length is supplied
-         */
-        if (eeprom->len % 2)
-                return -EINVAL;
-
-        eeprom->magic = AX_EEPROM_MAGIC;
-
-        /* ax8817x returns 2 bytes from eeprom on read */
-        for (i=0; i < eeprom->len / 2; i++) {
-                if (ax8817x_read_cmd(dev, AX_CMD_READ_EEPROM, 
-                        eeprom->offset + i, 0, 2, &ebuf[i]) < 0)
-                        return -EINVAL;
-        }
-        return 0;
-}
-
-static void ax8817x_get_drvinfo (struct net_device *net,
-                                 struct ethtool_drvinfo *info)
-{
-        /* Inherit standard device info */
-        usbnet_get_drvinfo(net, info);
-        info->eedump_len = 0x3e;
-}
-
-static int ax8817x_get_settings(struct net_device *net, struct ethtool_cmd *cmd)
-{
-        struct usbnet *dev = netdev_priv(net);
-
-        return mii_ethtool_gset(&dev->mii,cmd);
-}
-
-static int ax8817x_set_settings(struct net_device *net, struct ethtool_cmd *cmd)
-{
-        struct usbnet *dev = netdev_priv(net);
-
-        return mii_ethtool_sset(&dev->mii,cmd);
-}
-
-/* We need to override some ethtool_ops so we require our
-   own structure so we don't interfere with other usbnet
-   devices that may be connected at the same time. */
-static struct ethtool_ops ax8817x_ethtool_ops = {
-        .get_drvinfo            = ax8817x_get_drvinfo,
-        .get_link               = ethtool_op_get_link,
-        .get_msglevel           = usbnet_get_msglevel,
-        .set_msglevel           = usbnet_set_msglevel,
-        .get_wol                = ax8817x_get_wol,
-        .set_wol                = ax8817x_set_wol,
-        .get_eeprom_len         = ax8817x_get_eeprom_len,
-        .get_eeprom             = ax8817x_get_eeprom,
-        .get_settings           = ax8817x_get_settings,
-        .set_settings           = ax8817x_set_settings,
-};
-
-static int ax8817x_bind(struct usbnet *dev, struct usb_interface *intf)
-{
-        int ret = 0;
-        void *buf;
-        int i;
-        unsigned long gpio_bits = dev->driver_info->data;
-
-        get_endpoints(dev,intf);
-
-        buf = kmalloc(ETH_ALEN, GFP_KERNEL);
-        if(!buf) {
-                ret = -ENOMEM;
-                goto out1;
-        }
-
-        /* Toggle the GPIOs in a manufacturer/model specific way */
-        for (i = 2; i >= 0; i--) {
-                if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_GPIOS,
-                                        (gpio_bits >> (i * 8)) & 0xff, 0, 0,
-                                        buf)) < 0)
-                        goto out2;
-                msleep(5);
-        }
-
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL, 0x80, 0, 0, buf)) < 0) {
-                dbg("send AX_CMD_WRITE_RX_CTL failed: %d", ret);
-                goto out2;
-        }
-
-        /* Get the MAC address */
-        memset(buf, 0, ETH_ALEN);
-        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_NODE_ID, 0, 0, 6, buf)) < 0) {
-                dbg("read AX_CMD_READ_NODE_ID failed: %d", ret);
-                goto out2;
-        }
-        memcpy(dev->net->dev_addr, buf, ETH_ALEN);
-
-        /* Get the PHY id */
-        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf)) < 0) {
-                dbg("error on read AX_CMD_READ_PHY_ID: %02x", ret);
-                goto out2;
-        } else if (ret < 2) {
-                /* this should always return 2 bytes */
-                dbg("AX_CMD_READ_PHY_ID returned less than 2 bytes: ret=%02x", ret);
-                ret = -EIO;
-                goto out2;
-        }
-
-        /* Initialize MII structure */
-        dev->mii.dev = dev->net;
-        dev->mii.mdio_read = ax8817x_mdio_read;
-        dev->mii.mdio_write = ax8817x_mdio_write;
-        dev->mii.phy_id_mask = 0x3f;
-        dev->mii.reg_num_mask = 0x1f;
-        dev->mii.phy_id = *((u8 *)buf + 1);
-
-        dev->net->set_multicast_list = ax8817x_set_multicast;
-        dev->net->ethtool_ops = &ax8817x_ethtool_ops;
-
-        ax8817x_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
-        ax8817x_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
-                ADVERTISE_ALL | ADVERTISE_CSMA | ADVERTISE_PAUSE_CAP);
-        mii_nway_restart(&dev->mii);
-
-        return 0;
-out2:
-        kfree(buf);
-out1:
-        return ret;
-}
-
-static struct ethtool_ops ax88772_ethtool_ops = {
-        .get_drvinfo            = ax8817x_get_drvinfo,
-        .get_link               = ethtool_op_get_link,
-        .get_msglevel           = usbnet_get_msglevel,
-        .set_msglevel           = usbnet_set_msglevel,
-        .get_wol                = ax8817x_get_wol,
-        .set_wol                = ax8817x_set_wol,
-        .get_eeprom_len         = ax8817x_get_eeprom_len,
-        .get_eeprom             = ax8817x_get_eeprom,
-        .get_settings           = ax8817x_get_settings,
-        .set_settings           = ax8817x_set_settings,
-};
-
-static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf)
-{
-        int ret;
-        void *buf;
-
-        get_endpoints(dev,intf);
-
-        buf = kmalloc(6, GFP_KERNEL);
-        if(!buf) {
-                dbg ("Cannot allocate memory for buffer");
-                ret = -ENOMEM;
-                goto out1;
-        }
-
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_GPIOS,
-                                     0x00B0, 0, 0, buf)) < 0)
-                goto out2;
-
-        msleep(5);
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SW_PHY_SELECT, 0x0001, 0, 0, buf)) < 0) {
-                dbg("Select PHY #1 failed: %d", ret);
-                goto out2;
-        }
-
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_IPPD, 0, 0, buf)) < 0) {
-                dbg("Failed to power down internal PHY: %d", ret);
-                goto out2;
-        }
-
-        msleep(150);
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_CLEAR, 0, 0, buf)) < 0) {
-                dbg("Failed to perform software reset: %d", ret);
-                goto out2;
-        }
-
-        msleep(150);
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_IPRL | AX_SWRESET_PRL, 0, 0, buf)) < 0) {
-                dbg("Failed to set Internal/External PHY reset control: %d", ret);
-                goto out2;
-        }
-
-        msleep(150);
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL, 0x0000, 0, 0,
-                               buf)) < 0) {
-                dbg("Failed to reset RX_CTL: %d", ret);
-                goto out2;
-        }
-
-        /* Get the MAC address */
-        memset(buf, 0, ETH_ALEN);
-        if ((ret = ax8817x_read_cmd(dev, AX88772_CMD_READ_NODE_ID, 0, 0, ETH_ALEN, buf)) < 0) {
-                dbg("Failed to read MAC address: %d", ret);
-                goto out2;
-        }
-        memcpy(dev->net->dev_addr, buf, ETH_ALEN);
-
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_SET_SW_MII, 0, 0, 0, buf)) < 0) {
-                dbg("Enabling software MII failed: %d", ret);
-                goto out2;
-        }
-
-        if (((ret =
-              ax8817x_read_cmd(dev, AX_CMD_READ_MII_REG, 0x0010, 2, 2, buf)) < 0)
-            || (*((u16 *)buf) != 0x003b)) {
-                dbg("Read PHY register 2 must be 0x3b00: %d", ret);
-                goto out2;
-        }
-
-        /* Initialize MII structure */
-        dev->mii.dev = dev->net;
-        dev->mii.mdio_read = ax8817x_mdio_read;
-        dev->mii.mdio_write = ax8817x_mdio_write;
-        dev->mii.phy_id_mask = 0xff;
-        dev->mii.reg_num_mask = 0xff;
-
-        /* Get the PHY id */
-        if ((ret = ax8817x_read_cmd(dev, AX_CMD_READ_PHY_ID, 0, 0, 2, buf)) < 0) {
-                dbg("Error reading PHY ID: %02x", ret);
-                goto out2;
-        } else if (ret < 2) {
-                /* this should always return 2 bytes */
-                dbg("AX_CMD_READ_PHY_ID returned less than 2 bytes: ret=%02x",
-                    ret);
-                ret = -EIO;
-                goto out2;
-        }
-        dev->mii.phy_id = *((u8 *)buf + 1);
-
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_PRL, 0, 0, buf)) < 0) {
-                dbg("Set external PHY reset pin level: %d", ret);
-                goto out2;
-        }
-        msleep(150);
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SW_RESET, AX_SWRESET_IPRL | AX_SWRESET_PRL, 0, 0, buf)) < 0) {
-                dbg("Set Internal/External PHY reset control: %d", ret);
-                goto out2;
-        }
-        msleep(150);
-
-
-        dev->net->set_multicast_list = ax8817x_set_multicast;
-        dev->net->ethtool_ops = &ax88772_ethtool_ops;
-
-        ax8817x_mdio_write(dev->net, dev->mii.phy_id, MII_BMCR, BMCR_RESET);
-        ax8817x_mdio_write(dev->net, dev->mii.phy_id, MII_ADVERTISE,
-                        ADVERTISE_ALL | ADVERTISE_CSMA);
-        mii_nway_restart(&dev->mii);
-
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, AX88772_MEDIUM_DEFAULT, 0, 0, buf)) < 0) {
-                dbg("Write medium mode register: %d", ret);
-                goto out2;
-        }
-
-        if ((ret = ax8817x_write_cmd(dev, AX_CMD_WRITE_IPG0, AX88772_IPG0_DEFAULT | AX88772_IPG1_DEFAULT,AX88772_IPG2_DEFAULT, 0, buf)) < 0) {
-                dbg("Write IPG,IPG1,IPG2 failed: %d", ret);
-                goto out2;
-        }
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_SET_HW_MII, 0, 0, 0, &buf)) < 0) {
-                dbg("Failed to set hardware MII: %02x", ret);
-                goto out2;
-        }
-
-        /* Set RX_CTL to default values with 2k buffer, and enable cactus */
-        if ((ret =
-             ax8817x_write_cmd(dev, AX_CMD_WRITE_RX_CTL, 0x0088, 0, 0,
-                               buf)) < 0) {
-                dbg("Reset RX_CTL failed: %d", ret);
-                goto out2;
-        }
-
-        kfree(buf);
-
-        return 0;
-
-out2:
-        kfree(buf);
-out1:
-        return ret;
-}
-
-static int ax88772_rx_fixup(struct usbnet *dev, struct sk_buff *skb)
-{
-        u32 *header;
-        char *packet;
-        struct sk_buff *ax_skb;
-        u16 size;
-
-        header = (u32 *) skb->data;
-        le32_to_cpus(header);
-        packet = (char *)(header + 1);
-
-        skb_pull(skb, 4);
-
-        while (skb->len > 0) {
-                if ((short)(*header & 0x0000ffff) !=
-                    ~((short)((*header & 0xffff0000) >> 16))) {
-                        devdbg(dev,"header length data is error");
-                }
-                /* get the packet length */
-                size = (u16) (*header & 0x0000ffff);
-
-                if ((skb->len) - ((size + 1) & 0xfffe) == 0)
-                        return 2;
-                if (size > ETH_FRAME_LEN) {
-                        devdbg(dev,"invalid rx length %d", size);
-                        return 0;
-                }
-                ax_skb = skb_clone(skb, GFP_ATOMIC);
-                if (ax_skb) {
-                        ax_skb->len = size;
-                        ax_skb->data = packet;
-                        ax_skb->tail = packet + size;
-                        skb_return(dev, ax_skb);
-                } else {
-                        return 0;
-                }
-
-                skb_pull(skb, (size + 1) & 0xfffe);
-
-                if (skb->len == 0)
-                        break;
-
-                header = (u32 *) skb->data;
-                le32_to_cpus(header);
-                packet = (char *)(header + 1);
-                skb_pull(skb, 4);
-        }
-
-        if (skb->len < 0) {
-                devdbg(dev,"invalid rx length %d", skb->len);
-                return 0;
-        }
-        return 1;
-}
-
-static struct sk_buff *ax88772_tx_fixup(struct usbnet *dev, struct sk_buff *skb,
-                                        int flags)
-{
-        int padlen;
-        int headroom = skb_headroom(skb);
-        int tailroom = skb_tailroom(skb);
-        u32 *packet_len;
-        u32 *padbytes_ptr;
-
-        padlen = ((skb->len + 4) % 512) ? 0 : 4;
-
-        if ((!skb_cloned(skb))
-            && ((headroom + tailroom) >= (4 + padlen))) {
-                if ((headroom < 4) || (tailroom < padlen)) {
-                        skb->data = memmove(skb->head + 4, skb->data, skb->len);
-                        skb->tail = skb->data + skb->len;
-                }
-        } else {
-                struct sk_buff *skb2;
-                skb2 = skb_copy_expand(skb, 4, padlen, flags);
-                dev_kfree_skb_any(skb);
-                skb = skb2;
-                if (!skb)
-                        return NULL;
-        }
-
-        packet_len = (u32 *) skb_push(skb, 4);
-
-        packet_len = (u32 *) skb->data;
-        *packet_len = (((skb->len - 4) ^ 0x0000ffff) << 16) + (skb->len - 4);
-
-        if ((skb->len % 512) == 0) {
-                padbytes_ptr = (u32 *) skb->tail;
-                *padbytes_ptr = 0xffff0000;
-                skb_put(skb, padlen);
-        }
-        return skb;
-}
-
-static int ax88772_link_reset(struct usbnet *dev)
-{
-        u16 lpa;
-        u16 mode;
-
-        mode = AX88772_MEDIUM_DEFAULT;
-        lpa = ax8817x_mdio_read(dev->net, dev->mii.phy_id, MII_LPA);
-
-        if ((lpa & LPA_DUPLEX) == 0)
-                mode &= ~AX88772_MEDIUM_FULL_DUPLEX;
-        if ((lpa & LPA_100) == 0)
-                mode &= ~AX88772_MEDIUM_100MB;
-        ax8817x_write_cmd(dev, AX_CMD_WRITE_MEDIUM_MODE, mode, 0, 0, NULL);
-
-        return 0;
-}
-
-static const struct driver_info ax8817x_info = {
-        .description = "ASIX AX8817x USB 2.0 Ethernet",
-        .bind = ax8817x_bind,
-        .status = ax8817x_status,
-        .link_reset = ax88172_link_reset,
-        .reset = ax88172_link_reset,
-        .flags =  FLAG_ETHER,
-        .data = 0x00130103,
-};
-
-static const struct driver_info dlink_dub_e100_info = {
-        .description = "DLink DUB-E100 USB Ethernet",
-        .bind = ax8817x_bind,
-        .status = ax8817x_status,
-        .link_reset = ax88172_link_reset,
-        .reset = ax88172_link_reset,
-        .flags =  FLAG_ETHER,
-        .data = 0x009f9d9f,
-};
-
-static const struct driver_info netgear_fa120_info = {
-        .description = "Netgear FA-120 USB Ethernet",
-        .bind = ax8817x_bind,
-        .status = ax8817x_status,
-        .link_reset = ax88172_link_reset,
-        .reset = ax88172_link_reset,
-        .flags =  FLAG_ETHER,
-        .data = 0x00130103,
-};
-
-static const struct driver_info hawking_uf200_info = {
-        .description = "Hawking UF200 USB Ethernet",
-        .bind = ax8817x_bind,
-        .status = ax8817x_status,
-        .link_reset = ax88172_link_reset,
-        .reset = ax88172_link_reset,
-        .flags =  FLAG_ETHER,
-        .data = 0x001f1d1f,
-};
-
-static const struct driver_info ax88772_info = {
-        .description = "ASIX AX88772 USB 2.0 Ethernet",
-        .bind = ax88772_bind,
-        .status = ax8817x_status,
-        .link_reset = ax88772_link_reset,
-        .reset = ax88772_link_reset,
-        .flags = FLAG_ETHER | FLAG_FRAMING_AX,
-        .rx_fixup = ax88772_rx_fixup,
-        .tx_fixup = ax88772_tx_fixup,
-        .data = 0x00130103,
-};
-
-#endif /* CONFIG_USB_AX8817X */
-
-
-
-#ifdef  CONFIG_USB_BELKIN
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * Belkin F5U104 ... two NetChip 2280 devices + Atmel microcontroller
- *
- * ... also two eTEK designs, including one sold as "Advance USBNET"
- *
- *-------------------------------------------------------------------------*/
-
-static const struct driver_info belkin_info = {
-        .description =  "Belkin, eTEK, or compatible",
-};
-
-#endif  /* CONFIG_USB_BELKIN */
-
-
-
-/*-------------------------------------------------------------------------
- *
- * Communications Device Class declarations.
- * Used by CDC Ethernet, and some CDC variants
- *
- *-------------------------------------------------------------------------*/
-
-#ifdef  CONFIG_USB_CDCETHER
-#define NEED_GENERIC_CDC
-#endif
-
-#ifdef  CONFIG_USB_ZAURUS
-/* Ethernet variant uses funky framing, broken ethernet addressing */
-#define NEED_GENERIC_CDC
-#endif
-
-#ifdef  CONFIG_USB_RNDIS
-/* ACM variant uses even funkier framing, complex control RPC scheme */
-#define NEED_GENERIC_CDC
-#endif
-
-
-#ifdef  NEED_GENERIC_CDC
-
-#include <linux/usb_cdc.h>
-
-struct cdc_state {
-        struct usb_cdc_header_desc      *header;
-        struct usb_cdc_union_desc       *u;
-        struct usb_cdc_ether_desc       *ether;
-        struct usb_interface            *control;
-        struct usb_interface            *data;
-};
-
-static struct usb_driver usbnet_driver;
-
-/*
- * probes control interface, claims data interface, collects the bulk
- * endpoints, activates data interface (if needed), maybe sets MTU.
- * all pure cdc, except for certain firmware workarounds.
- */
-static int generic_cdc_bind (struct usbnet *dev, struct usb_interface *intf)
-{
-        u8                              *buf = intf->cur_altsetting->extra;
-        int                             len = intf->cur_altsetting->extralen;
-        struct usb_interface_descriptor *d;
-        struct cdc_state                *info = (void *) &dev->data;
-        int                             status;
-        int                             rndis;
-
-        if (sizeof dev->data < sizeof *info)
-                return -EDOM;
-
-        /* expect strict spec conformance for the descriptors, but
-         * cope with firmware which stores them in the wrong place
-         */
-        if (len == 0 && dev->udev->actconfig->extralen) {
-                /* Motorola SB4100 (and others: Brad Hards says it's
-                 * from a Broadcom design) put CDC descriptors here
-                 */
-                buf = dev->udev->actconfig->extra;
-                len = dev->udev->actconfig->extralen;
-                if (len)
-                        dev_dbg (&intf->dev,
-                                "CDC descriptors on config\n");
-        }
-
-        /* this assumes that if there's a non-RNDIS vendor variant
-         * of cdc-acm, it'll fail RNDIS requests cleanly.
-         */
-        rndis = (intf->cur_altsetting->desc.bInterfaceProtocol == 0xff);
-
-        memset (info, 0, sizeof *info);
-        info->control = intf;
-        while (len > 3) {
-                if (buf [1] != USB_DT_CS_INTERFACE)
-                        goto next_desc;
-
-                /* use bDescriptorSubType to identify the CDC descriptors.
-                 * We expect devices with CDC header and union descriptors.
-                 * For CDC Ethernet we need the ethernet descriptor.
-                 * For RNDIS, ignore two (pointless) CDC modem descriptors
-                 * in favor of a complicated OID-based RPC scheme doing what
-                 * CDC Ethernet achieves with a simple descriptor.
-                 */
-                switch (buf [2]) {
-                case USB_CDC_HEADER_TYPE:
-                        if (info->header) {
-                                dev_dbg (&intf->dev, "extra CDC header\n");
-                                goto bad_desc;
-                        }
-                        info->header = (void *) buf;
-                        if (info->header->bLength != sizeof *info->header) {
-                                dev_dbg (&intf->dev, "CDC header len %u\n",
-                                        info->header->bLength);
-                                goto bad_desc;
-                        }
-                        break;
-                case USB_CDC_UNION_TYPE:
-                        if (info->u) {
-                                dev_dbg (&intf->dev, "extra CDC union\n");
-                                goto bad_desc;
-                        }
-                        info->u = (void *) buf;
-                        if (info->u->bLength != sizeof *info->u) {
-                                dev_dbg (&intf->dev, "CDC union len %u\n",
-                                        info->u->bLength);
-                                goto bad_desc;
-                        }
-
-                        /* we need a master/control interface (what we're
-                         * probed with) and a slave/data interface; union
-                         * descriptors sort this all out.
-                         */
-                        info->control = usb_ifnum_to_if(dev->udev,
-                                                info->u->bMasterInterface0);
-                        info->data = usb_ifnum_to_if(dev->udev,
-                                                info->u->bSlaveInterface0);
-                        if (!info->control || !info->data) {
-                                dev_dbg (&intf->dev,
-                                        "master #%u/%p slave #%u/%p\n",
-                                        info->u->bMasterInterface0,
-                                        info->control,
-                                        info->u->bSlaveInterface0,
-                                        info->data);
-                                goto bad_desc;
-                        }
-                        if (info->control != intf) {
-                                dev_dbg (&intf->dev, "bogus CDC Union\n");
-                                /* Ambit USB Cable Modem (and maybe others)
-                                 * interchanges master and slave interface.
-                                 */
-                                if (info->data == intf) {
-                                        info->data = info->control;
-                                        info->control = intf;
-                                } else
-                                        goto bad_desc;
-                        }
-
-                        /* a data interface altsetting does the real i/o */
-                        d = &info->data->cur_altsetting->desc;
-                        if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
-                                dev_dbg (&intf->dev, "slave class %u\n",
-                                        d->bInterfaceClass);
-                                goto bad_desc;
-                        }
-                        break;
-                case USB_CDC_ETHERNET_TYPE:
-                        if (info->ether) {
-                                dev_dbg (&intf->dev, "extra CDC ether\n");
-                                goto bad_desc;
-                        }
-                        info->ether = (void *) buf;
-                        if (info->ether->bLength != sizeof *info->ether) {
-                                dev_dbg (&intf->dev, "CDC ether len %u\n",
-                                        info->ether->bLength);
-                                goto bad_desc;
-                        }
-                        dev->net->mtu = le16_to_cpup (
-                                                &info->ether->wMaxSegmentSize)
-                                        - ETH_HLEN;
-                        /* because of Zaurus, we may be ignoring the host
-                         * side link address we were given.
-                         */
-                        break;
-                }
-next_desc:
-                len -= buf [0]; /* bLength */
-                buf += buf [0];
-        }
-
-        if (!info->header || !info->u || (!rndis && !info->ether)) {
-                dev_dbg (&intf->dev, "missing cdc %s%s%sdescriptor\n",
-                        info->header ? "" : "header ",
-                        info->u ? "" : "union ",
-                        info->ether ? "" : "ether ");
-                goto bad_desc;
-        }
-
-        /* claim data interface and set it up ... with side effects.
-         * network traffic can't flow until an altsetting is enabled.
-         */
-        status = usb_driver_claim_interface (&usbnet_driver, info->data, dev);
-        if (status < 0)
-                return status;
-        status = get_endpoints (dev, info->data);
-        if (status < 0) {
-                /* ensure immediate exit from usbnet_disconnect */
-                usb_set_intfdata(info->data, NULL);
-                usb_driver_release_interface (&usbnet_driver, info->data);
-                return status;
-        }
-
-        /* status endpoint: optional for CDC Ethernet, not RNDIS (or ACM) */
-        dev->status = NULL;
-        if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
-                struct usb_endpoint_descriptor  *desc;
-
-                dev->status = &info->control->cur_altsetting->endpoint [0];
-                desc = &dev->status->desc;
-                if (desc->bmAttributes != USB_ENDPOINT_XFER_INT
-                                || !(desc->bEndpointAddress & USB_DIR_IN)
-                                || (le16_to_cpu(desc->wMaxPacketSize)
-                                        < sizeof (struct usb_cdc_notification))
-                                || !desc->bInterval) {
-                        dev_dbg (&intf->dev, "bad notification endpoint\n");
-                        dev->status = NULL;
-                }
-        }
-        if (rndis && !dev->status) {
-                dev_dbg (&intf->dev, "missing RNDIS status endpoint\n");
-                usb_set_intfdata(info->data, NULL);
-                usb_driver_release_interface (&usbnet_driver, info->data);
-                return -ENODEV;
-        }
-        return 0;
-
-bad_desc:
-        dev_info (&dev->udev->dev, "bad CDC descriptors\n");
-        return -ENODEV;
-}
-
-static void cdc_unbind (struct usbnet *dev, struct usb_interface *intf)
-{
-        struct cdc_state                *info = (void *) &dev->data;
-
-        /* disconnect master --> disconnect slave */
-        if (intf == info->control && info->data) {
-                /* ensure immediate exit from usbnet_disconnect */
-                usb_set_intfdata(info->data, NULL);
-                usb_driver_release_interface (&usbnet_driver, info->data);
-                info->data = NULL;
-        }
-
-        /* and vice versa (just in case) */
-        else if (intf == info->data && info->control) {
-                /* ensure immediate exit from usbnet_disconnect */
-                usb_set_intfdata(info->control, NULL);
-                usb_driver_release_interface (&usbnet_driver, info->control);
-                info->control = NULL;
-        }
-}
-
-#endif  /* NEED_GENERIC_CDC */
-
-
-#ifdef  CONFIG_USB_CDCETHER
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * Communications Device Class, Ethernet Control model
- *
- * Takes two interfaces.  The DATA interface is inactive till an altsetting
- * is selected.  Configuration data includes class descriptors.
- *
- * This should interop with whatever the 2.4 "CDCEther.c" driver
- * (by Brad Hards) talked with.
- *
- *-------------------------------------------------------------------------*/
-
-#include <linux/ctype.h>
-
-
-static void dumpspeed (struct usbnet *dev, __le32 *speeds)
-{
-        if (netif_msg_timer (dev))
-                devinfo (dev, "link speeds: %u kbps up, %u kbps down",
-                        __le32_to_cpu(speeds[0]) / 1000,
-                __le32_to_cpu(speeds[1]) / 1000);
-}
-
-static void cdc_status (struct usbnet *dev, struct urb *urb)
-{
-        struct usb_cdc_notification     *event;
-
-        if (urb->actual_length < sizeof *event)
-                return;
-        
-        /* SPEED_CHANGE can get split into two 8-byte packets */
-        if (test_and_clear_bit (EVENT_STS_SPLIT, &dev->flags)) {
-                dumpspeed (dev, (__le32 *) urb->transfer_buffer);
-                return;
-        }
-
-        event = urb->transfer_buffer;
-        switch (event->bNotificationType) {
-        case USB_CDC_NOTIFY_NETWORK_CONNECTION:
-                if (netif_msg_timer (dev))
-                        devdbg (dev, "CDC: carrier %s",
-                                        event->wValue ? "on" : "off");
-                if (event->wValue)
-                        netif_carrier_on(dev->net);
-                else
-                        netif_carrier_off(dev->net);
-                break;
-        case USB_CDC_NOTIFY_SPEED_CHANGE:       /* tx/rx rates */
-                if (netif_msg_timer (dev))
-                        devdbg (dev, "CDC: speed change (len %d)",
-                                        urb->actual_length);
-                if (urb->actual_length != (sizeof *event + 8))
-                        set_bit (EVENT_STS_SPLIT, &dev->flags);
-                else
-                        dumpspeed (dev, (__le32 *) &event[1]);
-                break;
-        // case USB_CDC_NOTIFY_RESPONSE_AVAILABLE:      /* RNDIS; or unsolicited */
-        default:
-                deverr (dev, "CDC: unexpected notification %02x!",
-                                 event->bNotificationType);
-                break;
-        }
-}
-
-static u8 nibble (unsigned char c)
-{
-        if (likely (isdigit (c)))
-                return c - '0';
-        c = toupper (c);
-        if (likely (isxdigit (c)))
-                return 10 + c - 'A';
-        return 0;
-}
-
-static inline int
-get_ethernet_addr (struct usbnet *dev, struct usb_cdc_ether_desc *e)
-{
-        int             tmp, i;
-        unsigned char   buf [13];
-
-        tmp = usb_string (dev->udev, e->iMACAddress, buf, sizeof buf);
-        if (tmp != 12) {
-                dev_dbg (&dev->udev->dev,
-                        "bad MAC string %d fetch, %d\n", e->iMACAddress, tmp);
-                if (tmp >= 0)
-                        tmp = -EINVAL;
-                return tmp;
-        }
-        for (i = tmp = 0; i < 6; i++, tmp += 2)
-                dev->net->dev_addr [i] =
-                         (nibble (buf [tmp]) << 4) + nibble (buf [tmp + 1]);
-        return 0;
-}
-
-static int cdc_bind (struct usbnet *dev, struct usb_interface *intf)
-{
-        int                             status;
-        struct cdc_state                *info = (void *) &dev->data;
-
-        status = generic_cdc_bind (dev, intf);
-        if (status < 0)
-                return status;
-
-        status = get_ethernet_addr (dev, info->ether);
-        if (status < 0) {
-                usb_set_intfdata(info->data, NULL);
-                usb_driver_release_interface (&usbnet_driver, info->data);
-                return status;
-        }
-
-        /* FIXME cdc-ether has some multicast code too, though it complains
-         * in routine cases.  info->ether describes the multicast support.
-         */
-        return 0;
-}
-
-static const struct driver_info cdc_info = {
-        .description =  "CDC Ethernet Device",
-        .flags =        FLAG_ETHER,
-        // .check_connect = cdc_check_connect,
-        .bind =         cdc_bind,
-        .unbind =       cdc_unbind,
-        .status =       cdc_status,
-};
-
-#endif  /* CONFIG_USB_CDCETHER */
-
-
-
-#ifdef  CONFIG_USB_EPSON2888
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * EPSON USB clients
- *
- * This is the same idea as Linux PDAs (below) except the firmware in the
- * device might not be Tux-powered.  Epson provides reference firmware that
- * implements this interface.  Product developers can reuse or modify that
- * code, such as by using their own product and vendor codes.
- *
- * Support was from Juro Bystricky <bystricky.juro@erd.epson.com>
- *
- *-------------------------------------------------------------------------*/
-
-static const struct driver_info epson2888_info = {
-        .description =  "Epson USB Device",
-        .check_connect = always_connected,
-
-        .in = 4, .out = 3,
-};
-
-#endif  /* CONFIG_USB_EPSON2888 */
-
-
-#ifdef CONFIG_USB_GENESYS
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * GeneSys GL620USB-A (www.genesyslogic.com.tw)
- *
- * ... should partially interop with the Win32 driver for this hardware
- * The GeneSys docs imply there's some NDIS issue motivating this framing.
- *
- * Some info from GeneSys:
- *  - GL620USB-A is full duplex; GL620USB is only half duplex for bulk.
- *    (Some cables, like the BAFO-100c, use the half duplex version.)
- *  - For the full duplex model, the low bit of the version code says
- *    which side is which ("left/right").
- *  - For the half duplex type, a control/interrupt handshake settles
- *    the transfer direction.  (That's disabled here, partially coded.)
- *    A control URB would block until other side writes an interrupt.
- *
- * Original code from Jiun-Jie Huang <huangjj@genesyslogic.com.tw>
- * and merged into "usbnet" by Stanislav Brabec <utx@penguin.cz>.
- *
- *-------------------------------------------------------------------------*/
-
-// control msg write command
-#define GENELINK_CONNECT_WRITE                  0xF0
-// interrupt pipe index
-#define GENELINK_INTERRUPT_PIPE                 0x03
-// interrupt read buffer size
-#define INTERRUPT_BUFSIZE                       0x08
-// interrupt pipe interval value
-#define GENELINK_INTERRUPT_INTERVAL             0x10
-// max transmit packet number per transmit
-#define GL_MAX_TRANSMIT_PACKETS                 32
-// max packet length
-#define GL_MAX_PACKET_LEN                       1514
-// max receive buffer size 
-#define GL_RCV_BUF_SIZE         \
-        (((GL_MAX_PACKET_LEN + 4) * GL_MAX_TRANSMIT_PACKETS) + 4)
-
-struct gl_packet {
-        u32             packet_length;
-        char            packet_data [1];
-};
-
-struct gl_header {
-        u32                     packet_count;
-        struct gl_packet        packets;
-};
-
-#ifdef  GENELINK_ACK
-
-// FIXME:  this code is incomplete, not debugged; it doesn't
-// handle interrupts correctly.  interrupts should be generic
-// code like all other device I/O, anyway.
-
-struct gl_priv { 
-        struct urb      *irq_urb;
-        char            irq_buf [INTERRUPT_BUFSIZE];
-};
-
-static inline int gl_control_write (struct usbnet *dev, u8 request, u16 value)
-{
-        int retval;
-
-        retval = usb_control_msg (dev->udev,
-                      usb_sndctrlpipe (dev->udev, 0),
-                      request,
-                      USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                      value, 
-                      0,                        // index
-                      0,                        // data buffer
-                      0,                        // size
-                      CONTROL_TIMEOUT_MS);
-        return retval;
-}
-
-static void gl_interrupt_complete (struct urb *urb, struct pt_regs *regs)
-{
-        int status = urb->status;
-        
-        switch (status) {
-        case 0:
-                /* success */
-                break;
-        case -ECONNRESET:
-        case -ENOENT:
-        case -ESHUTDOWN:
-                /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                                __FUNCTION__, status);
-                return;
-        default:
-                dbg("%s - nonzero urb status received: %d",
-                                __FUNCTION__, urb->status);
-        }
-
-        status = usb_submit_urb (urb, GFP_ATOMIC);
-        if (status)
-                err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, status);
-}
-
-static int gl_interrupt_read (struct usbnet *dev)
-{
-        struct gl_priv  *priv = dev->priv_data;
-        int             retval;
-
-        // issue usb interrupt read
-        if (priv && priv->irq_urb) {
-                // submit urb
-                if ((retval = usb_submit_urb (priv->irq_urb, GFP_KERNEL)) != 0)
-                        dbg ("gl_interrupt_read: submit fail - %X...", retval);
-                else
-                        dbg ("gl_interrupt_read: submit success...");
-        }
-
-        return 0;
-}
-
-// check whether another side is connected
-static int genelink_check_connect (struct usbnet *dev)
-{
-        int                     retval;
-
-        dbg ("genelink_check_connect...");
-
-        // detect whether another side is connected
-        if ((retval = gl_control_write (dev, GENELINK_CONNECT_WRITE, 0)) != 0) {
-                dbg ("%s: genelink_check_connect write fail - %X",
-                        dev->net->name, retval);
-                return retval;
-        }
-
-        // usb interrupt read to ack another side 
-        if ((retval = gl_interrupt_read (dev)) != 0) {
-                dbg ("%s: genelink_check_connect read fail - %X",
-                        dev->net->name, retval);
-                return retval;
-        }
-
-        dbg ("%s: genelink_check_connect read success", dev->net->name);
-        return 0;
-}
-
-// allocate and initialize the private data for genelink
-static int genelink_init (struct usbnet *dev)
-{
-        struct gl_priv *priv;
-
-        // allocate the private data structure
-        if ((priv = kmalloc (sizeof *priv, GFP_KERNEL)) == 0) {
-                dbg ("%s: cannot allocate private data per device",
-                        dev->net->name);
-                return -ENOMEM;
-        }
-
-        // allocate irq urb
-        if ((priv->irq_urb = usb_alloc_urb (0, GFP_KERNEL)) == 0) {
-                dbg ("%s: cannot allocate private irq urb per device",
-                        dev->net->name);
-                kfree (priv);
-                return -ENOMEM;
-        }
-
-        // fill irq urb
-        usb_fill_int_urb (priv->irq_urb, dev->udev,
-                usb_rcvintpipe (dev->udev, GENELINK_INTERRUPT_PIPE),
-                priv->irq_buf, INTERRUPT_BUFSIZE,
-                gl_interrupt_complete, 0,
-                GENELINK_INTERRUPT_INTERVAL);
-
-        // set private data pointer
-        dev->priv_data = priv;
-
-        return 0;
-}
-
-// release the private data
-static int genelink_free (struct usbnet *dev)
-{
-        struct gl_priv  *priv = dev->priv_data;
-
-        if (!priv) 
-                return 0;
-
-// FIXME:  can't cancel here; it's synchronous, and
-// should have happened earlier in any case (interrupt
-// handling needs to be generic)
-
-        // cancel irq urb first
-        usb_kill_urb (priv->irq_urb);
-
-        // free irq urb
-        usb_free_urb (priv->irq_urb);
-
-        // free the private data structure
-        kfree (priv);
-
-        return 0;
-}
-
-#endif
-
-static int genelink_rx_fixup (struct usbnet *dev, struct sk_buff *skb)
-{
-        struct gl_header        *header;
-        struct gl_packet        *packet;
-        struct sk_buff          *gl_skb;
-        u32                     size;
-
-        header = (struct gl_header *) skb->data;
-
-        // get the packet count of the received skb
-        le32_to_cpus (&header->packet_count);
-        if ((header->packet_count > GL_MAX_TRANSMIT_PACKETS)
-                        || (header->packet_count < 0)) {
-                dbg ("genelink: invalid received packet count %d",
-                        header->packet_count);
-                return 0;
-        }
-
-        // set the current packet pointer to the first packet
-        packet = &header->packets;
-
-        // decrement the length for the packet count size 4 bytes
-        skb_pull (skb, 4);
-
-        while (header->packet_count > 1) {
-                // get the packet length
-                size = packet->packet_length;
-
-                // this may be a broken packet
-                if (size > GL_MAX_PACKET_LEN) {
-                        dbg ("genelink: invalid rx length %d", size);
-                        return 0;
-                }
-
-                // allocate the skb for the individual packet
-                gl_skb = alloc_skb (size, GFP_ATOMIC);
-                if (gl_skb) {
-
-                        // copy the packet data to the new skb
-                        memcpy(skb_put(gl_skb, size), packet->packet_data, size);
-                        skb_return (dev, gl_skb);
-                }
-
-                // advance to the next packet
-                packet = (struct gl_packet *)
-                        &packet->packet_data [size];
-                header->packet_count--;
-
-                // shift the data pointer to the next gl_packet
-                skb_pull (skb, size + 4);
-        }
-
-        // skip the packet length field 4 bytes
-        skb_pull (skb, 4);
-
-        if (skb->len > GL_MAX_PACKET_LEN) {
-                dbg ("genelink: invalid rx length %d", skb->len);
-                return 0;
-        }
-        return 1;
-}
-
-static struct sk_buff *
-genelink_tx_fixup (struct usbnet *dev, struct sk_buff *skb, int flags)
-{
-        int     padlen;
-        int     length = skb->len;
-        int     headroom = skb_headroom (skb);
-        int     tailroom = skb_tailroom (skb);
-        u32     *packet_count;
-        u32     *packet_len;
-
-        // FIXME:  magic numbers, bleech
-        padlen = ((skb->len + (4 + 4*1)) % 64) ? 0 : 1;
-
-        if ((!skb_cloned (skb))
-                        && ((headroom + tailroom) >= (padlen + (4 + 4*1)))) {
-                if ((headroom < (4 + 4*1)) || (tailroom < padlen)) {
-                        skb->data = memmove (skb->head + (4 + 4*1),
-                                             skb->data, skb->len);
-                        skb->tail = skb->data + skb->len;
-                }
-        } else {
-                struct sk_buff  *skb2;
-                skb2 = skb_copy_expand (skb, (4 + 4*1) , padlen, flags);
-                dev_kfree_skb_any (skb);
-                skb = skb2;
-                if (!skb)
-                        return NULL;
-        }
-
-        // attach the packet count to the header
-        packet_count = (u32 *) skb_push (skb, (4 + 4*1));
-        packet_len = packet_count + 1;
-
-        // FIXME little endian?
-        *packet_count = 1;
-        *packet_len = length;
-
-        // add padding byte
-        if ((skb->len % dev->maxpacket) == 0)
-                skb_put (skb, 1);
-
-        return skb;
-}
-
-static const struct driver_info genelink_info = {
-        .description =  "Genesys GeneLink",
-        .flags =        FLAG_FRAMING_GL | FLAG_NO_SETINT,
-        .rx_fixup =     genelink_rx_fixup,
-        .tx_fixup =     genelink_tx_fixup,
-
-        .in = 1, .out = 2,
-
-#ifdef  GENELINK_ACK
-        .check_connect =genelink_check_connect,
-#endif
-};
-
-#endif /* CONFIG_USB_GENESYS */
-
-
-
-#ifdef  CONFIG_USB_NET1080
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * Netchip 1080 driver ... http://www.netchip.com
- * Used in LapLink cables
- *
- *-------------------------------------------------------------------------*/
-
-#define dev_packet_id   data[0]
-#define frame_errors    data[1]
-
-/*
- * NetChip framing of ethernet packets, supporting additional error
- * checks for links that may drop bulk packets from inside messages.
- * Odd USB length == always short read for last usb packet.
- *      - nc_header
- *      - Ethernet header (14 bytes)
- *      - payload
- *      - (optional padding byte, if needed so length becomes odd)
- *      - nc_trailer
- *
- * This framing is to be avoided for non-NetChip devices.
- */
-
-struct nc_header {              // packed:
-        __le16  hdr_len;                // sizeof nc_header (LE, all)
-        __le16  packet_len;             // payload size (including ethhdr)
-        __le16  packet_id;              // detects dropped packets
-#define MIN_HEADER      6
-
-        // all else is optional, and must start with:
-        // u16  vendorId;               // from usb-if
-        // u16  productId;
-} __attribute__((__packed__));
-
-#define PAD_BYTE        ((unsigned char)0xAC)
-
-struct nc_trailer {
-        __le16  packet_id;
-} __attribute__((__packed__));
-
-// packets may use FLAG_FRAMING_NC and optional pad
-#define FRAMED_SIZE(mtu) (sizeof (struct nc_header) \
-                                + sizeof (struct ethhdr) \
-                                + (mtu) \
-                                + 1 \
-                                + sizeof (struct nc_trailer))
-
-#define MIN_FRAMED      FRAMED_SIZE(0)
-
-
-/*
- * Zero means no timeout; else, how long a 64 byte bulk packet may be queued
- * before the hardware drops it.  If that's done, the driver will need to
- * frame network packets to guard against the dropped USB packets.  The win32
- * driver sets this for both sides of the link.
- */
-#define NC_READ_TTL_MS  ((u8)255)       // ms
-
-/*
- * We ignore most registers and EEPROM contents.
- */
-#define REG_USBCTL      ((u8)0x04)
-#define REG_TTL         ((u8)0x10)
-#define REG_STATUS      ((u8)0x11)
-
-/*
- * Vendor specific requests to read/write data
- */
-#define REQUEST_REGISTER        ((u8)0x10)
-#define REQUEST_EEPROM          ((u8)0x11)
-
-static int
-nc_vendor_read (struct usbnet *dev, u8 req, u8 regnum, u16 *retval_ptr)
-{
-        int status = usb_control_msg (dev->udev,
-                usb_rcvctrlpipe (dev->udev, 0),
-                req,
-                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                0, regnum,
-                retval_ptr, sizeof *retval_ptr,
-                CONTROL_TIMEOUT_MS);
-        if (status > 0)
-                status = 0;
-        if (!status)
-                le16_to_cpus (retval_ptr);
-        return status;
-}
-
-static inline int
-nc_register_read (struct usbnet *dev, u8 regnum, u16 *retval_ptr)
-{
-        return nc_vendor_read (dev, REQUEST_REGISTER, regnum, retval_ptr);
-}
-
-// no retval ... can become async, usable in_interrupt()
-static void
-nc_vendor_write (struct usbnet *dev, u8 req, u8 regnum, u16 value)
-{
-        usb_control_msg (dev->udev,
-                usb_sndctrlpipe (dev->udev, 0),
-                req,
-                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                value, regnum,
-                NULL, 0,                        // data is in setup packet
-                CONTROL_TIMEOUT_MS);
-}
-
-static inline void
-nc_register_write (struct usbnet *dev, u8 regnum, u16 value)
-{
-        nc_vendor_write (dev, REQUEST_REGISTER, regnum, value);
-}
-
-
-#if 0
-static void nc_dump_registers (struct usbnet *dev)
-{
-        u8      reg;
-        u16     *vp = kmalloc (sizeof (u16));
-
-        if (!vp) {
-                dbg ("no memory?");
-                return;
-        }
-
-        dbg ("%s registers:", dev->net->name);
-        for (reg = 0; reg < 0x20; reg++) {
-                int retval;
-
-                // reading some registers is trouble
-                if (reg >= 0x08 && reg <= 0xf)
-                        continue;
-                if (reg >= 0x12 && reg <= 0x1e)
-                        continue;
-
-                retval = nc_register_read (dev, reg, vp);
-                if (retval < 0)
-                        dbg ("%s reg [0x%x] ==> error %d",
-                                dev->net->name, reg, retval);
-                else
-                        dbg ("%s reg [0x%x] = 0x%x",
-                                dev->net->name, reg, *vp);
-        }
-        kfree (vp);
-}
-#endif
-
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Control register
- */
-
-#define USBCTL_WRITABLE_MASK    0x1f0f
-// bits 15-13 reserved, r/o
-#define USBCTL_ENABLE_LANG      (1 << 12)
-#define USBCTL_ENABLE_MFGR      (1 << 11)
-#define USBCTL_ENABLE_PROD      (1 << 10)
-#define USBCTL_ENABLE_SERIAL    (1 << 9)
-#define USBCTL_ENABLE_DEFAULTS  (1 << 8)
-// bits 7-4 reserved, r/o
-#define USBCTL_FLUSH_OTHER      (1 << 3)
-#define USBCTL_FLUSH_THIS       (1 << 2)
-#define USBCTL_DISCONN_OTHER    (1 << 1)
-#define USBCTL_DISCONN_THIS     (1 << 0)
-
-static inline void nc_dump_usbctl (struct usbnet *dev, u16 usbctl)
-{
-        if (!netif_msg_link (dev))
-                return;
-        devdbg (dev, "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s;"
-                        " this%s%s;"
-                        " other%s%s; r/o 0x%x",
-                dev->udev->bus->bus_name, dev->udev->devpath,
-                usbctl,
-                (usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
-                (usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
-                (usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
-                (usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
-                (usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",
-
-                (usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
-                (usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",
-                (usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
-                (usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",
-                usbctl & ~USBCTL_WRITABLE_MASK
-                );
-}
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * Status register
- */
-
-#define STATUS_PORT_A           (1 << 15)
-
-#define STATUS_CONN_OTHER       (1 << 14)
-#define STATUS_SUSPEND_OTHER    (1 << 13)
-#define STATUS_MAILBOX_OTHER    (1 << 12)
-#define STATUS_PACKETS_OTHER(n) (((n) >> 8) && 0x03)
-
-#define STATUS_CONN_THIS        (1 << 6)
-#define STATUS_SUSPEND_THIS     (1 << 5)
-#define STATUS_MAILBOX_THIS     (1 << 4)
-#define STATUS_PACKETS_THIS(n)  (((n) >> 0) && 0x03)
-
-#define STATUS_UNSPEC_MASK      0x0c8c
-#define STATUS_NOISE_MASK       ((u16)~(0x0303|STATUS_UNSPEC_MASK))
-
-
-static inline void nc_dump_status (struct usbnet *dev, u16 status)
-{
-        if (!netif_msg_link (dev))
-                return;
-        devdbg (dev, "net1080 %s-%s status 0x%x:"
-                        " this (%c) PKT=%d%s%s%s;"
-                        " other PKT=%d%s%s%s; unspec 0x%x",
-                dev->udev->bus->bus_name, dev->udev->devpath,
-                status,
-
-                // XXX the packet counts don't seem right
-                // (1 at reset, not 0); maybe UNSPEC too
-
-                (status & STATUS_PORT_A) ? 'A' : 'B',
-                STATUS_PACKETS_THIS (status),
-                (status & STATUS_CONN_THIS) ? " CON" : "",
-                (status & STATUS_SUSPEND_THIS) ? " SUS" : "",
-                (status & STATUS_MAILBOX_THIS) ? " MBOX" : "",
-
-                STATUS_PACKETS_OTHER (status),
-                (status & STATUS_CONN_OTHER) ? " CON" : "",
-                (status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
-                (status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",
-
-                status & STATUS_UNSPEC_MASK
-                );
-}
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * TTL register
- */
-
-#define TTL_THIS(ttl)   (0x00ff & ttl)
-#define TTL_OTHER(ttl)  (0x00ff & (ttl >> 8))
-#define MK_TTL(this,other)      ((u16)(((other)<<8)|(0x00ff&(this))))
-
-static inline void nc_dump_ttl (struct usbnet *dev, u16 ttl)
-{
-        if (netif_msg_link (dev))
-                devdbg (dev, "net1080 %s-%s ttl 0x%x this = %d, other = %d",
-                        dev->udev->bus->bus_name, dev->udev->devpath,
-                        ttl, TTL_THIS (ttl), TTL_OTHER (ttl));
-}
-
-/*-------------------------------------------------------------------------*/
-
-static int net1080_reset (struct usbnet *dev)
-{
-        u16             usbctl, status, ttl;
-        u16             *vp = kmalloc (sizeof (u16), GFP_KERNEL);
-        int             retval;
-
-        if (!vp)
-                return -ENOMEM;
-
-        // nc_dump_registers (dev);
-
-        if ((retval = nc_register_read (dev, REG_STATUS, vp)) < 0) {
-                dbg ("can't read %s-%s status: %d",
-                        dev->udev->bus->bus_name, dev->udev->devpath, retval);
-                goto done;
-        }
-        status = *vp;
-        nc_dump_status (dev, status);
-
-        if ((retval = nc_register_read (dev, REG_USBCTL, vp)) < 0) {
-                dbg ("can't read USBCTL, %d", retval);
-                goto done;
-        }
-        usbctl = *vp;
-        nc_dump_usbctl (dev, usbctl);
-
-        nc_register_write (dev, REG_USBCTL,
-                        USBCTL_FLUSH_THIS | USBCTL_FLUSH_OTHER);
-
-        if ((retval = nc_register_read (dev, REG_TTL, vp)) < 0) {
-                dbg ("can't read TTL, %d", retval);
-                goto done;
-        }
-        ttl = *vp;
-        // nc_dump_ttl (dev, ttl);
-
-        nc_register_write (dev, REG_TTL,
-                        MK_TTL (NC_READ_TTL_MS, TTL_OTHER (ttl)) );
-        dbg ("%s: assigned TTL, %d ms", dev->net->name, NC_READ_TTL_MS);
-
-        if (netif_msg_link (dev))
-                devinfo (dev, "port %c, peer %sconnected",
-                        (status & STATUS_PORT_A) ? 'A' : 'B',
-                        (status & STATUS_CONN_OTHER) ? "" : "dis"
-                        );
-        retval = 0;
-
-done:
-        kfree (vp);
-        return retval;
-}
-
-static int net1080_check_connect (struct usbnet *dev)
-{
-        int                     retval;
-        u16                     status;
-        u16                     *vp = kmalloc (sizeof (u16), GFP_KERNEL);
-
-        if (!vp)
-                return -ENOMEM;
-        retval = nc_register_read (dev, REG_STATUS, vp);
-        status = *vp;
-        kfree (vp);
-        if (retval != 0) {
-                dbg ("%s net1080_check_conn read - %d", dev->net->name, retval);
-                return retval;
-        }
-        if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
-                return -ENOLINK;
-        return 0;
-}
-
-static void nc_flush_complete (struct urb *urb, struct pt_regs *regs)
-{
-        kfree (urb->context);
-        usb_free_urb(urb);
-}
-
-static void nc_ensure_sync (struct usbnet *dev)
-{
-        dev->frame_errors++;
-        if (dev->frame_errors > 5) {
-                struct urb              *urb;
-                struct usb_ctrlrequest  *req;
-                int                     status;
-
-                /* Send a flush */
-                urb = usb_alloc_urb (0, SLAB_ATOMIC);
-                if (!urb)
-                        return;
-
-                req = kmalloc (sizeof *req, GFP_ATOMIC);
-                if (!req) {
-                        usb_free_urb (urb);
-                        return;
-                }
-
-                req->bRequestType = USB_DIR_OUT
-                        | USB_TYPE_VENDOR
-                        | USB_RECIP_DEVICE;
-                req->bRequest = REQUEST_REGISTER;
-                req->wValue = cpu_to_le16 (USBCTL_FLUSH_THIS
-                                | USBCTL_FLUSH_OTHER);
-                req->wIndex = cpu_to_le16 (REG_USBCTL);
-                req->wLength = cpu_to_le16 (0);
-
-                /* queue an async control request, we don't need
-                 * to do anything when it finishes except clean up.
-                 */
-                usb_fill_control_urb (urb, dev->udev,
-                        usb_sndctrlpipe (dev->udev, 0),
-                        (unsigned char *) req,
-                        NULL, 0,
-                        nc_flush_complete, req);
-                status = usb_submit_urb (urb, GFP_ATOMIC);
-                if (status) {
-                        kfree (req);
-                        usb_free_urb (urb);
-                        return;
-                }
-
-                if (netif_msg_rx_err (dev))
-                        devdbg (dev, "flush net1080; too many framing errors");
-                dev->frame_errors = 0;
-        }
-}
-
-static int net1080_rx_fixup (struct usbnet *dev, struct sk_buff *skb)
-{
-        struct nc_header        *header;
-        struct nc_trailer       *trailer;
-        u16                     hdr_len, packet_len;
-
-        if (!(skb->len & 0x01)
-                        || MIN_FRAMED > skb->len
-                        || skb->len > FRAMED_SIZE (dev->net->mtu)) {
-                dev->stats.rx_frame_errors++;
-                dbg ("rx framesize %d range %d..%d mtu %d", skb->len,
-                        (int)MIN_FRAMED, (int)FRAMED_SIZE (dev->net->mtu),
-                        dev->net->mtu);
-                nc_ensure_sync (dev);
-                return 0;
-        }
-
-        header = (struct nc_header *) skb->data;
-        hdr_len = le16_to_cpup (&header->hdr_len);
-        packet_len = le16_to_cpup (&header->packet_len);
-        if (FRAMED_SIZE (packet_len) > MAX_PACKET) {
-                dev->stats.rx_frame_errors++;
-                dbg ("packet too big, %d", packet_len);
-                nc_ensure_sync (dev);
-                return 0;
-        } else if (hdr_len < MIN_HEADER) {
-                dev->stats.rx_frame_errors++;
-                dbg ("header too short, %d", hdr_len);
-                nc_ensure_sync (dev);
-                return 0;
-        } else if (hdr_len > MIN_HEADER) {
-                // out of band data for us?
-                dbg ("header OOB, %d bytes", hdr_len - MIN_HEADER);
-                nc_ensure_sync (dev);
-                // switch (vendor/product ids) { ... }
-        }
-        skb_pull (skb, hdr_len);
-
-        trailer = (struct nc_trailer *)
-                (skb->data + skb->len - sizeof *trailer);
-        skb_trim (skb, skb->len - sizeof *trailer);
-
-        if ((packet_len & 0x01) == 0) {
-                if (skb->data [packet_len] != PAD_BYTE) {
-                        dev->stats.rx_frame_errors++;
-                        dbg ("bad pad");
-                        return 0;
-                }
-                skb_trim (skb, skb->len - 1);
-        }
-        if (skb->len != packet_len) {
-                dev->stats.rx_frame_errors++;
-                dbg ("bad packet len %d (expected %d)",
-                        skb->len, packet_len);
-                nc_ensure_sync (dev);
-                return 0;
-        }
-        if (header->packet_id != get_unaligned (&trailer->packet_id)) {
-                dev->stats.rx_fifo_errors++;
-                dbg ("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
-                        le16_to_cpu (header->packet_id),
-                        le16_to_cpu (trailer->packet_id));
-                return 0;
-        }
-#if 0
-        devdbg (dev, "frame <rx h %d p %d id %d", header->hdr_len,
-                header->packet_len, header->packet_id);
-#endif
-        dev->frame_errors = 0;
-        return 1;
-}
-
-static struct sk_buff *
-net1080_tx_fixup (struct usbnet *dev, struct sk_buff *skb, int flags)
-{
-        int                     padlen;
-        struct sk_buff          *skb2;
-
-        padlen = ((skb->len + sizeof (struct nc_header)
-                        + sizeof (struct nc_trailer)) & 0x01) ? 0 : 1;
-        if (!skb_cloned (skb)) {
-                int     headroom = skb_headroom (skb);
-                int     tailroom = skb_tailroom (skb);
-
-                if ((padlen + sizeof (struct nc_trailer)) <= tailroom
-                            && sizeof (struct nc_header) <= headroom)
-                        /* There's enough head and tail room */
-                        return skb;
-
-                if ((sizeof (struct nc_header) + padlen
-                                        + sizeof (struct nc_trailer)) <
-                                (headroom + tailroom)) {
-                        /* There's enough total room, so just readjust */
-                        skb->data = memmove (skb->head
-                                                + sizeof (struct nc_header),
-                                            skb->data, skb->len);
-                        skb->tail = skb->data + skb->len;
-                        return skb;
-                }
-        }
-
-        /* Create a new skb to use with the correct size */
-        skb2 = skb_copy_expand (skb,
-                                sizeof (struct nc_header),
-                                sizeof (struct nc_trailer) + padlen,
-                                flags);
-        dev_kfree_skb_any (skb);
-        return skb2;
-}
-
-static const struct driver_info net1080_info = {
-        .description =  "NetChip TurboCONNECT",
-        .flags =        FLAG_FRAMING_NC,
-        .reset =        net1080_reset,
-        .check_connect =net1080_check_connect,
-        .rx_fixup =     net1080_rx_fixup,
-        .tx_fixup =     net1080_tx_fixup,
-};
-
-#endif /* CONFIG_USB_NET1080 */
-
-
-
-#ifdef CONFIG_USB_PL2301
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * Prolific PL-2301/PL-2302 driver ... http://www.prolifictech.com
- *
- * The protocol and handshaking used here should be bug-compatible
- * with the Linux 2.2 "plusb" driver, by Deti Fliegl.
- *
- *-------------------------------------------------------------------------*/
-
-/*
- * Bits 0-4 can be used for software handshaking; they're set from
- * one end, cleared from the other, "read" with the interrupt byte.
- */
-#define PL_S_EN         (1<<7)          /* (feature only) suspend enable */
-/* reserved bit -- rx ready (6) ? */
-#define PL_TX_READY     (1<<5)          /* (interrupt only) transmit ready */
-#define PL_RESET_OUT    (1<<4)          /* reset output pipe */
-#define PL_RESET_IN     (1<<3)          /* reset input pipe */
-#define PL_TX_C         (1<<2)          /* transmission complete */
-#define PL_TX_REQ       (1<<1)          /* transmission received */
-#define PL_PEER_E       (1<<0)          /* peer exists */
-
-static inline int
-pl_vendor_req (struct usbnet *dev, u8 req, u8 val, u8 index)
-{
-        return usb_control_msg (dev->udev,
-                usb_rcvctrlpipe (dev->udev, 0),
-                req,
-                USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
-                val, index,
-                NULL, 0,
-                CONTROL_TIMEOUT_MS);
-}
-
-static inline int
-pl_clear_QuickLink_features (struct usbnet *dev, int val)
-{
-        return pl_vendor_req (dev, 1, (u8) val, 0);
-}
-
-static inline int
-pl_set_QuickLink_features (struct usbnet *dev, int val)
-{
-        return pl_vendor_req (dev, 3, (u8) val, 0);
-}
-
-/*-------------------------------------------------------------------------*/
-
-static int pl_reset (struct usbnet *dev)
-{
-        /* some units seem to need this reset, others reject it utterly.
-         * FIXME be more like "naplink" or windows drivers.
-         */
-        (void) pl_set_QuickLink_features (dev,
-                PL_S_EN|PL_RESET_OUT|PL_RESET_IN|PL_PEER_E);
-        return 0;
-}
-
-static const struct driver_info prolific_info = {
-        .description =  "Prolific PL-2301/PL-2302",
-        .flags =        FLAG_NO_SETINT,
-                /* some PL-2302 versions seem to fail usb_set_interface() */
-        .reset =        pl_reset,
-};
-
-#endif /* CONFIG_USB_PL2301 */
-
-
-#ifdef CONFIG_USB_KC2190
-#define HAVE_HARDWARE
-static const struct driver_info kc2190_info = {
-        .description =  "KC Technology KC-190",
-};
-#endif /* CONFIG_USB_KC2190 */
-
-
-#ifdef  CONFIG_USB_ARMLINUX
-#define HAVE_HARDWARE
-
-/*-------------------------------------------------------------------------
- *
- * Intel's SA-1100 chip integrates basic USB support, and is used
- * in PDAs like some iPaqs, the Yopy, some Zaurus models, and more.
- * When they run Linux, arch/arm/mach-sa1100/usb-eth.c may be used to
- * network using minimal USB framing data.
- *
- * This describes the driver currently in standard ARM Linux kernels.
- * The Zaurus uses a different driver (see later).
- *
- * PXA25x and PXA210 use XScale cores (ARM v5TE) with better USB support
- * and different USB endpoint numbering than the SA1100 devices.  The
- * mach-pxa/usb-eth.c driver re-uses the device ids from mach-sa1100
- * so we rely on the endpoint descriptors.
- *
- *-------------------------------------------------------------------------*/
-
-static const struct driver_info linuxdev_info = {
-        .description =  "Linux Device",
-        .check_connect = always_connected,
-};
-
-static const struct driver_info yopy_info = {
-        .description =  "Yopy",
-        .check_connect = always_connected,
-};
-
-static const struct driver_info blob_info = {
-        .description =  "Boot Loader OBject",
-        .check_connect = always_connected,
-};
-
-#endif  /* CONFIG_USB_ARMLINUX */
-
-
-#ifdef CONFIG_USB_ZAURUS
-#define HAVE_HARDWARE
-
-#include <linux/crc32.h>
-
-/*-------------------------------------------------------------------------
- *
- * Zaurus is also a SA-1110 based PDA, but one using a different driver
- * (and framing) for its USB slave/gadget controller than the case above.
- *
- * For the current version of that driver, the main way that framing is
- * nonstandard (also from perspective of the CDC ethernet model!) is a
- * crc32, added to help detect when some sa1100 usb-to-memory DMA errata
- * haven't been fully worked around.  Also, all Zaurii use the same
- * default Ethernet address.
- *
- * PXA based models use the same framing, and also can't implement
- * set_interface properly.
- *
- * All known Zaurii lie about their standards conformance.  Most lie by
- * saying they support CDC Ethernet.  Some lie and say they support CDC
- * MDLM (as if for access to cell phone modems).  Someone, please beat 
- * on Sharp (and other such vendors) for a while with a cluestick.
- *
- *-------------------------------------------------------------------------*/
-
-static struct sk_buff *
-zaurus_tx_fixup (struct usbnet *dev, struct sk_buff *skb, int flags)
-{
-        int                     padlen;
-        struct sk_buff          *skb2;
-
-        padlen = 2;
-        if (!skb_cloned (skb)) {
-                int     tailroom = skb_tailroom (skb);
-                if ((padlen + 4) <= tailroom)
-                        goto done;
-        }
-        skb2 = skb_copy_expand (skb, 0, 4 + padlen, flags);
-        dev_kfree_skb_any (skb);
-        skb = skb2;
-        if (skb) {
-                u32             fcs;
-done:
-                fcs = crc32_le (~0, skb->data, skb->len);
-                fcs = ~fcs;
-
-                *skb_put (skb, 1) = fcs       & 0xff;
-                *skb_put (skb, 1) = (fcs>> 8) & 0xff;
-                *skb_put (skb, 1) = (fcs>>16) & 0xff;
-                *skb_put (skb, 1) = (fcs>>24) & 0xff;
-        }
-        return skb;
-}
-
-static const struct driver_info zaurus_sl5x00_info = {
-        .description =  "Sharp Zaurus SL-5x00",
-        .flags =        FLAG_FRAMING_Z,
-        .check_connect = always_connected,
-        .bind =         generic_cdc_bind,
-        .unbind =       cdc_unbind,
-        .tx_fixup =     zaurus_tx_fixup,
-};
-#define ZAURUS_STRONGARM_INFO   ((unsigned long)&zaurus_sl5x00_info)
-
-static const struct driver_info zaurus_pxa_info = {
-        .description =  "Sharp Zaurus, PXA-2xx based",
-        .flags =        FLAG_FRAMING_Z,
-        .check_connect = always_connected,
-        .bind =         generic_cdc_bind,
-        .unbind =       cdc_unbind,
-        .tx_fixup =     zaurus_tx_fixup,
-};
-#define ZAURUS_PXA_INFO         ((unsigned long)&zaurus_pxa_info)
-
-static const struct driver_info olympus_mxl_info = {
-        .description =  "Olympus R1000",
-        .flags =        FLAG_FRAMING_Z,
-        .check_connect = always_connected,
-        .bind =         generic_cdc_bind,
-        .unbind =       cdc_unbind,
-        .tx_fixup =     zaurus_tx_fixup,
-};
-#define OLYMPUS_MXL_INFO        ((unsigned long)&olympus_mxl_info)
-
-
-/* Some more recent products using Lineo/Belcarra code will wrongly claim
- * CDC MDLM conformance.  They aren't conformant:  data endpoints live
- * in the control interface, there's no data interface, and it's not used
- * to talk to a cell phone radio.  But at least we can detect these two
- * pseudo-classes, rather than growing this product list with entries for
- * each new nonconformant product (sigh).
- */
-static const u8 safe_guid[16] = {
-        0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
-        0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
-};
-static const u8 blan_guid[16] = {
-        0x74, 0xf0, 0x3d, 0xbd, 0x1e, 0xc1, 0x44, 0x70,
-        0xa3, 0x67, 0x71, 0x34, 0xc9, 0xf5, 0x54, 0x37,
-};
-
-static int blan_mdlm_bind (struct usbnet *dev, struct usb_interface *intf)
-{
-        u8                              *buf = intf->cur_altsetting->extra;
-        int                             len = intf->cur_altsetting->extralen;
-        struct usb_cdc_mdlm_desc        *desc = NULL;
-        struct usb_cdc_mdlm_detail_desc *detail = NULL;
-
-        while (len > 3) {
-                if (buf [1] != USB_DT_CS_INTERFACE)
-                        goto next_desc;
-
-                /* use bDescriptorSubType, and just verify that we get a
-                 * "BLAN" (or "SAFE") descriptor.
-                 */
-                switch (buf [2]) {
-                case USB_CDC_MDLM_TYPE:
-                        if (desc) {
-                                dev_dbg (&intf->dev, "extra MDLM\n");
-                                goto bad_desc;
-                        }
-                        desc = (void *) buf;
-                        if (desc->bLength != sizeof *desc) {
-                                dev_dbg (&intf->dev, "MDLM len %u\n",
-                                        desc->bLength);
-                                goto bad_desc;
-                        }
-                        /* expect bcdVersion 1.0, ignore */
-                        if (memcmp(&desc->bGUID, blan_guid, 16)
-                                    && memcmp(&desc->bGUID, safe_guid, 16) ) {
-                                /* hey, this one might _really_ be MDLM! */
-                                dev_dbg (&intf->dev, "MDLM guid\n");
-                                goto bad_desc;
-                        }
-                        break;
-                case USB_CDC_MDLM_DETAIL_TYPE:
-                        if (detail) {
-                                dev_dbg (&intf->dev, "extra MDLM detail\n");
-                                goto bad_desc;
-                        }
-                        detail = (void *) buf;
-                        switch (detail->bGuidDescriptorType) {
-                        case 0:                 /* "SAFE" */
-                                if (detail->bLength != (sizeof *detail + 2))
-                                        goto bad_detail;
-                                break;
-                        case 1:                 /* "BLAN" */
-                                if (detail->bLength != (sizeof *detail + 3))
-                                        goto bad_detail;
-                                break;
-                        default:
-                                goto bad_detail;
-                        }
-
-                        /* assuming we either noticed BLAN already, or will
-                         * find it soon, there are some data bytes here:
-                         *  - bmNetworkCapabilities (unused)
-                         *  - bmDataCapabilities (bits, see below)
-                         *  - bPad (ignored, for PADAFTER -- BLAN-only)
-                         * bits are:
-                         *  - 0x01 -- Zaurus framing (add CRC)
-                         *  - 0x02 -- PADBEFORE (CRC includes some padding)
-                         *  - 0x04 -- PADAFTER (some padding after CRC)
-                         *  - 0x08 -- "fermat" packet mangling (for hw bugs)
-                         * the PADBEFORE appears not to matter; we interop
-                         * with devices that use it and those that don't.
-                         */
-                        if ((detail->bDetailData[1] & ~02) != 0x01) {
-                                /* bmDataCapabilites == 0 would be fine too,
-                                 * but framing is minidriver-coupled for now.
-                                 */
-bad_detail:
-                                dev_dbg (&intf->dev,
-                                                "bad MDLM detail, %d %d %d\n",
-                                                detail->bLength,
-                                                detail->bDetailData[0],
-                                                detail->bDetailData[2]);
-                                goto bad_desc;
-                        }
-                        break;
-                }
-next_desc:
-                len -= buf [0]; /* bLength */
-                buf += buf [0];
-        }
-
-        if (!desc || !detail) {
-                dev_dbg (&intf->dev, "missing cdc mdlm %s%sdescriptor\n",
-                        desc ? "" : "func ",
-                        detail ? "" : "detail ");
-                goto bad_desc;
-        }
-
-        /* There's probably a CDC Ethernet descriptor there, but we can't
-         * rely on the Ethernet address it provides since not all vendors
-         * bother to make it unique.  Likewise there's no point in tracking
-         * of the CDC event notifications.
-         */
-        return get_endpoints (dev, intf);
-
-bad_desc:
-        dev_info (&dev->udev->dev, "unsupported MDLM descriptors\n");
-        return -ENODEV;
-}
-
-static const struct driver_info bogus_mdlm_info = {
-        .description =  "pseudo-MDLM (BLAN) device",
-        .flags =        FLAG_FRAMING_Z,
-        .check_connect = always_connected,
-        .tx_fixup =     zaurus_tx_fixup,
-        .bind =         blan_mdlm_bind,
-};
-
-#else
-
-/* blacklist all those devices */
-#define ZAURUS_STRONGARM_INFO   0
-#define ZAURUS_PXA_INFO         0
-#define OLYMPUS_MXL_INFO        0
-
-#endif
+EXPORT_SYMBOL_GPL(usbnet_skb_return);
 
 
 /*-------------------------------------------------------------------------
@@ -2868,22 +230,12 @@ static const struct driver_info	bogus_mdlm_info = {
 static int usbnet_change_mtu (struct net_device *net, int new_mtu)
 {
         struct usbnet   *dev = netdev_priv(net);
+        int             ll_mtu = new_mtu + net->hard_header_len;
 
-        if (new_mtu <= MIN_PACKET || new_mtu > MAX_PACKET)
+        if (new_mtu <= 0 || ll_mtu > dev->hard_mtu)
                 return -EINVAL;
-#ifdef  CONFIG_USB_NET1080
-        if (((dev->driver_info->flags) & FLAG_FRAMING_NC)) {
-                if (FRAMED_SIZE (new_mtu) > MAX_PACKET)
-                        return -EINVAL;
-        }
-#endif
-#ifdef  CONFIG_USB_GENESYS
-        if (((dev->driver_info->flags) & FLAG_FRAMING_GL)
-                        && new_mtu > GL_MAX_PACKET_LEN)
-                return -EINVAL;
-#endif
         // no second zero-length packet read wanted after mtu-sized packets
-        if (((new_mtu + sizeof (struct ethhdr)) % dev->maxpacket) == 0)
+        if ((ll_mtu % dev->maxpacket) == 0)
                 return -EDOM;
         net->mtu = new_mtu;
         return 0;
@@ -2922,7 +274,7 @@ static void defer_bh(struct usbnet *dev, struct sk_buff *skb, struct sk_buff_hea
  * NOTE:  annoying asymmetry:  if it's active, schedule_work() fails,
  * but tasklet_schedule() doesn't.  hope the failure is rare.
  */
-static void defer_kevent (struct usbnet *dev, int work)
+void usbnet_defer_kevent (struct usbnet *dev, int work)
 {
         set_bit (work, &dev->flags);
         if (!schedule_work (&dev->kevent))
@@ -2930,50 +282,24 @@ static void defer_kevent (struct usbnet *dev, int work)
         else
                 devdbg (dev, "kevent %d scheduled", work);
 }
+EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
 
 /*-------------------------------------------------------------------------*/
 
 static void rx_complete (struct urb *urb, struct pt_regs *regs);
 
-static void rx_submit (struct usbnet *dev, struct urb *urb, int flags)
+static void rx_submit (struct usbnet *dev, struct urb *urb, unsigned flags)
 {
         struct sk_buff          *skb;
         struct skb_data         *entry;
         int                     retval = 0;
         unsigned long           lockflags;
-        size_t                  size;
-
-#ifdef CONFIG_USB_NET1080
-        if (dev->driver_info->flags & FLAG_FRAMING_NC)
-                size = FRAMED_SIZE (dev->net->mtu);
-        else
-#endif
-#ifdef CONFIG_USB_GENESYS
-        if (dev->driver_info->flags & FLAG_FRAMING_GL)
-                size = GL_RCV_BUF_SIZE;
-        else
-#endif
-#ifdef CONFIG_USB_ZAURUS
-        if (dev->driver_info->flags & FLAG_FRAMING_Z)
-                size = 6 + (sizeof (struct ethhdr) + dev->net->mtu);
-        else
-#endif
-#ifdef CONFIG_USB_RNDIS
-        if (dev->driver_info->flags & FLAG_FRAMING_RN)
-                size = RNDIS_MAX_TRANSFER;
-        else
-#endif
-#ifdef CONFIG_USB_AX8817X
-        if (dev->driver_info->flags & FLAG_FRAMING_AX)
-                size = 2048;
-        else
-#endif
-                size = (sizeof (struct ethhdr) + dev->net->mtu);
+        size_t                  size = dev->rx_urb_size;
 
         if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
                 if (netif_msg_rx_err (dev))
                         devdbg (dev, "no rx skb");
-                defer_kevent (dev, EVENT_RX_MEMORY);
+                usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
                 usb_free_urb (urb);
                 return;
         }
@@ -2987,7 +313,6 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, int flags)
 
         usb_fill_bulk_urb (urb, dev->udev, dev->in,
                 skb->data, size, rx_complete, skb);
-        urb->transfer_flags |= URB_ASYNC_UNLINK;
 
         spin_lock_irqsave (&dev->rxq.lock, lockflags);
 
@@ -2996,10 +321,10 @@ static void rx_submit (struct usbnet *dev, struct urb *urb, int flags)
                         && !test_bit (EVENT_RX_HALT, &dev->flags)) {
                 switch (retval = usb_submit_urb (urb, GFP_ATOMIC)){ 
                 case -EPIPE:
-                        defer_kevent (dev, EVENT_RX_HALT);
+                        usbnet_defer_kevent (dev, EVENT_RX_HALT);
                         break;
                 case -ENOMEM:
-                        defer_kevent (dev, EVENT_RX_MEMORY);
+                        usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
                         break;
                 case -ENODEV:
                         if (netif_msg_ifdown (dev))
@@ -3037,7 +362,7 @@ static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
         // else network stack removes extra byte if we forced a short packet
 
         if (skb->len)
-                skb_return (dev, skb);
+                usbnet_skb_return (dev, skb);
         else {
                 if (netif_msg_rx_err (dev))
                         devdbg (dev, "drop");
@@ -3063,7 +388,7 @@ static void rx_complete (struct urb *urb, struct pt_regs *regs)
         switch (urb_status) {
             // success
             case 0:
-                if (MIN_PACKET > skb->len || skb->len > MAX_PACKET) {
+                if (skb->len < dev->net->hard_header_len) {
                         entry->state = rx_cleanup;
                         dev->stats.rx_errors++;
                         dev->stats.rx_length_errors++;
@@ -3078,7 +403,7 @@ static void rx_complete (struct urb *urb, struct pt_regs *regs)
             // storm, recovering as needed.
             case -EPIPE:
                 dev->stats.rx_errors++;
-                defer_kevent (dev, EVENT_RX_HALT);
+                usbnet_defer_kevent (dev, EVENT_RX_HALT);
                 // FALLTHROUGH
 
             // software-driven interface shutdown
@@ -3320,55 +645,58 @@ done:
 
 /*-------------------------------------------------------------------------*/
 
-static void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
+/* ethtool methods; minidrivers may need to add some more, but
+ * they'll probably want to use this base set.
+ */
+
+void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
 {
         struct usbnet *dev = netdev_priv(net);
 
+        /* REVISIT don't always return "usbnet" */
         strncpy (info->driver, driver_name, sizeof info->driver);
         strncpy (info->version, DRIVER_VERSION, sizeof info->version);
         strncpy (info->fw_version, dev->driver_info->description,
                 sizeof info->fw_version);
         usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
 }
+EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
 
 static u32 usbnet_get_link (struct net_device *net)
 {
         struct usbnet *dev = netdev_priv(net);
 
-        /* If a check_connect is defined, return it's results */
+        /* If a check_connect is defined, return its result */
         if (dev->driver_info->check_connect)
                 return dev->driver_info->check_connect (dev) == 0;
 
-        /* Otherwise, we're up to avoid breaking scripts */
+        /* Otherwise, say we're up (to avoid breaking scripts) */
         return 1;
 }
 
-static u32 usbnet_get_msglevel (struct net_device *net)
+u32 usbnet_get_msglevel (struct net_device *net)
 {
         struct usbnet *dev = netdev_priv(net);
 
         return dev->msg_enable;
 }
+EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
 
-static void usbnet_set_msglevel (struct net_device *net, u32 level)
+void usbnet_set_msglevel (struct net_device *net, u32 level)
 {
         struct usbnet *dev = netdev_priv(net);
 
         dev->msg_enable = level;
 }
+EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
 
-static int usbnet_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
-{
-#ifdef NEED_MII
-        {
-        struct usbnet *dev = netdev_priv(net);
-
-        if (dev->mii.mdio_read != NULL && dev->mii.mdio_write != NULL)
-                return generic_mii_ioctl(&dev->mii, if_mii(rq), cmd, NULL);
-        }
-#endif
-        return -EOPNOTSUPP;
-}
+/* drivers may override default ethtool_ops in their bind() routine */
+static struct ethtool_ops usbnet_ethtool_ops = {
+        .get_drvinfo            = usbnet_get_drvinfo,
+        .get_link               = usbnet_get_link,
+        .get_msglevel           = usbnet_get_msglevel,
+        .set_msglevel           = usbnet_set_msglevel,
+};
 
 /*-------------------------------------------------------------------------*/
 
@@ -3387,19 +715,24 @@ kevent (void *data)
         if (test_bit (EVENT_TX_HALT, &dev->flags)) {
                 unlink_urbs (dev, &dev->txq);
                 status = usb_clear_halt (dev->udev, dev->out);
-                if (status < 0 && status != -EPIPE) {
+                if (status < 0
+                                && status != -EPIPE
+                                && status != -ESHUTDOWN) {
                         if (netif_msg_tx_err (dev))
                                 deverr (dev, "can't clear tx halt, status %d",
                                         status);
                 } else {
                         clear_bit (EVENT_TX_HALT, &dev->flags);
-                        netif_wake_queue (dev->net);
+                        if (status != -ESHUTDOWN)
+                                netif_wake_queue (dev->net);
                 }
         }
         if (test_bit (EVENT_RX_HALT, &dev->flags)) {
                 unlink_urbs (dev, &dev->rxq);
                 status = usb_clear_halt (dev->udev, dev->in);
-                if (status < 0 && status != -EPIPE) {
+                if (status < 0
+                                && status != -EPIPE
+                                && status != -ESHUTDOWN) {
                         if (netif_msg_rx_err (dev))
                                 deverr (dev, "can't clear rx halt, status %d",
                                         status);
@@ -3458,7 +791,7 @@ static void tx_complete (struct urb *urb, struct pt_regs *regs)
 
                 switch (urb->status) {
                 case -EPIPE:
-                        defer_kevent (dev, EVENT_TX_HALT);
+                        usbnet_defer_kevent (dev, EVENT_TX_HALT);
                         break;
 
                 /* software-driven interface shutdown */
@@ -3515,10 +848,6 @@ static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
         struct skb_data         *entry;
         struct driver_info      *info = dev->driver_info;
         unsigned long           flags;
-#ifdef  CONFIG_USB_NET1080
-        struct nc_header        *header = NULL;
-        struct nc_trailer       *trailer = NULL;
-#endif  /* CONFIG_USB_NET1080 */
 
         // some devices want funky USB-level framing, for
         // win32 driver (usually) and/or hardware quirks
@@ -3544,24 +873,8 @@ static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
         entry->state = tx_start;
         entry->length = length;
 
-        // FIXME: reorganize a bit, so that fixup() fills out NetChip
-        // framing too. (Packet ID update needs the spinlock...)
-        // [ BETTER:  we already own net->xmit_lock, that's enough ]
-
-#ifdef  CONFIG_USB_NET1080
-        if (info->flags & FLAG_FRAMING_NC) {
-                header = (struct nc_header *) skb_push (skb, sizeof *header);
-                header->hdr_len = cpu_to_le16 (sizeof (*header));
-                header->packet_len = cpu_to_le16 (length);
-                if (!((skb->len + sizeof *trailer) & 0x01))
-                        *skb_put (skb, 1) = PAD_BYTE;
-                trailer = (struct nc_trailer *) skb_put (skb, sizeof *trailer);
-        }
-#endif  /* CONFIG_USB_NET1080 */
-
         usb_fill_bulk_urb (urb, dev->udev, dev->out,
                         skb->data, skb->len, tx_complete, skb);
-        urb->transfer_flags |= URB_ASYNC_UNLINK;
 
         /* don't assume the hardware handles USB_ZERO_PACKET
          * NOTE:  strictly conforming cdc-ether devices should expect
@@ -3574,22 +887,10 @@ static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
 
         spin_lock_irqsave (&dev->txq.lock, flags);
 
-#ifdef  CONFIG_USB_NET1080
-        if (info->flags & FLAG_FRAMING_NC) {
-                header->packet_id = cpu_to_le16 ((u16)dev->dev_packet_id++);
-                put_unaligned (header->packet_id, &trailer->packet_id);
-#if 0
-                devdbg (dev, "frame >tx h %d p %d id %d",
-                        header->hdr_len, header->packet_len,
-                        header->packet_id);
-#endif
-        }
-#endif  /* CONFIG_USB_NET1080 */
-
         switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
         case -EPIPE:
                 netif_stop_queue (net);
-                defer_kevent (dev, EVENT_TX_HALT);
+                usbnet_defer_kevent (dev, EVENT_TX_HALT);
                 break;
         default:
                 if (netif_msg_tx_err (dev))
@@ -3692,7 +993,7 @@ static void usbnet_bh (unsigned long param)
  
 // precondition: never called in_interrupt
 
-static void usbnet_disconnect (struct usb_interface *intf)
+void usbnet_disconnect (struct usb_interface *intf)
 {
         struct usbnet           *dev;
         struct usb_device       *xdev;
@@ -3706,7 +1007,8 @@ static void usbnet_disconnect (struct usb_interface *intf)
         xdev = interface_to_usbdev (intf);
 
         if (netif_msg_probe (dev))
-                devinfo (dev, "unregister usbnet usb-%s-%s, %s",
+                devinfo (dev, "unregister '%s' usb-%s-%s, %s",
+                        intf->dev.driver->name,
                         xdev->bus->bus_name, xdev->devpath,
                         dev->driver_info->description);
         
@@ -3722,15 +1024,14 @@ static void usbnet_disconnect (struct usb_interface *intf)
         free_netdev(net);
         usb_put_dev (xdev);
 }
+EXPORT_SYMBOL_GPL(usbnet_disconnect);
 
 
 /*-------------------------------------------------------------------------*/
 
-static struct ethtool_ops usbnet_ethtool_ops;
-
 // precondition: never called in_interrupt
 
-static int
+int
 usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
 {
         struct usbnet                   *dev;
@@ -3779,6 +1080,10 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
         strcpy (net->name, "usb%d");
         memcpy (net->dev_addr, node_id, sizeof node_id);
 
+        /* rx and tx sides can use different message sizes;
+         * bind() should set rx_urb_size in that case.
+         */
+        dev->hard_mtu = net->mtu + net->hard_header_len;
 #if 0
 // dma_supported() is deeply broken on almost all architectures
         // possible with some EHCI controllers
@@ -3793,7 +1098,6 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
         net->stop = usbnet_stop;
         net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
         net->tx_timeout = usbnet_tx_timeout;
-        net->do_ioctl = usbnet_ioctl;
         net->ethtool_ops = &usbnet_ethtool_ops;
 
         // allow device-specific bind/init procedures
@@ -3806,8 +1110,12 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
                 if ((dev->driver_info->flags & FLAG_ETHER) != 0
                                 && (net->dev_addr [0] & 0x02) == 0)
                         strcpy (net->name, "eth%d");
-        } else if (!info->in || info->out)
-                status = get_endpoints (dev, udev);
+
+                /* maybe the remote can't receive an Ethernet MTU */
+                if (net->mtu > (dev->hard_mtu - net->hard_header_len))
+                        net->mtu = dev->hard_mtu - net->hard_header_len;
+        } else if (!info->in || !info->out)
+                status = usbnet_get_endpoints (dev, udev);
         else {
                 dev->in = usb_rcvbulkpipe (xdev, info->in);
                 dev->out = usb_sndbulkpipe (xdev, info->out);
@@ -3819,12 +1127,13 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
                         status = 0;
 
         }
-
         if (status == 0 && dev->status)
                 status = init_status (dev, udev);
         if (status < 0)
                 goto out1;
 
+        if (!dev->rx_urb_size)
+                dev->rx_urb_size = dev->hard_mtu;
         dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
         
         SET_NETDEV_DEV(net, &udev->dev);
@@ -3832,8 +1141,9 @@ usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
         if (status)
                 goto out3;
         if (netif_msg_probe (dev))
-                devinfo (dev, "register usbnet at usb-%s-%s, %s, "
+                devinfo (dev, "register '%s' at usb-%s-%s, %s, "
                                 "%02x:%02x:%02x:%02x:%02x:%02x",
+                        udev->dev.driver->name,
                         xdev->bus->bus_name, xdev->devpath,
                         dev->driver_info->description,
                         net->dev_addr [0], net->dev_addr [1],
@@ -3857,12 +1167,15 @@ out:
         usb_put_dev(xdev);
         return status;
 }
+EXPORT_SYMBOL_GPL(usbnet_probe);
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef  CONFIG_PM
+/* FIXME these suspend/resume methods assume non-CDC style
+ * devices, with only one interface.
+ */
 
-static int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
+int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
 {
         struct usbnet           *dev = usb_get_intfdata(intf);
         
@@ -3875,8 +1188,9 @@ static int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
         intf->dev.power.power_state = PMSG_SUSPEND;
         return 0;
 }
+EXPORT_SYMBOL_GPL(usbnet_suspend);
 
-static int usbnet_resume (struct usb_interface *intf)
+int usbnet_resume (struct usb_interface *intf)
 {
         struct usbnet           *dev = usb_get_intfdata(intf);
 
@@ -3885,357 +1199,27 @@ static int usbnet_resume (struct usb_interface *intf)
         tasklet_schedule (&dev->bh);
         return 0;
 }
+EXPORT_SYMBOL_GPL(usbnet_resume);
 
-#else   /* !CONFIG_PM */
-
-#define usbnet_suspend  NULL
-#define usbnet_resume   NULL
-
-#endif  /* CONFIG_PM */
-
-/*-------------------------------------------------------------------------*/
-
-#ifndef HAVE_HARDWARE
-#error You need to configure some hardware for this driver
-#endif
-
-/*
- * chip vendor names won't normally be on the cables, and
- * may not be on the device.
- */
-
-static const struct usb_device_id       products [] = {
-
-#ifdef  CONFIG_USB_ALI_M5632
-{
-        USB_DEVICE (0x0402, 0x5632),    // ALi defaults
-        .driver_info =  (unsigned long) &ali_m5632_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_AN2720
-{
-        USB_DEVICE (0x0547, 0x2720),    // AnchorChips defaults
-        .driver_info =  (unsigned long) &an2720_info,
-}, {
-        USB_DEVICE (0x0547, 0x2727),    // Xircom PGUNET
-        .driver_info =  (unsigned long) &an2720_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_BELKIN
-{
-        USB_DEVICE (0x050d, 0x0004),    // Belkin
-        .driver_info =  (unsigned long) &belkin_info,
-}, {
-        USB_DEVICE (0x056c, 0x8100),    // eTEK
-        .driver_info =  (unsigned long) &belkin_info,
-}, {
-        USB_DEVICE (0x0525, 0x9901),    // Advance USBNET (eTEK)
-        .driver_info =  (unsigned long) &belkin_info,
-},
-#endif
-
-#ifdef CONFIG_USB_AX8817X
-{
-        // Linksys USB200M
-        USB_DEVICE (0x077b, 0x2226),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // Netgear FA120
-        USB_DEVICE (0x0846, 0x1040),
-        .driver_info =  (unsigned long) &netgear_fa120_info,
-}, {
-        // DLink DUB-E100
-        USB_DEVICE (0x2001, 0x1a00),
-        .driver_info =  (unsigned long) &dlink_dub_e100_info,
-}, {
-        // Intellinet, ST Lab USB Ethernet
-        USB_DEVICE (0x0b95, 0x1720),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // Hawking UF200, TrendNet TU2-ET100
-        USB_DEVICE (0x07b8, 0x420a),
-        .driver_info =  (unsigned long) &hawking_uf200_info,
-}, {
-        // Billionton Systems, USB2AR 
-        USB_DEVICE (0x08dd, 0x90ff),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // ATEN UC210T
-        USB_DEVICE (0x0557, 0x2009),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // Buffalo LUA-U2-KTX
-        USB_DEVICE (0x0411, 0x003d),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // Sitecom LN-029 "USB 2.0 10/100 Ethernet adapter"
-        USB_DEVICE (0x6189, 0x182d),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // corega FEther USB2-TX
-        USB_DEVICE (0x07aa, 0x0017),
-        .driver_info =  (unsigned long) &ax8817x_info,
-}, {
-        // Surecom EP-1427X-2
-        USB_DEVICE (0x1189, 0x0893),
-        .driver_info = (unsigned long) &ax8817x_info,
-}, {
-        // goodway corp usb gwusb2e
-        USB_DEVICE (0x1631, 0x6200),
-        .driver_info = (unsigned long) &ax8817x_info,
-}, {
-        // ASIX AX88772 10/100
-        USB_DEVICE (0x0b95, 0x7720),
-        .driver_info = (unsigned long) &ax88772_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_EPSON2888
-{
-        USB_DEVICE (0x0525, 0x2888),    // EPSON USB client
-        .driver_info    = (unsigned long) &epson2888_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_GENESYS
-{
-        USB_DEVICE (0x05e3, 0x0502),    // GL620USB-A
-        .driver_info =  (unsigned long) &genelink_info,
-},
-        /* NOT: USB_DEVICE (0x05e3, 0x0501),    // GL620USB
-         * that's half duplex, not currently supported
-         */
-#endif
-
-#ifdef  CONFIG_USB_NET1080
-{
-        USB_DEVICE (0x0525, 0x1080),    // NetChip ref design
-        .driver_info =  (unsigned long) &net1080_info,
-}, {
-        USB_DEVICE (0x06D0, 0x0622),    // Laplink Gold
-        .driver_info =  (unsigned long) &net1080_info,
-},
-#endif
-
-#ifdef CONFIG_USB_PL2301
-{
-        USB_DEVICE (0x067b, 0x0000),    // PL-2301
-        .driver_info =  (unsigned long) &prolific_info,
-}, {
-        USB_DEVICE (0x067b, 0x0001),    // PL-2302
-        .driver_info =  (unsigned long) &prolific_info,
-},
-#endif
-
-#ifdef CONFIG_USB_KC2190
-{
-        USB_DEVICE (0x050f, 0x0190),    // KC-190
-        .driver_info =  (unsigned long) &kc2190_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_RNDIS
-{
-        /* RNDIS is MSFT's un-official variant of CDC ACM */
-        USB_INTERFACE_INFO (USB_CLASS_COMM, 2 /* ACM */, 0x0ff),
-        .driver_info = (unsigned long) &rndis_info,
-},
-#endif
-
-#ifdef  CONFIG_USB_ARMLINUX
-/*
- * SA-1100 using standard ARM Linux kernels, or compatible.
- * Often used when talking to Linux PDAs (iPaq, Yopy, etc).
- * The sa-1100 "usb-eth" driver handles the basic framing.
- *
- * PXA25x or PXA210 ...  these use a "usb-eth" driver much like
- * the sa1100 one, but hardware uses different endpoint numbers.
- *
- * Or the Linux "Ethernet" gadget on hardware that can't talk
- * CDC Ethernet (e.g., no altsettings), in either of two modes:
- *  - acting just like the old "usb-eth" firmware, though
- *    the implementation is different 
- *  - supporting RNDIS as the first/default configuration for
- *    MS-Windows interop; Linux needs to use the other config
- */
-{
-        // 1183 = 0x049F, both used as hex values?
-        // Compaq "Itsy" vendor/product id
-        USB_DEVICE (0x049F, 0x505A),    // usb-eth, or compatible
-        .driver_info =  (unsigned long) &linuxdev_info,
-}, {
-        USB_DEVICE (0x0E7E, 0x1001),    // G.Mate "Yopy"
-        .driver_info =  (unsigned long) &yopy_info,
-}, {
-        USB_DEVICE (0x8086, 0x07d3),    // "blob" bootloader
-        .driver_info =  (unsigned long) &blob_info,
-}, {
-        // Linux Ethernet/RNDIS gadget on pxa210/25x/26x
-        // e.g. Gumstix, current OpenZaurus, ...
-        USB_DEVICE_VER (0x0525, 0xa4a2, 0x0203, 0x0203),
-        .driver_info =  (unsigned long) &linuxdev_info,
-}, 
-#endif
-
-#if     defined(CONFIG_USB_ZAURUS) || defined(CONFIG_USB_CDCETHER)
-/*
- * SA-1100 based Sharp Zaurus ("collie"), or compatible.
- * Same idea as above, but different framing.
- *
- * PXA-2xx based models are also lying-about-cdc.
- * Some models don't even tell the same lies ...
- *
- * NOTE:  OpenZaurus versions with 2.6 kernels won't use these entries,
- * unlike the older ones with 2.4 "embedix" kernels.
- *
- * NOTE:  These entries do double-duty, serving as blacklist entries
- * whenever Zaurus support isn't enabled, but CDC Ethernet is.
- */
-#define ZAURUS_MASTER_INTERFACE \
-        .bInterfaceClass        = USB_CLASS_COMM, \
-        .bInterfaceSubClass     = USB_CDC_SUBCLASS_ETHERNET, \
-        .bInterfaceProtocol     = USB_CDC_PROTO_NONE
-{
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                          | USB_DEVICE_ID_MATCH_DEVICE, 
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x8004,
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_STRONGARM_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                          | USB_DEVICE_ID_MATCH_DEVICE, 
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x8005,       /* A-300 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                          | USB_DEVICE_ID_MATCH_DEVICE, 
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x8006,       /* B-500/SL-5600 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                  | USB_DEVICE_ID_MATCH_DEVICE,
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x8007,       /* C-700 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                 | USB_DEVICE_ID_MATCH_DEVICE,
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x9031,       /* C-750 C-760 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                 | USB_DEVICE_ID_MATCH_DEVICE,
-        .idVendor               = 0x04DD,
-        .idProduct              = 0x9032,       /* SL-6000 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-}, {
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                 | USB_DEVICE_ID_MATCH_DEVICE,
-        .idVendor               = 0x04DD,
-        /* reported with some C860 units */
-        .idProduct              = 0x9050,       /* C-860 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = ZAURUS_PXA_INFO,
-},
-
-#ifdef  CONFIG_USB_ZAURUS
-        /* At least some (reports vary) PXA units have very different lies
-         * about their standards support:  they claim to be cell phones with
-         * direct access to their radios.  (They don't conform to CDC MDLM.)
-         */
-{
-        USB_INTERFACE_INFO (USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
-                        USB_CDC_PROTO_NONE),
-        .driver_info = (unsigned long) &bogus_mdlm_info,
-},
-#endif
-
-/* Olympus has some models with a Zaurus-compatible option.
- * R-1000 uses a FreeScale i.MXL cpu (ARMv4T)
- */
-{
-        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
-                 | USB_DEVICE_ID_MATCH_DEVICE,
-        .idVendor               = 0x07B4,
-        .idProduct              = 0x0F02,       /* R-1000 */
-        ZAURUS_MASTER_INTERFACE,
-        .driver_info = OLYMPUS_MXL_INFO,
-},
-#endif
-
-#ifdef  CONFIG_USB_CDCETHER
-{
-        /* CDC Ether uses two interfaces, not necessarily consecutive.
-         * We match the main interface, ignoring the optional device
-         * class so we could handle devices that aren't exclusively
-         * CDC ether.
-         *
-         * NOTE:  this match must come AFTER entries working around
-         * bugs/quirks in a given product (like Zaurus, above).
-         */
-        USB_INTERFACE_INFO (USB_CLASS_COMM, USB_CDC_SUBCLASS_ETHERNET,
-                        USB_CDC_PROTO_NONE),
-        .driver_info = (unsigned long) &cdc_info,
-},
-#endif
-
-        { },            // END
-};
-MODULE_DEVICE_TABLE (usb, products);
-
-static struct usb_driver usbnet_driver = {
-        .owner =        THIS_MODULE,
-        .name =         driver_name,
-        .id_table =     products,
-        .probe =        usbnet_probe,
-        .disconnect =   usbnet_disconnect,
-        .suspend =      usbnet_suspend,
-        .resume =       usbnet_resume,
-};
-
-/* Default ethtool_ops assigned.  Devices can override in their bind() routine */
-static struct ethtool_ops usbnet_ethtool_ops = {
-        .get_drvinfo            = usbnet_get_drvinfo,
-        .get_link               = usbnet_get_link,
-        .get_msglevel           = usbnet_get_msglevel,
-        .set_msglevel           = usbnet_set_msglevel,
-};
 
 /*-------------------------------------------------------------------------*/
 
-static int __init usbnet_init (void)
+static int __init usbnet_init(void)
 {
-        // compiler should optimize these out
+        /* compiler should optimize this out */
         BUG_ON (sizeof (((struct sk_buff *)0)->cb)
                         < sizeof (struct skb_data));
-#ifdef  CONFIG_USB_CDCETHER
-        BUG_ON ((sizeof (((struct usbnet *)0)->data)
-                        < sizeof (struct cdc_state)));
-#endif
 
         random_ether_addr(node_id);
-
-        return usb_register(&usbnet_driver);
+        return 0;
 }
-module_init (usbnet_init);
+module_init(usbnet_init);
 
-static void __exit usbnet_exit (void)
+static void __exit usbnet_exit(void)
 {
-        usb_deregister (&usbnet_driver);
 }
-module_exit (usbnet_exit);
+module_exit(usbnet_exit);
 
-MODULE_AUTHOR ("David Brownell <dbrownell@users.sourceforge.net>");
-MODULE_DESCRIPTION ("USB Host-to-Host Link Drivers (numerous vendors)");
-MODULE_LICENSE ("GPL");
+MODULE_AUTHOR("David Brownell");
+MODULE_DESCRIPTION("USB network driver framework");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/usbnet.h b/drivers/usb/net/usbnet.h
new file mode 100644
index 000000000000..7aa0abd1a9bd
--- /dev/null
+++ b/drivers/usb/net/usbnet.h
@@ -0,0 +1,193 @@
+/*
+ * USB Networking Link Interface
+ *
+ * Copyright (C) 2000-2005 by David Brownell <dbrownell@users.sourceforge.net>
+ * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+
+#ifndef __USBNET_H
+#define __USBNET_H
+
+
+/* interface from usbnet core to each USB networking link we handle */
+struct usbnet {
+        /* housekeeping */
+        struct usb_device       *udev;
+        struct driver_info      *driver_info;
+        wait_queue_head_t       *wait;
+
+        /* i/o info: pipes etc */
+        unsigned                in, out;
+        struct usb_host_endpoint *status;
+        unsigned                maxpacket;
+        struct timer_list       delay;
+
+        /* protocol/interface state */
+        struct net_device       *net;
+        struct net_device_stats stats;
+        int                     msg_enable;
+        unsigned long           data [5];
+        u32                     xid;
+        u32                     hard_mtu;       /* count any extra framing */
+        size_t                  rx_urb_size;    /* size for rx urbs  */
+        struct mii_if_info      mii;
+
+        /* various kinds of pending driver work */
+        struct sk_buff_head     rxq;
+        struct sk_buff_head     txq;
+        struct sk_buff_head     done;
+        struct urb              *interrupt;
+        struct tasklet_struct   bh;
+
+        struct work_struct      kevent;
+        unsigned long           flags;
+#               define EVENT_TX_HALT    0
+#               define EVENT_RX_HALT    1
+#               define EVENT_RX_MEMORY  2
+#               define EVENT_STS_SPLIT  3
+#               define EVENT_LINK_RESET 4
+};
+
+static inline struct usb_driver *driver_of(struct usb_interface *intf)
+{
+        return to_usb_driver(intf->dev.driver);
+}
+
+/* interface from the device/framing level "minidriver" to core */
+struct driver_info {
+        char            *description;
+
+        int             flags;
+/* framing is CDC Ethernet, not writing ZLPs (hw issues), or optionally: */
+#define FLAG_FRAMING_NC 0x0001          /* guard against device dropouts */
+#define FLAG_FRAMING_GL 0x0002          /* genelink batches packets */
+#define FLAG_FRAMING_Z  0x0004          /* zaurus adds a trailer */
+#define FLAG_FRAMING_RN 0x0008          /* RNDIS batches, plus huge header */
+
+#define FLAG_NO_SETINT  0x0010          /* device can't set_interface() */
+#define FLAG_ETHER      0x0020          /* maybe use "eth%d" names */
+
+#define FLAG_FRAMING_AX 0x0040          /* AX88772/178 packets */
+
+        /* init device ... can sleep, or cause probe() failure */
+        int     (*bind)(struct usbnet *, struct usb_interface *);
+
+        /* cleanup device ... can sleep, but can't fail */
+        void    (*unbind)(struct usbnet *, struct usb_interface *);
+
+        /* reset device ... can sleep */
+        int     (*reset)(struct usbnet *);
+
+        /* see if peer is connected ... can sleep */
+        int     (*check_connect)(struct usbnet *);
+
+        /* for status polling */
+        void    (*status)(struct usbnet *, struct urb *);
+
+        /* link reset handling, called from defer_kevent */
+        int     (*link_reset)(struct usbnet *);
+
+        /* fixup rx packet (strip framing) */
+        int     (*rx_fixup)(struct usbnet *dev, struct sk_buff *skb);
+
+        /* fixup tx packet (add framing) */
+        struct sk_buff  *(*tx_fixup)(struct usbnet *dev,
+                                struct sk_buff *skb, unsigned flags);
+
+        /* for new devices, use the descriptor-reading code instead */
+        int             in;             /* rx endpoint */
+        int             out;            /* tx endpoint */
+
+        unsigned long   data;           /* Misc driver specific data */
+};
+
+/* Minidrivers are just drivers using the "usbnet" core as a powerful
+ * network-specific subroutine library ... that happens to do pretty
+ * much everything except custom framing and chip-specific stuff.
+ */
+extern int usbnet_probe(struct usb_interface *, const struct usb_device_id *);
+extern int usbnet_suspend (struct usb_interface *, pm_message_t );
+extern int usbnet_resume (struct usb_interface *);
+extern void usbnet_disconnect(struct usb_interface *);
+
+
+/* Drivers that reuse some of the standard USB CDC infrastructure
+ * (notably, using multiple interfaces according to the the CDC
+ * union descriptor) get some helper code.
+ */
+struct cdc_state {
+        struct usb_cdc_header_desc      *header;
+        struct usb_cdc_union_desc       *u;
+        struct usb_cdc_ether_desc       *ether;
+        struct usb_interface            *control;
+        struct usb_interface            *data;
+};
+
+extern int usbnet_generic_cdc_bind (struct usbnet *, struct usb_interface *);
+extern void usbnet_cdc_unbind (struct usbnet *, struct usb_interface *);
+
+/* CDC and RNDIS support the same host-chosen packet filters for IN transfers */
+#define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
+                        |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
+                        |USB_CDC_PACKET_TYPE_PROMISCUOUS \
+                        |USB_CDC_PACKET_TYPE_DIRECTED)
+
+
+/* we record the state for each of our queued skbs */
+enum skb_state {
+        illegal = 0,
+        tx_start, tx_done,
+        rx_start, rx_done, rx_cleanup
+};
+
+struct skb_data {       /* skb->cb is one of these */
+        struct urb              *urb;
+        struct usbnet           *dev;
+        enum skb_state          state;
+        size_t                  length;
+};
+
+
+extern int usbnet_get_endpoints(struct usbnet *, struct usb_interface *);
+extern void usbnet_defer_kevent (struct usbnet *, int);
+extern void usbnet_skb_return (struct usbnet *, struct sk_buff *);
+
+extern u32 usbnet_get_msglevel (struct net_device *);
+extern void usbnet_set_msglevel (struct net_device *, u32);
+extern void usbnet_get_drvinfo (struct net_device *, struct ethtool_drvinfo *);
+
+/* messaging support includes the interface name, so it must not be
+ * used before it has one ... notably, in minidriver bind() calls.
+ */
+#ifdef DEBUG
+#define devdbg(usbnet, fmt, arg...) \
+        printk(KERN_DEBUG "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
+#else
+#define devdbg(usbnet, fmt, arg...) do {} while(0)
+#endif
+
+#define deverr(usbnet, fmt, arg...) \
+        printk(KERN_ERR "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
+#define devwarn(usbnet, fmt, arg...) \
+        printk(KERN_WARNING "%s: " fmt "\n" , (usbnet)->net->name , ## arg)
+
+#define devinfo(usbnet, fmt, arg...) \
+        printk(KERN_INFO "%s: " fmt "\n" , (usbnet)->net->name , ## arg); \
+
+
+#endif  /* __USBNET_H */
diff --git a/drivers/usb/net/zaurus.c b/drivers/usb/net/zaurus.c
new file mode 100644
index 000000000000..ee3b892aeabc
--- /dev/null
+++ b/drivers/usb/net/zaurus.c
@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2002 Pavel Machek <pavel@ucw.cz>
+ * Copyright (C) 2002-2005 by David Brownell
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// #define      DEBUG                   // error path messages, extra info
+// #define      VERBOSE                 // more; success messages
+
+#include <linux/config.h>
+#ifdef  CONFIG_USB_DEBUG
+#   define DEBUG
+#endif
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/netdevice.h>
+#include <linux/ethtool.h>
+#include <linux/workqueue.h>
+#include <linux/mii.h>
+#include <linux/crc32.h>
+#include <linux/usb.h>
+#include <linux/usb_cdc.h>
+
+#include "usbnet.h"
+
+
+/*
+ * All known Zaurii lie about their standards conformance.  At least
+ * the earliest SA-1100 models lie by saying they support CDC Ethernet.
+ * Some later models (especially PXA-25x and PXA-27x based ones) lie
+ * and say they support CDC MDLM (for access to cell phone modems).
+ *
+ * There are non-Zaurus products that use these same protocols too.
+ *
+ * The annoying thing is that at the same time Sharp was developing
+ * that annoying standards-breaking software, the Linux community had
+ * a simple "CDC Subset" working reliably on the same SA-1100 hardware.
+ * That is, the same functionality but not violating standards.
+ *
+ * The CDC Ethernet nonconformance points are troublesome to hosts
+ * with a true CDC Ethernet implementation:
+ *   - Framing appends a CRC, which the spec says drivers "must not" do;
+ *   - Transfers data in altsetting zero, instead of altsetting 1;
+ *   - All these peripherals use the same ethernet address.
+ *
+ * The CDC MDLM nonconformance is less immediately troublesome, since all
+ * MDLM implementations are quasi-proprietary anyway.
+ */
+
+static struct sk_buff *
+zaurus_tx_fixup(struct usbnet *dev, struct sk_buff *skb, unsigned flags)
+{
+        int                     padlen;
+        struct sk_buff          *skb2;
+
+        padlen = 2;
+        if (!skb_cloned(skb)) {
+                int     tailroom = skb_tailroom(skb);
+                if ((padlen + 4) <= tailroom)
+                        goto done;
+        }
+        skb2 = skb_copy_expand(skb, 0, 4 + padlen, flags);
+        dev_kfree_skb_any(skb);
+        skb = skb2;
+        if (skb) {
+                u32             fcs;
+done:
+                fcs = crc32_le(~0, skb->data, skb->len);
+                fcs = ~fcs;
+
+                *skb_put (skb, 1) = fcs       & 0xff;
+                *skb_put (skb, 1) = (fcs>> 8) & 0xff;
+                *skb_put (skb, 1) = (fcs>>16) & 0xff;
+                *skb_put (skb, 1) = (fcs>>24) & 0xff;
+        }
+        return skb;
+}
+
+static int zaurus_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        /* Belcarra's funky framing has other options; mostly
+         * TRAILERS (!) with 4 bytes CRC, and maybe 2 pad bytes.
+         */
+        dev->net->hard_header_len += 6;
+        dev->rx_urb_size = dev->net->hard_header_len + dev->net->mtu;
+        return usbnet_generic_cdc_bind(dev, intf);
+}
+
+/* PDA style devices are always connected if present */
+static int always_connected (struct usbnet *dev)
+{
+        return 0;
+}
+
+static const struct driver_info zaurus_sl5x00_info = {
+        .description =  "Sharp Zaurus SL-5x00",
+        .flags =        FLAG_FRAMING_Z,
+        .check_connect = always_connected,
+        .bind =         zaurus_bind,
+        .unbind =       usbnet_cdc_unbind,
+        .tx_fixup =     zaurus_tx_fixup,
+};
+#define ZAURUS_STRONGARM_INFO   ((unsigned long)&zaurus_sl5x00_info)
+
+static const struct driver_info zaurus_pxa_info = {
+        .description =  "Sharp Zaurus, PXA-2xx based",
+        .flags =        FLAG_FRAMING_Z,
+        .check_connect = always_connected,
+        .bind =         zaurus_bind,
+        .unbind =       usbnet_cdc_unbind,
+        .tx_fixup =     zaurus_tx_fixup,
+};
+#define ZAURUS_PXA_INFO         ((unsigned long)&zaurus_pxa_info)
+
+static const struct driver_info olympus_mxl_info = {
+        .description =  "Olympus R1000",
+        .flags =        FLAG_FRAMING_Z,
+        .check_connect = always_connected,
+        .bind =         zaurus_bind,
+        .unbind =       usbnet_cdc_unbind,
+        .tx_fixup =     zaurus_tx_fixup,
+};
+#define OLYMPUS_MXL_INFO        ((unsigned long)&olympus_mxl_info)
+
+
+/* Some more recent products using Lineo/Belcarra code will wrongly claim
+ * CDC MDLM conformance.  They aren't conformant:  data endpoints live
+ * in the control interface, there's no data interface, and it's not used
+ * to talk to a cell phone radio.  But at least we can detect these two
+ * pseudo-classes, rather than growing this product list with entries for
+ * each new nonconformant product (sigh).
+ */
+static const u8 safe_guid[16] = {
+        0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
+        0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
+};
+static const u8 blan_guid[16] = {
+        0x74, 0xf0, 0x3d, 0xbd, 0x1e, 0xc1, 0x44, 0x70,
+        0xa3, 0x67, 0x71, 0x34, 0xc9, 0xf5, 0x54, 0x37,
+};
+
+static int blan_mdlm_bind(struct usbnet *dev, struct usb_interface *intf)
+{
+        u8                              *buf = intf->cur_altsetting->extra;
+        int                             len = intf->cur_altsetting->extralen;
+        struct usb_cdc_mdlm_desc        *desc = NULL;
+        struct usb_cdc_mdlm_detail_desc *detail = NULL;
+
+        while (len > 3) {
+                if (buf [1] != USB_DT_CS_INTERFACE)
+                        goto next_desc;
+
+                /* use bDescriptorSubType, and just verify that we get a
+                 * "BLAN" (or "SAFE") descriptor.
+                 */
+                switch (buf [2]) {
+                case USB_CDC_MDLM_TYPE:
+                        if (desc) {
+                                dev_dbg(&intf->dev, "extra MDLM\n");
+                                goto bad_desc;
+                        }
+                        desc = (void *) buf;
+                        if (desc->bLength != sizeof *desc) {
+                                dev_dbg(&intf->dev, "MDLM len %u\n",
+                                        desc->bLength);
+                                goto bad_desc;
+                        }
+                        /* expect bcdVersion 1.0, ignore */
+                        if (memcmp(&desc->bGUID, blan_guid, 16)
+                                    && memcmp(&desc->bGUID, safe_guid, 16) ) {
+                                /* hey, this one might _really_ be MDLM! */
+                                dev_dbg(&intf->dev, "MDLM guid\n");
+                                goto bad_desc;
+                        }
+                        break;
+                case USB_CDC_MDLM_DETAIL_TYPE:
+                        if (detail) {
+                                dev_dbg(&intf->dev, "extra MDLM detail\n");
+                                goto bad_desc;
+                        }
+                        detail = (void *) buf;
+                        switch (detail->bGuidDescriptorType) {
+                        case 0:                 /* "SAFE" */
+                                if (detail->bLength != (sizeof *detail + 2))
+                                        goto bad_detail;
+                                break;
+                        case 1:                 /* "BLAN" */
+                                if (detail->bLength != (sizeof *detail + 3))
+                                        goto bad_detail;
+                                break;
+                        default:
+                                goto bad_detail;
+                        }
+
+                        /* assuming we either noticed BLAN already, or will
+                         * find it soon, there are some data bytes here:
+                         *  - bmNetworkCapabilities (unused)
+                         *  - bmDataCapabilities (bits, see below)
+                         *  - bPad (ignored, for PADAFTER -- BLAN-only)
+                         * bits are:
+                         *  - 0x01 -- Zaurus framing (add CRC)
+                         *  - 0x02 -- PADBEFORE (CRC includes some padding)
+                         *  - 0x04 -- PADAFTER (some padding after CRC)
+                         *  - 0x08 -- "fermat" packet mangling (for hw bugs)
+                         * the PADBEFORE appears not to matter; we interop
+                         * with devices that use it and those that don't.
+                         */
+                        if ((detail->bDetailData[1] & ~0x02) != 0x01) {
+                                /* bmDataCapabilites == 0 would be fine too,
+                                 * but framing is minidriver-coupled for now.
+                                 */
+bad_detail:
+                                dev_dbg(&intf->dev,
+                                                "bad MDLM detail, %d %d %d\n",
+                                                detail->bLength,
+                                                detail->bDetailData[0],
+                                                detail->bDetailData[2]);
+                                goto bad_desc;
+                        }
+                        break;
+                }
+next_desc:
+                len -= buf [0]; /* bLength */
+                buf += buf [0];
+        }
+
+        if (!desc || !detail) {
+                dev_dbg(&intf->dev, "missing cdc mdlm %s%sdescriptor\n",
+                        desc ? "" : "func ",
+                        detail ? "" : "detail ");
+                goto bad_desc;
+        }
+
+        /* There's probably a CDC Ethernet descriptor there, but we can't
+         * rely on the Ethernet address it provides since not all vendors
+         * bother to make it unique.  Likewise there's no point in tracking
+         * of the CDC event notifications.
+         */
+        return usbnet_get_endpoints(dev, intf);
+
+bad_desc:
+        dev_info(&dev->udev->dev, "unsupported MDLM descriptors\n");
+        return -ENODEV;
+}
+
+static const struct driver_info bogus_mdlm_info = {
+        .description =  "pseudo-MDLM (BLAN) device",
+        .flags =        FLAG_FRAMING_Z,
+        .check_connect = always_connected,
+        .tx_fixup =     zaurus_tx_fixup,
+        .bind =         blan_mdlm_bind,
+};
+
+static const struct usb_device_id       products [] = {
+#define ZAURUS_MASTER_INTERFACE \
+        .bInterfaceClass        = USB_CLASS_COMM, \
+        .bInterfaceSubClass     = USB_CDC_SUBCLASS_ETHERNET, \
+        .bInterfaceProtocol     = USB_CDC_PROTO_NONE
+
+/* SA-1100 based Sharp Zaurus ("collie"), or compatible. */
+{
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8004,
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_STRONGARM_INFO,
+},
+
+/* PXA-2xx based models are also lying-about-cdc.  If you add any
+ * more devices that claim to be CDC Ethernet, make sure they get
+ * added to the blacklist in cdc_ether too.
+ *
+ * NOTE:  OpenZaurus versions with 2.6 kernels won't use these entries,
+ * unlike the older ones with 2.4 "embedix" kernels.
+ */
+{
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8005,       /* A-300 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                          | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8006,       /* B-500/SL-5600 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                  | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x8007,       /* C-700 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x9031,       /* C-750 C-760 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        .idProduct              = 0x9032,       /* SL-6000 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+}, {
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x04DD,
+        /* reported with some C860 units */
+        .idProduct              = 0x9050,       /* C-860 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = ZAURUS_PXA_INFO,
+},
+
+
+/* At least some of the newest PXA units have very different lies about
+ * their standards support:  they claim to be cell phones offering
+ * direct access to their radios!  (No, they don't conform to CDC MDLM.)
+ */
+{
+        USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_MDLM,
+                        USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &bogus_mdlm_info,
+},
+
+/* Olympus has some models with a Zaurus-compatible option.
+ * R-1000 uses a FreeScale i.MXL cpu (ARMv4T)
+ */
+{
+        .match_flags    =   USB_DEVICE_ID_MATCH_INT_INFO
+                 | USB_DEVICE_ID_MATCH_DEVICE,
+        .idVendor               = 0x07B4,
+        .idProduct              = 0x0F02,       /* R-1000 */
+        ZAURUS_MASTER_INTERFACE,
+        .driver_info = OLYMPUS_MXL_INFO,
+},
+        { },            // END
+};
+MODULE_DEVICE_TABLE(usb, products);
+
+static struct usb_driver zaurus_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "zaurus",
+        .id_table =     products,
+        .probe =        usbnet_probe,
+        .disconnect =   usbnet_disconnect,
+        .suspend =      usbnet_suspend,
+        .resume =       usbnet_resume,
+};
+
+static int __init zaurus_init(void)
+{
+        return usb_register(&zaurus_driver);
+}
+module_init(zaurus_init);
+
+static void __exit zaurus_exit(void)
+{
+        usb_deregister(&zaurus_driver);
+}
+module_exit(zaurus_exit);
+
+MODULE_AUTHOR("Pavel Machek, David Brownell");
+MODULE_DESCRIPTION("Sharp Zaurus PDA, and compatible products");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/net/zd1201.c b/drivers/usb/net/zd1201.c
index fc013978837e..c4e479ee926a 100644
--- a/drivers/usb/net/zd1201.c
+++ b/drivers/usb/net/zd1201.c
@@ -847,7 +847,6 @@ static void zd1201_tx_timeout(struct net_device *dev)
                 return;
         dev_warn(&zd->usb->dev, "%s: TX timeout, shooting down urb\n",
             dev->name);
-        zd->tx_urb->transfer_flags |= URB_ASYNC_UNLINK;
         usb_unlink_urb(zd->tx_urb);
         zd->stats.tx_errors++;
         /* Restart the timeout to quiet the watchdog: */
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 4ace9964fc6b..97c78c21e8d1 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -32,7 +32,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.04"
+#define DRIVER_VERSION "v0.05"
 #define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
 
 /*
@@ -54,8 +54,11 @@ static void cp2101_shutdown(struct usb_serial*);
 static int debug;
 
 static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
         { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
+        { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
+        { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
         { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
         { } /* Terminating Entry */
 };
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 012e63e05806..9ee1aaff2fcd 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -453,8 +453,8 @@ static int generic_startup (struct usb_serial *serial)
         priv->cbr_mask = B300;
         usb_set_serial_port_data(serial->port[0], priv);
         
-        return (0);     
-}       
+        return 0;
+}
 
 
 static int cypress_earthmate_startup (struct usb_serial *serial)
@@ -464,14 +464,15 @@ static int cypress_earthmate_startup (struct usb_serial *serial)
         dbg("%s", __FUNCTION__);
 
         if (generic_startup(serial)) {
-                dbg("%s - Failed setting up port %d", __FUNCTION__, serial->port[0]->number);
+                dbg("%s - Failed setting up port %d", __FUNCTION__,
+                                serial->port[0]->number);
                 return 1;
         }
 
         priv = usb_get_serial_port_data(serial->port[0]);
         priv->chiptype = CT_EARTHMATE;
-        
-        return (0);     
+
+        return 0;
 } /* cypress_earthmate_startup */
 
 
@@ -482,14 +483,15 @@ static int cypress_hidcom_startup (struct usb_serial *serial)
         dbg("%s", __FUNCTION__);
 
         if (generic_startup(serial)) {
-                dbg("%s - Failed setting up port %d", __FUNCTION__, serial->port[0]->number);
+                dbg("%s - Failed setting up port %d", __FUNCTION__,
+                                serial->port[0]->number);
                 return 1;
         }
 
         priv = usb_get_serial_port_data(serial->port[0]);
         priv->chiptype = CT_CYPHIDCOM;
         
-        return (0);     
+        return 0;
 } /* cypress_hidcom_startup */
 
 
@@ -608,8 +610,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
                 timeout = max((HZ*2560)/bps,HZ/10);
         else
                 timeout = 2*HZ;
-        set_current_state(TASK_INTERRUPTIBLE);
-        schedule_timeout(timeout);
+        schedule_timeout_interruptible(timeout);
 
         dbg("%s - stopping urbs", __FUNCTION__);
         usb_kill_urb (port->interrupt_in_urb);
@@ -909,7 +910,8 @@ static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsi
 } /* cypress_ioctl */
 
 
-static void cypress_set_termios (struct usb_serial_port *port, struct termios *old_termios)
+static void cypress_set_termios (struct usb_serial_port *port,
+                struct termios *old_termios)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         struct tty_struct *tty;
@@ -918,7 +920,7 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         unsigned long flags;
         __u8 oldlines;
         int linechange = 0;
-        
+
         dbg("%s - port %d", __FUNCTION__, port->number);
 
         tty = port->tty;
@@ -931,10 +933,12 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         if (!priv->termios_initialized) {
                 if (priv->chiptype == CT_EARTHMATE) {
                         *(tty->termios) = tty_std_termios;
-                        tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL | CLOCAL;
+                        tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL |
+                                CLOCAL;
                 } else if (priv->chiptype == CT_CYPHIDCOM) {
                         *(tty->termios) = tty_std_termios;
-                        tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+                        tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
+                                CLOCAL;
                 }
                 priv->termios_initialized = 1;
         }
@@ -946,12 +950,15 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         /* check if there are new settings */
         if (old_termios) {
                 if ((cflag != old_termios->c_cflag) ||
-                    (RELEVANT_IFLAG(iflag) != RELEVANT_IFLAG(old_termios->c_iflag))) {
-                        dbg("%s - attempting to set new termios settings", __FUNCTION__);
-                        /* should make a copy of this in case something goes wrong in the function, we can restore it */
+                        (RELEVANT_IFLAG(iflag) !=
+                         RELEVANT_IFLAG(old_termios->c_iflag))) {
+                        dbg("%s - attempting to set new termios settings",
+                                        __FUNCTION__);
+                        /* should make a copy of this in case something goes
+                         * wrong in the function, we can restore it */
                         spin_lock_irqsave(&priv->lock, flags);
                         priv->tmp_termios = *(tty->termios);
-                        spin_unlock_irqrestore(&priv->lock, flags); 
+                        spin_unlock_irqrestore(&priv->lock, flags);
                 } else {
                         dbg("%s - nothing to do, exiting", __FUNCTION__);
                         return;
@@ -962,21 +969,34 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         /* set number of data bits, parity, stop bits */
         /* when parity is disabled the parity type bit is ignored */
 
-        stop_bits = cflag & CSTOPB ? 1 : 0; /* 1 means 2 stop bits, 0 means 1 stop bit */
-        
+        /* 1 means 2 stop bits, 0 means 1 stop bit */
+        stop_bits = cflag & CSTOPB ? 1 : 0;
+
         if (cflag & PARENB) {
                 parity_enable = 1;
-                parity_type = cflag & PARODD ? 1 : 0; /* 1 means odd parity, 0 means even parity */
+                /* 1 means odd parity, 0 means even parity */
+                parity_type = cflag & PARODD ? 1 : 0;
         } else
                 parity_enable = parity_type = 0;
 
         if (cflag & CSIZE) {
                 switch (cflag & CSIZE) {
-                        case CS5: data_bits = 0; break;
-                        case CS6: data_bits = 1; break;
-                        case CS7: data_bits = 2; break;
-                        case CS8: data_bits = 3; break;
-                        default: err("%s - CSIZE was set, but not CS5-CS8", __FUNCTION__); data_bits = 3;
+                        case CS5:
+                                data_bits = 0;
+                                break;
+                        case CS6:
+                                data_bits = 1;
+                                break;
+                        case CS7:
+                                data_bits = 2;
+                                break;
+                        case CS8:
+                                data_bits = 3;
+                                break;
+                        default:
+                                err("%s - CSIZE was set, but not CS5-CS8",
+                                                __FUNCTION__);
+                                data_bits = 3;
                 }
         } else
                 data_bits = 3;
@@ -991,63 +1011,85 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         } else {
                 baud_mask = (cflag & CBAUD);
                 switch(baud_mask) {
-                        case B300: dbg("%s - setting baud 300bps", __FUNCTION__); break;
-                        case B600: dbg("%s - setting baud 600bps", __FUNCTION__); break;
-                        case B1200: dbg("%s - setting baud 1200bps", __FUNCTION__); break;
-                        case B2400: dbg("%s - setting baud 2400bps", __FUNCTION__); break;
-                        case B4800: dbg("%s - setting baud 4800bps", __FUNCTION__); break;
-                        case B9600: dbg("%s - setting baud 9600bps", __FUNCTION__); break;
-                        case B19200: dbg("%s - setting baud 19200bps", __FUNCTION__); break;
-                        case B38400: dbg("%s - setting baud 38400bps", __FUNCTION__); break;
-                        case B57600: dbg("%s - setting baud 57600bps", __FUNCTION__); break;
-                        case B115200: dbg("%s - setting baud 115200bps", __FUNCTION__); break;
-                        default: dbg("%s - unknown masked baud rate", __FUNCTION__);
+                        case B300:
+                                dbg("%s - setting baud 300bps", __FUNCTION__);
+                                break;
+                        case B600:
+                                dbg("%s - setting baud 600bps", __FUNCTION__);
+                                break;
+                        case B1200:
+                                dbg("%s - setting baud 1200bps", __FUNCTION__);
+                                break;
+                        case B2400:
+                                dbg("%s - setting baud 2400bps", __FUNCTION__);
+                                break;
+                        case B4800:
+                                dbg("%s - setting baud 4800bps", __FUNCTION__);
+                                break;
+                        case B9600:
+                                dbg("%s - setting baud 9600bps", __FUNCTION__);
+                                break;
+                        case B19200:
+                                dbg("%s - setting baud 19200bps", __FUNCTION__);
+                                break;
+                        case B38400:
+                                dbg("%s - setting baud 38400bps", __FUNCTION__);
+                                break;
+                        case B57600:
+                                dbg("%s - setting baud 57600bps", __FUNCTION__);
+                                break;
+                        case B115200:
+                                dbg("%s - setting baud 115200bps", __FUNCTION__);
+                                break;
+                        default:
+                                dbg("%s - unknown masked baud rate", __FUNCTION__);
                 }
                 priv->line_control = (CONTROL_DTR | CONTROL_RTS);
         }
         spin_unlock_irqrestore(&priv->lock, flags);
-        
-        dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)", __FUNCTION__,
-            stop_bits, parity_enable, parity_type, data_bits);
 
-        cypress_serial_control(port, baud_mask, data_bits, stop_bits, parity_enable,
-                               parity_type, 0, CYPRESS_SET_CONFIG);
+        dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
+                        "%d data_bits (+5)", __FUNCTION__, stop_bits,
+                        parity_enable, parity_type, data_bits);
+
+        cypress_serial_control(port, baud_mask, data_bits, stop_bits,
+                        parity_enable, parity_type, 0, CYPRESS_SET_CONFIG);
 
-        /* we perform a CYPRESS_GET_CONFIG so that the current settings are filled into the private structure
-         * this should confirm that all is working if it returns what we just set */
+        /* we perform a CYPRESS_GET_CONFIG so that the current settings are
+         * filled into the private structure this should confirm that all is
+         * working if it returns what we just set */
         cypress_serial_control(port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
 
-        /* Here we can define custom tty settings for devices
-         *
-         * the main tty termios flag base comes from empeg.c
-         */
+        /* Here we can define custom tty settings for devices; the main tty
+         * termios flag base comes from empeg.c */
 
-        spin_lock_irqsave(&priv->lock, flags);  
+        spin_lock_irqsave(&priv->lock, flags);
         if ( (priv->chiptype == CT_EARTHMATE) && (priv->baud_rate == 4800) ) {
-
-                dbg("Using custom termios settings for a baud rate of 4800bps.");
+                dbg("Using custom termios settings for a baud rate of "
+                                "4800bps.");
                 /* define custom termios settings for NMEA protocol */
 
                 tty->termios->c_iflag /* input modes - */
-                        &= ~(IGNBRK             /* disable ignore break */
-                        | BRKINT                /* disable break causes interrupt */
-                        | PARMRK                /* disable mark parity errors */
-                        | ISTRIP                /* disable clear high bit of input characters */
-                        | INLCR                 /* disable translate NL to CR */
-                        | IGNCR                 /* disable ignore CR */
-                        | ICRNL                 /* disable translate CR to NL */
-                        | IXON);                /* disable enable XON/XOFF flow control */
-                
+                        &= ~(IGNBRK  /* disable ignore break */
+                        | BRKINT     /* disable break causes interrupt */
+                        | PARMRK     /* disable mark parity errors */
+                        | ISTRIP     /* disable clear high bit of input char */
+                        | INLCR      /* disable translate NL to CR */
+                        | IGNCR      /* disable ignore CR */
+                        | ICRNL      /* disable translate CR to NL */
+                        | IXON);     /* disable enable XON/XOFF flow control */
+
                 tty->termios->c_oflag /* output modes */
-                        &= ~OPOST;              /* disable postprocess output characters */
-                
-                tty->termios->c_lflag /* line discipline modes */
-                        &= ~(ECHO               /* disable echo input characters */
-                        | ECHONL                /* disable echo new line */
-                        | ICANON                /* disable erase, kill, werase, and rprnt special characters */
-                        | ISIG                  /* disable interrupt, quit, and suspend special characters */
-                        | IEXTEN);              /* disable non-POSIX special characters */
+                        &= ~OPOST;    /* disable postprocess output char */
 
+                tty->termios->c_lflag /* line discipline modes */
+                        &= ~(ECHO     /* disable echo input characters */
+                        | ECHONL      /* disable echo new line */
+                        | ICANON      /* disable erase, kill, werase, and rprnt
+                                         special characters */
+                        | ISIG        /* disable interrupt, quit, and suspend
+                                         special characters */
+                        | IEXTEN);    /* disable non-POSIX special characters */
         } /* CT_CYPHIDCOM: Application should handle this for device */
 
         linechange = (priv->line_control != oldlines);
@@ -1060,7 +1102,7 @@ static void cypress_set_termios (struct usb_serial_port *port, struct termios *o
         }
 } /* cypress_set_termios */
 
- 
+
 /* returns amount of data still left in soft buffer */
 static int cypress_chars_in_buffer(struct usb_serial_port *port)
 {
@@ -1088,7 +1130,7 @@ static void cypress_throttle (struct usb_serial_port *port)
 
         spin_lock_irqsave(&priv->lock, flags);
         priv->rx_flags = THROTTLED;
-        spin_unlock_irqrestore(&priv->lock, flags);        
+        spin_unlock_irqrestore(&priv->lock, flags);
 }
 
 
@@ -1110,7 +1152,8 @@ static void cypress_unthrottle (struct usb_serial_port *port)
 
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                 if (result)
-                        dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __FUNCTION__, result);
+                        dev_err(&port->dev, "%s - failed submitting read urb, "
+                                        "error %d\n", __FUNCTION__, result);
         }
 }
 
@@ -1122,7 +1165,7 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
-        char tty_flag = TTY_NORMAL;     
+        char tty_flag = TTY_NORMAL;
         int havedata = 0;
         int bytes = 0;
         int result;
@@ -1131,7 +1174,8 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
         dbg("%s - port %d", __FUNCTION__, port->number);
 
         if (urb->status) {
-                dbg("%s - nonzero read status received: %d", __FUNCTION__, urb->status);
+                dbg("%s - nonzero read status received: %d", __FUNCTION__,
+                                urb->status);
                 return;
         }
 
@@ -1155,51 +1199,55 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
                 case 32:
                         /* This is for the CY7C64013... */
                         priv->current_status = data[0] & 0xF8;
-                        bytes = data[1]+2;
-                        i=2;
+                        bytes = data[1] + 2;
+                        i = 2;
                         if (bytes > 2)
                                 havedata = 1;
                         break;
                 case 8:
                         /* This is for the CY7C63743... */
                         priv->current_status = data[0] & 0xF8;
-                        bytes = (data[0] & 0x07)+1;
-                        i=1;
+                        bytes = (data[0] & 0x07) + 1;
+                        i = 1;
                         if (bytes > 1)
                                 havedata = 1;
                         break;
                 default:
-                        dbg("%s - wrong packet size - received %d bytes", __FUNCTION__, urb->actual_length);
+                        dbg("%s - wrong packet size - received %d bytes",
+                                        __FUNCTION__, urb->actual_length);
                         spin_unlock_irqrestore(&priv->lock, flags);
                         goto continue_read;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        usb_serial_debug_data (debug, &port->dev, __FUNCTION__, urb->actual_length, data);
+        usb_serial_debug_data (debug, &port->dev, __FUNCTION__,
+                        urb->actual_length, data);
 
         spin_lock_irqsave(&priv->lock, flags);
         /* check to see if status has changed */
         if (priv != NULL) {
                 if (priv->current_status != priv->prev_status) {
-                        priv->diff_status |= priv->current_status ^ priv->prev_status;
+                        priv->diff_status |= priv->current_status ^
+                                priv->prev_status;
                         wake_up_interruptible(&priv->delta_msr_wait);
                         priv->prev_status = priv->current_status;
                 }
         }
-        spin_unlock_irqrestore(&priv->lock, flags);     
+        spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* hangup, as defined in acm.c... this might be a bad place for it though */
-        if (tty && !(tty->termios->c_cflag & CLOCAL) && !(priv->current_status & UART_CD)) {
+        /* hangup, as defined in acm.c... this might be a bad place for it
+         * though */
+        if (tty && !(tty->termios->c_cflag & CLOCAL) &&
+                        !(priv->current_status & UART_CD)) {
                 dbg("%s - calling hangup", __FUNCTION__);
                 tty_hangup(tty);
                 goto continue_read;
         }
 
-        /* There is one error bit... I'm assuming it is a parity error indicator
-         * as the generic firmware will set this bit to 1 if a parity error occurs.
-         * I can not find reference to any other error events.
-         *
-         */
+        /* There is one error bit... I'm assuming it is a parity error
+         * indicator as the generic firmware will set this bit to 1 if a
+         * parity error occurs.
+         * I can not find reference to any other error events. */
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->current_status & CYP_ERROR) {
                 spin_unlock_irqrestore(&priv->lock, flags);
@@ -1211,7 +1259,8 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
         /* process read if there is data other than line status */
         if (tty && (bytes > i)) {
                 for (; i < bytes ; ++i) {
-                        dbg("pushing byte number %d - %d - %c",i,data[i],data[i]);
+                        dbg("pushing byte number %d - %d - %c", i, data[i],
+                                        data[i]);
                         if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
                                 tty_flip_buffer_push(tty);
                         }
@@ -1221,25 +1270,28 @@ static void cypress_read_int_callback(struct urb *urb, struct pt_regs *regs)
         }
 
         spin_lock_irqsave(&priv->lock, flags);
-        priv->bytes_in += bytes;  /* control and status byte(s) are also counted */
+        /* control and status byte(s) are also counted */
+        priv->bytes_in += bytes;
         spin_unlock_irqrestore(&priv->lock, flags);
 
 continue_read:
-        
-        /* Continue trying to always read... unless the port has closed.  */
+
+        /* Continue trying to always read... unless the port has closed. */
 
         if (port->open_count > 0) {
-        usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
-                usb_rcvintpipe(port->serial->dev, port->interrupt_in_endpointAddress),
-                port->interrupt_in_urb->transfer_buffer,
-                port->interrupt_in_urb->transfer_buffer_length,
-                cypress_read_int_callback, port,
-                interval);
-        result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-        if (result)
-                dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
+                usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
+                                usb_rcvintpipe(port->serial->dev,
+                                        port->interrupt_in_endpointAddress),
+                                port->interrupt_in_urb->transfer_buffer,
+                                port->interrupt_in_urb->transfer_buffer_length,
+                                cypress_read_int_callback, port, interval);
+                result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
+                if (result)
+                        dev_err(&urb->dev->dev, "%s - failed resubmitting "
+                                        "read urb, error %d\n", __FUNCTION__,
+                                        result);
         }
-        
+
         return;
 } /* cypress_read_int_callback */
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index d1964a0c4168..4e434cb10bb1 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -269,6 +269,8 @@
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 
 static int debug;
+static __u16 vendor = FTDI_VID;
+static __u16 product;
 
 /* struct ftdi_sio_quirk is used by devices requiring special attention. */
 struct ftdi_sio_quirk {
@@ -407,6 +409,34 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
+        /*
+         * These will probably use user-space drivers.  Uncomment them if
+         * you need them or use the user-specified vendor/product module
+         * parameters (see ftdi_sio.h for the numbers).  Make a fuss if
+         * you think the driver should recognize any of them by default.
+         */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) }, */
+        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) }, */
         { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
         { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
         { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
@@ -418,6 +448,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
         { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
         { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
+        { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
         { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
@@ -427,12 +458,21 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_0_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
+        { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
         { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
-        { }                                             /* Terminating entry */
+        { },                                    /* Optional parameter entry */
+        { }                                     /* Terminating entry */
 };
 
 MODULE_DEVICE_TABLE (usb, id_table_combined);
@@ -874,7 +914,7 @@ static void ftdi_determine_type(struct usb_serial_port *port)
         unsigned interfaces;
 
         /* Assume it is not the original SIO device for now. */
-        priv->baud_base = 48000000 / 16;
+        priv->baud_base = 48000000 / 2;
         priv->write_offset = 0;
 
         version = le16_to_cpu(udev->descriptor.bcdDevice);
@@ -2030,6 +2070,15 @@ static int __init ftdi_init (void)
         int retval;
 
         dbg("%s", __FUNCTION__);
+        if (vendor > 0 && product > 0) {
+                /* Add user specified VID/PID to reserved element of table. */
+                int i;
+                for (i = 0; id_table_combined[i].idVendor; i++)
+                        ;
+                id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
+                id_table_combined[i].idVendor = vendor;
+                id_table_combined[i].idProduct = product;
+        }
         retval = usb_serial_register(&ftdi_sio_device);
         if (retval)
                 goto failed_sio_register;
@@ -2066,4 +2115,9 @@ MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug enabled or not");
+module_param(vendor, ushort, 0);
+MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
+                __MODULE_STRING(FTDI_VID)")");
+module_param(product, ushort, 0);
+MODULE_PARM_DESC(vendor, "User specified product ID");
 
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 9f4342093e8b..2c35d74cc6d6 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -142,10 +142,43 @@
 /* http://home.earthlink.net/~jrhees/USBUIRT/index.htm */
 #define FTDI_USB_UIRT_PID       0xF850  /* Product Id */
 
-/* ELV USB Module UO100 (PID sent by Stefan Frings) */
-#define FTDI_ELV_UO100_PID      0xFB58  /* Product Id */
-/* ELV USB Module UM100 (PID sent by Arnim Laeuger) */
-#define FTDI_ELV_UM100_PID      0xFB5A  /* Product Id */
+/*
+ * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
+ * All of these devices use FTDI's vendor ID (0x0403).
+ *
+ * The previously included PID for the UO 100 module was incorrect.
+ * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
+ *
+ * Armin Laeuger originally sent the PID for the UM 100 module.
+ */
+#define FTDI_ELV_UR100_PID      0xFB58  /* USB-RS232-Umsetzer (UR 100) */
+#define FTDI_ELV_UM100_PID      0xFB5A  /* USB-Modul UM 100 */
+#define FTDI_ELV_UO100_PID      0xFB5B  /* USB-Modul UO 100 */
+#define FTDI_ELV_ALC8500_PID    0xF06E  /* ALC 8500 Expert */
+/* Additional ELV PIDs that default to using the FTDI D2XX drivers on
+ * MS Windows, rather than the FTDI Virtual Com Port drivers.
+ * Maybe these will be easier to use with the libftdi/libusb user-space
+ * drivers, or possibly the Comedi drivers in some cases. */
+#define FTDI_ELV_CLI7000_PID    0xFB59  /* Computer-Light-Interface (CLI 7000) */
+#define FTDI_ELV_PPS7330_PID    0xFB5C  /* Processor-Power-Supply (PPS 7330) */
+#define FTDI_ELV_TFM100_PID     0xFB5D  /* Temperartur-Feuchte Messgeraet (TFM 100) */
+#define FTDI_ELV_UDF77_PID      0xFB5E  /* USB DCF Funkurh (UDF 77) */
+#define FTDI_ELV_UIO88_PID      0xFB5F  /* USB-I/O Interface (UIO 88) */
+#define FTDI_ELV_UAD8_PID       0xF068  /* USB-AD-Wandler (UAD 8) */
+#define FTDI_ELV_UDA7_PID       0xF069  /* USB-DA-Wandler (UDA 7) */
+#define FTDI_ELV_USI2_PID       0xF06A  /* USB-Schrittmotoren-Interface (USI 2) */
+#define FTDI_ELV_T1100_PID      0xF06B  /* Thermometer (T 1100) */
+#define FTDI_ELV_PCD200_PID     0xF06C  /* PC-Datenlogger (PCD 200) */
+#define FTDI_ELV_ULA200_PID     0xF06D  /* USB-LCD-Ansteuerung (ULA 200) */
+#define FTDI_ELV_FHZ1000PC_PID  0xF06F  /* FHZ 1000 PC */
+#define FTDI_ELV_CSI8_PID       0xE0F0  /* Computer-Schalt-Interface (CSI 8) */
+#define FTDI_ELV_EM1000DL_PID   0xE0F1  /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
+#define FTDI_ELV_PCK100_PID     0xE0F2  /* PC-Kabeltester (PCK 100) */
+#define FTDI_ELV_RFP500_PID     0xE0F3  /* HF-Leistungsmesser (RFP 500) */
+#define FTDI_ELV_FS20SIG_PID    0xE0F4  /* Signalgeber (FS 20 SIG) */
+#define FTDI_ELV_WS300PC_PID    0xE0F6  /* PC-Wetterstation (WS 300 PC) */
+#define FTDI_ELV_FHZ1300PC_PID  0xE0E8  /* FHZ 1300 PC */
+#define FTDI_ELV_WS500_PID      0xE0E9  /* PC-Wetterstation (WS 500) */
 
 /*
  * Definitions for ID TECH (www.idt-net.com) devices
@@ -222,6 +255,7 @@
  */
 #define FALCOM_VID              0x0F94  /* Vendor Id */
 #define FALCOM_TWIST_PID        0x0001  /* Falcom Twist USB GPRS modem */
+#define FALCOM_SAMBA_PID        0x0005  /* Falcom Samba USB GPRS modem */
 
 /*
  * SUUNTO product ids
@@ -277,6 +311,18 @@
 #define FTDI_ACTIVE_ROBOTS_PID  0xE548  /* USB comms board */
 
 /*
+ * Xsens Technologies BV products (http://www.xsens.com).
+ */
+#define XSENS_CONVERTER_0_PID   0xD388
+#define XSENS_CONVERTER_1_PID   0xD389
+#define XSENS_CONVERTER_2_PID   0xD38A
+#define XSENS_CONVERTER_3_PID   0xD38B
+#define XSENS_CONVERTER_4_PID   0xD38C
+#define XSENS_CONVERTER_5_PID   0xD38D
+#define XSENS_CONVERTER_6_PID   0xD38E
+#define XSENS_CONVERTER_7_PID   0xD38F
+
+/*
  * Evolution Robotics products (http://www.evolution.com/).
  * Submitted by Shawn M. Lavelle.
  */
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index fb0926292228..3b958e60f5e8 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -383,11 +383,8 @@ static int keyspan_write(struct usb_serial_port *port,
                 dbg("%s - endpoint %d flip %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), flip);
 
                 if (this_urb->status == -EINPROGRESS) {
-                        if (this_urb->transfer_flags & URB_ASYNC_UNLINK)
-                                break;
                         if (time_before(jiffies, p_priv->tx_start_time[flip] + 10 * HZ))
                                 break;
-                        this_urb->transfer_flags |= URB_ASYNC_UNLINK;
                         usb_unlink_urb(this_urb);
                         break;
                 }
@@ -402,7 +399,6 @@ static int keyspan_write(struct usb_serial_port *port,
                 /* send the data out the bulk port */
                 this_urb->transfer_buffer_length = todo + dataOffset;
 
-                this_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
                 this_urb->dev = port->serial->dev;
                 if ((err = usb_submit_urb(this_urb, GFP_ATOMIC)) != 0) {
                         dbg("usb_submit_urb(write bulk) failed (%d)", err);
@@ -1119,10 +1115,8 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
 
 static inline void stop_urb(struct urb *urb)
 {
-        if (urb && urb->status == -EINPROGRESS) {
-                urb->transfer_flags &= ~URB_ASYNC_UNLINK;
+        if (urb && urb->status == -EINPROGRESS)
                 usb_kill_urb(urb);
-        }
 }
 
 static void keyspan_close(struct usb_serial_port *port, struct file *filp)
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index e9256408757f..92d0f925d053 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -45,29 +45,29 @@
 #include "usb-serial.h"
 
 /* Function prototypes */
-static int  option_open (struct usb_serial_port *port, struct file *filp);
-static void option_close (struct usb_serial_port *port, struct file *filp);
-static int  option_startup (struct usb_serial *serial);
-static void option_shutdown (struct usb_serial *serial);
-static void option_rx_throttle (struct usb_serial_port *port);
-static void option_rx_unthrottle (struct usb_serial_port *port);
-static int  option_write_room (struct usb_serial_port *port);
+static int  option_open(struct usb_serial_port *port, struct file *filp);
+static void option_close(struct usb_serial_port *port, struct file *filp);
+static int  option_startup(struct usb_serial *serial);
+static void option_shutdown(struct usb_serial *serial);
+static void option_rx_throttle(struct usb_serial_port *port);
+static void option_rx_unthrottle(struct usb_serial_port *port);
+static int  option_write_room(struct usb_serial_port *port);
 
 static void option_instat_callback(struct urb *urb, struct pt_regs *regs);
 
-static int  option_write (struct usb_serial_port *port,
-                          const unsigned char *buf, int count);
+static int option_write(struct usb_serial_port *port,
+                        const unsigned char *buf, int count);
 
-static int  option_chars_in_buffer (struct usb_serial_port *port);
-static int  option_ioctl (struct usb_serial_port *port, struct file *file,
-                          unsigned int cmd, unsigned long arg);
-static void option_set_termios (struct usb_serial_port *port,
-                                struct termios *old);
-static void option_break_ctl (struct usb_serial_port *port, int break_state);
-static int  option_tiocmget (struct usb_serial_port *port, struct file *file);
-static int  option_tiocmset (struct usb_serial_port *port, struct file *file,
-                             unsigned int set, unsigned int clear);
-static int  option_send_setup (struct usb_serial_port *port);
+static int  option_chars_in_buffer(struct usb_serial_port *port);
+static int  option_ioctl(struct usb_serial_port *port, struct file *file,
+                        unsigned int cmd, unsigned long arg);
+static void option_set_termios(struct usb_serial_port *port,
+                                struct termios *old);
+static void option_break_ctl(struct usb_serial_port *port, int break_state);
+static int  option_tiocmget(struct usb_serial_port *port, struct file *file);
+static int  option_tiocmset(struct usb_serial_port *port, struct file *file,
+                                unsigned int set, unsigned int clear);
+static int  option_send_setup(struct usb_serial_port *port);
 
 /* Vendor and product IDs */
 #define OPTION_VENDOR_ID                        0x0AF0
@@ -76,7 +76,6 @@ static int  option_send_setup (struct usb_serial_port *port);
 #define OPTION_PRODUCT_FUSION   0x6000
 #define OPTION_PRODUCT_FUSION2  0x6300
 
-
 static struct usb_device_id option_ids[] = {
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_OLD) },
         { USB_DEVICE(OPTION_VENDOR_ID, OPTION_PRODUCT_FUSION) },
@@ -129,7 +128,6 @@ static int debug;
 #define debug 0
 #endif
 
-
 /* per port private data */
 
 #define N_IN_URB 4
@@ -156,10 +154,8 @@ struct option_port_private {
         unsigned long tx_start_time[N_OUT_URB];
 };
 
-
 /* Functions used by new usb-serial code. */
-static int __init
-option_init (void)
+static int __init option_init(void)
 {
         int retval;
         retval = usb_serial_register(&option_3port_device);
@@ -179,8 +175,7 @@ failed_3port_device_register:
         return retval;
 }
 
-static void __exit
-option_exit (void)
+static void __exit option_exit(void)
 {
         usb_deregister (&option_driver);
         usb_serial_deregister (&option_3port_device);
@@ -189,39 +184,31 @@ option_exit (void)
 module_init(option_init);
 module_exit(option_exit);
 
-static void
-option_rx_throttle (struct usb_serial_port *port)
+static void option_rx_throttle(struct usb_serial_port *port)
 {
         dbg("%s", __FUNCTION__);
 }
 
-
-static void
-option_rx_unthrottle (struct usb_serial_port *port)
+static void option_rx_unthrottle(struct usb_serial_port *port)
 {
         dbg("%s", __FUNCTION__);
 }
 
-
-static void
-option_break_ctl (struct usb_serial_port *port, int break_state)
+static void option_break_ctl(struct usb_serial_port *port, int break_state)
 {
         /* Unfortunately, I don't know how to send a break */
         dbg("%s", __FUNCTION__);
 }
 
-
-static void
-option_set_termios (struct usb_serial_port *port,
-                    struct termios *old_termios)
+static void option_set_termios(struct usb_serial_port *port,
+                        struct termios *old_termios)
 {
         dbg("%s", __FUNCTION__);
 
         option_send_setup(port);
 }
 
-static int
-option_tiocmget (struct usb_serial_port *port, struct file *file)
+static int option_tiocmget(struct usb_serial_port *port, struct file *file)
 {
         unsigned int value;
         struct option_port_private *portdata;
@@ -238,9 +225,8 @@ option_tiocmget (struct usb_serial_port *port, struct file *file)
         return value;
 }
 
-static int
-option_tiocmset (struct usb_serial_port *port, struct file *file,
-                 unsigned int set, unsigned int clear)
+static int option_tiocmset(struct usb_serial_port *port, struct file *file,
+                        unsigned int set, unsigned int clear)
 {
         struct option_port_private *portdata;
 
@@ -258,17 +244,15 @@ option_tiocmset (struct usb_serial_port *port, struct file *file,
         return option_send_setup(port);
 }
 
-static int
-option_ioctl (struct usb_serial_port *port, struct file *file,
-              unsigned int cmd, unsigned long arg)
+static int option_ioctl(struct usb_serial_port *port, struct file *file,
+                        unsigned int cmd, unsigned long arg)
 {
         return -ENOIOCTLCMD;
 }
 
 /* Write */
-static int
-option_write (struct usb_serial_port *port,
-                          const unsigned char *buf, int count)
+static int option_write(struct usb_serial_port *port,
+                        const unsigned char *buf, int count)
 {
         struct option_port_private *portdata;
         int i;
@@ -289,28 +273,29 @@ option_write (struct usb_serial_port *port,
 
                 this_urb = portdata->out_urbs[i];
                 if (this_urb->status == -EINPROGRESS) {
-                        if (this_urb->transfer_flags & URB_ASYNC_UNLINK)
-                                continue;
-                        if (time_before(jiffies, portdata->tx_start_time[i] + 10 * HZ))
+                        if (time_before(jiffies,
+                                        portdata->tx_start_time[i] + 10 * HZ))
                                 continue;
-                        this_urb->transfer_flags |= URB_ASYNC_UNLINK;
                         usb_unlink_urb(this_urb);
                         continue;
                 }
                 if (this_urb->status != 0)
-                        dbg("usb_write %p failed (err=%d)", this_urb, this_urb->status);
+                        dbg("usb_write %p failed (err=%d)",
+                                this_urb, this_urb->status);
 
-                dbg("%s: endpoint %d buf %d", __FUNCTION__, usb_pipeendpoint(this_urb->pipe), i);
+                dbg("%s: endpoint %d buf %d", __FUNCTION__,
+                        usb_pipeendpoint(this_urb->pipe), i);
 
                 /* send the data */
                 memcpy (this_urb->transfer_buffer, buf, todo);
                 this_urb->transfer_buffer_length = todo;
 
-                this_urb->transfer_flags &= ~URB_ASYNC_UNLINK;
                 this_urb->dev = port->serial->dev;
                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
                 if (err) {
-                        dbg("usb_submit_urb %p (write bulk) failed (%d, has %d)", this_urb, err, this_urb->status);
+                        dbg("usb_submit_urb %p (write bulk) failed "
+                                "(%d, has %d)", this_urb,
+                                err, this_urb->status);
                         continue;
                 }
                 portdata->tx_start_time[i] = jiffies;
@@ -323,8 +308,7 @@ option_write (struct usb_serial_port *port,
         return count;
 }
 
-static void
-option_indat_callback (struct urb *urb, struct pt_regs *regs)
+static void option_indat_callback(struct urb *urb, struct pt_regs *regs)
 {
         int i, err;
         int endpoint;
@@ -357,14 +341,14 @@ option_indat_callback (struct urb *urb, struct pt_regs *regs)
                 if (port->open_count && urb->status != -ESHUTDOWN) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err)
-                                printk(KERN_ERR "%s: resubmit read urb failed. (%d)", __FUNCTION__, err);
+                                printk(KERN_ERR "%s: resubmit read urb failed. "
+                                        "(%d)", __FUNCTION__, err);
                 }
         }
         return;
 }
 
-static void
-option_outdat_callback (struct urb *urb, struct pt_regs *regs)
+static void option_outdat_callback(struct urb *urb, struct pt_regs *regs)
 {
         struct usb_serial_port *port;
 
@@ -376,8 +360,7 @@ option_outdat_callback (struct urb *urb, struct pt_regs *regs)
                 schedule_work(&port->work);
 }
 
-static void
-option_instat_callback (struct urb *urb, struct pt_regs *regs)
+static void option_instat_callback(struct urb *urb, struct pt_regs *regs)
 {
         int err;
         struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
@@ -395,10 +378,12 @@ option_instat_callback (struct urb *urb, struct pt_regs *regs)
                         dbg("%s: NULL req_pkt\n", __FUNCTION__);
                         return;
                 }
-                if ((req_pkt->bRequestType == 0xA1) && (req_pkt->bRequest == 0x20)) {
+                if ((req_pkt->bRequestType == 0xA1) &&
+                                (req_pkt->bRequest == 0x20)) {
                         int old_dcd_state;
                         unsigned char signals = *((unsigned char *)
-                                        urb->transfer_buffer + sizeof(struct usb_ctrlrequest));
+                                        urb->transfer_buffer +
+                                        sizeof(struct usb_ctrlrequest));
 
                         dbg("%s: signal x%x", __FUNCTION__, signals);
 
@@ -408,12 +393,13 @@ option_instat_callback (struct urb *urb, struct pt_regs *regs)
                         portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
                         portdata->ri_state = ((signals & 0x08) ? 1 : 0);
 
-                        if (port->tty && !C_CLOCAL(port->tty)
-                                        && old_dcd_state && !portdata->dcd_state) {
+                        if (port->tty && !C_CLOCAL(port->tty) &&
+                                        old_dcd_state && !portdata->dcd_state)
                                 tty_hangup(port->tty);
-                        }
-                } else
-                        dbg("%s: type %x req %x", __FUNCTION__, req_pkt->bRequestType,req_pkt->bRequest);
+                } else {
+                        dbg("%s: type %x req %x", __FUNCTION__,
+                                req_pkt->bRequestType,req_pkt->bRequest);
+                }
         } else
                 dbg("%s: error %d", __FUNCTION__, urb->status);
 
@@ -422,13 +408,12 @@ option_instat_callback (struct urb *urb, struct pt_regs *regs)
                 urb->dev = serial->dev;
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
-                        dbg("%s: resubmit intr urb failed. (%d)", __FUNCTION__, err);
+                        dbg("%s: resubmit intr urb failed. (%d)",
+                                __FUNCTION__, err);
         }
 }
 
-
-static int
-option_write_room (struct usb_serial_port *port)
+static int option_write_room(struct usb_serial_port *port)
 {
         struct option_port_private *portdata;
         int i;
@@ -447,9 +432,7 @@ option_write_room (struct usb_serial_port *port)
         return data_len;
 }
 
-
-static int
-option_chars_in_buffer (struct usb_serial_port *port)
+static int option_chars_in_buffer(struct usb_serial_port *port)
 {
         struct option_port_private *portdata;
         int i;
@@ -467,9 +450,7 @@ option_chars_in_buffer (struct usb_serial_port *port)
         return data_len;
 }
 
-
-static int
-option_open (struct usb_serial_port *port, struct file *filp)
+static int option_open(struct usb_serial_port *port, struct file *filp)
 {
         struct option_port_private *portdata;
         struct usb_serial *serial = port->serial;
@@ -490,17 +471,21 @@ option_open (struct usb_serial_port *port, struct file *filp)
                 if (! urb)
                         continue;
                 if (urb->dev != serial->dev) {
-                        dbg("%s: dev %p != %p", __FUNCTION__, urb->dev, serial->dev);
+                        dbg("%s: dev %p != %p", __FUNCTION__,
+                                urb->dev, serial->dev);
                         continue;
                 }
 
-                /* make sure endpoint data toggle is synchronized with the device */
-
+                /*
+                 * make sure endpoint data toggle is synchronized with the
+                 * device
+                 */
                 usb_clear_halt(urb->dev, urb->pipe);
 
                 err = usb_submit_urb(urb, GFP_KERNEL);
                 if (err) {
-                        dbg("%s: submit urb %d failed (%d) %d", __FUNCTION__, i, err,
+                        dbg("%s: submit urb %d failed (%d) %d",
+                                __FUNCTION__, i, err,
                                 urb->transfer_buffer_length);
                 }
         }
@@ -511,7 +496,8 @@ option_open (struct usb_serial_port *port, struct file *filp)
                 if (! urb)
                         continue;
                 urb->dev = serial->dev;
-                /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), usb_pipeout(urb->pipe), 0); */
+                /* usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
+                                usb_pipeout(urb->pipe), 0); */
         }
 
         port->tty->low_latency = 1;
@@ -521,17 +507,13 @@ option_open (struct usb_serial_port *port, struct file *filp)
         return (0);
 }
 
-static inline void
-stop_urb (struct urb *urb)
+static inline void stop_urb(struct urb *urb)
 {
-        if (urb && urb->status == -EINPROGRESS) {
-                urb->transfer_flags &= ~URB_ASYNC_UNLINK;
+        if (urb && urb->status == -EINPROGRESS)
                 usb_kill_urb(urb);
-        }
 }
 
-static void
-option_close (struct usb_serial_port *port, struct file *filp)
+static void option_close(struct usb_serial_port *port, struct file *filp)
 {
         int i;
         struct usb_serial *serial = port->serial;
@@ -555,12 +537,10 @@ option_close (struct usb_serial_port *port, struct file *filp)
         port->tty = NULL;
 }
 
-
 /* Helper functions used by option_setup_urbs */
-static struct urb *
-option_setup_urb (struct usb_serial *serial, int endpoint,
-                  int dir, void *ctx, char *buf, int len,
-                  void (*callback)(struct urb *, struct pt_regs *regs))
+static struct urb *option_setup_urb(struct usb_serial *serial, int endpoint,
+                int dir, void *ctx, char *buf, int len,
+                void (*callback)(struct urb *, struct pt_regs *regs))
 {
         struct urb *urb;
 
@@ -582,8 +562,7 @@ option_setup_urb (struct usb_serial *serial, int endpoint,
 }
 
 /* Setup urbs */
-static void
-option_setup_urbs (struct usb_serial *serial)
+static void option_setup_urbs(struct usb_serial *serial)
 {
         int j;
         struct usb_serial_port *port;
@@ -609,9 +588,7 @@ option_setup_urbs (struct usb_serial *serial)
         }
 }
 
-
-static int
-option_send_setup (struct usb_serial_port *port)
+static int option_send_setup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
@@ -627,16 +604,15 @@ option_send_setup (struct usb_serial_port *port)
                 if (portdata->rts_state)
                         val |= 0x02;
 
-                return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
-                                        0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
+                return usb_control_msg(serial->dev,
+                                usb_rcvctrlpipe(serial->dev, 0),
+                                0x22,0x21,val,0,NULL,0,USB_CTRL_SET_TIMEOUT);
         }
 
         return 0;
 }
 
-
-static int
-option_startup (struct usb_serial *serial)
+static int option_startup(struct usb_serial *serial)
 {
         int i, err;
         struct usb_serial_port *port;
@@ -647,9 +623,10 @@ option_startup (struct usb_serial *serial)
         /* Now setup per port private data */
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                portdata = kmalloc(sizeof(struct option_port_private), GFP_KERNEL);
+                portdata = kmalloc(sizeof(*portdata), GFP_KERNEL);
                 if (!portdata) {
-                        dbg("%s: kmalloc for option_port_private (%d) failed!.", __FUNCTION__, i);
+                        dbg("%s: kmalloc for option_port_private (%d) failed!.",
+                                        __FUNCTION__, i);
                         return (1);
                 }
                 memset(portdata, 0, sizeof(struct option_port_private));
@@ -660,7 +637,8 @@ option_startup (struct usb_serial *serial)
                         continue;
                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
                 if (err)
-                        dbg("%s: submit irq_in urb failed %d", __FUNCTION__, err);
+                        dbg("%s: submit irq_in urb failed %d",
+                                __FUNCTION__, err);
         }
 
         option_setup_urbs(serial);
@@ -668,8 +646,7 @@ option_startup (struct usb_serial *serial)
         return (0);
 }
 
-static void
-option_shutdown (struct usb_serial *serial)
+static void option_shutdown(struct usb_serial *serial)
 {
         int i, j;
         struct usb_serial_port *port;
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 7eab5d4cf3a8..3cf245bdda54 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -95,6 +95,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
         { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
         { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
+        { USB_DEVICE( NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID ) },
         { }                                     /* Terminating entry */
 };
 
@@ -538,8 +539,10 @@ static int pl2303_open (struct usb_serial_port *port, struct file *filp)
 
         dbg("%s -  port %d", __FUNCTION__, port->number);
 
-        usb_clear_halt(serial->dev, port->write_urb->pipe);
-        usb_clear_halt(serial->dev, port->read_urb->pipe);
+        if (priv->type != HX) {
+                usb_clear_halt(serial->dev, port->write_urb->pipe);
+                usb_clear_halt(serial->dev, port->read_urb->pipe);
+        }
 
         buf = kmalloc(10, GFP_KERNEL);
         if (buf==NULL)
@@ -650,8 +653,7 @@ static void pl2303_close (struct usb_serial_port *port, struct file *filp)
                 timeout = max((HZ*2560)/bps,HZ/10);
         else
                 timeout = 2*HZ;
-        set_current_state(TASK_INTERRUPTIBLE);
-        schedule_timeout(timeout);
+        schedule_timeout_interruptible(timeout);
 
         /* shutdown our urbs */
         dbg("%s - shutting down urbs", __FUNCTION__);
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index b734c4003c5a..7be9644f5a03 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -58,3 +58,7 @@
 
 #define SYNTECH_VENDOR_ID       0x0745
 #define SYNTECH_PRODUCT_ID      0x0001
+
+/* Nokia CA-42 Cable */
+#define NOKIA_CA42_VENDOR_ID    0x078b
+#define NOKIA_CA42_PRODUCT_ID   0x1234
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 0267b26dde18..e77fbdfc782d 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -531,7 +531,7 @@ bailout_kref_put:
 
 static void serial_close(struct tty_struct *tty, struct file * filp)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         if (!port)
                 return;
@@ -561,7 +561,7 @@ static void serial_close(struct tty_struct *tty, struct file * filp)
 
 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
         int retval = -EINVAL;
 
         dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
@@ -580,7 +580,7 @@ exit:
 
 static int serial_write_room (struct tty_struct *tty) 
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
         int retval = -EINVAL;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
@@ -599,7 +599,7 @@ exit:
 
 static int serial_chars_in_buffer (struct tty_struct *tty) 
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
         int retval = -EINVAL;
 
         dbg("%s = port %d", __FUNCTION__, port->number);
@@ -618,7 +618,7 @@ exit:
 
 static void serial_throttle (struct tty_struct * tty)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -634,7 +634,7 @@ static void serial_throttle (struct tty_struct * tty)
 
 static void serial_unthrottle (struct tty_struct * tty)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -650,7 +650,7 @@ static void serial_unthrottle (struct tty_struct * tty)
 
 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
         int retval = -ENODEV;
 
         dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
@@ -672,7 +672,7 @@ exit:
 
 static void serial_set_termios (struct tty_struct *tty, struct termios * old)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -688,7 +688,7 @@ static void serial_set_termios (struct tty_struct *tty, struct termios * old)
 
 static void serial_break (struct tty_struct *tty, int break_state)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -749,7 +749,7 @@ done:
 
 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -768,7 +768,7 @@ exit:
 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
                             unsigned int set, unsigned int clear)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
+        struct usb_serial_port *port = tty->driver_data;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
 
@@ -786,7 +786,7 @@ exit:
 
 void usb_serial_port_softint(void *private)
 {
-        struct usb_serial_port *port = (struct usb_serial_port *)private;
+        struct usb_serial_port *port = private;
         struct tty_struct *tty;
 
         dbg("%s - port %d", __FUNCTION__, port->number);
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index f1f1c0608c22..bb9819cc8826 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -111,3 +111,15 @@ config USB_STORAGE_JUMPSHOT
           Say Y here to include additional code to support the Lexar Jumpshot
           USB CompactFlash reader.
 
+
+config USB_STORAGE_ONETOUCH
+        bool "Support OneTouch Button on Maxtor Hard Drives (EXPERIMENTAL)"
+        depends on USB_STORAGE && INPUT_EVDEV && EXPERIMENTAL
+        help
+          Say Y here to include additional code to support the Maxtor OneTouch
+          USB hard drive's onetouch button.
+
+          This code registers the button on the front of Maxtor OneTouch USB
+          hard drive's as an input device. An action can be associated with
+          this input in any keybinding software. (e.g. gnome's keyboard short-
+          cuts)
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index 56652ccc2881..44ab8f9978fe 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -18,6 +18,7 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM)	+= dpcm.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)    += isd200.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)   += datafab.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)  += jumpshot.o
+usb-storage-obj-$(CONFIG_USB_STORAGE_ONETOUCH)  += onetouch.o
 
 usb-storage-objs :=     scsiglue.o protocol.o transport.o usb.o \
                         initializers.o $(usb-storage-obj-y)
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
new file mode 100644
index 000000000000..2c9402dc702b
--- /dev/null
+++ b/drivers/usb/storage/onetouch.c
@@ -0,0 +1,210 @@
+/*
+ * Support for the Maxtor OneTouch USB hard drive's button
+ *
+ * Current development and maintenance by:
+ *      Copyright (c) 2005 Nick Sillik <n.sillik@temple.edu>
+ *
+ * Initial work by:
+ *      Copyright (c) 2003 Erik Thyren <erth7411@student.uu.se>
+ *
+ * Based on usbmouse.c (Vojtech Pavlik) and xpad.c (Marko Friedemann)
+ *
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/input.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb_ch9.h>
+#include <linux/usb_input.h>
+#include "usb.h"
+#include "onetouch.h"
+#include "debug.h"
+
+void onetouch_release_input(void *onetouch_);
+
+struct usb_onetouch {
+        char name[128];
+        char phys[64];
+        struct input_dev dev;   /* input device interface */
+        struct usb_device *udev;        /* usb device */
+
+        struct urb *irq;        /* urb for interrupt in report */
+        unsigned char *data;    /* input data */
+        dma_addr_t data_dma;
+};
+
+static void usb_onetouch_irq(struct urb *urb, struct pt_regs *regs)
+{
+        struct usb_onetouch *onetouch = urb->context;
+        signed char *data = onetouch->data;
+        struct input_dev *dev = &onetouch->dev;
+        int status;
+
+        switch (urb->status) {
+        case 0:                 /* success */
+                break;
+        case -ECONNRESET:       /* unlink */
+        case -ENOENT:
+        case -ESHUTDOWN:
+                return;
+        /* -EPIPE:  should clear the halt */
+        default:                /* error */
+                goto resubmit;
+        }
+
+        input_regs(dev, regs);
+
+        input_report_key(&onetouch->dev, ONETOUCH_BUTTON,
+                         data[0] & 0x02);
+
+        input_sync(dev);
+resubmit:
+        status = usb_submit_urb (urb, SLAB_ATOMIC);
+        if (status)
+                err ("can't resubmit intr, %s-%s/input0, status %d",
+                        onetouch->udev->bus->bus_name,
+                        onetouch->udev->devpath, status);
+}
+
+static int usb_onetouch_open(struct input_dev *dev)
+{
+        struct usb_onetouch *onetouch = dev->private;
+
+        onetouch->irq->dev = onetouch->udev;
+        if (usb_submit_urb(onetouch->irq, GFP_KERNEL)) {
+                err("usb_submit_urb failed");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static void usb_onetouch_close(struct input_dev *dev)
+{
+        struct usb_onetouch *onetouch = dev->private;
+
+        usb_kill_urb(onetouch->irq);
+}
+
+int onetouch_connect_input(struct us_data *ss)
+{
+        struct usb_device *udev = ss->pusb_dev;
+        struct usb_host_interface *interface;
+        struct usb_endpoint_descriptor *endpoint;
+        struct usb_onetouch *onetouch;
+        int pipe, maxp;
+        char path[64];
+
+        interface = ss->pusb_intf->cur_altsetting;
+
+        if (interface->desc.bNumEndpoints != 3)
+                return -ENODEV;
+
+        endpoint = &interface->endpoint[2].desc;
+        if(!(endpoint->bEndpointAddress & USB_DIR_IN))
+                return -ENODEV;
+        if((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
+                        != USB_ENDPOINT_XFER_INT)
+                return -ENODEV;
+
+        pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
+        maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
+
+        if (!(onetouch = kcalloc(1, sizeof(struct usb_onetouch), GFP_KERNEL)))
+                return -ENOMEM;
+
+        onetouch->data = usb_buffer_alloc(udev, ONETOUCH_PKT_LEN,
+                                          SLAB_ATOMIC, &onetouch->data_dma);
+        if (!onetouch->data){
+                kfree(onetouch);
+                return -ENOMEM;
+        }
+
+        onetouch->irq = usb_alloc_urb(0, GFP_KERNEL);
+        if (!onetouch->irq){
+                kfree(onetouch);
+                usb_buffer_free(udev, ONETOUCH_PKT_LEN,
+                                onetouch->data, onetouch->data_dma);
+                return -ENODEV;
+        }
+
+
+        onetouch->udev = udev;
+
+        set_bit(EV_KEY, onetouch->dev.evbit);
+        set_bit(ONETOUCH_BUTTON, onetouch->dev.keybit);
+        clear_bit(0, onetouch->dev.keybit);
+
+        onetouch->dev.private = onetouch;
+        onetouch->dev.open = usb_onetouch_open;
+        onetouch->dev.close = usb_onetouch_close;
+
+        usb_make_path(udev, path, sizeof(path));
+        sprintf(onetouch->phys, "%s/input0", path);
+
+        onetouch->dev.name = onetouch->name;
+        onetouch->dev.phys = onetouch->phys;
+
+        usb_to_input_id(udev, &onetouch->dev.id);
+
+        onetouch->dev.dev = &udev->dev;
+
+        if (udev->manufacturer)
+                strcat(onetouch->name, udev->manufacturer);
+        if (udev->product)
+                sprintf(onetouch->name, "%s %s", onetouch->name,
+                        udev->product);
+        if (!strlen(onetouch->name))
+                sprintf(onetouch->name, "Maxtor Onetouch %04x:%04x",
+                        onetouch->dev.id.vendor, onetouch->dev.id.product);
+
+        usb_fill_int_urb(onetouch->irq, udev, pipe, onetouch->data,
+                         (maxp > 8 ? 8 : maxp),
+                         usb_onetouch_irq, onetouch, endpoint->bInterval);
+        onetouch->irq->transfer_dma = onetouch->data_dma;
+        onetouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+        ss->extra_destructor = onetouch_release_input;
+        ss->extra = onetouch;
+
+        input_register_device(&onetouch->dev);
+        printk(KERN_INFO "usb-input: %s on %s\n", onetouch->dev.name, path);
+
+        return 0;
+}
+
+void onetouch_release_input(void *onetouch_)
+{
+        struct usb_onetouch *onetouch = (struct usb_onetouch *) onetouch_;
+
+        if (onetouch) {
+                usb_kill_urb(onetouch->irq);
+                input_unregister_device(&onetouch->dev);
+                usb_free_urb(onetouch->irq);
+                usb_buffer_free(onetouch->udev, ONETOUCH_PKT_LEN,
+                                onetouch->data, onetouch->data_dma);
+                printk(KERN_INFO "usb-input: deregistering %s\n",
+                                onetouch->dev.name);
+        }
+}
diff --git a/drivers/usb/storage/onetouch.h b/drivers/usb/storage/onetouch.h
new file mode 100644
index 000000000000..41c7aa8f0446
--- /dev/null
+++ b/drivers/usb/storage/onetouch.h
@@ -0,0 +1,9 @@
+#ifndef _ONETOUCH_H_
+#define _ONETOUCH_H_
+
+#define ONETOUCH_PKT_LEN        0x02
+#define ONETOUCH_BUTTON         KEY_PROG1
+
+int onetouch_connect_input(struct us_data *ss);
+
+#endif
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index af294bb68c35..4837524eada7 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -156,6 +156,14 @@ static int slave_configure(struct scsi_device *sdev)
                 if (us->flags & US_FL_FIX_CAPACITY)
                         sdev->fix_capacity = 1;
 
+                /* Some devices report a SCSI revision level above 2 but are
+                 * unable to handle the REPORT LUNS command (for which
+                 * support is mandatory at level 3).  Since we already have
+                 * a Get-Max-LUN request, we won't lose much by setting the
+                 * revision level down to 2.  The only devices that would be
+                 * affected are those with sparse LUNs. */
+                sdev->scsi_level = SCSI_2;
+
                 /* USB-IDE bridges tend to report SK = 0x04 (Non-recoverable
                  * Hardware Error) when any low-level error occurs,
                  * recoverable or not.  Setting this flag tells the SCSI
@@ -219,42 +227,42 @@ static int queuecommand(struct scsi_cmnd *srb,
  ***********************************************************************/
 
 /* Command timeout and abort */
-/* This is always called with scsi_lock(host) held */
 static int command_abort(struct scsi_cmnd *srb)
 {
         struct us_data *us = host_to_us(srb->device->host);
 
         US_DEBUGP("%s called\n", __FUNCTION__);
 
+        /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
+         * bits are protected by the host lock. */
+        scsi_lock(us_to_host(us));
+
         /* Is this command still active? */
         if (us->srb != srb) {
+                scsi_unlock(us_to_host(us));
                 US_DEBUGP ("-- nothing to abort\n");
                 return FAILED;
         }
 
         /* Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
          * a device reset isn't already in progress (to avoid interfering
-         * with the reset).  To prevent races with auto-reset, we must
-         * stop any ongoing USB transfers while still holding the host
-         * lock. */
+         * with the reset).  Note that we must retain the host lock while
+         * calling usb_stor_stop_transport(); otherwise it might interfere
+         * with an auto-reset that begins as soon as we release the lock. */
         set_bit(US_FLIDX_TIMED_OUT, &us->flags);
         if (!test_bit(US_FLIDX_RESETTING, &us->flags)) {
                 set_bit(US_FLIDX_ABORTING, &us->flags);
                 usb_stor_stop_transport(us);
         }
+        scsi_unlock(us_to_host(us));
 
         /* Wait for the aborted command to finish */
         wait_for_completion(&us->notify);
-
-        /* Reacquire the lock and allow USB transfers to resume */
-        clear_bit(US_FLIDX_ABORTING, &us->flags);
-        clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
         return SUCCESS;
 }
 
 /* This invokes the transport reset mechanism to reset the state of the
  * device */
-/* This is always called with scsi_lock(host) held */
 static int device_reset(struct scsi_cmnd *srb)
 {
         struct us_data *us = host_to_us(srb->device->host);
@@ -271,7 +279,6 @@ static int device_reset(struct scsi_cmnd *srb)
 }
 
 /* Simulate a SCSI bus reset by resetting the device's USB port. */
-/* This is always called with scsi_lock(host) held */
 static int bus_reset(struct scsi_cmnd *srb)
 {
         struct us_data *us = host_to_us(srb->device->host);
@@ -283,7 +290,6 @@ static int bus_reset(struct scsi_cmnd *srb)
         result = usb_stor_port_reset(us);
         up(&(us->dev_semaphore));
 
-        /* lock the host for the return */
         return result < 0 ? FAILED : SUCCESS;
 }
 
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index f3b60288696c..356342c6e7a2 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -839,34 +839,31 @@ static int usbat_identify_device(struct us_data *us,
         rc = usbat_device_reset(us);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 return rc;
+        msleep(25);
 
         /*
-         * By examining the device signature after a reset, we can identify
-         * whether the device supports the ATAPI packet interface.
-         * The flash-devices do not support this, whereas the HP CDRW's obviously
-         * do.
-         *
-         * This method is not ideal, but works because no other devices have been
-         * produced based on the USBAT/USBAT02.
-         *
-         * Section 9.1 of the ATAPI-4 spec states (amongst other things) that
-         * after a device reset, a Cylinder low of 0x14 indicates that the device
-         * does support packet commands.
+         * In attempt to distinguish between HP CDRW's and Flash readers, we now
+         * execute the IDENTIFY PACKET DEVICE command. On ATA devices (i.e. flash
+         * readers), this command should fail with error. On ATAPI devices (i.e.
+         * CDROM drives), it should succeed.
          */
-        rc = usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, &status);
-        if (rc != USB_STOR_XFER_GOOD)
-                return USB_STOR_TRANSPORT_ERROR;
+        rc = usbat_write(us, USBAT_ATA, USBAT_ATA_CMD, 0xA1);
+        if (rc != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
 
-        US_DEBUGP("usbat_identify_device: Cylinder low is %02X\n", status);
+        rc = usbat_get_status(us, &status);
+        if (rc != USB_STOR_XFER_GOOD)
+                return USB_STOR_TRANSPORT_ERROR;
 
-        if (status == 0x14) {
+        // Check for error bit
+        if (status & 0x01) {
+                 // Device is a CompactFlash reader/writer
+                US_DEBUGP("usbat_identify_device: Detected Flash reader/writer\n");
+                info->devicetype = USBAT_DEV_FLASH;
+        } else {
                 // Device is HP 8200
                 US_DEBUGP("usbat_identify_device: Detected HP8200 CDRW\n");
                 info->devicetype = USBAT_DEV_HP8200;
-        } else {
-                // Device is a CompactFlash reader/writer
-                US_DEBUGP("usbat_identify_device: Detected Flash reader/writer\n");
-                info->devicetype = USBAT_DEV_FLASH;
         }
 
         return USB_STOR_TRANSPORT_GOOD;
@@ -1239,16 +1236,10 @@ static int usbat_select_and_test_registers(struct us_data *us)
 {
         int selector;
         unsigned char *status = us->iobuf;
-        unsigned char max_selector = 0xB0;
-        if (usbat_get_device_type(us) == USBAT_DEV_FLASH)
-                max_selector = 0xA0;
 
         // try device = master, then device = slave.
-
-        for (selector = 0xA0; selector <= max_selector; selector += 0x10) {
-
-                if (usbat_get_device_type(us) == USBAT_DEV_HP8200 &&
-                        usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) != 
+        for (selector = 0xA0; selector <= 0xB0; selector += 0x10) {
+                if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
                                 USB_STOR_XFER_GOOD)
                         return USB_STOR_TRANSPORT_ERROR;
 
@@ -1334,60 +1325,30 @@ int init_usbat(struct us_data *us)
 
         US_DEBUGP("INIT 3\n");
 
-        // At this point, we need to detect which device we are using
-        if (usbat_set_transport(us, info))
-                return USB_STOR_TRANSPORT_ERROR;
-
-        US_DEBUGP("INIT 4\n");
-
-        if (usbat_get_device_type(us) == USBAT_DEV_HP8200) {
-                msleep(250);
-
-                // Write 0x80 to ISA port 0x3F
-                rc = usbat_write(us, USBAT_ISA, 0x3F, 0x80);
-                if (rc != USB_STOR_XFER_GOOD)
-                        return USB_STOR_TRANSPORT_ERROR;
-
-                US_DEBUGP("INIT 5\n");
-
-                // Read ISA port 0x27
-                rc = usbat_read(us, USBAT_ISA, 0x27, status);
-                if (rc != USB_STOR_XFER_GOOD)
-                        return USB_STOR_TRANSPORT_ERROR;
-
-                US_DEBUGP("INIT 6\n");
-
-                rc = usbat_read_user_io(us, status);
-                if (rc != USB_STOR_XFER_GOOD)
-                        return USB_STOR_TRANSPORT_ERROR;
-
-                US_DEBUGP("INIT 7\n");
-        }
-
         rc = usbat_select_and_test_registers(us);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 return rc;
 
-        US_DEBUGP("INIT 8\n");
+        US_DEBUGP("INIT 4\n");
 
         rc = usbat_read_user_io(us, status);
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        US_DEBUGP("INIT 9\n");
+        US_DEBUGP("INIT 5\n");
 
         // Enable peripheral control signals and card detect
         rc = usbat_device_enable_cdt(us);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 return rc;
 
-        US_DEBUGP("INIT 10\n");
+        US_DEBUGP("INIT 6\n");
 
         rc = usbat_read_user_io(us, status);
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        US_DEBUGP("INIT 11\n");
+        US_DEBUGP("INIT 7\n");
 
         msleep(1400);
 
@@ -1395,13 +1356,19 @@ int init_usbat(struct us_data *us)
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        US_DEBUGP("INIT 12\n");
+        US_DEBUGP("INIT 8\n");
 
         rc = usbat_select_and_test_registers(us);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 return rc;
 
-        US_DEBUGP("INIT 13\n");
+        US_DEBUGP("INIT 9\n");
+
+        // At this point, we need to detect which device we are using
+        if (usbat_set_transport(us, info))
+                return USB_STOR_TRANSPORT_ERROR;
+
+        US_DEBUGP("INIT 10\n");
 
         if (usbat_get_device_type(us) == USBAT_DEV_FLASH) { 
                 subcountH = 0x02;
@@ -1412,7 +1379,7 @@ int init_usbat(struct us_data *us)
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        US_DEBUGP("INIT 14\n");
+        US_DEBUGP("INIT 11\n");
 
         return USB_STOR_TRANSPORT_GOOD;
 }
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index e6b1c6cf07f2..c1ba5301ebfc 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -96,8 +96,8 @@
  * or before the URB_ACTIVE bit was set.  If so, it's essential to cancel
  * the URB if it hasn't been cancelled already (i.e., if the URB_ACTIVE bit
  * is still set).  Either way, the function must then wait for the URB to
- * finish.  Note that because the URB_ASYNC_UNLINK flag is set, the URB can
- * still be in progress even after a call to usb_unlink_urb() returns.
+ * finish.  Note that the URB can still be in progress even after a call to
+ * usb_unlink_urb() returns.
  *
  * The idea is that (1) once the ABORTING or DISCONNECTING bit is set,
  * either the stop_transport() function or the submitting function
@@ -158,8 +158,7 @@ static int usb_stor_msg_common(struct us_data *us, int timeout)
          * hasn't been mapped for DMA.  Yes, this is clunky, but it's
          * easier than always having the caller tell us whether the
          * transfer buffer has already been mapped. */
-        us->current_urb->transfer_flags =
-                        URB_ASYNC_UNLINK | URB_NO_SETUP_DMA_MAP;
+        us->current_urb->transfer_flags = URB_NO_SETUP_DMA_MAP;
         if (us->current_urb->transfer_buffer == us->iobuf)
                 us->current_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
         us->current_urb->transfer_dma = us->iobuf_dma;
@@ -611,7 +610,6 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 unsigned char old_sc_data_direction;
                 unsigned char old_cmd_len;
                 unsigned char old_cmnd[MAX_COMMAND_SIZE];
-                unsigned long old_serial_number;
                 int old_resid;
 
                 US_DEBUGP("Issuing auto-REQUEST_SENSE\n");
@@ -648,10 +646,6 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 old_sg = srb->use_sg;
                 srb->use_sg = 0;
 
-                /* change the serial number -- toggle the high bit*/
-                old_serial_number = srb->serial_number;
-                srb->serial_number ^= 0x80000000;
-
                 /* issue the auto-sense command */
                 old_resid = srb->resid;
                 srb->resid = 0;
@@ -662,7 +656,6 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 srb->request_buffer = old_request_buffer;
                 srb->request_bufflen = old_request_bufflen;
                 srb->use_sg = old_sg;
-                srb->serial_number = old_serial_number;
                 srb->sc_data_direction = old_sc_data_direction;
                 srb->cmd_len = old_cmd_len;
                 memcpy(srb->cmnd, old_cmnd, MAX_COMMAND_SIZE);
@@ -985,7 +978,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
         bcb->DataTransferLength = cpu_to_le32(transfer_length);
         bcb->Flags = srb->sc_data_direction == DMA_FROM_DEVICE ? 1 << 7 : 0;
-        bcb->Tag = srb->serial_number;
+        bcb->Tag = ++us->tag;
         bcb->Lun = srb->device->lun;
         if (us->flags & US_FL_SCM_MULT_TARG)
                 bcb->Lun |= srb->device->id << 4;
@@ -1074,7 +1067,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         US_DEBUGP("Bulk Status S 0x%x T 0x%x R %u Stat 0x%x\n",
                         le32_to_cpu(bcs->Signature), bcs->Tag, 
                         residue, bcs->Status);
-        if (bcs->Tag != srb->serial_number || bcs->Status > US_BULK_STAT_PHASE) {
+        if (bcs->Tag != us->tag || bcs->Status > US_BULK_STAT_PHASE) {
                 US_DEBUGP("Bulk logical error\n");
                 return USB_STOR_TRANSPORT_ERROR;
         }
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index bd0ab3039bdd..b79dad1b598c 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -79,6 +79,23 @@ UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
                 US_SC_8070, US_PR_SCM_ATAPI, init_usbat, 0), 
 #endif
 
+/* Patch submitted by Mihnea-Costin Grigore <mihnea@zulu.ro> */
+UNUSUAL_DEV(  0x040d, 0x6205, 0x0003, 0x0003,
+                "VIA Technologies Inc.",
+                "USB 2.0 Card Reader",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE ),
+
+/* Reported by Sebastian Kapfer <sebastian_kapfer@gmx.net>
+ * and Olaf Hering <olh@suse.de> (different bcd's, same vendor/product)
+ * for USB floppies that need the SINGLE_LUN enforcement.
+ */
+UNUSUAL_DEV(  0x0409, 0x0040, 0x0000, 0x9999,
+                "NEC",
+                "NEC USB UF000x",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SINGLE_LUN ),
+
 /* Deduced by Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  * Entry needed for flags: US_FL_FIX_INQUIRY because initial inquiry message
  * always fails and confuses drive.
@@ -89,6 +106,13 @@ UNUSUAL_DEV(  0x0411, 0x001c, 0x0113, 0x0113,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* Reported by Olaf Hering <olh@suse.de> from novell bug #105878 */
+UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
+                "SMSC",
+                "FDC GOLD-2.30",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SINGLE_LUN ),
+
 #ifdef CONFIG_USB_STORAGE_DPCM
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 "Microtech",
@@ -96,6 +120,24 @@ UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ),
 #endif
 
+/*
+ * Pete Zaitcev <zaitcev@yahoo.com>, from Patrick C. F. Ernzer, bz#162559.
+ * The key does not actually break, but it returns zero sense which
+ * makes our SCSI stack to print confusing messages.
+ */
+UNUSUAL_DEV(  0x0457, 0x0150, 0x0100, 0x0100,
+                "USBest Technology",    /* sold by Transcend */
+                "USB Mass Storage Device",
+                US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
+
+/* Patch submitted by Daniel Drake <dsd@gentoo.org>
+ * Device reports nonsense bInterfaceProtocol 6 when connected over USB2 */
+UNUSUAL_DEV(  0x0451, 0x5416, 0x0100, 0x0100,
+                "Neuros Audio",
+                "USB 2.0 HD 2.5",
+                US_SC_DEVICE, US_PR_BULK, NULL,
+                US_FL_NEED_OVERRIDE ),
+
 /* Patch submitted by Philipp Friedrich <philipp@void.at> */
 UNUSUAL_DEV(  0x0482, 0x0100, 0x0100, 0x0100,
                 "Kyocera",
@@ -929,6 +971,18 @@ UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
                US_FL_SINGLE_LUN ),
 #endif
 
+/* Submitted by: Nick Sillik <n.sillik@temple.edu>
+ * Needed for OneTouch extension to usb-storage
+ *
+ */
+#ifdef CONFIG_USB_STORAGE_ONETOUCH
+        UNUSUAL_DEV(  0x0d49, 0x7010, 0x0000, 0x9999,
+                        "Maxtor",
+                        "OneTouch External Harddrive",
+                        US_SC_DEVICE, US_PR_DEVICE, onetouch_connect_input,
+                        0),
+#endif
+
 /* Submitted by Joris Struyve <joris@struyve.be> */
 UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
                 "Medion",
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 77e7fc258aa2..f9a9bfa1aef5 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -90,7 +90,9 @@
 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
 #include "jumpshot.h"
 #endif
-
+#ifdef CONFIG_USB_STORAGE_ONETOUCH
+#include "onetouch.h"
+#endif
 
 /* Some informational data */
 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
@@ -390,11 +392,16 @@ SkipForAbort:
                 /* If an abort request was received we need to signal that
                  * the abort has finished.  The proper test for this is
                  * the TIMED_OUT flag, not srb->result == DID_ABORT, because
-                 * a timeout/abort request might be received after all the
-                 * USB processing was complete. */
-                if (test_bit(US_FLIDX_TIMED_OUT, &us->flags))
+                 * the timeout might have occurred after the command had
+                 * already completed with a different result code. */
+                if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
                         complete(&(us->notify));
 
+                        /* Allow USB transfers to resume */
+                        clear_bit(US_FLIDX_ABORTING, &us->flags);
+                        clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
+                }
+
                 /* finished working on this command */
                 us->srb = NULL;
                 scsi_unlock(host);
@@ -786,6 +793,7 @@ static void usb_stor_release_resources(struct us_data *us)
          * any more commands.
          */
         US_DEBUGP("-- sending exit command to thread\n");
+        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
         up(&us->sema);
 
         /* Call the destructor routine, if it exists */
@@ -816,6 +824,49 @@ static void dissociate_dev(struct us_data *us)
         usb_set_intfdata(us->pusb_intf, NULL);
 }
 
+/* First stage of disconnect processing: stop all commands and remove
+ * the host */
+static void quiesce_and_remove_host(struct us_data *us)
+{
+        /* Prevent new USB transfers, stop the current command, and
+         * interrupt a SCSI-scan or device-reset delay */
+        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
+        usb_stor_stop_transport(us);
+        wake_up(&us->delay_wait);
+
+        /* It doesn't matter if the SCSI-scanning thread is still running.
+         * The thread will exit when it sees the DISCONNECTING flag. */
+
+        /* Wait for the current command to finish, then remove the host */
+        down(&us->dev_semaphore);
+        up(&us->dev_semaphore);
+
+        /* queuecommand won't accept any new commands and the control
+         * thread won't execute a previously-queued command.  If there
+         * is such a command pending, complete it with an error. */
+        if (us->srb) {
+                us->srb->result = DID_NO_CONNECT << 16;
+                scsi_lock(us_to_host(us));
+                us->srb->scsi_done(us->srb);
+                us->srb = NULL;
+                scsi_unlock(us_to_host(us));
+        }
+
+        /* Now we own no commands so it's safe to remove the SCSI host */
+        scsi_remove_host(us_to_host(us));
+}
+
+/* Second stage of disconnect processing: deallocate all resources */
+static void release_everything(struct us_data *us)
+{
+        usb_stor_release_resources(us);
+        dissociate_dev(us);
+
+        /* Drop our reference to the host; the SCSI core will free it
+         * (and "us" along with it) when the refcount becomes 0. */
+        scsi_host_put(us_to_host(us));
+}
+
 /* Thread to carry out delayed SCSI-device scanning */
 static int usb_stor_scan_thread(void * __us)
 {
@@ -956,7 +1007,7 @@ static int storage_probe(struct usb_interface *intf,
         if (result < 0) {
                 printk(KERN_WARNING USB_STORAGE 
                        "Unable to start the device-scanning thread\n");
-                scsi_remove_host(host);
+                quiesce_and_remove_host(us);
                 goto BadDevice;
         }
         atomic_inc(&total_threads);
@@ -969,10 +1020,7 @@ static int storage_probe(struct usb_interface *intf,
         /* We come here if there are any problems */
 BadDevice:
         US_DEBUGP("storage_probe() failed\n");
-        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
-        usb_stor_release_resources(us);
-        dissociate_dev(us);
-        scsi_host_put(host);
+        release_everything(us);
         return result;
 }
 
@@ -982,28 +1030,8 @@ static void storage_disconnect(struct usb_interface *intf)
         struct us_data *us = usb_get_intfdata(intf);
 
         US_DEBUGP("storage_disconnect() called\n");
-
-        /* Prevent new USB transfers, stop the current command, and
-         * interrupt a SCSI-scan or device-reset delay */
-        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
-        usb_stor_stop_transport(us);
-        wake_up(&us->delay_wait);
-
-        /* It doesn't matter if the SCSI-scanning thread is still running.
-         * The thread will exit when it sees the DISCONNECTING flag. */
-
-        /* Wait for the current command to finish, then remove the host */
-        down(&us->dev_semaphore);
-        up(&us->dev_semaphore);
-        scsi_remove_host(us_to_host(us));
-
-        /* Wait for everything to become idle and release all our resources */
-        usb_stor_release_resources(us);
-        dissociate_dev(us);
-
-        /* Drop our reference to the host; the SCSI core will free it
-         * (and "us" along with it) when the refcount becomes 0. */
-        scsi_host_put(us_to_host(us));
+        quiesce_and_remove_host(us);
+        release_everything(us);
 }
 
 /***********************************************************************
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 625b7aa98074..a195adae57b6 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -158,6 +158,7 @@ struct us_data {
 
         /* SCSI interfaces */
         struct scsi_cmnd        *srb;            /* current srb         */
+        unsigned int            tag;             /* current dCBWTag     */
 
         /* thread information */
         int                     pid;             /* control thread       */