Merge git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb-2.6: (100 commits)
  usb-storage: revert DMA-alignment change for Wireless USB
  USB: use reset_resume when normal resume fails
  usb_gadget: composite cdc gadget fault handling
  usb gadget: minor USBCV fix for composite framework
  USB: Fix bug with byte order in isp116x-hcd.c fio write/read
  USB: fix double kfree in ipaq in error case
  USB: fix build error in cdc-acm for CONFIG_PM=n
  USB: remove board-specific UP2OCR configuration from pxa27x-udc
  USB: EHCI: Reconciling USB register differences on MPC85xx vs MPC83xx
  USB: Fix pointer/int cast in USB devio code
  usb gadget: g_cdc dependso on NET
  USB: Au1xxx-usb: suspend/resume support.
  USB: Au1xxx-usb: clean up ohci/ehci bus glue sources.
  usbfs: don't store bad pointers in registration
  usbfs: fix race between open and unregister
  usbfs: simplify the lookup-by-minor routines
  usbfs: send disconnect signals when device is unregistered
  USB: Force unbinding of drivers lacking reset_resume or other methods
  USB: ohci-pnx4008: I2C cleanups and fixes
  USB: debug port converter does not accept more than 8 byte packets
  ...

133 files changed, 11033 insertions, 8766 deletions

diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index 01427c51c7cc..27fe4d8912cb 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -122,7 +122,7 @@ static void hid_reset(struct work_struct *work)
                 dev_dbg(&usbhid->intf->dev, "resetting device\n");
                 rc = rc_lock = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf);
                 if (rc_lock >= 0) {
-                        rc = usb_reset_composite_device(hid_to_usb_dev(hid), usbhid->intf);
+                        rc = usb_reset_device(hid_to_usb_dev(hid));
                         if (rc_lock)
                                 usb_unlock_device(hid_to_usb_dev(hid));
                 }
diff --git a/drivers/usb/atm/cxacru.c b/drivers/usb/atm/cxacru.c
index 90583d6a5949..507a9bd0d77c 100644
--- a/drivers/usb/atm/cxacru.c
+++ b/drivers/usb/atm/cxacru.c
@@ -1052,7 +1052,6 @@ static int cxacru_bind(struct usbatm_data *usbatm_instance,
 
         instance->usbatm = usbatm_instance;
         instance->modem_type = (struct cxacru_modem_type *) id->driver_info;
-        memset(instance->card_info, 0, sizeof(instance->card_info));
 
         mutex_init(&instance->poll_state_serialize);
         instance->poll_state = CXPOLL_STOPPED;
diff --git a/drivers/usb/atm/speedtch.c b/drivers/usb/atm/speedtch.c
index 7d27c9cf3c43..76fce44c2f9a 100644
--- a/drivers/usb/atm/speedtch.c
+++ b/drivers/usb/atm/speedtch.c
@@ -829,7 +829,6 @@ static int speedtch_bind(struct usbatm_data *usbatm,
         if (use_isoc) {
                 const struct usb_host_interface *desc = data_intf->cur_altsetting;
                 const __u8 target_address = USB_DIR_IN | usbatm->driver->isoc_in;
-                int i;
 
                 use_isoc = 0; /* fall back to bulk if endpoint not found */
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index c3201affa0b6..95ae6377d7e5 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -159,12 +159,34 @@ static void acm_write_done(struct acm *acm, struct acm_wb *wb)
         spin_lock_irqsave(&acm->write_lock, flags);
         acm->write_ready = 1;
         wb->use = 0;
+        acm->transmitting--;
         spin_unlock_irqrestore(&acm->write_lock, flags);
 }
 
 /*
  * Poke write.
+ *
+ * the caller is responsible for locking
  */
+
+static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
+{
+        int rc;
+
+        acm->transmitting++;
+
+        wb->urb->transfer_buffer = wb->buf;
+        wb->urb->transfer_dma = wb->dmah;
+        wb->urb->transfer_buffer_length = wb->len;
+        wb->urb->dev = acm->dev;
+
+        if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
+                dbg("usb_submit_urb(write bulk) failed: %d", rc);
+                acm_write_done(acm, wb);
+        }
+        return rc;
+}
+
 static int acm_write_start(struct acm *acm, int wbn)
 {
         unsigned long flags;
@@ -182,26 +204,31 @@ static int acm_write_start(struct acm *acm, int wbn)
                 return 0;       /* A white lie */
         }
 
+        wb = &acm->wb[wbn];
+        if(acm_wb_is_avail(acm) <= 1)
+                acm->write_ready = 0;
+
+        dbg("%s susp_count: %d", __func__, acm->susp_count);
+        if (acm->susp_count) {
+                acm->old_ready = acm->write_ready;
+                acm->delayed_wb = wb;
+                acm->write_ready = 0;
+                schedule_work(&acm->waker);
+                spin_unlock_irqrestore(&acm->write_lock, flags);
+                return 0;       /* A white lie */
+        }
+        usb_mark_last_busy(acm->dev);
+
         if (!acm_wb_is_used(acm, wbn)) {
                 spin_unlock_irqrestore(&acm->write_lock, flags);
                 return 0;
         }
-        wb = &acm->wb[wbn];
 
-        if(acm_wb_is_avail(acm) <= 1)
-                acm->write_ready = 0;
+        rc = acm_start_wb(acm, wb);
         spin_unlock_irqrestore(&acm->write_lock, flags);
 
-        wb->urb->transfer_buffer = wb->buf;
-        wb->urb->transfer_dma = wb->dmah;
-        wb->urb->transfer_buffer_length = wb->len;
-        wb->urb->dev = acm->dev;
-
-        if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
-                dbg("usb_submit_urb(write bulk) failed: %d", rc);
-                acm_write_done(acm, wb);
-        }
         return rc;
+
 }
 /*
  * attributes exported through sysfs
@@ -304,6 +331,7 @@ static void acm_ctrl_irq(struct urb *urb)
                         break;
         }
 exit:
+        usb_mark_last_busy(acm->dev);
         retval = usb_submit_urb (urb, GFP_ATOMIC);
         if (retval)
                 err ("%s - usb_submit_urb failed with result %d",
@@ -320,8 +348,11 @@ static void acm_read_bulk(struct urb *urb)
 
         dbg("Entering acm_read_bulk with status %d", status);
 
-        if (!ACM_READY(acm))
+        if (!ACM_READY(acm)) {
+                dev_dbg(&acm->data->dev, "Aborting, acm not ready");
                 return;
+        }
+        usb_mark_last_busy(acm->dev);
 
         if (status)
                 dev_dbg(&acm->data->dev, "bulk rx status %d\n", status);
@@ -331,6 +362,7 @@ static void acm_read_bulk(struct urb *urb)
 
         if (likely(status == 0)) {
                 spin_lock(&acm->read_lock);
+                acm->processing++;
                 list_add_tail(&rcv->list, &acm->spare_read_urbs);
                 list_add_tail(&buf->list, &acm->filled_read_bufs);
                 spin_unlock(&acm->read_lock);
@@ -343,7 +375,8 @@ static void acm_read_bulk(struct urb *urb)
                 /* nevertheless the tasklet must be kicked unconditionally
                 so the queue cannot dry up */
         }
-        tasklet_schedule(&acm->urb_task);
+        if (likely(!acm->susp_count))
+                tasklet_schedule(&acm->urb_task);
 }
 
 static void acm_rx_tasklet(unsigned long _acm)
@@ -354,16 +387,23 @@ static void acm_rx_tasklet(unsigned long _acm)
         struct acm_ru *rcv;
         unsigned long flags;
         unsigned char throttled;
+
         dbg("Entering acm_rx_tasklet");
 
         if (!ACM_READY(acm))
+        {
+                dbg("acm_rx_tasklet: ACM not ready");
                 return;
+        }
 
         spin_lock_irqsave(&acm->throttle_lock, flags);
         throttled = acm->throttle;
         spin_unlock_irqrestore(&acm->throttle_lock, flags);
         if (throttled)
+        {
+                dbg("acm_rx_tasklet: throttled");
                 return;
+        }
 
 next_buffer:
         spin_lock_irqsave(&acm->read_lock, flags);
@@ -403,6 +443,7 @@ urbs:
         while (!list_empty(&acm->spare_read_bufs)) {
                 spin_lock_irqsave(&acm->read_lock, flags);
                 if (list_empty(&acm->spare_read_urbs)) {
+                        acm->processing = 0;
                         spin_unlock_irqrestore(&acm->read_lock, flags);
                         return;
                 }
@@ -425,18 +466,23 @@ urbs:
                 rcv->urb->transfer_dma = buf->dma;
                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-                dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
-
                 /* This shouldn't kill the driver as unsuccessful URBs are returned to the
                    free-urbs-pool and resubmited ASAP */
-                if (usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
+                spin_lock_irqsave(&acm->read_lock, flags);
+                if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
                         list_add(&buf->list, &acm->spare_read_bufs);
-                        spin_lock_irqsave(&acm->read_lock, flags);
                         list_add(&rcv->list, &acm->spare_read_urbs);
+                        acm->processing = 0;
                         spin_unlock_irqrestore(&acm->read_lock, flags);
                         return;
+                } else {
+                        spin_unlock_irqrestore(&acm->read_lock, flags);
+                        dbg("acm_rx_tasklet: sending urb 0x%p, rcv 0x%p, buf 0x%p", rcv->urb, rcv, buf);
                 }
         }
+        spin_lock_irqsave(&acm->read_lock, flags);
+        acm->processing = 0;
+        spin_unlock_irqrestore(&acm->read_lock, flags);
 }
 
 /* data interface wrote those outgoing bytes */
@@ -463,6 +509,27 @@ static void acm_softint(struct work_struct *work)
         tty_wakeup(acm->tty);
 }
 
+static void acm_waker(struct work_struct *waker)
+{
+        struct acm *acm = container_of(waker, struct acm, waker);
+        long flags;
+        int rv;
+
+        rv = usb_autopm_get_interface(acm->control);
+        if (rv < 0) {
+                err("Autopm failure in %s", __func__);
+                return;
+        }
+        if (acm->delayed_wb) {
+                acm_start_wb(acm, acm->delayed_wb);
+                acm->delayed_wb = NULL;
+        }
+        spin_lock_irqsave(&acm->write_lock, flags);
+        acm->write_ready = acm->old_ready;
+        spin_unlock_irqrestore(&acm->write_lock, flags);
+        usb_autopm_put_interface(acm->control);
+}
+
 /*
  * TTY handlers
  */
@@ -492,6 +559,8 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 
         if (usb_autopm_get_interface(acm->control) < 0)
                 goto early_bail;
+        else
+                acm->control->needs_remote_wakeup = 1;
 
         mutex_lock(&acm->mutex);
         if (acm->used++) {
@@ -509,6 +578,7 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
             (acm->ctrl_caps & USB_CDC_CAP_LINE))
                 goto full_bailout;
+        usb_autopm_put_interface(acm->control);
 
         INIT_LIST_HEAD(&acm->spare_read_urbs);
         INIT_LIST_HEAD(&acm->spare_read_bufs);
@@ -570,12 +640,14 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
         mutex_lock(&open_mutex);
         if (!--acm->used) {
                 if (acm->dev) {
+                        usb_autopm_get_interface(acm->control);
                         acm_set_control(acm, acm->ctrlout = 0);
                         usb_kill_urb(acm->ctrlurb);
                         for (i = 0; i < ACM_NW; i++)
                                 usb_kill_urb(acm->wb[i].urb);
                         for (i = 0; i < nr; i++)
                                 usb_kill_urb(acm->ru[i].urb);
+                        acm->control->needs_remote_wakeup = 0;
                         usb_autopm_put_interface(acm->control);
                 } else
                         acm_tty_unregister(acm);
@@ -766,7 +838,7 @@ static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios
  * USB probe and disconnect routines.
  */
 
-/* Little helper: write buffers free */
+/* Little helpers: write/read buffers free */
 static void acm_write_buffers_free(struct acm *acm)
 {
         int i;
@@ -777,6 +849,15 @@ static void acm_write_buffers_free(struct acm *acm)
         }
 }
 
+static void acm_read_buffers_free(struct acm *acm)
+{
+        struct usb_device *usb_dev = interface_to_usbdev(acm->control);
+        int i, n = acm->rx_buflimit;
+
+        for (i = 0; i < n; i++)
+                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
+}
+
 /* Little helper: write buffers allocate */
 static int acm_write_buffers_alloc(struct acm *acm)
 {
@@ -987,6 +1068,7 @@ skip_normal_probe:
         acm->urb_task.func = acm_rx_tasklet;
         acm->urb_task.data = (unsigned long) acm;
         INIT_WORK(&acm->work, acm_softint);
+        INIT_WORK(&acm->waker, acm_waker);
         spin_lock_init(&acm->throttle_lock);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
@@ -1098,8 +1180,7 @@ alloc_fail8:
         for (i = 0; i < ACM_NW; i++)
                 usb_free_urb(acm->wb[i].urb);
 alloc_fail7:
-        for (i = 0; i < num_rx_buf; i++)
-                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
+        acm_read_buffers_free(acm);
         for (i = 0; i < num_rx_buf; i++)
                 usb_free_urb(acm->ru[i].urb);
         usb_free_urb(acm->ctrlurb);
@@ -1116,6 +1197,7 @@ alloc_fail:
 static void stop_data_traffic(struct acm *acm)
 {
         int i;
+        dbg("Entering stop_data_traffic");
 
         tasklet_disable(&acm->urb_task);
 
@@ -1128,21 +1210,16 @@ static void stop_data_traffic(struct acm *acm)
         tasklet_enable(&acm->urb_task);
 
         cancel_work_sync(&acm->work);
+        cancel_work_sync(&acm->waker);
 }
 
 static void acm_disconnect(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
         struct usb_device *usb_dev = interface_to_usbdev(intf);
-        int i;
-
-        if (!acm || !acm->dev) {
-                dbg("disconnect on nonexisting interface");
-                return;
-        }
 
         mutex_lock(&open_mutex);
-        if (!usb_get_intfdata(intf)) {
+        if (!acm || !acm->dev) {
                 mutex_unlock(&open_mutex);
                 return;
         }
@@ -1161,10 +1238,10 @@ static void acm_disconnect(struct usb_interface *intf)
 
         acm_write_buffers_free(acm);
         usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
-        for (i = 0; i < acm->rx_buflimit; i++)
-                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
+        acm_read_buffers_free(acm);
 
-        usb_driver_release_interface(&acm_driver, intf == acm->control ? acm->data : intf);
+        usb_driver_release_interface(&acm_driver, intf == acm->control ?
+                                        acm->data : acm->control);
 
         if (!acm->used) {
                 acm_tty_unregister(acm);
@@ -1178,11 +1255,31 @@ static void acm_disconnect(struct usb_interface *intf)
                 tty_hangup(acm->tty);
 }
 
+#ifdef CONFIG_PM
 static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct acm *acm = usb_get_intfdata(intf);
+        int cnt;
+
+        if (acm->dev->auto_pm) {
+                int b;
+
+                spin_lock_irq(&acm->read_lock);
+                spin_lock(&acm->write_lock);
+                b = acm->processing + acm->transmitting;
+                spin_unlock(&acm->write_lock);
+                spin_unlock_irq(&acm->read_lock);
+                if (b)
+                        return -EBUSY;
+        }
+
+        spin_lock_irq(&acm->read_lock);
+        spin_lock(&acm->write_lock);
+        cnt = acm->susp_count++;
+        spin_unlock(&acm->write_lock);
+        spin_unlock_irq(&acm->read_lock);
 
-        if (acm->susp_count++)
+        if (cnt)
                 return 0;
         /*
         we treat opened interfaces differently,
@@ -1201,15 +1298,21 @@ static int acm_resume(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
         int rv = 0;
+        int cnt;
+
+        spin_lock_irq(&acm->read_lock);
+        acm->susp_count -= 1;
+        cnt = acm->susp_count;
+        spin_unlock_irq(&acm->read_lock);
 
-        if (--acm->susp_count)
+        if (cnt)
                 return 0;
 
         mutex_lock(&acm->mutex);
         if (acm->used) {
                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
                 if (rv < 0)
-                goto err_out;
+                        goto err_out;
 
                 tasklet_schedule(&acm->urb_task);
         }
@@ -1218,6 +1321,8 @@ err_out:
         mutex_unlock(&acm->mutex);
         return rv;
 }
+
+#endif /* CONFIG_PM */
 /*
  * USB driver structure.
  */
@@ -1273,10 +1378,14 @@ static struct usb_driver acm_driver = {
         .name =         "cdc_acm",
         .probe =        acm_probe,
         .disconnect =   acm_disconnect,
+#ifdef CONFIG_PM
         .suspend =      acm_suspend,
         .resume =       acm_resume,
+#endif
         .id_table =     acm_ids,
+#ifdef CONFIG_PM
         .supports_autosuspend = 1,
+#endif
 };
 
 /*
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index 046e064b033a..85c3aaaab7c5 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -107,10 +107,14 @@ struct acm {
         struct list_head filled_read_bufs;
         int write_used;                                 /* number of non-empty write buffers */
         int write_ready;                                /* write urb is not running */
+        int old_ready;
+        int processing;
+        int transmitting;
         spinlock_t write_lock;
         struct mutex mutex;
         struct usb_cdc_line_coding line;                /* bits, stop, parity */
         struct work_struct work;                        /* work queue entry for line discipline waking up */
+        struct work_struct waker;
         struct tasklet_struct urb_task;                 /* rx processing */
         spinlock_t throttle_lock;                       /* synchronize throtteling and read callback */
         unsigned int ctrlin;                            /* input control lines (DCD, DSR, RI, break, overruns) */
@@ -123,6 +127,7 @@ struct acm {
         unsigned char clocal;                           /* termios CLOCAL */
         unsigned int ctrl_caps;                         /* control capabilities from the class specific header */
         unsigned int susp_count;                        /* number of suspended interfaces */
+        struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
 };
 
 #define CDC_DATA_INTERFACE_TYPE 0x0a
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 731db051070a..7e8e1235e4e5 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -28,8 +28,9 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.02"
+#define DRIVER_VERSION "v0.03"
 #define DRIVER_AUTHOR "Oliver Neukum"
+#define DRIVER_DESC "USB Abstract Control Model driver for USB WCM Device Management"
 
 static struct usb_device_id wdm_ids[] = {
         {
@@ -87,6 +88,7 @@ struct wdm_device {
         dma_addr_t              ihandle;
         struct mutex            wlock;
         struct mutex            rlock;
+        struct mutex            plock;
         wait_queue_head_t       wait;
         struct work_struct      rxwork;
         int                     werr;
@@ -205,7 +207,7 @@ static void wdm_int_callback(struct urb *urb)
         req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
         req->wValue = 0;
         req->wIndex = desc->inum;
-        req->wLength = cpu_to_le16(desc->bMaxPacketSize0);
+        req->wLength = cpu_to_le16(desc->wMaxCommand);
 
         usb_fill_control_urb(
                 desc->response,
@@ -214,7 +216,7 @@ static void wdm_int_callback(struct urb *urb)
                 usb_rcvctrlpipe(interface_to_usbdev(desc->intf), 0),
                 (unsigned char *)req,
                 desc->inbuf,
-                desc->bMaxPacketSize0,
+                desc->wMaxCommand,
                 wdm_in_callback,
                 desc
         );
@@ -247,6 +249,7 @@ exit:
 
 static void kill_urbs(struct wdm_device *desc)
 {
+        /* the order here is essential */
         usb_kill_urb(desc->command);
         usb_kill_urb(desc->validity);
         usb_kill_urb(desc->response);
@@ -266,7 +269,7 @@ static void cleanup(struct wdm_device *desc)
                         desc->sbuf,
                         desc->validity->transfer_dma);
         usb_buffer_free(interface_to_usbdev(desc->intf),
-                        desc->wMaxPacketSize,
+                        desc->wMaxCommand,
                         desc->inbuf,
                         desc->response->transfer_dma);
         kfree(desc->orq);
@@ -299,6 +302,9 @@ static ssize_t wdm_write
         if (r)
                 goto outnl;
 
+        r = usb_autopm_get_interface(desc->intf);
+        if (r < 0)
+                goto outnp;
         r = wait_event_interruptible(desc->wait, !test_bit(WDM_IN_USE,
                                                            &desc->flags));
         if (r < 0)
@@ -347,11 +353,14 @@ static ssize_t wdm_write
         if (rv < 0) {
                 kfree(buf);
                 clear_bit(WDM_IN_USE, &desc->flags);
+                err("Tx URB error: %d", rv);
         } else {
                 dev_dbg(&desc->intf->dev, "Tx URB has been submitted index=%d",
                         req->wIndex);
         }
 out:
+        usb_autopm_put_interface(desc->intf);
+outnp:
         mutex_unlock(&desc->wlock);
 outnl:
         return rv < 0 ? rv : count;
@@ -376,6 +385,11 @@ retry:
                 rv = wait_event_interruptible(desc->wait,
                                               test_bit(WDM_READ, &desc->flags));
 
+                if (test_bit(WDM_DISCONNECTING, &desc->flags)) {
+                        rv = -ENODEV;
+                        goto err;
+                }
+                usb_mark_last_busy(interface_to_usbdev(desc->intf));
                 if (rv < 0) {
                         rv = -ERESTARTSYS;
                         goto err;
@@ -418,6 +432,9 @@ retry:
                 desc->ubuf[i] = desc->ubuf[i + cntr];
 
         desc->length -= cntr;
+        /* in case we had outstanding data */
+        if (!desc->length)
+                clear_bit(WDM_READ, &desc->flags);
         rv = cntr;
 
 err:
@@ -480,18 +497,28 @@ static int wdm_open(struct inode *inode, struct file *file)
         if (test_bit(WDM_DISCONNECTING, &desc->flags))
                 goto out;
 
-        desc->count++;
+        ;
         file->private_data = desc;
 
-        rv = usb_submit_urb(desc->validity, GFP_KERNEL);
-
+        rv = usb_autopm_get_interface(desc->intf);
         if (rv < 0) {
-                desc->count--;
-                err("Error submitting int urb - %d", rv);
+                err("Error autopm - %d", rv);
                 goto out;
         }
-        rv = 0;
+        intf->needs_remote_wakeup = 1;
 
+        mutex_lock(&desc->plock);
+        if (!desc->count++) {
+                rv = usb_submit_urb(desc->validity, GFP_KERNEL);
+                if (rv < 0) {
+                        desc->count--;
+                        err("Error submitting int urb - %d", rv);
+                }
+        } else {
+                rv = 0;
+        }
+        mutex_unlock(&desc->plock);
+        usb_autopm_put_interface(desc->intf);
 out:
         mutex_unlock(&wdm_mutex);
         return rv;
@@ -502,10 +529,15 @@ static int wdm_release(struct inode *inode, struct file *file)
         struct wdm_device *desc = file->private_data;
 
         mutex_lock(&wdm_mutex);
+        mutex_lock(&desc->plock);
         desc->count--;
+        mutex_unlock(&desc->plock);
+
         if (!desc->count) {
                 dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
                 kill_urbs(desc);
+                if (!test_bit(WDM_DISCONNECTING, &desc->flags))
+                        desc->intf->needs_remote_wakeup = 0;
         }
         mutex_unlock(&wdm_mutex);
         return 0;
@@ -597,6 +629,7 @@ next_desc:
                 goto out;
         mutex_init(&desc->wlock);
         mutex_init(&desc->rlock);
+        mutex_init(&desc->plock);
         spin_lock_init(&desc->iuspin);
         init_waitqueue_head(&desc->wait);
         desc->wMaxCommand = maxcom;
@@ -698,6 +731,7 @@ static void wdm_disconnect(struct usb_interface *intf)
         spin_lock_irqsave(&desc->iuspin, flags);
         set_bit(WDM_DISCONNECTING, &desc->flags);
         set_bit(WDM_READ, &desc->flags);
+        /* to terminate pending flushes */
         clear_bit(WDM_IN_USE, &desc->flags);
         spin_unlock_irqrestore(&desc->iuspin, flags);
         cancel_work_sync(&desc->rxwork);
@@ -708,11 +742,81 @@ static void wdm_disconnect(struct usb_interface *intf)
         mutex_unlock(&wdm_mutex);
 }
 
+static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
+{
+        struct wdm_device *desc = usb_get_intfdata(intf);
+        int rv = 0;
+
+        dev_dbg(&desc->intf->dev, "wdm%d_suspend\n", intf->minor);
+
+        mutex_lock(&desc->plock);
+#ifdef CONFIG_PM
+        if (interface_to_usbdev(desc->intf)->auto_pm && test_bit(WDM_IN_USE, &desc->flags)) {
+                rv = -EBUSY;
+        } else {
+#endif
+                cancel_work_sync(&desc->rxwork);
+                kill_urbs(desc);
+#ifdef CONFIG_PM
+        }
+#endif
+        mutex_unlock(&desc->plock);
+
+        return rv;
+}
+
+static int recover_from_urb_loss(struct wdm_device *desc)
+{
+        int rv = 0;
+
+        if (desc->count) {
+                rv = usb_submit_urb(desc->validity, GFP_NOIO);
+                if (rv < 0)
+                        err("Error resume submitting int urb - %d", rv);
+        }
+        return rv;
+}
+static int wdm_resume(struct usb_interface *intf)
+{
+        struct wdm_device *desc = usb_get_intfdata(intf);
+        int rv;
+
+        dev_dbg(&desc->intf->dev, "wdm%d_resume\n", intf->minor);
+        mutex_lock(&desc->plock);
+        rv = recover_from_urb_loss(desc);
+        mutex_unlock(&desc->plock);
+        return rv;
+}
+
+static int wdm_pre_reset(struct usb_interface *intf)
+{
+        struct wdm_device *desc = usb_get_intfdata(intf);
+
+        mutex_lock(&desc->plock);
+        return 0;
+}
+
+static int wdm_post_reset(struct usb_interface *intf)
+{
+        struct wdm_device *desc = usb_get_intfdata(intf);
+        int rv;
+
+        rv = recover_from_urb_loss(desc);
+        mutex_unlock(&desc->plock);
+        return 0;
+}
+
 static struct usb_driver wdm_driver = {
         .name =         "cdc_wdm",
         .probe =        wdm_probe,
         .disconnect =   wdm_disconnect,
+        .suspend =      wdm_suspend,
+        .resume =       wdm_resume,
+        .reset_resume = wdm_resume,
+        .pre_reset =    wdm_pre_reset,
+        .post_reset =   wdm_post_reset,
         .id_table =     wdm_ids,
+        .supports_autosuspend = 1,
 };
 
 /* --- low level module stuff --- */
@@ -735,6 +839,5 @@ module_init(wdm_init);
 module_exit(wdm_exit);
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION("USB Abstract Control Model driver for "
-                   "USB WCM Device Management");
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 83d9dc379d96..6ec38175a817 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -46,8 +46,6 @@
  * 2000-07-05: Ashley Montanaro <ashley@compsoc.man.ac.uk>
  *   Converted file reading routine to dump to buffer once
  *   per device, not per bus
- *
- * $Id: devices.c,v 1.5 2000/01/11 13:58:21 tom Exp $
  */
 
 #include <linux/fs.h>
@@ -63,8 +61,6 @@
 #include "usb.h"
 #include "hcd.h"
 
-#define MAX_TOPO_LEVEL          6
-
 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
 #define ALLOW_SERIAL_NUMBER
 
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 9218cca21043..54a350ccd033 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -19,8 +19,6 @@
  *      along with this program; if not, write to the Free Software
  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- *  $Id: devio.c,v 1.7 2000/02/01 17:28:48 fliegl Exp $
- *
  *  This file implements the usbfs/x/y files, where
  *  x is the bus number and y the device number.
  *
@@ -61,6 +59,22 @@
 /* Mutual exclusion for removal, open, and release */
 DEFINE_MUTEX(usbfs_mutex);
 
+struct dev_state {
+        struct list_head list;      /* state list */
+        struct usb_device *dev;
+        struct file *file;
+        spinlock_t lock;            /* protects the async urb lists */
+        struct list_head async_pending;
+        struct list_head async_completed;
+        wait_queue_head_t wait;     /* wake up if a request completed */
+        unsigned int discsignr;
+        struct pid *disc_pid;
+        uid_t disc_uid, disc_euid;
+        void __user *disccontext;
+        unsigned long ifclaimed;
+        u32 secid;
+};
+
 struct async {
         struct list_head asynclist;
         struct dev_state *ps;
@@ -536,23 +550,19 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype,
         return ret;
 }
 
-static int __match_minor(struct device *dev, void *data)
+static int match_devt(struct device *dev, void *data)
 {
-        int minor = *((int *)data);
-
-        if (dev->devt == MKDEV(USB_DEVICE_MAJOR, minor))
-                return 1;
-        return 0;
+        return dev->devt == (dev_t) (unsigned long) data;
 }
 
-static struct usb_device *usbdev_lookup_by_minor(int minor)
+static struct usb_device *usbdev_lookup_by_devt(dev_t devt)
 {
         struct device *dev;
 
-        dev = bus_find_device(&usb_bus_type, NULL, &minor, __match_minor);
+        dev = bus_find_device(&usb_bus_type, NULL,
+                              (void *) (unsigned long) devt, match_devt);
         if (!dev)
                 return NULL;
-        put_device(dev);
         return container_of(dev, struct usb_device, dev);
 }
 
@@ -575,21 +585,27 @@ static int usbdev_open(struct inode *inode, struct file *file)
                 goto out;
 
         ret = -ENOENT;
+
         /* usbdev device-node */
         if (imajor(inode) == USB_DEVICE_MAJOR)
-                dev = usbdev_lookup_by_minor(iminor(inode));
+                dev = usbdev_lookup_by_devt(inode->i_rdev);
 #ifdef CONFIG_USB_DEVICEFS
         /* procfs file */
-        if (!dev)
+        if (!dev) {
                 dev = inode->i_private;
+                if (dev && dev->usbfs_dentry &&
+                                        dev->usbfs_dentry->d_inode == inode)
+                        usb_get_dev(dev);
+                else
+                        dev = NULL;
+        }
 #endif
-        if (!dev)
+        if (!dev || dev->state == USB_STATE_NOTATTACHED)
                 goto out;
         ret = usb_autoresume_device(dev);
         if (ret)
                 goto out;
 
-        usb_get_dev(dev);
         ret = 0;
         ps->dev = dev;
         ps->file = file;
@@ -609,8 +625,10 @@ static int usbdev_open(struct inode *inode, struct file *file)
         list_add_tail(&ps->list, &dev->filelist);
         file->private_data = ps;
  out:
-        if (ret)
+        if (ret) {
                 kfree(ps);
+                usb_put_dev(dev);
+        }
         mutex_unlock(&usbfs_mutex);
         unlock_kernel();
         return ret;
@@ -874,7 +892,7 @@ static int proc_connectinfo(struct dev_state *ps, void __user *arg)
 
 static int proc_resetdevice(struct dev_state *ps)
 {
-        return usb_reset_composite_device(ps->dev, NULL);
+        return usb_reset_device(ps->dev);
 }
 
 static int proc_setintf(struct dev_state *ps, void __user *arg)
@@ -1682,25 +1700,49 @@ const struct file_operations usbdev_file_operations = {
         .release =      usbdev_release,
 };
 
+void usb_fs_classdev_common_remove(struct usb_device *udev)
+{
+        struct dev_state *ps;
+        struct siginfo sinfo;
+
+        while (!list_empty(&udev->filelist)) {
+                ps = list_entry(udev->filelist.next, struct dev_state, list);
+                destroy_all_async(ps);
+                wake_up_all(&ps->wait);
+                list_del_init(&ps->list);
+                if (ps->discsignr) {
+                        sinfo.si_signo = ps->discsignr;
+                        sinfo.si_errno = EPIPE;
+                        sinfo.si_code = SI_ASYNCIO;
+                        sinfo.si_addr = ps->disccontext;
+                        kill_pid_info_as_uid(ps->discsignr, &sinfo,
+                                        ps->disc_pid, ps->disc_uid,
+                                        ps->disc_euid, ps->secid);
+                }
+        }
+}
+
 #ifdef CONFIG_USB_DEVICE_CLASS
 static struct class *usb_classdev_class;
 
 static int usb_classdev_add(struct usb_device *dev)
 {
-        int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
-
-        dev->usb_classdev = device_create(usb_classdev_class, &dev->dev,
-                                MKDEV(USB_DEVICE_MAJOR, minor),
-                                "usbdev%d.%d", dev->bus->busnum, dev->devnum);
-        if (IS_ERR(dev->usb_classdev))
-                return PTR_ERR(dev->usb_classdev);
-
+        struct device *cldev;
+
+        cldev = device_create(usb_classdev_class, &dev->dev, dev->dev.devt,
+                              "usbdev%d.%d", dev->bus->busnum,
+                              dev->devnum);
+        if (IS_ERR(cldev))
+                return PTR_ERR(cldev);
+        dev->usb_classdev = cldev;
         return 0;
 }
 
 static void usb_classdev_remove(struct usb_device *dev)
 {
-        device_unregister(dev->usb_classdev);
+        if (dev->usb_classdev)
+                device_unregister(dev->usb_classdev);
+        usb_fs_classdev_common_remove(dev);
 }
 
 static int usb_classdev_notify(struct notifier_block *self,
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 1e56f1cfa6dc..ddb54e14a5c5 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -201,6 +201,7 @@ static int usb_probe_interface(struct device *dev)
 
         intf = to_usb_interface(dev);
         udev = interface_to_usbdev(intf);
+        intf->needs_binding = 0;
 
         if (udev->authorized == 0) {
                 dev_err(&intf->dev, "Device is not authorized for usage\n");
@@ -257,15 +258,16 @@ static int usb_unbind_interface(struct device *dev)
         udev = interface_to_usbdev(intf);
         error = usb_autoresume_device(udev);
 
-        /* release all urbs for this interface */
-        usb_disable_interface(interface_to_usbdev(intf), intf);
+        /* Terminate all URBs for this interface unless the driver
+         * supports "soft" unbinding.
+         */
+        if (!driver->soft_unbind)
+                usb_disable_interface(udev, intf);
 
         driver->disconnect(intf);
 
         /* reset other interface state */
-        usb_set_interface(interface_to_usbdev(intf),
-                        intf->altsetting[0].desc.bInterfaceNumber,
-                        0);
+        usb_set_interface(udev, intf->altsetting[0].desc.bInterfaceNumber, 0);
         usb_set_intfdata(intf, NULL);
 
         intf->condition = USB_INTERFACE_UNBOUND;
@@ -310,6 +312,7 @@ int usb_driver_claim_interface(struct usb_driver *driver,
 
         dev->driver = &driver->drvwrap.driver;
         usb_set_intfdata(iface, priv);
+        iface->needs_binding = 0;
 
         usb_pm_lock(udev);
         iface->condition = USB_INTERFACE_BOUND;
@@ -586,7 +589,7 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
         struct usb_device *usb_dev;
 
         /* driver is often null here; dev_dbg() would oops */
-        pr_debug("usb %s: uevent\n", dev->bus_id);
+        pr_debug("usb %s: uevent\n", dev_name(dev));
 
         if (is_usb_device(dev))
                 usb_dev = to_usb_device(dev);
@@ -596,11 +599,11 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
         }
 
         if (usb_dev->devnum < 0) {
-                pr_debug("usb %s: already deleted?\n", dev->bus_id);
+                pr_debug("usb %s: already deleted?\n", dev_name(dev));
                 return -ENODEV;
         }
         if (!usb_dev->bus) {
-                pr_debug("usb %s: bus removed?\n", dev->bus_id);
+                pr_debug("usb %s: bus removed?\n", dev_name(dev));
                 return -ENODEV;
         }
 
@@ -771,6 +774,104 @@ void usb_deregister(struct usb_driver *driver)
 }
 EXPORT_SYMBOL_GPL(usb_deregister);
 
+
+/* Forced unbinding of a USB interface driver, either because
+ * it doesn't support pre_reset/post_reset/reset_resume or
+ * because it doesn't support suspend/resume.
+ *
+ * The caller must hold @intf's device's lock, but not its pm_mutex
+ * and not @intf->dev.sem.
+ */
+void usb_forced_unbind_intf(struct usb_interface *intf)
+{
+        struct usb_driver *driver = to_usb_driver(intf->dev.driver);
+
+        dev_dbg(&intf->dev, "forced unbind\n");
+        usb_driver_release_interface(driver, intf);
+
+        /* Mark the interface for later rebinding */
+        intf->needs_binding = 1;
+}
+
+/* Delayed forced unbinding of a USB interface driver and scan
+ * for rebinding.
+ *
+ * The caller must hold @intf's device's lock, but not its pm_mutex
+ * and not @intf->dev.sem.
+ *
+ * FIXME: The caller must block system sleep transitions.
+ */
+void usb_rebind_intf(struct usb_interface *intf)
+{
+        int rc;
+
+        /* Delayed unbind of an existing driver */
+        if (intf->dev.driver) {
+                struct usb_driver *driver =
+                                to_usb_driver(intf->dev.driver);
+
+                dev_dbg(&intf->dev, "forced unbind\n");
+                usb_driver_release_interface(driver, intf);
+        }
+
+        /* Try to rebind the interface */
+        intf->needs_binding = 0;
+        rc = device_attach(&intf->dev);
+        if (rc < 0)
+                dev_warn(&intf->dev, "rebind failed: %d\n", rc);
+}
+
+#define DO_UNBIND       0
+#define DO_REBIND       1
+
+/* Unbind drivers for @udev's interfaces that don't support suspend/resume,
+ * or rebind interfaces that have been unbound, according to @action.
+ *
+ * The caller must hold @udev's device lock.
+ * FIXME: For rebinds, the caller must block system sleep transitions.
+ */
+static void do_unbind_rebind(struct usb_device *udev, int action)
+{
+        struct usb_host_config  *config;
+        int                     i;
+        struct usb_interface    *intf;
+        struct usb_driver       *drv;
+
+        config = udev->actconfig;
+        if (config) {
+                for (i = 0; i < config->desc.bNumInterfaces; ++i) {
+                        intf = config->interface[i];
+                        switch (action) {
+                        case DO_UNBIND:
+                                if (intf->dev.driver) {
+                                        drv = to_usb_driver(intf->dev.driver);
+                                        if (!drv->suspend || !drv->resume)
+                                                usb_forced_unbind_intf(intf);
+                                }
+                                break;
+                        case DO_REBIND:
+                                if (intf->needs_binding) {
+
+        /* FIXME: The next line is needed because we are going to probe
+         * the interface, but as far as the PM core is concerned the
+         * interface is still suspended.  The problem wouldn't exist
+         * if we could rebind the interface during the interface's own
+         * resume() call, but at the time the usb_device isn't locked!
+         *
+         * The real solution will be to carry this out during the device's
+         * complete() callback.  Until that is implemented, we have to
+         * use this hack.
+         */
+//                                      intf->dev.power.sleeping = 0;
+
+                                        usb_rebind_intf(intf);
+                                }
+                                break;
+                        }
+                }
+        }
+}
+
 #ifdef CONFIG_PM
 
 /* Caller has locked udev's pm_mutex */
@@ -805,8 +906,6 @@ static int usb_resume_device(struct usb_device *udev)
 
         if (udev->state == USB_STATE_NOTATTACHED)
                 goto done;
-        if (udev->state != USB_STATE_SUSPENDED && !udev->reset_resume)
-                goto done;
 
         /* Can't resume it if it doesn't have a driver. */
         if (udev->dev.driver == NULL) {
@@ -842,7 +941,7 @@ static int usb_suspend_interface(struct usb_interface *intf, pm_message_t msg)
                 goto done;
         driver = to_usb_driver(intf->dev.driver);
 
-        if (driver->suspend && driver->resume) {
+        if (driver->suspend) {
                 status = driver->suspend(intf, msg);
                 if (status == 0)
                         mark_quiesced(intf);
@@ -850,12 +949,10 @@ static int usb_suspend_interface(struct usb_interface *intf, pm_message_t msg)
                         dev_err(&intf->dev, "%s error %d\n",
                                         "suspend", status);
         } else {
-                /*
-                 * FIXME else if there's no suspend method, disconnect...
-                 * Not possible if auto_pm is set...
-                 */
-                dev_warn(&intf->dev, "no suspend for driver %s?\n",
-                                driver->name);
+                /* Later we will unbind the driver and reprobe */
+                intf->needs_binding = 1;
+                dev_warn(&intf->dev, "no %s for driver %s?\n",
+                                "suspend", driver->name);
                 mark_quiesced(intf);
         }
 
@@ -879,10 +976,12 @@ static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
                 goto done;
 
         /* Can't resume it if it doesn't have a driver. */
-        if (intf->condition == USB_INTERFACE_UNBOUND) {
-                status = -ENOTCONN;
+        if (intf->condition == USB_INTERFACE_UNBOUND)
+                goto done;
+
+        /* Don't resume if the interface is marked for rebinding */
+        if (intf->needs_binding)
                 goto done;
-        }
         driver = to_usb_driver(intf->dev.driver);
 
         if (reset_resume) {
@@ -892,7 +991,7 @@ static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
                                 dev_err(&intf->dev, "%s error %d\n",
                                                 "reset_resume", status);
                 } else {
-                        /* status = -EOPNOTSUPP; */
+                        intf->needs_binding = 1;
                         dev_warn(&intf->dev, "no %s for driver %s?\n",
                                         "reset_resume", driver->name);
                 }
@@ -903,7 +1002,7 @@ static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
                                 dev_err(&intf->dev, "%s error %d\n",
                                                 "resume", status);
                 } else {
-                        /* status = -EOPNOTSUPP; */
+                        intf->needs_binding = 1;
                         dev_warn(&intf->dev, "no %s for driver %s?\n",
                                         "resume", driver->name);
                 }
@@ -911,11 +1010,10 @@ static int usb_resume_interface(struct usb_interface *intf, int reset_resume)
 
 done:
         dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
-        if (status == 0)
+        if (status == 0 && intf->condition == USB_INTERFACE_BOUND)
                 mark_active(intf);
 
-        /* FIXME: Unbind the driver and reprobe if the resume failed
-         * (not possible if auto_pm is set) */
+        /* Later we will unbind the driver and/or reprobe, if necessary */
         return status;
 }
 
@@ -1173,11 +1271,8 @@ static int usb_resume_both(struct usb_device *udev)
                          * then we're stuck. */
                         status = usb_resume_device(udev);
                 }
-        } else {
-
-                /* Needed for reset-resume */
+        } else if (udev->reset_resume)
                 status = usb_resume_device(udev);
-        }
 
         if (status == 0 && udev->actconfig) {
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
@@ -1474,6 +1569,7 @@ int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
 {
         int     status;
 
+        do_unbind_rebind(udev, DO_UNBIND);
         usb_pm_lock(udev);
         udev->auto_pm = 0;
         status = usb_suspend_both(udev, msg);
@@ -1501,6 +1597,7 @@ int usb_external_resume_device(struct usb_device *udev)
         status = usb_resume_both(udev);
         udev->last_busy = jiffies;
         usb_pm_unlock(udev);
+        do_unbind_rebind(udev, DO_REBIND);
 
         /* Now that the device is awake, we can start trying to autosuspend
          * it again. */
@@ -1542,14 +1639,11 @@ static int usb_resume(struct device *dev)
         udev = to_usb_device(dev);
 
         /* If udev->skip_sys_resume is set then udev was already suspended
-         * when the system suspend started, so we don't want to resume
-         * udev during this system wakeup.  However a reset-resume counts
-         * as a wakeup event, so allow a reset-resume to occur if remote
-         * wakeup is enabled. */
-        if (udev->skip_sys_resume) {
-                if (!(udev->reset_resume && udev->do_remote_wakeup))
-                        return -EHOSTUNREACH;
-        }
+         * when the system sleep started, so we don't want to resume it
+         * during this system wakeup.
+         */
+        if (udev->skip_sys_resume)
+                return 0;
         return usb_external_resume_device(udev);
 }
 
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index fae55a31e26d..22912136fc14 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -296,7 +296,7 @@ int usb_create_ep_files(struct device *parent,
         retval = endpoint_get_minor(ep_dev);
         if (retval) {
                 dev_err(parent, "can not allocate minor number for %s\n",
-                        ep_dev->dev.bus_id);
+                        dev_name(&ep_dev->dev));
                 goto error_register;
         }
 
@@ -307,7 +307,7 @@ int usb_create_ep_files(struct device *parent,
         ep_dev->dev.class = ep_class->class;
         ep_dev->dev.parent = parent;
         ep_dev->dev.release = ep_device_release;
-        snprintf(ep_dev->dev.bus_id, BUS_ID_SIZE, "usbdev%d.%d_ep%02x",
+        dev_set_name(&ep_dev->dev, "usbdev%d.%d_ep%02x",
                  udev->bus->busnum, udev->devnum,
                  endpoint->desc.bEndpointAddress);
 
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index c6a95395e52a..913fb8667899 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -150,7 +150,7 @@ int usb_register_dev(struct usb_interface *intf,
         int retval = -EINVAL;
         int minor_base = class_driver->minor_base;
         int minor = 0;
-        char name[BUS_ID_SIZE];
+        char name[20];
         char *temp;
 
 #ifdef CONFIG_USB_DYNAMIC_MINORS
@@ -190,9 +190,9 @@ int usb_register_dev(struct usb_interface *intf,
         intf->minor = minor;
 
         /* create a usb class device for this usb interface */
-        snprintf(name, BUS_ID_SIZE, class_driver->name, minor - minor_base);
+        snprintf(name, sizeof(name), class_driver->name, minor - minor_base);
         temp = strrchr(name, '/');
-        if (temp && (temp[1] != 0x00))
+        if (temp && (temp[1] != '\0'))
                 ++temp;
         else
                 temp = name;
@@ -227,7 +227,7 @@ void usb_deregister_dev(struct usb_interface *intf,
                         struct usb_class_driver *class_driver)
 {
         int minor_base = class_driver->minor_base;
-        char name[BUS_ID_SIZE];
+        char name[20];
 
 #ifdef CONFIG_USB_DYNAMIC_MINORS
         minor_base = 0;
@@ -242,7 +242,7 @@ void usb_deregister_dev(struct usb_interface *intf,
         usb_minors[intf->minor] = NULL;
         up_write(&minor_rwsem);
 
-        snprintf(name, BUS_ID_SIZE, class_driver->name, intf->minor - minor_base);
+        snprintf(name, sizeof(name), class_driver->name, intf->minor - minor_base);
         device_destroy(usb_class->class, MKDEV(USB_MAJOR, intf->minor));
         intf->usb_dev = NULL;
         intf->minor = -1;
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 42a436478b78..f7bfd72ef115 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -900,14 +900,14 @@ static int register_root_hub(struct usb_hcd *hcd)
         if (retval != sizeof usb_dev->descriptor) {
                 mutex_unlock(&usb_bus_list_lock);
                 dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
-                                usb_dev->dev.bus_id, retval);
+                                dev_name(&usb_dev->dev), retval);
                 return (retval < 0) ? retval : -EMSGSIZE;
         }
 
         retval = usb_new_device (usb_dev);
         if (retval) {
                 dev_err (parent_dev, "can't register root hub for %s, %d\n",
-                                usb_dev->dev.bus_id, retval);
+                                dev_name(&usb_dev->dev), retval);
         }
         mutex_unlock(&usb_bus_list_lock);
 
@@ -1764,7 +1764,7 @@ EXPORT_SYMBOL_GPL (usb_hc_died);
  * If memory is unavailable, returns NULL.
  */
 struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
-                struct device *dev, char *bus_name)
+                struct device *dev, const char *bus_name)
 {
         struct usb_hcd *hcd;
 
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index b9de1569b39e..5b0b59b0d89b 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -21,6 +21,8 @@
 
 #include <linux/rwsem.h>
 
+#define MAX_TOPO_LEVEL          6
+
 /* This file contains declarations of usbcore internals that are mostly
  * used or exposed by Host Controller Drivers.
  */
@@ -235,7 +237,7 @@ extern void usb_hcd_disable_endpoint(struct usb_device *udev,
 extern int usb_hcd_get_frame_number(struct usb_device *udev);
 
 extern struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
-                struct device *dev, char *bus_name);
+                struct device *dev, const char *bus_name);
 extern struct usb_hcd *usb_get_hcd(struct usb_hcd *hcd);
 extern void usb_put_hcd(struct usb_hcd *hcd);
 extern int usb_add_hcd(struct usb_hcd *hcd,
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 4cfe32a16c37..107e1d25ddec 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -72,7 +72,6 @@ struct usb_hub {
 
         unsigned                limited_power:1;
         unsigned                quiescing:1;
-        unsigned                activating:1;
         unsigned                disconnected:1;
 
         unsigned                has_indicators:1;
@@ -131,6 +130,12 @@ MODULE_PARM_DESC(use_both_schemes,
 DECLARE_RWSEM(ehci_cf_port_reset_rwsem);
 EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 
+#define HUB_DEBOUNCE_TIMEOUT    1500
+#define HUB_DEBOUNCE_STEP         25
+#define HUB_DEBOUNCE_STABLE      100
+
+
+static int usb_reset_and_verify_device(struct usb_device *udev);
 
 static inline char *portspeed(int portstatus)
 {
@@ -535,37 +540,6 @@ static void hub_power_on(struct usb_hub *hub)
         msleep(max(pgood_delay, (unsigned) 100));
 }
 
-static void hub_quiesce(struct usb_hub *hub)
-{
-        /* (nonblocking) khubd and related activity won't re-trigger */
-        hub->quiescing = 1;
-        hub->activating = 0;
-
-        /* (blocking) stop khubd and related activity */
-        usb_kill_urb(hub->urb);
-        if (hub->has_indicators)
-                cancel_delayed_work_sync(&hub->leds);
-        if (hub->tt.hub)
-                cancel_work_sync(&hub->tt.kevent);
-}
-
-static void hub_activate(struct usb_hub *hub)
-{
-        int     status;
-
-        hub->quiescing = 0;
-        hub->activating = 1;
-
-        status = usb_submit_urb(hub->urb, GFP_NOIO);
-        if (status < 0)
-                dev_err(hub->intfdev, "activate --> %d\n", status);
-        if (hub->has_indicators && blinkenlights)
-                schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
-
-        /* scan all ports ASAP */
-        kick_khubd(hub);
-}
-
 static int hub_hub_status(struct usb_hub *hub,
                 u16 *status, u16 *change)
 {
@@ -624,136 +598,149 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
         kick_khubd(hub);
 }
 
-/* caller has locked the hub device */
-static void hub_stop(struct usb_hub *hub)
+enum hub_activation_type {
+        HUB_INIT, HUB_POST_RESET, HUB_RESUME, HUB_RESET_RESUME
+};
+
+static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 {
         struct usb_device *hdev = hub->hdev;
-        int i;
+        int port1;
+        int status;
+        bool need_debounce_delay = false;
 
-        /* Disconnect all the children */
-        for (i = 0; i < hdev->maxchild; ++i) {
-                if (hdev->children[i])
-                        usb_disconnect(&hdev->children[i]);
-        }
-        hub_quiesce(hub);
-}
+        /* After a resume, port power should still be on.
+         * For any other type of activation, turn it on.
+         */
+        if (type != HUB_RESUME)
+                hub_power_on(hub);
 
-#define HUB_RESET               1
-#define HUB_RESUME              2
-#define HUB_RESET_RESUME        3
+        /* Check each port and set hub->change_bits to let khubd know
+         * which ports need attention.
+         */
+        for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
+                struct usb_device *udev = hdev->children[port1-1];
+                u16 portstatus, portchange;
 
-#ifdef CONFIG_PM
+                portstatus = portchange = 0;
+                status = hub_port_status(hub, port1, &portstatus, &portchange);
+                if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
+                        dev_dbg(hub->intfdev,
+                                        "port %d: status %04x change %04x\n",
+                                        port1, portstatus, portchange);
 
-/* Try to identify which devices need USB-PERSIST handling */
-static int persistent_device(struct usb_device *udev)
-{
-        int i;
-        int retval;
-        struct usb_host_config *actconfig;
+                /* After anything other than HUB_RESUME (i.e., initialization
+                 * or any sort of reset), every port should be disabled.
+                 * Unconnected ports should likewise be disabled (paranoia),
+                 * and so should ports for which we have no usb_device.
+                 */
+                if ((portstatus & USB_PORT_STAT_ENABLE) && (
+                                type != HUB_RESUME ||
+                                !(portstatus & USB_PORT_STAT_CONNECTION) ||
+                                !udev ||
+                                udev->state == USB_STATE_NOTATTACHED)) {
+                        clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
+                        portstatus &= ~USB_PORT_STAT_ENABLE;
+                }
 
-        /* Explicitly not marked persistent? */
-        if (!udev->persist_enabled)
-                return 0;
+                /* Clear status-change flags; we'll debounce later */
+                if (portchange & USB_PORT_STAT_C_CONNECTION) {
+                        need_debounce_delay = true;
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_CONNECTION);
+                }
+                if (portchange & USB_PORT_STAT_C_ENABLE) {
+                        need_debounce_delay = true;
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_ENABLE);
+                }
 
-        /* No active config? */
-        actconfig = udev->actconfig;
-        if (!actconfig)
-                return 0;
+                if (!udev || udev->state == USB_STATE_NOTATTACHED) {
+                        /* Tell khubd to disconnect the device or
+                         * check for a new connection
+                         */
+                        if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
+                                set_bit(port1, hub->change_bits);
+
+                } else if (portstatus & USB_PORT_STAT_ENABLE) {
+                        /* The power session apparently survived the resume.
+                         * If there was an overcurrent or suspend change
+                         * (i.e., remote wakeup request), have khubd
+                         * take care of it.
+                         */
+                        if (portchange)
+                                set_bit(port1, hub->change_bits);
 
-        /* FIXME! We should check whether it's open here or not! */
+                } else if (udev->persist_enabled) {
+#ifdef CONFIG_PM
+                        udev->reset_resume = 1;
+#endif
+                        set_bit(port1, hub->change_bits);
 
-        /*
-         * Check that all the interface drivers have a
-         * 'reset_resume' entrypoint
+                } else {
+                        /* The power session is gone; tell khubd */
+                        usb_set_device_state(udev, USB_STATE_NOTATTACHED);
+                        set_bit(port1, hub->change_bits);
+                }
+        }
+
+        /* If no port-status-change flags were set, we don't need any
+         * debouncing.  If flags were set we can try to debounce the
+         * ports all at once right now, instead of letting khubd do them
+         * one at a time later on.
+         *
+         * If any port-status changes do occur during this delay, khubd
+         * will see them later and handle them normally.
          */
-        retval = 0;
-        for (i = 0; i < actconfig->desc.bNumInterfaces; i++) {
-                struct usb_interface *intf;
-                struct usb_driver *driver;
+        if (need_debounce_delay)
+                msleep(HUB_DEBOUNCE_STABLE);
 
-                intf = actconfig->interface[i];
-                if (!intf->dev.driver)
-                        continue;
-                driver = to_usb_driver(intf->dev.driver);
-                if (!driver->reset_resume)
-                        return 0;
-                /*
-                 * We have at least one driver, and that one
-                 * has a reset_resume method.
-                 */
-                retval = 1;
-        }
-        return retval;
-}
+        hub->quiescing = 0;
 
-static void hub_restart(struct usb_hub *hub, int type)
-{
-        struct usb_device *hdev = hub->hdev;
-        int port1;
+        status = usb_submit_urb(hub->urb, GFP_NOIO);
+        if (status < 0)
+                dev_err(hub->intfdev, "activate --> %d\n", status);
+        if (hub->has_indicators && blinkenlights)
+                schedule_delayed_work(&hub->leds, LED_CYCLE_PERIOD);
 
-        /* Check each of the children to see if they require
-         * USB-PERSIST handling or disconnection.  Also check
-         * each unoccupied port to make sure it is still disabled.
-         */
-        for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device *udev = hdev->children[port1-1];
-                int status = 0;
-                u16 portstatus, portchange;
+        /* Scan all ports that need attention */
+        kick_khubd(hub);
+}
 
-                if (!udev || udev->state == USB_STATE_NOTATTACHED) {
-                        if (type != HUB_RESET) {
-                                status = hub_port_status(hub, port1,
-                                                &portstatus, &portchange);
-                                if (status == 0 && (portstatus &
-                                                USB_PORT_STAT_ENABLE))
-                                        clear_port_feature(hdev, port1,
-                                                        USB_PORT_FEAT_ENABLE);
-                        }
-                        continue;
-                }
+enum hub_quiescing_type {
+        HUB_DISCONNECT, HUB_PRE_RESET, HUB_SUSPEND
+};
 
-                /* Was the power session lost while we were suspended? */
-                status = hub_port_status(hub, port1, &portstatus, &portchange);
+static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
+{
+        struct usb_device *hdev = hub->hdev;
+        int i;
 
-                /* If the device is gone, khubd will handle it later */
-                if (status == 0 && !(portstatus & USB_PORT_STAT_CONNECTION))
-                        continue;
+        /* khubd and related activity won't re-trigger */
+        hub->quiescing = 1;
 
-                /* For "USB_PERSIST"-enabled children we must
-                 * mark the child device for reset-resume and
-                 * turn off the various status changes to prevent
-                 * khubd from disconnecting it later.
-                 */
-                if (status == 0 && !(portstatus & USB_PORT_STAT_ENABLE) &&
-                                persistent_device(udev)) {
-                        if (portchange & USB_PORT_STAT_C_ENABLE)
-                                clear_port_feature(hub->hdev, port1,
-                                                USB_PORT_FEAT_C_ENABLE);
-                        if (portchange & USB_PORT_STAT_C_CONNECTION)
-                                clear_port_feature(hub->hdev, port1,
-                                                USB_PORT_FEAT_C_CONNECTION);
-                        udev->reset_resume = 1;
+        if (type != HUB_SUSPEND) {
+                /* Disconnect all the children */
+                for (i = 0; i < hdev->maxchild; ++i) {
+                        if (hdev->children[i])
+                                usb_disconnect(&hdev->children[i]);
                 }
-
-                /* Otherwise for a reset_resume we must disconnect the child,
-                 * but as we may not lock the child device here
-                 * we have to do a "logical" disconnect.
-                 */
-                else if (type == HUB_RESET_RESUME)
-                        hub_port_logical_disconnect(hub, port1);
         }
 
-        hub_activate(hub);
+        /* Stop khubd and related activity */
+        usb_kill_urb(hub->urb);
+        if (hub->has_indicators)
+                cancel_delayed_work_sync(&hub->leds);
+        if (hub->tt.hub)
+                cancel_work_sync(&hub->tt.kevent);
 }
 
-#endif  /* CONFIG_PM */
-
 /* caller has locked the hub device */
 static int hub_pre_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
-        hub_stop(hub);
+        hub_quiesce(hub, HUB_PRE_RESET);
         return 0;
 }
 
@@ -762,8 +749,7 @@ static int hub_post_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
-        hub_power_on(hub);
-        hub_activate(hub);
+        hub_activate(hub, HUB_POST_RESET);
         return 0;
 }
 
@@ -1009,8 +995,7 @@ static int hub_configure(struct usb_hub *hub,
         if (hub->has_indicators && blinkenlights)
                 hub->indicator [0] = INDICATOR_CYCLE;
 
-        hub_power_on(hub);
-        hub_activate(hub);
+        hub_activate(hub, HUB_INIT);
         return 0;
 
 fail:
@@ -1042,7 +1027,7 @@ static void hub_disconnect(struct usb_interface *intf)
 
         /* Disconnect all children and quiesce the hub */
         hub->error = 0;
-        hub_stop(hub);
+        hub_quiesce(hub, HUB_DISCONNECT);
 
         usb_set_intfdata (intf, NULL);
 
@@ -1068,6 +1053,12 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
         desc = intf->cur_altsetting;
         hdev = interface_to_usbdev(intf);
 
+        if (hdev->level == MAX_TOPO_LEVEL) {
+                dev_err(&intf->dev, "Unsupported bus topology: "
+                                "hub nested too deep\n");
+                return -E2BIG;
+        }
+
 #ifdef  CONFIG_USB_OTG_BLACKLIST_HUB
         if (hdev->parent) {
                 dev_warn(&intf->dev, "ignoring external hub\n");
@@ -1814,6 +1805,51 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
 
 #ifdef  CONFIG_PM
 
+#define MASK_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION | \
+                                USB_PORT_STAT_SUSPEND)
+#define WANT_BITS       (USB_PORT_STAT_POWER | USB_PORT_STAT_CONNECTION)
+
+/* Determine whether the device on a port is ready for a normal resume,
+ * is ready for a reset-resume, or should be disconnected.
+ */
+static int check_port_resume_type(struct usb_device *udev,
+                struct usb_hub *hub, int port1,
+                int status, unsigned portchange, unsigned portstatus)
+{
+        /* Is the device still present? */
+        if (status || (portstatus & MASK_BITS) != WANT_BITS) {
+                if (status >= 0)
+                        status = -ENODEV;
+        }
+
+        /* Can't do a normal resume if the port isn't enabled,
+         * so try a reset-resume instead.
+         */
+        else if (!(portstatus & USB_PORT_STAT_ENABLE) && !udev->reset_resume) {
+                if (udev->persist_enabled)
+                        udev->reset_resume = 1;
+                else
+                        status = -ENODEV;
+        }
+
+        if (status) {
+                dev_dbg(hub->intfdev,
+                                "port %d status %04x.%04x after resume, %d\n",
+                                port1, portchange, portstatus, status);
+        } else if (udev->reset_resume) {
+
+                /* Late port handoff can set status-change bits */
+                if (portchange & USB_PORT_STAT_C_CONNECTION)
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_CONNECTION);
+                if (portchange & USB_PORT_STAT_C_ENABLE)
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_ENABLE);
+        }
+
+        return status;
+}
+
 #ifdef  CONFIG_USB_SUSPEND
 
 /*
@@ -1943,7 +1979,8 @@ static int finish_port_resume(struct usb_device *udev)
          * resumed.
          */
         if (udev->reset_resume)
-                status = usb_reset_device(udev);
+ retry_reset_resume:
+                status = usb_reset_and_verify_device(udev);
 
         /* 10.5.4.5 says be sure devices in the tree are still there.
          * For now let's assume the device didn't go crazy on resume,
@@ -1954,6 +1991,13 @@ static int finish_port_resume(struct usb_device *udev)
                 status = usb_get_status(udev, USB_RECIP_DEVICE, 0, &devstatus);
                 if (status >= 0)
                         status = (status > 0 ? 0 : -ENODEV);
+
+                /* If a normal resume failed, try doing a reset-resume */
+                if (status && !udev->reset_resume && udev->persist_enabled) {
+                        dev_dbg(&udev->dev, "retry with reset-resume\n");
+                        udev->reset_resume = 1;
+                        goto retry_reset_resume;
+                }
         }
 
         if (status) {
@@ -2002,7 +2046,7 @@ static int finish_port_resume(struct usb_device *udev)
  * to it will be lost.  Using the USB_PERSIST facility, the device can be
  * made to appear as if it had not disconnected.
  *
- * This facility can be dangerous.  Although usb_reset_device() makes
+ * This facility can be dangerous.  Although usb_reset_and_verify_device() makes
  * every effort to insure that the same device is present after the
  * reset as before, it cannot provide a 100% guarantee.  Furthermore it's
  * quite possible for a device to remain unaltered but its media to be
@@ -2018,7 +2062,6 @@ int usb_port_resume(struct usb_device *udev)
         int             port1 = udev->portnum;
         int             status;
         u16             portchange, portstatus;
-        unsigned        mask_flags, want_flags;
 
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
@@ -2047,35 +2090,23 @@ int usb_port_resume(struct usb_device *udev)
                  */
                 status = hub_port_status(hub, port1, &portstatus, &portchange);
 
- SuspendCleared:
-                if (udev->reset_resume)
-                        want_flags = USB_PORT_STAT_POWER
-                                        | USB_PORT_STAT_CONNECTION;
-                else
-                        want_flags = USB_PORT_STAT_POWER
-                                        | USB_PORT_STAT_CONNECTION
-                                        | USB_PORT_STAT_ENABLE;
-                mask_flags = want_flags | USB_PORT_STAT_SUSPEND;
+                /* TRSMRCY = 10 msec */
+                msleep(10);
+        }
 
-                if (status < 0 || (portstatus & mask_flags) != want_flags) {
-                        dev_dbg(hub->intfdev,
-                                "port %d status %04x.%04x after resume, %d\n",
-                                port1, portchange, portstatus, status);
-                        if (status >= 0)
-                                status = -ENODEV;
-                } else {
-                        if (portchange & USB_PORT_STAT_C_SUSPEND)
-                                clear_port_feature(hub->hdev, port1,
-                                                USB_PORT_FEAT_C_SUSPEND);
-                        /* TRSMRCY = 10 msec */
-                        msleep(10);
-                }
+ SuspendCleared:
+        if (status == 0) {
+                if (portchange & USB_PORT_STAT_C_SUSPEND)
+                        clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_SUSPEND);
         }
 
         clear_bit(port1, hub->busy_bits);
         if (!hub->hdev->parent && !hub->busy_bits[0])
                 usb_enable_root_hub_irq(hub->hdev->bus);
 
+        status = check_port_resume_type(udev,
+                        hub, port1, status, portchange, portstatus);
         if (status == 0)
                 status = finish_port_resume(udev);
         if (status < 0) {
@@ -2085,17 +2116,16 @@ int usb_port_resume(struct usb_device *udev)
         return status;
 }
 
+/* caller has locked udev */
 static int remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
-        usb_lock_device(udev);
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
                 usb_mark_last_busy(udev);
                 status = usb_external_resume_device(udev);
         }
-        usb_unlock_device(udev);
         return status;
 }
 
@@ -2108,14 +2138,25 @@ int usb_port_suspend(struct usb_device *udev)
         return 0;
 }
 
+/* However we may need to do a reset-resume */
+
 int usb_port_resume(struct usb_device *udev)
 {
-        int status = 0;
+        struct usb_hub  *hub = hdev_to_hub(udev->parent);
+        int             port1 = udev->portnum;
+        int             status;
+        u16             portchange, portstatus;
 
-        /* However we may need to do a reset-resume */
-        if (udev->reset_resume) {
+        status = hub_port_status(hub, port1, &portstatus, &portchange);
+        status = check_port_resume_type(udev,
+                        hub, port1, status, portchange, portstatus);
+
+        if (status) {
+                dev_dbg(&udev->dev, "can't resume, status %d\n", status);
+                hub_port_logical_disconnect(hub, port1);
+        } else if (udev->reset_resume) {
                 dev_dbg(&udev->dev, "reset-resume\n");
-                status = usb_reset_device(udev);
+                status = usb_reset_and_verify_device(udev);
         }
         return status;
 }
@@ -2149,7 +2190,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
         dev_dbg(&intf->dev, "%s\n", __func__);
 
         /* stop khubd and related activity */
-        hub_quiesce(hub);
+        hub_quiesce(hub, HUB_SUSPEND);
         return 0;
 }
 
@@ -2158,7 +2199,7 @@ static int hub_resume(struct usb_interface *intf)
         struct usb_hub *hub = usb_get_intfdata(intf);
 
         dev_dbg(&intf->dev, "%s\n", __func__);
-        hub_restart(hub, HUB_RESUME);
+        hub_activate(hub, HUB_RESUME);
         return 0;
 }
 
@@ -2167,8 +2208,7 @@ static int hub_reset_resume(struct usb_interface *intf)
         struct usb_hub *hub = usb_get_intfdata(intf);
 
         dev_dbg(&intf->dev, "%s\n", __func__);
-        hub_power_on(hub);
-        hub_restart(hub, HUB_RESET_RESUME);
+        hub_activate(hub, HUB_RESET_RESUME);
         return 0;
 }
 
@@ -2218,11 +2258,6 @@ static inline int remote_wakeup(struct usb_device *udev)
  * every 25ms for transient disconnects.  When the port status has been
  * unchanged for 100ms it returns the port status.
  */
-
-#define HUB_DEBOUNCE_TIMEOUT    1500
-#define HUB_DEBOUNCE_STEP         25
-#define HUB_DEBOUNCE_STABLE      100
-
 static int hub_port_debounce(struct usb_hub *hub, int port1)
 {
         int ret;
@@ -2302,7 +2337,7 @@ static int hub_set_address(struct usb_device *udev, int devnum)
  * Returns device in USB_STATE_ADDRESS, except on error.
  *
  * If this is called for an already-existing device (as part of
- * usb_reset_device), the caller must own the device lock.  For a
+ * usb_reset_and_verify_device), the caller must own the device lock.  For a
  * newly detected device that is not accessible through any global
  * pointers, it's not necessary to lock the device.
  */
@@ -2619,7 +2654,7 @@ hub_power_remaining (struct usb_hub *hub)
  * This routine is called when:
  *      a port connection-change occurs;
  *      a port enable-change occurs (often caused by EMI);
- *      usb_reset_device() encounters changed descriptors (as from
+ *      usb_reset_and_verify_device() encounters changed descriptors (as from
  *              a firmware download)
  * caller already locked the hub
  */
@@ -2629,9 +2664,11 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
         struct usb_device *hdev = hub->hdev;
         struct device *hub_dev = hub->intfdev;
         struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
-        u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
+        unsigned wHubCharacteristics =
+                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
+        struct usb_device *udev;
         int status, i;
- 
+
         dev_dbg (hub_dev,
                 "port %d, status %04x, change %04x, %s\n",
                 port1, portstatus, portchange, portspeed (portstatus));
@@ -2640,30 +2677,73 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 set_port_led(hub, port1, HUB_LED_AUTO);
                 hub->indicator[port1-1] = INDICATOR_AUTO;
         }
- 
-        /* Disconnect any existing devices under this port */
-        if (hdev->children[port1-1])
-                usb_disconnect(&hdev->children[port1-1]);
-        clear_bit(port1, hub->change_bits);
 
 #ifdef  CONFIG_USB_OTG
         /* during HNP, don't repeat the debounce */
         if (hdev->bus->is_b_host)
-                portchange &= ~USB_PORT_STAT_C_CONNECTION;
+                portchange &= ~(USB_PORT_STAT_C_CONNECTION |
+                                USB_PORT_STAT_C_ENABLE);
 #endif
 
-        if (portchange & USB_PORT_STAT_C_CONNECTION) {
+        /* Try to use the debounce delay for protection against
+         * port-enable changes caused, for example, by EMI.
+         */
+        if (portchange & (USB_PORT_STAT_C_CONNECTION |
+                                USB_PORT_STAT_C_ENABLE)) {
                 status = hub_port_debounce(hub, port1);
                 if (status < 0) {
                         if (printk_ratelimit())
                                 dev_err (hub_dev, "connect-debounce failed, "
                                                 "port %d disabled\n", port1);
-                        goto done;
+                        portstatus &= ~USB_PORT_STAT_CONNECTION;
+                } else {
+                        portstatus = status;
+                }
+        }
+
+        /* Try to resuscitate an existing device */
+        udev = hdev->children[port1-1];
+        if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
+                        udev->state != USB_STATE_NOTATTACHED) {
+
+                usb_lock_device(udev);
+                if (portstatus & USB_PORT_STAT_ENABLE) {
+                        status = 0;             /* Nothing to do */
+                } else if (!udev->persist_enabled) {
+                        status = -ENODEV;       /* Mustn't resuscitate */
+
+#ifdef CONFIG_USB_SUSPEND
+                } else if (udev->state == USB_STATE_SUSPENDED) {
+                        /* For a suspended device, treat this as a
+                         * remote wakeup event.
+                         */
+                        if (udev->do_remote_wakeup)
+                                status = remote_wakeup(udev);
+
+                        /* Otherwise leave it be; devices can't tell the
+                         * difference between suspended and disabled.
+                         */
+                        else
+                                status = 0;
+#endif
+
+                } else {
+                        status = usb_reset_device(udev);
+                }
+                usb_unlock_device(udev);
+
+                if (status == 0) {
+                        clear_bit(port1, hub->change_bits);
+                        return;
                 }
-                portstatus = status;
         }
 
-        /* Return now if nothing is connected */
+        /* Disconnect any existing devices under this port */
+        if (udev)
+                usb_disconnect(&hdev->children[port1-1]);
+        clear_bit(port1, hub->change_bits);
+
+        /* Return now if debouncing failed or nothing is connected */
         if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
 
                 /* maybe switch power back on (e.g. root hub was reset) */
@@ -2677,7 +2757,6 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
         }
 
         for (i = 0; i < SET_CONFIG_TRIES; i++) {
-                struct usb_device *udev;
 
                 /* reallocate for each attempt, since references
                  * to the previous one can escape in various ways
@@ -2858,7 +2937,7 @@ static void hub_events(void)
                 /* If the hub has died, clean up after it */
                 if (hdev->state == USB_STATE_NOTATTACHED) {
                         hub->error = -ENODEV;
-                        hub_stop(hub);
+                        hub_quiesce(hub, HUB_DISCONNECT);
                         goto loop;
                 }
 
@@ -2877,7 +2956,7 @@ static void hub_events(void)
                         dev_dbg (hub_dev, "resetting for error %d\n",
                                 hub->error);
 
-                        ret = usb_reset_composite_device(hdev, intf);
+                        ret = usb_reset_device(hdev);
                         if (ret) {
                                 dev_dbg (hub_dev,
                                         "error resetting hub: %d\n", ret);
@@ -2894,7 +2973,7 @@ static void hub_events(void)
                                 continue;
                         connect_change = test_bit(i, hub->change_bits);
                         if (!test_and_clear_bit(i, hub->event_bits) &&
-                                        !connect_change && !hub->activating)
+                                        !connect_change)
                                 continue;
 
                         ret = hub_port_status(hub, i,
@@ -2902,11 +2981,6 @@ static void hub_events(void)
                         if (ret < 0)
                                 continue;
 
-                        if (hub->activating && !hdev->children[i-1] &&
-                                        (portstatus &
-                                                USB_PORT_STAT_CONNECTION))
-                                connect_change = 1;
-
                         if (portchange & USB_PORT_STAT_C_CONNECTION) {
                                 clear_port_feature(hdev, i,
                                         USB_PORT_FEAT_C_CONNECTION);
@@ -2941,11 +3015,16 @@ static void hub_events(void)
                         }
 
                         if (portchange & USB_PORT_STAT_C_SUSPEND) {
+                                struct usb_device *udev;
+
                                 clear_port_feature(hdev, i,
                                         USB_PORT_FEAT_C_SUSPEND);
-                                if (hdev->children[i-1]) {
+                                udev = hdev->children[i-1];
+                                if (udev) {
+                                        usb_lock_device(udev);
                                         ret = remote_wakeup(hdev->
                                                         children[i-1]);
+                                        usb_unlock_device(udev);
                                         if (ret < 0)
                                                 connect_change = 1;
                                 } else {
@@ -3002,8 +3081,6 @@ static void hub_events(void)
                         }
                 }
 
-                hub->activating = 0;
-
                 /* If this is a root hub, tell the HCD it's okay to
                  * re-enable port-change interrupts now. */
                 if (!hdev->parent && !hub->busy_bits[0])
@@ -3172,12 +3249,12 @@ static int descriptors_changed(struct usb_device *udev,
 }
 
 /**
- * usb_reset_device - perform a USB port reset to reinitialize a device
+ * usb_reset_and_verify_device - perform a USB port reset to reinitialize a device
  * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
  *
  * WARNING - don't use this routine to reset a composite device
  * (one with multiple interfaces owned by separate drivers)!
- * Use usb_reset_composite_device() instead.
+ * Use usb_reset_device() instead.
  *
  * Do a port reset, reassign the device's address, and establish its
  * former operating configuration.  If the reset fails, or the device's
@@ -3201,7 +3278,7 @@ static int descriptors_changed(struct usb_device *udev,
  * holding the device lock because these tasks should always call
  * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
  */
-int usb_reset_device(struct usb_device *udev)
+static int usb_reset_and_verify_device(struct usb_device *udev)
 {
         struct usb_device               *parent_hdev = udev->parent;
         struct usb_hub                  *parent_hub;
@@ -3289,26 +3366,28 @@ re_enumerate:
         hub_port_logical_disconnect(parent_hub, port1);
         return -ENODEV;
 }
-EXPORT_SYMBOL_GPL(usb_reset_device);
 
 /**
- * usb_reset_composite_device - warn interface drivers and perform a USB port reset
+ * usb_reset_device - warn interface drivers and perform a USB port reset
  * @udev: device to reset (not in SUSPENDED or NOTATTACHED state)
- * @iface: interface bound to the driver making the request (optional)
  *
  * Warns all drivers bound to registered interfaces (using their pre_reset
  * method), performs the port reset, and then lets the drivers know that
  * the reset is over (using their post_reset method).
  *
- * Return value is the same as for usb_reset_device().
+ * Return value is the same as for usb_reset_and_verify_device().
  *
  * The caller must own the device lock.  For example, it's safe to use
  * this from a driver probe() routine after downloading new firmware.
  * For calls that might not occur during probe(), drivers should lock
  * the device using usb_lock_device_for_reset().
+ *
+ * If an interface is currently being probed or disconnected, we assume
+ * its driver knows how to handle resets.  For all other interfaces,
+ * if the driver doesn't have pre_reset and post_reset methods then
+ * we attempt to unbind it and rebind afterward.
  */
-int usb_reset_composite_device(struct usb_device *udev,
-                struct usb_interface *iface)
+int usb_reset_device(struct usb_device *udev)
 {
         int ret;
         int i;
@@ -3324,40 +3403,47 @@ int usb_reset_composite_device(struct usb_device *udev,
         /* Prevent autosuspend during the reset */
         usb_autoresume_device(udev);
 
-        if (iface && iface->condition != USB_INTERFACE_BINDING)
-                iface = NULL;
-
         if (config) {
                 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
                         struct usb_interface *cintf = config->interface[i];
                         struct usb_driver *drv;
+                        int unbind = 0;
 
                         if (cintf->dev.driver) {
                                 drv = to_usb_driver(cintf->dev.driver);
-                                if (drv->pre_reset)
-                                        (drv->pre_reset)(cintf);
-        /* FIXME: Unbind if pre_reset returns an error or isn't defined */
+                                if (drv->pre_reset && drv->post_reset)
+                                        unbind = (drv->pre_reset)(cintf);
+                                else if (cintf->condition ==
+                                                USB_INTERFACE_BOUND)
+                                        unbind = 1;
+                                if (unbind)
+                                        usb_forced_unbind_intf(cintf);
                         }
                 }
         }
 
-        ret = usb_reset_device(udev);
+        ret = usb_reset_and_verify_device(udev);
 
         if (config) {
                 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
                         struct usb_interface *cintf = config->interface[i];
                         struct usb_driver *drv;
+                        int rebind = cintf->needs_binding;
 
-                        if (cintf->dev.driver) {
+                        if (!rebind && cintf->dev.driver) {
                                 drv = to_usb_driver(cintf->dev.driver);
                                 if (drv->post_reset)
-                                        (drv->post_reset)(cintf);
-        /* FIXME: Unbind if post_reset returns an error or isn't defined */
+                                        rebind = (drv->post_reset)(cintf);
+                                else if (cintf->condition ==
+                                                USB_INTERFACE_BOUND)
+                                        rebind = 1;
                         }
+                        if (rebind)
+                                usb_rebind_intf(cintf);
                 }
         }
 
         usb_autosuspend_device(udev);
         return ret;
 }
-EXPORT_SYMBOL_GPL(usb_reset_composite_device);
+EXPORT_SYMBOL_GPL(usb_reset_device);
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 1d253dd4ea81..db410e92c80d 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -712,25 +712,11 @@ static void usbfs_add_device(struct usb_device *dev)
 
 static void usbfs_remove_device(struct usb_device *dev)
 {
-        struct dev_state *ds;
-        struct siginfo sinfo;
-
         if (dev->usbfs_dentry) {
                 fs_remove_file (dev->usbfs_dentry);
                 dev->usbfs_dentry = NULL;
         }
-        while (!list_empty(&dev->filelist)) {
-                ds = list_entry(dev->filelist.next, struct dev_state, list);
-                wake_up_all(&ds->wait);
-                list_del_init(&ds->list);
-                if (ds->discsignr) {
-                        sinfo.si_signo = ds->discsignr;
-                        sinfo.si_errno = EPIPE;
-                        sinfo.si_code = SI_ASYNCIO;
-                        sinfo.si_addr = ds->disccontext;
-                        kill_pid_info_as_uid(ds->discsignr, &sinfo, ds->disc_pid, ds->disc_uid, ds->disc_euid, ds->secid);
-                }
-        }
+        usb_fs_classdev_common_remove(dev);
 }
 
 static int usbfs_notify(struct notifier_block *self, unsigned long action, void *dev)
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index fe47d145255a..2fcc06eb5e60 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -400,7 +400,7 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
         if (usb_pipein(pipe))
                 urb_flags |= URB_SHORT_NOT_OK;
 
-        for (i = 0; i < io->entries; i++) {
+        for_each_sg(sg, sg, io->entries, i) {
                 unsigned len;
 
                 io->urbs[i] = usb_alloc_urb(0, mem_flags);
@@ -434,17 +434,17 @@ int usb_sg_init(struct usb_sg_request *io, struct usb_device *dev,
                  * to prevent stale pointers and to help spot bugs.
                  */
                 if (dma) {
-                        io->urbs[i]->transfer_dma = sg_dma_address(sg + i);
-                        len = sg_dma_len(sg + i);
+                        io->urbs[i]->transfer_dma = sg_dma_address(sg);
+                        len = sg_dma_len(sg);
 #if defined(CONFIG_HIGHMEM) || defined(CONFIG_GART_IOMMU)
                         io->urbs[i]->transfer_buffer = NULL;
 #else
-                        io->urbs[i]->transfer_buffer = sg_virt(&sg[i]);
+                        io->urbs[i]->transfer_buffer = sg_virt(sg);
 #endif
                 } else {
                         /* hc may use _only_ transfer_buffer */
-                        io->urbs[i]->transfer_buffer = sg_virt(&sg[i]);
-                        len = sg[i].length;
+                        io->urbs[i]->transfer_buffer = sg_virt(sg);
+                        len = sg->length;
                 }
 
                 if (length) {
@@ -1090,7 +1090,7 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                         if (!device_is_registered(&interface->dev))
                                 continue;
                         dev_dbg(&dev->dev, "unregistering interface %s\n",
-                                interface->dev.bus_id);
+                                dev_name(&interface->dev));
                         device_del(&interface->dev);
                         usb_remove_sysfs_intf_files(interface);
                 }
@@ -1476,7 +1476,7 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
  *
  * This call is synchronous. The calling context must be able to sleep,
  * must own the device lock, and must not hold the driver model's USB
- * bus mutex; usb device driver probe() methods cannot use this routine.
+ * bus mutex; usb interface driver probe() methods cannot use this routine.
  *
  * Returns zero on success, or else the status code returned by the
  * underlying call that failed.  On successful completion, each interface
@@ -1611,7 +1611,7 @@ free_interfaces:
                 intf->dev.dma_mask = dev->dev.dma_mask;
                 device_initialize(&intf->dev);
                 mark_quiesced(intf);
-                sprintf(&intf->dev.bus_id[0], "%d-%s:%d.%d",
+                dev_set_name(&intf->dev, "%d-%s:%d.%d",
                         dev->bus->busnum, dev->devpath,
                         configuration, alt->desc.bInterfaceNumber);
         }
@@ -1631,12 +1631,12 @@ free_interfaces:
 
                 dev_dbg(&dev->dev,
                         "adding %s (config #%d, interface %d)\n",
-                        intf->dev.bus_id, configuration,
+                        dev_name(&intf->dev), configuration,
                         intf->cur_altsetting->desc.bInterfaceNumber);
                 ret = device_add(&intf->dev);
                 if (ret != 0) {
                         dev_err(&dev->dev, "device_add(%s) --> %d\n",
-                                intf->dev.bus_id, ret);
+                                dev_name(&intf->dev), ret);
                         continue;
                 }
                 usb_create_sysfs_intf_files(intf);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 325774375837..84fcaa6a21ec 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -308,7 +308,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
          * by location for diagnostics, tools, driver model, etc.  The
          * string is a path along hub ports, from the root.  Each device's
          * dev->devpath will be stable until USB is re-cabled, and hubs
-         * are often labeled with these port numbers.  The bus_id isn't
+         * are often labeled with these port numbers.  The name isn't
          * as stable:  bus->busnum changes easily from modprobe order,
          * cardbus or pci hotplugging, and so on.
          */
@@ -316,7 +316,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 dev->devpath[0] = '0';
 
                 dev->dev.parent = bus->controller;
-                sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum);
+                dev_set_name(&dev->dev, "usb%d", bus->busnum);
                 root_hub = 1;
         } else {
                 /* match any labeling on the hubs; it's one-based */
@@ -328,8 +328,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
                                 "%s.%d", parent->devpath, port1);
 
                 dev->dev.parent = &parent->dev;
-                sprintf(&dev->dev.bus_id[0], "%d-%s",
-                        bus->busnum, dev->devpath);
+                dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
 
                 /* hub driver sets up TT records */
         }
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 1a8bc21c335e..d9a6e16dbf84 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -29,6 +29,8 @@ extern int usb_choose_configuration(struct usb_device *udev);
 extern void usb_kick_khubd(struct usb_device *dev);
 extern int usb_match_device(struct usb_device *dev,
                             const struct usb_device_id *id);
+extern void usb_forced_unbind_intf(struct usb_interface *intf);
+extern void usb_rebind_intf(struct usb_interface *intf);
 
 extern int  usb_hub_init(void);
 extern void usb_hub_cleanup(void);
@@ -140,26 +142,11 @@ extern struct usb_driver usbfs_driver;
 extern const struct file_operations usbfs_devices_fops;
 extern const struct file_operations usbdev_file_operations;
 extern void usbfs_conn_disc_event(void);
+extern void usb_fs_classdev_common_remove(struct usb_device *udev);
 
 extern int usb_devio_init(void);
 extern void usb_devio_cleanup(void);
 
-struct dev_state {
-        struct list_head list;      /* state list */
-        struct usb_device *dev;
-        struct file *file;
-        spinlock_t lock;            /* protects the async urb lists */
-        struct list_head async_pending;
-        struct list_head async_completed;
-        wait_queue_head_t wait;     /* wake up if a request completed */
-        unsigned int discsignr;
-        struct pid *disc_pid;
-        uid_t disc_uid, disc_euid;
-        void __user *disccontext;
-        unsigned long ifclaimed;
-        u32 secid;
-};
-
 /* internal notify stuff */
 extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index d6bab0d5f453..c6a8c6b1116a 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -586,6 +586,20 @@ config USB_G_PRINTER
           For more information, see Documentation/usb/gadget_printer.txt
           which includes sample code for accessing the device file.
 
+config USB_CDC_COMPOSITE
+        tristate "CDC Composite Device (Ethernet and ACM)"
+        depends on NET
+        help
+          This driver provides two functions in one configuration:
+          a CDC Ethernet (ECM) link, and a CDC ACM (serial port) link.
+
+          This driver requires four bulk and two interrupt endpoints,
+          plus the ability to handle altsettings.  Not all peripheral
+          controllers are that capable.
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module.
+
 # put drivers that need isochronous transfer support (for audio
 # or video class gadget drivers), or specific hardware, here.
 
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index e258afd25faf..fcb5cb9094d9 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -22,18 +22,22 @@ obj-$(CONFIG_USB_M66592)	+= m66592-udc.o
 #
 # USB gadget drivers
 #
-g_zero-objs                     := zero.o usbstring.o config.o epautoconf.o
-g_ether-objs                    := ether.o usbstring.o config.o epautoconf.o
-g_serial-objs                   := serial.o usbstring.o config.o epautoconf.o
+C_UTILS =       composite.o usbstring.o config.o epautoconf.o
+
+g_zero-objs                     := zero.o f_sourcesink.o f_loopback.o $(C_UTILS)
+g_ether-objs                    := ether.o u_ether.o f_subset.o f_ecm.o $(C_UTILS)
+g_serial-objs                   := serial.o u_serial.o f_acm.o f_serial.o $(C_UTILS)
 g_midi-objs                     := gmidi.o usbstring.o config.o epautoconf.o
 gadgetfs-objs                   := inode.o
 g_file_storage-objs             := file_storage.o usbstring.o config.o \
                                         epautoconf.o
 g_printer-objs                  := printer.o usbstring.o config.o \
                                         epautoconf.o
+g_cdc-objs                      := cdc2.o u_ether.o f_ecm.o \
+                                        u_serial.o f_acm.o $(C_UTILS)
 
 ifeq ($(CONFIG_USB_ETH_RNDIS),y)
-        g_ether-objs            += rndis.o
+        g_ether-objs            += f_rndis.o rndis.o
 endif
  
 obj-$(CONFIG_USB_ZERO)          += g_zero.o
@@ -43,4 +47,5 @@ obj-$(CONFIG_USB_FILE_STORAGE)	+= g_file_storage.o
 obj-$(CONFIG_USB_G_SERIAL)      += g_serial.o
 obj-$(CONFIG_USB_G_PRINTER)     += g_printer.o
 obj-$(CONFIG_USB_MIDI_GADGET)   += g_midi.o
+obj-$(CONFIG_USB_CDC_COMPOSITE) += g_cdc.o
 
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index f261d2a9a5f0..1500e1b3c302 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -3342,7 +3342,7 @@ static int udc_probe(struct udc *dev)
         spin_lock_init(&dev->lock);
         dev->gadget.ops = &udc_ops;
 
-        strcpy(dev->gadget.dev.bus_id, "gadget");
+        dev_set_name(&dev->gadget.dev, "gadget");
         dev->gadget.dev.release = gadget_release;
         dev->gadget.name = name;
         dev->gadget.name = name;
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index b6b2a0a5ba37..e2d8a5d86c40 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -1687,6 +1687,19 @@ static int __init at91udc_probe(struct platform_device *pdev)
                                 udc->board.pullup_active_low);
         }
 
+        /* newer chips have more FIFO memory than rm9200 */
+        if (cpu_is_at91sam9260()) {
+                udc->ep[0].maxpacket = 64;
+                udc->ep[3].maxpacket = 64;
+                udc->ep[4].maxpacket = 512;
+                udc->ep[5].maxpacket = 512;
+        } else if (cpu_is_at91sam9261()) {
+                udc->ep[3].maxpacket = 64;
+        } else if (cpu_is_at91sam9263()) {
+                udc->ep[0].maxpacket = 64;
+                udc->ep[3].maxpacket = 64;
+        }
+
         udc->udp_baseaddr = ioremap(res->start, res->end - res->start + 1);
         if (!udc->udp_baseaddr) {
                 retval = -ENOMEM;
diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
new file mode 100644
index 000000000000..d490d0289507
--- /dev/null
+++ b/drivers/usb/gadget/cdc2.c
@@ -0,0 +1,246 @@
+/*
+ * cdc2.c -- CDC Composite driver, with ECM and ACM support
+ *
+ * Copyright (C) 2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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/kernel.h>
+#include <linux/utsname.h>
+
+#include "u_ether.h"
+#include "u_serial.h"
+
+
+#define DRIVER_DESC             "CDC Composite Gadget"
+#define DRIVER_VERSION          "King Kamehameha Day 2008"
+
+/*-------------------------------------------------------------------------*/
+
+/* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
+ * Instead:  allocate your own, using normal USB-IF procedures.
+ */
+
+/* Thanks to NetChip Technologies for donating this product ID.
+ * It's for devices with only this composite CDC configuration.
+ */
+#define CDC_VENDOR_NUM          0x0525  /* NetChip */
+#define CDC_PRODUCT_NUM         0xa4aa  /* CDC Composite: ECM + ACM */
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_device_descriptor device_desc = {
+        .bLength =              sizeof device_desc,
+        .bDescriptorType =      USB_DT_DEVICE,
+
+        .bcdUSB =               __constant_cpu_to_le16(0x0200),
+
+        .bDeviceClass =         USB_CLASS_COMM,
+        .bDeviceSubClass =      0,
+        .bDeviceProtocol =      0,
+        /* .bMaxPacketSize0 = f(hardware) */
+
+        /* Vendor and product id can be overridden by module parameters.  */
+        .idVendor =             __constant_cpu_to_le16(CDC_VENDOR_NUM),
+        .idProduct =            __constant_cpu_to_le16(CDC_PRODUCT_NUM),
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
+        .bNumConfigurations =   1,
+};
+
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
+        .bDescriptorType =      USB_DT_OTG,
+
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
+};
+
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
+        NULL,
+};
+
+
+/* string IDs are assigned dynamically */
+
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+
+static char manufacturer[50];
+
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
+
+static u8 hostaddr[ETH_ALEN];
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * We _always_ have both CDC ECM and CDC ACM functions.
+ */
+static int __init cdc_do_config(struct usb_configuration *c)
+{
+        int     status;
+
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        status = ecm_bind_config(c, hostaddr);
+        if (status < 0)
+                return status;
+
+        status = acm_bind_config(c, 0);
+        if (status < 0)
+                return status;
+
+        return 0;
+}
+
+static struct usb_configuration cdc_config_driver = {
+        .label                  = "CDC Composite (ECM + ACM)",
+        .bind                   = cdc_do_config,
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower              = 1,    /* 2 mA, minimal */
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init cdc_bind(struct usb_composite_dev *cdev)
+{
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
+
+        if (!can_support_ecm(cdev->gadget)) {
+                ERROR(cdev, "controller '%s' not usable\n", gadget->name);
+                return -EINVAL;
+        }
+
+        /* set up network link layer */
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                return status;
+
+        /* set up serial link layer */
+        status = gserial_setup(cdev->gadget, 1);
+        if (status < 0)
+                goto fail0;
+
+        gcnum = usb_gadget_controller_number(gadget);
+        if (gcnum >= 0)
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
+        else {
+                /* We assume that can_support_ecm() tells the truth;
+                 * but if the controller isn't recognized at all then
+                 * that assumption is a bit more likely to be wrong.
+                 */
+                WARN(cdev, "controller '%s' not recognized; trying %s\n",
+                                gadget->name,
+                                cdc_config_driver.label);
+                device_desc.bcdDevice =
+                        __constant_cpu_to_le16(0x0300 | 0x0099);
+        }
+
+
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
+
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                init_utsname()->sysname, init_utsname()->release,
+                gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail1;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        device_desc.iManufacturer = status;
+
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail1;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        device_desc.iProduct = status;
+
+        /* register our configuration */
+        status = usb_add_config(cdev, &cdc_config_driver);
+        if (status < 0)
+                goto fail1;
+
+        INFO(cdev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC);
+
+        return 0;
+
+fail1:
+        gserial_cleanup();
+fail0:
+        gether_cleanup();
+        return status;
+}
+
+static int __exit cdc_unbind(struct usb_composite_dev *cdev)
+{
+        gserial_cleanup();
+        gether_cleanup();
+        return 0;
+}
+
+static struct usb_composite_driver cdc_driver = {
+        .name           = "g_cdc",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .bind           = cdc_bind,
+        .unbind         = __exit_p(cdc_unbind),
+};
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("David Brownell");
+MODULE_LICENSE("GPL");
+
+static int __init init(void)
+{
+        return usb_composite_register(&cdc_driver);
+}
+module_init(init);
+
+static void __exit cleanup(void)
+{
+        usb_composite_unregister(&cdc_driver);
+}
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
new file mode 100644
index 000000000000..85c876c1f150
--- /dev/null
+++ b/drivers/usb/gadget/composite.c
@@ -0,0 +1,1041 @@
+/*
+ * composite.c - infrastructure for Composite USB Gadgets
+ *
+ * Copyright (C) 2006-2008 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 VERBOSE_DEBUG */
+
+#include <linux/kallsyms.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/device.h>
+
+#include <linux/usb/composite.h>
+
+
+/*
+ * The code in this file is utility code, used to build a gadget driver
+ * from one or more "function" drivers, one or more "configuration"
+ * objects, and a "usb_composite_driver" by gluing them together along
+ * with the relevant device-wide data.
+ */
+
+/* big enough to hold our biggest descriptor */
+#define USB_BUFSIZ      512
+
+static struct usb_composite_driver *composite;
+
+/* Some systems will need runtime overrides for the  product identifers
+ * published in the device descriptor, either numbers or strings or both.
+ * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
+ */
+
+static ushort idVendor;
+module_param(idVendor, ushort, 0);
+MODULE_PARM_DESC(idVendor, "USB Vendor ID");
+
+static ushort idProduct;
+module_param(idProduct, ushort, 0);
+MODULE_PARM_DESC(idProduct, "USB Product ID");
+
+static ushort bcdDevice;
+module_param(bcdDevice, ushort, 0);
+MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
+
+static char *iManufacturer;
+module_param(iManufacturer, charp, 0);
+MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
+
+static char *iProduct;
+module_param(iProduct, charp, 0);
+MODULE_PARM_DESC(iProduct, "USB Product string");
+
+static char *iSerialNumber;
+module_param(iSerialNumber, charp, 0);
+MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
+
+/*-------------------------------------------------------------------------*/
+
+/**
+ * usb_add_function() - add a function to a configuration
+ * @config: the configuration
+ * @function: the function being added
+ * Context: single threaded during gadget setup
+ *
+ * After initialization, each configuration must have one or more
+ * functions added to it.  Adding a function involves calling its @bind()
+ * method to allocate resources such as interface and string identifiers
+ * and endpoints.
+ *
+ * This function returns the value of the function's bind(), which is
+ * zero for success else a negative errno value.
+ */
+int __init usb_add_function(struct usb_configuration *config,
+                struct usb_function *function)
+{
+        int     value = -EINVAL;
+
+        DBG(config->cdev, "adding '%s'/%p to config '%s'/%p\n",
+                        function->name, function,
+                        config->label, config);
+
+        if (!function->set_alt || !function->disable)
+                goto done;
+
+        function->config = config;
+        list_add_tail(&function->list, &config->functions);
+
+        /* REVISIT *require* function->bind? */
+        if (function->bind) {
+                value = function->bind(config, function);
+                if (value < 0) {
+                        list_del(&function->list);
+                        function->config = NULL;
+                }
+        } else
+                value = 0;
+
+        /* We allow configurations that don't work at both speeds.
+         * If we run into a lowspeed Linux system, treat it the same
+         * as full speed ... it's the function drivers that will need
+         * to avoid bulk and ISO transfers.
+         */
+        if (!config->fullspeed && function->descriptors)
+                config->fullspeed = true;
+        if (!config->highspeed && function->hs_descriptors)
+                config->highspeed = true;
+
+done:
+        if (value)
+                DBG(config->cdev, "adding '%s'/%p --> %d\n",
+                                function->name, function, value);
+        return value;
+}
+
+/**
+ * usb_interface_id() - allocate an unused interface ID
+ * @config: configuration associated with the interface
+ * @function: function handling the interface
+ * Context: single threaded during gadget setup
+ *
+ * usb_interface_id() is called from usb_function.bind() callbacks to
+ * allocate new interface IDs.  The function driver will then store that
+ * ID in interface, association, CDC union, and other descriptors.  It
+ * will also handle any control requests targetted at that interface,
+ * particularly changing its altsetting via set_alt().  There may
+ * also be class-specific or vendor-specific requests to handle.
+ *
+ * All interface identifier should be allocated using this routine, to
+ * ensure that for example different functions don't wrongly assign
+ * different meanings to the same identifier.  Note that since interface
+ * identifers are configuration-specific, functions used in more than
+ * one configuration (or more than once in a given configuration) need
+ * multiple versions of the relevant descriptors.
+ *
+ * Returns the interface ID which was allocated; or -ENODEV if no
+ * more interface IDs can be allocated.
+ */
+int __init usb_interface_id(struct usb_configuration *config,
+                struct usb_function *function)
+{
+        unsigned id = config->next_interface_id;
+
+        if (id < MAX_CONFIG_INTERFACES) {
+                config->interface[id] = function;
+                config->next_interface_id = id + 1;
+                return id;
+        }
+        return -ENODEV;
+}
+
+static int config_buf(struct usb_configuration *config,
+                enum usb_device_speed speed, void *buf, u8 type)
+{
+        struct usb_config_descriptor    *c = buf;
+        void                            *next = buf + USB_DT_CONFIG_SIZE;
+        int                             len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
+        struct usb_function             *f;
+        int                             status;
+
+        /* write the config descriptor */
+        c = buf;
+        c->bLength = USB_DT_CONFIG_SIZE;
+        c->bDescriptorType = type;
+        /* wTotalLength is written later */
+        c->bNumInterfaces = config->next_interface_id;
+        c->bConfigurationValue = config->bConfigurationValue;
+        c->iConfiguration = config->iConfiguration;
+        c->bmAttributes = USB_CONFIG_ATT_ONE | config->bmAttributes;
+        c->bMaxPower = config->bMaxPower;
+
+        /* There may be e.g. OTG descriptors */
+        if (config->descriptors) {
+                status = usb_descriptor_fillbuf(next, len,
+                                config->descriptors);
+                if (status < 0)
+                        return status;
+                len -= status;
+                next += status;
+        }
+
+        /* add each function's descriptors */
+        list_for_each_entry(f, &config->functions, list) {
+                struct usb_descriptor_header **descriptors;
+
+                if (speed == USB_SPEED_HIGH)
+                        descriptors = f->hs_descriptors;
+                else
+                        descriptors = f->descriptors;
+                if (!descriptors)
+                        continue;
+                status = usb_descriptor_fillbuf(next, len,
+                        (const struct usb_descriptor_header **) descriptors);
+                if (status < 0)
+                        return status;
+                len -= status;
+                next += status;
+        }
+
+        len = next - buf;
+        c->wTotalLength = cpu_to_le16(len);
+        return len;
+}
+
+static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
+{
+        struct usb_gadget               *gadget = cdev->gadget;
+        struct usb_configuration        *c;
+        u8                              type = w_value >> 8;
+        enum usb_device_speed           speed = USB_SPEED_UNKNOWN;
+
+        if (gadget_is_dualspeed(gadget)) {
+                int                     hs = 0;
+
+                if (gadget->speed == USB_SPEED_HIGH)
+                        hs = 1;
+                if (type == USB_DT_OTHER_SPEED_CONFIG)
+                        hs = !hs;
+                if (hs)
+                        speed = USB_SPEED_HIGH;
+
+        }
+
+        /* This is a lookup by config *INDEX* */
+        w_value &= 0xff;
+        list_for_each_entry(c, &cdev->configs, list) {
+                /* ignore configs that won't work at this speed */
+                if (speed == USB_SPEED_HIGH) {
+                        if (!c->highspeed)
+                                continue;
+                } else {
+                        if (!c->fullspeed)
+                                continue;
+                }
+                if (w_value == 0)
+                        return config_buf(c, speed, cdev->req->buf, type);
+                w_value--;
+        }
+        return -EINVAL;
+}
+
+static int count_configs(struct usb_composite_dev *cdev, unsigned type)
+{
+        struct usb_gadget               *gadget = cdev->gadget;
+        struct usb_configuration        *c;
+        unsigned                        count = 0;
+        int                             hs = 0;
+
+        if (gadget_is_dualspeed(gadget)) {
+                if (gadget->speed == USB_SPEED_HIGH)
+                        hs = 1;
+                if (type == USB_DT_DEVICE_QUALIFIER)
+                        hs = !hs;
+        }
+        list_for_each_entry(c, &cdev->configs, list) {
+                /* ignore configs that won't work at this speed */
+                if (hs) {
+                        if (!c->highspeed)
+                                continue;
+                } else {
+                        if (!c->fullspeed)
+                                continue;
+                }
+                count++;
+        }
+        return count;
+}
+
+static void device_qual(struct usb_composite_dev *cdev)
+{
+        struct usb_qualifier_descriptor *qual = cdev->req->buf;
+
+        qual->bLength = sizeof(*qual);
+        qual->bDescriptorType = USB_DT_DEVICE_QUALIFIER;
+        /* POLICY: same bcdUSB and device type info at both speeds */
+        qual->bcdUSB = cdev->desc.bcdUSB;
+        qual->bDeviceClass = cdev->desc.bDeviceClass;
+        qual->bDeviceSubClass = cdev->desc.bDeviceSubClass;
+        qual->bDeviceProtocol = cdev->desc.bDeviceProtocol;
+        /* ASSUME same EP0 fifo size at both speeds */
+        qual->bMaxPacketSize0 = cdev->desc.bMaxPacketSize0;
+        qual->bNumConfigurations = count_configs(cdev, USB_DT_DEVICE_QUALIFIER);
+        qual->bRESERVED = 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void reset_config(struct usb_composite_dev *cdev)
+{
+        struct usb_function             *f;
+
+        DBG(cdev, "reset config\n");
+
+        list_for_each_entry(f, &cdev->config->functions, list) {
+                if (f->disable)
+                        f->disable(f);
+        }
+        cdev->config = NULL;
+}
+
+static int set_config(struct usb_composite_dev *cdev,
+                const struct usb_ctrlrequest *ctrl, unsigned number)
+{
+        struct usb_gadget       *gadget = cdev->gadget;
+        struct usb_configuration *c = NULL;
+        int                     result = -EINVAL;
+        unsigned                power = gadget_is_otg(gadget) ? 8 : 100;
+        int                     tmp;
+
+        if (cdev->config)
+                reset_config(cdev);
+
+        if (number) {
+                list_for_each_entry(c, &cdev->configs, list) {
+                        if (c->bConfigurationValue == number) {
+                                result = 0;
+                                break;
+                        }
+                }
+                if (result < 0)
+                        goto done;
+        } else
+                result = 0;
+
+        INFO(cdev, "%s speed config #%d: %s\n",
+                ({ char *speed;
+                switch (gadget->speed) {
+                case USB_SPEED_LOW:     speed = "low"; break;
+                case USB_SPEED_FULL:    speed = "full"; break;
+                case USB_SPEED_HIGH:    speed = "high"; break;
+                default:                speed = "?"; break;
+                } ; speed; }), number, c ? c->label : "unconfigured");
+
+        if (!c)
+                goto done;
+
+        cdev->config = c;
+
+        /* Initialize all interfaces by setting them to altsetting zero. */
+        for (tmp = 0; tmp < MAX_CONFIG_INTERFACES; tmp++) {
+                struct usb_function     *f = c->interface[tmp];
+
+                if (!f)
+                        break;
+
+                result = f->set_alt(f, tmp, 0);
+                if (result < 0) {
+                        DBG(cdev, "interface %d (%s/%p) alt 0 --> %d\n",
+                                        tmp, f->name, f, result);
+
+                        reset_config(cdev);
+                        goto done;
+                }
+        }
+
+        /* when we return, be sure our power usage is valid */
+        power = 2 * c->bMaxPower;
+done:
+        usb_gadget_vbus_draw(gadget, power);
+        return result;
+}
+
+/**
+ * usb_add_config() - add a configuration to a device.
+ * @cdev: wraps the USB gadget
+ * @config: the configuration, with bConfigurationValue assigned
+ * Context: single threaded during gadget setup
+ *
+ * One of the main tasks of a composite driver's bind() routine is to
+ * add each of the configurations it supports, using this routine.
+ *
+ * This function returns the value of the configuration's bind(), which
+ * is zero for success else a negative errno value.  Binding configurations
+ * assigns global resources including string IDs, and per-configuration
+ * resources such as interface IDs and endpoints.
+ */
+int __init usb_add_config(struct usb_composite_dev *cdev,
+                struct usb_configuration *config)
+{
+        int                             status = -EINVAL;
+        struct usb_configuration        *c;
+
+        DBG(cdev, "adding config #%u '%s'/%p\n",
+                        config->bConfigurationValue,
+                        config->label, config);
+
+        if (!config->bConfigurationValue || !config->bind)
+                goto done;
+
+        /* Prevent duplicate configuration identifiers */
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c->bConfigurationValue == config->bConfigurationValue) {
+                        status = -EBUSY;
+                        goto done;
+                }
+        }
+
+        config->cdev = cdev;
+        list_add_tail(&config->list, &cdev->configs);
+
+        INIT_LIST_HEAD(&config->functions);
+        config->next_interface_id = 0;
+
+        status = config->bind(config);
+        if (status < 0) {
+                list_del(&config->list);
+                config->cdev = NULL;
+        } else {
+                unsigned        i;
+
+                DBG(cdev, "cfg %d/%p speeds:%s%s\n",
+                        config->bConfigurationValue, config,
+                        config->highspeed ? " high" : "",
+                        config->fullspeed
+                                ? (gadget_is_dualspeed(cdev->gadget)
+                                        ? " full"
+                                        : " full/low")
+                                : "");
+
+                for (i = 0; i < MAX_CONFIG_INTERFACES; i++) {
+                        struct usb_function     *f = config->interface[i];
+
+                        if (!f)
+                                continue;
+                        DBG(cdev, "  interface %d = %s/%p\n",
+                                i, f->name, f);
+                }
+        }
+
+        /* set_alt(), or next config->bind(), sets up
+         * ep->driver_data as needed.
+         */
+        usb_ep_autoconfig_reset(cdev->gadget);
+
+done:
+        if (status)
+                DBG(cdev, "added config '%s'/%u --> %d\n", config->label,
+                                config->bConfigurationValue, status);
+        return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* We support strings in multiple languages ... string descriptor zero
+ * says which languages are supported.  The typical case will be that
+ * only one language (probably English) is used, with I18N handled on
+ * the host side.
+ */
+
+static void collect_langs(struct usb_gadget_strings **sp, __le16 *buf)
+{
+        const struct usb_gadget_strings *s;
+        u16                             language;
+        __le16                          *tmp;
+
+        while (*sp) {
+                s = *sp;
+                language = cpu_to_le16(s->language);
+                for (tmp = buf; *tmp && tmp < &buf[126]; tmp++) {
+                        if (*tmp == language)
+                                goto repeat;
+                }
+                *tmp++ = language;
+repeat:
+                sp++;
+        }
+}
+
+static int lookup_string(
+        struct usb_gadget_strings       **sp,
+        void                            *buf,
+        u16                             language,
+        int                             id
+)
+{
+        struct usb_gadget_strings       *s;
+        int                             value;
+
+        while (*sp) {
+                s = *sp++;
+                if (s->language != language)
+                        continue;
+                value = usb_gadget_get_string(s, id, buf);
+                if (value > 0)
+                        return value;
+        }
+        return -EINVAL;
+}
+
+static int get_string(struct usb_composite_dev *cdev,
+                void *buf, u16 language, int id)
+{
+        struct usb_configuration        *c;
+        struct usb_function             *f;
+        int                             len;
+
+        /* Yes, not only is USB's I18N support probably more than most
+         * folk will ever care about ... also, it's all supported here.
+         * (Except for UTF8 support for Unicode's "Astral Planes".)
+         */
+
+        /* 0 == report all available language codes */
+        if (id == 0) {
+                struct usb_string_descriptor    *s = buf;
+                struct usb_gadget_strings       **sp;
+
+                memset(s, 0, 256);
+                s->bDescriptorType = USB_DT_STRING;
+
+                sp = composite->strings;
+                if (sp)
+                        collect_langs(sp, s->wData);
+
+                list_for_each_entry(c, &cdev->configs, list) {
+                        sp = c->strings;
+                        if (sp)
+                                collect_langs(sp, s->wData);
+
+                        list_for_each_entry(f, &c->functions, list) {
+                                sp = f->strings;
+                                if (sp)
+                                        collect_langs(sp, s->wData);
+                        }
+                }
+
+                for (len = 0; s->wData[len] && len <= 126; len++)
+                        continue;
+                if (!len)
+                        return -EINVAL;
+
+                s->bLength = 2 * (len + 1);
+                return s->bLength;
+        }
+
+        /* Otherwise, look up and return a specified string.  String IDs
+         * are device-scoped, so we look up each string table we're told
+         * about.  These lookups are infrequent; simpler-is-better here.
+         */
+        if (composite->strings) {
+                len = lookup_string(composite->strings, buf, language, id);
+                if (len > 0)
+                        return len;
+        }
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c->strings) {
+                        len = lookup_string(c->strings, buf, language, id);
+                        if (len > 0)
+                                return len;
+                }
+                list_for_each_entry(f, &c->functions, list) {
+                        if (!f->strings)
+                                continue;
+                        len = lookup_string(f->strings, buf, language, id);
+                        if (len > 0)
+                                return len;
+                }
+        }
+        return -EINVAL;
+}
+
+/**
+ * usb_string_id() - allocate an unused string ID
+ * @cdev: the device whose string descriptor IDs are being allocated
+ * Context: single threaded during gadget setup
+ *
+ * @usb_string_id() is called from bind() callbacks to allocate
+ * string IDs.  Drivers for functions, configurations, or gadgets will
+ * then store that ID in the appropriate descriptors and string table.
+ *
+ * All string identifier should be allocated using this routine, to
+ * ensure that for example different functions don't wrongly assign
+ * different meanings to the same identifier.
+ */
+int __init usb_string_id(struct usb_composite_dev *cdev)
+{
+        if (cdev->next_string_id < 254) {
+                /* string id 0 is reserved */
+                cdev->next_string_id++;
+                return cdev->next_string_id;
+        }
+        return -ENODEV;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        if (req->status || req->actual != req->length)
+                DBG((struct usb_composite_dev *) ep->driver_data,
+                                "setup complete --> %d, %d/%d\n",
+                                req->status, req->actual, req->length);
+}
+
+/*
+ * The setup() callback implements all the ep0 functionality that's
+ * not handled lower down, in hardware or the hardware driver(like
+ * device and endpoint feature flags, and their status).  It's all
+ * housekeeping for the gadget function we're implementing.  Most of
+ * the work is in config and function specific setup.
+ */
+static int
+composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_request              *req = cdev->req;
+        int                             value = -EOPNOTSUPP;
+        u16                             w_index = le16_to_cpu(ctrl->wIndex);
+        u16                             w_value = le16_to_cpu(ctrl->wValue);
+        u16                             w_length = le16_to_cpu(ctrl->wLength);
+        struct usb_function             *f = NULL;
+
+        /* partial re-init of the response message; the function or the
+         * gadget might need to intercept e.g. a control-OUT completion
+         * when we delegate to it.
+         */
+        req->zero = 0;
+        req->complete = composite_setup_complete;
+        req->length = USB_BUFSIZ;
+        gadget->ep0->driver_data = cdev;
+
+        switch (ctrl->bRequest) {
+
+        /* we handle all standard USB descriptors */
+        case USB_REQ_GET_DESCRIPTOR:
+                if (ctrl->bRequestType != USB_DIR_IN)
+                        goto unknown;
+                switch (w_value >> 8) {
+
+                case USB_DT_DEVICE:
+                        cdev->desc.bNumConfigurations =
+                                count_configs(cdev, USB_DT_DEVICE);
+                        value = min(w_length, (u16) sizeof cdev->desc);
+                        memcpy(req->buf, &cdev->desc, value);
+                        break;
+                case USB_DT_DEVICE_QUALIFIER:
+                        if (!gadget_is_dualspeed(gadget))
+                                break;
+                        device_qual(cdev);
+                        value = min_t(int, w_length,
+                                sizeof(struct usb_qualifier_descriptor));
+                        break;
+                case USB_DT_OTHER_SPEED_CONFIG:
+                        if (!gadget_is_dualspeed(gadget))
+                                break;
+                        /* FALLTHROUGH */
+                case USB_DT_CONFIG:
+                        value = config_desc(cdev, w_value);
+                        if (value >= 0)
+                                value = min(w_length, (u16) value);
+                        break;
+                case USB_DT_STRING:
+                        value = get_string(cdev, req->buf,
+                                        w_index, w_value & 0xff);
+                        if (value >= 0)
+                                value = min(w_length, (u16) value);
+                        break;
+                }
+                break;
+
+        /* any number of configs can work */
+        case USB_REQ_SET_CONFIGURATION:
+                if (ctrl->bRequestType != 0)
+                        goto unknown;
+                if (gadget_is_otg(gadget)) {
+                        if (gadget->a_hnp_support)
+                                DBG(cdev, "HNP available\n");
+                        else if (gadget->a_alt_hnp_support)
+                                DBG(cdev, "HNP on another port\n");
+                        else
+                                VDBG(cdev, "HNP inactive\n");
+                }
+                spin_lock(&cdev->lock);
+                value = set_config(cdev, ctrl, w_value);
+                spin_unlock(&cdev->lock);
+                break;
+        case USB_REQ_GET_CONFIGURATION:
+                if (ctrl->bRequestType != USB_DIR_IN)
+                        goto unknown;
+                if (cdev->config)
+                        *(u8 *)req->buf = cdev->config->bConfigurationValue;
+                else
+                        *(u8 *)req->buf = 0;
+                value = min(w_length, (u16) 1);
+                break;
+
+        /* function drivers must handle get/set altsetting; if there's
+         * no get() method, we know only altsetting zero works.
+         */
+        case USB_REQ_SET_INTERFACE:
+                if (ctrl->bRequestType != USB_RECIP_INTERFACE)
+                        goto unknown;
+                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                        break;
+                f = cdev->config->interface[w_index];
+                if (!f)
+                        break;
+                if (w_value && !f->get_alt)
+                        break;
+                value = f->set_alt(f, w_index, w_value);
+                break;
+        case USB_REQ_GET_INTERFACE:
+                if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
+                        goto unknown;
+                if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES)
+                        break;
+                f = cdev->config->interface[w_index];
+                if (!f)
+                        break;
+                /* lots of interfaces only need altsetting zero... */
+                value = f->get_alt ? f->get_alt(f, w_index) : 0;
+                if (value < 0)
+                        break;
+                *((u8 *)req->buf) = value;
+                value = min(w_length, (u16) 1);
+                break;
+        default:
+unknown:
+                VDBG(cdev,
+                        "non-core control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+
+                /* functions always handle their interfaces ... punt other
+                 * recipients (endpoint, other, WUSB, ...) to the current
+                 * configuration code.
+                 *
+                 * REVISIT it could make sense to let the composite device
+                 * take such requests too, if that's ever needed:  to work
+                 * in config 0, etc.
+                 */
+                if ((ctrl->bRequestType & USB_RECIP_MASK)
+                                == USB_RECIP_INTERFACE) {
+                        f = cdev->config->interface[w_index];
+                        if (f && f->setup)
+                                value = f->setup(f, ctrl);
+                        else
+                                f = NULL;
+                }
+                if (value < 0 && !f) {
+                        struct usb_configuration        *c;
+
+                        c = cdev->config;
+                        if (c && c->setup)
+                                value = c->setup(c, ctrl);
+                }
+
+                goto done;
+        }
+
+        /* respond with data transfer before status phase? */
+        if (value >= 0) {
+                req->length = value;
+                req->zero = value < w_length;
+                value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0) {
+                        DBG(cdev, "ep_queue --> %d\n", value);
+                        req->status = 0;
+                        composite_setup_complete(gadget->ep0, req);
+                }
+        }
+
+done:
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+static void composite_disconnect(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        unsigned long                   flags;
+
+        /* REVISIT:  should we have config and device level
+         * disconnect callbacks?
+         */
+        spin_lock_irqsave(&cdev->lock, flags);
+        if (cdev->config)
+                reset_config(cdev);
+        spin_unlock_irqrestore(&cdev->lock, flags);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void /* __init_or_exit */
+composite_unbind(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+
+        /* composite_disconnect() must already have been called
+         * by the underlying peripheral controller driver!
+         * so there's no i/o concurrency that could affect the
+         * state protected by cdev->lock.
+         */
+        WARN_ON(cdev->config);
+
+        while (!list_empty(&cdev->configs)) {
+                struct usb_configuration        *c;
+
+                c = list_first_entry(&cdev->configs,
+                                struct usb_configuration, list);
+                while (!list_empty(&c->functions)) {
+                        struct usb_function             *f;
+
+                        f = list_first_entry(&c->functions,
+                                        struct usb_function, list);
+                        list_del(&f->list);
+                        if (f->unbind) {
+                                DBG(cdev, "unbind function '%s'/%p\n",
+                                                f->name, f);
+                                f->unbind(c, f);
+                                /* may free memory for "f" */
+                        }
+                }
+                list_del(&c->list);
+                if (c->unbind) {
+                        DBG(cdev, "unbind config '%s'/%p\n", c->label, c);
+                        c->unbind(c);
+                        /* may free memory for "c" */
+                }
+        }
+        if (composite->unbind)
+                composite->unbind(cdev);
+
+        if (cdev->req) {
+                kfree(cdev->req->buf);
+                usb_ep_free_request(gadget->ep0, cdev->req);
+        }
+        kfree(cdev);
+        set_gadget_data(gadget, NULL);
+        composite = NULL;
+}
+
+static void __init
+string_override_one(struct usb_gadget_strings *tab, u8 id, const char *s)
+{
+        struct usb_string               *str = tab->strings;
+
+        for (str = tab->strings; str->s; str++) {
+                if (str->id == id) {
+                        str->s = s;
+                        return;
+                }
+        }
+}
+
+static void __init
+string_override(struct usb_gadget_strings **tab, u8 id, const char *s)
+{
+        while (*tab) {
+                string_override_one(*tab, id, s);
+                tab++;
+        }
+}
+
+static int __init composite_bind(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev;
+        int                             status = -ENOMEM;
+
+        cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
+        if (!cdev)
+                return status;
+
+        spin_lock_init(&cdev->lock);
+        cdev->gadget = gadget;
+        set_gadget_data(gadget, cdev);
+        INIT_LIST_HEAD(&cdev->configs);
+
+        /* preallocate control response and buffer */
+        cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
+        if (!cdev->req)
+                goto fail;
+        cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
+        if (!cdev->req->buf)
+                goto fail;
+        cdev->req->complete = composite_setup_complete;
+        gadget->ep0->driver_data = cdev;
+
+        cdev->bufsiz = USB_BUFSIZ;
+        cdev->driver = composite;
+
+        usb_gadget_set_selfpowered(gadget);
+
+        /* interface and string IDs start at zero via kzalloc.
+         * we force endpoints to start unassigned; few controller
+         * drivers will zero ep->driver_data.
+         */
+        usb_ep_autoconfig_reset(cdev->gadget);
+
+        /* composite gadget needs to assign strings for whole device (like
+         * serial number), register function drivers, potentially update
+         * power state and consumption, etc
+         */
+        status = composite->bind(cdev);
+        if (status < 0)
+                goto fail;
+
+        cdev->desc = *composite->dev;
+        cdev->desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
+
+        /* standardized runtime overrides for device ID data */
+        if (idVendor)
+                cdev->desc.idVendor = cpu_to_le16(idVendor);
+        if (idProduct)
+                cdev->desc.idProduct = cpu_to_le16(idProduct);
+        if (bcdDevice)
+                cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
+
+        /* strings can't be assigned before bind() allocates the
+         * releavnt identifiers
+         */
+        if (cdev->desc.iManufacturer && iManufacturer)
+                string_override(composite->strings,
+                        cdev->desc.iManufacturer, iManufacturer);
+        if (cdev->desc.iProduct && iProduct)
+                string_override(composite->strings,
+                        cdev->desc.iProduct, iProduct);
+        if (cdev->desc.iSerialNumber && iSerialNumber)
+                string_override(composite->strings,
+                        cdev->desc.iSerialNumber, iSerialNumber);
+
+        INFO(cdev, "%s ready\n", composite->name);
+        return 0;
+
+fail:
+        composite_unbind(gadget);
+        return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void
+composite_suspend(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_function             *f;
+
+        /* REVISIT:  should we have config and device level
+         * suspend/resume callbacks?
+         */
+        DBG(cdev, "suspend\n");
+        if (cdev->config) {
+                list_for_each_entry(f, &cdev->config->functions, list) {
+                        if (f->suspend)
+                                f->suspend(f);
+                }
+        }
+}
+
+static void
+composite_resume(struct usb_gadget *gadget)
+{
+        struct usb_composite_dev        *cdev = get_gadget_data(gadget);
+        struct usb_function             *f;
+
+        /* REVISIT:  should we have config and device level
+         * suspend/resume callbacks?
+         */
+        DBG(cdev, "resume\n");
+        if (cdev->config) {
+                list_for_each_entry(f, &cdev->config->functions, list) {
+                        if (f->resume)
+                                f->resume(f);
+                }
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_gadget_driver composite_driver = {
+        .speed          = USB_SPEED_HIGH,
+
+        .bind           = composite_bind,
+        .unbind         = __exit_p(composite_unbind),
+
+        .setup          = composite_setup,
+        .disconnect     = composite_disconnect,
+
+        .suspend        = composite_suspend,
+        .resume         = composite_resume,
+
+        .driver = {
+                .owner          = THIS_MODULE,
+        },
+};
+
+/**
+ * usb_composite_register() - register a composite driver
+ * @driver: the driver to register
+ * Context: single threaded during gadget setup
+ *
+ * This function is used to register drivers using the composite driver
+ * framework.  The return value is zero, or a negative errno value.
+ * Those values normally come from the driver's @bind method, which does
+ * all the work of setting up the driver to match the hardware.
+ *
+ * On successful return, the gadget is ready to respond to requests from
+ * the host, unless one of its components invokes usb_gadget_disconnect()
+ * while it was binding.  That would usually be done in order to wait for
+ * some userspace participation.
+ */
+int __init usb_composite_register(struct usb_composite_driver *driver)
+{
+        if (!driver || !driver->dev || !driver->bind || composite)
+                return -EINVAL;
+
+        if (!driver->name)
+                driver->name = "composite";
+        composite_driver.function =  (char *) driver->name;
+        composite_driver.driver.name = driver->name;
+        composite = driver;
+
+        return usb_gadget_register_driver(&composite_driver);
+}
+
+/**
+ * usb_composite_unregister() - unregister a composite driver
+ * @driver: the driver to unregister
+ *
+ * This function is used to unregister drivers using the composite
+ * driver framework.
+ */
+void __exit usb_composite_unregister(struct usb_composite_driver *driver)
+{
+        if (composite != driver)
+                return;
+        usb_gadget_unregister_driver(&composite_driver);
+}
diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
index a4e54b2743f0..1ca1c326392a 100644
--- a/drivers/usb/gadget/config.c
+++ b/drivers/usb/gadget/config.c
@@ -96,7 +96,7 @@ int usb_gadget_config_buf(
         /* config descriptor first */
         if (length < USB_DT_CONFIG_SIZE || !desc)
                 return -EINVAL;
-        *cp = *config; 
+        *cp = *config;
 
         /* then interface/endpoint/class/vendor/... */
         len = usb_descriptor_fillbuf(USB_DT_CONFIG_SIZE + (u8*)buf,
@@ -115,3 +115,77 @@ int usb_gadget_config_buf(
         return len;
 }
 
+/**
+ * usb_copy_descriptors - copy a vector of USB descriptors
+ * @src: null-terminated vector to copy
+ * Context: initialization code, which may sleep
+ *
+ * This makes a copy of a vector of USB descriptors.  Its primary use
+ * is to support usb_function objects which can have multiple copies,
+ * each needing different descriptors.  Functions may have static
+ * tables of descriptors, which are used as templates and customized
+ * with identifiers (for interfaces, strings, endpoints, and more)
+ * as needed by a given function instance.
+ */
+struct usb_descriptor_header **__init
+usb_copy_descriptors(struct usb_descriptor_header **src)
+{
+        struct usb_descriptor_header **tmp;
+        unsigned bytes;
+        unsigned n_desc;
+        void *mem;
+        struct usb_descriptor_header **ret;
+
+        /* count descriptors and their sizes; then add vector size */
+        for (bytes = 0, n_desc = 0, tmp = src; *tmp; tmp++, n_desc++)
+                bytes += (*tmp)->bLength;
+        bytes += (n_desc + 1) * sizeof(*tmp);
+
+        mem = kmalloc(bytes, GFP_KERNEL);
+        if (!mem)
+                return NULL;
+
+        /* fill in pointers starting at "tmp",
+         * to descriptors copied starting at "mem";
+         * and return "ret"
+         */
+        tmp = mem;
+        ret = mem;
+        mem += (n_desc + 1) * sizeof(*tmp);
+        while (*src) {
+                memcpy(mem, *src, (*src)->bLength);
+                *tmp = mem;
+                tmp++;
+                mem += (*src)->bLength;
+                src++;
+        }
+        *tmp = NULL;
+
+        return ret;
+}
+
+/**
+ * usb_find_endpoint - find a copy of an endpoint descriptor
+ * @src: original vector of descriptors
+ * @copy: copy of @src
+ * @ep: endpoint descriptor found in @src
+ *
+ * This returns the copy of the @match descriptor made for @copy.  Its
+ * intended use is to help remembering the endpoint descriptor to use
+ * when enabling a given endpoint.
+ */
+struct usb_endpoint_descriptor *__init
+usb_find_endpoint(
+        struct usb_descriptor_header **src,
+        struct usb_descriptor_header **copy,
+        struct usb_endpoint_descriptor *match
+)
+{
+        while (*src) {
+                if (*src == (void *) match)
+                        return (void *)*copy;
+                src++;
+                copy++;
+        }
+        return NULL;
+}
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 42036192a03c..21d1406af9ee 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -862,7 +862,7 @@ static int dummy_udc_probe (struct platform_device *pdev)
         /* maybe claim OTG support, though we won't complete HNP */
         dum->gadget.is_otg = (dummy_to_hcd(dum)->self.otg_port != 0);
 
-        strcpy (dum->gadget.dev.bus_id, "gadget");
+        dev_set_name(&dum->gadget.dev, "gadget");
         dum->gadget.dev.parent = &pdev->dev;
         dum->gadget.dev.release = dummy_gadget_release;
         rc = device_register (&dum->gadget.dev);
@@ -1865,7 +1865,7 @@ static int dummy_hcd_probe(struct platform_device *pdev)
 
         dev_info(&pdev->dev, "%s, driver " DRIVER_VERSION "\n", driver_desc);
 
-        hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(&dummy_hcd, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd)
                 return -ENOMEM;
         the_controller = hcd_to_dummy (hcd);
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 8bdad221fa91..9462e30192d8 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -159,6 +159,7 @@ ep_matches (
         /* MATCH!! */
 
         /* report address */
+        desc->bEndpointAddress &= USB_DIR_IN;
         if (isdigit (ep->name [2])) {
                 u8      num = simple_strtol (&ep->name [2], NULL, 10);
                 desc->bEndpointAddress |= num;
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index 4ce3950b997f..d7aaaa29b1e1 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -1,8 +1,9 @@
 /*
  * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
  *
- * Copyright (C) 2003-2005 David Brownell
+ * Copyright (C) 2003-2005,2008 David Brownell
  * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
  *
  * 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,18 +24,9 @@
 
 #include <linux/kernel.h>
 #include <linux/utsname.h>
-#include <linux/device.h>
-#include <linux/ctype.h>
-#include <linux/etherdevice.h>
-#include <linux/ethtool.h>
 
-#include <linux/usb/ch9.h>
-#include <linux/usb/cdc.h>
-#include <linux/usb/gadget.h>
+#include "u_ether.h"
 
-#include "gadget_chips.h"
-
-/*-------------------------------------------------------------------------*/
 
 /*
  * Ethernet gadget driver -- with CDC and non-CDC options
@@ -46,7 +38,11 @@
  * this USB-IF standard as its open-systems interoperability solution;
  * most host side USB stacks (except from Microsoft) support it.
  *
- * There's some hardware that can't talk CDC.  We make that hardware
+ * This is sometimes called "CDC ECM" (Ethernet Control Model) to support
+ * TLA-soup.  "CDC ACM" (Abstract Control Model) is for modems, and a new
+ * "CDC EEM" (Ethernet Emulation Model) is starting to spread.
+ *
+ * There's some hardware that can't talk CDC ECM.  We make that hardware
  * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
  * link-level setup only requires activating the configuration.  Only the
  * endpoint descriptors, and product/vendor IDs, are relevant; no control
@@ -64,70 +60,40 @@
  * A third option is also in use.  Rather than CDC Ethernet, or something
  * simpler, Microsoft pushes their own approach: RNDIS.  The published
  * RNDIS specs are ambiguous and appear to be incomplete, and are also
- * needlessly complex.
+ * needlessly complex.  They borrow more from CDC ACM than CDC ECM.
  */
 
 #define DRIVER_DESC             "Ethernet Gadget"
-#define DRIVER_VERSION          "May Day 2005"
-
-static const char shortname [] = "ether";
-static const char driver_desc [] = DRIVER_DESC;
-
-#define RX_EXTRA        20              /* guard against rx overflows */
-
-#include "rndis.h"
+#define DRIVER_VERSION          "Memorial Day 2008"
 
-#ifndef CONFIG_USB_ETH_RNDIS
-#define rndis_uninit(x)         do{}while(0)
-#define rndis_deregister(c)     do{}while(0)
-#define rndis_exit()            do{}while(0)
+#ifdef CONFIG_USB_ETH_RNDIS
+#define PREFIX                  "RNDIS/"
+#else
+#define PREFIX                  ""
 #endif
 
-/* CDC and RNDIS support the same host-chosen outgoing packet filters. */
-#define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
-                        |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
-                        |USB_CDC_PACKET_TYPE_PROMISCUOUS \
-                        |USB_CDC_PACKET_TYPE_DIRECTED)
-
-
-/*-------------------------------------------------------------------------*/
-
-struct eth_dev {
-        spinlock_t              lock;
-        struct usb_gadget       *gadget;
-        struct usb_request      *req;           /* for control responses */
-        struct usb_request      *stat_req;      /* for cdc & rndis status */
-
-        u8                      config;
-        struct usb_ep           *in_ep, *out_ep, *status_ep;
-        const struct usb_endpoint_descriptor
-                                *in, *out, *status;
-
-        spinlock_t              req_lock;
-        struct list_head        tx_reqs, rx_reqs;
-
-        struct net_device       *net;
-        struct net_device_stats stats;
-        atomic_t                tx_qlen;
-
-        struct work_struct      work;
-        unsigned                zlp:1;
-        unsigned                cdc:1;
-        unsigned                rndis:1;
-        unsigned                suspended:1;
-        u16                     cdc_filter;
-        unsigned long           todo;
-#define WORK_RX_MEMORY          0
-        int                     rndis_config;
-        u8                      host_mac [ETH_ALEN];
-};
-
-/* This version autoconfigures as much as possible at run-time.
+/*
+ * This driver aims for interoperability by using CDC ECM unless
+ *
+ *              can_support_ecm()
+ *
+ * returns false, in which case it supports the CDC Subset.  By default,
+ * that returns true; most hardware has no problems with CDC ECM, that's
+ * a good default.  Previous versions of this driver had no default; this
+ * version changes that, removing overhead for new controller support.
  *
- * It also ASSUMES a self-powered device, without remote wakeup,
- * although remote wakeup support would make sense.
+ *      IF YOUR HARDWARE CAN'T SUPPORT CDC ECM, UPDATE THAT ROUTINE!
  */
 
+static inline bool has_rndis(void)
+{
+#ifdef  CONFIG_USB_ETH_RNDIS
+        return true;
+#else
+        return false;
+#endif
+}
+
 /*-------------------------------------------------------------------------*/
 
 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
@@ -137,8 +103,8 @@ struct eth_dev {
 /* Thanks to NetChip Technologies for donating this product ID.
  * It's for devices with only CDC Ethernet configurations.
  */
-#define CDC_VENDOR_NUM  0x0525          /* NetChip */
-#define CDC_PRODUCT_NUM 0xa4a1          /* Linux-USB Ethernet Gadget */
+#define CDC_VENDOR_NUM          0x0525  /* NetChip */
+#define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
 
 /* For hardware that can't talk CDC, we use the same vendor ID that
  * ARM Linux has used for ethernet-over-usb, both with sa1100 and
@@ -162,274 +128,9 @@ struct eth_dev {
 #define RNDIS_VENDOR_NUM        0x0525  /* NetChip */
 #define RNDIS_PRODUCT_NUM       0xa4a2  /* Ethernet/RNDIS Gadget */
 
-
-/* Some systems will want different product identifers published in the
- * device descriptor, either numbers or strings or both.  These string
- * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
- */
-
-static ushort idVendor;
-module_param(idVendor, ushort, S_IRUGO);
-MODULE_PARM_DESC(idVendor, "USB Vendor ID");
-
-static ushort idProduct;
-module_param(idProduct, ushort, S_IRUGO);
-MODULE_PARM_DESC(idProduct, "USB Product ID");
-
-static ushort bcdDevice;
-module_param(bcdDevice, ushort, S_IRUGO);
-MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
-
-static char *iManufacturer;
-module_param(iManufacturer, charp, S_IRUGO);
-MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
-
-static char *iProduct;
-module_param(iProduct, charp, S_IRUGO);
-MODULE_PARM_DESC(iProduct, "USB Product string");
-
-static char *iSerialNumber;
-module_param(iSerialNumber, charp, S_IRUGO);
-MODULE_PARM_DESC(iSerialNumber, "SerialNumber");
-
-/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
-static char *dev_addr;
-module_param(dev_addr, charp, S_IRUGO);
-MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
-
-/* this address is invisible to ifconfig */
-static char *host_addr;
-module_param(host_addr, charp, S_IRUGO);
-MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
-
-
-/*-------------------------------------------------------------------------*/
-
-/* Include CDC support if we could run on CDC-capable hardware. */
-
-#ifdef CONFIG_USB_GADGET_NET2280
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_DUMMY_HCD
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_GOKU
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_LH7A40X
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_MQ11XX
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_OMAP
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_N9604
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_S3C2410
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_AT91
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_MUSBHSFC
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_MUSB_HDRC
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_ATMEL_USBA
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_FSL_USB2
-#define DEV_CONFIG_CDC
-#endif
-
-/* For CDC-incapable hardware, choose the simple cdc subset.
- * Anything that talks bulk (without notable bugs) can do this.
- */
-#ifdef CONFIG_USB_GADGET_PXA25X
-#define DEV_CONFIG_SUBSET
-#endif
-
-#ifdef CONFIG_USB_GADGET_PXA27X
-#define DEV_CONFIG_SUBSET
-#endif
-
-#ifdef CONFIG_USB_GADGET_SUPERH
-#define DEV_CONFIG_SUBSET
-#endif
-
-#ifdef CONFIG_USB_GADGET_SA1100
-/* use non-CDC for backwards compatibility */
-#define DEV_CONFIG_SUBSET
-#endif
-
-#ifdef CONFIG_USB_GADGET_M66592
-#define DEV_CONFIG_CDC
-#endif
-
-#ifdef CONFIG_USB_GADGET_AMD5536UDC
-#define DEV_CONFIG_CDC
-#endif
-
-
-/*-------------------------------------------------------------------------*/
-
-/* "main" config is either CDC, or its simple subset */
-static inline int is_cdc(struct eth_dev *dev)
-{
-#if     !defined(DEV_CONFIG_SUBSET)
-        return 1;               /* only cdc possible */
-#elif   !defined (DEV_CONFIG_CDC)
-        return 0;               /* only subset possible */
-#else
-        return dev->cdc;        /* depends on what hardware we found */
-#endif
-}
-
-/* "secondary" RNDIS config may sometimes be activated */
-static inline int rndis_active(struct eth_dev *dev)
-{
-#ifdef  CONFIG_USB_ETH_RNDIS
-        return dev->rndis;
-#else
-        return 0;
-#endif
-}
-
-#define subset_active(dev)      (!is_cdc(dev) && !rndis_active(dev))
-#define cdc_active(dev)         ( is_cdc(dev) && !rndis_active(dev))
-
-
-
-#define DEFAULT_QLEN    2       /* double buffering by default */
-
-/* peak bulk transfer bits-per-second */
-#define HS_BPS          (13 * 512 * 8 * 1000 * 8)
-#define FS_BPS          (19 *  64 * 1 * 1000 * 8)
-
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-#define DEVSPEED        USB_SPEED_HIGH
-
-static unsigned qmult = 5;
-module_param (qmult, uint, S_IRUGO|S_IWUSR);
-
-
-/* for dual-speed hardware, use deeper queues at highspeed */
-#define qlen(gadget) \
-        (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
-
-static inline int BITRATE(struct usb_gadget *g)
-{
-        return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;
-}
-
-#else   /* full speed (low speed doesn't do bulk) */
-
-#define qmult           1
-
-#define DEVSPEED        USB_SPEED_FULL
-
-#define qlen(gadget) DEFAULT_QLEN
-
-static inline int BITRATE(struct usb_gadget *g)
-{
-        return FS_BPS;
-}
-#endif
-
-
-/*-------------------------------------------------------------------------*/
-
-#define xprintk(d,level,fmt,args...) \
-        printk(level "%s: " fmt , (d)->net->name , ## args)
-
-#ifdef DEBUG
-#undef DEBUG
-#define DEBUG(dev,fmt,args...) \
-        xprintk(dev , KERN_DEBUG , fmt , ## args)
-#else
-#define DEBUG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-#ifdef VERBOSE_DEBUG
-#define VDEBUG  DEBUG
-#else
-#define VDEBUG(dev,fmt,args...) \
-        do { } while (0)
-#endif /* DEBUG */
-
-#define ERROR(dev,fmt,args...) \
-        xprintk(dev , KERN_ERR , fmt , ## args)
-#define WARN(dev,fmt,args...) \
-        xprintk(dev , KERN_WARNING , fmt , ## args)
-#define INFO(dev,fmt,args...) \
-        xprintk(dev , KERN_INFO , fmt , ## args)
-
 /*-------------------------------------------------------------------------*/
 
-/* USB DRIVER HOOKUP (to the hardware driver, below us), mostly
- * ep0 implementation:  descriptors, config management, setup().
- * also optional class-specific notification interrupt transfer.
- */
-
-/*
- * DESCRIPTORS ... most are static, but strings and (full) configuration
- * descriptors are built on demand.  For now we do either full CDC, or
- * our simple subset, with RNDIS as an optional second configuration.
- *
- * RNDIS includes some CDC ACM descriptors ... like CDC Ethernet.  But
- * the class descriptors match a modem (they're ignored; it's really just
- * Ethernet functionality), they don't need the NOP altsetting, and the
- * status transfer endpoint isn't optional.
- */
-
-#define STRING_MANUFACTURER             1
-#define STRING_PRODUCT                  2
-#define STRING_ETHADDR                  3
-#define STRING_DATA                     4
-#define STRING_CONTROL                  5
-#define STRING_RNDIS_CONTROL            6
-#define STRING_CDC                      7
-#define STRING_SUBSET                   8
-#define STRING_RNDIS                    9
-#define STRING_SERIALNUMBER             10
-
-/* holds our biggest descriptor (or RNDIS response) */
-#define USB_BUFSIZ      256
-
-/*
- * This device advertises one configuration, eth_config, unless RNDIS
- * is enabled (rndis_config) on hardware supporting at least two configs.
- *
- * NOTE:  Controllers like superh_udc should probably be able to use
- * an RNDIS-only configuration.
- *
- * FIXME define some higher-powered configurations to make it easier
- * to recharge batteries ...
- */
-
-#define DEV_CONFIG_VALUE        1       /* cdc or subset */
-#define DEV_RNDIS_CONFIG_VALUE  2       /* rndis; optional */
-
-static struct usb_device_descriptor
-device_desc = {
+static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
         .bDescriptorType =      USB_DT_DEVICE,
 
@@ -438,2220 +139,234 @@ device_desc = {
         .bDeviceClass =         USB_CLASS_COMM,
         .bDeviceSubClass =      0,
         .bDeviceProtocol =      0,
+        /* .bMaxPacketSize0 = f(hardware) */
 
+        /* Vendor and product id defaults change according to what configs
+         * we support.  (As does bNumConfigurations.)  These values can
+         * also be overridden by module parameters.
+         */
         .idVendor =             __constant_cpu_to_le16 (CDC_VENDOR_NUM),
         .idProduct =            __constant_cpu_to_le16 (CDC_PRODUCT_NUM),
-        .iManufacturer =        STRING_MANUFACTURER,
-        .iProduct =             STRING_PRODUCT,
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        /* NO SERIAL NUMBER */
         .bNumConfigurations =   1,
 };
 
-static struct usb_otg_descriptor
-otg_descriptor = {
+static struct usb_otg_descriptor otg_descriptor = {
         .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
 
-        .bmAttributes =         USB_OTG_SRP,
-};
-
-static struct usb_config_descriptor
-eth_config = {
-        .bLength =              sizeof eth_config,
-        .bDescriptorType =      USB_DT_CONFIG,
-
-        /* compute wTotalLength on the fly */
-        .bNumInterfaces =       2,
-        .bConfigurationValue =  DEV_CONFIG_VALUE,
-        .iConfiguration =       STRING_CDC,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            50,
-};
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-static struct usb_config_descriptor
-rndis_config = {
-        .bLength =              sizeof rndis_config,
-        .bDescriptorType =      USB_DT_CONFIG,
-
-        /* compute wTotalLength on the fly */
-        .bNumInterfaces =       2,
-        .bConfigurationValue =  DEV_RNDIS_CONFIG_VALUE,
-        .iConfiguration =       STRING_RNDIS,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            50,
-};
-#endif
-
-/*
- * Compared to the simple CDC subset, the full CDC Ethernet model adds
- * three class descriptors, two interface descriptors, optional status
- * endpoint.  Both have a "data" interface and two bulk endpoints.
- * There are also differences in how control requests are handled.
- *
- * RNDIS shares a lot with CDC-Ethernet, since it's a variant of the
- * CDC-ACM (modem) spec.  Unfortunately MSFT's RNDIS driver is buggy; it
- * may hang or oops.  Since bugfixes (or accurate specs, letting Linux
- * work around those bugs) are unlikely to ever come from MSFT, you may
- * wish to avoid using RNDIS.
- *
- * MCCI offers an alternative to RNDIS if you need to connect to Windows
- * but have hardware that can't support CDC Ethernet.   We add descriptors
- * to present the CDC Subset as a (nonconformant) CDC MDLM variant called
- * "SAFE".  That borrows from both CDC Ethernet and CDC MDLM.  You can
- * get those drivers from MCCI, or bundled with various products.
- */
-
-#ifdef  DEV_CONFIG_CDC
-static struct usb_interface_descriptor
-control_intf = {
-        .bLength =              sizeof control_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     0,
-        /* status endpoint is optional; this may be patched later */
-        .bNumEndpoints =        1,
-        .bInterfaceClass =      USB_CLASS_COMM,
-        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ETHERNET,
-        .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
-        .iInterface =           STRING_CONTROL,
-};
-#endif
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-static const struct usb_interface_descriptor
-rndis_control_intf = {
-        .bLength =              sizeof rndis_control_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     0,
-        .bNumEndpoints =        1,
-        .bInterfaceClass =      USB_CLASS_COMM,
-        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
-        .bInterfaceProtocol =   USB_CDC_ACM_PROTO_VENDOR,
-        .iInterface =           STRING_RNDIS_CONTROL,
-};
-#endif
-
-static const struct usb_cdc_header_desc header_desc = {
-        .bLength =              sizeof header_desc,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-
-        .bcdCDC =               __constant_cpu_to_le16 (0x0110),
-};
-
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-
-static const struct usb_cdc_union_desc union_desc = {
-        .bLength =              sizeof union_desc,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
-
-        .bMasterInterface0 =    0,      /* index of control interface */
-        .bSlaveInterface0 =     1,      /* index of DATA interface */
-};
-
-#endif  /* CDC || RNDIS */
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-
-static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {
-        .bLength =              sizeof call_mgmt_descriptor,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
-
-        .bmCapabilities =       0x00,
-        .bDataInterface =       0x01,
-};
-
-static const struct usb_cdc_acm_descriptor acm_descriptor = {
-        .bLength =              sizeof acm_descriptor,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
-
-        .bmCapabilities =       0x00,
-};
-
-#endif
-
-#ifndef DEV_CONFIG_CDC
-
-/* "SAFE" loosely follows CDC WMC MDLM, violating the spec in various
- * ways:  data endpoints live in the control interface, there's no data
- * interface, and it's not used to talk to a cell phone radio.
- */
-
-static const struct usb_cdc_mdlm_desc mdlm_desc = {
-        .bLength =              sizeof mdlm_desc,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
-
-        .bcdVersion =           __constant_cpu_to_le16(0x0100),
-        .bGUID = {
-                0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
-                0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
-        },
-};
-
-/* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
- * can't really use its struct.  All we do here is say that we're using
- * the submode of "SAFE" which directly matches the CDC Subset.
- */
-static const u8 mdlm_detail_desc[] = {
-        6,
-        USB_DT_CS_INTERFACE,
-        USB_CDC_MDLM_DETAIL_TYPE,
-
-        0,      /* "SAFE" */
-        0,      /* network control capabilities (none) */
-        0,      /* network data capabilities ("raw" encapsulation) */
-};
-
-#endif
-
-static const struct usb_cdc_ether_desc ether_desc = {
-        .bLength =              sizeof ether_desc,
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
-
-        /* this descriptor actually adds value, surprise! */
-        .iMACAddress =          STRING_ETHADDR,
-        .bmEthernetStatistics = __constant_cpu_to_le32 (0), /* no statistics */
-        .wMaxSegmentSize =      __constant_cpu_to_le16 (ETH_FRAME_LEN),
-        .wNumberMCFilters =     __constant_cpu_to_le16 (0),
-        .bNumberPowerFilters =  0,
-};
-
-
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-
-/* include the status endpoint if we can, even where it's optional.
- * use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
- * packet, to simplify cancellation; and a big transfer interval, to
- * waste less bandwidth.
- *
- * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
- * if they ignore the connect/disconnect notifications that real aether
- * can provide.  more advanced cdc configurations might want to support
- * encapsulated commands (vendor-specific, using control-OUT).
- *
- * RNDIS requires the status endpoint, since it uses that encapsulation
- * mechanism for its funky RPC scheme.
- */
-
-#define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
-#define STATUS_BYTECOUNT                16      /* 8 byte header + data */
-
-static struct usb_endpoint_descriptor
-fs_status_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (STATUS_BYTECOUNT),
-        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
-};
-#endif
-
-#ifdef  DEV_CONFIG_CDC
-
-/* the default data interface has no endpoints ... */
-
-static const struct usb_interface_descriptor
-data_nop_intf = {
-        .bLength =              sizeof data_nop_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     1,
-        .bAlternateSetting =    0,
-        .bNumEndpoints =        0,
-        .bInterfaceClass =      USB_CLASS_CDC_DATA,
-        .bInterfaceSubClass =   0,
-        .bInterfaceProtocol =   0,
-};
-
-/* ... but the "real" data interface has two bulk endpoints */
-
-static const struct usb_interface_descriptor
-data_intf = {
-        .bLength =              sizeof data_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     1,
-        .bAlternateSetting =    1,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_CDC_DATA,
-        .bInterfaceSubClass =   0,
-        .bInterfaceProtocol =   0,
-        .iInterface =           STRING_DATA,
-};
-
-#endif
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-
-/* RNDIS doesn't activate by changing to the "real" altsetting */
-
-static const struct usb_interface_descriptor
-rndis_data_intf = {
-        .bLength =              sizeof rndis_data_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     1,
-        .bAlternateSetting =    0,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_CDC_DATA,
-        .bInterfaceSubClass =   0,
-        .bInterfaceProtocol =   0,
-        .iInterface =           STRING_DATA,
-};
-
-#endif
-
-#ifdef DEV_CONFIG_SUBSET
-
-/*
- * "Simple" CDC-subset option is a simple vendor-neutral model that most
- * full speed controllers can handle:  one interface, two bulk endpoints.
- *
- * To assist host side drivers, we fancy it up a bit, and add descriptors
- * so some host side drivers will understand it as a "SAFE" variant.
- */
-
-static const struct usb_interface_descriptor
-subset_data_intf = {
-        .bLength =              sizeof subset_data_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bInterfaceNumber =     0,
-        .bAlternateSetting =    0,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_COMM,
-        .bInterfaceSubClass =   USB_CDC_SUBCLASS_MDLM,
-        .bInterfaceProtocol =   0,
-        .iInterface =           STRING_DATA,
-};
-
-#endif  /* SUBSET */
-
-
-static struct usb_endpoint_descriptor
-fs_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-};
-
-static struct usb_endpoint_descriptor
-fs_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
 };
 
-static const struct usb_descriptor_header *fs_eth_function [11] = {
+static const struct usb_descriptor_header *otg_desc[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
-#ifdef DEV_CONFIG_CDC
-        /* "cdc" mode descriptors */
-        (struct usb_descriptor_header *) &control_intf,
-        (struct usb_descriptor_header *) &header_desc,
-        (struct usb_descriptor_header *) &union_desc,
-        (struct usb_descriptor_header *) &ether_desc,
-        /* NOTE: status endpoint may need to be removed */
-        (struct usb_descriptor_header *) &fs_status_desc,
-        /* data interface, with altsetting */
-        (struct usb_descriptor_header *) &data_nop_intf,
-        (struct usb_descriptor_header *) &data_intf,
-        (struct usb_descriptor_header *) &fs_source_desc,
-        (struct usb_descriptor_header *) &fs_sink_desc,
         NULL,
-#endif /* DEV_CONFIG_CDC */
 };
 
-static inline void __init fs_subset_descriptors(void)
-{
-#ifdef DEV_CONFIG_SUBSET
-        /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
-        fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
-        fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
-        fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
-        fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
-        fs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
-        fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;
-        fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;
-        fs_eth_function[8] = NULL;
-#else
-        fs_eth_function[1] = NULL;
-#endif
-}
 
-#ifdef  CONFIG_USB_ETH_RNDIS
-static const struct usb_descriptor_header *fs_rndis_function [] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-        /* control interface matches ACM, not Ethernet */
-        (struct usb_descriptor_header *) &rndis_control_intf,
-        (struct usb_descriptor_header *) &header_desc,
-        (struct usb_descriptor_header *) &call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &acm_descriptor,
-        (struct usb_descriptor_header *) &union_desc,
-        (struct usb_descriptor_header *) &fs_status_desc,
-        /* data interface has no altsetting */
-        (struct usb_descriptor_header *) &rndis_data_intf,
-        (struct usb_descriptor_header *) &fs_source_desc,
-        (struct usb_descriptor_header *) &fs_sink_desc,
-        NULL,
-};
-#endif
-
-/*
- * usb 2.0 devices need to expose both high speed and full speed
- * descriptors, unless they only run at full speed.
- */
-
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-static struct usb_endpoint_descriptor
-hs_status_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (STATUS_BYTECOUNT),
-        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
-};
-#endif /* DEV_CONFIG_CDC */
-
-static struct usb_endpoint_descriptor
-hs_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (512),
-};
-
-static struct usb_endpoint_descriptor
-hs_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16 (512),
-};
+/* string IDs are assigned dynamically */
 
-static struct usb_qualifier_descriptor
-dev_qualifier = {
-        .bLength =              sizeof dev_qualifier,
-        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
 
-        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
-        .bDeviceClass =         USB_CLASS_COMM,
+static char manufacturer[50];
 
-        .bNumConfigurations =   1,
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = PREFIX DRIVER_DESC,
+        {  } /* end of list */
 };
 
-static const struct usb_descriptor_header *hs_eth_function [11] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-#ifdef DEV_CONFIG_CDC
-        /* "cdc" mode descriptors */
-        (struct usb_descriptor_header *) &control_intf,
-        (struct usb_descriptor_header *) &header_desc,
-        (struct usb_descriptor_header *) &union_desc,
-        (struct usb_descriptor_header *) &ether_desc,
-        /* NOTE: status endpoint may need to be removed */
-        (struct usb_descriptor_header *) &hs_status_desc,
-        /* data interface, with altsetting */
-        (struct usb_descriptor_header *) &data_nop_intf,
-        (struct usb_descriptor_header *) &data_intf,
-        (struct usb_descriptor_header *) &hs_source_desc,
-        (struct usb_descriptor_header *) &hs_sink_desc,
-        NULL,
-#endif /* DEV_CONFIG_CDC */
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
 };
 
-static inline void __init hs_subset_descriptors(void)
-{
-#ifdef DEV_CONFIG_SUBSET
-        /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
-        hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
-        hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
-        hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
-        hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
-        hs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
-        hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;
-        hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;
-        hs_eth_function[8] = NULL;
-#else
-        hs_eth_function[1] = NULL;
-#endif
-}
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-static const struct usb_descriptor_header *hs_rndis_function [] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-        /* control interface matches ACM, not Ethernet */
-        (struct usb_descriptor_header *) &rndis_control_intf,
-        (struct usb_descriptor_header *) &header_desc,
-        (struct usb_descriptor_header *) &call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &acm_descriptor,
-        (struct usb_descriptor_header *) &union_desc,
-        (struct usb_descriptor_header *) &hs_status_desc,
-        /* data interface has no altsetting */
-        (struct usb_descriptor_header *) &rndis_data_intf,
-        (struct usb_descriptor_header *) &hs_source_desc,
-        (struct usb_descriptor_header *) &hs_sink_desc,
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
         NULL,
 };
-#endif
-
-
-/* maxpacket and other transfer characteristics vary by speed. */
-static inline struct usb_endpoint_descriptor *
-ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
-                struct usb_endpoint_descriptor *fs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
 
+static u8 hostaddr[ETH_ALEN];
 
 /*-------------------------------------------------------------------------*/
 
-/* descriptors that are built on-demand */
-
-static char                             manufacturer [50];
-static char                             product_desc [40] = DRIVER_DESC;
-static char                             serial_number [20];
-
-/* address that the host will use ... usually assigned at random */
-static char                             ethaddr [2 * ETH_ALEN + 1];
-
-/* static strings, in UTF-8 */
-static struct usb_string                strings [] = {
-        { STRING_MANUFACTURER,  manufacturer, },
-        { STRING_PRODUCT,       product_desc, },
-        { STRING_SERIALNUMBER,  serial_number, },
-        { STRING_DATA,          "Ethernet Data", },
-        { STRING_ETHADDR,       ethaddr, },
-#ifdef  DEV_CONFIG_CDC
-        { STRING_CDC,           "CDC Ethernet", },
-        { STRING_CONTROL,       "CDC Communications Control", },
-#endif
-#ifdef  DEV_CONFIG_SUBSET
-        { STRING_SUBSET,        "CDC Ethernet Subset", },
-#endif
-#ifdef  CONFIG_USB_ETH_RNDIS
-        { STRING_RNDIS,         "RNDIS", },
-        { STRING_RNDIS_CONTROL, "RNDIS Communications Control", },
-#endif
-        {  }            /* end of list */
-};
-
-static struct usb_gadget_strings        stringtab = {
-        .language       = 0x0409,       /* en-us */
-        .strings        = strings,
-};
-
 /*
- * one config, two interfaces:  control, data.
- * complications: class descriptors, and an altsetting.
- */
-static int
-config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
-{
-        int                                     len;
-        const struct usb_config_descriptor      *config;
-        const struct usb_descriptor_header      **function;
-        int                                     hs = 0;
-
-        if (gadget_is_dualspeed(g)) {
-                hs = (g->speed == USB_SPEED_HIGH);
-                if (type == USB_DT_OTHER_SPEED_CONFIG)
-                        hs = !hs;
-        }
-#define which_fn(t)     (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
-
-        if (index >= device_desc.bNumConfigurations)
-                return -EINVAL;
-
-#ifdef  CONFIG_USB_ETH_RNDIS
-        /* list the RNDIS config first, to make Microsoft's drivers
-         * happy. DOCSIS 1.0 needs this too.
-         */
-        if (device_desc.bNumConfigurations == 2 && index == 0) {
-                config = &rndis_config;
-                function = which_fn (rndis);
-        } else
-#endif
-        {
-                config = &eth_config;
-                function = which_fn (eth);
-        }
-
-        /* for now, don't advertise srp-only devices */
-        if (!is_otg)
-                function++;
-
-        len = usb_gadget_config_buf (config, buf, USB_BUFSIZ, function);
-        if (len < 0)
-                return len;
-        ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
-        return len;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static void eth_start (struct eth_dev *dev, gfp_t gfp_flags);
-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
-
-static int
-set_ether_config (struct eth_dev *dev, gfp_t gfp_flags)
-{
-        int                                     result = 0;
-        struct usb_gadget                       *gadget = dev->gadget;
-
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-        /* status endpoint used for RNDIS and (optionally) CDC */
-        if (!subset_active(dev) && dev->status_ep) {
-                dev->status = ep_desc (gadget, &hs_status_desc,
-                                                &fs_status_desc);
-                dev->status_ep->driver_data = dev;
-
-                result = usb_ep_enable (dev->status_ep, dev->status);
-                if (result != 0) {
-                        DEBUG (dev, "enable %s --> %d\n",
-                                dev->status_ep->name, result);
-                        goto done;
-                }
-        }
-#endif
-
-        dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
-        dev->in_ep->driver_data = dev;
-
-        dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
-        dev->out_ep->driver_data = dev;
-
-        /* With CDC,  the host isn't allowed to use these two data
-         * endpoints in the default altsetting for the interface.
-         * so we don't activate them yet.  Reset from SET_INTERFACE.
-         *
-         * Strictly speaking RNDIS should work the same: activation is
-         * a side effect of setting a packet filter.  Deactivation is
-         * from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.
-         */
-        if (!cdc_active(dev)) {
-                result = usb_ep_enable (dev->in_ep, dev->in);
-                if (result != 0) {
-                        DEBUG(dev, "enable %s --> %d\n",
-                                dev->in_ep->name, result);
-                        goto done;
-                }
-
-                result = usb_ep_enable (dev->out_ep, dev->out);
-                if (result != 0) {
-                        DEBUG (dev, "enable %s --> %d\n",
-                                dev->out_ep->name, result);
-                        goto done;
-                }
-        }
-
-done:
-        if (result == 0)
-                result = alloc_requests (dev, qlen (gadget), gfp_flags);
-
-        /* on error, disable any endpoints  */
-        if (result < 0) {
-                if (!subset_active(dev) && dev->status_ep)
-                        (void) usb_ep_disable (dev->status_ep);
-                dev->status = NULL;
-                (void) usb_ep_disable (dev->in_ep);
-                (void) usb_ep_disable (dev->out_ep);
-                dev->in = NULL;
-                dev->out = NULL;
-        }
-
-        /* activate non-CDC configs right away
-         * this isn't strictly according to the RNDIS spec
-         */
-        else if (!cdc_active (dev)) {
-                netif_carrier_on (dev->net);
-                if (netif_running (dev->net)) {
-                        spin_unlock (&dev->lock);
-                        eth_start (dev, GFP_ATOMIC);
-                        spin_lock (&dev->lock);
-                }
-        }
-
-        if (result == 0)
-                DEBUG (dev, "qlen %d\n", qlen (gadget));
-
-        /* caller is responsible for cleanup on error */
-        return result;
-}
-
-static void eth_reset_config (struct eth_dev *dev)
-{
-        struct usb_request      *req;
-
-        if (dev->config == 0)
-                return;
-
-        DEBUG (dev, "%s\n", __func__);
-
-        netif_stop_queue (dev->net);
-        netif_carrier_off (dev->net);
-        rndis_uninit(dev->rndis_config);
-
-        /* disable endpoints, forcing (synchronous) completion of
-         * pending i/o.  then free the requests.
-         */
-        if (dev->in) {
-                usb_ep_disable (dev->in_ep);
-                spin_lock(&dev->req_lock);
-                while (likely (!list_empty (&dev->tx_reqs))) {
-                        req = container_of (dev->tx_reqs.next,
-                                                struct usb_request, list);
-                        list_del (&req->list);
-
-                        spin_unlock(&dev->req_lock);
-                        usb_ep_free_request (dev->in_ep, req);
-                        spin_lock(&dev->req_lock);
-                }
-                spin_unlock(&dev->req_lock);
-        }
-        if (dev->out) {
-                usb_ep_disable (dev->out_ep);
-                spin_lock(&dev->req_lock);
-                while (likely (!list_empty (&dev->rx_reqs))) {
-                        req = container_of (dev->rx_reqs.next,
-                                                struct usb_request, list);
-                        list_del (&req->list);
-
-                        spin_unlock(&dev->req_lock);
-                        usb_ep_free_request (dev->out_ep, req);
-                        spin_lock(&dev->req_lock);
-                }
-                spin_unlock(&dev->req_lock);
-        }
-
-        if (dev->status) {
-                usb_ep_disable (dev->status_ep);
-        }
-        dev->rndis = 0;
-        dev->cdc_filter = 0;
-        dev->config = 0;
-}
-
-/* change our operational config.  must agree with the code
- * that returns config descriptors, and altsetting code.
+ * We may not have an RNDIS configuration, but if we do it needs to be
+ * the first one present.  That's to make Microsoft's drivers happy,
+ * and to follow DOCSIS 1.0 (cable modem standard).
  */
-static int
-eth_set_config (struct eth_dev *dev, unsigned number, gfp_t gfp_flags)
+static int __init rndis_do_config(struct usb_configuration *c)
 {
-        int                     result = 0;
-        struct usb_gadget       *gadget = dev->gadget;
-
-        if (gadget_is_sa1100 (gadget)
-                        && dev->config
-                        && atomic_read (&dev->tx_qlen) != 0) {
-                /* tx fifo is full, but we can't clear it...*/
-                INFO (dev, "can't change configurations\n");
-                return -ESPIPE;
-        }
-        eth_reset_config (dev);
-
-        switch (number) {
-        case DEV_CONFIG_VALUE:
-                result = set_ether_config (dev, gfp_flags);
-                break;
-#ifdef  CONFIG_USB_ETH_RNDIS
-        case DEV_RNDIS_CONFIG_VALUE:
-                dev->rndis = 1;
-                result = set_ether_config (dev, gfp_flags);
-                break;
-#endif
-        default:
-                result = -EINVAL;
-                /* FALL THROUGH */
-        case 0:
-                break;
-        }
-
-        if (result) {
-                if (number)
-                        eth_reset_config (dev);
-                usb_gadget_vbus_draw(dev->gadget,
-                                gadget_is_otg(dev->gadget) ? 8 : 100);
-        } else {
-                char *speed;
-                unsigned power;
-
-                power = 2 * eth_config.bMaxPower;
-                usb_gadget_vbus_draw(dev->gadget, power);
+        /* FIXME alloc iConfiguration string, set it in c->strings */
 
-                switch (gadget->speed) {
-                case USB_SPEED_FULL:    speed = "full"; break;
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-                case USB_SPEED_HIGH:    speed = "high"; break;
-#endif
-                default:                speed = "?"; break;
-                }
-
-                dev->config = number;
-                INFO (dev, "%s speed config #%d: %d mA, %s, using %s\n",
-                                speed, number, power, driver_desc,
-                                rndis_active(dev)
-                                        ? "RNDIS"
-                                        : (cdc_active(dev)
-                                                ? "CDC Ethernet"
-                                                : "CDC Ethernet Subset"));
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
-        return result;
-}
-
-/*-------------------------------------------------------------------------*/
-
-#ifdef  DEV_CONFIG_CDC
 
-/* The interrupt endpoint is used in CDC networking models (Ethernet, ATM)
- * only to notify the host about link status changes (which we support) or
- * report completion of some encapsulated command (as used in RNDIS).  Since
- * we want this CDC Ethernet code to be vendor-neutral, we don't use that
- * command mechanism; and only one status request is ever queued.
- */
-
-static void eth_status_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        struct usb_cdc_notification     *event = req->buf;
-        int                             value = req->status;
-        struct eth_dev                  *dev = ep->driver_data;
-
-        /* issue the second notification if host reads the first */
-        if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION
-                        && value == 0) {
-                __le32  *data = req->buf + sizeof *event;
-
-                event->bmRequestType = 0xA1;
-                event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
-                event->wValue = __constant_cpu_to_le16 (0);
-                event->wIndex = __constant_cpu_to_le16 (1);
-                event->wLength = __constant_cpu_to_le16 (8);
-
-                /* SPEED_CHANGE data is up/down speeds in bits/sec */
-                data [0] = data [1] = cpu_to_le32 (BITRATE (dev->gadget));
-
-                req->length = STATUS_BYTECOUNT;
-                value = usb_ep_queue (ep, req, GFP_ATOMIC);
-                DEBUG (dev, "send SPEED_CHANGE --> %d\n", value);
-                if (value == 0)
-                        return;
-        } else if (value != -ECONNRESET)
-                DEBUG (dev, "event %02x --> %d\n",
-                        event->bNotificationType, value);
-        req->context = NULL;
+        return rndis_bind_config(c, hostaddr);
 }
 
-static void issue_start_status (struct eth_dev *dev)
-{
-        struct usb_request              *req = dev->stat_req;
-        struct usb_cdc_notification     *event;
-        int                             value;
-
-        DEBUG (dev, "%s, flush old status first\n", __func__);
-
-        /* flush old status
-         *
-         * FIXME ugly idiom, maybe we'd be better with just
-         * a "cancel the whole queue" primitive since any
-         * unlink-one primitive has way too many error modes.
-         * here, we "know" toggle is already clear...
-         *
-         * FIXME iff req->context != null just dequeue it
-         */
-        usb_ep_disable (dev->status_ep);
-        usb_ep_enable (dev->status_ep, dev->status);
-
-        /* 3.8.1 says to issue first NETWORK_CONNECTION, then
-         * a SPEED_CHANGE.  could be useful in some configs.
-         */
-        event = req->buf;
-        event->bmRequestType = 0xA1;
-        event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
-        event->wValue = __constant_cpu_to_le16 (1);     /* connected */
-        event->wIndex = __constant_cpu_to_le16 (1);
-        event->wLength = 0;
-
-        req->length = sizeof *event;
-        req->complete = eth_status_complete;
-        req->context = dev;
-
-        value = usb_ep_queue (dev->status_ep, req, GFP_ATOMIC);
-        if (value < 0)
-                DEBUG (dev, "status buf queue --> %d\n", value);
-}
-
-#endif
+static struct usb_configuration rndis_config_driver = {
+        .label                  = "RNDIS",
+        .bind                   = rndis_do_config,
+        .bConfigurationValue    = 2,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower              = 1,    /* 2 mA, minimal */
+};
 
 /*-------------------------------------------------------------------------*/
 
-static void eth_setup_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        if (req->status || req->actual != req->length)
-                DEBUG ((struct eth_dev *) ep->driver_data,
-                                "setup complete --> %d, %d/%d\n",
-                                req->status, req->actual, req->length);
-}
-
-#ifdef CONFIG_USB_ETH_RNDIS
-
-static void rndis_response_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        if (req->status || req->actual != req->length)
-                DEBUG ((struct eth_dev *) ep->driver_data,
-                        "rndis response complete --> %d, %d/%d\n",
-                        req->status, req->actual, req->length);
-
-        /* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */
-}
-
-static void rndis_command_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        struct eth_dev          *dev = ep->driver_data;
-        int                     status;
-
-        /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
-        spin_lock(&dev->lock);
-        status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf);
-        if (status < 0)
-                ERROR(dev, "%s: rndis parse error %d\n", __func__, status);
-        spin_unlock(&dev->lock);
-}
-
-#endif  /* RNDIS */
-
 /*
- * The setup() callback implements all the ep0 functionality that's not
- * handled lower down.  CDC has a number of less-common features:
- *
- *  - two interfaces:  control, and ethernet data
- *  - Ethernet data interface has two altsettings:  default, and active
- *  - class-specific descriptors for the control interface
- *  - class-specific control requests
+ * We _always_ have an ECM or CDC Subset configuration.
  */
-static int
-eth_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
+static int __init eth_do_config(struct usb_configuration *c)
 {
-        struct eth_dev          *dev = get_gadget_data (gadget);
-        struct usb_request      *req = dev->req;
-        int                     value = -EOPNOTSUPP;
-        u16                     wIndex = le16_to_cpu(ctrl->wIndex);
-        u16                     wValue = le16_to_cpu(ctrl->wValue);
-        u16                     wLength = le16_to_cpu(ctrl->wLength);
-
-        /* descriptors just go into the pre-allocated ep0 buffer,
-         * while config change events may enable network traffic.
-         */
-        req->complete = eth_setup_complete;
-        switch (ctrl->bRequest) {
-
-        case USB_REQ_GET_DESCRIPTOR:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        break;
-                switch (wValue >> 8) {
-
-                case USB_DT_DEVICE:
-                        value = min (wLength, (u16) sizeof device_desc);
-                        memcpy (req->buf, &device_desc, value);
-                        break;
-                case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        value = min (wLength, (u16) sizeof dev_qualifier);
-                        memcpy (req->buf, &dev_qualifier, value);
-                        break;
-
-                case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        // FALLTHROUGH
-                case USB_DT_CONFIG:
-                        value = config_buf(gadget, req->buf,
-                                        wValue >> 8,
-                                        wValue & 0xff,
-                                        gadget_is_otg(gadget));
-                        if (value >= 0)
-                                value = min (wLength, (u16) value);
-                        break;
-
-                case USB_DT_STRING:
-                        value = usb_gadget_get_string (&stringtab,
-                                        wValue & 0xff, req->buf);
-                        if (value >= 0)
-                                value = min (wLength, (u16) value);
-                        break;
-                }
-                break;
-
-        case USB_REQ_SET_CONFIGURATION:
-                if (ctrl->bRequestType != 0)
-                        break;
-                if (gadget->a_hnp_support)
-                        DEBUG (dev, "HNP available\n");
-                else if (gadget->a_alt_hnp_support)
-                        DEBUG (dev, "HNP needs a different root port\n");
-                spin_lock (&dev->lock);
-                value = eth_set_config (dev, wValue, GFP_ATOMIC);
-                spin_unlock (&dev->lock);
-                break;
-        case USB_REQ_GET_CONFIGURATION:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        break;
-                *(u8 *)req->buf = dev->config;
-                value = min (wLength, (u16) 1);
-                break;
-
-        case USB_REQ_SET_INTERFACE:
-                if (ctrl->bRequestType != USB_RECIP_INTERFACE
-                                || !dev->config
-                                || wIndex > 1)
-                        break;
-                if (!cdc_active(dev) && wIndex != 0)
-                        break;
-                spin_lock (&dev->lock);
-
-                /* PXA hardware partially handles SET_INTERFACE;
-                 * we need to kluge around that interference.
-                 */
-                if (gadget_is_pxa (gadget)) {
-                        value = eth_set_config (dev, DEV_CONFIG_VALUE,
-                                                GFP_ATOMIC);
-                        goto done_set_intf;
-                }
-
-#ifdef DEV_CONFIG_CDC
-                switch (wIndex) {
-                case 0:         /* control/master intf */
-                        if (wValue != 0)
-                                break;
-                        if (dev->status) {
-                                usb_ep_disable (dev->status_ep);
-                                usb_ep_enable (dev->status_ep, dev->status);
-                        }
-                        value = 0;
-                        break;
-                case 1:         /* data intf */
-                        if (wValue > 1)
-                                break;
-                        usb_ep_disable (dev->in_ep);
-                        usb_ep_disable (dev->out_ep);
-
-                        /* CDC requires the data transfers not be done from
-                         * the default interface setting ... also, setting
-                         * the non-default interface resets filters etc.
-                         */
-                        if (wValue == 1) {
-                                if (!cdc_active (dev))
-                                        break;
-                                usb_ep_enable (dev->in_ep, dev->in);
-                                usb_ep_enable (dev->out_ep, dev->out);
-                                dev->cdc_filter = DEFAULT_FILTER;
-                                netif_carrier_on (dev->net);
-                                if (dev->status)
-                                        issue_start_status (dev);
-                                if (netif_running (dev->net)) {
-                                        spin_unlock (&dev->lock);
-                                        eth_start (dev, GFP_ATOMIC);
-                                        spin_lock (&dev->lock);
-                                }
-                        } else {
-                                netif_stop_queue (dev->net);
-                                netif_carrier_off (dev->net);
-                        }
-                        value = 0;
-                        break;
-                }
-#else
-                /* FIXME this is wrong, as is the assumption that
-                 * all non-PXA hardware talks real CDC ...
-                 */
-                dev_warn (&gadget->dev, "set_interface ignored!\n");
-#endif /* DEV_CONFIG_CDC */
-
-done_set_intf:
-                spin_unlock (&dev->lock);
-                break;
-        case USB_REQ_GET_INTERFACE:
-                if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
-                                || !dev->config
-                                || wIndex > 1)
-                        break;
-                if (!(cdc_active(dev) || rndis_active(dev)) && wIndex != 0)
-                        break;
-
-                /* for CDC, iff carrier is on, data interface is active. */
-                if (rndis_active(dev) || wIndex != 1)
-                        *(u8 *)req->buf = 0;
-                else
-                        *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0;
-                value = min (wLength, (u16) 1);
-                break;
-
-#ifdef DEV_CONFIG_CDC
-        case USB_CDC_SET_ETHERNET_PACKET_FILTER:
-                /* see 6.2.30: no data, wIndex = interface,
-                 * wValue = packet filter bitmap
-                 */
-                if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
-                                || !cdc_active(dev)
-                                || wLength != 0
-                                || wIndex > 1)
-                        break;
-                DEBUG (dev, "packet filter %02x\n", wValue);
-                dev->cdc_filter = wValue;
-                value = 0;
-                break;
-
-        /* and potentially:
-         * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
-         * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
-         * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
-         * case USB_CDC_GET_ETHERNET_STATISTIC:
-         */
-
-#endif /* DEV_CONFIG_CDC */
+        /* FIXME alloc iConfiguration string, set it in c->strings */
 
-#ifdef CONFIG_USB_ETH_RNDIS
-        /* RNDIS uses the CDC command encapsulation mechanism to implement
-         * an RPC scheme, with much getting/setting of attributes by OID.
-         */
-        case USB_CDC_SEND_ENCAPSULATED_COMMAND:
-                if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
-                                || !rndis_active(dev)
-                                || wLength > USB_BUFSIZ
-                                || wValue
-                                || rndis_control_intf.bInterfaceNumber
-                                        != wIndex)
-                        break;
-                /* read the request, then process it */
-                value = wLength;
-                req->complete = rndis_command_complete;
-                /* later, rndis_control_ack () sends a notification */
-                break;
-
-        case USB_CDC_GET_ENCAPSULATED_RESPONSE:
-                if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)
-                                        == ctrl->bRequestType
-                                && rndis_active(dev)
-                                // && wLength >= 0x0400
-                                && !wValue
-                                && rndis_control_intf.bInterfaceNumber
-                                        == wIndex) {
-                        u8 *buf;
-                        u32 n;
-
-                        /* return the result */
-                        buf = rndis_get_next_response(dev->rndis_config, &n);
-                        if (buf) {
-                                memcpy(req->buf, buf, n);
-                                req->complete = rndis_response_complete;
-                                rndis_free_response(dev->rndis_config, buf);
-                                value = n;
-                        }
-                        /* else stalls ... spec says to avoid that */
-                }
-                break;
-#endif  /* RNDIS */
-
-        default:
-                VDEBUG (dev,
-                        "unknown control req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
+        if (gadget_is_otg(c->cdev->gadget)) {
+                c->descriptors = otg_desc;
+                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        /* respond with data transfer before status phase? */
-        if (value >= 0) {
-                req->length = value;
-                req->zero = value < wLength
-                                && (value % gadget->ep0->maxpacket) == 0;
-                value = usb_ep_queue (gadget->ep0, req, GFP_ATOMIC);
-                if (value < 0) {
-                        DEBUG (dev, "ep_queue --> %d\n", value);
-                        req->status = 0;
-                        eth_setup_complete (gadget->ep0, req);
-                }
-        }
-
-        /* host either stalls (value < 0) or reports success */
-        return value;
-}
-
-static void
-eth_disconnect (struct usb_gadget *gadget)
-{
-        struct eth_dev          *dev = get_gadget_data (gadget);
-        unsigned long           flags;
-
-        spin_lock_irqsave (&dev->lock, flags);
-        netif_stop_queue (dev->net);
-        netif_carrier_off (dev->net);
-        eth_reset_config (dev);
-        spin_unlock_irqrestore (&dev->lock, flags);
-
-        /* FIXME RNDIS should enter RNDIS_UNINITIALIZED */
-
-        /* next we may get setup() calls to enumerate new connections;
-         * or an unbind() during shutdown (including removing module).
-         */
-}
-
-/*-------------------------------------------------------------------------*/
-
-/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
-
-static int eth_change_mtu (struct net_device *net, int new_mtu)
-{
-        struct eth_dev  *dev = netdev_priv(net);
-
-        if (dev->rndis)
-                return -EBUSY;
-
-        if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
-                return -ERANGE;
-        /* no zero-length packet read wanted after mtu-sized packets */
-        if (((new_mtu + sizeof (struct ethhdr)) % dev->in_ep->maxpacket) == 0)
-                return -EDOM;
-        net->mtu = new_mtu;
-        return 0;
-}
-
-static struct net_device_stats *eth_get_stats (struct net_device *net)
-{
-        return &((struct eth_dev *)netdev_priv(net))->stats;
-}
-
-static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
-{
-        struct eth_dev  *dev = netdev_priv(net);
-        strlcpy(p->driver, shortname, sizeof p->driver);
-        strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
-        strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
-        strlcpy (p->bus_info, dev->gadget->dev.bus_id, sizeof p->bus_info);
-}
-
-static u32 eth_get_link(struct net_device *net)
-{
-        struct eth_dev  *dev = netdev_priv(net);
-        return dev->gadget->speed != USB_SPEED_UNKNOWN;
-}
-
-static struct ethtool_ops ops = {
-        .get_drvinfo = eth_get_drvinfo,
-        .get_link = eth_get_link
-};
-
-static void defer_kevent (struct eth_dev *dev, int flag)
-{
-        if (test_and_set_bit (flag, &dev->todo))
-                return;
-        if (!schedule_work (&dev->work))
-                ERROR (dev, "kevent %d may have been dropped\n", flag);
+        if (can_support_ecm(c->cdev->gadget))
+                return ecm_bind_config(c, hostaddr);
         else
-                DEBUG (dev, "kevent %d scheduled\n", flag);
-}
-
-static void rx_complete (struct usb_ep *ep, struct usb_request *req);
-
-static int
-rx_submit (struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
-{
-        struct sk_buff          *skb;
-        int                     retval = -ENOMEM;
-        size_t                  size;
-
-        /* Padding up to RX_EXTRA handles minor disagreements with host.
-         * Normally we use the USB "terminate on short read" convention;
-         * so allow up to (N*maxpacket), since that memory is normally
-         * already allocated.  Some hardware doesn't deal well with short
-         * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
-         * byte off the end (to force hardware errors on overflow).
-         *
-         * RNDIS uses internal framing, and explicitly allows senders to
-         * pad to end-of-packet.  That's potentially nice for speed,
-         * but means receivers can't recover synch on their own.
-         */
-        size = (sizeof (struct ethhdr) + dev->net->mtu + RX_EXTRA);
-        size += dev->out_ep->maxpacket - 1;
-        if (rndis_active(dev))
-                size += sizeof (struct rndis_packet_msg_type);
-        size -= size % dev->out_ep->maxpacket;
-
-        skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
-        if (skb == NULL) {
-                DEBUG (dev, "no rx skb\n");
-                goto enomem;
-        }
-
-        /* Some platforms perform better when IP packets are aligned,
-         * but on at least one, checksumming fails otherwise.  Note:
-         * RNDIS headers involve variable numbers of LE32 values.
-         */
-        skb_reserve(skb, NET_IP_ALIGN);
-
-        req->buf = skb->data;
-        req->length = size;
-        req->complete = rx_complete;
-        req->context = skb;
-
-        retval = usb_ep_queue (dev->out_ep, req, gfp_flags);
-        if (retval == -ENOMEM)
-enomem:
-                defer_kevent (dev, WORK_RX_MEMORY);
-        if (retval) {
-                DEBUG (dev, "rx submit --> %d\n", retval);
-                if (skb)
-                        dev_kfree_skb_any(skb);
-                spin_lock(&dev->req_lock);
-                list_add (&req->list, &dev->rx_reqs);
-                spin_unlock(&dev->req_lock);
-        }
-        return retval;
-}
-
-static void rx_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        struct sk_buff  *skb = req->context;
-        struct eth_dev  *dev = ep->driver_data;
-        int             status = req->status;
-
-        switch (status) {
-
-        /* normal completion */
-        case 0:
-                skb_put (skb, req->actual);
-                /* we know MaxPacketsPerTransfer == 1 here */
-                if (rndis_active(dev))
-                        status = rndis_rm_hdr (skb);
-                if (status < 0
-                                || ETH_HLEN > skb->len
-                                || skb->len > ETH_FRAME_LEN) {
-                        dev->stats.rx_errors++;
-                        dev->stats.rx_length_errors++;
-                        DEBUG (dev, "rx length %d\n", skb->len);
-                        break;
-                }
-
-                skb->protocol = eth_type_trans (skb, dev->net);
-                dev->stats.rx_packets++;
-                dev->stats.rx_bytes += skb->len;
-
-                /* no buffer copies needed, unless hardware can't
-                 * use skb buffers.
-                 */
-                status = netif_rx (skb);
-                skb = NULL;
-                break;
-
-        /* software-driven interface shutdown */
-        case -ECONNRESET:               // unlink
-        case -ESHUTDOWN:                // disconnect etc
-                VDEBUG (dev, "rx shutdown, code %d\n", status);
-                goto quiesce;
-
-        /* for hardware automagic (such as pxa) */
-        case -ECONNABORTED:             // endpoint reset
-                DEBUG (dev, "rx %s reset\n", ep->name);
-                defer_kevent (dev, WORK_RX_MEMORY);
-quiesce:
-                dev_kfree_skb_any (skb);
-                goto clean;
-
-        /* data overrun */
-        case -EOVERFLOW:
-                dev->stats.rx_over_errors++;
-                // FALLTHROUGH
-
-        default:
-                dev->stats.rx_errors++;
-                DEBUG (dev, "rx status %d\n", status);
-                break;
-        }
-
-        if (skb)
-                dev_kfree_skb_any (skb);
-        if (!netif_running (dev->net)) {
-clean:
-                spin_lock(&dev->req_lock);
-                list_add (&req->list, &dev->rx_reqs);
-                spin_unlock(&dev->req_lock);
-                req = NULL;
-        }
-        if (req)
-                rx_submit (dev, req, GFP_ATOMIC);
-}
-
-static int prealloc (struct list_head *list, struct usb_ep *ep,
-                        unsigned n, gfp_t gfp_flags)
-{
-        unsigned                i;
-        struct usb_request      *req;
-
-        if (!n)
-                return -ENOMEM;
-
-        /* queue/recycle up to N requests */
-        i = n;
-        list_for_each_entry (req, list, list) {
-                if (i-- == 0)
-                        goto extra;
-        }
-        while (i--) {
-                req = usb_ep_alloc_request (ep, gfp_flags);
-                if (!req)
-                        return list_empty (list) ? -ENOMEM : 0;
-                list_add (&req->list, list);
-        }
-        return 0;
-
-extra:
-        /* free extras */
-        for (;;) {
-                struct list_head        *next;
-
-                next = req->list.next;
-                list_del (&req->list);
-                usb_ep_free_request (ep, req);
-
-                if (next == list)
-                        break;
-
-                req = container_of (next, struct usb_request, list);
-        }
-        return 0;
-}
-
-static int alloc_requests (struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
-{
-        int status;
-
-        spin_lock(&dev->req_lock);
-        status = prealloc (&dev->tx_reqs, dev->in_ep, n, gfp_flags);
-        if (status < 0)
-                goto fail;
-        status = prealloc (&dev->rx_reqs, dev->out_ep, n, gfp_flags);
-        if (status < 0)
-                goto fail;
-        goto done;
-fail:
-        DEBUG (dev, "can't alloc requests\n");
-done:
-        spin_unlock(&dev->req_lock);
-        return status;
-}
-
-static void rx_fill (struct eth_dev *dev, gfp_t gfp_flags)
-{
-        struct usb_request      *req;
-        unsigned long           flags;
-
-        /* fill unused rxq slots with some skb */
-        spin_lock_irqsave(&dev->req_lock, flags);
-        while (!list_empty (&dev->rx_reqs)) {
-                req = container_of (dev->rx_reqs.next,
-                                struct usb_request, list);
-                list_del_init (&req->list);
-                spin_unlock_irqrestore(&dev->req_lock, flags);
-
-                if (rx_submit (dev, req, gfp_flags) < 0) {
-                        defer_kevent (dev, WORK_RX_MEMORY);
-                        return;
-                }
-
-                spin_lock_irqsave(&dev->req_lock, flags);
-        }
-        spin_unlock_irqrestore(&dev->req_lock, flags);
-}
-
-static void eth_work (struct work_struct *work)
-{
-        struct eth_dev  *dev = container_of(work, struct eth_dev, work);
-
-        if (test_and_clear_bit (WORK_RX_MEMORY, &dev->todo)) {
-                if (netif_running (dev->net))
-                        rx_fill (dev, GFP_KERNEL);
-        }
-
-        if (dev->todo)
-                DEBUG (dev, "work done, flags = 0x%lx\n", dev->todo);
-}
-
-static void tx_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        struct sk_buff  *skb = req->context;
-        struct eth_dev  *dev = ep->driver_data;
-
-        switch (req->status) {
-        default:
-                dev->stats.tx_errors++;
-                VDEBUG (dev, "tx err %d\n", req->status);
-                /* FALLTHROUGH */
-        case -ECONNRESET:               // unlink
-        case -ESHUTDOWN:                // disconnect etc
-                break;
-        case 0:
-                dev->stats.tx_bytes += skb->len;
-        }
-        dev->stats.tx_packets++;
-
-        spin_lock(&dev->req_lock);
-        list_add (&req->list, &dev->tx_reqs);
-        spin_unlock(&dev->req_lock);
-        dev_kfree_skb_any (skb);
-
-        atomic_dec (&dev->tx_qlen);
-        if (netif_carrier_ok (dev->net))
-                netif_wake_queue (dev->net);
-}
-
-static inline int eth_is_promisc (struct eth_dev *dev)
-{
-        /* no filters for the CDC subset; always promisc */
-        if (subset_active (dev))
-                return 1;
-        return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
-}
-
-static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
-{
-        struct eth_dev          *dev = netdev_priv(net);
-        int                     length = skb->len;
-        int                     retval;
-        struct usb_request      *req = NULL;
-        unsigned long           flags;
-
-        /* apply outgoing CDC or RNDIS filters */
-        if (!eth_is_promisc (dev)) {
-                u8              *dest = skb->data;
-
-                if (is_multicast_ether_addr(dest)) {
-                        u16     type;
-
-                        /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
-                         * SET_ETHERNET_MULTICAST_FILTERS requests
-                         */
-                        if (is_broadcast_ether_addr(dest))
-                                type = USB_CDC_PACKET_TYPE_BROADCAST;
-                        else
-                                type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
-                        if (!(dev->cdc_filter & type)) {
-                                dev_kfree_skb_any (skb);
-                                return 0;
-                        }
-                }
-                /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
-        }
-
-        spin_lock_irqsave(&dev->req_lock, flags);
-        /*
-         * this freelist can be empty if an interrupt triggered disconnect()
-         * and reconfigured the gadget (shutting down this queue) after the
-         * network stack decided to xmit but before we got the spinlock.
-         */
-        if (list_empty(&dev->tx_reqs)) {
-                spin_unlock_irqrestore(&dev->req_lock, flags);
-                return 1;
-        }
-
-        req = container_of (dev->tx_reqs.next, struct usb_request, list);
-        list_del (&req->list);
-
-        /* temporarily stop TX queue when the freelist empties */
-        if (list_empty (&dev->tx_reqs))
-                netif_stop_queue (net);
-        spin_unlock_irqrestore(&dev->req_lock, flags);
-
-        /* no buffer copies needed, unless the network stack did it
-         * or the hardware can't use skb buffers.
-         * or there's not enough space for any RNDIS headers we need
-         */
-        if (rndis_active(dev)) {
-                struct sk_buff  *skb_rndis;
-
-                skb_rndis = skb_realloc_headroom (skb,
-                                sizeof (struct rndis_packet_msg_type));
-                if (!skb_rndis)
-                        goto drop;
-
-                dev_kfree_skb_any (skb);
-                skb = skb_rndis;
-                rndis_add_hdr (skb);
-                length = skb->len;
-        }
-        req->buf = skb->data;
-        req->context = skb;
-        req->complete = tx_complete;
-
-        /* use zlp framing on tx for strict CDC-Ether conformance,
-         * though any robust network rx path ignores extra padding.
-         * and some hardware doesn't like to write zlps.
-         */
-        req->zero = 1;
-        if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
-                length++;
-
-        req->length = length;
-
-        /* throttle highspeed IRQ rate back slightly */
-        if (gadget_is_dualspeed(dev->gadget))
-                req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
-                        ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
-                        : 0;
-
-        retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
-        switch (retval) {
-        default:
-                DEBUG (dev, "tx queue err %d\n", retval);
-                break;
-        case 0:
-                net->trans_start = jiffies;
-                atomic_inc (&dev->tx_qlen);
-        }
-
-        if (retval) {
-drop:
-                dev->stats.tx_dropped++;
-                dev_kfree_skb_any (skb);
-                spin_lock_irqsave(&dev->req_lock, flags);
-                if (list_empty (&dev->tx_reqs))
-                        netif_start_queue (net);
-                list_add (&req->list, &dev->tx_reqs);
-                spin_unlock_irqrestore(&dev->req_lock, flags);
-        }
-        return 0;
-}
-
-/*-------------------------------------------------------------------------*/
-
-#ifdef CONFIG_USB_ETH_RNDIS
-
-/* The interrupt endpoint is used in RNDIS to notify the host when messages
- * other than data packets are available ... notably the REMOTE_NDIS_*_CMPLT
- * messages, but also REMOTE_NDIS_INDICATE_STATUS_MSG and potentially even
- * REMOTE_NDIS_KEEPALIVE_MSG.
- *
- * The RNDIS control queue is processed by GET_ENCAPSULATED_RESPONSE, and
- * normally just one notification will be queued.
- */
-
-static struct usb_request *eth_req_alloc (struct usb_ep *, unsigned, gfp_t);
-static void eth_req_free (struct usb_ep *ep, struct usb_request *req);
-
-static void
-rndis_control_ack_complete (struct usb_ep *ep, struct usb_request *req)
-{
-        struct eth_dev          *dev = ep->driver_data;
-
-        if (req->status || req->actual != req->length)
-                DEBUG (dev,
-                        "rndis control ack complete --> %d, %d/%d\n",
-                        req->status, req->actual, req->length);
-        req->context = NULL;
-
-        if (req != dev->stat_req)
-                eth_req_free(ep, req);
-}
-
-static int rndis_control_ack (struct net_device *net)
-{
-        struct eth_dev          *dev = netdev_priv(net);
-        int                     length;
-        struct usb_request      *resp = dev->stat_req;
-
-        /* in case RNDIS calls this after disconnect */
-        if (!dev->status) {
-                DEBUG (dev, "status ENODEV\n");
-                return -ENODEV;
-        }
-
-        /* in case queue length > 1 */
-        if (resp->context) {
-                resp = eth_req_alloc (dev->status_ep, 8, GFP_ATOMIC);
-                if (!resp)
-                        return -ENOMEM;
-        }
-
-        /* Send RNDIS RESPONSE_AVAILABLE notification;
-         * USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too
-         */
-        resp->length = 8;
-        resp->complete = rndis_control_ack_complete;
-        resp->context = dev;
-
-        *((__le32 *) resp->buf) = __constant_cpu_to_le32 (1);
-        *((__le32 *) resp->buf + 1) = __constant_cpu_to_le32 (0);
-
-        length = usb_ep_queue (dev->status_ep, resp, GFP_ATOMIC);
-        if (length < 0) {
-                resp->status = 0;
-                rndis_control_ack_complete (dev->status_ep, resp);
-        }
-
-        return 0;
-}
-
-#else
-
-#define rndis_control_ack       NULL
-
-#endif  /* RNDIS */
-
-static void eth_start (struct eth_dev *dev, gfp_t gfp_flags)
-{
-        DEBUG (dev, "%s\n", __func__);
-
-        /* fill the rx queue */
-        rx_fill (dev, gfp_flags);
-
-        /* and open the tx floodgates */
-        atomic_set (&dev->tx_qlen, 0);
-        netif_wake_queue (dev->net);
-        if (rndis_active(dev)) {
-                rndis_set_param_medium (dev->rndis_config,
-                                        NDIS_MEDIUM_802_3,
-                                        BITRATE(dev->gadget)/100);
-                (void) rndis_signal_connect (dev->rndis_config);
-        }
-}
-
-static int eth_open (struct net_device *net)
-{
-        struct eth_dev          *dev = netdev_priv(net);
-
-        DEBUG (dev, "%s\n", __func__);
-        if (netif_carrier_ok (dev->net))
-                eth_start (dev, GFP_KERNEL);
-        return 0;
+                return geth_bind_config(c, hostaddr);
 }
 
-static int eth_stop (struct net_device *net)
-{
-        struct eth_dev          *dev = netdev_priv(net);
-
-        VDEBUG (dev, "%s\n", __func__);
-        netif_stop_queue (net);
-
-        DEBUG (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
-                dev->stats.rx_packets, dev->stats.tx_packets,
-                dev->stats.rx_errors, dev->stats.tx_errors
-                );
-
-        /* ensure there are no more active requests */
-        if (dev->config) {
-                usb_ep_disable (dev->in_ep);
-                usb_ep_disable (dev->out_ep);
-                if (netif_carrier_ok (dev->net)) {
-                        DEBUG (dev, "host still using in/out endpoints\n");
-                        // FIXME idiom may leave toggle wrong here
-                        usb_ep_enable (dev->in_ep, dev->in);
-                        usb_ep_enable (dev->out_ep, dev->out);
-                }
-                if (dev->status_ep) {
-                        usb_ep_disable (dev->status_ep);
-                        usb_ep_enable (dev->status_ep, dev->status);
-                }
-        }
-
-        if (rndis_active(dev)) {
-                rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);
-                (void) rndis_signal_disconnect (dev->rndis_config);
-        }
-
-        return 0;
-}
+static struct usb_configuration eth_config_driver = {
+        /* .label = f(hardware) */
+        .bind                   = eth_do_config,
+        .bConfigurationValue    = 1,
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower              = 1,    /* 2 mA, minimal */
+};
 
 /*-------------------------------------------------------------------------*/
 
-static struct usb_request *
-eth_req_alloc (struct usb_ep *ep, unsigned size, gfp_t gfp_flags)
+static int __init eth_bind(struct usb_composite_dev *cdev)
 {
-        struct usb_request      *req;
-
-        req = usb_ep_alloc_request (ep, gfp_flags);
-        if (!req)
-                return NULL;
-
-        req->buf = kmalloc (size, gfp_flags);
-        if (!req->buf) {
-                usb_ep_free_request (ep, req);
-                req = NULL;
-        }
-        return req;
-}
-
-static void
-eth_req_free (struct usb_ep *ep, struct usb_request *req)
-{
-        kfree (req->buf);
-        usb_ep_free_request (ep, req);
-}
-
-
-static void /* __init_or_exit */
-eth_unbind (struct usb_gadget *gadget)
-{
-        struct eth_dev          *dev = get_gadget_data (gadget);
-
-        DEBUG (dev, "unbind\n");
-        rndis_deregister (dev->rndis_config);
-        rndis_exit ();
-
-        /* we've already been disconnected ... no i/o is active */
-        if (dev->req) {
-                eth_req_free (gadget->ep0, dev->req);
-                dev->req = NULL;
-        }
-        if (dev->stat_req) {
-                eth_req_free (dev->status_ep, dev->stat_req);
-                dev->stat_req = NULL;
-        }
-
-        unregister_netdev (dev->net);
-        free_netdev(dev->net);
-
-        /* assuming we used keventd, it must quiesce too */
-        flush_scheduled_work ();
-        set_gadget_data (gadget, NULL);
-}
-
-static u8 __init nibble (unsigned char c)
-{
-        if (likely (isdigit (c)))
-                return c - '0';
-        c = toupper (c);
-        if (likely (isxdigit (c)))
-                return 10 + c - 'A';
-        return 0;
-}
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
 
-static int __init get_ether_addr(const char *str, u8 *dev_addr)
-{
-        if (str) {
-                unsigned        i;
+        /* set up network link layer */
+        status = gether_setup(cdev->gadget, hostaddr);
+        if (status < 0)
+                return status;
 
-                for (i = 0; i < 6; i++) {
-                        unsigned char num;
+        /* set up main config label and device descriptor */
+        if (can_support_ecm(cdev->gadget)) {
+                /* ECM */
+                eth_config_driver.label = "CDC Ethernet (ECM)";
+        } else {
+                /* CDC Subset */
+                eth_config_driver.label = "CDC Subset/SAFE";
 
-                        if((*str == '.') || (*str == ':'))
-                                str++;
-                        num = nibble(*str++) << 4;
-                        num |= (nibble(*str++));
-                        dev_addr [i] = num;
-                }
-                if (is_valid_ether_addr (dev_addr))
-                        return 0;
+                device_desc.idVendor = cpu_to_le16(SIMPLE_VENDOR_NUM),
+                device_desc.idProduct = cpu_to_le16(SIMPLE_PRODUCT_NUM),
+                device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
         }
-        random_ether_addr(dev_addr);
-        return 1;
-}
-
-static int __init
-eth_bind (struct usb_gadget *gadget)
-{
-        struct eth_dev          *dev;
-        struct net_device       *net;
-        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
-        cdc = 0;
-#endif
-#ifndef CONFIG_USB_ETH_RNDIS
-        rndis = 0;
-#endif
 
-        /* Because most host side USB stacks handle CDC Ethernet, that
-         * standard protocol is _strongly_ preferred for interop purposes.
-         * (By everyone except Microsoft.)
-         */
-        if (gadget_is_pxa (gadget)) {
-                /* pxa doesn't support altsettings */
-                cdc = 0;
-        } else if (gadget_is_musbhdrc(gadget)) {
-                /* reduce tx dma overhead by avoiding special cases */
-                zlp = 0;
-        } else if (gadget_is_sh(gadget)) {
-                /* sh doesn't support multiple interfaces or configs */
-                cdc = 0;
-                rndis = 0;
-        } else if (gadget_is_sa1100 (gadget)) {
-                /* 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;
+        if (has_rndis()) {
+                /* RNDIS plus ECM-or-Subset */
+                device_desc.idVendor = cpu_to_le16(RNDIS_VENDOR_NUM),
+                device_desc.idProduct = cpu_to_le16(RNDIS_PRODUCT_NUM),
+                device_desc.bNumConfigurations = 2;
         }
 
-        gcnum = usb_gadget_controller_number (gadget);
+        gcnum = usb_gadget_controller_number(gadget);
         if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16 (0x0200 + gcnum);
+                device_desc.bcdDevice = cpu_to_le16(0x0300 | 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.
+                /* We assume that can_support_ecm() tells the truth;
+                 * but if the controller isn't recognized at all then
+                 * that assumption is a bit more likely to be wrong.
                  */
-                dev_err (&gadget->dev,
-                        "controller '%s' not recognized\n",
-                        gadget->name);
-                return -ENODEV;
-        }
-        snprintf (manufacturer, sizeof manufacturer, "%s %s/%s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-
-        /* If there's an RNDIS configuration, that's what Windows wants to
-         * be using ... so use these product IDs here and in the "linux.inf"
-         * needed to install MSFT drivers.  Current Linux kernels will use
-         * the second configuration if it's CDC Ethernet, and need some help
-         * to choose the right configuration otherwise.
-         */
-        if (rndis) {
-                device_desc.idVendor =
-                        __constant_cpu_to_le16(RNDIS_VENDOR_NUM);
-                device_desc.idProduct =
-                        __constant_cpu_to_le16(RNDIS_PRODUCT_NUM);
-                snprintf (product_desc, sizeof product_desc,
-                        "RNDIS/%s", driver_desc);
-
-        /* CDC subset ... recognized by Linux since 2.4.10, but Windows
-         * drivers aren't widely available.  (That may be improved by
-         * supporting one submode of the "SAFE" variant of MDLM.)
-         */
-        } else if (!cdc) {
-                device_desc.idVendor =
-                        __constant_cpu_to_le16(SIMPLE_VENDOR_NUM);
-                device_desc.idProduct =
-                        __constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);
-        }
-
-        /* support optional vendor/distro customization */
-        if (idVendor) {
-                if (!idProduct) {
-                        dev_err (&gadget->dev, "idVendor needs idProduct!\n");
-                        return -ENODEV;
-                }
-                device_desc.idVendor = cpu_to_le16(idVendor);
-                device_desc.idProduct = cpu_to_le16(idProduct);
-                if (bcdDevice)
-                        device_desc.bcdDevice = cpu_to_le16(bcdDevice);
-        }
-        if (iManufacturer)
-                strlcpy (manufacturer, iManufacturer, sizeof manufacturer);
-        if (iProduct)
-                strlcpy (product_desc, iProduct, sizeof product_desc);
-        if (iSerialNumber) {
-                device_desc.iSerialNumber = STRING_SERIALNUMBER,
-                strlcpy(serial_number, iSerialNumber, sizeof serial_number);
-        }
-
-        /* all we really need is bulk IN/OUT */
-        usb_ep_autoconfig_reset (gadget);
-        in_ep = usb_ep_autoconfig (gadget, &fs_source_desc);
-        if (!in_ep) {
-autoconf_fail:
-                dev_err (&gadget->dev,
-                        "can't autoconfigure on %s\n",
-                        gadget->name);
-                return -ENODEV;
-        }
-        in_ep->driver_data = in_ep;     /* claim */
-
-        out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc);
-        if (!out_ep)
-                goto autoconf_fail;
-        out_ep->driver_data = out_ep;   /* claim */
-
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-        /* CDC Ethernet control interface doesn't require a status endpoint.
-         * Since some hosts expect one, try to allocate one anyway.
-         */
-        if (cdc || rndis) {
-                status_ep = usb_ep_autoconfig (gadget, &fs_status_desc);
-                if (status_ep) {
-                        status_ep->driver_data = status_ep;     /* claim */
-                } else if (rndis) {
-                        dev_err (&gadget->dev,
-                                "can't run RNDIS on %s\n",
-                                gadget->name);
-                        return -ENODEV;
-#ifdef DEV_CONFIG_CDC
-                /* pxa25x only does CDC subset; often used with RNDIS */
-                } else if (cdc) {
-                        control_intf.bNumEndpoints = 0;
-                        /* FIXME remove endpoint from descriptor list */
-#endif
-                }
-        }
-#endif
-
-        /* one config:  cdc, else minimal subset */
-        if (!cdc) {
-                eth_config.bNumInterfaces = 1;
-                eth_config.iConfiguration = STRING_SUBSET;
-
-                /* use functions to set these up, in case we're built to work
-                 * with multiple controllers and must override CDC Ethernet.
-                 */
-                fs_subset_descriptors();
-                hs_subset_descriptors();
-        }
-
-        device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-        usb_gadget_set_selfpowered (gadget);
-
-        /* For now RNDIS is always a second config */
-        if (rndis)
-                device_desc.bNumConfigurations = 2;
-
-        if (gadget_is_dualspeed(gadget)) {
-                if (rndis)
-                        dev_qualifier.bNumConfigurations = 2;
-                else if (!cdc)
-                        dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
-
-                /* assumes ep0 uses the same value for both speeds ... */
-                dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
-
-                /* and that all endpoints are dual-speed */
-                hs_source_desc.bEndpointAddress =
-                                fs_source_desc.bEndpointAddress;
-                hs_sink_desc.bEndpointAddress =
-                                fs_sink_desc.bEndpointAddress;
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-                if (status_ep)
-                        hs_status_desc.bEndpointAddress =
-                                        fs_status_desc.bEndpointAddress;
-#endif
+                WARN(cdev, "controller '%s' not recognized; trying %s\n",
+                                gadget->name,
+                                eth_config_driver.label);
+                device_desc.bcdDevice =
+                        __constant_cpu_to_le16(0x0300 | 0x0099);
         }
 
-        if (gadget_is_otg(gadget)) {
-                otg_descriptor.bmAttributes |= USB_OTG_HNP,
-                eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-                eth_config.bMaxPower = 4;
-#ifdef  CONFIG_USB_ETH_RNDIS
-                rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-                rndis_config.bMaxPower = 4;
-#endif
-        }
-
-        net = alloc_etherdev (sizeof *dev);
-        if (!net)
-                return status;
-        dev = netdev_priv(net);
-        spin_lock_init (&dev->lock);
-        spin_lock_init (&dev->req_lock);
-        INIT_WORK (&dev->work, eth_work);
-        INIT_LIST_HEAD (&dev->tx_reqs);
-        INIT_LIST_HEAD (&dev->rx_reqs);
-
-        /* network device setup */
-        dev->net = net;
-        strcpy (net->name, "usb%d");
-        dev->cdc = cdc;
-        dev->zlp = zlp;
 
-        dev->in_ep = in_ep;
-        dev->out_ep = out_ep;
-        dev->status_ep = status_ep;
-
-        /* Module params for these addresses should come from ID proms.
-         * The host side address is used with CDC and RNDIS, and commonly
-         * ends up in a persistent config database.  It's not clear if
-         * host side code for the SAFE thing cares -- its original BLAN
-         * thing didn't, Sharp never assigned those addresses on Zaurii.
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
          */
-        if (get_ether_addr(dev_addr, net->dev_addr))
-                dev_warn(&gadget->dev,
-                        "using random %s ethernet address\n", "self");
-        if (get_ether_addr(host_addr, dev->host_mac))
-                dev_warn(&gadget->dev,
-                        "using random %s ethernet address\n", "host");
-        snprintf (ethaddr, sizeof ethaddr, "%02X%02X%02X%02X%02X%02X",
-                dev->host_mac [0], dev->host_mac [1],
-                dev->host_mac [2], dev->host_mac [3],
-                dev->host_mac [4], dev->host_mac [5]);
-
-        if (rndis) {
-                status = rndis_init();
-                if (status < 0) {
-                        dev_err (&gadget->dev, "can't init RNDIS, %d\n",
-                                status);
-                        goto fail;
-                }
-        }
 
-        net->change_mtu = eth_change_mtu;
-        net->get_stats = eth_get_stats;
-        net->hard_start_xmit = eth_start_xmit;
-        net->open = eth_open;
-        net->stop = eth_stop;
-        // watchdog_timeo, tx_timeout ...
-        // set_multicast_list
-        SET_ETHTOOL_OPS(net, &ops);
+        /* device descriptor strings: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                init_utsname()->sysname, init_utsname()->release,
+                gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
+        device_desc.iManufacturer = status;
 
-        /* preallocate control message data and buffer */
-        dev->req = eth_req_alloc (gadget->ep0, USB_BUFSIZ, GFP_KERNEL);
-        if (!dev->req)
+        status = usb_string_id(cdev);
+        if (status < 0)
                 goto fail;
-        dev->req->complete = eth_setup_complete;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
+        device_desc.iProduct = status;
 
-        /* ... and maybe likewise for status transfer */
-#if defined(DEV_CONFIG_CDC) || defined(CONFIG_USB_ETH_RNDIS)
-        if (dev->status_ep) {
-                dev->stat_req = eth_req_alloc (dev->status_ep,
-                                        STATUS_BYTECOUNT, GFP_KERNEL);
-                if (!dev->stat_req) {
-                        eth_req_free (gadget->ep0, dev->req);
+        /* register our configuration(s); RNDIS first, if it's used */
+        if (has_rndis()) {
+                status = usb_add_config(cdev, &rndis_config_driver);
+                if (status < 0)
                         goto fail;
-                }
-                dev->stat_req->context = NULL;
         }
-#endif
-
-        /* finish hookup to lower layer ... */
-        dev->gadget = gadget;
-        set_gadget_data (gadget, dev);
-        gadget->ep0->driver_data = dev;
 
-        /* two kinds of host-initiated state changes:
-         *  - iff DATA transfer is active, carrier is "on"
-         *  - tx queueing enabled if open *and* carrier is "on"
-         */
-        netif_stop_queue (dev->net);
-        netif_carrier_off (dev->net);
-
-        SET_NETDEV_DEV (dev->net, &gadget->dev);
-        status = register_netdev (dev->net);
+        status = usb_add_config(cdev, &eth_config_driver);
         if (status < 0)
-                goto fail1;
-
-        INFO (dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
-        INFO (dev, "using %s, OUT %s IN %s%s%s\n", gadget->name,
-                out_ep->name, in_ep->name,
-                status_ep ? " STATUS " : "",
-                status_ep ? status_ep->name : ""
-                );
-        INFO (dev, "MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-                net->dev_addr [0], net->dev_addr [1],
-                net->dev_addr [2], net->dev_addr [3],
-                net->dev_addr [4], net->dev_addr [5]);
-
-        if (cdc || rndis)
-                INFO (dev, "HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
-                        dev->host_mac [0], dev->host_mac [1],
-                        dev->host_mac [2], dev->host_mac [3],
-                        dev->host_mac [4], dev->host_mac [5]);
-
-        if (rndis) {
-                u32     vendorID = 0;
-
-                /* FIXME RNDIS vendor id == "vendor NIC code" == ? */
-
-                dev->rndis_config = rndis_register (rndis_control_ack);
-                if (dev->rndis_config < 0) {
-fail0:
-                        unregister_netdev (dev->net);
-                        status = -ENODEV;
-                        goto fail;
-                }
+                goto fail;
 
-                /* these set up a lot of the OIDs that RNDIS needs */
-                rndis_set_host_mac (dev->rndis_config, dev->host_mac);
-                if (rndis_set_param_dev (dev->rndis_config, dev->net,
-                                         &dev->stats, &dev->cdc_filter))
-                        goto fail0;
-                if (rndis_set_param_vendor(dev->rndis_config, vendorID,
-                                        manufacturer))
-                        goto fail0;
-                if (rndis_set_param_medium(dev->rndis_config,
-                                        NDIS_MEDIUM_802_3, 0))
-                        goto fail0;
-                INFO (dev, "RNDIS ready\n");
-        }
+        INFO(cdev, "%s, version: " DRIVER_VERSION "\n", DRIVER_DESC);
 
-        return status;
+        return 0;
 
-fail1:
-        dev_dbg(&gadget->dev, "register_netdev failed, %d\n", status);
 fail:
-        eth_unbind (gadget);
+        gether_cleanup();
         return status;
 }
 
-/*-------------------------------------------------------------------------*/
-
-static void
-eth_suspend (struct usb_gadget *gadget)
-{
-        struct eth_dev          *dev = get_gadget_data (gadget);
-
-        DEBUG (dev, "suspend\n");
-        dev->suspended = 1;
-}
-
-static void
-eth_resume (struct usb_gadget *gadget)
+static int __exit eth_unbind(struct usb_composite_dev *cdev)
 {
-        struct eth_dev          *dev = get_gadget_data (gadget);
-
-        DEBUG (dev, "resume\n");
-        dev->suspended = 0;
+        gether_cleanup();
+        return 0;
 }
 
-/*-------------------------------------------------------------------------*/
-
-static struct usb_gadget_driver eth_driver = {
-        .speed          = DEVSPEED,
-
-        .function       = (char *) driver_desc,
+static struct usb_composite_driver eth_driver = {
+        .name           = "g_ether",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
         .bind           = eth_bind,
-        .unbind         = eth_unbind,
-
-        .setup          = eth_setup,
-        .disconnect     = eth_disconnect,
-
-        .suspend        = eth_suspend,
-        .resume         = eth_resume,
-
-        .driver = {
-                .name           = (char *) shortname,
-                .owner          = THIS_MODULE,
-        },
+        .unbind         = __exit_p(eth_unbind),
 };
 
-MODULE_DESCRIPTION (DRIVER_DESC);
-MODULE_AUTHOR ("David Brownell, Benedikt Spanger");
-MODULE_LICENSE ("GPL");
+MODULE_DESCRIPTION(PREFIX DRIVER_DESC);
+MODULE_AUTHOR("David Brownell, Benedikt Spanger");
+MODULE_LICENSE("GPL");
 
-
-static int __init init (void)
+static int __init init(void)
 {
-        return usb_gadget_register_driver (&eth_driver);
+        return usb_composite_register(&eth_driver);
 }
-module_init (init);
+module_init(init);
 
-static void __exit cleanup (void)
+static void __exit cleanup(void)
 {
-        usb_gadget_unregister_driver (&eth_driver);
+        usb_composite_unregister(&eth_driver);
 }
-module_exit (cleanup);
-
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/f_acm.c b/drivers/usb/gadget/f_acm.c
new file mode 100644
index 000000000000..d8faccf27895
--- /dev/null
+++ b/drivers/usb/gadget/f_acm.c
@@ -0,0 +1,589 @@
+/*
+ * f_acm.c -- USB CDC serial (ACM) function driver
+ *
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 by David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * either version 2 of that License or (at your option) any later version.
+ */
+
+/* #define VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+
+#include "u_serial.h"
+#include "gadget_chips.h"
+
+
+/*
+ * This CDC ACM function support just wraps control functions and
+ * notifications around the generic serial-over-usb code.
+ *
+ * Because CDC ACM is standardized by the USB-IF, many host operating
+ * systems have drivers for it.  Accordingly, ACM is the preferred
+ * interop solution for serial-port type connections.  The control
+ * models are often not necessary, and in any case don't do much in
+ * this bare-bones implementation.
+ *
+ * Note that even MS-Windows has some support for ACM.  However, that
+ * support is somewhat broken because when you use ACM in a composite
+ * device, having multiple interfaces confuses the poor OS.  It doesn't
+ * seem to understand CDC Union descriptors.  The new "association"
+ * descriptors (roughly equivalent to CDC Unions) may sometimes help.
+ */
+
+struct acm_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+        struct usb_endpoint_descriptor  *notify;
+};
+
+struct f_acm {
+        struct gserial                  port;
+        u8                              ctrl_id, data_id;
+        u8                              port_num;
+
+        struct usb_descriptor_header    **fs_function;
+        struct acm_ep_descs             fs;
+        struct usb_descriptor_header    **hs_function;
+        struct acm_ep_descs             hs;
+
+        struct usb_ep                   *notify;
+        struct usb_endpoint_descriptor  *notify_desc;
+
+        struct usb_cdc_line_coding      port_line_coding;       /* 8-N-1 etc */
+        u16                             port_handshake_bits;
+#define RS232_RTS       (1 << 1)        /* unused with full duplex */
+#define RS232_DTR       (1 << 0)        /* host is ready for data r/w */
+};
+
+static inline struct f_acm *func_to_acm(struct usb_function *f)
+{
+        return container_of(f, struct f_acm, port.func);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* notification endpoint uses smallish and infrequent fixed-size messages */
+
+#define GS_LOG2_NOTIFY_INTERVAL         5       /* 1 << 5 == 32 msec */
+#define GS_NOTIFY_MAXPACKET             8
+
+/* interface and class descriptors: */
+
+static struct usb_interface_descriptor acm_control_interface_desc __initdata = {
+        .bLength =              USB_DT_INTERFACE_SIZE,
+        .bDescriptorType =      USB_DT_INTERFACE,
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        1,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
+        .bInterfaceProtocol =   USB_CDC_ACM_PROTO_AT_V25TER,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_interface_descriptor acm_data_interface_desc __initdata = {
+        .bLength =              USB_DT_INTERFACE_SIZE,
+        .bDescriptorType =      USB_DT_INTERFACE,
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc acm_header_desc __initdata = {
+        .bLength =              sizeof(acm_header_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_call_mgmt_descriptor
+acm_call_mgmt_descriptor __initdata = {
+        .bLength =              sizeof(acm_call_mgmt_descriptor),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
+        .bmCapabilities =       0,
+        /* .bDataInterface = DYNAMIC */
+};
+
+static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
+        .bLength =              sizeof(acm_descriptor),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
+        .bmCapabilities =       (1 << 1),
+};
+
+static struct usb_cdc_union_desc acm_union_desc __initdata = {
+        .bLength =              sizeof(acm_union_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
+        /* .bMasterInterface0 = DYNAMIC */
+        /* .bSlaveInterface0 =  DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor acm_fs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+        .bInterval =            1 << GS_LOG2_NOTIFY_INTERVAL,
+};
+
+static struct usb_endpoint_descriptor acm_fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor acm_fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *acm_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &acm_control_interface_desc,
+        (struct usb_descriptor_header *) &acm_header_desc,
+        (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
+        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &acm_union_desc,
+        (struct usb_descriptor_header *) &acm_fs_notify_desc,
+        (struct usb_descriptor_header *) &acm_data_interface_desc,
+        (struct usb_descriptor_header *) &acm_fs_in_desc,
+        (struct usb_descriptor_header *) &acm_fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor acm_hs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
+        .bInterval =            GS_LOG2_NOTIFY_INTERVAL+4,
+};
+
+static struct usb_endpoint_descriptor acm_hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor acm_hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *acm_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &acm_control_interface_desc,
+        (struct usb_descriptor_header *) &acm_header_desc,
+        (struct usb_descriptor_header *) &acm_call_mgmt_descriptor,
+        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &acm_union_desc,
+        (struct usb_descriptor_header *) &acm_hs_notify_desc,
+        (struct usb_descriptor_header *) &acm_data_interface_desc,
+        (struct usb_descriptor_header *) &acm_hs_in_desc,
+        (struct usb_descriptor_header *) &acm_hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+#define ACM_CTRL_IDX    0
+#define ACM_DATA_IDX    1
+
+/* static strings, in UTF-8 */
+static struct usb_string acm_string_defs[] = {
+        [ACM_CTRL_IDX].s = "CDC Abstract Control Model (ACM)",
+        [ACM_DATA_IDX].s = "CDC ACM Data",
+        {  /* ZEROES END LIST */ },
+};
+
+static struct usb_gadget_strings acm_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              acm_string_defs,
+};
+
+static struct usb_gadget_strings *acm_strings[] = {
+        &acm_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* ACM control ... data handling is delegated to tty library code.
+ * The main task of this function is to activate and deactivate
+ * that code based on device state; track parameters like line
+ * speed, handshake state, and so on; and issue notifications.
+ */
+
+static void acm_complete_set_line_coding(struct usb_ep *ep,
+                struct usb_request *req)
+{
+        struct f_acm    *acm = ep->driver_data;
+        struct usb_composite_dev *cdev = acm->port.func.config->cdev;
+
+        if (req->status != 0) {
+                DBG(cdev, "acm ttyGS%d completion, err %d\n",
+                                acm->port_num, req->status);
+                return;
+        }
+
+        /* normal completion */
+        if (req->actual != sizeof(acm->port_line_coding)) {
+                DBG(cdev, "acm ttyGS%d short resp, len %d\n",
+                                acm->port_num, req->actual);
+                usb_ep_set_halt(ep);
+        } else {
+                struct usb_cdc_line_coding      *value = req->buf;
+
+                /* REVISIT:  we currently just remember this data.
+                 * If we change that, (a) validate it first, then
+                 * (b) update whatever hardware needs updating,
+                 * (c) worry about locking.  This is information on
+                 * the order of 9600-8-N-1 ... most of which means
+                 * nothing unless we control a real RS232 line.
+                 */
+                acm->port_line_coding = *value;
+        }
+}
+
+static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct f_acm            *acm = func_to_acm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /* composite driver infrastructure handles everything except
+         * CDC class messages; interface activation uses set_alt().
+         */
+        switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+
+        /* SET_LINE_CODING ... just read and save what the host sends */
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_REQ_SET_LINE_CODING:
+                if (w_length != sizeof(struct usb_cdc_line_coding)
+                                || w_index != acm->ctrl_id)
+                        goto invalid;
+
+                value = w_length;
+                cdev->gadget->ep0->driver_data = acm;
+                req->complete = acm_complete_set_line_coding;
+                break;
+
+        /* GET_LINE_CODING ... return what host sent, or initial value */
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_REQ_GET_LINE_CODING:
+                if (w_index != acm->ctrl_id)
+                        goto invalid;
+
+                value = min_t(unsigned, w_length,
+                                sizeof(struct usb_cdc_line_coding));
+                memcpy(req->buf, &acm->port_line_coding, value);
+                break;
+
+        /* SET_CONTROL_LINE_STATE ... save what the host sent */
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_REQ_SET_CONTROL_LINE_STATE:
+                if (w_index != acm->ctrl_id)
+                        goto invalid;
+
+                value = 0;
+
+                /* FIXME we should not allow data to flow until the
+                 * host sets the RS232_DTR bit; and when it clears
+                 * that bit, we should return to that no-flow state.
+                 */
+                acm->port_handshake_bits = w_value;
+                break;
+
+        default:
+invalid:
+                VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                DBG(cdev, "acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
+                        acm->port_num, ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(cdev, "acm response on ttyGS%d, err %d\n",
+                                        acm->port_num, value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_acm            *acm = func_to_acm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* we know alt == 0, so this is an activation or a reset */
+
+        if (intf == acm->ctrl_id) {
+                /* REVISIT this may need more work when we start to
+                 * send notifications ...
+                 */
+                if (acm->notify->driver_data) {
+                        VDBG(cdev, "reset acm control interface %d\n", intf);
+                        usb_ep_disable(acm->notify);
+                } else {
+                        VDBG(cdev, "init acm ctrl interface %d\n", intf);
+                        acm->notify_desc = ep_choose(cdev->gadget,
+                                        acm->hs.notify,
+                                        acm->fs.notify);
+                }
+                usb_ep_enable(acm->notify, acm->notify_desc);
+                acm->notify->driver_data = acm;
+
+        } else if (intf == acm->data_id) {
+                if (acm->port.in->driver_data) {
+                        DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
+                        gserial_disconnect(&acm->port);
+                } else {
+                        DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
+                        acm->port.in_desc = ep_choose(cdev->gadget,
+                                        acm->hs.in, acm->fs.in);
+                        acm->port.out_desc = ep_choose(cdev->gadget,
+                                        acm->hs.out, acm->fs.out);
+                }
+                gserial_connect(&acm->port, acm->port_num);
+
+        } else
+                return -EINVAL;
+
+        return 0;
+}
+
+static void acm_disable(struct usb_function *f)
+{
+        struct f_acm    *acm = func_to_acm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "acm ttyGS%d deactivated\n", acm->port_num);
+        gserial_disconnect(&acm->port);
+        usb_ep_disable(acm->notify);
+        acm->notify->driver_data = NULL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* ACM function driver setup/binding */
+static int __init
+acm_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_acm            *acm = func_to_acm(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs, and patch descriptors */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        acm->ctrl_id = status;
+
+        acm_control_interface_desc.bInterfaceNumber = status;
+        acm_union_desc .bMasterInterface0 = status;
+
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        acm->data_id = status;
+
+        acm_data_interface_desc.bInterfaceNumber = status;
+        acm_union_desc.bSlaveInterface0 = status;
+        acm_call_mgmt_descriptor.bDataInterface = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_in_desc);
+        if (!ep)
+                goto fail;
+        acm->port.in = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_out_desc);
+        if (!ep)
+                goto fail;
+        acm->port.out = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &acm_fs_notify_desc);
+        if (!ep)
+                goto fail;
+        acm->notify = ep;
+        ep->driver_data = cdev; /* claim */
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(acm_fs_function);
+
+        acm->fs.in = usb_find_endpoint(acm_fs_function,
+                        f->descriptors, &acm_fs_in_desc);
+        acm->fs.out = usb_find_endpoint(acm_fs_function,
+                        f->descriptors, &acm_fs_out_desc);
+        acm->fs.notify = usb_find_endpoint(acm_fs_function,
+                        f->descriptors, &acm_fs_notify_desc);
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                acm_hs_in_desc.bEndpointAddress =
+                                acm_fs_in_desc.bEndpointAddress;
+                acm_hs_out_desc.bEndpointAddress =
+                                acm_fs_out_desc.bEndpointAddress;
+                acm_hs_notify_desc.bEndpointAddress =
+                                acm_fs_notify_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(acm_hs_function);
+
+                acm->hs.in = usb_find_endpoint(acm_hs_function,
+                                f->hs_descriptors, &acm_hs_in_desc);
+                acm->hs.out = usb_find_endpoint(acm_hs_function,
+                                f->hs_descriptors, &acm_hs_out_desc);
+                acm->hs.notify = usb_find_endpoint(acm_hs_function,
+                                f->hs_descriptors, &acm_hs_notify_desc);
+        }
+
+        /* FIXME provide a callback for triggering notifications */
+
+        DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                        acm->port_num,
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        acm->port.in->name, acm->port.out->name,
+                        acm->notify->name);
+        return 0;
+
+fail:
+        /* we might as well release our claims on endpoints */
+        if (acm->notify)
+                acm->notify->driver_data = NULL;
+        if (acm->port.out)
+                acm->port.out->driver_data = NULL;
+        if (acm->port.in)
+                acm->port.in->driver_data = NULL;
+
+        ERROR(cdev, "%s/%p: can't bind, err %d\n", f->name, f, status);
+
+        return status;
+}
+
+static void
+acm_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+        kfree(func_to_acm(f));
+}
+
+/* Some controllers can't support CDC ACM ... */
+static inline bool can_support_cdc(struct usb_configuration *c)
+{
+        /* SH3 doesn't support multiple interfaces */
+        if (gadget_is_sh(c->cdev->gadget))
+                return false;
+
+        /* sa1100 doesn't have a third interrupt endpoint */
+        if (gadget_is_sa1100(c->cdev->gadget))
+                return false;
+
+        /* everything else is *probably* fine ... */
+        return true;
+}
+
+/**
+ * acm_bind_config - add a CDC ACM function to a configuration
+ * @c: the configuration to support the CDC ACM instance
+ * @port_num: /dev/ttyGS* port this interface will use
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gserial_setup() with enough ports to
+ * handle all the ones it binds.  Caller is also responsible
+ * for calling @gserial_cleanup() before module unload.
+ */
+int __init acm_bind_config(struct usb_configuration *c, u8 port_num)
+{
+        struct f_acm    *acm;
+        int             status;
+
+        if (!can_support_cdc(c))
+                return -EINVAL;
+
+        /* REVISIT might want instance-specific strings to help
+         * distinguish instances ...
+         */
+
+        /* maybe allocate device-global string IDs, and patch descriptors */
+        if (acm_string_defs[ACM_CTRL_IDX].id == 0) {
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                acm_string_defs[ACM_CTRL_IDX].id = status;
+
+                acm_control_interface_desc.iInterface = status;
+
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                acm_string_defs[ACM_DATA_IDX].id = status;
+
+                acm_data_interface_desc.iInterface = status;
+        }
+
+        /* allocate and initialize one new instance */
+        acm = kzalloc(sizeof *acm, GFP_KERNEL);
+        if (!acm)
+                return -ENOMEM;
+
+        acm->port_num = port_num;
+
+        acm->port.func.name = "acm";
+        acm->port.func.strings = acm_strings;
+        /* descriptors are per-instance copies */
+        acm->port.func.bind = acm_bind;
+        acm->port.func.unbind = acm_unbind;
+        acm->port.func.set_alt = acm_set_alt;
+        acm->port.func.setup = acm_setup;
+        acm->port.func.disable = acm_disable;
+
+        status = usb_add_function(c, &acm->port.func);
+        if (status)
+                kfree(acm);
+        return status;
+}
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
new file mode 100644
index 000000000000..0822e9d7693a
--- /dev/null
+++ b/drivers/usb/gadget/f_ecm.c
@@ -0,0 +1,833 @@
+/*
+ * f_ecm.c -- USB CDC Ethernet (ECM) link function driver
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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 VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+
+#include "u_ether.h"
+
+
+/*
+ * This function is a "CDC Ethernet Networking Control Model" (CDC ECM)
+ * Ethernet link.  The data transfer model is simple (packets sent and
+ * received over bulk endpoints using normal short packet termination),
+ * and the control model exposes various data and optional notifications.
+ *
+ * ECM is well standardized and (except for Microsoft) supported by most
+ * operating systems with USB host support.  It's the preferred interop
+ * solution for Ethernet over USB, at least for firmware based solutions.
+ * (Hardware solutions tend to be more minimalist.)  A newer and simpler
+ * "Ethernet Emulation Model" (CDC EEM) hasn't yet caught on.
+ *
+ * Note that ECM requires the use of "alternate settings" for its data
+ * interface.  This means that the set_alt() method has real work to do,
+ * and also means that a get_alt() method is required.
+ */
+
+struct ecm_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+        struct usb_endpoint_descriptor  *notify;
+};
+
+enum ecm_notify_state {
+        ECM_NOTIFY_NONE,                /* don't notify */
+        ECM_NOTIFY_CONNECT,             /* issue CONNECT next */
+        ECM_NOTIFY_SPEED,               /* issue SPEED_CHANGE next */
+};
+
+struct f_ecm {
+        struct gether                   port;
+        u8                              ctrl_id, data_id;
+
+        char                            ethaddr[14];
+
+        struct usb_descriptor_header    **fs_function;
+        struct ecm_ep_descs             fs;
+        struct usb_descriptor_header    **hs_function;
+        struct ecm_ep_descs             hs;
+
+        struct usb_ep                   *notify;
+        struct usb_endpoint_descriptor  *notify_desc;
+        struct usb_request              *notify_req;
+        u8                              notify_state;
+        bool                            is_open;
+
+        /* FIXME is_open needs some irq-ish locking
+         * ... possibly the same as port.ioport
+         */
+};
+
+static inline struct f_ecm *func_to_ecm(struct usb_function *f)
+{
+        return container_of(f, struct f_ecm, port.func);
+}
+
+/* peak (theoretical) bulk transfer rate in bits-per-second */
+static inline unsigned bitrate(struct usb_gadget *g)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return 13 * 512 * 8 * 1000 * 8;
+        else
+                return 19 *  64 * 1 * 1000 * 8;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Include the status endpoint if we can, even though it's optional.
+ *
+ * Use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
+ * packet, to simplify cancellation; and a big transfer interval, to
+ * waste less bandwidth.
+ *
+ * Some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
+ * if they ignore the connect/disconnect notifications that real aether
+ * can provide.  More advanced cdc configurations might want to support
+ * encapsulated commands (vendor-specific, using control-OUT).
+ */
+
+#define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
+#define STATUS_BYTECOUNT                16      /* 8 byte header + data */
+
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor ecm_control_intf __initdata = {
+        .bLength =              sizeof ecm_control_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        /* status endpoint is optional; this could be patched later */
+        .bNumEndpoints =        1,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ETHERNET,
+        .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc header_desc __initdata = {
+        .bLength =              sizeof header_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+
+        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_union_desc ecm_union_desc __initdata = {
+        .bLength =              sizeof(ecm_union_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
+        /* .bMasterInterface0 = DYNAMIC */
+        /* .bSlaveInterface0 =  DYNAMIC */
+};
+
+static struct usb_cdc_ether_desc ether_desc __initdata = {
+        .bLength =              sizeof ether_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
+
+        /* this descriptor actually adds value, surprise! */
+        /* .iMACAddress = DYNAMIC */
+        .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
+        .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
+        .wNumberMCFilters =     __constant_cpu_to_le16(0),
+        .bNumberPowerFilters =  0,
+};
+
+/* the default data interface has no endpoints ... */
+
+static struct usb_interface_descriptor ecm_data_nop_intf __initdata = {
+        .bLength =              sizeof ecm_data_nop_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    0,
+        .bNumEndpoints =        0,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+/* ... but the "real" data interface has two bulk endpoints */
+
+static struct usb_interface_descriptor ecm_data_intf __initdata = {
+        .bLength =              sizeof ecm_data_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bInterfaceNumber =     1,
+        .bAlternateSetting =    1,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
+};
+
+static struct usb_endpoint_descriptor fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *eth_fs_function[] __initdata = {
+        /* CDC ECM control descriptors */
+        (struct usb_descriptor_header *) &ecm_control_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &ecm_union_desc,
+        (struct usb_descriptor_header *) &ether_desc,
+        /* NOTE: status endpoint might need to be removed */
+        (struct usb_descriptor_header *) &fs_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ecm_data_nop_intf,
+        (struct usb_descriptor_header *) &ecm_data_intf,
+        (struct usb_descriptor_header *) &fs_in_desc,
+        (struct usb_descriptor_header *) &fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
+};
+static struct usb_endpoint_descriptor hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *eth_hs_function[] __initdata = {
+        /* CDC ECM control descriptors */
+        (struct usb_descriptor_header *) &ecm_control_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &ecm_union_desc,
+        (struct usb_descriptor_header *) &ether_desc,
+        /* NOTE: status endpoint might need to be removed */
+        (struct usb_descriptor_header *) &hs_notify_desc,
+        /* data interface, altsettings 0 and 1 */
+        (struct usb_descriptor_header *) &ecm_data_nop_intf,
+        (struct usb_descriptor_header *) &ecm_data_intf,
+        (struct usb_descriptor_header *) &hs_in_desc,
+        (struct usb_descriptor_header *) &hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+static struct usb_string ecm_string_defs[] = {
+        [0].s = "CDC Ethernet Control Model (ECM)",
+        [1].s = NULL /* DYNAMIC */,
+        [2].s = "CDC Ethernet Data",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings ecm_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              ecm_string_defs,
+};
+
+static struct usb_gadget_strings *ecm_strings[] = {
+        &ecm_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static void ecm_do_notify(struct f_ecm *ecm)
+{
+        struct usb_request              *req = ecm->notify_req;
+        struct usb_cdc_notification     *event;
+        struct usb_composite_dev        *cdev = ecm->port.func.config->cdev;
+        __le32                          *data;
+        int                             status;
+
+        /* notification already in flight? */
+        if (!req)
+                return;
+
+        event = req->buf;
+        switch (ecm->notify_state) {
+        case ECM_NOTIFY_NONE:
+                return;
+
+        case ECM_NOTIFY_CONNECT:
+                event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
+                if (ecm->is_open)
+                        event->wValue = cpu_to_le16(1);
+                else
+                        event->wValue = cpu_to_le16(0);
+                event->wLength = 0;
+                req->length = sizeof *event;
+
+                DBG(cdev, "notify connect %s\n",
+                                ecm->is_open ? "true" : "false");
+                ecm->notify_state = ECM_NOTIFY_SPEED;
+                break;
+
+        case ECM_NOTIFY_SPEED:
+                event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
+                event->wValue = cpu_to_le16(0);
+                event->wLength = cpu_to_le16(8);
+                req->length = STATUS_BYTECOUNT;
+
+                /* SPEED_CHANGE data is up/down speeds in bits/sec */
+                data = req->buf + sizeof *event;
+                data[0] = cpu_to_le32(bitrate(cdev->gadget));
+                data[1] = data[0];
+
+                DBG(cdev, "notify speed %d\n", bitrate(cdev->gadget));
+                ecm->notify_state = ECM_NOTIFY_NONE;
+                break;
+        }
+        event->bmRequestType = 0xA1;
+        event->wIndex = cpu_to_le16(ecm->ctrl_id);
+
+        ecm->notify_req = NULL;
+        status = usb_ep_queue(ecm->notify, req, GFP_ATOMIC);
+        if (status < 0) {
+                ecm->notify_req = req;
+                DBG(cdev, "notify --> %d\n", status);
+        }
+}
+
+static void ecm_notify(struct f_ecm *ecm)
+{
+        /* NOTE on most versions of Linux, host side cdc-ethernet
+         * won't listen for notifications until its netdevice opens.
+         * The first notification then sits in the FIFO for a long
+         * time, and the second one is queued.
+         */
+        ecm->notify_state = ECM_NOTIFY_CONNECT;
+        ecm_do_notify(ecm);
+}
+
+static void ecm_notify_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_ecm                    *ecm = req->context;
+        struct usb_composite_dev        *cdev = ecm->port.func.config->cdev;
+        struct usb_cdc_notification     *event = req->buf;
+
+        switch (req->status) {
+        case 0:
+                /* no fault */
+                break;
+        case -ECONNRESET:
+        case -ESHUTDOWN:
+                ecm->notify_state = ECM_NOTIFY_NONE;
+                break;
+        default:
+                DBG(cdev, "event %02x --> %d\n",
+                        event->bNotificationType, req->status);
+                break;
+        }
+        ecm->notify_req = req;
+        ecm_do_notify(ecm);
+}
+
+static int ecm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct f_ecm            *ecm = func_to_ecm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /* composite driver infrastructure handles everything except
+         * CDC class messages; interface activation uses set_alt().
+         */
+        switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_SET_ETHERNET_PACKET_FILTER:
+                /* see 6.2.30: no data, wIndex = interface,
+                 * wValue = packet filter bitmap
+                 */
+                if (w_length != 0 || w_index != ecm->ctrl_id)
+                        goto invalid;
+                DBG(cdev, "packet filter %02x\n", w_value);
+                /* REVISIT locking of cdc_filter.  This assumes the UDC
+                 * driver won't have a concurrent packet TX irq running on
+                 * another CPU; or that if it does, this write is atomic...
+                 */
+                ecm->port.cdc_filter = w_value;
+                value = 0;
+                break;
+
+        /* and optionally:
+         * case USB_CDC_SEND_ENCAPSULATED_COMMAND:
+         * case USB_CDC_GET_ENCAPSULATED_RESPONSE:
+         * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
+         * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
+         * case USB_CDC_GET_ETHERNET_STATISTIC:
+         */
+
+        default:
+invalid:
+                DBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                DBG(cdev, "ecm req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(cdev, "ecm req %02x.%02x response err %d\n",
+                                        ctrl->bRequestType, ctrl->bRequest,
+                                        value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+
+static int ecm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_ecm            *ecm = func_to_ecm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* Control interface has only altsetting 0 */
+        if (intf == ecm->ctrl_id) {
+                if (alt != 0)
+                        goto fail;
+
+                if (ecm->notify->driver_data) {
+                        VDBG(cdev, "reset ecm control %d\n", intf);
+                        usb_ep_disable(ecm->notify);
+                } else {
+                        VDBG(cdev, "init ecm ctrl %d\n", intf);
+                        ecm->notify_desc = ep_choose(cdev->gadget,
+                                        ecm->hs.notify,
+                                        ecm->fs.notify);
+                }
+                usb_ep_enable(ecm->notify, ecm->notify_desc);
+                ecm->notify->driver_data = ecm;
+
+        /* Data interface has two altsettings, 0 and 1 */
+        } else if (intf == ecm->data_id) {
+                if (alt > 1)
+                        goto fail;
+
+                if (ecm->port.in_ep->driver_data) {
+                        DBG(cdev, "reset ecm\n");
+                        gether_disconnect(&ecm->port);
+                }
+
+                if (!ecm->port.in) {
+                        DBG(cdev, "init ecm\n");
+                        ecm->port.in = ep_choose(cdev->gadget,
+                                        ecm->hs.in, ecm->fs.in);
+                        ecm->port.out = ep_choose(cdev->gadget,
+                                        ecm->hs.out, ecm->fs.out);
+                }
+
+                /* CDC Ethernet only sends data in non-default altsettings.
+                 * Changing altsettings resets filters, statistics, etc.
+                 */
+                if (alt == 1) {
+                        struct net_device       *net;
+
+                        /* Enable zlps by default for ECM conformance;
+                         * override for musb_hdrc (avoids txdma ovhead)
+                         * and sa1100 (can't).
+                         */
+                        ecm->port.is_zlp_ok = !(
+                                   gadget_is_sa1100(cdev->gadget)
+                                || gadget_is_musbhdrc(cdev->gadget)
+                                );
+                        ecm->port.cdc_filter = DEFAULT_FILTER;
+                        DBG(cdev, "activate ecm\n");
+                        net = gether_connect(&ecm->port);
+                        if (IS_ERR(net))
+                                return PTR_ERR(net);
+                }
+
+                /* NOTE this can be a minor disagreement with the ECM spec,
+                 * which says speed notifications will "always" follow
+                 * connection notifications.  But we allow one connect to
+                 * follow another (if the first is in flight), and instead
+                 * just guarantee that a speed notification is always sent.
+                 */
+                ecm_notify(ecm);
+        } else
+                goto fail;
+
+        return 0;
+fail:
+        return -EINVAL;
+}
+
+/* Because the data interface supports multiple altsettings,
+ * this ECM function *MUST* implement a get_alt() method.
+ */
+static int ecm_get_alt(struct usb_function *f, unsigned intf)
+{
+        struct f_ecm            *ecm = func_to_ecm(f);
+
+        if (intf == ecm->ctrl_id)
+                return 0;
+        return ecm->port.in_ep->driver_data ? 1 : 0;
+}
+
+static void ecm_disable(struct usb_function *f)
+{
+        struct f_ecm            *ecm = func_to_ecm(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "ecm deactivated\n");
+
+        if (ecm->port.in_ep->driver_data)
+                gether_disconnect(&ecm->port);
+
+        if (ecm->notify->driver_data) {
+                usb_ep_disable(ecm->notify);
+                ecm->notify->driver_data = NULL;
+                ecm->notify_desc = NULL;
+        }
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * Callbacks let us notify the host about connect/disconnect when the
+ * net device is opened or closed.
+ *
+ * For testing, note that link states on this side include both opened
+ * and closed variants of:
+ *
+ *   - disconnected/unconfigured
+ *   - configured but inactive (data alt 0)
+ *   - configured and active (data alt 1)
+ *
+ * Each needs to be tested with unplug, rmmod, SET_CONFIGURATION, and
+ * SET_INTERFACE (altsetting).  Remember also that "configured" doesn't
+ * imply the host is actually polling the notification endpoint, and
+ * likewise that "active" doesn't imply it's actually using the data
+ * endpoints for traffic.
+ */
+
+static void ecm_open(struct gether *geth)
+{
+        struct f_ecm            *ecm = func_to_ecm(&geth->func);
+
+        DBG(ecm->port.func.config->cdev, "%s\n", __func__);
+
+        ecm->is_open = true;
+        ecm_notify(ecm);
+}
+
+static void ecm_close(struct gether *geth)
+{
+        struct f_ecm            *ecm = func_to_ecm(&geth->func);
+
+        DBG(ecm->port.func.config->cdev, "%s\n", __func__);
+
+        ecm->is_open = false;
+        ecm_notify(ecm);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* ethernet function driver setup/binding */
+
+static int __init
+ecm_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_ecm            *ecm = func_to_ecm(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ecm->ctrl_id = status;
+
+        ecm_control_intf.bInterfaceNumber = status;
+        ecm_union_desc.bMasterInterface0 = status;
+
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        ecm->data_id = status;
+
+        ecm_data_nop_intf.bInterfaceNumber = status;
+        ecm_data_intf.bInterfaceNumber = status;
+        ecm_union_desc.bSlaveInterface0 = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
+        if (!ep)
+                goto fail;
+        ecm->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
+        if (!ep)
+                goto fail;
+        ecm->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        /* NOTE:  a status/notification endpoint is *OPTIONAL* but we
+         * don't treat it that way.  It's simpler, and some newer CDC
+         * profiles (wireless handsets) no longer treat it as optional.
+         */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
+        if (!ep)
+                goto fail;
+        ecm->notify = ep;
+        ep->driver_data = cdev; /* claim */
+
+        status = -ENOMEM;
+
+        /* allocate notification request and buffer */
+        ecm->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
+        if (!ecm->notify_req)
+                goto fail;
+        ecm->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
+        if (!ecm->notify_req->buf)
+                goto fail;
+        ecm->notify_req->context = ecm;
+        ecm->notify_req->complete = ecm_notify_complete;
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(eth_fs_function);
+        if (!f->descriptors)
+                goto fail;
+
+        ecm->fs.in = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_in_desc);
+        ecm->fs.out = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_out_desc);
+        ecm->fs.notify = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_notify_desc);
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_in_desc.bEndpointAddress =
+                                fs_in_desc.bEndpointAddress;
+                hs_out_desc.bEndpointAddress =
+                                fs_out_desc.bEndpointAddress;
+                hs_notify_desc.bEndpointAddress =
+                                fs_notify_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(eth_hs_function);
+                if (!f->hs_descriptors)
+                        goto fail;
+
+                ecm->hs.in = usb_find_endpoint(eth_hs_function,
+                                f->hs_descriptors, &hs_in_desc);
+                ecm->hs.out = usb_find_endpoint(eth_hs_function,
+                                f->hs_descriptors, &hs_out_desc);
+                ecm->hs.notify = usb_find_endpoint(eth_hs_function,
+                                f->hs_descriptors, &hs_notify_desc);
+        }
+
+        /* NOTE:  all that is done without knowing or caring about
+         * the network link ... which is unavailable to this code
+         * until we're activated via set_alt().
+         */
+
+        ecm->port.open = ecm_open;
+        ecm->port.close = ecm_close;
+
+        DBG(cdev, "CDC Ethernet: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        ecm->port.in_ep->name, ecm->port.out_ep->name,
+                        ecm->notify->name);
+        return 0;
+
+fail:
+        if (f->descriptors)
+                usb_free_descriptors(f->descriptors);
+
+        if (ecm->notify_req) {
+                kfree(ecm->notify_req->buf);
+                usb_ep_free_request(ecm->notify, ecm->notify_req);
+        }
+
+        /* we might as well release our claims on endpoints */
+        if (ecm->notify)
+                ecm->notify->driver_data = NULL;
+        if (ecm->port.out)
+                ecm->port.out_ep->driver_data = NULL;
+        if (ecm->port.in)
+                ecm->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+ecm_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct f_ecm            *ecm = func_to_ecm(f);
+
+        DBG(c->cdev, "ecm unbind\n");
+
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+
+        kfree(ecm->notify_req->buf);
+        usb_ep_free_request(ecm->notify, ecm->notify_req);
+
+        ecm_string_defs[1].s = NULL;
+        kfree(ecm);
+}
+
+/**
+ * ecm_bind_config - add CDC Ethernet network link to a configuration
+ * @c: the configuration to support the network link
+ * @ethaddr: a buffer in which the ethernet address of the host side
+ *      side of the link was recorded
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        struct f_ecm    *ecm;
+        int             status;
+
+        if (!can_support_ecm(c->cdev->gadget) || !ethaddr)
+                return -EINVAL;
+
+        /* maybe allocate device-global string IDs */
+        if (ecm_string_defs[0].id == 0) {
+
+                /* control interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ecm_string_defs[0].id = status;
+                ecm_control_intf.iInterface = status;
+
+                /* data interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ecm_string_defs[2].id = status;
+                ecm_data_intf.iInterface = status;
+
+                /* MAC address */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                ecm_string_defs[1].id = status;
+                ether_desc.iMACAddress = status;
+        }
+
+        /* allocate and initialize one new instance */
+        ecm = kzalloc(sizeof *ecm, GFP_KERNEL);
+        if (!ecm)
+                return -ENOMEM;
+
+        /* export host's Ethernet address in CDC format */
+        snprintf(ecm->ethaddr, sizeof ecm->ethaddr,
+                "%02X%02X%02X%02X%02X%02X",
+                ethaddr[0], ethaddr[1], ethaddr[2],
+                ethaddr[3], ethaddr[4], ethaddr[5]);
+        ecm_string_defs[1].s = ecm->ethaddr;
+
+        ecm->port.cdc_filter = DEFAULT_FILTER;
+
+        ecm->port.func.name = "cdc_ethernet";
+        ecm->port.func.strings = ecm_strings;
+        /* descriptors are per-instance copies */
+        ecm->port.func.bind = ecm_bind;
+        ecm->port.func.unbind = ecm_unbind;
+        ecm->port.func.set_alt = ecm_set_alt;
+        ecm->port.func.get_alt = ecm_get_alt;
+        ecm->port.func.setup = ecm_setup;
+        ecm->port.func.disable = ecm_disable;
+
+        status = usb_add_function(c, &ecm->port.func);
+        if (status) {
+                ecm_string_defs[1].s = NULL;
+                kfree(ecm);
+        }
+        return status;
+}
diff --git a/drivers/usb/gadget/f_loopback.c b/drivers/usb/gadget/f_loopback.c
new file mode 100644
index 000000000000..eda4cde72c82
--- /dev/null
+++ b/drivers/usb/gadget/f_loopback.c
@@ -0,0 +1,381 @@
+/*
+ * f_loopback.c - USB peripheral loopback configuration driver
+ *
+ * Copyright (C) 2003-2008 David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * 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 VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/device.h>
+
+#include "g_zero.h"
+#include "gadget_chips.h"
+
+
+/*
+ * LOOPBACK FUNCTION ... a testing vehicle for USB peripherals,
+ *
+ * This takes messages of various sizes written OUT to a device, and loops
+ * them back so they can be read IN from it.  It has been used by certain
+ * test applications.  It supports limited testing of data queueing logic.
+ *
+ *
+ * This is currently packaged as a configuration driver, which can't be
+ * combined with other functions to make composite devices.  However, it
+ * can be combined with other independent configurations.
+ */
+struct f_loopback {
+        struct usb_function     function;
+
+        struct usb_ep           *in_ep;
+        struct usb_ep           *out_ep;
+};
+
+static inline struct f_loopback *func_to_loop(struct usb_function *f)
+{
+        return container_of(f, struct f_loopback, function);
+}
+
+static unsigned qlen = 32;
+module_param(qlen, uint, 0);
+MODULE_PARM_DESC(qlenn, "depth of loopback queue");
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_interface_descriptor loopback_intf = {
+        .bLength =              sizeof loopback_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *fs_loopback_descs[] = {
+        (struct usb_descriptor_header *) &loopback_intf,
+        (struct usb_descriptor_header *) &fs_sink_desc,
+        (struct usb_descriptor_header *) &fs_source_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *hs_loopback_descs[] = {
+        (struct usb_descriptor_header *) &loopback_intf,
+        (struct usb_descriptor_header *) &hs_source_desc,
+        (struct usb_descriptor_header *) &hs_sink_desc,
+        NULL,
+};
+
+/* function-specific strings: */
+
+static struct usb_string strings_loopback[] = {
+        [0].s = "loop input to output",
+        {  }                    /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_loop = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_loopback,
+};
+
+static struct usb_gadget_strings *loopback_strings[] = {
+        &stringtab_loop,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init
+loopback_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_loopback       *loop = func_to_loop(f);
+        int                     id;
+
+        /* allocate interface ID(s) */
+        id = usb_interface_id(c, f);
+        if (id < 0)
+                return id;
+        loopback_intf.bInterfaceNumber = id;
+
+        /* allocate endpoints */
+
+        loop->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
+        if (!loop->in_ep) {
+autoconf_fail:
+                ERROR(cdev, "%s: can't autoconfigure on %s\n",
+                        f->name, cdev->gadget->name);
+                return -ENODEV;
+        }
+        loop->in_ep->driver_data = cdev;        /* claim */
+
+        loop->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
+        if (!loop->out_ep)
+                goto autoconf_fail;
+        loop->out_ep->driver_data = cdev;       /* claim */
+
+        /* support high speed hardware */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_source_desc.bEndpointAddress =
+                                fs_source_desc.bEndpointAddress;
+                hs_sink_desc.bEndpointAddress =
+                                fs_sink_desc.bEndpointAddress;
+                f->hs_descriptors = hs_loopback_descs;
+        }
+
+        DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        f->name, loop->in_ep->name, loop->out_ep->name);
+        return 0;
+}
+
+static void
+loopback_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        kfree(func_to_loop(f));
+}
+
+static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_loopback       *loop = ep->driver_data;
+        struct usb_composite_dev *cdev = loop->function.config->cdev;
+        int                     status = req->status;
+
+        switch (status) {
+
+        case 0:                         /* normal completion? */
+                if (ep == loop->out_ep) {
+                        /* loop this OUT packet back IN to the host */
+                        req->zero = (req->actual < req->length);
+                        req->length = req->actual;
+                        status = usb_ep_queue(loop->in_ep, req, GFP_ATOMIC);
+                        if (status == 0)
+                                return;
+
+                        /* "should never get here" */
+                        ERROR(cdev, "can't loop %s to %s: %d\n",
+                                ep->name, loop->in_ep->name,
+                                status);
+                }
+
+                /* queue the buffer for some later OUT packet */
+                req->length = buflen;
+                status = usb_ep_queue(loop->out_ep, req, GFP_ATOMIC);
+                if (status == 0)
+                        return;
+
+                /* "should never get here" */
+                /* FALLTHROUGH */
+
+        default:
+                ERROR(cdev, "%s loop complete --> %d, %d/%d\n", ep->name,
+                                status, req->actual, req->length);
+                /* FALLTHROUGH */
+
+        /* NOTE:  since this driver doesn't maintain an explicit record
+         * of requests it submitted (just maintains qlen count), we
+         * rely on the hardware driver to clean up on disconnect or
+         * endpoint disable.
+         */
+        case -ECONNABORTED:             /* hardware forced ep reset */
+        case -ECONNRESET:               /* request dequeued */
+        case -ESHUTDOWN:                /* disconnect from host */
+                free_ep_req(ep, req);
+                return;
+        }
+}
+
+static void disable_loopback(struct f_loopback *loop)
+{
+        struct usb_composite_dev        *cdev;
+
+        cdev = loop->function.config->cdev;
+        disable_endpoints(cdev, loop->in_ep, loop->out_ep);
+        VDBG(cdev, "%s disabled\n", loop->function.name);
+}
+
+static int
+enable_loopback(struct usb_composite_dev *cdev, struct f_loopback *loop)
+{
+        int                                     result = 0;
+        const struct usb_endpoint_descriptor    *src, *sink;
+        struct usb_ep                           *ep;
+        struct usb_request                      *req;
+        unsigned                                i;
+
+        src = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
+        sink = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
+
+        /* one endpoint writes data back IN to the host */
+        ep = loop->in_ep;
+        result = usb_ep_enable(ep, src);
+        if (result < 0)
+                return result;
+        ep->driver_data = loop;
+
+        /* one endpoint just reads OUT packets */
+        ep = loop->out_ep;
+        result = usb_ep_enable(ep, sink);
+        if (result < 0) {
+fail0:
+                ep = loop->in_ep;
+                usb_ep_disable(ep);
+                ep->driver_data = NULL;
+                return result;
+        }
+        ep->driver_data = loop;
+
+        /* allocate a bunch of read buffers and queue them all at once.
+         * we buffer at most 'qlen' transfers; fewer if any need more
+         * than 'buflen' bytes each.
+         */
+        for (i = 0; i < qlen && result == 0; i++) {
+                req = alloc_ep_req(ep);
+                if (req) {
+                        req->complete = loopback_complete;
+                        result = usb_ep_queue(ep, req, GFP_ATOMIC);
+                        if (result)
+                                ERROR(cdev, "%s queue req --> %d\n",
+                                                ep->name, result);
+                } else {
+                        usb_ep_disable(ep);
+                        ep->driver_data = NULL;
+                        result = -ENOMEM;
+                        goto fail0;
+                }
+        }
+
+        DBG(cdev, "%s enabled\n", loop->function.name);
+        return result;
+}
+
+static int loopback_set_alt(struct usb_function *f,
+                unsigned intf, unsigned alt)
+{
+        struct f_loopback       *loop = func_to_loop(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* we know alt is zero */
+        if (loop->in_ep->driver_data)
+                disable_loopback(loop);
+        return enable_loopback(cdev, loop);
+}
+
+static void loopback_disable(struct usb_function *f)
+{
+        struct f_loopback       *loop = func_to_loop(f);
+
+        disable_loopback(loop);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int __init loopback_bind_config(struct usb_configuration *c)
+{
+        struct f_loopback       *loop;
+        int                     status;
+
+        loop = kzalloc(sizeof *loop, GFP_KERNEL);
+        if (!loop)
+                return -ENOMEM;
+
+        loop->function.name = "loopback";
+        loop->function.descriptors = fs_loopback_descs;
+        loop->function.bind = loopback_bind;
+        loop->function.unbind = loopback_unbind;
+        loop->function.set_alt = loopback_set_alt;
+        loop->function.disable = loopback_disable;
+
+        status = usb_add_function(c, &loop->function);
+        if (status)
+                kfree(loop);
+        return status;
+}
+
+static struct usb_configuration loopback_driver = {
+        .label          = "loopback",
+        .strings        = loopback_strings,
+        .bind           = loopback_bind_config,
+        .bConfigurationValue = 2,
+        .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower      = 1,    /* 2 mA, minimal */
+        /* .iConfiguration = DYNAMIC */
+};
+
+/**
+ * loopback_add - add a loopback testing configuration to a device
+ * @cdev: the device to support the loopback configuration
+ */
+int __init loopback_add(struct usb_composite_dev *cdev)
+{
+        int id;
+
+        /* allocate string ID(s) */
+        id = usb_string_id(cdev);
+        if (id < 0)
+                return id;
+        strings_loopback[0].id = id;
+
+        loopback_intf.iInterface = id;
+        loopback_driver.iConfiguration = id;
+
+        /* support OTG systems */
+        if (gadget_is_otg(cdev->gadget)) {
+                loopback_driver.descriptors = otg_desc;
+                loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        return usb_add_config(cdev, &loopback_driver);
+}
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
new file mode 100644
index 000000000000..61652f0f13fd
--- /dev/null
+++ b/drivers/usb/gadget/f_rndis.c
@@ -0,0 +1,827 @@
+/*
+ * f_rndis.c -- RNDIS link function driver
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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 VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+
+#include <asm/atomic.h>
+
+#include "u_ether.h"
+#include "rndis.h"
+
+
+/*
+ * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
+ * been promoted instead of the standard CDC Ethernet.  The published RNDIS
+ * spec is ambiguous, incomplete, and needlessly complex.  Variants such as
+ * ActiveSync have even worse status in terms of specification.
+ *
+ * In short:  it's a protocol controlled by (and for) Microsoft, not for an
+ * Open ecosystem or markets.  Linux supports it *only* because Microsoft
+ * doesn't support the CDC Ethernet standard.
+ *
+ * The RNDIS data transfer model is complex, with multiple Ethernet packets
+ * per USB message, and out of band data.  The control model is built around
+ * what's essentially an "RNDIS RPC" protocol.  It's all wrapped in a CDC ACM
+ * (modem, not Ethernet) veneer, with those ACM descriptors being entirely
+ * useless (they're ignored).  RNDIS expects to be the only function in its
+ * configuration, so it's no real help if you need composite devices; and
+ * it expects to be the first configuration too.
+ *
+ * There is a single technical advantage of RNDIS over CDC Ethernet, if you
+ * discount the fluff that its RPC can be made to deliver: it doesn't need
+ * a NOP altsetting for the data interface.  That lets it work on some of the
+ * "so smart it's stupid" hardware which takes over configuration changes
+ * from the software, and adds restrictions like "no altsettings".
+ *
+ * Unfortunately MSFT's RNDIS drivers are buggy.  They hang or oops, and
+ * have all sorts of contrary-to-specification oddities that can prevent
+ * them from working sanely.  Since bugfixes (or accurate specs, letting
+ * Linux work around those bugs) are unlikely to ever come from MSFT, you
+ * may want to avoid using RNDIS on purely operational grounds.
+ *
+ * Omissions from the RNDIS 1.0 specification include:
+ *
+ *   - Power management ... references data that's scattered around lots
+ *     of other documentation, which is incorrect/incomplete there too.
+ *
+ *   - There are various undocumented protocol requirements, like the need
+ *     to send garbage in some control-OUT messages.
+ *
+ *   - MS-Windows drivers sometimes emit undocumented requests.
+ */
+
+struct rndis_ep_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+        struct usb_endpoint_descriptor  *notify;
+};
+
+struct f_rndis {
+        struct gether                   port;
+        u8                              ctrl_id, data_id;
+        u8                              ethaddr[ETH_ALEN];
+        int                             config;
+
+        struct usb_descriptor_header    **fs_function;
+        struct rndis_ep_descs           fs;
+        struct usb_descriptor_header    **hs_function;
+        struct rndis_ep_descs           hs;
+
+        struct usb_ep                   *notify;
+        struct usb_endpoint_descriptor  *notify_desc;
+        struct usb_request              *notify_req;
+        atomic_t                        notify_count;
+};
+
+static inline struct f_rndis *func_to_rndis(struct usb_function *f)
+{
+        return container_of(f, struct f_rndis, port.func);
+}
+
+/* peak (theoretical) bulk transfer rate in bits-per-second */
+static unsigned int bitrate(struct usb_gadget *g)
+{
+        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
+                return 13 * 512 * 8 * 1000 * 8;
+        else
+                return 19 *  64 * 1 * 1000 * 8;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ */
+
+#define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
+#define STATUS_BYTECOUNT                8       /* 8 bytes data */
+
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor rndis_control_intf __initdata = {
+        .bLength =              sizeof rndis_control_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        /* status endpoint is optional; this could be patched later */
+        .bNumEndpoints =        1,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
+        .bInterfaceProtocol =   USB_CDC_ACM_PROTO_VENDOR,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc header_desc __initdata = {
+        .bLength =              sizeof header_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+
+        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor __initdata = {
+        .bLength =              sizeof call_mgmt_descriptor,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
+
+        .bmCapabilities =       0x00,
+        .bDataInterface =       0x01,
+};
+
+static struct usb_cdc_acm_descriptor acm_descriptor __initdata = {
+        .bLength =              sizeof acm_descriptor,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
+
+        .bmCapabilities =       0x00,
+};
+
+static struct usb_cdc_union_desc rndis_union_desc __initdata = {
+        .bLength =              sizeof(rndis_union_desc),
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
+        /* .bMasterInterface0 = DYNAMIC */
+        /* .bSlaveInterface0 =  DYNAMIC */
+};
+
+/* the data interface has two bulk endpoints */
+
+static struct usb_interface_descriptor rndis_data_intf __initdata = {
+        .bLength =              sizeof rndis_data_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        .bAlternateSetting =    1,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_CDC_DATA,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
+};
+
+static struct usb_endpoint_descriptor fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *eth_fs_function[] __initdata = {
+        /* control interface matches ACM, not Ethernet */
+        (struct usb_descriptor_header *) &rndis_control_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &call_mgmt_descriptor,
+        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &rndis_union_desc,
+        (struct usb_descriptor_header *) &fs_notify_desc,
+        /* data interface has no altsetting */
+        (struct usb_descriptor_header *) &rndis_data_intf,
+        (struct usb_descriptor_header *) &fs_in_desc,
+        (struct usb_descriptor_header *) &fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_notify_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
+        .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
+};
+static struct usb_endpoint_descriptor hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *eth_hs_function[] __initdata = {
+        /* control interface matches ACM, not Ethernet */
+        (struct usb_descriptor_header *) &rndis_control_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &call_mgmt_descriptor,
+        (struct usb_descriptor_header *) &acm_descriptor,
+        (struct usb_descriptor_header *) &rndis_union_desc,
+        (struct usb_descriptor_header *) &hs_notify_desc,
+        /* data interface has no altsetting */
+        (struct usb_descriptor_header *) &rndis_data_intf,
+        (struct usb_descriptor_header *) &hs_in_desc,
+        (struct usb_descriptor_header *) &hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+static struct usb_string rndis_string_defs[] = {
+        [0].s = "RNDIS Communications Control",
+        [1].s = "RNDIS Ethernet Data",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings rndis_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              rndis_string_defs,
+};
+
+static struct usb_gadget_strings *rndis_strings[] = {
+        &rndis_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static struct sk_buff *rndis_add_header(struct sk_buff *skb)
+{
+        skb = skb_realloc_headroom(skb, sizeof(struct rndis_packet_msg_type));
+        if (skb)
+                rndis_add_hdr(skb);
+        return skb;
+}
+
+static void rndis_response_available(void *_rndis)
+{
+        struct f_rndis                  *rndis = _rndis;
+        struct usb_request              *req = rndis->notify_req;
+        struct usb_composite_dev        *cdev = rndis->port.func.config->cdev;
+        __le32                          *data = req->buf;
+        int                             status;
+
+        if (atomic_inc_return(&rndis->notify_count))
+                return;
+
+        /* Send RNDIS RESPONSE_AVAILABLE notification; a
+         * USB_CDC_NOTIFY_RESPONSE_AVAILABLE "should" work too
+         *
+         * This is the only notification defined by RNDIS.
+         */
+        data[0] = cpu_to_le32(1);
+        data[1] = cpu_to_le32(0);
+
+        status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
+        if (status) {
+                atomic_dec(&rndis->notify_count);
+                DBG(cdev, "notify/0 --> %d\n", status);
+        }
+}
+
+static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_rndis                  *rndis = req->context;
+        struct usb_composite_dev        *cdev = rndis->port.func.config->cdev;
+        int                             status = req->status;
+
+        /* after TX:
+         *  - USB_CDC_GET_ENCAPSULATED_RESPONSE (ep0/control)
+         *  - RNDIS_RESPONSE_AVAILABLE (status/irq)
+         */
+        switch (status) {
+        case -ECONNRESET:
+        case -ESHUTDOWN:
+                /* connection gone */
+                atomic_set(&rndis->notify_count, 0);
+                break;
+        default:
+                DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
+                        ep->name, status,
+                        req->actual, req->length);
+                /* FALLTHROUGH */
+        case 0:
+                if (ep != rndis->notify)
+                        break;
+
+                /* handle multiple pending RNDIS_RESPONSE_AVAILABLE
+                 * notifications by resending until we're done
+                 */
+                if (atomic_dec_and_test(&rndis->notify_count))
+                        break;
+                status = usb_ep_queue(rndis->notify, req, GFP_ATOMIC);
+                if (status) {
+                        atomic_dec(&rndis->notify_count);
+                        DBG(cdev, "notify/1 --> %d\n", status);
+                }
+                break;
+        }
+}
+
+static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_rndis                  *rndis = req->context;
+        struct usb_composite_dev        *cdev = rndis->port.func.config->cdev;
+        int                             status;
+
+        /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
+//      spin_lock(&dev->lock);
+        status = rndis_msg_parser(rndis->config, (u8 *) req->buf);
+        if (status < 0)
+                ERROR(cdev, "RNDIS command error %d, %d/%d\n",
+                        status, req->actual, req->length);
+//      spin_unlock(&dev->lock);
+}
+
+static int
+rndis_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+        struct f_rndis          *rndis = func_to_rndis(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct usb_request      *req = cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /* composite driver infrastructure handles everything except
+         * CDC class messages; interface activation uses set_alt().
+         */
+        switch ((ctrl->bRequestType << 8) | ctrl->bRequest) {
+
+        /* RNDIS uses the CDC command encapsulation mechanism to implement
+         * an RPC scheme, with much getting/setting of attributes by OID.
+         */
+        case ((USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_SEND_ENCAPSULATED_COMMAND:
+                if (w_length > req->length || w_value
+                                || w_index != rndis->ctrl_id)
+                        goto invalid;
+                /* read the request; process it later */
+                value = w_length;
+                req->complete = rndis_command_complete;
+                req->context = rndis;
+                /* later, rndis_response_available() sends a notification */
+                break;
+
+        case ((USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE) << 8)
+                        | USB_CDC_GET_ENCAPSULATED_RESPONSE:
+                if (w_value || w_index != rndis->ctrl_id)
+                        goto invalid;
+                else {
+                        u8 *buf;
+                        u32 n;
+
+                        /* return the result */
+                        buf = rndis_get_next_response(rndis->config, &n);
+                        if (buf) {
+                                memcpy(req->buf, buf, n);
+                                req->complete = rndis_response_complete;
+                                rndis_free_response(rndis->config, buf);
+                                value = n;
+                        }
+                        /* else stalls ... spec says to avoid that */
+                }
+                break;
+
+        default:
+invalid:
+                VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                DBG(cdev, "rndis req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(cdev, "rndis response on err %d\n", value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+
+static int rndis_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_rndis          *rndis = func_to_rndis(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* we know alt == 0 */
+
+        if (intf == rndis->ctrl_id) {
+                if (rndis->notify->driver_data) {
+                        VDBG(cdev, "reset rndis control %d\n", intf);
+                        usb_ep_disable(rndis->notify);
+                } else {
+                        VDBG(cdev, "init rndis ctrl %d\n", intf);
+                        rndis->notify_desc = ep_choose(cdev->gadget,
+                                        rndis->hs.notify,
+                                        rndis->fs.notify);
+                }
+                usb_ep_enable(rndis->notify, rndis->notify_desc);
+                rndis->notify->driver_data = rndis;
+
+        } else if (intf == rndis->data_id) {
+                struct net_device       *net;
+
+                if (rndis->port.in_ep->driver_data) {
+                        DBG(cdev, "reset rndis\n");
+                        gether_disconnect(&rndis->port);
+                } else {
+                        DBG(cdev, "init rndis\n");
+                        rndis->port.in = ep_choose(cdev->gadget,
+                                        rndis->hs.in, rndis->fs.in);
+                        rndis->port.out = ep_choose(cdev->gadget,
+                                        rndis->hs.out, rndis->fs.out);
+                }
+
+                /* Avoid ZLPs; they can be troublesome. */
+                rndis->port.is_zlp_ok = false;
+
+                /* RNDIS should be in the "RNDIS uninitialized" state,
+                 * either never activated or after rndis_uninit().
+                 *
+                 * We don't want data to flow here until a nonzero packet
+                 * filter is set, at which point it enters "RNDIS data
+                 * initialized" state ... but we do want the endpoints
+                 * to be activated.  It's a strange little state.
+                 *
+                 * REVISIT the RNDIS gadget code has done this wrong for a
+                 * very long time.  We need another call to the link layer
+                 * code -- gether_updown(...bool) maybe -- to do it right.
+                 */
+                rndis->port.cdc_filter = 0;
+
+                DBG(cdev, "RNDIS RX/TX early activation ... \n");
+                net = gether_connect(&rndis->port);
+                if (IS_ERR(net))
+                        return PTR_ERR(net);
+
+                rndis_set_param_dev(rndis->config, net,
+                                &rndis->port.cdc_filter);
+        } else
+                goto fail;
+
+        return 0;
+fail:
+        return -EINVAL;
+}
+
+static void rndis_disable(struct usb_function *f)
+{
+        struct f_rndis          *rndis = func_to_rndis(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        if (!rndis->notify->driver_data)
+                return;
+
+        DBG(cdev, "rndis deactivated\n");
+
+        rndis_uninit(rndis->config);
+        gether_disconnect(&rndis->port);
+
+        usb_ep_disable(rndis->notify);
+        rndis->notify->driver_data = NULL;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * This isn't quite the same mechanism as CDC Ethernet, since the
+ * notification scheme passes less data, but the same set of link
+ * states must be tested.  A key difference is that altsettings are
+ * not used to tell whether the link should send packets or not.
+ */
+
+static void rndis_open(struct gether *geth)
+{
+        struct f_rndis          *rndis = func_to_rndis(&geth->func);
+        struct usb_composite_dev *cdev = geth->func.config->cdev;
+
+        DBG(cdev, "%s\n", __func__);
+
+        rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3,
+                                bitrate(cdev->gadget) / 100);
+        rndis_signal_connect(rndis->config);
+}
+
+static void rndis_close(struct gether *geth)
+{
+        struct f_rndis          *rndis = func_to_rndis(&geth->func);
+
+        DBG(geth->func.config->cdev, "%s\n", __func__);
+
+        rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3, 0);
+        rndis_signal_disconnect(rndis->config);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* ethernet function driver setup/binding */
+
+static int __init
+rndis_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_rndis          *rndis = func_to_rndis(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        rndis->ctrl_id = status;
+
+        rndis_control_intf.bInterfaceNumber = status;
+        rndis_union_desc.bMasterInterface0 = status;
+
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        rndis->data_id = status;
+
+        rndis_data_intf.bInterfaceNumber = status;
+        rndis_union_desc.bSlaveInterface0 = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
+        if (!ep)
+                goto fail;
+        rndis->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
+        if (!ep)
+                goto fail;
+        rndis->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        /* NOTE:  a status/notification endpoint is, strictly speaking,
+         * optional.  We don't treat it that way though!  It's simpler,
+         * and some newer profiles don't treat it as optional.
+         */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_notify_desc);
+        if (!ep)
+                goto fail;
+        rndis->notify = ep;
+        ep->driver_data = cdev; /* claim */
+
+        status = -ENOMEM;
+
+        /* allocate notification request and buffer */
+        rndis->notify_req = usb_ep_alloc_request(ep, GFP_KERNEL);
+        if (!rndis->notify_req)
+                goto fail;
+        rndis->notify_req->buf = kmalloc(STATUS_BYTECOUNT, GFP_KERNEL);
+        if (!rndis->notify_req->buf)
+                goto fail;
+        rndis->notify_req->length = STATUS_BYTECOUNT;
+        rndis->notify_req->context = rndis;
+        rndis->notify_req->complete = rndis_response_complete;
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(eth_fs_function);
+        if (!f->descriptors)
+                goto fail;
+
+        rndis->fs.in = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_in_desc);
+        rndis->fs.out = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_out_desc);
+        rndis->fs.notify = usb_find_endpoint(eth_fs_function,
+                        f->descriptors, &fs_notify_desc);
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_in_desc.bEndpointAddress =
+                                fs_in_desc.bEndpointAddress;
+                hs_out_desc.bEndpointAddress =
+                                fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(eth_hs_function);
+
+                if (!f->hs_descriptors)
+                        goto fail;
+
+                rndis->hs.in = usb_find_endpoint(eth_hs_function,
+                                f->hs_descriptors, &hs_in_desc);
+                rndis->hs.out = usb_find_endpoint(eth_hs_function,
+                                f->hs_descriptors, &hs_out_desc);
+        }
+
+        rndis->port.open = rndis_open;
+        rndis->port.close = rndis_close;
+
+        status = rndis_register(rndis_response_available, rndis);
+        if (status < 0)
+                goto fail;
+        rndis->config = status;
+
+        rndis_set_param_medium(rndis->config, NDIS_MEDIUM_802_3, 0);
+        rndis_set_host_mac(rndis->config, rndis->ethaddr);
+
+#if 0
+// FIXME
+        if (rndis_set_param_vendor(rndis->config, vendorID,
+                                manufacturer))
+                goto fail0;
+#endif
+
+        /* NOTE:  all that is done without knowing or caring about
+         * the network link ... which is unavailable to this code
+         * until we're activated via set_alt().
+         */
+
+        DBG(cdev, "RNDIS: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        rndis->port.in_ep->name, rndis->port.out_ep->name,
+                        rndis->notify->name);
+        return 0;
+
+fail:
+        if (gadget_is_dualspeed(c->cdev->gadget) && f->hs_descriptors)
+                usb_free_descriptors(f->hs_descriptors);
+        if (f->descriptors)
+                usb_free_descriptors(f->descriptors);
+
+        if (rndis->notify_req) {
+                kfree(rndis->notify_req->buf);
+                usb_ep_free_request(rndis->notify, rndis->notify_req);
+        }
+
+        /* we might as well release our claims on endpoints */
+        if (rndis->notify)
+                rndis->notify->driver_data = NULL;
+        if (rndis->port.out)
+                rndis->port.out_ep->driver_data = NULL;
+        if (rndis->port.in)
+                rndis->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+rndis_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct f_rndis          *rndis = func_to_rndis(f);
+
+        rndis_deregister(rndis->config);
+        rndis_exit();
+
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+
+        kfree(rndis->notify_req->buf);
+        usb_ep_free_request(rndis->notify, rndis->notify_req);
+
+        kfree(rndis);
+}
+
+/* Some controllers can't support RNDIS ... */
+static inline bool can_support_rndis(struct usb_configuration *c)
+{
+        /* only two endpoints on sa1100 */
+        if (gadget_is_sa1100(c->cdev->gadget))
+                return false;
+
+        /* everything else is *presumably* fine */
+        return true;
+}
+
+/**
+ * rndis_bind_config - add RNDIS network link to a configuration
+ * @c: the configuration to support the network link
+ * @ethaddr: a buffer in which the ethernet address of the host side
+ *      side of the link was recorded
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        struct f_rndis  *rndis;
+        int             status;
+
+        if (!can_support_rndis(c) || !ethaddr)
+                return -EINVAL;
+
+        /* maybe allocate device-global string IDs */
+        if (rndis_string_defs[0].id == 0) {
+
+                /* ... and setup RNDIS itself */
+                status = rndis_init();
+                if (status < 0)
+                        return status;
+
+                /* control interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                rndis_string_defs[0].id = status;
+                rndis_control_intf.iInterface = status;
+
+                /* data interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                rndis_string_defs[1].id = status;
+                rndis_data_intf.iInterface = status;
+        }
+
+        /* allocate and initialize one new instance */
+        status = -ENOMEM;
+        rndis = kzalloc(sizeof *rndis, GFP_KERNEL);
+        if (!rndis)
+                goto fail;
+
+        memcpy(rndis->ethaddr, ethaddr, ETH_ALEN);
+
+        /* RNDIS activates when the host changes this filter */
+        rndis->port.cdc_filter = 0;
+
+        /* RNDIS has special (and complex) framing */
+        rndis->port.header_len = sizeof(struct rndis_packet_msg_type);
+        rndis->port.wrap = rndis_add_header;
+        rndis->port.unwrap = rndis_rm_hdr;
+
+        rndis->port.func.name = "rndis";
+        rndis->port.func.strings = rndis_strings;
+        /* descriptors are per-instance copies */
+        rndis->port.func.bind = rndis_bind;
+        rndis->port.func.unbind = rndis_unbind;
+        rndis->port.func.set_alt = rndis_set_alt;
+        rndis->port.func.setup = rndis_setup;
+        rndis->port.func.disable = rndis_disable;
+
+        status = usb_add_function(c, &rndis->port.func);
+        if (status) {
+                kfree(rndis);
+fail:
+                rndis_exit();
+        }
+        return status;
+}
diff --git a/drivers/usb/gadget/f_serial.c b/drivers/usb/gadget/f_serial.c
new file mode 100644
index 000000000000..1b6bde9aaed5
--- /dev/null
+++ b/drivers/usb/gadget/f_serial.c
@@ -0,0 +1,296 @@
+/*
+ * f_serial.c - generic USB serial function driver
+ *
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 by David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * either version 2 of that License or (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+
+#include "u_serial.h"
+#include "gadget_chips.h"
+
+
+/*
+ * This function packages a simple "generic serial" port with no real
+ * control mechanisms, just raw data transfer over two bulk endpoints.
+ *
+ * Because it's not standardized, this isn't as interoperable as the
+ * CDC ACM driver.  However, for many purposes it's just as functional
+ * if you can arrange appropriate host side drivers.
+ */
+
+struct gser_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+};
+
+struct f_gser {
+        struct gserial                  port;
+        u8                              data_id;
+        u8                              port_num;
+
+        struct usb_descriptor_header    **fs_function;
+        struct gser_descs               fs;
+        struct usb_descriptor_header    **hs_function;
+        struct gser_descs               hs;
+};
+
+static inline struct f_gser *func_to_gser(struct usb_function *f)
+{
+        return container_of(f, struct f_gser, port.func);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor gser_interface_desc __initdata = {
+        .bLength =              USB_DT_INTERFACE_SIZE,
+        .bDescriptorType =      USB_DT_INTERFACE,
+        /* .bInterfaceNumber = DYNAMIC */
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
+        .bInterfaceSubClass =   0,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor gser_fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor gser_fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *gser_fs_function[] __initdata = {
+        (struct usb_descriptor_header *) &gser_interface_desc,
+        (struct usb_descriptor_header *) &gser_fs_in_desc,
+        (struct usb_descriptor_header *) &gser_fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor gser_hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor gser_hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *gser_hs_function[] __initdata = {
+        (struct usb_descriptor_header *) &gser_interface_desc,
+        (struct usb_descriptor_header *) &gser_hs_in_desc,
+        (struct usb_descriptor_header *) &gser_hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+static struct usb_string gser_string_defs[] = {
+        [0].s = "Generic Serial",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings gser_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              gser_string_defs,
+};
+
+static struct usb_gadget_strings *gser_strings[] = {
+        &gser_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_gser           *gser = func_to_gser(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* we know alt == 0, so this is an activation or a reset */
+
+        if (gser->port.in->driver_data) {
+                DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
+                gserial_disconnect(&gser->port);
+        } else {
+                DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
+                gser->port.in_desc = ep_choose(cdev->gadget,
+                                gser->hs.in, gser->fs.in);
+                gser->port.out_desc = ep_choose(cdev->gadget,
+                                gser->hs.out, gser->fs.out);
+        }
+        gserial_connect(&gser->port, gser->port_num);
+        return 0;
+}
+
+static void gser_disable(struct usb_function *f)
+{
+        struct f_gser   *gser = func_to_gser(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
+        gserial_disconnect(&gser->port);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* serial function driver setup/binding */
+
+static int __init
+gser_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_gser           *gser = func_to_gser(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        gser->data_id = status;
+        gser_interface_desc.bInterfaceNumber = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_in_desc);
+        if (!ep)
+                goto fail;
+        gser->port.in = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &gser_fs_out_desc);
+        if (!ep)
+                goto fail;
+        gser->port.out = ep;
+        ep->driver_data = cdev; /* claim */
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(gser_fs_function);
+
+        gser->fs.in = usb_find_endpoint(gser_fs_function,
+                        f->descriptors, &gser_fs_in_desc);
+        gser->fs.out = usb_find_endpoint(gser_fs_function,
+                        f->descriptors, &gser_fs_out_desc);
+
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                gser_hs_in_desc.bEndpointAddress =
+                                gser_fs_in_desc.bEndpointAddress;
+                gser_hs_out_desc.bEndpointAddress =
+                                gser_fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(gser_hs_function);
+
+                gser->hs.in = usb_find_endpoint(gser_hs_function,
+                                f->hs_descriptors, &gser_hs_in_desc);
+                gser->hs.out = usb_find_endpoint(gser_hs_function,
+                                f->hs_descriptors, &gser_hs_out_desc);
+        }
+
+        DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
+                        gser->port_num,
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        gser->port.in->name, gser->port.out->name);
+        return 0;
+
+fail:
+        /* we might as well release our claims on endpoints */
+        if (gser->port.out)
+                gser->port.out->driver_data = NULL;
+        if (gser->port.in)
+                gser->port.in->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+gser_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+        kfree(func_to_gser(f));
+}
+
+/**
+ * gser_bind_config - add a generic serial function to a configuration
+ * @c: the configuration to support the serial instance
+ * @port_num: /dev/ttyGS* port this interface will use
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gserial_setup() with enough ports to
+ * handle all the ones it binds.  Caller is also responsible
+ * for calling @gserial_cleanup() before module unload.
+ */
+int __init gser_bind_config(struct usb_configuration *c, u8 port_num)
+{
+        struct f_gser   *gser;
+        int             status;
+
+        /* REVISIT might want instance-specific strings to help
+         * distinguish instances ...
+         */
+
+        /* maybe allocate device-global string ID */
+        if (gser_string_defs[0].id == 0) {
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                gser_string_defs[0].id = status;
+        }
+
+        /* allocate and initialize one new instance */
+        gser = kzalloc(sizeof *gser, GFP_KERNEL);
+        if (!gser)
+                return -ENOMEM;
+
+        gser->port_num = port_num;
+
+        gser->port.func.name = "gser";
+        gser->port.func.strings = gser_strings;
+        gser->port.func.bind = gser_bind;
+        gser->port.func.unbind = gser_unbind;
+        gser->port.func.set_alt = gser_set_alt;
+        gser->port.func.disable = gser_disable;
+
+        status = usb_add_function(c, &gser->port.func);
+        if (status)
+                kfree(gser);
+        return status;
+}
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
new file mode 100644
index 000000000000..f18c3a14d72a
--- /dev/null
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -0,0 +1,587 @@
+/*
+ * f_sourcesink.c - USB peripheral source/sink configuration driver
+ *
+ * Copyright (C) 2003-2008 David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * 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 VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/device.h>
+
+#include "g_zero.h"
+#include "gadget_chips.h"
+
+
+/*
+ * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
+ * controller drivers.
+ *
+ * This just sinks bulk packets OUT to the peripheral and sources them IN
+ * to the host, optionally with specific data patterns for integrity tests.
+ * As such it supports basic functionality and load tests.
+ *
+ * In terms of control messaging, this supports all the standard requests
+ * plus two that support control-OUT tests.  If the optional "autoresume"
+ * mode is enabled, it provides good functional coverage for the "USBCV"
+ * test harness from USB-IF.
+ *
+ * Note that because this doesn't queue more than one request at a time,
+ * some other function must be used to test queueing logic.  The network
+ * link (g_ether) is the best overall option for that, since its TX and RX
+ * queues are relatively independent, will receive a range of packet sizes,
+ * and can often be made to run out completely.  Those issues are important
+ * when stress testing peripheral controller drivers.
+ *
+ *
+ * This is currently packaged as a configuration driver, which can't be
+ * combined with other functions to make composite devices.  However, it
+ * can be combined with other independent configurations.
+ */
+struct f_sourcesink {
+        struct usb_function     function;
+
+        struct usb_ep           *in_ep;
+        struct usb_ep           *out_ep;
+        struct timer_list       resume;
+};
+
+static inline struct f_sourcesink *func_to_ss(struct usb_function *f)
+{
+        return container_of(f, struct f_sourcesink, function);
+}
+
+static unsigned autoresume;
+module_param(autoresume, uint, 0);
+MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
+
+static unsigned pattern;
+module_param(pattern, uint, 0);
+MODULE_PARM_DESC(pattern, "0 = all zeroes, 1 = mod63 ");
+
+/*-------------------------------------------------------------------------*/
+
+static struct usb_interface_descriptor source_sink_intf = {
+        .bLength =              sizeof source_sink_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
+        /* .iInterface = DYNAMIC */
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *fs_source_sink_descs[] = {
+        (struct usb_descriptor_header *) &source_sink_intf,
+        (struct usb_descriptor_header *) &fs_sink_desc,
+        (struct usb_descriptor_header *) &fs_source_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *hs_source_sink_descs[] = {
+        (struct usb_descriptor_header *) &source_sink_intf,
+        (struct usb_descriptor_header *) &hs_source_desc,
+        (struct usb_descriptor_header *) &hs_sink_desc,
+        NULL,
+};
+
+/* function-specific strings: */
+
+static struct usb_string strings_sourcesink[] = {
+        [0].s = "source and sink data",
+        {  }                    /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_sourcesink = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_sourcesink,
+};
+
+static struct usb_gadget_strings *sourcesink_strings[] = {
+        &stringtab_sourcesink,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static void sourcesink_autoresume(unsigned long _c)
+{
+        struct usb_composite_dev *cdev = (void *)_c;
+        struct usb_gadget       *g = cdev->gadget;
+
+        /* Normally the host would be woken up for something
+         * more significant than just a timer firing; likely
+         * because of some direct user request.
+         */
+        if (g->speed != USB_SPEED_UNKNOWN) {
+                int status = usb_gadget_wakeup(g);
+                DBG(cdev, "%s --> %d\n", __func__, status);
+        }
+}
+
+static int __init
+sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_sourcesink     *ss = func_to_ss(f);
+        int     id;
+
+        /* allocate interface ID(s) */
+        id = usb_interface_id(c, f);
+        if (id < 0)
+                return id;
+        source_sink_intf.bInterfaceNumber = id;
+
+        /* allocate endpoints */
+        ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
+        if (!ss->in_ep) {
+autoconf_fail:
+                ERROR(cdev, "%s: can't autoconfigure on %s\n",
+                        f->name, cdev->gadget->name);
+                return -ENODEV;
+        }
+        ss->in_ep->driver_data = cdev;  /* claim */
+
+        ss->out_ep = usb_ep_autoconfig(cdev->gadget, &fs_sink_desc);
+        if (!ss->out_ep)
+                goto autoconf_fail;
+        ss->out_ep->driver_data = cdev; /* claim */
+
+        setup_timer(&ss->resume, sourcesink_autoresume,
+                        (unsigned long) c->cdev);
+
+        /* support high speed hardware */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_source_desc.bEndpointAddress =
+                                fs_source_desc.bEndpointAddress;
+                hs_sink_desc.bEndpointAddress =
+                                fs_sink_desc.bEndpointAddress;
+                f->hs_descriptors = hs_source_sink_descs;
+        }
+
+        DBG(cdev, "%s speed %s: IN/%s, OUT/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        f->name, ss->in_ep->name, ss->out_ep->name);
+        return 0;
+}
+
+static void
+sourcesink_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        kfree(func_to_ss(f));
+}
+
+/* optionally require specific source/sink data patterns  */
+static int check_read_data(struct f_sourcesink *ss, struct usb_request *req)
+{
+        unsigned                i;
+        u8                      *buf = req->buf;
+        struct usb_composite_dev *cdev = ss->function.config->cdev;
+
+        for (i = 0; i < req->actual; i++, buf++) {
+                switch (pattern) {
+
+                /* all-zeroes has no synchronization issues */
+                case 0:
+                        if (*buf == 0)
+                                continue;
+                        break;
+
+                /* "mod63" stays in sync with short-terminated transfers,
+                 * OR otherwise when host and gadget agree on how large
+                 * each usb transfer request should be.  Resync is done
+                 * with set_interface or set_config.  (We *WANT* it to
+                 * get quickly out of sync if controllers or their drivers
+                 * stutter for any reason, including buffer duplcation...)
+                 */
+                case 1:
+                        if (*buf == (u8)(i % 63))
+                                continue;
+                        break;
+                }
+                ERROR(cdev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
+                usb_ep_set_halt(ss->out_ep);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
+{
+        unsigned        i;
+        u8              *buf = req->buf;
+
+        switch (pattern) {
+        case 0:
+                memset(req->buf, 0, req->length);
+                break;
+        case 1:
+                for  (i = 0; i < req->length; i++)
+                        *buf++ = (u8) (i % 63);
+                break;
+        }
+}
+
+static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct f_sourcesink     *ss = ep->driver_data;
+        struct usb_composite_dev *cdev = ss->function.config->cdev;
+        int                     status = req->status;
+
+        switch (status) {
+
+        case 0:                         /* normal completion? */
+                if (ep == ss->out_ep) {
+                        check_read_data(ss, req);
+                        memset(req->buf, 0x55, req->length);
+                } else
+                        reinit_write_data(ep, req);
+                break;
+
+        /* this endpoint is normally active while we're configured */
+        case -ECONNABORTED:             /* hardware forced ep reset */
+        case -ECONNRESET:               /* request dequeued */
+        case -ESHUTDOWN:                /* disconnect from host */
+                VDBG(cdev, "%s gone (%d), %d/%d\n", ep->name, status,
+                                req->actual, req->length);
+                if (ep == ss->out_ep)
+                        check_read_data(ss, req);
+                free_ep_req(ep, req);
+                return;
+
+        case -EOVERFLOW:                /* buffer overrun on read means that
+                                         * we didn't provide a big enough
+                                         * buffer.
+                                         */
+        default:
+#if 1
+                DBG(cdev, "%s complete --> %d, %d/%d\n", ep->name,
+                                status, req->actual, req->length);
+#endif
+        case -EREMOTEIO:                /* short read */
+                break;
+        }
+
+        status = usb_ep_queue(ep, req, GFP_ATOMIC);
+        if (status) {
+                ERROR(cdev, "kill %s:  resubmit %d bytes --> %d\n",
+                                ep->name, req->length, status);
+                usb_ep_set_halt(ep);
+                /* FIXME recover later ... somehow */
+        }
+}
+
+static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in)
+{
+        struct usb_ep           *ep;
+        struct usb_request      *req;
+        int                     status;
+
+        ep = is_in ? ss->in_ep : ss->out_ep;
+        req = alloc_ep_req(ep);
+        if (!req)
+                return -ENOMEM;
+
+        req->complete = source_sink_complete;
+        if (is_in)
+                reinit_write_data(ep, req);
+        else
+                memset(req->buf, 0x55, req->length);
+
+        status = usb_ep_queue(ep, req, GFP_ATOMIC);
+        if (status) {
+                struct usb_composite_dev        *cdev;
+
+                cdev = ss->function.config->cdev;
+                ERROR(cdev, "start %s %s --> %d\n",
+                                is_in ? "IN" : "OUT",
+                                ep->name, status);
+                free_ep_req(ep, req);
+        }
+
+        return status;
+}
+
+static void disable_source_sink(struct f_sourcesink *ss)
+{
+        struct usb_composite_dev        *cdev;
+
+        cdev = ss->function.config->cdev;
+        disable_endpoints(cdev, ss->in_ep, ss->out_ep);
+        del_timer(&ss->resume);
+        VDBG(cdev, "%s disabled\n", ss->function.name);
+}
+
+static int
+enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss)
+{
+        int                                     result = 0;
+        const struct usb_endpoint_descriptor    *src, *sink;
+        struct usb_ep                           *ep;
+
+        src = ep_choose(cdev->gadget, &hs_source_desc, &fs_source_desc);
+        sink = ep_choose(cdev->gadget, &hs_sink_desc, &fs_sink_desc);
+
+        /* one endpoint writes (sources) zeroes IN (to the host) */
+        ep = ss->in_ep;
+        result = usb_ep_enable(ep, src);
+        if (result < 0)
+                return result;
+        ep->driver_data = ss;
+
+        result = source_sink_start_ep(ss, true);
+        if (result < 0) {
+fail:
+                ep = ss->in_ep;
+                usb_ep_disable(ep);
+                ep->driver_data = NULL;
+                return result;
+        }
+
+        /* one endpoint reads (sinks) anything OUT (from the host) */
+        ep = ss->out_ep;
+        result = usb_ep_enable(ep, sink);
+        if (result < 0)
+                goto fail;
+        ep->driver_data = ss;
+
+        result = source_sink_start_ep(ss, false);
+        if (result < 0) {
+                usb_ep_disable(ep);
+                ep->driver_data = NULL;
+                goto fail;
+        }
+
+        DBG(cdev, "%s enabled\n", ss->function.name);
+        return result;
+}
+
+static int sourcesink_set_alt(struct usb_function *f,
+                unsigned intf, unsigned alt)
+{
+        struct f_sourcesink     *ss = func_to_ss(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        /* we know alt is zero */
+        if (ss->in_ep->driver_data)
+                disable_source_sink(ss);
+        return enable_source_sink(cdev, ss);
+}
+
+static void sourcesink_disable(struct usb_function *f)
+{
+        struct f_sourcesink     *ss = func_to_ss(f);
+
+        disable_source_sink(ss);
+}
+
+static void sourcesink_suspend(struct usb_function *f)
+{
+        struct f_sourcesink     *ss = func_to_ss(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        if (cdev->gadget->speed == USB_SPEED_UNKNOWN)
+                return;
+
+        if (autoresume) {
+                mod_timer(&ss->resume, jiffies + (HZ * autoresume));
+                DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
+        } else
+                DBG(cdev, "%s\n", __func__);
+}
+
+static void sourcesink_resume(struct usb_function *f)
+{
+        struct f_sourcesink     *ss = func_to_ss(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "%s\n", __func__);
+        del_timer(&ss->resume);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int __init sourcesink_bind_config(struct usb_configuration *c)
+{
+        struct f_sourcesink     *ss;
+        int                     status;
+
+        ss = kzalloc(sizeof *ss, GFP_KERNEL);
+        if (!ss)
+                return -ENOMEM;
+
+        ss->function.name = "source/sink";
+        ss->function.descriptors = fs_source_sink_descs;
+        ss->function.bind = sourcesink_bind;
+        ss->function.unbind = sourcesink_unbind;
+        ss->function.set_alt = sourcesink_set_alt;
+        ss->function.disable = sourcesink_disable;
+        ss->function.suspend = sourcesink_suspend;
+        ss->function.resume = sourcesink_resume;
+
+        status = usb_add_function(c, &ss->function);
+        if (status)
+                kfree(ss);
+        return status;
+}
+
+static int sourcesink_setup(struct usb_configuration *c,
+                const struct usb_ctrlrequest *ctrl)
+{
+        struct usb_request      *req = c->cdev->req;
+        int                     value = -EOPNOTSUPP;
+        u16                     w_index = le16_to_cpu(ctrl->wIndex);
+        u16                     w_value = le16_to_cpu(ctrl->wValue);
+        u16                     w_length = le16_to_cpu(ctrl->wLength);
+
+        /* composite driver infrastructure handles everything except
+         * the two control test requests.
+         */
+        switch (ctrl->bRequest) {
+
+        /*
+         * These are the same vendor-specific requests supported by
+         * Intel's USB 2.0 compliance test devices.  We exceed that
+         * device spec by allowing multiple-packet requests.
+         *
+         * NOTE:  the Control-OUT data stays in req->buf ... better
+         * would be copying it into a scratch buffer, so that other
+         * requests may safely intervene.
+         */
+        case 0x5b:      /* control WRITE test -- fill the buffer */
+                if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
+                        goto unknown;
+                if (w_value || w_index)
+                        break;
+                /* just read that many bytes into the buffer */
+                if (w_length > req->length)
+                        break;
+                value = w_length;
+                break;
+        case 0x5c:      /* control READ test -- return the buffer */
+                if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
+                        goto unknown;
+                if (w_value || w_index)
+                        break;
+                /* expect those bytes are still in the buffer; send back */
+                if (w_length > req->length)
+                        break;
+                value = w_length;
+                break;
+
+        default:
+unknown:
+                VDBG(c->cdev,
+                        "unknown control req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+        }
+
+        /* respond with data transfer or status phase? */
+        if (value >= 0) {
+                VDBG(c->cdev, "source/sink req%02x.%02x v%04x i%04x l%d\n",
+                        ctrl->bRequestType, ctrl->bRequest,
+                        w_value, w_index, w_length);
+                req->zero = 0;
+                req->length = value;
+                value = usb_ep_queue(c->cdev->gadget->ep0, req, GFP_ATOMIC);
+                if (value < 0)
+                        ERROR(c->cdev, "source/sinkc response, err %d\n",
+                                        value);
+        }
+
+        /* device either stalls (value < 0) or reports success */
+        return value;
+}
+
+static struct usb_configuration sourcesink_driver = {
+        .label          = "source/sink",
+        .strings        = sourcesink_strings,
+        .bind           = sourcesink_bind_config,
+        .setup          = sourcesink_setup,
+        .bConfigurationValue = 3,
+        .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower      = 1,    /* 2 mA, minimal */
+        /* .iConfiguration = DYNAMIC */
+};
+
+/**
+ * sourcesink_add - add a source/sink testing configuration to a device
+ * @cdev: the device to support the configuration
+ */
+int __init sourcesink_add(struct usb_composite_dev *cdev)
+{
+        int id;
+
+        /* allocate string ID(s) */
+        id = usb_string_id(cdev);
+        if (id < 0)
+                return id;
+        strings_sourcesink[0].id = id;
+
+        source_sink_intf.iInterface = id;
+        sourcesink_driver.iConfiguration = id;
+
+        /* support autoresume for remote wakeup testing */
+        if (autoresume)
+                sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+
+        /* support OTG systems */
+        if (gadget_is_otg(cdev->gadget)) {
+                sourcesink_driver.descriptors = otg_desc;
+                sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+        }
+
+        return usb_add_config(cdev, &sourcesink_driver);
+}
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
new file mode 100644
index 000000000000..afeab9a0523f
--- /dev/null
+++ b/drivers/usb/gadget/f_subset.c
@@ -0,0 +1,423 @@
+/*
+ * f_subset.c -- "CDC Subset" Ethernet link function driver
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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/kernel.h>
+#include <linux/device.h>
+#include <linux/etherdevice.h>
+
+#include "u_ether.h"
+
+
+/*
+ * This function packages a simple "CDC Subset" Ethernet port with no real
+ * control mechanisms; just raw data transfer over two bulk endpoints.
+ * The data transfer model is exactly that of CDC Ethernet, which is
+ * why we call it the "CDC Subset".
+ *
+ * Because it's not standardized, this has some interoperability issues.
+ * They mostly relate to driver binding, since the data transfer model is
+ * so simple (CDC Ethernet).  The original versions of this protocol used
+ * specific product/vendor IDs:  byteswapped IDs for Digital Equipment's
+ * SA-1100 "Itsy" board, which could run Linux 2.4 kernels and supported
+ * daughtercards with USB peripheral connectors.  (It was used more often
+ * with other boards, using the Itsy identifiers.)  Linux hosts recognized
+ * this with CONFIG_USB_ARMLINUX; these devices have only one configuration
+ * and one interface.
+ *
+ * At some point, MCCI defined a (nonconformant) CDC MDLM variant called
+ * "SAFE", which happens to have a mode which is identical to the "CDC
+ * Subset" in terms of data transfer and lack of control model.  This was
+ * adopted by later Sharp Zaurus models, and by some other software which
+ * Linux hosts recognize with CONFIG_USB_NET_ZAURUS.
+ *
+ * Because Microsoft's RNDIS drivers are far from robust, we added a few
+ * descriptors to the CDC Subset code, making this code look like a SAFE
+ * implementation.  This lets you use MCCI's host side MS-Windows drivers
+ * if you get fed up with RNDIS.  It also makes it easier for composite
+ * drivers to work, since they can use class based binding instead of
+ * caring about specific product and vendor IDs.
+ */
+
+struct geth_descs {
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+};
+
+struct f_gether {
+        struct gether                   port;
+
+        char                            ethaddr[14];
+
+        struct usb_descriptor_header    **fs_function;
+        struct geth_descs               fs;
+        struct usb_descriptor_header    **hs_function;
+        struct geth_descs               hs;
+};
+
+static inline struct f_gether *func_to_geth(struct usb_function *f)
+{
+        return container_of(f, struct f_gether, port.func);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * "Simple" CDC-subset option is a simple vendor-neutral model that most
+ * full speed controllers can handle:  one interface, two bulk endpoints.
+ * To assist host side drivers, we fancy it up a bit, and add descriptors so
+ * some host side drivers will understand it as a "SAFE" variant.
+ *
+ * "SAFE" loosely follows CDC WMC MDLM, violating the spec in various ways.
+ * Data endpoints live in the control interface, there's no data interface.
+ * And it's not used to talk to a cell phone radio.
+ */
+
+/* interface descriptor: */
+
+static struct usb_interface_descriptor subset_data_intf __initdata = {
+        .bLength =              sizeof subset_data_intf,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        /* .bInterfaceNumber = DYNAMIC */
+        .bAlternateSetting =    0,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_COMM,
+        .bInterfaceSubClass =   USB_CDC_SUBCLASS_MDLM,
+        .bInterfaceProtocol =   0,
+        /* .iInterface = DYNAMIC */
+};
+
+static struct usb_cdc_header_desc header_desc __initdata = {
+        .bLength =              sizeof header_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
+
+        .bcdCDC =               __constant_cpu_to_le16(0x0110),
+};
+
+static struct usb_cdc_mdlm_desc mdlm_desc __initdata = {
+        .bLength =              sizeof mdlm_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
+
+        .bcdVersion =           __constant_cpu_to_le16(0x0100),
+        .bGUID = {
+                0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
+                0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
+        },
+};
+
+/* since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
+ * can't really use its struct.  All we do here is say that we're using
+ * the submode of "SAFE" which directly matches the CDC Subset.
+ */
+static u8 mdlm_detail_desc[] __initdata = {
+        6,
+        USB_DT_CS_INTERFACE,
+        USB_CDC_MDLM_DETAIL_TYPE,
+
+        0,      /* "SAFE" */
+        0,      /* network control capabilities (none) */
+        0,      /* network data capabilities ("raw" encapsulation) */
+};
+
+static struct usb_cdc_ether_desc ether_desc __initdata = {
+        .bLength =              sizeof ether_desc,
+        .bDescriptorType =      USB_DT_CS_INTERFACE,
+        .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
+
+        /* this descriptor actually adds value, surprise! */
+        /* .iMACAddress = DYNAMIC */
+        .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
+        .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
+        .wNumberMCFilters =     __constant_cpu_to_le16(0),
+        .bNumberPowerFilters =  0,
+};
+
+/* full speed support: */
+
+static struct usb_endpoint_descriptor fs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_endpoint_descriptor fs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+};
+
+static struct usb_descriptor_header *fs_eth_function[] __initdata = {
+        (struct usb_descriptor_header *) &subset_data_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &mdlm_desc,
+        (struct usb_descriptor_header *) &mdlm_detail_desc,
+        (struct usb_descriptor_header *) &ether_desc,
+        (struct usb_descriptor_header *) &fs_in_desc,
+        (struct usb_descriptor_header *) &fs_out_desc,
+        NULL,
+};
+
+/* high speed support: */
+
+static struct usb_endpoint_descriptor hs_in_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_endpoint_descriptor hs_out_desc __initdata = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize =       __constant_cpu_to_le16(512),
+};
+
+static struct usb_descriptor_header *hs_eth_function[] __initdata = {
+        (struct usb_descriptor_header *) &subset_data_intf,
+        (struct usb_descriptor_header *) &header_desc,
+        (struct usb_descriptor_header *) &mdlm_desc,
+        (struct usb_descriptor_header *) &mdlm_detail_desc,
+        (struct usb_descriptor_header *) &ether_desc,
+        (struct usb_descriptor_header *) &hs_in_desc,
+        (struct usb_descriptor_header *) &hs_out_desc,
+        NULL,
+};
+
+/* string descriptors: */
+
+static struct usb_string geth_string_defs[] = {
+        [0].s = "CDC Ethernet Subset/SAFE",
+        [1].s = NULL /* DYNAMIC */,
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings geth_string_table = {
+        .language =             0x0409, /* en-us */
+        .strings =              geth_string_defs,
+};
+
+static struct usb_gadget_strings *geth_strings[] = {
+        &geth_string_table,
+        NULL,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+        struct f_gether         *geth = func_to_geth(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+        struct net_device       *net;
+
+        /* we know alt == 0, so this is an activation or a reset */
+
+        if (geth->port.in_ep->driver_data) {
+                DBG(cdev, "reset cdc subset\n");
+                gether_disconnect(&geth->port);
+        }
+
+        DBG(cdev, "init + activate cdc subset\n");
+        geth->port.in = ep_choose(cdev->gadget,
+                        geth->hs.in, geth->fs.in);
+        geth->port.out = ep_choose(cdev->gadget,
+                        geth->hs.out, geth->fs.out);
+
+        net = gether_connect(&geth->port);
+        return IS_ERR(net) ? PTR_ERR(net) : 0;
+}
+
+static void geth_disable(struct usb_function *f)
+{
+        struct f_gether *geth = func_to_geth(f);
+        struct usb_composite_dev *cdev = f->config->cdev;
+
+        DBG(cdev, "net deactivated\n");
+        gether_disconnect(&geth->port);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* serial function driver setup/binding */
+
+static int __init
+geth_bind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct f_gether         *geth = func_to_geth(f);
+        int                     status;
+        struct usb_ep           *ep;
+
+        /* allocate instance-specific interface IDs */
+        status = usb_interface_id(c, f);
+        if (status < 0)
+                goto fail;
+        subset_data_intf.bInterfaceNumber = status;
+
+        status = -ENODEV;
+
+        /* allocate instance-specific endpoints */
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_in_desc);
+        if (!ep)
+                goto fail;
+        geth->port.in_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        ep = usb_ep_autoconfig(cdev->gadget, &fs_out_desc);
+        if (!ep)
+                goto fail;
+        geth->port.out_ep = ep;
+        ep->driver_data = cdev; /* claim */
+
+        /* copy descriptors, and track endpoint copies */
+        f->descriptors = usb_copy_descriptors(fs_eth_function);
+
+        geth->fs.in = usb_find_endpoint(fs_eth_function,
+                        f->descriptors, &fs_in_desc);
+        geth->fs.out = usb_find_endpoint(fs_eth_function,
+                        f->descriptors, &fs_out_desc);
+
+
+        /* support all relevant hardware speeds... we expect that when
+         * hardware is dual speed, all bulk-capable endpoints work at
+         * both speeds
+         */
+        if (gadget_is_dualspeed(c->cdev->gadget)) {
+                hs_in_desc.bEndpointAddress =
+                                fs_in_desc.bEndpointAddress;
+                hs_out_desc.bEndpointAddress =
+                                fs_out_desc.bEndpointAddress;
+
+                /* copy descriptors, and track endpoint copies */
+                f->hs_descriptors = usb_copy_descriptors(hs_eth_function);
+
+                geth->hs.in = usb_find_endpoint(hs_eth_function,
+                                f->hs_descriptors, &hs_in_desc);
+                geth->hs.out = usb_find_endpoint(hs_eth_function,
+                                f->hs_descriptors, &hs_out_desc);
+        }
+
+        /* NOTE:  all that is done without knowing or caring about
+         * the network link ... which is unavailable to this code
+         * until we're activated via set_alt().
+         */
+
+        DBG(cdev, "CDC Subset: %s speed IN/%s OUT/%s\n",
+                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                        geth->port.in_ep->name, geth->port.out_ep->name);
+        return 0;
+
+fail:
+        /* we might as well release our claims on endpoints */
+        if (geth->port.out)
+                geth->port.out_ep->driver_data = NULL;
+        if (geth->port.in)
+                geth->port.in_ep->driver_data = NULL;
+
+        ERROR(cdev, "%s: can't bind, err %d\n", f->name, status);
+
+        return status;
+}
+
+static void
+geth_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        if (gadget_is_dualspeed(c->cdev->gadget))
+                usb_free_descriptors(f->hs_descriptors);
+        usb_free_descriptors(f->descriptors);
+        geth_string_defs[1].s = NULL;
+        kfree(func_to_geth(f));
+}
+
+/**
+ * geth_bind_config - add CDC Subset network link to a configuration
+ * @c: the configuration to support the network link
+ * @ethaddr: a buffer in which the ethernet address of the host side
+ *      side of the link was recorded
+ * Context: single threaded during gadget setup
+ *
+ * Returns zero on success, else negative errno.
+ *
+ * Caller must have called @gether_setup().  Caller is also responsible
+ * for calling @gether_cleanup() before module unload.
+ */
+int __init geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        struct f_gether *geth;
+        int             status;
+
+        if (!ethaddr)
+                return -EINVAL;
+
+        /* maybe allocate device-global string IDs */
+        if (geth_string_defs[0].id == 0) {
+
+                /* interface label */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                geth_string_defs[0].id = status;
+                subset_data_intf.iInterface = status;
+
+                /* MAC address */
+                status = usb_string_id(c->cdev);
+                if (status < 0)
+                        return status;
+                geth_string_defs[1].id = status;
+                ether_desc.iMACAddress = status;
+        }
+
+        /* allocate and initialize one new instance */
+        geth = kzalloc(sizeof *geth, GFP_KERNEL);
+        if (!geth)
+                return -ENOMEM;
+
+        /* export host's Ethernet address in CDC format */
+        snprintf(geth->ethaddr, sizeof geth->ethaddr,
+                "%02X%02X%02X%02X%02X%02X",
+                ethaddr[0], ethaddr[1], ethaddr[2],
+                ethaddr[3], ethaddr[4], ethaddr[5]);
+        geth_string_defs[1].s = geth->ethaddr;
+
+        geth->port.cdc_filter = DEFAULT_FILTER;
+
+        geth->port.func.name = "cdc_subset";
+        geth->port.func.strings = geth_strings;
+        geth->port.func.bind = geth_bind;
+        geth->port.func.unbind = geth_unbind;
+        geth->port.func.set_alt = geth_set_alt;
+        geth->port.func.disable = geth_disable;
+
+        status = usb_add_function(c, &geth->port.func);
+        if (status) {
+                geth_string_defs[1].s = NULL;
+                kfree(geth);
+        }
+        return status;
+}
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 47bb9f09a1aa..15c24edbb61a 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -3867,8 +3867,8 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 curlun->dev.parent = &gadget->dev;
                 curlun->dev.driver = &fsg_driver.driver;
                 dev_set_drvdata(&curlun->dev, fsg);
-                snprintf(curlun->dev.bus_id, BUS_ID_SIZE,
-                                "%s-lun%d", gadget->dev.bus_id, i);
+                dev_set_name(&curlun->dev,"%s-lun%d",
+                             dev_name(&gadget->dev), i);
 
                 if ((rc = device_register(&curlun->dev)) != 0) {
                         INFO(fsg, "failed to register LUN%d: %d\n", i, rc);
diff --git a/drivers/usb/gadget/fsl_usb2_udc.c b/drivers/usb/gadget/fsl_usb2_udc.c
index 18687543d7fa..1695382f30fe 100644
--- a/drivers/usb/gadget/fsl_usb2_udc.c
+++ b/drivers/usb/gadget/fsl_usb2_udc.c
@@ -2331,7 +2331,7 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
         udc_controller->gadget.name = driver_name;
 
         /* Setup gadget.dev and register with kernel */
-        strcpy(udc_controller->gadget.dev.bus_id, "gadget");
+        dev_set_name(&udc_controller->gadget.dev, "gadget");
         udc_controller->gadget.dev.release = fsl_udc_release;
         udc_controller->gadget.dev.parent = &pdev->dev;
         ret = device_register(&udc_controller->gadget.dev);
diff --git a/drivers/usb/gadget/g_zero.h b/drivers/usb/gadget/g_zero.h
new file mode 100644
index 000000000000..dd2f16ad5a88
--- /dev/null
+++ b/drivers/usb/gadget/g_zero.h
@@ -0,0 +1,25 @@
+/*
+ * This header declares the utility functions used by "Gadget Zero", plus
+ * interfaces to its two single-configuration function drivers.
+ */
+
+#ifndef __G_ZERO_H
+#define __G_ZERO_H
+
+#include <linux/usb/composite.h>
+
+/* global state */
+extern unsigned buflen;
+extern const struct usb_descriptor_header *otg_desc[];
+
+/* common utilities */
+struct usb_request *alloc_ep_req(struct usb_ep *ep);
+void free_ep_req(struct usb_ep *ep, struct usb_request *req);
+void disable_endpoints(struct usb_composite_dev *cdev,
+                struct usb_ep *in, struct usb_ep *out);
+
+/* configuration-specific linkup */
+int sourcesink_add(struct usb_composite_dev *cdev);
+int loopback_add(struct usb_composite_dev *cdev);
+
+#endif /* __G_ZERO_H */
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index ca5149ea7312..5246e8fef2b2 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -214,3 +214,26 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x21;
         return -ENOENT;
 }
+
+
+/**
+ * gadget_supports_altsettings - return true if altsettings work
+ * @gadget: the gadget in question
+ */
+static inline bool gadget_supports_altsettings(struct usb_gadget *gadget)
+{
+        /* PXA 21x/25x/26x has no altsettings at all */
+        if (gadget_is_pxa(gadget))
+                return false;
+
+        /* PXA 27x and 3xx have *broken* altsetting support */
+        if (gadget_is_pxa27x(gadget))
+                return false;
+
+        /* SH3 hardware just doesn't do altsettings */
+        if (gadget_is_sh(gadget))
+                return false;
+
+        /* Everything else is *presumably* fine ... */
+        return true;
+}
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index be6613afedbf..48f1c63b7013 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1790,7 +1790,7 @@ static int goku_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         dev->gadget.ops = &goku_ops;
 
         /* the "gadget" abstracts/virtualizes the controller */
-        strcpy(dev->gadget.dev.bus_id, "gadget");
+        dev_set_name(&dev->gadget.dev, "gadget");
         dev->gadget.dev.parent = &pdev->dev;
         dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
         dev->gadget.dev.release = gadget_release;
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index f132a9219e11..04692d59fc1c 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -32,6 +32,7 @@
 #include <asm/uaccess.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
+#include <linux/smp_lock.h>
 
 #include <linux/device.h>
 #include <linux/moduleparam.h>
@@ -483,8 +484,7 @@ ep_release (struct inode *inode, struct file *fd)
         return 0;
 }
 
-static int ep_ioctl (struct inode *inode, struct file *fd,
-                unsigned code, unsigned long value)
+static long ep_ioctl(struct file *fd, unsigned code, unsigned long value)
 {
         struct ep_data          *data = fd->private_data;
         int                     status;
@@ -740,7 +740,7 @@ static const struct file_operations ep_io_operations = {
 
         .read =         ep_read,
         .write =        ep_write,
-        .ioctl =        ep_ioctl,
+        .unlocked_ioctl = ep_ioctl,
         .release =      ep_release,
 
         .aio_read =     ep_aio_read,
@@ -1294,15 +1294,18 @@ out:
        return mask;
 }
 
-static int dev_ioctl (struct inode *inode, struct file *fd,
-                unsigned code, unsigned long value)
+static long dev_ioctl (struct file *fd, unsigned code, unsigned long value)
 {
         struct dev_data         *dev = fd->private_data;
         struct usb_gadget       *gadget = dev->gadget;
+        long ret = -ENOTTY;
 
-        if (gadget->ops->ioctl)
-                return gadget->ops->ioctl (gadget, code, value);
-        return -ENOTTY;
+        if (gadget->ops->ioctl) {
+                lock_kernel();
+                ret = gadget->ops->ioctl (gadget, code, value);
+                unlock_kernel();
+        }
+        return ret;
 }
 
 /* used after device configuration */
@@ -1314,7 +1317,7 @@ static const struct file_operations ep0_io_operations = {
         .write =        ep0_write,
         .fasync =       ep0_fasync,
         .poll =         ep0_poll,
-        .ioctl =        dev_ioctl,
+        .unlocked_ioctl =       dev_ioctl,
         .release =      dev_release,
 };
 
@@ -1964,7 +1967,7 @@ static const struct file_operations dev_init_operations = {
         .open =         dev_open,
         .write =        dev_config,
         .fasync =       ep0_fasync,
-        .ioctl =        dev_ioctl,
+        .unlocked_ioctl = dev_ioctl,
         .release =      dev_release,
 };
 
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
index 825abd2621b3..c6e7df04c69a 100644
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ b/drivers/usb/gadget/lh7a40x_udc.c
@@ -1970,7 +1970,7 @@ static const struct usb_gadget_ops lh7a40x_udc_ops = {
 
 static void nop_release(struct device *dev)
 {
-        DEBUG("%s %s\n", __func__, dev->bus_id);
+        DEBUG("%s %s\n", __func__, dev_name(dev));
 }
 
 static struct lh7a40x_udc memory = {
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index ee6b35fa870f..8da7535c0c70 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1593,7 +1593,7 @@ static int __init m66592_probe(struct platform_device *pdev)
 
         m66592->gadget.ops = &m66592_gadget_ops;
         device_initialize(&m66592->gadget.dev);
-        strcpy(m66592->gadget.dev.bus_id, "gadget");
+        dev_set_name(&m66592->gadget, "gadget");
         m66592->gadget.is_dualspeed = 1;
         m66592->gadget.dev.parent = &pdev->dev;
         m66592->gadget.dev.dma_mask = pdev->dev.dma_mask;
diff --git a/drivers/usb/gadget/ndis.h b/drivers/usb/gadget/ndis.h
index 09e3ee4eeae1..df886cec5ef4 100644
--- a/drivers/usb/gadget/ndis.h
+++ b/drivers/usb/gadget/ndis.h
@@ -1,11 +1,11 @@
 /*
- * ndis.h 
- * 
+ * ndis.h
+ *
  * ntddndis.h modified by Benedikt Spranger <b.spranger@pengutronix.de>
- * 
- * Thanks to the cygwin development team, 
+ *
+ * Thanks to the cygwin development team,
  * espacially to Casper S. Hornstrup <chorns@users.sourceforge.net>
- * 
+ *
  * THIS SOFTWARE IS NOT COPYRIGHTED
  *
  * This source code is offered for use in the public domain. You may
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index e01862300169..b67ab677af72 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -2768,7 +2768,7 @@ static int net2280_probe (struct pci_dev *pdev, const struct pci_device_id *id)
         dev->gadget.is_dualspeed = 1;
 
         /* the "gadget" abstracts/virtualizes the controller */
-        strcpy (dev->gadget.dev.bus_id, "gadget");
+        dev_set_name(&dev->gadget.dev, "gadget");
         dev->gadget.dev.parent = &pdev->dev;
         dev->gadget.dev.dma_mask = pdev->dev.dma_mask;
         dev->gadget.dev.release = gadget_release;
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 03a7f49d207d..4b79a8509e84 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -2686,7 +2686,7 @@ omap_udc_setup(struct platform_device *odev, struct otg_transceiver *xceiv)
         udc->gadget.name = driver_name;
 
         device_initialize(&udc->gadget.dev);
-        strcpy (udc->gadget.dev.bus_id, "gadget");
+        dev_set_name(&udc->gadget.dev, "gadget");
         udc->gadget.dev.release = omap_udc_release;
         udc->gadget.dev.parent = &odev->dev;
         if (use_dma)
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index ec8f2eb041ca..9caaec3ae9a3 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -828,9 +828,8 @@ printer_poll(struct file *fd, poll_table *wait)
         return status;
 }
 
-static int
-printer_ioctl(struct inode *inode, struct file *fd, unsigned int code,
-                unsigned long arg)
+static long
+printer_ioctl(struct file *fd, unsigned int code, unsigned long arg)
 {
         struct printer_dev      *dev = fd->private_data;
         unsigned long           flags;
@@ -869,7 +868,7 @@ static struct file_operations printer_io_operations = {
         .write =        printer_write,
         .fsync =        printer_fsync,
         .poll =         printer_poll,
-        .ioctl =        printer_ioctl,
+        .unlocked_ioctl = printer_ioctl,
         .release =      printer_close
 };
 
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index 031dceb93023..fbd6289977c8 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -1818,7 +1818,7 @@ pxa25x_udc_irq(int irq, void *_dev)
 
 static void nop_release (struct device *dev)
 {
-        DMSG("%s %s\n", __func__, dev->bus_id);
+        DMSG("%s %s\n", __func__, dev_name(dev));
 }
 
 /* this uses load-time allocation and initialization (instead of
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 9c0e82ec5c43..9d447d8cfc0c 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -1575,7 +1575,6 @@ static void udc_enable(struct pxa_udc *udc)
 {
         udc_writel(udc, UDCICR0, 0);
         udc_writel(udc, UDCICR1, 0);
-        udc_writel(udc, UP2OCR, UP2OCR_HXOE);
         udc_clear_mask_UDCCR(udc, UDCCR_UDE);
 
         clk_enable(udc->clk);
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index d0677f5d3cd5..7228e8562236 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -1,8 +1,6 @@
 /*
  * RNDIS MSG parser
  *
- * Version:     $Id: rndis.c,v 1.19 2004/03/25 21:33:46 robert Exp $
- *
  * Authors:     Benedikt Spranger, Pengutronix
  *              Robert Schwebel, Pengutronix
  *
@@ -30,6 +28,7 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/netdevice.h>
 
 #include <asm/io.h>
@@ -38,9 +37,7 @@
 #include <asm/unaligned.h>
 
 
-#undef  RNDIS_PM
-#undef  RNDIS_WAKEUP
-#undef  VERBOSE
+#undef  VERBOSE_DEBUG
 
 #include "rndis.h"
 
@@ -96,9 +93,6 @@ static const u32 oid_supported_list [] =
         OID_GEN_MAXIMUM_TOTAL_SIZE,
         OID_GEN_MEDIA_CONNECT_STATUS,
         OID_GEN_PHYSICAL_MEDIUM,
-#if 0
-        OID_GEN_RNDIS_CONFIG_PARAMETER,
-#endif
 
         /* the statistical stuff */
         OID_GEN_XMIT_OK,
@@ -146,7 +140,14 @@ static const u32 oid_supported_list [] =
 #endif  /* RNDIS_OPTIONAL_STATS */
 
 #ifdef  RNDIS_PM
-        /* PM and wakeup are mandatory for USB: */
+        /* PM and wakeup are "mandatory" for USB, but the RNDIS specs
+         * don't say what they mean ... and the NDIS specs are often
+         * confusing and/or ambiguous in this context.  (That is, more
+         * so than their specs for the other OIDs.)
+         *
+         * FIXME someone who knows what these should do, please
+         * implement them!
+         */
 
         /* power management */
         OID_PNP_CAPABILITIES,
@@ -173,6 +174,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         __le32                  *outbuf;
         int                     i, count;
         rndis_query_cmplt_type  *resp;
+        struct net_device       *net;
+        struct net_device_stats *stats;
 
         if (!r) return -ENOMEM;
         resp = (rndis_query_cmplt_type *) r->buf;
@@ -194,6 +197,12 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         outbuf = (__le32 *) &resp[1];
         resp->InformationBufferOffset = __constant_cpu_to_le32 (16);
 
+        net = rndis_per_dev_params[configNr].dev;
+        if (net->get_stats)
+                stats = net->get_stats(net);
+        else
+                stats = NULL;
+
         switch (OID) {
 
         /* general oids (table 4-1) */
@@ -350,11 +359,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_XMIT_OK:
                 if (rndis_debug > 1)
                         DBG("%s: OID_GEN_XMIT_OK\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (
-                            rndis_per_dev_params [configNr].stats->tx_packets -
-                            rndis_per_dev_params [configNr].stats->tx_errors -
-                            rndis_per_dev_params [configNr].stats->tx_dropped);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->tx_packets
+                                - stats->tx_errors - stats->tx_dropped);
                         retval = 0;
                 }
                 break;
@@ -363,11 +370,9 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_RCV_OK:
                 if (rndis_debug > 1)
                         DBG("%s: OID_GEN_RCV_OK\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (
-                            rndis_per_dev_params [configNr].stats->rx_packets -
-                            rndis_per_dev_params [configNr].stats->rx_errors -
-                            rndis_per_dev_params [configNr].stats->rx_dropped);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->rx_packets
+                                - stats->rx_errors - stats->rx_dropped);
                         retval = 0;
                 }
                 break;
@@ -376,9 +381,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_XMIT_ERROR:
                 if (rndis_debug > 1)
                         DBG("%s: OID_GEN_XMIT_ERROR\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->tx_errors);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->tx_errors);
                         retval = 0;
                 }
                 break;
@@ -387,9 +391,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         case OID_GEN_RCV_ERROR:
                 if (rndis_debug > 1)
                         DBG("%s: OID_GEN_RCV_ERROR\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_errors);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->rx_errors);
                         retval = 0;
                 }
                 break;
@@ -397,150 +400,12 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_GEN_RCV_NO_BUFFER:
                 DBG("%s: OID_GEN_RCV_NO_BUFFER\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_dropped);
-                        retval = 0;
-                }
-                break;
-
-#ifdef  RNDIS_OPTIONAL_STATS
-        case OID_GEN_DIRECTED_BYTES_XMIT:
-                DBG("%s: OID_GEN_DIRECTED_BYTES_XMIT\n", __func__);
-                /*
-                 * Aunt Tilly's size of shoes
-                 * minus antarctica count of penguins
-                 * divided by weight of Alpha Centauri
-                 */
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (
-                                (rndis_per_dev_params [configNr]
-                                        .stats->tx_packets -
-                                 rndis_per_dev_params [configNr]
-                                         .stats->tx_errors -
-                                 rndis_per_dev_params [configNr]
-                                         .stats->tx_dropped)
-                                * 123);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_DIRECTED_FRAMES_XMIT:
-                DBG("%s: OID_GEN_DIRECTED_FRAMES_XMIT\n", __func__);
-                /* dito */
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (
-                                (rndis_per_dev_params [configNr]
-                                        .stats->tx_packets -
-                                 rndis_per_dev_params [configNr]
-                                         .stats->tx_errors -
-                                 rndis_per_dev_params [configNr]
-                                         .stats->tx_dropped)
-                                / 123);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_MULTICAST_BYTES_XMIT:
-                DBG("%s: OID_GEN_MULTICAST_BYTES_XMIT\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->multicast*1234);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_MULTICAST_FRAMES_XMIT:
-                DBG("%s: OID_GEN_MULTICAST_FRAMES_XMIT\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->multicast);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_BROADCAST_BYTES_XMIT:
-                DBG("%s: OID_GEN_BROADCAST_BYTES_XMIT\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->tx_packets/42*255);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_BROADCAST_FRAMES_XMIT:
-                DBG("%s: OID_GEN_BROADCAST_FRAMES_XMIT\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->tx_packets/42);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_DIRECTED_BYTES_RCV:
-                DBG("%s: OID_GEN_DIRECTED_BYTES_RCV\n", __func__);
-                *outbuf = __constant_cpu_to_le32 (0);
-                retval = 0;
-                break;
-
-        case OID_GEN_DIRECTED_FRAMES_RCV:
-                DBG("%s: OID_GEN_DIRECTED_FRAMES_RCV\n", __func__);
-                *outbuf = __constant_cpu_to_le32 (0);
-                retval = 0;
-                break;
-
-        case OID_GEN_MULTICAST_BYTES_RCV:
-                DBG("%s: OID_GEN_MULTICAST_BYTES_RCV\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->multicast * 1111);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_MULTICAST_FRAMES_RCV:
-                DBG("%s: OID_GEN_MULTICAST_FRAMES_RCV\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->multicast);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_BROADCAST_BYTES_RCV:
-                DBG("%s: OID_GEN_BROADCAST_BYTES_RCV\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_packets/42*255);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_BROADCAST_FRAMES_RCV:
-                DBG("%s: OID_GEN_BROADCAST_FRAMES_RCV\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_packets/42);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->rx_dropped);
                         retval = 0;
                 }
                 break;
 
-        case OID_GEN_RCV_CRC_ERROR:
-                DBG("%s: OID_GEN_RCV_CRC_ERROR\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_crc_errors);
-                        retval = 0;
-                }
-                break;
-
-        case OID_GEN_TRANSMIT_QUEUE_LENGTH:
-                DBG("%s: OID_GEN_TRANSMIT_QUEUE_LENGTH\n", __func__);
-                *outbuf = __constant_cpu_to_le32 (0);
-                retval = 0;
-                break;
-#endif  /* RNDIS_OPTIONAL_STATS */
-
         /* ieee802.3 OIDs (table 4-3) */
 
         /* mandatory */
@@ -592,9 +457,8 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
         /* mandatory */
         case OID_802_3_RCV_ERROR_ALIGNMENT:
                 DBG("%s: OID_802_3_RCV_ERROR_ALIGNMENT\n", __func__);
-                if (rndis_per_dev_params [configNr].stats) {
-                        *outbuf = cpu_to_le32 (rndis_per_dev_params [configNr]
-                                        .stats->rx_frame_errors);
+                if (stats) {
+                        *outbuf = cpu_to_le32(stats->rx_frame_errors);
                         retval = 0;
                 }
                 break;
@@ -613,64 +477,6 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                 retval = 0;
                 break;
 
-#ifdef  RNDIS_OPTIONAL_STATS
-        case OID_802_3_XMIT_DEFERRED:
-                DBG("%s: OID_802_3_XMIT_DEFERRED\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_XMIT_MAX_COLLISIONS:
-                DBG("%s: OID_802_3_XMIT_MAX_COLLISIONS\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_RCV_OVERRUN:
-                DBG("%s: OID_802_3_RCV_OVERRUN\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_XMIT_UNDERRUN:
-                DBG("%s: OID_802_3_XMIT_UNDERRUN\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_XMIT_HEARTBEAT_FAILURE:
-                DBG("%s: OID_802_3_XMIT_HEARTBEAT_FAILURE\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_XMIT_TIMES_CRS_LOST:
-                DBG("%s: OID_802_3_XMIT_TIMES_CRS_LOST\n", __func__);
-                /* TODO */
-                break;
-
-        case OID_802_3_XMIT_LATE_COLLISIONS:
-                DBG("%s: OID_802_3_XMIT_LATE_COLLISIONS\n", __func__);
-                /* TODO */
-                break;
-#endif  /* RNDIS_OPTIONAL_STATS */
-
-#ifdef  RNDIS_PM
-        /* power management OIDs (table 4-5) */
-        case OID_PNP_CAPABILITIES:
-                DBG("%s: OID_PNP_CAPABILITIES\n", __func__);
-
-                /* for now, no wakeup capabilities */
-                length = sizeof (struct NDIS_PNP_CAPABILITIES);
-                memset(outbuf, 0, length);
-                retval = 0;
-                break;
-        case OID_PNP_QUERY_POWER:
-                DBG("%s: OID_PNP_QUERY_POWER D%d\n", __func__,
-                                get_unaligned_le32(buf) - 1);
-                /* only suspend is a real power state, and
-                 * it can't be entered by OID_PNP_SET_POWER...
-                 */
-                length = 0;
-                retval = 0;
-                break;
-#endif
-
         default:
                 pr_warning("%s: query unknown OID 0x%08X\n",
                          __func__, OID);
@@ -726,9 +532,6 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                  * what makes the packet flow start and stop, like
                  * activating the CDC Ethernet altsetting.
                  */
-#ifdef  RNDIS_PM
-update_linkstate:
-#endif
                 retval = 0;
                 if (*params->filter) {
                         params->state = RNDIS_DATA_INITIALIZED;
@@ -747,49 +550,6 @@ update_linkstate:
                 DBG("%s: OID_802_3_MULTICAST_LIST\n", __func__);
                 retval = 0;
                 break;
-#if 0
-        case OID_GEN_RNDIS_CONFIG_PARAMETER:
-                {
-                struct rndis_config_parameter   *param;
-                param = (struct rndis_config_parameter *) buf;
-                DBG("%s: OID_GEN_RNDIS_CONFIG_PARAMETER '%*s'\n",
-                        __func__,
-                        min(cpu_to_le32(param->ParameterNameLength),80),
-                        buf + param->ParameterNameOffset);
-                retval = 0;
-                }
-                break;
-#endif
-
-#ifdef  RNDIS_PM
-        case OID_PNP_SET_POWER:
-                /* The only real power state is USB suspend, and RNDIS requests
-                 * can't enter it; this one isn't really about power.  After
-                 * resuming, Windows forces a reset, and then SET_POWER D0.
-                 * FIXME ... then things go batty; Windows wedges itself.
-                 */
-                i = get_unaligned_le32(buf);
-                DBG("%s: OID_PNP_SET_POWER D%d\n", __func__, i - 1);
-                switch (i) {
-                case NdisDeviceStateD0:
-                        *params->filter = params->saved_filter;
-                        goto update_linkstate;
-                case NdisDeviceStateD3:
-                case NdisDeviceStateD2:
-                case NdisDeviceStateD1:
-                        params->saved_filter = *params->filter;
-                        retval = 0;
-                        break;
-                }
-                break;
-
-#ifdef  RNDIS_WAKEUP
-        // no wakeup support advertised, so wakeup OIDs always fail:
-        //  - OID_PNP_ENABLE_WAKE_UP
-        //  - OID_PNP_{ADD,REMOVE}_WAKE_UP_PATTERN
-#endif
-
-#endif  /* RNDIS_PM */
 
         default:
                 pr_warning("%s: set unknown OID 0x%08X, size %d\n",
@@ -807,8 +567,10 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
 {
         rndis_init_cmplt_type   *resp;
         rndis_resp_t            *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
-        if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
+        if (!params->dev)
+                return -ENOTSUPP;
 
         r = rndis_add_response (configNr, sizeof (rndis_init_cmplt_type));
         if (!r)
@@ -826,7 +588,7 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
         resp->Medium = __constant_cpu_to_le32 (RNDIS_MEDIUM_802_3);
         resp->MaxPacketsPerTransfer = __constant_cpu_to_le32 (1);
         resp->MaxTransferSize = cpu_to_le32 (
-                  rndis_per_dev_params [configNr].dev->mtu
+                  params->dev->mtu
                 + sizeof (struct ethhdr)
                 + sizeof (struct rndis_packet_msg_type)
                 + 22);
@@ -834,10 +596,7 @@ static int rndis_init_response (int configNr, rndis_init_msg_type *buf)
         resp->AFListOffset = __constant_cpu_to_le32 (0);
         resp->AFListSize = __constant_cpu_to_le32 (0);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
-
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -845,9 +604,11 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
 {
         rndis_query_cmplt_type *resp;
         rndis_resp_t            *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
         // DBG("%s: OID = %08X\n", __func__, cpu_to_le32(buf->OID));
-        if (!rndis_per_dev_params [configNr].dev) return -ENOTSUPP;
+        if (!params->dev)
+                return -ENOTSUPP;
 
         /*
          * we need more memory:
@@ -878,9 +639,7 @@ static int rndis_query_response (int configNr, rndis_query_msg_type *buf)
         } else
                 resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -889,6 +648,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
         u32                     BufLength, BufOffset;
         rndis_set_cmplt_type    *resp;
         rndis_resp_t            *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
         r = rndis_add_response (configNr, sizeof (rndis_set_cmplt_type));
         if (!r)
@@ -898,7 +658,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
         BufLength = le32_to_cpu (buf->InformationBufferLength);
         BufOffset = le32_to_cpu (buf->InformationBufferOffset);
 
-#ifdef  VERBOSE
+#ifdef  VERBOSE_DEBUG
         DBG("%s: Length: %d\n", __func__, BufLength);
         DBG("%s: Offset: %d\n", __func__, BufOffset);
         DBG("%s: InfoBuffer: ", __func__);
@@ -919,10 +679,7 @@ static int rndis_set_response (int configNr, rndis_set_msg_type *buf)
         else
                 resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
-
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -930,6 +687,7 @@ static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
 {
         rndis_reset_cmplt_type  *resp;
         rndis_resp_t            *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
         r = rndis_add_response (configNr, sizeof (rndis_reset_cmplt_type));
         if (!r)
@@ -942,10 +700,7 @@ static int rndis_reset_response (int configNr, rndis_reset_msg_type *buf)
         /* resent information */
         resp->AddressingReset = __constant_cpu_to_le32 (1);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
-
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -954,6 +709,7 @@ static int rndis_keepalive_response (int configNr,
 {
         rndis_keepalive_cmplt_type      *resp;
         rndis_resp_t                    *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
         /* host "should" check only in RNDIS_DATA_INITIALIZED state */
 
@@ -968,10 +724,7 @@ static int rndis_keepalive_response (int configNr,
         resp->RequestID = buf->RequestID; /* Still LE in msg buffer */
         resp->Status = __constant_cpu_to_le32 (RNDIS_STATUS_SUCCESS);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
-
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -983,8 +736,9 @@ static int rndis_indicate_status_msg (int configNr, u32 status)
 {
         rndis_indicate_status_msg_type  *resp;
         rndis_resp_t                    *r;
+        struct rndis_params     *params = rndis_per_dev_params + configNr;
 
-        if (rndis_per_dev_params [configNr].state == RNDIS_UNINITIALIZED)
+        if (params->state == RNDIS_UNINITIALIZED)
                 return -ENOTSUPP;
 
         r = rndis_add_response (configNr,
@@ -1000,9 +754,7 @@ static int rndis_indicate_status_msg (int configNr, u32 status)
         resp->StatusBufferLength = __constant_cpu_to_le32 (0);
         resp->StatusBufferOffset = __constant_cpu_to_le32 (0);
 
-        if (rndis_per_dev_params [configNr].ack)
-                rndis_per_dev_params [configNr].ack (
-                        rndis_per_dev_params [configNr].dev);
+        params->resp_avail(params->v);
         return 0;
 }
 
@@ -1029,7 +781,6 @@ void rndis_uninit (int configNr)
 
         if (configNr >= RNDIS_MAX_CONFIGS)
                 return;
-        rndis_per_dev_params [configNr].used = 0;
         rndis_per_dev_params [configNr].state = RNDIS_UNINITIALIZED;
 
         /* drain the response queue */
@@ -1142,21 +893,25 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
         return -ENOTSUPP;
 }
 
-int rndis_register (int (* rndis_control_ack) (struct net_device *))
+int rndis_register(void (*resp_avail)(void *v), void *v)
 {
         u8 i;
 
+        if (!resp_avail)
+                return -EINVAL;
+
         for (i = 0; i < RNDIS_MAX_CONFIGS; i++) {
                 if (!rndis_per_dev_params [i].used) {
                         rndis_per_dev_params [i].used = 1;
-                        rndis_per_dev_params [i].ack = rndis_control_ack;
+                        rndis_per_dev_params [i].resp_avail = resp_avail;
+                        rndis_per_dev_params [i].v = v;
                         DBG("%s: configNr = %d\n", __func__, i);
                         return i;
                 }
         }
         DBG("failed\n");
 
-        return -1;
+        return -ENODEV;
 }
 
 void rndis_deregister (int configNr)
@@ -1169,16 +924,14 @@ void rndis_deregister (int configNr)
         return;
 }
 
-int rndis_set_param_dev (u8 configNr, struct net_device *dev,
-                         struct net_device_stats *stats,
-                         u16 *cdc_filter)
+int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
 {
         DBG("%s:\n", __func__ );
-        if (!dev || !stats) return -1;
+        if (!dev)
+                return -EINVAL;
         if (configNr >= RNDIS_MAX_CONFIGS) return -1;
 
         rndis_per_dev_params [configNr].dev = dev;
-        rndis_per_dev_params [configNr].stats = stats;
         rndis_per_dev_params [configNr].filter = cdc_filter;
 
         return 0;
@@ -1296,14 +1049,11 @@ int rndis_rm_hdr(struct sk_buff *skb)
 
 #ifdef  CONFIG_USB_GADGET_DEBUG_FILES
 
-static int rndis_proc_read (char *page, char **start, off_t off, int count, int *eof,
-                void *data)
+static int rndis_proc_show(struct seq_file *m, void *v)
 {
-        char *out = page;
-        int len;
-        rndis_params *param = (rndis_params *) data;
+        rndis_params *param = m->private;
 
-        out += snprintf (out, count,
+        seq_printf(m,
                          "Config Nr. %d\n"
                          "used      : %s\n"
                          "state     : %s\n"
@@ -1326,25 +1076,13 @@ static int rndis_proc_read (char *page, char **start, off_t off, int count, int
                          (param->media_state) ? 0 : param->speed*100,
                          (param->media_state) ? "disconnected" : "connected",
                          param->vendorID, param->vendorDescr);
-
-        len = out - page;
-        len -= off;
-
-        if (len < count) {
-                *eof = 1;
-                if (len <= 0)
-                        return 0;
-        } else
-                len = count;
-
-        *start = page + off;
-        return len;
+        return 0;
 }
 
-static int rndis_proc_write (struct file *file, const char __user *buffer,
-                unsigned long count, void *data)
+static ssize_t rndis_proc_write(struct file *file, const char __user *buffer,
+                size_t count, loff_t *ppos)
 {
-        rndis_params *p = data;
+        rndis_params *p = PDE(file->f_path.dentry->d_inode)->data;
         u32 speed = 0;
         int i, fl_speed = 0;
 
@@ -1386,6 +1124,20 @@ static int rndis_proc_write (struct file *file, const char __user *buffer,
         return count;
 }
 
+static int rndis_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, rndis_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations rndis_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = rndis_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+        .write          = rndis_proc_write,
+};
+
 #define NAME_TEMPLATE   "driver/rndis-%03d"
 
 static struct proc_dir_entry *rndis_connect_state [RNDIS_MAX_CONFIGS];
@@ -1403,7 +1155,9 @@ int __init rndis_init (void)
 
                 sprintf (name, NAME_TEMPLATE, i);
                 if (!(rndis_connect_state [i]
-                                = create_proc_entry (name, 0660, NULL)))
+                                = proc_create_data(name, 0660, NULL,
+                                        &rndis_proc_fops,
+                                        (void *)(rndis_per_dev_params + i))))
                 {
                         DBG("%s :remove entries", __func__);
                         while (i) {
@@ -1413,11 +1167,6 @@ int __init rndis_init (void)
                         DBG("\n");
                         return -EIO;
                 }
-
-                rndis_connect_state [i]->write_proc = rndis_proc_write;
-                rndis_connect_state [i]->read_proc = rndis_proc_read;
-                rndis_connect_state [i]->data = (void *)
-                                (rndis_per_dev_params + i);
 #endif
                 rndis_per_dev_params [i].confignr = i;
                 rndis_per_dev_params [i].used = 0;
diff --git a/drivers/usb/gadget/rndis.h b/drivers/usb/gadget/rndis.h
index 397b149f3ca7..aac61dfe0f03 100644
--- a/drivers/usb/gadget/rndis.h
+++ b/drivers/usb/gadget/rndis.h
@@ -1,8 +1,6 @@
 /*
  * RNDIS        Definitions for Remote NDIS
  *
- * Version:     $Id: rndis.h,v 1.15 2004/03/25 21:33:46 robert Exp $
- *
  * Authors:     Benedikt Spranger, Pengutronix
  *              Robert Schwebel, Pengutronix
  *
@@ -235,20 +233,19 @@ typedef struct rndis_params
         const u8                *host_mac;
         u16                     *filter;
         struct net_device       *dev;
-        struct net_device_stats *stats;
 
         u32                     vendorID;
         const char              *vendorDescr;
-        int                     (*ack) (struct net_device *);
+        void                    (*resp_avail)(void *v);
+        void                    *v;
         struct list_head        resp_queue;
 } rndis_params;
 
 /* RNDIS Message parser and other useless functions */
 int  rndis_msg_parser (u8 configNr, u8 *buf);
-int  rndis_register (int (*rndis_control_ack) (struct net_device *));
+int  rndis_register(void (*resp_avail)(void *v), void *v);
 void rndis_deregister (int configNr);
 int  rndis_set_param_dev (u8 configNr, struct net_device *dev,
-                         struct net_device_stats *stats,
                          u16 *cdc_filter);
 int  rndis_set_param_vendor (u8 configNr, u32 vendorID,
                             const char *vendorDescr);
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index fa019fa73334..b3699afff002 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -1,15 +1,9 @@
 /*
- * g_serial.c -- USB gadget serial driver
+ * serial.c -- USB gadget serial driver
  *
- * Copyright 2003 (C) Al Borchers (alborchers@steinerpoint.com)
- *
- * This code is based in part on the Gadget Zero driver, which
- * is Copyright (C) 2003 by David Brownell, all rights reserved.
- *
- * This code also borrows from usbserial.c, which is
- * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
- * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
- * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 by David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
  *
  * This software is distributed under the terms of the GNU General
  * Public License ("GPL") as published by the Free Software Foundation,
@@ -22,2254 +16,237 @@
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 
-#include <linux/usb/ch9.h>
-#include <linux/usb/cdc.h>
-#include <linux/usb/gadget.h>
-
+#include "u_serial.h"
 #include "gadget_chips.h"
 
 
 /* Defines */
 
-#define GS_VERSION_STR                  "v2.2"
-#define GS_VERSION_NUM                  0x2200
+#define GS_VERSION_STR                  "v2.4"
+#define GS_VERSION_NUM                  0x2400
 
 #define GS_LONG_NAME                    "Gadget Serial"
-#define GS_SHORT_NAME                   "g_serial"
-
-#define GS_MAJOR                        127
-#define GS_MINOR_START                  0
-
-/* REVISIT only one port is supported for now;
- * see gs_{send,recv}_packet() ... no multiplexing,
- * and no support for multiple ACM devices.
- */
-#define GS_NUM_PORTS                    1
-
-#define GS_NUM_CONFIGS                  1
-#define GS_NO_CONFIG_ID                 0
-#define GS_BULK_CONFIG_ID               1
-#define GS_ACM_CONFIG_ID                2
-
-#define GS_MAX_NUM_INTERFACES           2
-#define GS_BULK_INTERFACE_ID            0
-#define GS_CONTROL_INTERFACE_ID         0
-#define GS_DATA_INTERFACE_ID            1
-
-#define GS_MAX_DESC_LEN                 256
-
-#define GS_DEFAULT_READ_Q_SIZE          32
-#define GS_DEFAULT_WRITE_Q_SIZE         32
-
-#define GS_DEFAULT_WRITE_BUF_SIZE       8192
-#define GS_TMP_BUF_SIZE                 8192
-
-#define GS_CLOSE_TIMEOUT                15
-
-#define GS_DEFAULT_USE_ACM              0
-
-/* 9600-8-N-1 ... matches init_termios.c_cflag and defaults
- * expected by "usbser.sys" on MS-Windows.
- */
-#define GS_DEFAULT_DTE_RATE             9600
-#define GS_DEFAULT_DATA_BITS            8
-#define GS_DEFAULT_PARITY               USB_CDC_NO_PARITY
-#define GS_DEFAULT_CHAR_FORMAT          USB_CDC_1_STOP_BITS
-
-/* maxpacket and other transfer characteristics vary by speed. */
-static inline struct usb_endpoint_descriptor *
-choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
-                struct usb_endpoint_descriptor *fs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
-
-
-/* debug settings */
-#ifdef DEBUG
-static int debug = 1;
-#else
-#define debug 0
-#endif
-
-#define gs_debug(format, arg...) \
-        do { if (debug) pr_debug(format, ## arg); } while (0)
-#define gs_debug_level(level, format, arg...) \
-        do { if (debug >= level) pr_debug(format, ## arg); } while (0)
+#define GS_VERSION_NAME                 GS_LONG_NAME " " GS_VERSION_STR
 
+/*-------------------------------------------------------------------------*/
 
 /* Thanks to NetChip Technologies for donating this product ID.
- *
- * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
- * Instead:  allocate your own, using normal USB-IF procedures.
- */
+*
+* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
+* Instead:  allocate your own, using normal USB-IF procedures.
+*/
 #define GS_VENDOR_ID                    0x0525  /* NetChip */
 #define GS_PRODUCT_ID                   0xa4a6  /* Linux-USB Serial Gadget */
 #define GS_CDC_PRODUCT_ID               0xa4a7  /* ... as CDC-ACM */
 
-#define GS_LOG2_NOTIFY_INTERVAL         5       /* 1 << 5 == 32 msec */
-#define GS_NOTIFY_MAXPACKET             8
+/* string IDs are assigned dynamically */
 
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+#define STRING_DESCRIPTION_IDX          2
 
-/* circular buffer */
-struct gs_buf {
-        unsigned int            buf_size;
-        char                    *buf_buf;
-        char                    *buf_get;
-        char                    *buf_put;
-};
+static char manufacturer[50];
 
-/* the port structure holds info for each port, one for each minor number */
-struct gs_port {
-        struct gs_dev           *port_dev;      /* pointer to device struct */
-        struct tty_struct       *port_tty;      /* pointer to tty struct */
-        spinlock_t              port_lock;
-        int                     port_num;
-        int                     port_open_count;
-        int                     port_in_use;    /* open/close in progress */
-        wait_queue_head_t       port_write_wait;/* waiting to write */
-        struct gs_buf           *port_write_buf;
-        struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
-        u16                     port_handshake_bits;
-#define RS232_RTS       (1 << 1)
-#define RS232_DTE       (1 << 0)
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = GS_VERSION_NAME,
+        [STRING_DESCRIPTION_IDX].s = NULL /* updated; f(use_acm) */,
+        {  } /* end of list */
 };
 
-/* the device structure holds info for the USB device */
-struct gs_dev {
-        struct usb_gadget       *dev_gadget;    /* gadget device pointer */
-        spinlock_t              dev_lock;       /* lock for set/reset config */
-        int                     dev_config;     /* configuration number */
-        struct usb_ep           *dev_notify_ep; /* address of notify endpoint */
-        struct usb_ep           *dev_in_ep;     /* address of in endpoint */
-        struct usb_ep           *dev_out_ep;    /* address of out endpoint */
-        struct usb_endpoint_descriptor          /* descriptor of notify ep */
-                                *dev_notify_ep_desc;
-        struct usb_endpoint_descriptor          /* descriptor of in endpoint */
-                                *dev_in_ep_desc;
-        struct usb_endpoint_descriptor          /* descriptor of out endpoint */
-                                *dev_out_ep_desc;
-        struct usb_request      *dev_ctrl_req;  /* control request */
-        struct list_head        dev_req_list;   /* list of write requests */
-        int                     dev_sched_port; /* round robin port scheduled */
-        struct gs_port          *dev_port[GS_NUM_PORTS]; /* the ports */
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
 };
 
-
-/* Functions */
-
-/* tty driver internals */
-static int gs_send(struct gs_dev *dev);
-static int gs_send_packet(struct gs_dev *dev, char *packet,
-        unsigned int size);
-static int gs_recv_packet(struct gs_dev *dev, char *packet,
-        unsigned int size);
-static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
-static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
-
-/* gadget driver internals */
-static int gs_set_config(struct gs_dev *dev, unsigned config);
-static void gs_reset_config(struct gs_dev *dev);
-static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
-                u8 type, unsigned int index, int is_otg);
-
-static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
-        gfp_t kmalloc_flags);
-static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
-
-static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
-static void gs_free_ports(struct gs_dev *dev);
-
-/* circular buffer */
-static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags);
-static void gs_buf_free(struct gs_buf *gb);
-static void gs_buf_clear(struct gs_buf *gb);
-static unsigned int gs_buf_data_avail(struct gs_buf *gb);
-static unsigned int gs_buf_space_avail(struct gs_buf *gb);
-static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
-        unsigned int count);
-static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
-        unsigned int count);
-
-
-/* Globals */
-
-static struct gs_dev *gs_device;
-
-static struct mutex gs_open_close_lock[GS_NUM_PORTS];
-
-
-/*-------------------------------------------------------------------------*/
-
-/* USB descriptors */
-
-#define GS_MANUFACTURER_STR_ID  1
-#define GS_PRODUCT_STR_ID       2
-#define GS_SERIAL_STR_ID        3
-#define GS_BULK_CONFIG_STR_ID   4
-#define GS_ACM_CONFIG_STR_ID    5
-#define GS_CONTROL_STR_ID       6
-#define GS_DATA_STR_ID          7
-
-/* static strings, in UTF-8 */
-static char manufacturer[50];
-static struct usb_string gs_strings[] = {
-        { GS_MANUFACTURER_STR_ID, manufacturer },
-        { GS_PRODUCT_STR_ID, GS_LONG_NAME },
-        { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" },
-        { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" },
-        { GS_CONTROL_STR_ID, "Gadget Serial Control" },
-        { GS_DATA_STR_ID, "Gadget Serial Data" },
-        {  } /* end of list */
-};
-
-static struct usb_gadget_strings gs_string_table = {
-        .language =             0x0409, /* en-us */
-        .strings =              gs_strings,
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
 };
 
-static struct usb_device_descriptor gs_device_desc = {
+static struct usb_device_descriptor device_desc = {
         .bLength =              USB_DT_DEVICE_SIZE,
         .bDescriptorType =      USB_DT_DEVICE,
         .bcdUSB =               __constant_cpu_to_le16(0x0200),
+        /* .bDeviceClass = f(use_acm) */
         .bDeviceSubClass =      0,
         .bDeviceProtocol =      0,
+        /* .bMaxPacketSize0 = f(hardware) */
         .idVendor =             __constant_cpu_to_le16(GS_VENDOR_ID),
-        .idProduct =            __constant_cpu_to_le16(GS_PRODUCT_ID),
-        .iManufacturer =        GS_MANUFACTURER_STR_ID,
-        .iProduct =             GS_PRODUCT_STR_ID,
-        .bNumConfigurations =   GS_NUM_CONFIGS,
+        /* .idProduct = f(use_acm) */
+        /* .bcdDevice = f(hardware) */
+        /* .iManufacturer = DYNAMIC */
+        /* .iProduct = DYNAMIC */
+        .bNumConfigurations =   1,
 };
 
-static struct usb_otg_descriptor gs_otg_descriptor = {
-        .bLength =              sizeof(gs_otg_descriptor),
+static struct usb_otg_descriptor otg_descriptor = {
+        .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
-        .bmAttributes =         USB_OTG_SRP,
-};
-
-static struct usb_config_descriptor gs_bulk_config_desc = {
-        .bLength =              USB_DT_CONFIG_SIZE,
-        .bDescriptorType =      USB_DT_CONFIG,
-        /* .wTotalLength computed dynamically */
-        .bNumInterfaces =       1,
-        .bConfigurationValue =  GS_BULK_CONFIG_ID,
-        .iConfiguration =       GS_BULK_CONFIG_STR_ID,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            1,
-};
-
-static struct usb_config_descriptor gs_acm_config_desc = {
-        .bLength =              USB_DT_CONFIG_SIZE,
-        .bDescriptorType =      USB_DT_CONFIG,
-        /* .wTotalLength computed dynamically */
-        .bNumInterfaces =       2,
-        .bConfigurationValue =  GS_ACM_CONFIG_ID,
-        .iConfiguration =       GS_ACM_CONFIG_STR_ID,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            1,
-};
-
-static const struct usb_interface_descriptor gs_bulk_interface_desc = {
-        .bLength =              USB_DT_INTERFACE_SIZE,
-        .bDescriptorType =      USB_DT_INTERFACE,
-        .bInterfaceNumber =     GS_BULK_INTERFACE_ID,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
-        .bInterfaceSubClass =   0,
-        .bInterfaceProtocol =   0,
-        .iInterface =           GS_DATA_STR_ID,
-};
-
-static const struct usb_interface_descriptor gs_control_interface_desc = {
-        .bLength =              USB_DT_INTERFACE_SIZE,
-        .bDescriptorType =      USB_DT_INTERFACE,
-        .bInterfaceNumber =     GS_CONTROL_INTERFACE_ID,
-        .bNumEndpoints =        1,
-        .bInterfaceClass =      USB_CLASS_COMM,
-        .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
-        .bInterfaceProtocol =   USB_CDC_ACM_PROTO_AT_V25TER,
-        .iInterface =           GS_CONTROL_STR_ID,
-};
-
-static const struct usb_interface_descriptor gs_data_interface_desc = {
-        .bLength =              USB_DT_INTERFACE_SIZE,
-        .bDescriptorType =      USB_DT_INTERFACE,
-        .bInterfaceNumber =     GS_DATA_INTERFACE_ID,
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_CDC_DATA,
-        .bInterfaceSubClass =   0,
-        .bInterfaceProtocol =   0,
-        .iInterface =           GS_DATA_STR_ID,
-};
-
-static const struct usb_cdc_header_desc gs_header_desc = {
-        .bLength =              sizeof(gs_header_desc),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
-        .bcdCDC =               __constant_cpu_to_le16(0x0110),
-};
-
-static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
-        .bLength =              sizeof(gs_call_mgmt_descriptor),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
-        .bmCapabilities =       0,
-        .bDataInterface =       1,      /* index of data interface */
-};
-
-static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
-        .bLength =              sizeof(gs_acm_descriptor),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_ACM_TYPE,
-        .bmCapabilities =       (1 << 1),
-};
-
-static const struct usb_cdc_union_desc gs_union_desc = {
-        .bLength =              sizeof(gs_union_desc),
-        .bDescriptorType =      USB_DT_CS_INTERFACE,
-        .bDescriptorSubType =   USB_CDC_UNION_TYPE,
-        .bMasterInterface0 =    0,      /* index of control interface */
-        .bSlaveInterface0 =     1,      /* index of data interface */
-};
-
-static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
-        .bInterval =            1 << GS_LOG2_NOTIFY_INTERVAL,
-};
-
-static struct usb_endpoint_descriptor gs_fullspeed_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-};
-
-static struct usb_endpoint_descriptor gs_fullspeed_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-};
-
-static const struct usb_descriptor_header *gs_bulk_fullspeed_function[] = {
-        (struct usb_descriptor_header *) &gs_otg_descriptor,
-        (struct usb_descriptor_header *) &gs_bulk_interface_desc,
-        (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
-        (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
-        NULL,
-};
-
-static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = {
-        (struct usb_descriptor_header *) &gs_otg_descriptor,
-        (struct usb_descriptor_header *) &gs_control_interface_desc,
-        (struct usb_descriptor_header *) &gs_header_desc,
-        (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &gs_acm_descriptor,
-        (struct usb_descriptor_header *) &gs_union_desc,
-        (struct usb_descriptor_header *) &gs_fullspeed_notify_desc,
-        (struct usb_descriptor_header *) &gs_data_interface_desc,
-        (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
-        (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
-        NULL,
-};
 
-static struct usb_endpoint_descriptor gs_highspeed_notify_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_INT,
-        .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
-        .bInterval =            GS_LOG2_NOTIFY_INTERVAL+4,
-};
-
-static struct usb_endpoint_descriptor gs_highspeed_in_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
-};
-
-static struct usb_endpoint_descriptor gs_highspeed_out_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
-};
-
-static struct usb_qualifier_descriptor gs_qualifier_desc = {
-        .bLength =              sizeof(struct usb_qualifier_descriptor),
-        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
-        .bcdUSB =               __constant_cpu_to_le16 (0x0200),
-        /* assumes ep0 uses the same value for both speeds ... */
-        .bNumConfigurations =   GS_NUM_CONFIGS,
-};
-
-static const struct usb_descriptor_header *gs_bulk_highspeed_function[] = {
-        (struct usb_descriptor_header *) &gs_otg_descriptor,
-        (struct usb_descriptor_header *) &gs_bulk_interface_desc,
-        (struct usb_descriptor_header *) &gs_highspeed_in_desc,
-        (struct usb_descriptor_header *) &gs_highspeed_out_desc,
-        NULL,
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
 };
 
-static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
-        (struct usb_descriptor_header *) &gs_otg_descriptor,
-        (struct usb_descriptor_header *) &gs_control_interface_desc,
-        (struct usb_descriptor_header *) &gs_header_desc,
-        (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
-        (struct usb_descriptor_header *) &gs_acm_descriptor,
-        (struct usb_descriptor_header *) &gs_union_desc,
-        (struct usb_descriptor_header *) &gs_highspeed_notify_desc,
-        (struct usb_descriptor_header *) &gs_data_interface_desc,
-        (struct usb_descriptor_header *) &gs_highspeed_in_desc,
-        (struct usb_descriptor_header *) &gs_highspeed_out_desc,
+static const struct usb_descriptor_header *otg_desc[] = {
+        (struct usb_descriptor_header *) &otg_descriptor,
         NULL,
 };
 
-
 /*-------------------------------------------------------------------------*/
 
 /* Module */
-MODULE_DESCRIPTION(GS_LONG_NAME);
+MODULE_DESCRIPTION(GS_VERSION_NAME);
 MODULE_AUTHOR("Al Borchers");
+MODULE_AUTHOR("David Brownell");
 MODULE_LICENSE("GPL");
 
-#ifdef DEBUG
-module_param(debug, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
-#endif
-
-static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
-module_param(read_q_size, uint, S_IRUGO);
-MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
-
-static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
-module_param(write_q_size, uint, S_IRUGO);
-MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
+static int use_acm = true;
+module_param(use_acm, bool, 0);
+MODULE_PARM_DESC(use_acm, "Use CDC ACM, default=yes");
 
-static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
-module_param(write_buf_size, uint, S_IRUGO);
-MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
-
-static unsigned int use_acm = GS_DEFAULT_USE_ACM;
-module_param(use_acm, uint, S_IRUGO);
-MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
+static unsigned n_ports = 1;
+module_param(n_ports, uint, 0);
+MODULE_PARM_DESC(n_ports, "number of ports to create, default=1");
 
 /*-------------------------------------------------------------------------*/
 
-/* TTY Driver */
-
-/*
- * gs_open
- */
-static int gs_open(struct tty_struct *tty, struct file *file)
-{
-        int port_num;
-        unsigned long flags;
-        struct gs_port *port;
-        struct gs_dev *dev;
-        struct gs_buf *buf;
-        struct mutex *mtx;
-        int ret;
-
-        port_num = tty->index;
-
-        gs_debug("gs_open: (%d,%p,%p)\n", port_num, tty, file);
-
-        if (port_num < 0 || port_num >= GS_NUM_PORTS) {
-                pr_err("gs_open: (%d,%p,%p) invalid port number\n",
-                        port_num, tty, file);
-                return -ENODEV;
-        }
-
-        dev = gs_device;
-
-        if (dev == NULL) {
-                pr_err("gs_open: (%d,%p,%p) NULL device pointer\n",
-                        port_num, tty, file);
-                return -ENODEV;
-        }
-
-        mtx = &gs_open_close_lock[port_num];
-        if (mutex_lock_interruptible(mtx)) {
-                pr_err("gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
-                        port_num, tty, file);
-                return -ERESTARTSYS;
-        }
-
-        spin_lock_irqsave(&dev->dev_lock, flags);
-
-        if (dev->dev_config == GS_NO_CONFIG_ID) {
-                pr_err("gs_open: (%d,%p,%p) device is not connected\n",
-                        port_num, tty, file);
-                ret = -ENODEV;
-                goto exit_unlock_dev;
-        }
-
-        port = dev->dev_port[port_num];
-
-        if (port == NULL) {
-                pr_err("gs_open: (%d,%p,%p) NULL port pointer\n",
-                        port_num, tty, file);
-                ret = -ENODEV;
-                goto exit_unlock_dev;
-        }
-
-        spin_lock(&port->port_lock);
-        spin_unlock(&dev->dev_lock);
-
-        if (port->port_dev == NULL) {
-                pr_err("gs_open: (%d,%p,%p) port disconnected (1)\n",
-                        port_num, tty, file);
-                ret = -EIO;
-                goto exit_unlock_port;
-        }
-
-        if (port->port_open_count > 0) {
-                ++port->port_open_count;
-                gs_debug("gs_open: (%d,%p,%p) already open\n",
-                        port_num, tty, file);
-                ret = 0;
-                goto exit_unlock_port;
-        }
-
-        tty->driver_data = NULL;
-
-        /* mark port as in use, we can drop port lock and sleep if necessary */
-        port->port_in_use = 1;
-
-        /* allocate write buffer on first open */
-        if (port->port_write_buf == NULL) {
-                spin_unlock_irqrestore(&port->port_lock, flags);
-                buf = gs_buf_alloc(write_buf_size, GFP_KERNEL);
-                spin_lock_irqsave(&port->port_lock, flags);
-
-                /* might have been disconnected while asleep, check */
-                if (port->port_dev == NULL) {
-                        pr_err("gs_open: (%d,%p,%p) port disconnected (2)\n",
-                                port_num, tty, file);
-                        port->port_in_use = 0;
-                        ret = -EIO;
-                        goto exit_unlock_port;
-                }
-
-                if ((port->port_write_buf=buf) == NULL) {
-                        pr_err("gs_open: (%d,%p,%p) cannot allocate "
-                                "port write buffer\n",
-                                port_num, tty, file);
-                        port->port_in_use = 0;
-                        ret = -ENOMEM;
-                        goto exit_unlock_port;
-                }
-
-        }
-
-        /* wait for carrier detect (not implemented) */
-
-        /* might have been disconnected while asleep, check */
-        if (port->port_dev == NULL) {
-                pr_err("gs_open: (%d,%p,%p) port disconnected (3)\n",
-                        port_num, tty, file);
-                port->port_in_use = 0;
-                ret = -EIO;
-                goto exit_unlock_port;
-        }
-
-        tty->driver_data = port;
-        port->port_tty = tty;
-        port->port_open_count = 1;
-        port->port_in_use = 0;
-
-        gs_debug("gs_open: (%d,%p,%p) completed\n", port_num, tty, file);
-
-        ret = 0;
-
-exit_unlock_port:
-        spin_unlock_irqrestore(&port->port_lock, flags);
-        mutex_unlock(mtx);
-        return ret;
-
-exit_unlock_dev:
-        spin_unlock_irqrestore(&dev->dev_lock, flags);
-        mutex_unlock(mtx);
-        return ret;
-
-}
-
-/*
- * gs_close
- */
-
-static int gs_write_finished_event_safely(struct gs_port *p)
-{
-        int cond;
-
-        spin_lock_irq(&(p)->port_lock);
-        cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf);
-        spin_unlock_irq(&(p)->port_lock);
-        return cond;
-}
-
-static void gs_close(struct tty_struct *tty, struct file *file)
-{
-        struct gs_port *port = tty->driver_data;
-        struct mutex *mtx;
-
-        if (port == NULL) {
-                pr_err("gs_close: NULL port pointer\n");
-                return;
-        }
-
-        gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
-
-        mtx = &gs_open_close_lock[port->port_num];
-        mutex_lock(mtx);
-
-        spin_lock_irq(&port->port_lock);
-
-        if (port->port_open_count == 0) {
-                pr_err("gs_close: (%d,%p,%p) port is already closed\n",
-                        port->port_num, tty, file);
-                goto exit;
-        }
-
-        if (port->port_open_count > 1) {
-                --port->port_open_count;
-                goto exit;
-        }
-
-        /* free disconnected port on final close */
-        if (port->port_dev == NULL) {
-                kfree(port);
-                goto exit;
-        }
-
-        /* mark port as closed but in use, we can drop port lock */
-        /* and sleep if necessary */
-        port->port_in_use = 1;
-        port->port_open_count = 0;
-
-        /* wait for write buffer to drain, or */
-        /* at most GS_CLOSE_TIMEOUT seconds */
-        if (gs_buf_data_avail(port->port_write_buf) > 0) {
-                spin_unlock_irq(&port->port_lock);
-                wait_event_interruptible_timeout(port->port_write_wait,
-                                        gs_write_finished_event_safely(port),
-                                        GS_CLOSE_TIMEOUT * HZ);
-                spin_lock_irq(&port->port_lock);
-        }
-
-        /* free disconnected port on final close */
-        /* (might have happened during the above sleep) */
-        if (port->port_dev == NULL) {
-                kfree(port);
-                goto exit;
-        }
-
-        gs_buf_clear(port->port_write_buf);
-
-        tty->driver_data = NULL;
-        port->port_tty = NULL;
-        port->port_in_use = 0;
-
-        gs_debug("gs_close: (%d,%p,%p) completed\n",
-                port->port_num, tty, file);
-
-exit:
-        spin_unlock_irq(&port->port_lock);
-        mutex_unlock(mtx);
-}
-
-/*
- * gs_write
- */
-static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
+static int __init serial_bind_config(struct usb_configuration *c)
 {
-        unsigned long flags;
-        struct gs_port *port = tty->driver_data;
-        int ret;
-
-        if (port == NULL) {
-                pr_err("gs_write: NULL port pointer\n");
-                return -EIO;
-        }
-
-        gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty,
-                count);
-
-        if (count == 0)
-                return 0;
-
-        spin_lock_irqsave(&port->port_lock, flags);
-
-        if (port->port_dev == NULL) {
-                pr_err("gs_write: (%d,%p) port is not connected\n",
-                        port->port_num, tty);
-                ret = -EIO;
-                goto exit;
-        }
-
-        if (port->port_open_count == 0) {
-                pr_err("gs_write: (%d,%p) port is closed\n",
-                        port->port_num, tty);
-                ret = -EBADF;
-                goto exit;
-        }
-
-        count = gs_buf_put(port->port_write_buf, buf, count);
-
-        spin_unlock_irqrestore(&port->port_lock, flags);
-
-        gs_send(gs_device);
-
-        gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
-                count);
+        unsigned i;
+        int status = 0;
 
-        return count;
-
-exit:
-        spin_unlock_irqrestore(&port->port_lock, flags);
-        return ret;
-}
-
-/*
- * gs_put_char
- */
-static int gs_put_char(struct tty_struct *tty, unsigned char ch)
-{
-        unsigned long flags;
-        struct gs_port *port = tty->driver_data;
-        int ret = 0;
-
-        if (port == NULL) {
-                pr_err("gs_put_char: NULL port pointer\n");
-                return 0;
-        }
-
-        gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
-                port->port_num, tty, ch, __builtin_return_address(0));
-
-        spin_lock_irqsave(&port->port_lock, flags);
-
-        if (port->port_dev == NULL) {
-                pr_err("gs_put_char: (%d,%p) port is not connected\n",
-                        port->port_num, tty);
-                goto exit;
-        }
-
-        if (port->port_open_count == 0) {
-                pr_err("gs_put_char: (%d,%p) port is closed\n",
-                        port->port_num, tty);
-                goto exit;
-        }
-
-        ret = gs_buf_put(port->port_write_buf, &ch, 1);
-
-exit:
-        spin_unlock_irqrestore(&port->port_lock, flags);
-        return ret;
-}
-
-/*
- * gs_flush_chars
- */
-static void gs_flush_chars(struct tty_struct *tty)
-{
-        unsigned long flags;
-        struct gs_port *port = tty->driver_data;
-
-        if (port == NULL) {
-                pr_err("gs_flush_chars: NULL port pointer\n");
-                return;
-        }
-
-        gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
-
-        spin_lock_irqsave(&port->port_lock, flags);
-
-        if (port->port_dev == NULL) {
-                pr_err("gs_flush_chars: (%d,%p) port is not connected\n",
-                        port->port_num, tty);
-                goto exit;
-        }
-
-        if (port->port_open_count == 0) {
-                pr_err("gs_flush_chars: (%d,%p) port is closed\n",
-                        port->port_num, tty);
-                goto exit;
-        }
-
-        spin_unlock_irqrestore(&port->port_lock, flags);
-
-        gs_send(gs_device);
-
-        return;
-
-exit:
-        spin_unlock_irqrestore(&port->port_lock, flags);
-}
-
-/*
- * gs_write_room
- */
-static int gs_write_room(struct tty_struct *tty)
-{
-
-        int room = 0;
-        unsigned long flags;
-        struct gs_port *port = tty->driver_data;
-
-
-        if (port == NULL)
-                return 0;
-
-        spin_lock_irqsave(&port->port_lock, flags);
-
-        if (port->port_dev != NULL && port->port_open_count > 0
-        && port->port_write_buf != NULL)
-                room = gs_buf_space_avail(port->port_write_buf);
-
-        spin_unlock_irqrestore(&port->port_lock, flags);
-
-        gs_debug("gs_write_room: (%d,%p) room=%d\n",
-                port->port_num, tty, room);
-
-        return room;
-}
-
-/*
- * gs_chars_in_buffer
- */
-static int gs_chars_in_buffer(struct tty_struct *tty)
-{
-        int chars = 0;
-        unsigned long flags;
-        struct gs_port *port = tty->driver_data;
-
-        if (port == NULL)
-                return 0;
-
-        spin_lock_irqsave(&port->port_lock, flags);
-
-        if (port->port_dev != NULL && port->port_open_count > 0
-        && port->port_write_buf != NULL)
-                chars = gs_buf_data_avail(port->port_write_buf);
-
-        spin_unlock_irqrestore(&port->port_lock, flags);
-
-        gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
-                port->port_num, tty, chars);
-
-        return chars;
-}
-
-/*
- * gs_throttle
- */
-static void gs_throttle(struct tty_struct *tty)
-{
-}
-
-/*
- * gs_unthrottle
- */
-static void gs_unthrottle(struct tty_struct *tty)
-{
-}
-
-/*
- * gs_break
- */
-static void gs_break(struct tty_struct *tty, int break_state)
-{
-}
-
-/*
- * gs_ioctl
- */
-static int gs_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
-{
-        struct gs_port *port = tty->driver_data;
-
-        if (port == NULL) {
-                pr_err("gs_ioctl: NULL port pointer\n");
-                return -EIO;
+        for (i = 0; i < n_ports && status == 0; i++) {
+                if (use_acm)
+                        status = acm_bind_config(c, i);
+                else
+                        status = gser_bind_config(c, i);
         }
-
-        gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
-                port->port_num, tty, file, cmd, arg);
-
-        /* handle ioctls */
-
-        /* could not handle ioctl */
-        return -ENOIOCTLCMD;
-}
-
-/*
- * gs_set_termios
- */
-static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
-{
+        return status;
 }
 
-static const struct tty_operations gs_tty_ops = {
-        .open =                 gs_open,
-        .close =                gs_close,
-        .write =                gs_write,
-        .put_char =             gs_put_char,
-        .flush_chars =          gs_flush_chars,
-        .write_room =           gs_write_room,
-        .ioctl =                gs_ioctl,
-        .set_termios =          gs_set_termios,
-        .throttle =             gs_throttle,
-        .unthrottle =           gs_unthrottle,
-        .break_ctl =            gs_break,
-        .chars_in_buffer =      gs_chars_in_buffer,
+static struct usb_configuration serial_config_driver = {
+        /* .label = f(use_acm) */
+        .bind           = serial_bind_config,
+        /* .bConfigurationValue = f(use_acm) */
+        /* .iConfiguration = DYNAMIC */
+        .bmAttributes   = USB_CONFIG_ATT_SELFPOWER,
+        .bMaxPower      = 1,    /* 2 mA, minimal */
 };
 
-/*-------------------------------------------------------------------------*/
-
-/*
-* gs_send
-*
-* This function finds available write requests, calls
-* gs_send_packet to fill these packets with data, and
-* continues until either there are no more write requests
-* available or no more data to send.  This function is
-* run whenever data arrives or write requests are available.
-*/
-static int gs_send(struct gs_dev *dev)
-{
-        int ret,len;
-        unsigned long flags;
-        struct usb_ep *ep;
-        struct usb_request *req;
-
-        if (dev == NULL) {
-                pr_err("gs_send: NULL device pointer\n");
-                return -ENODEV;
-        }
-
-        spin_lock_irqsave(&dev->dev_lock, flags);
-
-        ep = dev->dev_in_ep;
-
-        while(!list_empty(&dev->dev_req_list)) {
-
-                req = list_entry(dev->dev_req_list.next,
-                                struct usb_request, list);
-
-                len = gs_send_packet(dev, req->buf, ep->maxpacket);
-
-                if (len > 0) {
-                        gs_debug_level(3, "gs_send: len=%d, 0x%2.2x "
-                                        "0x%2.2x 0x%2.2x ...\n", len,
-                                        *((unsigned char *)req->buf),
-                                        *((unsigned char *)req->buf+1),
-                                        *((unsigned char *)req->buf+2));
-                        list_del(&req->list);
-                        req->length = len;
-                        spin_unlock_irqrestore(&dev->dev_lock, flags);
-                        if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
-                                pr_err(
-                                "gs_send: cannot queue read request, ret=%d\n",
-                                        ret);
-                                spin_lock_irqsave(&dev->dev_lock, flags);
-                                break;
-                        }
-                        spin_lock_irqsave(&dev->dev_lock, flags);
-                } else {
-                        break;
-                }
-
-        }
-
-        spin_unlock_irqrestore(&dev->dev_lock, flags);
-
-        return 0;
-}
-
-/*
- * gs_send_packet
- *
- * If there is data to send, a packet is built in the given
- * buffer and the size is returned.  If there is no data to
- * send, 0 is returned.  If there is any error a negative
- * error number is returned.
- *
- * Called during USB completion routine, on interrupt time.
- *
- * We assume that disconnect will not happen until all completion
- * routines have completed, so we can assume that the dev_port
- * array does not change during the lifetime of this function.
- */
-static int gs_send_packet(struct gs_dev *dev, char *packet, unsigned int size)
-{
-        unsigned int len;
-        struct gs_port *port;
-
-        /* TEMPORARY -- only port 0 is supported right now */
-        port = dev->dev_port[0];
-
-        if (port == NULL) {
-                pr_err("gs_send_packet: port=%d, NULL port pointer\n", 0);
-                return -EIO;
-        }
-
-        spin_lock(&port->port_lock);
-
-        len = gs_buf_data_avail(port->port_write_buf);
-        if (len < size)
-                size = len;
-
-        if (size == 0)
-                goto exit;
-
-        size = gs_buf_get(port->port_write_buf, packet, size);
-
-        if (port->port_tty)
-                wake_up_interruptible(&port->port_tty->write_wait);
-
-exit:
-        spin_unlock(&port->port_lock);
-        return size;
-}
-
-/*
- * gs_recv_packet
- *
- * Called for each USB packet received.  Reads the packet
- * header and stuffs the data in the appropriate tty buffer.
- * Returns 0 if successful, or a negative error number.
- *
- * Called during USB completion routine, on interrupt time.
- *
- * We assume that disconnect will not happen until all completion
- * routines have completed, so we can assume that the dev_port
- * array does not change during the lifetime of this function.
- */
-static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
-{
-        unsigned int len;
-        struct gs_port *port;
-        int ret;
-        struct tty_struct *tty;
-
-        /* TEMPORARY -- only port 0 is supported right now */
-        port = dev->dev_port[0];
-
-        if (port == NULL) {
-                pr_err("gs_recv_packet: port=%d, NULL port pointer\n",
-                        port->port_num);
-                return -EIO;
-        }
-
-        spin_lock(&port->port_lock);
-
-        if (port->port_open_count == 0) {
-                pr_err("gs_recv_packet: port=%d, port is closed\n",
-                        port->port_num);
-                ret = -EIO;
-                goto exit;
-        }
-
-
-        tty = port->port_tty;
-
-        if (tty == NULL) {
-                pr_err("gs_recv_packet: port=%d, NULL tty pointer\n",
-                        port->port_num);
-                ret = -EIO;
-                goto exit;
-        }
-
-        if (port->port_tty->magic != TTY_MAGIC) {
-                pr_err("gs_recv_packet: port=%d, bad tty magic\n",
-                        port->port_num);
-                ret = -EIO;
-                goto exit;
-        }
-
-        len = tty_buffer_request_room(tty, size);
-        if (len > 0) {
-                tty_insert_flip_string(tty, packet, len);
-                tty_flip_buffer_push(port->port_tty);
-                wake_up_interruptible(&port->port_tty->read_wait);
-        }
-        ret = 0;
-exit:
-        spin_unlock(&port->port_lock);
-        return ret;
-}
-
-/*
-* gs_read_complete
-*/
-static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
+static int __init gs_bind(struct usb_composite_dev *cdev)
 {
-        int ret;
-        struct gs_dev *dev = ep->driver_data;
-
-        if (dev == NULL) {
-                pr_err("gs_read_complete: NULL device pointer\n");
-                return;
-        }
+        int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     status;
 
-        switch(req->status) {
-        case 0:
-                /* normal completion */
-                gs_recv_packet(dev, req->buf, req->actual);
-requeue:
-                req->length = ep->maxpacket;
-                if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
-                        pr_err(
-                        "gs_read_complete: cannot queue read request, ret=%d\n",
-                                ret);
-                }
-                break;
-
-        case -ESHUTDOWN:
-                /* disconnect */
-                gs_debug("gs_read_complete: shutdown\n");
-                gs_free_req(ep, req);
-                break;
-
-        default:
-                /* unexpected */
-                pr_err(
-                "gs_read_complete: unexpected status error, status=%d\n",
-                        req->status);
-                goto requeue;
-                break;
-        }
-}
-
-/*
-* gs_write_complete
-*/
-static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        struct gs_dev *dev = ep->driver_data;
-
-        if (dev == NULL) {
-                pr_err("gs_write_complete: NULL device pointer\n");
-                return;
-        }
+        status = gserial_setup(cdev->gadget, n_ports);
+        if (status < 0)
+                return status;
 
-        switch(req->status) {
-        case 0:
-                /* normal completion */
-requeue:
-                spin_lock(&dev->dev_lock);
-                list_add(&req->list, &dev->dev_req_list);
-                spin_unlock(&dev->dev_lock);
-
-                gs_send(dev);
-
-                break;
-
-        case -ESHUTDOWN:
-                /* disconnect */
-                gs_debug("gs_write_complete: shutdown\n");
-                gs_free_req(ep, req);
-                break;
-
-        default:
-                pr_err(
-                "gs_write_complete: unexpected status error, status=%d\n",
-                        req->status);
-                goto requeue;
-                break;
-        }
-}
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
+         */
 
-/*-------------------------------------------------------------------------*/
+        /* device description: manufacturer, product */
+        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
+                init_utsname()->sysname, init_utsname()->release,
+                gadget->name);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_MANUFACTURER_IDX].id = status;
 
-/* Gadget Driver */
+        device_desc.iManufacturer = status;
 
-/*
- * gs_unbind
- *
- * Called on module unload.  Frees the control request and device
- * structure.
- */
-static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
-{
-        struct gs_dev *dev = get_gadget_data(gadget);
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_PRODUCT_IDX].id = status;
 
-        gs_device = NULL;
+        device_desc.iProduct = status;
 
-        /* read/write requests already freed, only control request remains */
-        if (dev != NULL) {
-                if (dev->dev_ctrl_req != NULL) {
-                        gs_free_req(gadget->ep0, dev->dev_ctrl_req);
-                        dev->dev_ctrl_req = NULL;
-                }
-                gs_reset_config(dev);
-                gs_free_ports(dev);
-                kfree(dev);
-                set_gadget_data(gadget, NULL);
-        }
+        /* config description */
+        status = usb_string_id(cdev);
+        if (status < 0)
+                goto fail;
+        strings_dev[STRING_DESCRIPTION_IDX].id = status;
 
-        pr_info("gs_unbind: %s %s unbound\n", GS_LONG_NAME,
-                GS_VERSION_STR);
-}
-
-/*
- * gs_bind
- *
- * Called on module load.  Allocates and initializes the device
- * structure and a control request.
- */
-static int __init gs_bind(struct usb_gadget *gadget)
-{
-        int ret;
-        struct usb_ep *ep;
-        struct gs_dev *dev;
-        int gcnum;
-
-        /* 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;
+        serial_config_driver.iConfiguration = status;
 
+        /* set up other descriptors */
         gcnum = usb_gadget_controller_number(gadget);
         if (gcnum >= 0)
-                gs_device_desc.bcdDevice =
-                                cpu_to_le16(GS_VERSION_NUM | gcnum);
+                device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum);
         else {
+                /* this 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.
+                 *
+                 * things like configuration and altsetting numbering
+                 * can need hardware-specific attention though.
+                 */
                 pr_warning("gs_bind: controller '%s' not recognized\n",
                         gadget->name);
-                /* unrecognized, but safe unless bulk is REALLY quirky */
-                gs_device_desc.bcdDevice =
-                        __constant_cpu_to_le16(GS_VERSION_NUM|0x0099);
-        }
-
-        dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
-        if (dev == NULL)
-                return -ENOMEM;
-
-        usb_ep_autoconfig_reset(gadget);
-
-        ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
-        if (!ep)
-                goto autoconf_fail;
-        dev->dev_in_ep = ep;
-        ep->driver_data = dev;  /* claim the endpoint */
-
-        ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
-        if (!ep)
-                goto autoconf_fail;
-        dev->dev_out_ep = ep;
-        ep->driver_data = dev;  /* claim the endpoint */
-
-        if (use_acm) {
-                ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
-                if (!ep) {
-                        pr_err("gs_bind: cannot run ACM on %s\n", gadget->name);
-                        goto autoconf_fail;
-                }
-                gs_device_desc.idProduct = __constant_cpu_to_le16(
-                                                GS_CDC_PRODUCT_ID),
-                dev->dev_notify_ep = ep;
-                ep->driver_data = dev;  /* claim the endpoint */
-        }
-
-        gs_device_desc.bDeviceClass = use_acm
-                ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
-        gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-
-        if (gadget_is_dualspeed(gadget)) {
-                gs_qualifier_desc.bDeviceClass = use_acm
-                        ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
-                /* assume ep0 uses the same packet size for both speeds */
-                gs_qualifier_desc.bMaxPacketSize0 =
-                        gs_device_desc.bMaxPacketSize0;
-                /* assume endpoints are dual-speed */
-                gs_highspeed_notify_desc.bEndpointAddress =
-                        gs_fullspeed_notify_desc.bEndpointAddress;
-                gs_highspeed_in_desc.bEndpointAddress =
-                        gs_fullspeed_in_desc.bEndpointAddress;
-                gs_highspeed_out_desc.bEndpointAddress =
-                        gs_fullspeed_out_desc.bEndpointAddress;
-        }
-
-        usb_gadget_set_selfpowered(gadget);
-
-        if (gadget_is_otg(gadget)) {
-                gs_otg_descriptor.bmAttributes |= USB_OTG_HNP,
-                gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-                gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+                device_desc.bcdDevice =
+                        __constant_cpu_to_le16(GS_VERSION_NUM | 0x0099);
         }
 
-        gs_device = dev;
-
-        snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-
-        dev->dev_gadget = gadget;
-        spin_lock_init(&dev->dev_lock);
-        INIT_LIST_HEAD(&dev->dev_req_list);
-        set_gadget_data(gadget, dev);
-
-        if ((ret=gs_alloc_ports(dev, GFP_KERNEL)) != 0) {
-                pr_err("gs_bind: cannot allocate ports\n");
-                gs_unbind(gadget);
-                return ret;
+        if (gadget_is_otg(cdev->gadget)) {
+                serial_config_driver.descriptors = otg_desc;
+                serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        /* preallocate control response and buffer */
-        dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
-                GFP_KERNEL);
-        if (dev->dev_ctrl_req == NULL) {
-                gs_unbind(gadget);
-                return -ENOMEM;
-        }
-        gadget->ep0->driver_data = dev;
+        /* register our configuration */
+        status = usb_add_config(cdev, &serial_config_driver);
+        if (status < 0)
+                goto fail;
 
-        pr_info("gs_bind: %s %s bound\n",
-                GS_LONG_NAME, GS_VERSION_STR);
+        INFO(cdev, "%s\n", GS_VERSION_NAME);
 
         return 0;
 
-autoconf_fail:
-        kfree(dev);
-        pr_err("gs_bind: cannot autoconfigure on %s\n", gadget->name);
-        return -ENODEV;
-}
-
-static int gs_setup_standard(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl)
-{
-        int ret = -EOPNOTSUPP;
-        struct gs_dev *dev = get_gadget_data(gadget);
-        struct usb_request *req = dev->dev_ctrl_req;
-        u16 wIndex = le16_to_cpu(ctrl->wIndex);
-        u16 wValue = le16_to_cpu(ctrl->wValue);
-        u16 wLength = le16_to_cpu(ctrl->wLength);
-
-        switch (ctrl->bRequest) {
-        case USB_REQ_GET_DESCRIPTOR:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        break;
-
-                switch (wValue >> 8) {
-                case USB_DT_DEVICE:
-                        ret = min(wLength,
-                                (u16)sizeof(struct usb_device_descriptor));
-                        memcpy(req->buf, &gs_device_desc, ret);
-                        break;
-
-                case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        ret = min(wLength,
-                                (u16)sizeof(struct usb_qualifier_descriptor));
-                        memcpy(req->buf, &gs_qualifier_desc, ret);
-                        break;
-
-                case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        /* fall through */
-                case USB_DT_CONFIG:
-                        ret = gs_build_config_buf(req->buf, gadget,
-                                wValue >> 8, wValue & 0xff,
-                                gadget_is_otg(gadget));
-                        if (ret >= 0)
-                                ret = min(wLength, (u16)ret);
-                        break;
-
-                case USB_DT_STRING:
-                        /* wIndex == language code. */
-                        ret = usb_gadget_get_string(&gs_string_table,
-                                wValue & 0xff, req->buf);
-                        if (ret >= 0)
-                                ret = min(wLength, (u16)ret);
-                        break;
-                }
-                break;
-
-        case USB_REQ_SET_CONFIGURATION:
-                if (ctrl->bRequestType != 0)
-                        break;
-                spin_lock(&dev->dev_lock);
-                ret = gs_set_config(dev, wValue);
-                spin_unlock(&dev->dev_lock);
-                break;
-
-        case USB_REQ_GET_CONFIGURATION:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        break;
-                *(u8 *)req->buf = dev->dev_config;
-                ret = min(wLength, (u16)1);
-                break;
-
-        case USB_REQ_SET_INTERFACE:
-                if (ctrl->bRequestType != USB_RECIP_INTERFACE
-                                || !dev->dev_config
-                                || wIndex >= GS_MAX_NUM_INTERFACES)
-                        break;
-                if (dev->dev_config == GS_BULK_CONFIG_ID
-                                && wIndex != GS_BULK_INTERFACE_ID)
-                        break;
-                /* no alternate interface settings */
-                if (wValue != 0)
-                        break;
-                spin_lock(&dev->dev_lock);
-                /* PXA hardware partially handles SET_INTERFACE;
-                 * we need to kluge around that interference.  */
-                if (gadget_is_pxa(gadget)) {
-                        ret = gs_set_config(dev, use_acm ?
-                                GS_ACM_CONFIG_ID : GS_BULK_CONFIG_ID);
-                        goto set_interface_done;
-                }
-                if (dev->dev_config != GS_BULK_CONFIG_ID
-                                && wIndex == GS_CONTROL_INTERFACE_ID) {
-                        if (dev->dev_notify_ep) {
-                                usb_ep_disable(dev->dev_notify_ep);
-                                usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc);
-                        }
-                } else {
-                        usb_ep_disable(dev->dev_in_ep);
-                        usb_ep_disable(dev->dev_out_ep);
-                        usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc);
-                        usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc);
-                }
-                ret = 0;
-set_interface_done:
-                spin_unlock(&dev->dev_lock);
-                break;
-
-        case USB_REQ_GET_INTERFACE:
-                if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
-                || dev->dev_config == GS_NO_CONFIG_ID)
-                        break;
-                if (wIndex >= GS_MAX_NUM_INTERFACES
-                                || (dev->dev_config == GS_BULK_CONFIG_ID
-                                && wIndex != GS_BULK_INTERFACE_ID)) {
-                        ret = -EDOM;
-                        break;
-                }
-                /* no alternate interface settings */
-                *(u8 *)req->buf = 0;
-                ret = min(wLength, (u16)1);
-                break;
-
-        default:
-                pr_err("gs_setup: unknown standard request, type=%02x, "
-                        "request=%02x, value=%04x, index=%04x, length=%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
-                break;
-        }
-
-        return ret;
+fail:
+        gserial_cleanup();
+        return status;
 }
 
-static void gs_setup_complete_set_line_coding(struct usb_ep *ep,
-                struct usb_request *req)
-{
-        struct gs_dev *dev = ep->driver_data;
-        struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
-
-        switch (req->status) {
-        case 0:
-                /* normal completion */
-                if (req->actual != sizeof(port->port_line_coding))
-                        usb_ep_set_halt(ep);
-                else if (port) {
-                        struct usb_cdc_line_coding      *value = req->buf;
-
-                        /* REVISIT:  we currently just remember this data.
-                         * If we change that, (a) validate it first, then
-                         * (b) update whatever hardware needs updating.
-                         */
-                        spin_lock(&port->port_lock);
-                        port->port_line_coding = *value;
-                        spin_unlock(&port->port_lock);
-                }
-                break;
-
-        case -ESHUTDOWN:
-                /* disconnect */
-                gs_free_req(ep, req);
-                break;
-
-        default:
-                /* unexpected */
-                break;
-        }
-        return;
-}
-
-static int gs_setup_class(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl)
-{
-        int ret = -EOPNOTSUPP;
-        struct gs_dev *dev = get_gadget_data(gadget);
-        struct gs_port *port = dev->dev_port[0];        /* ACM only has one port */
-        struct usb_request *req = dev->dev_ctrl_req;
-        u16 wIndex = le16_to_cpu(ctrl->wIndex);
-        u16 wValue = le16_to_cpu(ctrl->wValue);
-        u16 wLength = le16_to_cpu(ctrl->wLength);
-
-        switch (ctrl->bRequest) {
-        case USB_CDC_REQ_SET_LINE_CODING:
-                if (wLength != sizeof(struct usb_cdc_line_coding))
-                        break;
-                ret = wLength;
-                req->complete = gs_setup_complete_set_line_coding;
-                break;
-
-        case USB_CDC_REQ_GET_LINE_CODING:
-                ret = min_t(int, wLength, sizeof(struct usb_cdc_line_coding));
-                if (port) {
-                        spin_lock(&port->port_lock);
-                        memcpy(req->buf, &port->port_line_coding, ret);
-                        spin_unlock(&port->port_lock);
-                }
-                break;
-
-        case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
-                if (wLength != 0)
-                        break;
-                ret = 0;
-                if (port) {
-                        /* REVISIT:  we currently just remember this data.
-                         * If we change that, update whatever hardware needs
-                         * updating.
-                         */
-                        spin_lock(&port->port_lock);
-                        port->port_handshake_bits = wValue;
-                        spin_unlock(&port->port_lock);
-                }
-                break;
-
-        default:
-                /* NOTE:  strictly speaking, we should accept AT-commands
-                 * using SEND_ENCPSULATED_COMMAND/GET_ENCAPSULATED_RESPONSE.
-                 * But our call management descriptor says we don't handle
-                 * call management, so we should be able to get by without
-                 * handling those "required" commands (except by stalling).
-                 */
-                pr_err("gs_setup: unknown class request, "
-                                "type=%02x, request=%02x, value=%04x, "
-                                "index=%04x, length=%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
-                break;
-        }
-
-        return ret;
-}
-
-/*
- * gs_setup_complete
- */
-static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        if (req->status || req->actual != req->length) {
-                pr_err("gs_setup_complete: status error, status=%d, "
-                        "actual=%d, length=%d\n",
-                        req->status, req->actual, req->length);
-        }
-}
-
-/*
- * gs_setup
- *
- * Implements all the control endpoint functionality that's not
- * handled in hardware or the hardware driver.
- *
- * Returns the size of the data sent to the host, or a negative
- * error number.
- */
-static int gs_setup(struct usb_gadget *gadget,
-        const struct usb_ctrlrequest *ctrl)
-{
-        int             ret = -EOPNOTSUPP;
-        struct gs_dev   *dev = get_gadget_data(gadget);
-        struct usb_request *req = dev->dev_ctrl_req;
-        u16             wIndex = le16_to_cpu(ctrl->wIndex);
-        u16             wValue = le16_to_cpu(ctrl->wValue);
-        u16             wLength = le16_to_cpu(ctrl->wLength);
-
-        req->complete = gs_setup_complete;
-
-        switch (ctrl->bRequestType & USB_TYPE_MASK) {
-        case USB_TYPE_STANDARD:
-                ret = gs_setup_standard(gadget, ctrl);
-                break;
-
-        case USB_TYPE_CLASS:
-                ret = gs_setup_class(gadget, ctrl);
-                break;
-
-        default:
-                pr_err("gs_setup: unknown request, type=%02x, request=%02x, "
-                        "value=%04x, index=%04x, length=%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        wValue, wIndex, wLength);
-                break;
-        }
-
-        /* respond with data transfer before status phase? */
-        if (ret >= 0) {
-                req->length = ret;
-                req->zero = ret < wLength
-                                && (ret % gadget->ep0->maxpacket) == 0;
-                ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
-                if (ret < 0) {
-                        pr_err("gs_setup: cannot queue response, ret=%d\n",
-                                ret);
-                        req->status = 0;
-                        gs_setup_complete(gadget->ep0, req);
-                }
-        }
-
-        /* device either stalls (ret < 0) or reports success */
-        return ret;
-}
-
-/*
- * gs_disconnect
- *
- * Called when the device is disconnected.  Frees the closed
- * ports and disconnects open ports.  Open ports will be freed
- * on close.  Then reallocates the ports for the next connection.
- */
-static void gs_disconnect(struct usb_gadget *gadget)
-{
-        unsigned long flags;
-        struct gs_dev *dev = get_gadget_data(gadget);
-
-        spin_lock_irqsave(&dev->dev_lock, flags);
-
-        gs_reset_config(dev);
-
-        /* free closed ports and disconnect open ports */
-        /* (open ports will be freed when closed) */
-        gs_free_ports(dev);
-
-        /* re-allocate ports for the next connection */
-        if (gs_alloc_ports(dev, GFP_ATOMIC) != 0)
-                pr_err("gs_disconnect: cannot re-allocate ports\n");
-
-        spin_unlock_irqrestore(&dev->dev_lock, flags);
-
-        pr_info("gs_disconnect: %s disconnected\n", GS_LONG_NAME);
-}
-
-static struct usb_gadget_driver gs_gadget_driver = {
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        .speed =                USB_SPEED_HIGH,
-#else
-        .speed =                USB_SPEED_FULL,
-#endif /* CONFIG_USB_GADGET_DUALSPEED */
-        .function =             GS_LONG_NAME,
-        .bind =                 gs_bind,
-        .unbind =               gs_unbind,
-        .setup =                gs_setup,
-        .disconnect =           gs_disconnect,
-        .driver = {
-                .name =         GS_SHORT_NAME,
-                .owner =        THIS_MODULE,
-        },
+static struct usb_composite_driver gserial_driver = {
+        .name           = "g_serial",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
+        .bind           = gs_bind,
 };
 
-/*
- * gs_set_config
- *
- * Configures the device by enabling device specific
- * optimizations, setting up the endpoints, allocating
- * read and write requests and queuing read requests.
- *
- * The device lock must be held when calling this function.
- */
-static int gs_set_config(struct gs_dev *dev, unsigned config)
+static int __init init(void)
 {
-        int i;
-        int ret = 0;
-        struct usb_gadget *gadget = dev->dev_gadget;
-        struct usb_ep *ep;
-        struct usb_endpoint_descriptor *out, *in, *notify;
-        struct usb_request *req;
-
-        if (dev == NULL) {
-                pr_err("gs_set_config: NULL device pointer\n");
-                return 0;
-        }
-
-        if (config == dev->dev_config)
-                return 0;
-
-        gs_reset_config(dev);
-
-        switch (config) {
-        case GS_NO_CONFIG_ID:
-                return 0;
-        case GS_BULK_CONFIG_ID:
-                if (use_acm)
-                        return -EINVAL;
-                break;
-        case GS_ACM_CONFIG_ID:
-                if (!use_acm)
-                        return -EINVAL;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        in = choose_ep_desc(gadget,
-                        &gs_highspeed_in_desc,
-                        &gs_fullspeed_in_desc);
-        out = choose_ep_desc(gadget,
-                        &gs_highspeed_out_desc,
-                        &gs_fullspeed_out_desc);
-        notify = dev->dev_notify_ep
-                ? choose_ep_desc(gadget,
-                                &gs_highspeed_notify_desc,
-                                &gs_fullspeed_notify_desc)
-                : NULL;
-
-        ret = usb_ep_enable(dev->dev_in_ep, in);
-        if (ret == 0) {
-                dev->dev_in_ep_desc = in;
-        } else {
-                pr_debug("%s: cannot enable %s %s, ret=%d\n",
-                        __func__, "IN", dev->dev_in_ep->name, ret);
-                return ret;
-        }
-
-        ret = usb_ep_enable(dev->dev_out_ep, out);
-        if (ret == 0) {
-                dev->dev_out_ep_desc = out;
-        } else {
-                pr_debug("%s: cannot enable %s %s, ret=%d\n",
-                        __func__, "OUT", dev->dev_out_ep->name, ret);
-fail0:
-                usb_ep_disable(dev->dev_in_ep);
-                return ret;
-        }
-
-        if (notify) {
-                ret = usb_ep_enable(dev->dev_notify_ep, notify);
-                if (ret == 0) {
-                        dev->dev_notify_ep_desc = notify;
-                } else {
-                        pr_debug("%s: cannot enable %s %s, ret=%d\n",
-                                __func__, "NOTIFY",
-                                dev->dev_notify_ep->name, ret);
-                        usb_ep_disable(dev->dev_out_ep);
-                        goto fail0;
-                }
-        }
-
-        dev->dev_config = config;
-
-        /* allocate and queue read requests */
-        ep = dev->dev_out_ep;
-        for (i=0; i<read_q_size && ret == 0; i++) {
-                if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) {
-                        req->complete = gs_read_complete;
-                        if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
-                                pr_err("gs_set_config: cannot queue read "
-                                        "request, ret=%d\n", ret);
-                        }
-                } else {
-                        pr_err("gs_set_config: cannot allocate "
-                                        "read requests\n");
-                        ret = -ENOMEM;
-                        goto exit_reset_config;
-                }
-        }
-
-        /* allocate write requests, and put on free list */
-        ep = dev->dev_in_ep;
-        for (i=0; i<write_q_size; i++) {
-                req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
-                if (req) {
-                        req->complete = gs_write_complete;
-                        list_add(&req->list, &dev->dev_req_list);
-                } else {
-                        pr_err("gs_set_config: cannot allocate "
-                                        "write requests\n");
-                        ret = -ENOMEM;
-                        goto exit_reset_config;
-                }
-        }
-
-        /* REVISIT the ACM mode should be able to actually *issue* some
-         * notifications, for at least serial state change events if
-         * not also for network connection; say so in bmCapabilities.
+        /* We *could* export two configs; that'd be much cleaner...
+         * but neither of these product IDs was defined that way.
          */
-
-        pr_info("gs_set_config: %s configured, %s speed %s config\n",
-                GS_LONG_NAME,
-                gadget->speed == USB_SPEED_HIGH ? "high" : "full",
-                config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM");
-
-        return 0;
-
-exit_reset_config:
-        gs_reset_config(dev);
-        return ret;
-}
-
-/*
- * gs_reset_config
- *
- * Mark the device as not configured, disable all endpoints,
- * which forces completion of pending I/O and frees queued
- * requests, and free the remaining write requests on the
- * free list.
- *
- * The device lock must be held when calling this function.
- */
-static void gs_reset_config(struct gs_dev *dev)
-{
-        struct usb_request *req;
-
-        if (dev == NULL) {
-                pr_err("gs_reset_config: NULL device pointer\n");
-                return;
-        }
-
-        if (dev->dev_config == GS_NO_CONFIG_ID)
-                return;
-
-        dev->dev_config = GS_NO_CONFIG_ID;
-
-        /* free write requests on the free list */
-        while(!list_empty(&dev->dev_req_list)) {
-                req = list_entry(dev->dev_req_list.next,
-                                struct usb_request, list);
-                list_del(&req->list);
-                gs_free_req(dev->dev_in_ep, req);
-        }
-
-        /* disable endpoints, forcing completion of pending i/o; */
-        /* completion handlers free their requests in this case */
-        if (dev->dev_notify_ep)
-                usb_ep_disable(dev->dev_notify_ep);
-        usb_ep_disable(dev->dev_in_ep);
-        usb_ep_disable(dev->dev_out_ep);
-}
-
-/*
- * gs_build_config_buf
- *
- * Builds the config descriptors in the given buffer and returns the
- * length, or a negative error number.
- */
-static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
-        u8 type, unsigned int index, int is_otg)
-{
-        int len;
-        int high_speed = 0;
-        const struct usb_config_descriptor *config_desc;
-        const struct usb_descriptor_header **function;
-
-        if (index >= gs_device_desc.bNumConfigurations)
-                return -EINVAL;
-
-        /* other speed switches high and full speed */
-        if (gadget_is_dualspeed(g)) {
-                high_speed = (g->speed == USB_SPEED_HIGH);
-                if (type == USB_DT_OTHER_SPEED_CONFIG)
-                        high_speed = !high_speed;
-        }
-
         if (use_acm) {
-                config_desc = &gs_acm_config_desc;
-                function = high_speed
-                        ? gs_acm_highspeed_function
-                        : gs_acm_fullspeed_function;
+                serial_config_driver.label = "CDC ACM config";
+                serial_config_driver.bConfigurationValue = 2;
+                device_desc.bDeviceClass = USB_CLASS_COMM;
+                device_desc.idProduct =
+                                __constant_cpu_to_le16(GS_CDC_PRODUCT_ID);
         } else {
-                config_desc = &gs_bulk_config_desc;
-                function = high_speed
-                        ? gs_bulk_highspeed_function
-                        : gs_bulk_fullspeed_function;
-        }
-
-        /* for now, don't advertise srp-only devices */
-        if (!is_otg)
-                function++;
-
-        len = usb_gadget_config_buf(config_desc, buf, GS_MAX_DESC_LEN, function);
-        if (len < 0)
-                return len;
-
-        ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
-
-        return len;
-}
-
-/*
- * gs_alloc_req
- *
- * Allocate a usb_request and its buffer.  Returns a pointer to the
- * usb_request or NULL if there is an error.
- */
-static struct usb_request *
-gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags)
-{
-        struct usb_request *req;
-
-        if (ep == NULL)
-                return NULL;
-
-        req = usb_ep_alloc_request(ep, kmalloc_flags);
-
-        if (req != NULL) {
-                req->length = len;
-                req->buf = kmalloc(len, kmalloc_flags);
-                if (req->buf == NULL) {
-                        usb_ep_free_request(ep, req);
-                        return NULL;
-                }
+                serial_config_driver.label = "Generic Serial config";
+                serial_config_driver.bConfigurationValue = 1;
+                device_desc.bDeviceClass = USB_CLASS_VENDOR_SPEC;
+                device_desc.idProduct =
+                                __constant_cpu_to_le16(GS_PRODUCT_ID);
         }
+        strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
 
-        return req;
+        return usb_composite_register(&gserial_driver);
 }
+module_init(init);
 
-/*
- * gs_free_req
- *
- * Free a usb_request and its buffer.
- */
-static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
+static void __exit cleanup(void)
 {
-        if (ep != NULL && req != NULL) {
-                kfree(req->buf);
-                usb_ep_free_request(ep, req);
-        }
-}
-
-/*
- * gs_alloc_ports
- *
- * Allocate all ports and set the gs_dev struct to point to them.
- * Return 0 if successful, or a negative error number.
- *
- * The device lock is normally held when calling this function.
- */
-static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags)
-{
-        int i;
-        struct gs_port *port;
-
-        if (dev == NULL)
-                return -EIO;
-
-        for (i=0; i<GS_NUM_PORTS; i++) {
-                if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL)
-                        return -ENOMEM;
-
-                port->port_dev = dev;
-                port->port_num = i;
-                port->port_line_coding.dwDTERate = cpu_to_le32(GS_DEFAULT_DTE_RATE);
-                port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT;
-                port->port_line_coding.bParityType = GS_DEFAULT_PARITY;
-                port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS;
-                spin_lock_init(&port->port_lock);
-                init_waitqueue_head(&port->port_write_wait);
-
-                dev->dev_port[i] = port;
-        }
-
-        return 0;
-}
-
-/*
- * gs_free_ports
- *
- * Free all closed ports.  Open ports are disconnected by
- * freeing their write buffers, setting their device pointers
- * and the pointers to them in the device to NULL.  These
- * ports will be freed when closed.
- *
- * The device lock is normally held when calling this function.
- */
-static void gs_free_ports(struct gs_dev *dev)
-{
-        int i;
-        unsigned long flags;
-        struct gs_port *port;
-
-        if (dev == NULL)
-                return;
-
-        for (i=0; i<GS_NUM_PORTS; i++) {
-                if ((port=dev->dev_port[i]) != NULL) {
-                        dev->dev_port[i] = NULL;
-
-                        spin_lock_irqsave(&port->port_lock, flags);
-
-                        if (port->port_write_buf != NULL) {
-                                gs_buf_free(port->port_write_buf);
-                                port->port_write_buf = NULL;
-                        }
-
-                        if (port->port_open_count > 0 || port->port_in_use) {
-                                port->port_dev = NULL;
-                                wake_up_interruptible(&port->port_write_wait);
-                                if (port->port_tty) {
-                                        tty_hangup(port->port_tty);
-                                }
-                                spin_unlock_irqrestore(&port->port_lock, flags);
-                        } else {
-                                spin_unlock_irqrestore(&port->port_lock, flags);
-                                kfree(port);
-                        }
-
-                }
-        }
-}
-
-/*-------------------------------------------------------------------------*/
-
-/* Circular Buffer */
-
-/*
- * gs_buf_alloc
- *
- * Allocate a circular buffer and all associated memory.
- */
-static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags)
-{
-        struct gs_buf *gb;
-
-        if (size == 0)
-                return NULL;
-
-        gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags);
-        if (gb == NULL)
-                return NULL;
-
-        gb->buf_buf = kmalloc(size, kmalloc_flags);
-        if (gb->buf_buf == NULL) {
-                kfree(gb);
-                return NULL;
-        }
-
-        gb->buf_size = size;
-        gb->buf_get = gb->buf_put = gb->buf_buf;
-
-        return gb;
-}
-
-/*
- * gs_buf_free
- *
- * Free the buffer and all associated memory.
- */
-static void gs_buf_free(struct gs_buf *gb)
-{
-        if (gb) {
-                kfree(gb->buf_buf);
-                kfree(gb);
-        }
-}
-
-/*
- * gs_buf_clear
- *
- * Clear out all data in the circular buffer.
- */
-static void gs_buf_clear(struct gs_buf *gb)
-{
-        if (gb != NULL)
-                gb->buf_get = gb->buf_put;
-                /* equivalent to a get of all data available */
-}
-
-/*
- * gs_buf_data_avail
- *
- * Return the number of bytes of data available in the circular
- * buffer.
- */
-static unsigned int gs_buf_data_avail(struct gs_buf *gb)
-{
-        if (gb != NULL)
-                return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
-        else
-                return 0;
-}
-
-/*
- * gs_buf_space_avail
- *
- * Return the number of bytes of space available in the circular
- * buffer.
- */
-static unsigned int gs_buf_space_avail(struct gs_buf *gb)
-{
-        if (gb != NULL)
-                return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
-        else
-                return 0;
-}
-
-/*
- * gs_buf_put
- *
- * Copy data data from a user buffer and put it into the circular buffer.
- * Restrict to the amount of space available.
- *
- * Return the number of bytes copied.
- */
-static unsigned int
-gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count)
-{
-        unsigned int len;
-
-        if (gb == NULL)
-                return 0;
-
-        len  = gs_buf_space_avail(gb);
-        if (count > len)
-                count = len;
-
-        if (count == 0)
-                return 0;
-
-        len = gb->buf_buf + gb->buf_size - gb->buf_put;
-        if (count > len) {
-                memcpy(gb->buf_put, buf, len);
-                memcpy(gb->buf_buf, buf+len, count - len);
-                gb->buf_put = gb->buf_buf + count - len;
-        } else {
-                memcpy(gb->buf_put, buf, count);
-                if (count < len)
-                        gb->buf_put += count;
-                else /* count == len */
-                        gb->buf_put = gb->buf_buf;
-        }
-
-        return count;
-}
-
-/*
- * gs_buf_get
- *
- * Get data from the circular buffer and copy to the given buffer.
- * Restrict to the amount of data available.
- *
- * Return the number of bytes copied.
- */
-static unsigned int
-gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
-{
-        unsigned int len;
-
-        if (gb == NULL)
-                return 0;
-
-        len = gs_buf_data_avail(gb);
-        if (count > len)
-                count = len;
-
-        if (count == 0)
-                return 0;
-
-        len = gb->buf_buf + gb->buf_size - gb->buf_get;
-        if (count > len) {
-                memcpy(buf, gb->buf_get, len);
-                memcpy(buf+len, gb->buf_buf, count - len);
-                gb->buf_get = gb->buf_buf + count - len;
-        } else {
-                memcpy(buf, gb->buf_get, count);
-                if (count < len)
-                        gb->buf_get += count;
-                else /* count == len */
-                        gb->buf_get = gb->buf_buf;
-        }
-
-        return count;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static struct tty_driver *gs_tty_driver;
-
-/*
- *  gs_module_init
- *
- *  Register as a USB gadget driver and a tty driver.
- */
-static int __init gs_module_init(void)
-{
-        int i;
-        int retval;
-
-        retval = usb_gadget_register_driver(&gs_gadget_driver);
-        if (retval) {
-                pr_err("gs_module_init: cannot register gadget driver, "
-                        "ret=%d\n", retval);
-                return retval;
-        }
-
-        gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
-        if (!gs_tty_driver)
-                return -ENOMEM;
-        gs_tty_driver->owner = THIS_MODULE;
-        gs_tty_driver->driver_name = GS_SHORT_NAME;
-        gs_tty_driver->name = "ttygs";
-        gs_tty_driver->major = GS_MAJOR;
-        gs_tty_driver->minor_start = GS_MINOR_START;
-        gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
-        gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
-        gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
-        gs_tty_driver->init_termios = tty_std_termios;
-        /* must match GS_DEFAULT_DTE_RATE and friends */
-        gs_tty_driver->init_termios.c_cflag =
-                B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-        gs_tty_driver->init_termios.c_ispeed = GS_DEFAULT_DTE_RATE;
-        gs_tty_driver->init_termios.c_ospeed = GS_DEFAULT_DTE_RATE;
-        tty_set_operations(gs_tty_driver, &gs_tty_ops);
-
-        for (i = 0; i < GS_NUM_PORTS; i++)
-                mutex_init(&gs_open_close_lock[i]);
-
-        retval = tty_register_driver(gs_tty_driver);
-        if (retval) {
-                usb_gadget_unregister_driver(&gs_gadget_driver);
-                put_tty_driver(gs_tty_driver);
-                pr_err("gs_module_init: cannot register tty driver, "
-                                "ret=%d\n", retval);
-                return retval;
-        }
-
-        pr_info("gs_module_init: %s %s loaded\n",
-                        GS_LONG_NAME, GS_VERSION_STR);
-        return 0;
-}
-module_init(gs_module_init);
-
-/*
- * gs_module_exit
- *
- * Unregister as a tty driver and a USB gadget driver.
- */
-static void __exit gs_module_exit(void)
-{
-        tty_unregister_driver(gs_tty_driver);
-        put_tty_driver(gs_tty_driver);
-        usb_gadget_unregister_driver(&gs_gadget_driver);
-
-        pr_info("gs_module_exit: %s %s unloaded\n",
-                        GS_LONG_NAME, GS_VERSION_STR);
+        usb_composite_unregister(&gserial_driver);
+        gserial_cleanup();
 }
-module_exit(gs_module_exit);
+module_exit(cleanup);
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
new file mode 100644
index 000000000000..5458f43a8668
--- /dev/null
+++ b/drivers/usb/gadget/u_ether.c
@@ -0,0 +1,967 @@
+/*
+ * u_ether.c -- Ethernet-over-USB link layer utilities for Gadget stack
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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 VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/utsname.h>
+#include <linux/device.h>
+#include <linux/ctype.h>
+#include <linux/etherdevice.h>
+#include <linux/ethtool.h>
+
+#include "u_ether.h"
+
+
+/*
+ * This component encapsulates the Ethernet link glue needed to provide
+ * one (!) network link through the USB gadget stack, normally "usb0".
+ *
+ * The control and data models are handled by the function driver which
+ * connects to this code; such as CDC Ethernet, "CDC Subset", or RNDIS.
+ * That includes all descriptor and endpoint management.
+ *
+ * Link level addressing is handled by this component using module
+ * parameters; if no such parameters are provided, random link level
+ * addresses are used.  Each end of the link uses one address.  The
+ * host end address is exported in various ways, and is often recorded
+ * in configuration databases.
+ *
+ * The driver which assembles each configuration using such a link is
+ * responsible for ensuring that each configuration includes at most one
+ * instance of is network link.  (The network layer provides ways for
+ * this single "physical" link to be used by multiple virtual links.)
+ */
+
+#define DRIVER_VERSION  "29-May-2008"
+
+struct eth_dev {
+        /* lock is held while accessing port_usb
+         * or updating its backlink port_usb->ioport
+         */
+        spinlock_t              lock;
+        struct gether           *port_usb;
+
+        struct net_device       *net;
+        struct usb_gadget       *gadget;
+
+        spinlock_t              req_lock;       /* guard {rx,tx}_reqs */
+        struct list_head        tx_reqs, rx_reqs;
+        atomic_t                tx_qlen;
+
+        unsigned                header_len;
+        struct sk_buff          *(*wrap)(struct sk_buff *skb);
+        int                     (*unwrap)(struct sk_buff *skb);
+
+        struct work_struct      work;
+
+        unsigned long           todo;
+#define WORK_RX_MEMORY          0
+
+        bool                    zlp;
+        u8                      host_mac[ETH_ALEN];
+};
+
+/*-------------------------------------------------------------------------*/
+
+#define RX_EXTRA        20      /* bytes guarding against rx overflows */
+
+#define DEFAULT_QLEN    2       /* double buffering by default */
+
+
+#ifdef CONFIG_USB_GADGET_DUALSPEED
+
+static unsigned qmult = 5;
+module_param(qmult, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(qmult, "queue length multiplier at high speed");
+
+#else   /* full speed (low speed doesn't do bulk) */
+#define qmult           1
+#endif
+
+/* for dual-speed hardware, use deeper queues at highspeed */
+static inline int qlen(struct usb_gadget *gadget)
+{
+        if (gadget_is_dualspeed(gadget) && gadget->speed == USB_SPEED_HIGH)
+                return qmult * DEFAULT_QLEN;
+        else
+                return DEFAULT_QLEN;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* REVISIT there must be a better way than having two sets
+ * of debug calls ...
+ */
+
+#undef DBG
+#undef VDBG
+#undef ERROR
+#undef WARN
+#undef INFO
+
+#define xprintk(d, level, fmt, args...) \
+        printk(level "%s: " fmt , (d)->net->name , ## args)
+
+#ifdef DEBUG
+#undef DEBUG
+#define DBG(dev, fmt, args...) \
+        xprintk(dev , KERN_DEBUG , fmt , ## args)
+#else
+#define DBG(dev, fmt, args...) \
+        do { } while (0)
+#endif /* DEBUG */
+
+#ifdef VERBOSE_DEBUG
+#define VDBG    DBG
+#else
+#define VDBG(dev, fmt, args...) \
+        do { } while (0)
+#endif /* DEBUG */
+
+#define ERROR(dev, fmt, args...) \
+        xprintk(dev , KERN_ERR , fmt , ## args)
+#define WARN(dev, fmt, args...) \
+        xprintk(dev , KERN_WARNING , fmt , ## args)
+#define INFO(dev, fmt, args...) \
+        xprintk(dev , KERN_INFO , fmt , ## args)
+
+/*-------------------------------------------------------------------------*/
+
+/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
+
+static int eth_change_mtu(struct net_device *net, int new_mtu)
+{
+        struct eth_dev  *dev = netdev_priv(net);
+        unsigned long   flags;
+        int             status = 0;
+
+        /* don't change MTU on "live" link (peer won't know) */
+        spin_lock_irqsave(&dev->lock, flags);
+        if (dev->port_usb)
+                status = -EBUSY;
+        else if (new_mtu <= ETH_HLEN || new_mtu > ETH_FRAME_LEN)
+                status = -ERANGE;
+        else
+                net->mtu = new_mtu;
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        return status;
+}
+
+static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
+{
+        struct eth_dev  *dev = netdev_priv(net);
+
+        strlcpy(p->driver, "g_ether", sizeof p->driver);
+        strlcpy(p->version, DRIVER_VERSION, sizeof p->version);
+        strlcpy(p->fw_version, dev->gadget->name, sizeof p->fw_version);
+        strlcpy(p->bus_info, dev_name(&dev->gadget->dev), sizeof p->bus_info);
+}
+
+static u32 eth_get_link(struct net_device *net)
+{
+        struct eth_dev  *dev = netdev_priv(net);
+        return dev->gadget->speed != USB_SPEED_UNKNOWN;
+}
+
+/* REVISIT can also support:
+ *   - WOL (by tracking suspends and issuing remote wakeup)
+ *   - msglevel (implies updated messaging)
+ *   - ... probably more ethtool ops
+ */
+
+static struct ethtool_ops ops = {
+        .get_drvinfo = eth_get_drvinfo,
+        .get_link = eth_get_link
+};
+
+static void defer_kevent(struct eth_dev *dev, int flag)
+{
+        if (test_and_set_bit(flag, &dev->todo))
+                return;
+        if (!schedule_work(&dev->work))
+                ERROR(dev, "kevent %d may have been dropped\n", flag);
+        else
+                DBG(dev, "kevent %d scheduled\n", flag);
+}
+
+static void rx_complete(struct usb_ep *ep, struct usb_request *req);
+
+static int
+rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
+{
+        struct sk_buff  *skb;
+        int             retval = -ENOMEM;
+        size_t          size = 0;
+        struct usb_ep   *out;
+        unsigned long   flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (dev->port_usb)
+                out = dev->port_usb->out_ep;
+        else
+                out = NULL;
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        if (!out)
+                return -ENOTCONN;
+
+
+        /* Padding up to RX_EXTRA handles minor disagreements with host.
+         * Normally we use the USB "terminate on short read" convention;
+         * so allow up to (N*maxpacket), since that memory is normally
+         * already allocated.  Some hardware doesn't deal well with short
+         * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
+         * byte off the end (to force hardware errors on overflow).
+         *
+         * RNDIS uses internal framing, and explicitly allows senders to
+         * pad to end-of-packet.  That's potentially nice for speed, but
+         * means receivers can't recover lost synch on their own (because
+         * new packets don't only start after a short RX).
+         */
+        size += sizeof(struct ethhdr) + dev->net->mtu + RX_EXTRA;
+        size += dev->port_usb->header_len;
+        size += out->maxpacket - 1;
+        size -= size % out->maxpacket;
+
+        skb = alloc_skb(size + NET_IP_ALIGN, gfp_flags);
+        if (skb == NULL) {
+                DBG(dev, "no rx skb\n");
+                goto enomem;
+        }
+
+        /* Some platforms perform better when IP packets are aligned,
+         * but on at least one, checksumming fails otherwise.  Note:
+         * RNDIS headers involve variable numbers of LE32 values.
+         */
+        skb_reserve(skb, NET_IP_ALIGN);
+
+        req->buf = skb->data;
+        req->length = size;
+        req->complete = rx_complete;
+        req->context = skb;
+
+        retval = usb_ep_queue(out, req, gfp_flags);
+        if (retval == -ENOMEM)
+enomem:
+                defer_kevent(dev, WORK_RX_MEMORY);
+        if (retval) {
+                DBG(dev, "rx submit --> %d\n", retval);
+                if (skb)
+                        dev_kfree_skb_any(skb);
+                spin_lock_irqsave(&dev->req_lock, flags);
+                list_add(&req->list, &dev->rx_reqs);
+                spin_unlock_irqrestore(&dev->req_lock, flags);
+        }
+        return retval;
+}
+
+static void rx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct sk_buff  *skb = req->context;
+        struct eth_dev  *dev = ep->driver_data;
+        int             status = req->status;
+
+        switch (status) {
+
+        /* normal completion */
+        case 0:
+                skb_put(skb, req->actual);
+                if (dev->unwrap)
+                        status = dev->unwrap(skb);
+                if (status < 0
+                                || ETH_HLEN > skb->len
+                                || skb->len > ETH_FRAME_LEN) {
+                        dev->net->stats.rx_errors++;
+                        dev->net->stats.rx_length_errors++;
+                        DBG(dev, "rx length %d\n", skb->len);
+                        break;
+                }
+
+                skb->protocol = eth_type_trans(skb, dev->net);
+                dev->net->stats.rx_packets++;
+                dev->net->stats.rx_bytes += skb->len;
+
+                /* no buffer copies needed, unless hardware can't
+                 * use skb buffers.
+                 */
+                status = netif_rx(skb);
+                skb = NULL;
+                break;
+
+        /* software-driven interface shutdown */
+        case -ECONNRESET:               /* unlink */
+        case -ESHUTDOWN:                /* disconnect etc */
+                VDBG(dev, "rx shutdown, code %d\n", status);
+                goto quiesce;
+
+        /* for hardware automagic (such as pxa) */
+        case -ECONNABORTED:             /* endpoint reset */
+                DBG(dev, "rx %s reset\n", ep->name);
+                defer_kevent(dev, WORK_RX_MEMORY);
+quiesce:
+                dev_kfree_skb_any(skb);
+                goto clean;
+
+        /* data overrun */
+        case -EOVERFLOW:
+                dev->net->stats.rx_over_errors++;
+                /* FALLTHROUGH */
+
+        default:
+                dev->net->stats.rx_errors++;
+                DBG(dev, "rx status %d\n", status);
+                break;
+        }
+
+        if (skb)
+                dev_kfree_skb_any(skb);
+        if (!netif_running(dev->net)) {
+clean:
+                spin_lock(&dev->req_lock);
+                list_add(&req->list, &dev->rx_reqs);
+                spin_unlock(&dev->req_lock);
+                req = NULL;
+        }
+        if (req)
+                rx_submit(dev, req, GFP_ATOMIC);
+}
+
+static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n)
+{
+        unsigned                i;
+        struct usb_request      *req;
+
+        if (!n)
+                return -ENOMEM;
+
+        /* queue/recycle up to N requests */
+        i = n;
+        list_for_each_entry(req, list, list) {
+                if (i-- == 0)
+                        goto extra;
+        }
+        while (i--) {
+                req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+                if (!req)
+                        return list_empty(list) ? -ENOMEM : 0;
+                list_add(&req->list, list);
+        }
+        return 0;
+
+extra:
+        /* free extras */
+        for (;;) {
+                struct list_head        *next;
+
+                next = req->list.next;
+                list_del(&req->list);
+                usb_ep_free_request(ep, req);
+
+                if (next == list)
+                        break;
+
+                req = container_of(next, struct usb_request, list);
+        }
+        return 0;
+}
+
+static int alloc_requests(struct eth_dev *dev, struct gether *link, unsigned n)
+{
+        int     status;
+
+        spin_lock(&dev->req_lock);
+        status = prealloc(&dev->tx_reqs, link->in_ep, n);
+        if (status < 0)
+                goto fail;
+        status = prealloc(&dev->rx_reqs, link->out_ep, n);
+        if (status < 0)
+                goto fail;
+        goto done;
+fail:
+        DBG(dev, "can't alloc requests\n");
+done:
+        spin_unlock(&dev->req_lock);
+        return status;
+}
+
+static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
+{
+        struct usb_request      *req;
+        unsigned long           flags;
+
+        /* fill unused rxq slots with some skb */
+        spin_lock_irqsave(&dev->req_lock, flags);
+        while (!list_empty(&dev->rx_reqs)) {
+                req = container_of(dev->rx_reqs.next,
+                                struct usb_request, list);
+                list_del_init(&req->list);
+                spin_unlock_irqrestore(&dev->req_lock, flags);
+
+                if (rx_submit(dev, req, gfp_flags) < 0) {
+                        defer_kevent(dev, WORK_RX_MEMORY);
+                        return;
+                }
+
+                spin_lock_irqsave(&dev->req_lock, flags);
+        }
+        spin_unlock_irqrestore(&dev->req_lock, flags);
+}
+
+static void eth_work(struct work_struct *work)
+{
+        struct eth_dev  *dev = container_of(work, struct eth_dev, work);
+
+        if (test_and_clear_bit(WORK_RX_MEMORY, &dev->todo)) {
+                if (netif_running(dev->net))
+                        rx_fill(dev, GFP_KERNEL);
+        }
+
+        if (dev->todo)
+                DBG(dev, "work done, flags = 0x%lx\n", dev->todo);
+}
+
+static void tx_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct sk_buff  *skb = req->context;
+        struct eth_dev  *dev = ep->driver_data;
+
+        switch (req->status) {
+        default:
+                dev->net->stats.tx_errors++;
+                VDBG(dev, "tx err %d\n", req->status);
+                /* FALLTHROUGH */
+        case -ECONNRESET:               /* unlink */
+        case -ESHUTDOWN:                /* disconnect etc */
+                break;
+        case 0:
+                dev->net->stats.tx_bytes += skb->len;
+        }
+        dev->net->stats.tx_packets++;
+
+        spin_lock(&dev->req_lock);
+        list_add(&req->list, &dev->tx_reqs);
+        spin_unlock(&dev->req_lock);
+        dev_kfree_skb_any(skb);
+
+        atomic_dec(&dev->tx_qlen);
+        if (netif_carrier_ok(dev->net))
+                netif_wake_queue(dev->net);
+}
+
+static inline int is_promisc(u16 cdc_filter)
+{
+        return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
+}
+
+static int eth_start_xmit(struct sk_buff *skb, struct net_device *net)
+{
+        struct eth_dev          *dev = netdev_priv(net);
+        int                     length = skb->len;
+        int                     retval;
+        struct usb_request      *req = NULL;
+        unsigned long           flags;
+        struct usb_ep           *in;
+        u16                     cdc_filter;
+
+        spin_lock_irqsave(&dev->lock, flags);
+        if (dev->port_usb) {
+                in = dev->port_usb->in_ep;
+                cdc_filter = dev->port_usb->cdc_filter;
+        } else {
+                in = NULL;
+                cdc_filter = 0;
+        }
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        if (!in) {
+                dev_kfree_skb_any(skb);
+                return 0;
+        }
+
+        /* apply outgoing CDC or RNDIS filters */
+        if (!is_promisc(cdc_filter)) {
+                u8              *dest = skb->data;
+
+                if (is_multicast_ether_addr(dest)) {
+                        u16     type;
+
+                        /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
+                         * SET_ETHERNET_MULTICAST_FILTERS requests
+                         */
+                        if (is_broadcast_ether_addr(dest))
+                                type = USB_CDC_PACKET_TYPE_BROADCAST;
+                        else
+                                type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
+                        if (!(cdc_filter & type)) {
+                                dev_kfree_skb_any(skb);
+                                return 0;
+                        }
+                }
+                /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
+        }
+
+        spin_lock_irqsave(&dev->req_lock, flags);
+        /*
+         * this freelist can be empty if an interrupt triggered disconnect()
+         * and reconfigured the gadget (shutting down this queue) after the
+         * network stack decided to xmit but before we got the spinlock.
+         */
+        if (list_empty(&dev->tx_reqs)) {
+                spin_unlock_irqrestore(&dev->req_lock, flags);
+                return 1;
+        }
+
+        req = container_of(dev->tx_reqs.next, struct usb_request, list);
+        list_del(&req->list);
+
+        /* temporarily stop TX queue when the freelist empties */
+        if (list_empty(&dev->tx_reqs))
+                netif_stop_queue(net);
+        spin_unlock_irqrestore(&dev->req_lock, flags);
+
+        /* no buffer copies needed, unless the network stack did it
+         * or the hardware can't use skb buffers.
+         * or there's not enough space for extra headers we need
+         */
+        if (dev->wrap) {
+                struct sk_buff  *skb_new;
+
+                skb_new = dev->wrap(skb);
+                if (!skb_new)
+                        goto drop;
+
+                dev_kfree_skb_any(skb);
+                skb = skb_new;
+                length = skb->len;
+        }
+        req->buf = skb->data;
+        req->context = skb;
+        req->complete = tx_complete;
+
+        /* use zlp framing on tx for strict CDC-Ether conformance,
+         * though any robust network rx path ignores extra padding.
+         * and some hardware doesn't like to write zlps.
+         */
+        req->zero = 1;
+        if (!dev->zlp && (length % in->maxpacket) == 0)
+                length++;
+
+        req->length = length;
+
+        /* throttle highspeed IRQ rate back slightly */
+        if (gadget_is_dualspeed(dev->gadget))
+                req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
+                        ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
+                        : 0;
+
+        retval = usb_ep_queue(in, req, GFP_ATOMIC);
+        switch (retval) {
+        default:
+                DBG(dev, "tx queue err %d\n", retval);
+                break;
+        case 0:
+                net->trans_start = jiffies;
+                atomic_inc(&dev->tx_qlen);
+        }
+
+        if (retval) {
+drop:
+                dev->net->stats.tx_dropped++;
+                dev_kfree_skb_any(skb);
+                spin_lock_irqsave(&dev->req_lock, flags);
+                if (list_empty(&dev->tx_reqs))
+                        netif_start_queue(net);
+                list_add(&req->list, &dev->tx_reqs);
+                spin_unlock_irqrestore(&dev->req_lock, flags);
+        }
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
+{
+        DBG(dev, "%s\n", __func__);
+
+        /* fill the rx queue */
+        rx_fill(dev, gfp_flags);
+
+        /* and open the tx floodgates */
+        atomic_set(&dev->tx_qlen, 0);
+        netif_wake_queue(dev->net);
+}
+
+static int eth_open(struct net_device *net)
+{
+        struct eth_dev  *dev = netdev_priv(net);
+        struct gether   *link;
+
+        DBG(dev, "%s\n", __func__);
+        if (netif_carrier_ok(dev->net))
+                eth_start(dev, GFP_KERNEL);
+
+        spin_lock_irq(&dev->lock);
+        link = dev->port_usb;
+        if (link && link->open)
+                link->open(link);
+        spin_unlock_irq(&dev->lock);
+
+        return 0;
+}
+
+static int eth_stop(struct net_device *net)
+{
+        struct eth_dev  *dev = netdev_priv(net);
+        unsigned long   flags;
+
+        VDBG(dev, "%s\n", __func__);
+        netif_stop_queue(net);
+
+        DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
+                dev->net->stats.rx_packets, dev->net->stats.tx_packets,
+                dev->net->stats.rx_errors, dev->net->stats.tx_errors
+                );
+
+        /* ensure there are no more active requests */
+        spin_lock_irqsave(&dev->lock, flags);
+        if (dev->port_usb) {
+                struct gether   *link = dev->port_usb;
+
+                if (link->close)
+                        link->close(link);
+
+                /* NOTE:  we have no abort-queue primitive we could use
+                 * to cancel all pending I/O.  Instead, we disable then
+                 * reenable the endpoints ... this idiom may leave toggle
+                 * wrong, but that's a self-correcting error.
+                 *
+                 * REVISIT:  we *COULD* just let the transfers complete at
+                 * their own pace; the network stack can handle old packets.
+                 * For the moment we leave this here, since it works.
+                 */
+                usb_ep_disable(link->in_ep);
+                usb_ep_disable(link->out_ep);
+                if (netif_carrier_ok(net)) {
+                        DBG(dev, "host still using in/out endpoints\n");
+                        usb_ep_enable(link->in_ep, link->in);
+                        usb_ep_enable(link->out_ep, link->out);
+                }
+        }
+        spin_unlock_irqrestore(&dev->lock, flags);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
+static char *dev_addr;
+module_param(dev_addr, charp, S_IRUGO);
+MODULE_PARM_DESC(dev_addr, "Device Ethernet Address");
+
+/* this address is invisible to ifconfig */
+static char *host_addr;
+module_param(host_addr, charp, S_IRUGO);
+MODULE_PARM_DESC(host_addr, "Host Ethernet Address");
+
+
+static u8 __init nibble(unsigned char c)
+{
+        if (isdigit(c))
+                return c - '0';
+        c = toupper(c);
+        if (isxdigit(c))
+                return 10 + c - 'A';
+        return 0;
+}
+
+static int __init get_ether_addr(const char *str, u8 *dev_addr)
+{
+        if (str) {
+                unsigned        i;
+
+                for (i = 0; i < 6; i++) {
+                        unsigned char num;
+
+                        if ((*str == '.') || (*str == ':'))
+                                str++;
+                        num = nibble(*str++) << 4;
+                        num |= (nibble(*str++));
+                        dev_addr [i] = num;
+                }
+                if (is_valid_ether_addr(dev_addr))
+                        return 0;
+        }
+        random_ether_addr(dev_addr);
+        return 1;
+}
+
+static struct eth_dev *the_dev;
+
+
+/**
+ * gether_setup - initialize one ethernet-over-usb link
+ * @g: gadget to associated with these links
+ * @ethaddr: NULL, or a buffer in which the ethernet address of the
+ *      host side of the link is recorded
+ * Context: may sleep
+ *
+ * This sets up the single network link that may be exported by a
+ * gadget driver using this framework.  The link layer addresses are
+ * set up using module parameters.
+ *
+ * Returns negative errno, or zero on success
+ */
+int __init gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN])
+{
+        struct eth_dev          *dev;
+        struct net_device       *net;
+        int                     status;
+
+        if (the_dev)
+                return -EBUSY;
+
+        net = alloc_etherdev(sizeof *dev);
+        if (!net)
+                return -ENOMEM;
+
+        dev = netdev_priv(net);
+        spin_lock_init(&dev->lock);
+        spin_lock_init(&dev->req_lock);
+        INIT_WORK(&dev->work, eth_work);
+        INIT_LIST_HEAD(&dev->tx_reqs);
+        INIT_LIST_HEAD(&dev->rx_reqs);
+
+        /* network device setup */
+        dev->net = net;
+        strcpy(net->name, "usb%d");
+
+        if (get_ether_addr(dev_addr, net->dev_addr))
+                dev_warn(&g->dev,
+                        "using random %s ethernet address\n", "self");
+        if (get_ether_addr(host_addr, dev->host_mac))
+                dev_warn(&g->dev,
+                        "using random %s ethernet address\n", "host");
+
+        if (ethaddr)
+                memcpy(ethaddr, dev->host_mac, ETH_ALEN);
+
+        net->change_mtu = eth_change_mtu;
+        net->hard_start_xmit = eth_start_xmit;
+        net->open = eth_open;
+        net->stop = eth_stop;
+        /* watchdog_timeo, tx_timeout ... */
+        /* set_multicast_list */
+        SET_ETHTOOL_OPS(net, &ops);
+
+        /* two kinds of host-initiated state changes:
+         *  - iff DATA transfer is active, carrier is "on"
+         *  - tx queueing enabled if open *and* carrier is "on"
+         */
+        netif_stop_queue(net);
+        netif_carrier_off(net);
+
+        dev->gadget = g;
+        SET_NETDEV_DEV(net, &g->dev);
+
+        status = register_netdev(net);
+        if (status < 0) {
+                dev_dbg(&g->dev, "register_netdev failed, %d\n", status);
+                free_netdev(net);
+        } else {
+                DECLARE_MAC_BUF(tmp);
+
+                INFO(dev, "MAC %s\n", print_mac(tmp, net->dev_addr));
+                INFO(dev, "HOST MAC %s\n", print_mac(tmp, dev->host_mac));
+
+                the_dev = dev;
+        }
+
+        return status;
+}
+
+/**
+ * gether_cleanup - remove Ethernet-over-USB device
+ * Context: may sleep
+ *
+ * This is called to free all resources allocated by @gether_setup().
+ */
+void gether_cleanup(void)
+{
+        if (!the_dev)
+                return;
+
+        unregister_netdev(the_dev->net);
+        free_netdev(the_dev->net);
+
+        /* assuming we used keventd, it must quiesce too */
+        flush_scheduled_work();
+
+        the_dev = NULL;
+}
+
+
+/**
+ * gether_connect - notify network layer that USB link is active
+ * @link: the USB link, set up with endpoints, descriptors matching
+ *      current device speed, and any framing wrapper(s) set up.
+ * Context: irqs blocked
+ *
+ * This is called to activate endpoints and let the network layer know
+ * the connection is active ("carrier detect").  It may cause the I/O
+ * queues to open and start letting network packets flow, but will in
+ * any case activate the endpoints so that they respond properly to the
+ * USB host.
+ *
+ * Verify net_device pointer returned using IS_ERR().  If it doesn't
+ * indicate some error code (negative errno), ep->driver_data values
+ * have been overwritten.
+ */
+struct net_device *gether_connect(struct gether *link)
+{
+        struct eth_dev          *dev = the_dev;
+        int                     result = 0;
+
+        if (!dev)
+                return ERR_PTR(-EINVAL);
+
+        link->in_ep->driver_data = dev;
+        result = usb_ep_enable(link->in_ep, link->in);
+        if (result != 0) {
+                DBG(dev, "enable %s --> %d\n",
+                        link->in_ep->name, result);
+                goto fail0;
+        }
+
+        link->out_ep->driver_data = dev;
+        result = usb_ep_enable(link->out_ep, link->out);
+        if (result != 0) {
+                DBG(dev, "enable %s --> %d\n",
+                        link->out_ep->name, result);
+                goto fail1;
+        }
+
+        if (result == 0)
+                result = alloc_requests(dev, link, qlen(dev->gadget));
+
+        if (result == 0) {
+                dev->zlp = link->is_zlp_ok;
+                DBG(dev, "qlen %d\n", qlen(dev->gadget));
+
+                dev->header_len = link->header_len;
+                dev->unwrap = link->unwrap;
+                dev->wrap = link->wrap;
+
+                spin_lock(&dev->lock);
+                dev->port_usb = link;
+                link->ioport = dev;
+                spin_unlock(&dev->lock);
+
+                netif_carrier_on(dev->net);
+                if (netif_running(dev->net))
+                        eth_start(dev, GFP_ATOMIC);
+
+        /* on error, disable any endpoints  */
+        } else {
+                (void) usb_ep_disable(link->out_ep);
+fail1:
+                (void) usb_ep_disable(link->in_ep);
+        }
+fail0:
+        /* caller is responsible for cleanup on error */
+        if (result < 0)
+                return ERR_PTR(result);
+        return dev->net;
+}
+
+/**
+ * gether_disconnect - notify network layer that USB link is inactive
+ * @link: the USB link, on which gether_connect() was called
+ * Context: irqs blocked
+ *
+ * This is called to deactivate endpoints and let the network layer know
+ * the connection went inactive ("no carrier").
+ *
+ * On return, the state is as if gether_connect() had never been called.
+ * The endpoints are inactive, and accordingly without active USB I/O.
+ * Pointers to endpoint descriptors and endpoint private data are nulled.
+ */
+void gether_disconnect(struct gether *link)
+{
+        struct eth_dev          *dev = link->ioport;
+        struct usb_request      *req;
+
+        WARN_ON(!dev);
+        if (!dev)
+                return;
+
+        DBG(dev, "%s\n", __func__);
+
+        netif_stop_queue(dev->net);
+        netif_carrier_off(dev->net);
+
+        /* disable endpoints, forcing (synchronous) completion
+         * of all pending i/o.  then free the request objects
+         * and forget about the endpoints.
+         */
+        usb_ep_disable(link->in_ep);
+        spin_lock(&dev->req_lock);
+        while (!list_empty(&dev->tx_reqs)) {
+                req = container_of(dev->tx_reqs.next,
+                                        struct usb_request, list);
+                list_del(&req->list);
+
+                spin_unlock(&dev->req_lock);
+                usb_ep_free_request(link->in_ep, req);
+                spin_lock(&dev->req_lock);
+        }
+        spin_unlock(&dev->req_lock);
+        link->in_ep->driver_data = NULL;
+        link->in = NULL;
+
+        usb_ep_disable(link->out_ep);
+        spin_lock(&dev->req_lock);
+        while (!list_empty(&dev->rx_reqs)) {
+                req = container_of(dev->rx_reqs.next,
+                                        struct usb_request, list);
+                list_del(&req->list);
+
+                spin_unlock(&dev->req_lock);
+                usb_ep_free_request(link->out_ep, req);
+                spin_lock(&dev->req_lock);
+        }
+        spin_unlock(&dev->req_lock);
+        link->out_ep->driver_data = NULL;
+        link->out = NULL;
+
+        /* finish forgetting about this USB link episode */
+        dev->header_len = 0;
+        dev->unwrap = NULL;
+        dev->wrap = NULL;
+
+        spin_lock(&dev->lock);
+        dev->port_usb = NULL;
+        link->ioport = NULL;
+        spin_unlock(&dev->lock);
+}
diff --git a/drivers/usb/gadget/u_ether.h b/drivers/usb/gadget/u_ether.h
new file mode 100644
index 000000000000..0d1f7ae3b071
--- /dev/null
+++ b/drivers/usb/gadget/u_ether.h
@@ -0,0 +1,127 @@
+/*
+ * u_ether.h -- interface to USB gadget "ethernet link" utilities
+ *
+ * Copyright (C) 2003-2005,2008 David Brownell
+ * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
+ * Copyright (C) 2008 Nokia Corporation
+ *
+ * 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 __U_ETHER_H
+#define __U_ETHER_H
+
+#include <linux/err.h>
+#include <linux/if_ether.h>
+#include <linux/usb/composite.h>
+#include <linux/usb/cdc.h>
+
+#include "gadget_chips.h"
+
+
+/*
+ * This represents the USB side of an "ethernet" link, managed by a USB
+ * function which provides control and (maybe) framing.  Two functions
+ * in different configurations could share the same ethernet link/netdev,
+ * using different host interaction models.
+ *
+ * There is a current limitation that only one instance of this link may
+ * be present in any given configuration.  When that's a problem, network
+ * layer facilities can be used to package multiple logical links on this
+ * single "physical" one.
+ */
+struct gether {
+        struct usb_function             func;
+
+        /* updated by gether_{connect,disconnect} */
+        struct eth_dev                  *ioport;
+
+        /* endpoints handle full and/or high speeds */
+        struct usb_ep                   *in_ep;
+        struct usb_ep                   *out_ep;
+
+        /* descriptors match device speed at gether_connect() time */
+        struct usb_endpoint_descriptor  *in;
+        struct usb_endpoint_descriptor  *out;
+
+        bool                            is_zlp_ok;
+
+        u16                             cdc_filter;
+
+        /* hooks for added framing, as needed for RNDIS and EEM.
+         * we currently don't support multiple frames per SKB.
+         */
+        u32                             header_len;
+        struct sk_buff                  *(*wrap)(struct sk_buff *skb);
+        int                             (*unwrap)(struct sk_buff *skb);
+
+        /* called on network open/close */
+        void                            (*open)(struct gether *);
+        void                            (*close)(struct gether *);
+};
+
+#define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
+                        |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
+                        |USB_CDC_PACKET_TYPE_PROMISCUOUS \
+                        |USB_CDC_PACKET_TYPE_DIRECTED)
+
+
+/* netdev setup/teardown as directed by the gadget driver */
+int gether_setup(struct usb_gadget *g, u8 ethaddr[ETH_ALEN]);
+void gether_cleanup(void);
+
+/* connect/disconnect is handled by individual functions */
+struct net_device *gether_connect(struct gether *);
+void gether_disconnect(struct gether *);
+
+/* Some controllers can't support CDC Ethernet (ECM) ... */
+static inline bool can_support_ecm(struct usb_gadget *gadget)
+{
+        if (!gadget_supports_altsettings(gadget))
+                return false;
+
+        /* SA1100 can do ECM, *without* status endpoint ... but we'll
+         * only use it in non-ECM mode for backwards compatibility
+         * (and since we currently require a status endpoint)
+         */
+        if (gadget_is_sa1100(gadget))
+                return false;
+
+        /* Everything else is *presumably* fine ... but this is a bit
+         * chancy, so be **CERTAIN** there are no hardware issues with
+         * your controller.  Add it above if it can't handle CDC.
+         */
+        return true;
+}
+
+/* each configuration may bind one instance of an ethernet link */
+int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+int ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+
+#ifdef CONFIG_USB_ETH_RNDIS
+
+int rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN]);
+
+#else
+
+static inline int
+rndis_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
+{
+        return 0;
+}
+
+#endif
+
+#endif /* __U_ETHER_H */
diff --git a/drivers/usb/gadget/u_serial.c b/drivers/usb/gadget/u_serial.c
new file mode 100644
index 000000000000..abf9505d3a75
--- /dev/null
+++ b/drivers/usb/gadget/u_serial.c
@@ -0,0 +1,1246 @@
+/*
+ * u_serial.c - utilities for USB gadget "serial port"/TTY support
+ *
+ * Copyright (C) 2003 Al Borchers (alborchers@steinerpoint.com)
+ * Copyright (C) 2008 David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This code also borrows from usbserial.c, which is
+ * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
+ * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * either version 2 of that License or (at your option) any later version.
+ */
+
+/* #define VERBOSE_DEBUG */
+
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/delay.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+
+#include "u_serial.h"
+
+
+/*
+ * This component encapsulates the TTY layer glue needed to provide basic
+ * "serial port" functionality through the USB gadget stack.  Each such
+ * port is exposed through a /dev/ttyGS* node.
+ *
+ * After initialization (gserial_setup), these TTY port devices stay
+ * available until they are removed (gserial_cleanup).  Each one may be
+ * connected to a USB function (gserial_connect), or disconnected (with
+ * gserial_disconnect) when the USB host issues a config change event.
+ * Data can only flow when the port is connected to the host.
+ *
+ * A given TTY port can be made available in multiple configurations.
+ * For example, each one might expose a ttyGS0 node which provides a
+ * login application.  In one case that might use CDC ACM interface 0,
+ * while another configuration might use interface 3 for that.  The
+ * work to handle that (including descriptor management) is not part
+ * of this component.
+ *
+ * Configurations may expose more than one TTY port.  For example, if
+ * ttyGS0 provides login service, then ttyGS1 might provide dialer access
+ * for a telephone or fax link.  And ttyGS2 might be something that just
+ * needs a simple byte stream interface for some messaging protocol that
+ * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
+ */
+
+/*
+ * gserial is the lifecycle interface, used by USB functions
+ * gs_port is the I/O nexus, used by the tty driver
+ * tty_struct links to the tty/filesystem framework
+ *
+ * gserial <---> gs_port ... links will be null when the USB link is
+ * inactive; managed by gserial_{connect,disconnect}().
+ *      gserial->ioport == usb_ep->driver_data ... gs_port
+ *      gs_port->port_usb ... gserial
+ *
+ * gs_port <---> tty_struct ... links will be null when the TTY file
+ * isn't opened; managed by gs_open()/gs_close()
+ *      gserial->port_tty ... tty_struct
+ *      tty_struct->driver_data ... gserial
+ */
+
+/* RX and TX queues can buffer QUEUE_SIZE packets before they hit the
+ * next layer of buffering.  For TX that's a circular buffer; for RX
+ * consider it a NOP.  A third layer is provided by the TTY code.
+ */
+#define QUEUE_SIZE              16
+#define WRITE_BUF_SIZE          8192            /* TX only */
+
+/* circular buffer */
+struct gs_buf {
+        unsigned                buf_size;
+        char                    *buf_buf;
+        char                    *buf_get;
+        char                    *buf_put;
+};
+
+/*
+ * The port structure holds info for each port, one for each minor number
+ * (and thus for each /dev/ node).
+ */
+struct gs_port {
+        spinlock_t              port_lock;      /* guard port_* access */
+
+        struct gserial          *port_usb;
+        struct tty_struct       *port_tty;
+
+        unsigned                open_count;
+        bool                    openclose;      /* open/close in progress */
+        u8                      port_num;
+
+        wait_queue_head_t       close_wait;     /* wait for last close */
+
+        struct list_head        read_pool;
+        struct tasklet_struct   push;
+
+        struct list_head        write_pool;
+        struct gs_buf           port_write_buf;
+        wait_queue_head_t       drain_wait;     /* wait while writes drain */
+
+        /* REVISIT this state ... */
+        struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
+};
+
+/* increase N_PORTS if you need more */
+#define N_PORTS         4
+static struct portmaster {
+        struct mutex    lock;                   /* protect open/close */
+        struct gs_port  *port;
+} ports[N_PORTS];
+static unsigned n_ports;
+
+#define GS_CLOSE_TIMEOUT                15              /* seconds */
+
+
+
+#ifdef VERBOSE_DEBUG
+#define pr_vdebug(fmt, arg...) \
+        pr_debug(fmt, ##arg)
+#else
+#define pr_vdebug(fmt, arg...) \
+        ({ if (0) pr_debug(fmt, ##arg); })
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+/* Circular Buffer */
+
+/*
+ * gs_buf_alloc
+ *
+ * Allocate a circular buffer and all associated memory.
+ */
+static int gs_buf_alloc(struct gs_buf *gb, unsigned size)
+{
+        gb->buf_buf = kmalloc(size, GFP_KERNEL);
+        if (gb->buf_buf == NULL)
+                return -ENOMEM;
+
+        gb->buf_size = size;
+        gb->buf_put = gb->buf_buf;
+        gb->buf_get = gb->buf_buf;
+
+        return 0;
+}
+
+/*
+ * gs_buf_free
+ *
+ * Free the buffer and all associated memory.
+ */
+static void gs_buf_free(struct gs_buf *gb)
+{
+        kfree(gb->buf_buf);
+        gb->buf_buf = NULL;
+}
+
+/*
+ * gs_buf_clear
+ *
+ * Clear out all data in the circular buffer.
+ */
+static void gs_buf_clear(struct gs_buf *gb)
+{
+        gb->buf_get = gb->buf_put;
+        /* equivalent to a get of all data available */
+}
+
+/*
+ * gs_buf_data_avail
+ *
+ * Return the number of bytes of data available in the circular
+ * buffer.
+ */
+static unsigned gs_buf_data_avail(struct gs_buf *gb)
+{
+        return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
+}
+
+/*
+ * gs_buf_space_avail
+ *
+ * Return the number of bytes of space available in the circular
+ * buffer.
+ */
+static unsigned gs_buf_space_avail(struct gs_buf *gb)
+{
+        return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
+}
+
+/*
+ * gs_buf_put
+ *
+ * Copy data data from a user buffer and put it into the circular buffer.
+ * Restrict to the amount of space available.
+ *
+ * Return the number of bytes copied.
+ */
+static unsigned
+gs_buf_put(struct gs_buf *gb, const char *buf, unsigned count)
+{
+        unsigned len;
+
+        len  = gs_buf_space_avail(gb);
+        if (count > len)
+                count = len;
+
+        if (count == 0)
+                return 0;
+
+        len = gb->buf_buf + gb->buf_size - gb->buf_put;
+        if (count > len) {
+                memcpy(gb->buf_put, buf, len);
+                memcpy(gb->buf_buf, buf+len, count - len);
+                gb->buf_put = gb->buf_buf + count - len;
+        } else {
+                memcpy(gb->buf_put, buf, count);
+                if (count < len)
+                        gb->buf_put += count;
+                else /* count == len */
+                        gb->buf_put = gb->buf_buf;
+        }
+
+        return count;
+}
+
+/*
+ * gs_buf_get
+ *
+ * Get data from the circular buffer and copy to the given buffer.
+ * Restrict to the amount of data available.
+ *
+ * Return the number of bytes copied.
+ */
+static unsigned
+gs_buf_get(struct gs_buf *gb, char *buf, unsigned count)
+{
+        unsigned len;
+
+        len = gs_buf_data_avail(gb);
+        if (count > len)
+                count = len;
+
+        if (count == 0)
+                return 0;
+
+        len = gb->buf_buf + gb->buf_size - gb->buf_get;
+        if (count > len) {
+                memcpy(buf, gb->buf_get, len);
+                memcpy(buf+len, gb->buf_buf, count - len);
+                gb->buf_get = gb->buf_buf + count - len;
+        } else {
+                memcpy(buf, gb->buf_get, count);
+                if (count < len)
+                        gb->buf_get += count;
+                else /* count == len */
+                        gb->buf_get = gb->buf_buf;
+        }
+
+        return count;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* I/O glue between TTY (upper) and USB function (lower) driver layers */
+
+/*
+ * gs_alloc_req
+ *
+ * Allocate a usb_request and its buffer.  Returns a pointer to the
+ * usb_request or NULL if there is an error.
+ */
+static struct usb_request *
+gs_alloc_req(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
+{
+        struct usb_request *req;
+
+        req = usb_ep_alloc_request(ep, kmalloc_flags);
+
+        if (req != NULL) {
+                req->length = len;
+                req->buf = kmalloc(len, kmalloc_flags);
+                if (req->buf == NULL) {
+                        usb_ep_free_request(ep, req);
+                        return NULL;
+                }
+        }
+
+        return req;
+}
+
+/*
+ * gs_free_req
+ *
+ * Free a usb_request and its buffer.
+ */
+static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
+{
+        kfree(req->buf);
+        usb_ep_free_request(ep, req);
+}
+
+/*
+ * gs_send_packet
+ *
+ * If there is data to send, a packet is built in the given
+ * buffer and the size is returned.  If there is no data to
+ * send, 0 is returned.
+ *
+ * Called with port_lock held.
+ */
+static unsigned
+gs_send_packet(struct gs_port *port, char *packet, unsigned size)
+{
+        unsigned len;
+
+        len = gs_buf_data_avail(&port->port_write_buf);
+        if (len < size)
+                size = len;
+        if (size != 0)
+                size = gs_buf_get(&port->port_write_buf, packet, size);
+        return size;
+}
+
+/*
+ * gs_start_tx
+ *
+ * This function finds available write requests, calls
+ * gs_send_packet to fill these packets with data, and
+ * continues until either there are no more write requests
+ * available or no more data to send.  This function is
+ * run whenever data arrives or write requests are available.
+ *
+ * Context: caller owns port_lock; port_usb is non-null.
+ */
+static int gs_start_tx(struct gs_port *port)
+/*
+__releases(&port->port_lock)
+__acquires(&port->port_lock)
+*/
+{
+        struct list_head        *pool = &port->write_pool;
+        struct usb_ep           *in = port->port_usb->in;
+        int                     status = 0;
+        bool                    do_tty_wake = false;
+
+        while (!list_empty(pool)) {
+                struct usb_request      *req;
+                int                     len;
+
+                req = list_entry(pool->next, struct usb_request, list);
+                len = gs_send_packet(port, req->buf, in->maxpacket);
+                if (len == 0) {
+                        wake_up_interruptible(&port->drain_wait);
+                        break;
+                }
+                do_tty_wake = true;
+
+                req->length = len;
+                list_del(&req->list);
+
+#ifdef VERBOSE_DEBUG
+                pr_debug("%s: %s, len=%d, 0x%02x 0x%02x 0x%02x ...\n",
+                                __func__, in->name, len, *((u8 *)req->buf),
+                                *((u8 *)req->buf+1), *((u8 *)req->buf+2));
+#endif
+
+                /* Drop lock while we call out of driver; completions
+                 * could be issued while we do so.  Disconnection may
+                 * happen too; maybe immediately before we queue this!
+                 *
+                 * NOTE that we may keep sending data for a while after
+                 * the TTY closed (dev->ioport->port_tty is NULL).
+                 */
+                spin_unlock(&port->port_lock);
+                status = usb_ep_queue(in, req, GFP_ATOMIC);
+                spin_lock(&port->port_lock);
+
+                if (status) {
+                        pr_debug("%s: %s %s err %d\n",
+                                        __func__, "queue", in->name, status);
+                        list_add(&req->list, pool);
+                        break;
+                }
+
+                /* abort immediately after disconnect */
+                if (!port->port_usb)
+                        break;
+        }
+
+        if (do_tty_wake && port->port_tty)
+                tty_wakeup(port->port_tty);
+        return status;
+}
+
+static void gs_rx_push(unsigned long _port)
+{
+        struct gs_port          *port = (void *)_port;
+        struct tty_struct       *tty = port->port_tty;
+
+        /* With low_latency, tty_flip_buffer_push() doesn't put its
+         * real work through a workqueue, so the ldisc has a better
+         * chance to keep up with peak USB data rates.
+         */
+        if (tty) {
+                tty_flip_buffer_push(tty);
+                wake_up_interruptible(&tty->read_wait);
+        }
+}
+
+/*
+ * gs_recv_packet
+ *
+ * Called for each USB packet received.  Reads the packet
+ * header and stuffs the data in the appropriate tty buffer.
+ * Returns 0 if successful, or a negative error number.
+ *
+ * Called during USB completion routine, on interrupt time.
+ * With port_lock.
+ */
+static int gs_recv_packet(struct gs_port *port, char *packet, unsigned size)
+{
+        unsigned                len;
+        struct tty_struct       *tty;
+
+        /* I/O completions can continue for a while after close(), until the
+         * request queue empties.  Just discard any data we receive, until
+         * something reopens this TTY ... as if there were no HW flow control.
+         */
+        tty = port->port_tty;
+        if (tty == NULL) {
+                pr_vdebug("%s: ttyGS%d, after close\n",
+                                __func__, port->port_num);
+                return -EIO;
+        }
+
+        len = tty_insert_flip_string(tty, packet, size);
+        if (len > 0)
+                tasklet_schedule(&port->push);
+        if (len < size)
+                pr_debug("%s: ttyGS%d, drop %d bytes\n",
+                                __func__, port->port_num, size - len);
+        return 0;
+}
+
+/*
+ * Context: caller owns port_lock, and port_usb is set
+ */
+static unsigned gs_start_rx(struct gs_port *port)
+/*
+__releases(&port->port_lock)
+__acquires(&port->port_lock)
+*/
+{
+        struct list_head        *pool = &port->read_pool;
+        struct usb_ep           *out = port->port_usb->out;
+        unsigned                started = 0;
+
+        while (!list_empty(pool)) {
+                struct usb_request      *req;
+                int                     status;
+                struct tty_struct       *tty;
+
+                /* no more rx if closed or throttled */
+                tty = port->port_tty;
+                if (!tty || test_bit(TTY_THROTTLED, &tty->flags))
+                        break;
+
+                req = list_entry(pool->next, struct usb_request, list);
+                list_del(&req->list);
+                req->length = out->maxpacket;
+
+                /* drop lock while we call out; the controller driver
+                 * may need to call us back (e.g. for disconnect)
+                 */
+                spin_unlock(&port->port_lock);
+                status = usb_ep_queue(out, req, GFP_ATOMIC);
+                spin_lock(&port->port_lock);
+
+                if (status) {
+                        pr_debug("%s: %s %s err %d\n",
+                                        __func__, "queue", out->name, status);
+                        list_add(&req->list, pool);
+                        break;
+                }
+                started++;
+
+                /* abort immediately after disconnect */
+                if (!port->port_usb)
+                        break;
+        }
+        return started;
+}
+
+static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        int             status;
+        struct gs_port  *port = ep->driver_data;
+
+        spin_lock(&port->port_lock);
+        list_add(&req->list, &port->read_pool);
+
+        switch (req->status) {
+        case 0:
+                /* normal completion */
+                status = gs_recv_packet(port, req->buf, req->actual);
+                if (status && status != -EIO)
+                        pr_debug("%s: %s %s err %d\n",
+                                __func__, "recv", ep->name, status);
+                gs_start_rx(port);
+                break;
+
+        case -ESHUTDOWN:
+                /* disconnect */
+                pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
+                break;
+
+        default:
+                /* presumably a transient fault */
+                pr_warning("%s: unexpected %s status %d\n",
+                                __func__, ep->name, req->status);
+                gs_start_rx(port);
+                break;
+        }
+        spin_unlock(&port->port_lock);
+}
+
+static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        struct gs_port  *port = ep->driver_data;
+
+        spin_lock(&port->port_lock);
+        list_add(&req->list, &port->write_pool);
+
+        switch (req->status) {
+        default:
+                /* presumably a transient fault */
+                pr_warning("%s: unexpected %s status %d\n",
+                                __func__, ep->name, req->status);
+                /* FALL THROUGH */
+        case 0:
+                /* normal completion */
+                gs_start_tx(port);
+                break;
+
+        case -ESHUTDOWN:
+                /* disconnect */
+                pr_vdebug("%s: %s shutdown\n", __func__, ep->name);
+                break;
+        }
+
+        spin_unlock(&port->port_lock);
+}
+
+static void gs_free_requests(struct usb_ep *ep, struct list_head *head)
+{
+        struct usb_request      *req;
+
+        while (!list_empty(head)) {
+                req = list_entry(head->next, struct usb_request, list);
+                list_del(&req->list);
+                gs_free_req(ep, req);
+        }
+}
+
+static int gs_alloc_requests(struct usb_ep *ep, struct list_head *head,
+                void (*fn)(struct usb_ep *, struct usb_request *))
+{
+        int                     i;
+        struct usb_request      *req;
+
+        /* Pre-allocate up to QUEUE_SIZE transfers, but if we can't
+         * do quite that many this time, don't fail ... we just won't
+         * be as speedy as we might otherwise be.
+         */
+        for (i = 0; i < QUEUE_SIZE; i++) {
+                req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
+                if (!req)
+                        return list_empty(head) ? -ENOMEM : 0;
+                req->complete = fn;
+                list_add_tail(&req->list, head);
+        }
+        return 0;
+}
+
+/**
+ * gs_start_io - start USB I/O streams
+ * @dev: encapsulates endpoints to use
+ * Context: holding port_lock; port_tty and port_usb are non-null
+ *
+ * We only start I/O when something is connected to both sides of
+ * this port.  If nothing is listening on the host side, we may
+ * be pointlessly filling up our TX buffers and FIFO.
+ */
+static int gs_start_io(struct gs_port *port)
+{
+        struct list_head        *head = &port->read_pool;
+        struct usb_ep           *ep = port->port_usb->out;
+        int                     status;
+        unsigned                started;
+
+        /* Allocate RX and TX I/O buffers.  We can't easily do this much
+         * earlier (with GFP_KERNEL) because the requests are coupled to
+         * endpoints, as are the packet sizes we'll be using.  Different
+         * configurations may use different endpoints with a given port;
+         * and high speed vs full speed changes packet sizes too.
+         */
+        status = gs_alloc_requests(ep, head, gs_read_complete);
+        if (status)
+                return status;
+
+        status = gs_alloc_requests(port->port_usb->in, &port->write_pool,
+                        gs_write_complete);
+        if (status) {
+                gs_free_requests(ep, head);
+                return status;
+        }
+
+        /* queue read requests */
+        started = gs_start_rx(port);
+
+        /* unblock any pending writes into our circular buffer */
+        if (started) {
+                tty_wakeup(port->port_tty);
+        } else {
+                gs_free_requests(ep, head);
+                gs_free_requests(port->port_usb->in, &port->write_pool);
+        }
+
+        return started ? 0 : status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* TTY Driver */
+
+/*
+ * gs_open sets up the link between a gs_port and its associated TTY.
+ * That link is broken *only* by TTY close(), and all driver methods
+ * know that.
+ */
+static int gs_open(struct tty_struct *tty, struct file *file)
+{
+        int             port_num = tty->index;
+        struct gs_port  *port;
+        int             status;
+
+        if (port_num < 0 || port_num >= n_ports)
+                return -ENXIO;
+
+        do {
+                mutex_lock(&ports[port_num].lock);
+                port = ports[port_num].port;
+                if (!port)
+                        status = -ENODEV;
+                else {
+                        spin_lock_irq(&port->port_lock);
+
+                        /* already open?  Great. */
+                        if (port->open_count) {
+                                status = 0;
+                                port->open_count++;
+
+                        /* currently opening/closing? wait ... */
+                        } else if (port->openclose) {
+                                status = -EBUSY;
+
+                        /* ... else we do the work */
+                        } else {
+                                status = -EAGAIN;
+                                port->openclose = true;
+                        }
+                        spin_unlock_irq(&port->port_lock);
+                }
+                mutex_unlock(&ports[port_num].lock);
+
+                switch (status) {
+                default:
+                        /* fully handled */
+                        return status;
+                case -EAGAIN:
+                        /* must do the work */
+                        break;
+                case -EBUSY:
+                        /* wait for EAGAIN task to finish */
+                        msleep(1);
+                        /* REVISIT could have a waitchannel here, if
+                         * concurrent open performance is important
+                         */
+                        break;
+                }
+        } while (status != -EAGAIN);
+
+        /* Do the "real open" */
+        spin_lock_irq(&port->port_lock);
+
+        /* allocate circular buffer on first open */
+        if (port->port_write_buf.buf_buf == NULL) {
+
+                spin_unlock_irq(&port->port_lock);
+                status = gs_buf_alloc(&port->port_write_buf, WRITE_BUF_SIZE);
+                spin_lock_irq(&port->port_lock);
+
+                if (status) {
+                        pr_debug("gs_open: ttyGS%d (%p,%p) no buffer\n",
+                                port->port_num, tty, file);
+                        port->openclose = false;
+                        goto exit_unlock_port;
+                }
+        }
+
+        /* REVISIT if REMOVED (ports[].port NULL), abort the open
+         * to let rmmod work faster (but this way isn't wrong).
+         */
+
+        /* REVISIT maybe wait for "carrier detect" */
+
+        tty->driver_data = port;
+        port->port_tty = tty;
+
+        port->open_count = 1;
+        port->openclose = false;
+
+        /* low_latency means ldiscs work in tasklet context, without
+         * needing a workqueue schedule ... easier to keep up.
+         */
+        tty->low_latency = 1;
+
+        /* if connected, start the I/O stream */
+        if (port->port_usb) {
+                pr_debug("gs_open: start ttyGS%d\n", port->port_num);
+                gs_start_io(port);
+
+                /* REVISIT for ACM, issue "network connected" event */
+        }
+
+        pr_debug("gs_open: ttyGS%d (%p,%p)\n", port->port_num, tty, file);
+
+        status = 0;
+
+exit_unlock_port:
+        spin_unlock_irq(&port->port_lock);
+        return status;
+}
+
+static int gs_writes_finished(struct gs_port *p)
+{
+        int cond;
+
+        /* return true on disconnect or empty buffer */
+        spin_lock_irq(&p->port_lock);
+        cond = (p->port_usb == NULL) || !gs_buf_data_avail(&p->port_write_buf);
+        spin_unlock_irq(&p->port_lock);
+
+        return cond;
+}
+
+static void gs_close(struct tty_struct *tty, struct file *file)
+{
+        struct gs_port *port = tty->driver_data;
+
+        spin_lock_irq(&port->port_lock);
+
+        if (port->open_count != 1) {
+                if (port->open_count == 0)
+                        WARN_ON(1);
+                else
+                        --port->open_count;
+                goto exit;
+        }
+
+        pr_debug("gs_close: ttyGS%d (%p,%p) ...\n", port->port_num, tty, file);
+
+        /* mark port as closing but in use; we can drop port lock
+         * and sleep if necessary
+         */
+        port->openclose = true;
+        port->open_count = 0;
+
+        if (port->port_usb)
+                /* REVISIT for ACM, issue "network disconnected" event */;
+
+        /* wait for circular write buffer to drain, disconnect, or at
+         * most GS_CLOSE_TIMEOUT seconds; then discard the rest
+         */
+        if (gs_buf_data_avail(&port->port_write_buf) > 0
+                        && port->port_usb) {
+                spin_unlock_irq(&port->port_lock);
+                wait_event_interruptible_timeout(port->drain_wait,
+                                        gs_writes_finished(port),
+                                        GS_CLOSE_TIMEOUT * HZ);
+                spin_lock_irq(&port->port_lock);
+        }
+
+        /* Iff we're disconnected, there can be no I/O in flight so it's
+         * ok to free the circular buffer; else just scrub it.  And don't
+         * let the push tasklet fire again until we're re-opened.
+         */
+        if (port->port_usb == NULL)
+                gs_buf_free(&port->port_write_buf);
+        else
+                gs_buf_clear(&port->port_write_buf);
+
+        tasklet_kill(&port->push);
+
+        tty->driver_data = NULL;
+        port->port_tty = NULL;
+
+        port->openclose = false;
+
+        pr_debug("gs_close: ttyGS%d (%p,%p) done!\n",
+                        port->port_num, tty, file);
+
+        wake_up_interruptible(&port->close_wait);
+exit:
+        spin_unlock_irq(&port->port_lock);
+}
+
+static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
+{
+        struct gs_port  *port = tty->driver_data;
+        unsigned long   flags;
+        int             status;
+
+        pr_vdebug("gs_write: ttyGS%d (%p) writing %d bytes\n",
+                        port->port_num, tty, count);
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        if (count)
+                count = gs_buf_put(&port->port_write_buf, buf, count);
+        /* treat count == 0 as flush_chars() */
+        if (port->port_usb)
+                status = gs_start_tx(port);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        return count;
+}
+
+static int gs_put_char(struct tty_struct *tty, unsigned char ch)
+{
+        struct gs_port  *port = tty->driver_data;
+        unsigned long   flags;
+        int             status;
+
+        pr_vdebug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
+                port->port_num, tty, ch, __builtin_return_address(0));
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        status = gs_buf_put(&port->port_write_buf, &ch, 1);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        return status;
+}
+
+static void gs_flush_chars(struct tty_struct *tty)
+{
+        struct gs_port  *port = tty->driver_data;
+        unsigned long   flags;
+
+        pr_vdebug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        if (port->port_usb)
+                gs_start_tx(port);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+}
+
+static int gs_write_room(struct tty_struct *tty)
+{
+        struct gs_port  *port = tty->driver_data;
+        unsigned long   flags;
+        int             room = 0;
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        if (port->port_usb)
+                room = gs_buf_space_avail(&port->port_write_buf);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        pr_vdebug("gs_write_room: (%d,%p) room=%d\n",
+                port->port_num, tty, room);
+
+        return room;
+}
+
+static int gs_chars_in_buffer(struct tty_struct *tty)
+{
+        struct gs_port  *port = tty->driver_data;
+        unsigned long   flags;
+        int             chars = 0;
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        chars = gs_buf_data_avail(&port->port_write_buf);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        pr_vdebug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
+                port->port_num, tty, chars);
+
+        return chars;
+}
+
+/* undo side effects of setting TTY_THROTTLED */
+static void gs_unthrottle(struct tty_struct *tty)
+{
+        struct gs_port          *port = tty->driver_data;
+        unsigned long           flags;
+        unsigned                started = 0;
+
+        spin_lock_irqsave(&port->port_lock, flags);
+        if (port->port_usb)
+                started = gs_start_rx(port);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        pr_vdebug("gs_unthrottle: ttyGS%d, %d packets\n",
+                        port->port_num, started);
+}
+
+static const struct tty_operations gs_tty_ops = {
+        .open =                 gs_open,
+        .close =                gs_close,
+        .write =                gs_write,
+        .put_char =             gs_put_char,
+        .flush_chars =          gs_flush_chars,
+        .write_room =           gs_write_room,
+        .chars_in_buffer =      gs_chars_in_buffer,
+        .unthrottle =           gs_unthrottle,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static struct tty_driver *gs_tty_driver;
+
+static int __init
+gs_port_alloc(unsigned port_num, struct usb_cdc_line_coding *coding)
+{
+        struct gs_port  *port;
+
+        port = kzalloc(sizeof(struct gs_port), GFP_KERNEL);
+        if (port == NULL)
+                return -ENOMEM;
+
+        spin_lock_init(&port->port_lock);
+        init_waitqueue_head(&port->close_wait);
+        init_waitqueue_head(&port->drain_wait);
+
+        tasklet_init(&port->push, gs_rx_push, (unsigned long) port);
+
+        INIT_LIST_HEAD(&port->read_pool);
+        INIT_LIST_HEAD(&port->write_pool);
+
+        port->port_num = port_num;
+        port->port_line_coding = *coding;
+
+        ports[port_num].port = port;
+
+        return 0;
+}
+
+/**
+ * gserial_setup - initialize TTY driver for one or more ports
+ * @g: gadget to associate with these ports
+ * @count: how many ports to support
+ * Context: may sleep
+ *
+ * The TTY stack needs to know in advance how many devices it should
+ * plan to manage.  Use this call to set up the ports you will be
+ * exporting through USB.  Later, connect them to functions based
+ * on what configuration is activated by the USB host; and disconnect
+ * them as appropriate.
+ *
+ * An example would be a two-configuration device in which both
+ * configurations expose port 0, but through different functions.
+ * One configuration could even expose port 1 while the other
+ * one doesn't.
+ *
+ * Returns negative errno or zero.
+ */
+int __init gserial_setup(struct usb_gadget *g, unsigned count)
+{
+        unsigned                        i;
+        struct usb_cdc_line_coding      coding;
+        int                             status;
+
+        if (count == 0 || count > N_PORTS)
+                return -EINVAL;
+
+        gs_tty_driver = alloc_tty_driver(count);
+        if (!gs_tty_driver)
+                return -ENOMEM;
+
+        gs_tty_driver->owner = THIS_MODULE;
+        gs_tty_driver->driver_name = "g_serial";
+        gs_tty_driver->name = "ttyGS";
+        /* uses dynamically assigned dev_t values */
+
+        gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
+        gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
+        gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
+        gs_tty_driver->init_termios = tty_std_termios;
+
+        /* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
+         * MS-Windows.  Otherwise, most of these flags shouldn't affect
+         * anything unless we were to actually hook up to a serial line.
+         */
+        gs_tty_driver->init_termios.c_cflag =
+                        B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        gs_tty_driver->init_termios.c_ispeed = 9600;
+        gs_tty_driver->init_termios.c_ospeed = 9600;
+
+        coding.dwDTERate = __constant_cpu_to_le32(9600);
+        coding.bCharFormat = 8;
+        coding.bParityType = USB_CDC_NO_PARITY;
+        coding.bDataBits = USB_CDC_1_STOP_BITS;
+
+        tty_set_operations(gs_tty_driver, &gs_tty_ops);
+
+        /* make devices be openable */
+        for (i = 0; i < count; i++) {
+                mutex_init(&ports[i].lock);
+                status = gs_port_alloc(i, &coding);
+                if (status) {
+                        count = i;
+                        goto fail;
+                }
+        }
+        n_ports = count;
+
+        /* export the driver ... */
+        status = tty_register_driver(gs_tty_driver);
+        if (status) {
+                put_tty_driver(gs_tty_driver);
+                pr_err("%s: cannot register, err %d\n",
+                                __func__, status);
+                goto fail;
+        }
+
+        /* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
+        for (i = 0; i < count; i++) {
+                struct device   *tty_dev;
+
+                tty_dev = tty_register_device(gs_tty_driver, i, &g->dev);
+                if (IS_ERR(tty_dev))
+                        pr_warning("%s: no classdev for port %d, err %ld\n",
+                                __func__, i, PTR_ERR(tty_dev));
+        }
+
+        pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
+                        count, (count == 1) ? "" : "s");
+
+        return status;
+fail:
+        while (count--)
+                kfree(ports[count].port);
+        put_tty_driver(gs_tty_driver);
+        gs_tty_driver = NULL;
+        return status;
+}
+
+static int gs_closed(struct gs_port *port)
+{
+        int cond;
+
+        spin_lock_irq(&port->port_lock);
+        cond = (port->open_count == 0) && !port->openclose;
+        spin_unlock_irq(&port->port_lock);
+        return cond;
+}
+
+/**
+ * gserial_cleanup - remove TTY-over-USB driver and devices
+ * Context: may sleep
+ *
+ * This is called to free all resources allocated by @gserial_setup().
+ * Accordingly, it may need to wait until some open /dev/ files have
+ * closed.
+ *
+ * The caller must have issued @gserial_disconnect() for any ports
+ * that had previously been connected, so that there is never any
+ * I/O pending when it's called.
+ */
+void gserial_cleanup(void)
+{
+        unsigned        i;
+        struct gs_port  *port;
+
+        if (!gs_tty_driver)
+                return;
+
+        /* start sysfs and /dev/ttyGS* node removal */
+        for (i = 0; i < n_ports; i++)
+                tty_unregister_device(gs_tty_driver, i);
+
+        for (i = 0; i < n_ports; i++) {
+                /* prevent new opens */
+                mutex_lock(&ports[i].lock);
+                port = ports[i].port;
+                ports[i].port = NULL;
+                mutex_unlock(&ports[i].lock);
+
+                /* wait for old opens to finish */
+                wait_event(port->close_wait, gs_closed(port));
+
+                WARN_ON(port->port_usb != NULL);
+
+                kfree(port);
+        }
+        n_ports = 0;
+
+        tty_unregister_driver(gs_tty_driver);
+        gs_tty_driver = NULL;
+
+        pr_debug("%s: cleaned up ttyGS* support\n", __func__);
+}
+
+/**
+ * gserial_connect - notify TTY I/O glue that USB link is active
+ * @gser: the function, set up with endpoints and descriptors
+ * @port_num: which port is active
+ * Context: any (usually from irq)
+ *
+ * This is called activate endpoints and let the TTY layer know that
+ * the connection is active ... not unlike "carrier detect".  It won't
+ * necessarily start I/O queues; unless the TTY is held open by any
+ * task, there would be no point.  However, the endpoints will be
+ * activated so the USB host can perform I/O, subject to basic USB
+ * hardware flow control.
+ *
+ * Caller needs to have set up the endpoints and USB function in @dev
+ * before calling this, as well as the appropriate (speed-specific)
+ * endpoint descriptors, and also have set up the TTY driver by calling
+ * @gserial_setup().
+ *
+ * Returns negative errno or zero.
+ * On success, ep->driver_data will be overwritten.
+ */
+int gserial_connect(struct gserial *gser, u8 port_num)
+{
+        struct gs_port  *port;
+        unsigned long   flags;
+        int             status;
+
+        if (!gs_tty_driver || port_num >= n_ports)
+                return -ENXIO;
+
+        /* we "know" gserial_cleanup() hasn't been called */
+        port = ports[port_num].port;
+
+        /* activate the endpoints */
+        status = usb_ep_enable(gser->in, gser->in_desc);
+        if (status < 0)
+                return status;
+        gser->in->driver_data = port;
+
+        status = usb_ep_enable(gser->out, gser->out_desc);
+        if (status < 0)
+                goto fail_out;
+        gser->out->driver_data = port;
+
+        /* then tell the tty glue that I/O can work */
+        spin_lock_irqsave(&port->port_lock, flags);
+        gser->ioport = port;
+        port->port_usb = gser;
+
+        /* REVISIT unclear how best to handle this state...
+         * we don't really couple it with the Linux TTY.
+         */
+        gser->port_line_coding = port->port_line_coding;
+
+        /* REVISIT if waiting on "carrier detect", signal. */
+
+        /* REVISIT for ACM, issue "network connection" status notification:
+         * connected if open_count, else disconnected.
+         */
+
+        /* if it's already open, start I/O */
+        if (port->open_count) {
+                pr_debug("gserial_connect: start ttyGS%d\n", port->port_num);
+                gs_start_io(port);
+        }
+
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        return status;
+
+fail_out:
+        usb_ep_disable(gser->in);
+        gser->in->driver_data = NULL;
+        return status;
+}
+
+/**
+ * gserial_disconnect - notify TTY I/O glue that USB link is inactive
+ * @gser: the function, on which gserial_connect() was called
+ * Context: any (usually from irq)
+ *
+ * This is called to deactivate endpoints and let the TTY layer know
+ * that the connection went inactive ... not unlike "hangup".
+ *
+ * On return, the state is as if gserial_connect() had never been called;
+ * there is no active USB I/O on these endpoints.
+ */
+void gserial_disconnect(struct gserial *gser)
+{
+        struct gs_port  *port = gser->ioport;
+        unsigned long   flags;
+
+        if (!port)
+                return;
+
+        /* tell the TTY glue not to do I/O here any more */
+        spin_lock_irqsave(&port->port_lock, flags);
+
+        /* REVISIT as above: how best to track this? */
+        port->port_line_coding = gser->port_line_coding;
+
+        port->port_usb = NULL;
+        gser->ioport = NULL;
+        if (port->open_count > 0 || port->openclose) {
+                wake_up_interruptible(&port->drain_wait);
+                if (port->port_tty)
+                        tty_hangup(port->port_tty);
+        }
+        spin_unlock_irqrestore(&port->port_lock, flags);
+
+        /* disable endpoints, aborting down any active I/O */
+        usb_ep_disable(gser->out);
+        gser->out->driver_data = NULL;
+
+        usb_ep_disable(gser->in);
+        gser->in->driver_data = NULL;
+
+        /* finally, free any unused/unusable I/O buffers */
+        spin_lock_irqsave(&port->port_lock, flags);
+        if (port->open_count == 0 && !port->openclose)
+                gs_buf_free(&port->port_write_buf);
+        gs_free_requests(gser->out, &port->read_pool);
+        gs_free_requests(gser->in, &port->write_pool);
+        spin_unlock_irqrestore(&port->port_lock, flags);
+}
diff --git a/drivers/usb/gadget/u_serial.h b/drivers/usb/gadget/u_serial.h
new file mode 100644
index 000000000000..7b561138f90e
--- /dev/null
+++ b/drivers/usb/gadget/u_serial.h
@@ -0,0 +1,58 @@
+/*
+ * u_serial.h - interface to USB gadget "serial port"/TTY utilities
+ *
+ * Copyright (C) 2008 David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
+ *
+ * This software is distributed under the terms of the GNU General
+ * Public License ("GPL") as published by the Free Software Foundation,
+ * either version 2 of that License or (at your option) any later version.
+ */
+
+#ifndef __U_SERIAL_H
+#define __U_SERIAL_H
+
+#include <linux/usb/composite.h>
+#include <linux/usb/cdc.h>
+
+/*
+ * One non-multiplexed "serial" I/O port ... there can be several of these
+ * on any given USB peripheral device, if it provides enough endpoints.
+ *
+ * The "u_serial" utility component exists to do one thing:  manage TTY
+ * style I/O using the USB peripheral endpoints listed here, including
+ * hookups to sysfs and /dev for each logical "tty" device.
+ *
+ * REVISIT need TTY --> USB event flow too, so ACM can report open/close
+ * as carrier detect events.  Model after ECM.  There's more ACM state too.
+ *
+ * REVISIT someday, allow multiplexing several TTYs over these endpoints.
+ */
+struct gserial {
+        struct usb_function             func;
+
+        /* port is managed by gserial_{connect,disconnect} */
+        struct gs_port                  *ioport;
+
+        struct usb_ep                   *in;
+        struct usb_ep                   *out;
+        struct usb_endpoint_descriptor  *in_desc;
+        struct usb_endpoint_descriptor  *out_desc;
+
+        /* REVISIT avoid this CDC-ACM support harder ... */
+        struct usb_cdc_line_coding port_line_coding;    /* 9600-8-N-1 etc */
+};
+
+/* port setup/teardown is handled by gadget driver */
+int gserial_setup(struct usb_gadget *g, unsigned n_ports);
+void gserial_cleanup(void);
+
+/* connect/disconnect is handled by individual functions */
+int gserial_connect(struct gserial *, u8 port_num);
+void gserial_disconnect(struct gserial *);
+
+/* functions are bound to configurations by a config or gadget driver */
+int acm_bind_config(struct usb_configuration *c, u8 port_num);
+int gser_bind_config(struct usb_configuration *c, u8 port_num);
+
+#endif /* __U_SERIAL_H */
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index fce4924dbbe8..aa0bd4f126a1 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -1,8 +1,8 @@
 /*
  * zero.c -- Gadget Zero, for USB development
  *
- * Copyright (C) 2003-2007 David Brownell
- * All rights reserved.
+ * Copyright (C) 2003-2008 David Brownell
+ * Copyright (C) 2008 by Nokia Corporation
  *
  * 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
@@ -30,12 +30,7 @@
  *
  * It supports two similar configurations.  One sinks whatever the usb host
  * writes, and in return sources zeroes.  The other loops whatever the host
- * writes back, so the host can read it.  Module options include:
- *
- *   buflen=N           default N=4096, buffer size used
- *   qlen=N             default N=32, how many buffers in the loopback queue
- *   loopdefault        default false, list loopback config first
- *   autoresume=N       default N=0, seconds before triggering remote wakeup
+ * writes back, so the host can read it.
  *
  * Many drivers will only have one configuration, letting them be much
  * simpler if they also don't support high speed operation (like this
@@ -47,94 +42,35 @@
  * work with low capability USB controllers without four bulk endpoints.
  */
 
+/*
+ * driver assumes self-powered hardware, and
+ * has no way for users to trigger remote wakeup.
+ */
+
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
 #include <linux/utsname.h>
 #include <linux/device.h>
 
-#include <linux/usb/ch9.h>
-#include <linux/usb/gadget.h>
-
+#include "g_zero.h"
 #include "gadget_chips.h"
 
 
 /*-------------------------------------------------------------------------*/
 
-#define DRIVER_VERSION          "Earth Day 2008"
+#define DRIVER_VERSION          "Cinco de Mayo 2008"
 
-static const char shortname[] = "zero";
 static const char longname[] = "Gadget Zero";
 
-static const char source_sink[] = "source and sink data";
-static const char loopback[] = "loop input to output";
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * driver assumes self-powered hardware, and
- * has no way for users to trigger remote wakeup.
- *
- * this version autoconfigures as much as possible,
- * which is reasonable for most "bulk-only" drivers.
- */
-static const char *EP_IN_NAME;          /* source */
-static const char *EP_OUT_NAME;         /* sink */
-
-/*-------------------------------------------------------------------------*/
-
-/* big enough to hold our biggest descriptor */
-#define USB_BUFSIZ      256
-
-struct zero_dev {
-        spinlock_t              lock;
-        struct usb_gadget       *gadget;
-        struct usb_request      *req;           /* for control responses */
-
-        /* when configured, we have one of two configs:
-         * - source data (in to host) and sink it (out from host)
-         * - or loop it back (out from host back in to host)
-         */
-        u8                      config;
-        struct usb_ep           *in_ep, *out_ep;
-
-        /* autoresume timer */
-        struct timer_list       resume;
-};
-
-#define DBG(d, fmt, args...) \
-        dev_dbg(&(d)->gadget->dev , fmt , ## args)
-#define VDBG(d, fmt, args...) \
-        dev_vdbg(&(d)->gadget->dev , fmt , ## args)
-#define ERROR(d, fmt, args...) \
-        dev_err(&(d)->gadget->dev , fmt , ## args)
-#define WARN(d, fmt, args...) \
-        dev_warn(&(d)->gadget->dev , fmt , ## args)
-#define INFO(d, fmt, args...) \
-        dev_info(&(d)->gadget->dev , fmt , ## args)
-
-/*-------------------------------------------------------------------------*/
-
-static unsigned buflen = 4096;
-static unsigned qlen = 32;
-static unsigned pattern = 0;
-
-module_param(buflen, uint, S_IRUGO);
-module_param(qlen, uint, S_IRUGO);
-module_param(pattern, uint, S_IRUGO|S_IWUSR);
-
-/*
- * if it's nonzero, autoresume says how many seconds to wait
- * before trying to wake up the host after suspend.
- */
-static unsigned autoresume = 0;
-module_param(autoresume, uint, 0);
+unsigned buflen = 4096;
+module_param(buflen, uint, 0);
 
 /*
  * Normally the "loopback" configuration is second (index 1) so
  * it's not the default.  Here's where to change that order, to
- * work better with hosts where config changes are problematic.
- * Or controllers (like superh) that only support one config.
+ * work better with hosts where config changes are problematic or
+ * controllers (like original superh) that only support one config.
  */
 static int loopdefault = 0;
 module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
@@ -156,24 +92,6 @@ module_param(loopdefault, bool, S_IRUGO|S_IWUSR);
 
 /*-------------------------------------------------------------------------*/
 
-/*
- * DESCRIPTORS ... most are static, but strings and (full)
- * configuration descriptors are built on demand.
- */
-
-#define STRING_MANUFACTURER             25
-#define STRING_PRODUCT                  42
-#define STRING_SERIAL                   101
-#define STRING_SOURCE_SINK              250
-#define STRING_LOOPBACK                 251
-
-/*
- * This device advertises two configurations; these numbers work
- * on a pxa250 as well as more flexible hardware.
- */
-#define CONFIG_SOURCE_SINK      3
-#define CONFIG_LOOPBACK         2
-
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
         .bDescriptorType =      USB_DT_DEVICE,
@@ -183,248 +101,64 @@ static struct usb_device_descriptor device_desc = {
 
         .idVendor =             __constant_cpu_to_le16(DRIVER_VENDOR_NUM),
         .idProduct =            __constant_cpu_to_le16(DRIVER_PRODUCT_NUM),
-        .iManufacturer =        STRING_MANUFACTURER,
-        .iProduct =             STRING_PRODUCT,
-        .iSerialNumber =        STRING_SERIAL,
         .bNumConfigurations =   2,
 };
 
-static struct usb_config_descriptor source_sink_config = {
-        .bLength =              sizeof source_sink_config,
-        .bDescriptorType =      USB_DT_CONFIG,
-
-        /* compute wTotalLength on the fly */
-        .bNumInterfaces =       1,
-        .bConfigurationValue =  CONFIG_SOURCE_SINK,
-        .iConfiguration =       STRING_SOURCE_SINK,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            1,      /* self-powered */
-};
-
-static struct usb_config_descriptor loopback_config = {
-        .bLength =              sizeof loopback_config,
-        .bDescriptorType =      USB_DT_CONFIG,
-
-        /* compute wTotalLength on the fly */
-        .bNumInterfaces =       1,
-        .bConfigurationValue =  CONFIG_LOOPBACK,
-        .iConfiguration =       STRING_LOOPBACK,
-        .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
-        .bMaxPower =            1,      /* self-powered */
-};
-
+#ifdef CONFIG_USB_OTG
 static struct usb_otg_descriptor otg_descriptor = {
         .bLength =              sizeof otg_descriptor,
         .bDescriptorType =      USB_DT_OTG,
 
-        .bmAttributes =         USB_OTG_SRP,
-};
-
-/* one interface in each configuration */
-
-static const struct usb_interface_descriptor source_sink_intf = {
-        .bLength =              sizeof source_sink_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
-        .iInterface =           STRING_SOURCE_SINK,
-};
-
-static const struct usb_interface_descriptor loopback_intf = {
-        .bLength =              sizeof loopback_intf,
-        .bDescriptorType =      USB_DT_INTERFACE,
-
-        .bNumEndpoints =        2,
-        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
-        .iInterface =           STRING_LOOPBACK,
-};
-
-/* two full speed bulk endpoints; their use is config-dependent */
-
-static struct usb_endpoint_descriptor fs_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_IN,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-};
-
-static struct usb_endpoint_descriptor fs_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bEndpointAddress =     USB_DIR_OUT,
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-};
-
-static const struct usb_descriptor_header *fs_source_sink_function[] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-        (struct usb_descriptor_header *) &source_sink_intf,
-        (struct usb_descriptor_header *) &fs_sink_desc,
-        (struct usb_descriptor_header *) &fs_source_desc,
-        NULL,
-};
-
-static const struct usb_descriptor_header *fs_loopback_function[] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-        (struct usb_descriptor_header *) &loopback_intf,
-        (struct usb_descriptor_header *) &fs_sink_desc,
-        (struct usb_descriptor_header *) &fs_source_desc,
-        NULL,
-};
-
-/*
- * usb 2.0 devices need to expose both high speed and full speed
- * descriptors, unless they only run at full speed.
- *
- * that means alternate endpoint descriptors (bigger packets)
- * and a "device qualifier" ... plus more construction options
- * for the config descriptor.
- */
-
-static struct usb_endpoint_descriptor hs_source_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
-};
-
-static struct usb_endpoint_descriptor hs_sink_desc = {
-        .bLength =              USB_DT_ENDPOINT_SIZE,
-        .bDescriptorType =      USB_DT_ENDPOINT,
-
-        .bmAttributes =         USB_ENDPOINT_XFER_BULK,
-        .wMaxPacketSize =       __constant_cpu_to_le16(512),
-};
-
-static struct usb_qualifier_descriptor dev_qualifier = {
-        .bLength =              sizeof dev_qualifier,
-        .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
-
-        .bcdUSB =               __constant_cpu_to_le16(0x0200),
-        .bDeviceClass =         USB_CLASS_VENDOR_SPEC,
-
-        .bNumConfigurations =   2,
+        /* REVISIT SRP-only hardware is possible, although
+         * it would not be called "OTG" ...
+         */
+        .bmAttributes =         USB_OTG_SRP | USB_OTG_HNP,
 };
 
-static const struct usb_descriptor_header *hs_source_sink_function[] = {
+const struct usb_descriptor_header *otg_desc[] = {
         (struct usb_descriptor_header *) &otg_descriptor,
-        (struct usb_descriptor_header *) &source_sink_intf,
-        (struct usb_descriptor_header *) &hs_source_desc,
-        (struct usb_descriptor_header *) &hs_sink_desc,
         NULL,
 };
+#endif
 
-static const struct usb_descriptor_header *hs_loopback_function[] = {
-        (struct usb_descriptor_header *) &otg_descriptor,
-        (struct usb_descriptor_header *) &loopback_intf,
-        (struct usb_descriptor_header *) &hs_source_desc,
-        (struct usb_descriptor_header *) &hs_sink_desc,
-        NULL,
-};
+/* string IDs are assigned dynamically */
 
-/* maxpacket and other transfer characteristics vary by speed. */
-static inline struct usb_endpoint_descriptor *
-ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
-                struct usb_endpoint_descriptor *fs)
-{
-        if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
-                return hs;
-        return fs;
-}
+#define STRING_MANUFACTURER_IDX         0
+#define STRING_PRODUCT_IDX              1
+#define STRING_SERIAL_IDX               2
 
 static char manufacturer[50];
 
 /* default serial number takes at least two packets */
 static char serial[] = "0123456789.0123456789.0123456789";
 
-
-/* static strings, in UTF-8 */
-static struct usb_string strings[] = {
-        { STRING_MANUFACTURER, manufacturer, },
-        { STRING_PRODUCT, longname, },
-        { STRING_SERIAL, serial, },
-        { STRING_LOOPBACK, loopback, },
-        { STRING_SOURCE_SINK, source_sink, },
+static struct usb_string strings_dev[] = {
+        [STRING_MANUFACTURER_IDX].s = manufacturer,
+        [STRING_PRODUCT_IDX].s = longname,
+        [STRING_SERIAL_IDX].s = serial,
         {  }                    /* end of list */
 };
 
-static struct usb_gadget_strings stringtab = {
+static struct usb_gadget_strings stringtab_dev = {
         .language       = 0x0409,       /* en-us */
-        .strings        = strings,
+        .strings        = strings_dev,
 };
 
-/*
- * config descriptors are also handcrafted.  these must agree with code
- * that sets configurations, and with code managing interfaces and their
- * altsettings.  other complexity may come from:
- *
- *  - high speed support, including "other speed config" rules
- *  - multiple configurations
- *  - interfaces with alternate settings
- *  - embedded class or vendor-specific descriptors
- *
- * this handles high speed, and has a second config that could as easily
- * have been an alternate interface setting (on most hardware).
- *
- * NOTE:  to demonstrate (and test) more USB capabilities, this driver
- * should include an altsetting to test interrupt transfers, including
- * high bandwidth modes at high speed.  (Maybe work like Intel's test
- * device?)
- */
-static int config_buf(struct usb_gadget *gadget,
-                u8 *buf, u8 type, unsigned index)
-{
-        int                             is_source_sink;
-        int                             len;
-        const struct usb_descriptor_header **function;
-        int                             hs = 0;
-
-        /* two configurations will always be index 0 and index 1 */
-        if (index > 1)
-                return -EINVAL;
-        is_source_sink = loopdefault ? (index == 1) : (index == 0);
-
-        if (gadget_is_dualspeed(gadget)) {
-                hs = (gadget->speed == USB_SPEED_HIGH);
-                if (type == USB_DT_OTHER_SPEED_CONFIG)
-                        hs = !hs;
-        }
-        if (hs)
-                function = is_source_sink
-                        ? hs_source_sink_function
-                        : hs_loopback_function;
-        else
-                function = is_source_sink
-                        ? fs_source_sink_function
-                        : fs_loopback_function;
-
-        /* for now, don't advertise srp-only devices */
-        if (!gadget_is_otg(gadget))
-                function++;
-
-        len = usb_gadget_config_buf(is_source_sink
-                                        ? &source_sink_config
-                                        : &loopback_config,
-                        buf, USB_BUFSIZ, function);
-        if (len < 0)
-                return len;
-        ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
-        return len;
-}
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
 
 /*-------------------------------------------------------------------------*/
 
-static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
+struct usb_request *alloc_ep_req(struct usb_ep *ep)
 {
         struct usb_request      *req;
 
         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
         if (req) {
-                req->length = length;
-                req->buf = kmalloc(length, GFP_ATOMIC);
+                req->length = buflen;
+                req->buf = kmalloc(buflen, GFP_ATOMIC);
                 if (!req->buf) {
                         usb_ep_free_request(ep, req);
                         req = NULL;
@@ -433,681 +167,73 @@ static struct usb_request *alloc_ep_req(struct usb_ep *ep, unsigned length)
         return req;
 }
 
-static void free_ep_req(struct usb_ep *ep, struct usb_request *req)
+void free_ep_req(struct usb_ep *ep, struct usb_request *req)
 {
         kfree(req->buf);
         usb_ep_free_request(ep, req);
 }
 
-/*-------------------------------------------------------------------------*/
-
-/*
- * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripherals,
- * this just sinks bulk packets OUT to the peripheral and sources them IN
- * to the host, optionally with specific data patterns.
- *
- * In terms of control messaging, this supports all the standard requests
- * plus two that support control-OUT tests.
- *
- * Note that because this doesn't queue more than one request at a time,
- * some other function must be used to test queueing logic.  The network
- * link (g_ether) is probably the best option for that.
- */
-
-/* optionally require specific source/sink data patterns  */
-
-static int
-check_read_data(
-        struct zero_dev         *dev,
-        struct usb_ep           *ep,
-        struct usb_request      *req
-)
+static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
 {
-        unsigned        i;
-        u8              *buf = req->buf;
-
-        for (i = 0; i < req->actual; i++, buf++) {
-                switch (pattern) {
-                /* all-zeroes has no synchronization issues */
-                case 0:
-                        if (*buf == 0)
-                                continue;
-                        break;
-                /* mod63 stays in sync with short-terminated transfers,
-                 * or otherwise when host and gadget agree on how large
-                 * each usb transfer request should be.  resync is done
-                 * with set_interface or set_config.
-                 */
-                case 1:
-                        if (*buf == (u8)(i % 63))
-                                continue;
-                        break;
-                }
-                ERROR(dev, "bad OUT byte, buf[%d] = %d\n", i, *buf);
-                usb_ep_set_halt(ep);
-                return -EINVAL;
+        int                     value;
+
+        if (ep->driver_data) {
+                value = usb_ep_disable(ep);
+                if (value < 0)
+                        DBG(cdev, "disable %s --> %d\n",
+                                        ep->name, value);
+                ep->driver_data = NULL;
         }
-        return 0;
 }
 
-static void reinit_write_data(struct usb_ep *ep, struct usb_request *req)
+void disable_endpoints(struct usb_composite_dev *cdev,
+                struct usb_ep *in, struct usb_ep *out)
 {
-        unsigned        i;
-        u8              *buf = req->buf;
-
-        switch (pattern) {
-        case 0:
-                memset(req->buf, 0, req->length);
-                break;
-        case 1:
-                for  (i = 0; i < req->length; i++)
-                        *buf++ = (u8) (i % 63);
-                break;
-        }
-}
-
-/* if there is only one request in the queue, there'll always be an
- * irq delay between end of one request and start of the next.
- * that prevents using hardware dma queues.
- */
-static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        struct zero_dev *dev = ep->driver_data;
-        int             status = req->status;
-
-        switch (status) {
-
-        case 0:                         /* normal completion? */
-                if (ep == dev->out_ep) {
-                        check_read_data(dev, ep, req);
-                        memset(req->buf, 0x55, req->length);
-                } else
-                        reinit_write_data(ep, req);
-                break;
-
-        /* this endpoint is normally active while we're configured */
-        case -ECONNABORTED:             /* hardware forced ep reset */
-        case -ECONNRESET:               /* request dequeued */
-        case -ESHUTDOWN:                /* disconnect from host */
-                VDBG(dev, "%s gone (%d), %d/%d\n", ep->name, status,
-                                req->actual, req->length);
-                if (ep == dev->out_ep)
-                        check_read_data(dev, ep, req);
-                free_ep_req(ep, req);
-                return;
-
-        case -EOVERFLOW:                /* buffer overrun on read means that
-                                         * we didn't provide a big enough
-                                         * buffer.
-                                         */
-        default:
-#if 1
-                DBG(dev, "%s complete --> %d, %d/%d\n", ep->name,
-                                status, req->actual, req->length);
-#endif
-        case -EREMOTEIO:                /* short read */
-                break;
-        }
-
-        status = usb_ep_queue(ep, req, GFP_ATOMIC);
-        if (status) {
-                ERROR(dev, "kill %s:  resubmit %d bytes --> %d\n",
-                                ep->name, req->length, status);
-                usb_ep_set_halt(ep);
-                /* FIXME recover later ... somehow */
-        }
-}
-
-static struct usb_request *source_sink_start_ep(struct usb_ep *ep)
-{
-        struct usb_request      *req;
-        int                     status;
-
-        req = alloc_ep_req(ep, buflen);
-        if (!req)
-                return NULL;
-
-        memset(req->buf, 0, req->length);
-        req->complete = source_sink_complete;
-
-        if (strcmp(ep->name, EP_IN_NAME) == 0)
-                reinit_write_data(ep, req);
-        else
-                memset(req->buf, 0x55, req->length);
-
-        status = usb_ep_queue(ep, req, GFP_ATOMIC);
-        if (status) {
-                struct zero_dev *dev = ep->driver_data;
-
-                ERROR(dev, "start %s --> %d\n", ep->name, status);
-                free_ep_req(ep, req);
-                req = NULL;
-        }
-
-        return req;
-}
-
-static int set_source_sink_config(struct zero_dev *dev)
-{
-        int                     result = 0;
-        struct usb_ep           *ep;
-        struct usb_gadget       *gadget = dev->gadget;
-
-        gadget_for_each_ep(ep, gadget) {
-                const struct usb_endpoint_descriptor    *d;
-
-                /* one endpoint writes (sources) zeroes in (to the host) */
-                if (strcmp(ep->name, EP_IN_NAME) == 0) {
-                        d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
-                        result = usb_ep_enable(ep, d);
-                        if (result == 0) {
-                                ep->driver_data = dev;
-                                if (source_sink_start_ep(ep) != NULL) {
-                                        dev->in_ep = ep;
-                                        continue;
-                                }
-                                usb_ep_disable(ep);
-                                result = -EIO;
-                        }
-
-                /* one endpoint reads (sinks) anything out (from the host) */
-                } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
-                        d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
-                        result = usb_ep_enable(ep, d);
-                        if (result == 0) {
-                                ep->driver_data = dev;
-                                if (source_sink_start_ep(ep) != NULL) {
-                                        dev->out_ep = ep;
-                                        continue;
-                                }
-                                usb_ep_disable(ep);
-                                result = -EIO;
-                        }
-
-                /* ignore any other endpoints */
-                } else
-                        continue;
-
-                /* stop on error */
-                ERROR(dev, "can't start %s, result %d\n", ep->name, result);
-                break;
-        }
-        if (result == 0)
-                DBG(dev, "buflen %d\n", buflen);
-
-        /* caller is responsible for cleanup on error */
-        return result;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static void loopback_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        struct zero_dev *dev = ep->driver_data;
-        int             status = req->status;
-
-        switch (status) {
-
-        case 0:                         /* normal completion? */
-                if (ep == dev->out_ep) {
-                        /* loop this OUT packet back IN to the host */
-                        req->zero = (req->actual < req->length);
-                        req->length = req->actual;
-                        status = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
-                        if (status == 0)
-                                return;
-
-                        /* "should never get here" */
-                        ERROR(dev, "can't loop %s to %s: %d\n",
-                                ep->name, dev->in_ep->name,
-                                status);
-                }
-
-                /* queue the buffer for some later OUT packet */
-                req->length = buflen;
-                status = usb_ep_queue(dev->out_ep, req, GFP_ATOMIC);
-                if (status == 0)
-                        return;
-
-                /* "should never get here" */
-                /* FALLTHROUGH */
-
-        default:
-                ERROR(dev, "%s loop complete --> %d, %d/%d\n", ep->name,
-                                status, req->actual, req->length);
-                /* FALLTHROUGH */
-
-        /* NOTE:  since this driver doesn't maintain an explicit record
-         * of requests it submitted (just maintains qlen count), we
-         * rely on the hardware driver to clean up on disconnect or
-         * endpoint disable.
-         */
-        case -ECONNABORTED:             /* hardware forced ep reset */
-        case -ECONNRESET:               /* request dequeued */
-        case -ESHUTDOWN:                /* disconnect from host */
-                free_ep_req(ep, req);
-                return;
-        }
-}
-
-static int set_loopback_config(struct zero_dev *dev)
-{
-        int                     result = 0;
-        struct usb_ep           *ep;
-        struct usb_gadget       *gadget = dev->gadget;
-
-        gadget_for_each_ep(ep, gadget) {
-                const struct usb_endpoint_descriptor    *d;
-
-                /* one endpoint writes data back IN to the host */
-                if (strcmp(ep->name, EP_IN_NAME) == 0) {
-                        d = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
-                        result = usb_ep_enable(ep, d);
-                        if (result == 0) {
-                                ep->driver_data = dev;
-                                dev->in_ep = ep;
-                                continue;
-                        }
-
-                /* one endpoint just reads OUT packets */
-                } else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
-                        d = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
-                        result = usb_ep_enable(ep, d);
-                        if (result == 0) {
-                                ep->driver_data = dev;
-                                dev->out_ep = ep;
-                                continue;
-                        }
-
-                /* ignore any other endpoints */
-                } else
-                        continue;
-
-                /* stop on error */
-                ERROR(dev, "can't enable %s, result %d\n", ep->name, result);
-                break;
-        }
-
-        /* allocate a bunch of read buffers and queue them all at once.
-         * we buffer at most 'qlen' transfers; fewer if any need more
-         * than 'buflen' bytes each.
-         */
-        if (result == 0) {
-                struct usb_request      *req;
-                unsigned                i;
-
-                ep = dev->out_ep;
-                for (i = 0; i < qlen && result == 0; i++) {
-                        req = alloc_ep_req(ep, buflen);
-                        if (req) {
-                                req->complete = loopback_complete;
-                                result = usb_ep_queue(ep, req, GFP_ATOMIC);
-                                if (result)
-                                        DBG(dev, "%s queue req --> %d\n",
-                                                        ep->name, result);
-                        } else
-                                result = -ENOMEM;
-                }
-        }
-        if (result == 0)
-                DBG(dev, "qlen %d, buflen %d\n", qlen, buflen);
-
-        /* caller is responsible for cleanup on error */
-        return result;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static void zero_reset_config(struct zero_dev *dev)
-{
-        if (dev->config == 0)
-                return;
-
-        DBG(dev, "reset config\n");
-
-        /* just disable endpoints, forcing completion of pending i/o.
-         * all our completion handlers free their requests in this case.
-         */
-        if (dev->in_ep) {
-                usb_ep_disable(dev->in_ep);
-                dev->in_ep = NULL;
-        }
-        if (dev->out_ep) {
-                usb_ep_disable(dev->out_ep);
-                dev->out_ep = NULL;
-        }
-        dev->config = 0;
-        del_timer(&dev->resume);
-}
-
-/* change our operational config.  this code must agree with the code
- * that returns config descriptors, and altsetting code.
- *
- * it's also responsible for power management interactions. some
- * configurations might not work with our current power sources.
- *
- * note that some device controller hardware will constrain what this
- * code can do, perhaps by disallowing more than one configuration or
- * by limiting configuration choices (like the pxa2xx).
- */
-static int zero_set_config(struct zero_dev *dev, unsigned number)
-{
-        int                     result = 0;
-        struct usb_gadget       *gadget = dev->gadget;
-
-        if (number == dev->config)
-                return 0;
-
-        if (gadget_is_sa1100(gadget) && dev->config) {
-                /* tx fifo is full, but we can't clear it...*/
-                ERROR(dev, "can't change configurations\n");
-                return -ESPIPE;
-        }
-        zero_reset_config(dev);
-
-        switch (number) {
-        case CONFIG_SOURCE_SINK:
-                result = set_source_sink_config(dev);
-                break;
-        case CONFIG_LOOPBACK:
-                result = set_loopback_config(dev);
-                break;
-        default:
-                result = -EINVAL;
-                /* FALL THROUGH */
-        case 0:
-                return result;
-        }
-
-        if (!result && (!dev->in_ep || !dev->out_ep))
-                result = -ENODEV;
-        if (result)
-                zero_reset_config(dev);
-        else {
-                char *speed;
-
-                switch (gadget->speed) {
-                case USB_SPEED_LOW:     speed = "low"; break;
-                case USB_SPEED_FULL:    speed = "full"; break;
-                case USB_SPEED_HIGH:    speed = "high"; break;
-                default:                speed = "?"; break;
-                }
-
-                dev->config = number;
-                INFO(dev, "%s speed config #%d: %s\n", speed, number,
-                                (number == CONFIG_SOURCE_SINK)
-                                        ? source_sink : loopback);
-        }
-        return result;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static void zero_setup_complete(struct usb_ep *ep, struct usb_request *req)
-{
-        if (req->status || req->actual != req->length)
-                DBG((struct zero_dev *) ep->driver_data,
-                                "setup complete --> %d, %d/%d\n",
-                                req->status, req->actual, req->length);
-}
-
-/*
- * The setup() callback implements all the ep0 functionality that's
- * not handled lower down, in hardware or the hardware driver (like
- * device and endpoint feature flags, and their status).  It's all
- * housekeeping for the gadget function we're implementing.  Most of
- * the work is in config-specific setup.
- */
-static int
-zero_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
-{
-        struct zero_dev         *dev = get_gadget_data(gadget);
-        struct usb_request      *req = dev->req;
-        int                     value = -EOPNOTSUPP;
-        u16                     w_index = le16_to_cpu(ctrl->wIndex);
-        u16                     w_value = le16_to_cpu(ctrl->wValue);
-        u16                     w_length = le16_to_cpu(ctrl->wLength);
-
-        /* usually this stores reply data in the pre-allocated ep0 buffer,
-         * but config change events will reconfigure hardware.
-         */
-        req->zero = 0;
-        switch (ctrl->bRequest) {
-
-        case USB_REQ_GET_DESCRIPTOR:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        goto unknown;
-                switch (w_value >> 8) {
-
-                case USB_DT_DEVICE:
-                        value = min(w_length, (u16) sizeof device_desc);
-                        memcpy(req->buf, &device_desc, value);
-                        break;
-                case USB_DT_DEVICE_QUALIFIER:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        value = min(w_length, (u16) sizeof dev_qualifier);
-                        memcpy(req->buf, &dev_qualifier, value);
-                        break;
-
-                case USB_DT_OTHER_SPEED_CONFIG:
-                        if (!gadget_is_dualspeed(gadget))
-                                break;
-                        // FALLTHROUGH
-                case USB_DT_CONFIG:
-                        value = config_buf(gadget, req->buf,
-                                        w_value >> 8,
-                                        w_value & 0xff);
-                        if (value >= 0)
-                                value = min(w_length, (u16) value);
-                        break;
-
-                case USB_DT_STRING:
-                        /* wIndex == language code.
-                         * this driver only handles one language, you can
-                         * add string tables for other languages, using
-                         * any UTF-8 characters
-                         */
-                        value = usb_gadget_get_string(&stringtab,
-                                        w_value & 0xff, req->buf);
-                        if (value >= 0)
-                                value = min(w_length, (u16) value);
-                        break;
-                }
-                break;
-
-        /* currently two configs, two speeds */
-        case USB_REQ_SET_CONFIGURATION:
-                if (ctrl->bRequestType != 0)
-                        goto unknown;
-                if (gadget->a_hnp_support)
-                        DBG(dev, "HNP available\n");
-                else if (gadget->a_alt_hnp_support)
-                        DBG(dev, "HNP needs a different root port\n");
-                else
-                        VDBG(dev, "HNP inactive\n");
-                spin_lock(&dev->lock);
-                value = zero_set_config(dev, w_value);
-                spin_unlock(&dev->lock);
-                break;
-        case USB_REQ_GET_CONFIGURATION:
-                if (ctrl->bRequestType != USB_DIR_IN)
-                        goto unknown;
-                *(u8 *)req->buf = dev->config;
-                value = min(w_length, (u16) 1);
-                break;
-
-        /* until we add altsetting support, or other interfaces,
-         * only 0/0 are possible.  pxa2xx only supports 0/0 (poorly)
-         * and already killed pending endpoint I/O.
-         */
-        case USB_REQ_SET_INTERFACE:
-                if (ctrl->bRequestType != USB_RECIP_INTERFACE)
-                        goto unknown;
-                spin_lock(&dev->lock);
-                if (dev->config && w_index == 0 && w_value == 0) {
-                        u8              config = dev->config;
-
-                        /* resets interface configuration, forgets about
-                         * previous transaction state (queued bufs, etc)
-                         * and re-inits endpoint state (toggle etc)
-                         * no response queued, just zero status == success.
-                         * if we had more than one interface we couldn't
-                         * use this "reset the config" shortcut.
-                         */
-                        zero_reset_config(dev);
-                        zero_set_config(dev, config);
-                        value = 0;
-                }
-                spin_unlock(&dev->lock);
-                break;
-        case USB_REQ_GET_INTERFACE:
-                if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE))
-                        goto unknown;
-                if (!dev->config)
-                        break;
-                if (w_index != 0) {
-                        value = -EDOM;
-                        break;
-                }
-                *(u8 *)req->buf = 0;
-                value = min(w_length, (u16) 1);
-                break;
-
-        /*
-         * These are the same vendor-specific requests supported by
-         * Intel's USB 2.0 compliance test devices.  We exceed that
-         * device spec by allowing multiple-packet requests.
-         */
-        case 0x5b:      /* control WRITE test -- fill the buffer */
-                if (ctrl->bRequestType != (USB_DIR_OUT|USB_TYPE_VENDOR))
-                        goto unknown;
-                if (w_value || w_index)
-                        break;
-                /* just read that many bytes into the buffer */
-                if (w_length > USB_BUFSIZ)
-                        break;
-                value = w_length;
-                break;
-        case 0x5c:      /* control READ test -- return the buffer */
-                if (ctrl->bRequestType != (USB_DIR_IN|USB_TYPE_VENDOR))
-                        goto unknown;
-                if (w_value || w_index)
-                        break;
-                /* expect those bytes are still in the buffer; send back */
-                if (w_length > USB_BUFSIZ
-                                || w_length != req->length)
-                        break;
-                value = w_length;
-                break;
-
-        default:
-unknown:
-                VDBG(dev,
-                        "unknown control req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        w_value, w_index, w_length);
-        }
-
-        /* respond with data transfer before status phase? */
-        if (value >= 0) {
-                req->length = value;
-                req->zero = value < w_length;
-                value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
-                if (value < 0) {
-                        DBG(dev, "ep_queue --> %d\n", value);
-                        req->status = 0;
-                        zero_setup_complete(gadget->ep0, req);
-                }
-        }
-
-        /* device either stalls (value < 0) or reports success */
-        return value;
-}
-
-static void zero_disconnect(struct usb_gadget *gadget)
-{
-        struct zero_dev         *dev = get_gadget_data(gadget);
-        unsigned long           flags;
-
-        spin_lock_irqsave(&dev->lock, flags);
-        zero_reset_config(dev);
-
-        /* a more significant application might have some non-usb
-         * activities to quiesce here, saving resources like power
-         * or pushing the notification up a network stack.
-         */
-        spin_unlock_irqrestore(&dev->lock, flags);
-
-        /* next we may get setup() calls to enumerate new connections;
-         * or an unbind() during shutdown (including removing module).
-         */
-}
-
-static void zero_autoresume(unsigned long _dev)
-{
-        struct zero_dev *dev = (struct zero_dev *) _dev;
-        int             status;
-
-        /* normally the host would be woken up for something
-         * more significant than just a timer firing...
-         */
-        if (dev->gadget->speed != USB_SPEED_UNKNOWN) {
-                status = usb_gadget_wakeup(dev->gadget);
-                DBG(dev, "wakeup --> %d\n", status);
-        }
+        disable_ep(cdev, in);
+        disable_ep(cdev, out);
 }
 
 /*-------------------------------------------------------------------------*/
 
-static void zero_unbind(struct usb_gadget *gadget)
+static int __init zero_bind(struct usb_composite_dev *cdev)
 {
-        struct zero_dev         *dev = get_gadget_data(gadget);
-
-        DBG(dev, "unbind\n");
-
-        /* we've already been disconnected ... no i/o is active */
-        if (dev->req) {
-                dev->req->length = USB_BUFSIZ;
-                free_ep_req(gadget->ep0, dev->req);
-        }
-        del_timer_sync(&dev->resume);
-        kfree(dev);
-        set_gadget_data(gadget, NULL);
-}
-
-static int __init zero_bind(struct usb_gadget *gadget)
-{
-        struct zero_dev         *dev;
-        struct usb_ep           *ep;
         int                     gcnum;
+        struct usb_gadget       *gadget = cdev->gadget;
+        int                     id;
 
-        /* FIXME this can't yet work right with SH ... it has only
-         * one configuration, numbered one.
+        /* Allocate string descriptor numbers ... note that string
+         * contents can be overridden by the composite_dev glue.
          */
-        if (gadget_is_sh(gadget))
-                return -ENODEV;
-
-        /* Bulk-only drivers like this one SHOULD be able to
-         * autoconfigure on any sane usb controller driver,
-         * but there may also be important quirks to address.
+        id = usb_string_id(cdev);
+        if (id < 0)
+                return id;
+        strings_dev[STRING_MANUFACTURER_IDX].id = id;
+        device_desc.iManufacturer = id;
+
+        id = usb_string_id(cdev);
+        if (id < 0)
+                return id;
+        strings_dev[STRING_PRODUCT_IDX].id = id;
+        device_desc.iProduct = id;
+
+        id = usb_string_id(cdev);
+        if (id < 0)
+                return id;
+        strings_dev[STRING_SERIAL_IDX].id = id;
+        device_desc.iSerialNumber = id;
+
+        /* Register primary, then secondary configuration.  Note that
+         * SH3 only allows one config...
          */
-        usb_ep_autoconfig_reset(gadget);
-        ep = usb_ep_autoconfig(gadget, &fs_source_desc);
-        if (!ep) {
-autoconf_fail:
-                pr_err("%s: can't autoconfigure on %s\n",
-                        shortname, gadget->name);
-                return -ENODEV;
+        if (loopdefault) {
+                loopback_add(cdev);
+                if (!gadget_is_sh(gadget))
+                        sourcesink_add(cdev);
+        } else {
+                sourcesink_add(cdev);
+                if (!gadget_is_sh(gadget))
+                        loopback_add(cdev);
         }
-        EP_IN_NAME = ep->name;
-        ep->driver_data = ep;   /* claim */
-
-        ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
-        if (!ep)
-                goto autoconf_fail;
-        EP_OUT_NAME = ep->name;
-        ep->driver_data = ep;   /* claim */
 
         gcnum = usb_gadget_controller_number(gadget);
         if (gcnum >= 0)
@@ -1115,144 +241,44 @@ autoconf_fail:
         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.
+                 * so just warn about unrcognized controllers -- don't panic.
                  *
                  * things like configuration and altsetting numbering
                  * can need hardware-specific attention though.
                  */
                 pr_warning("%s: controller '%s' not recognized\n",
-                        shortname, gadget->name);
+                        longname, gadget->name);
                 device_desc.bcdDevice = __constant_cpu_to_le16(0x9999);
         }
 
 
-        /* ok, we made sense of the hardware ... */
-        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
-        if (!dev)
-                return -ENOMEM;
-        spin_lock_init(&dev->lock);
-        dev->gadget = gadget;
-        set_gadget_data(gadget, dev);
-
-        init_timer(&dev->resume);
-        dev->resume.function = zero_autoresume;
-        dev->resume.data = (unsigned long) dev;
-
-        /* preallocate control response and buffer */
-        dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
-        if (!dev->req)
-                goto enomem;
-        dev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
-        if (!dev->req->buf)
-                goto enomem;
-
-        dev->req->complete = zero_setup_complete;
-
-        device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
-
-        if (gadget_is_dualspeed(gadget)) {
-                /* assume ep0 uses the same value for both speeds ... */
-                dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
-
-                /* and that all endpoints are dual-speed */
-                hs_source_desc.bEndpointAddress =
-                                fs_source_desc.bEndpointAddress;
-                hs_sink_desc.bEndpointAddress =
-                                fs_sink_desc.bEndpointAddress;
-        }
-
-        if (gadget_is_otg(gadget)) {
-                otg_descriptor.bmAttributes |= USB_OTG_HNP,
-                source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-                loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-        }
-
-        usb_gadget_set_selfpowered(gadget);
-
-        if (autoresume) {
-                source_sink_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-                loopback_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
-        }
-
-        gadget->ep0->driver_data = dev;
-
-        INFO(dev, "%s, version: " DRIVER_VERSION "\n", longname);
-        INFO(dev, "using %s, OUT %s IN %s\n", gadget->name,
-                EP_OUT_NAME, EP_IN_NAME);
+        INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname);
 
         snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
                 init_utsname()->sysname, init_utsname()->release,
                 gadget->name);
 
         return 0;
-
-enomem:
-        zero_unbind(gadget);
-        return -ENOMEM;
 }
 
-/*-------------------------------------------------------------------------*/
-
-static void zero_suspend(struct usb_gadget *gadget)
-{
-        struct zero_dev         *dev = get_gadget_data(gadget);
-
-        if (gadget->speed == USB_SPEED_UNKNOWN)
-                return;
-
-        if (autoresume) {
-                mod_timer(&dev->resume, jiffies + (HZ * autoresume));
-                DBG(dev, "suspend, wakeup in %d seconds\n", autoresume);
-        } else
-                DBG(dev, "suspend\n");
-}
-
-static void zero_resume(struct usb_gadget *gadget)
-{
-        struct zero_dev         *dev = get_gadget_data(gadget);
-
-        DBG(dev, "resume\n");
-        del_timer(&dev->resume);
-}
-
-
-/*-------------------------------------------------------------------------*/
-
-static struct usb_gadget_driver zero_driver = {
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-        .speed          = USB_SPEED_HIGH,
-#else
-        .speed          = USB_SPEED_FULL,
-#endif
-        .function       = (char *) longname,
+static struct usb_composite_driver zero_driver = {
+        .name           = "zero",
+        .dev            = &device_desc,
+        .strings        = dev_strings,
         .bind           = zero_bind,
-        .unbind         = __exit_p(zero_unbind),
-
-        .setup          = zero_setup,
-        .disconnect     = zero_disconnect,
-
-        .suspend        = zero_suspend,
-        .resume         = zero_resume,
-
-        .driver         = {
-                .name           = (char *) shortname,
-                .owner          = THIS_MODULE,
-        },
 };
 
 MODULE_AUTHOR("David Brownell");
 MODULE_LICENSE("GPL");
 
-
 static int __init init(void)
 {
-        return usb_gadget_register_driver(&zero_driver);
+        return usb_composite_register(&zero_driver);
 }
 module_init(init);
 
 static void __exit cleanup(void)
 {
-        usb_gadget_unregister_driver(&zero_driver);
+        usb_composite_unregister(&zero_driver);
 }
 module_exit(cleanup);
-
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index 08a4335401a9..bf69f4739107 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -19,263 +19,304 @@
 #define USB_MCFG_RDCOMB   (1<<30)
 #define USB_MCFG_SSDEN    (1<<23)
 #define USB_MCFG_PHYPLLEN (1<<19)
+#define USB_MCFG_UCECLKEN (1<<18)
 #define USB_MCFG_EHCCLKEN (1<<17)
+#ifdef CONFIG_DMA_COHERENT
 #define USB_MCFG_UCAM     (1<<7)
+#else
+#define USB_MCFG_UCAM     (0)
+#endif
 #define USB_MCFG_EBMEN    (1<<3)
 #define USB_MCFG_EMEMEN   (1<<2)
 
-#define USBH_ENABLE_CE    (USB_MCFG_PHYPLLEN | USB_MCFG_EHCCLKEN)
+#define USBH_ENABLE_CE  (USB_MCFG_PHYPLLEN | USB_MCFG_EHCCLKEN)
+#define USBH_ENABLE_INIT (USB_MCFG_PFEN  | USB_MCFG_RDCOMB |    \
+                          USBH_ENABLE_CE | USB_MCFG_SSDEN  |    \
+                          USB_MCFG_UCAM  | USB_MCFG_EBMEN  |    \
+                          USB_MCFG_EMEMEN)
 
-#ifdef CONFIG_DMA_COHERENT
-#define USBH_ENABLE_INIT  (USBH_ENABLE_CE \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN | USB_MCFG_UCAM \
-                         | USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
-#else
-#define USBH_ENABLE_INIT  (USBH_ENABLE_CE \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN \
-                         | USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
-#endif
 #define USBH_DISABLE      (USB_MCFG_EBMEN | USB_MCFG_EMEMEN)
 
 extern int usb_disabled(void);
 
-/*-------------------------------------------------------------------------*/
-
-static void au1xxx_start_ehc(struct platform_device *dev)
+static void au1xxx_start_ehc(void)
 {
-        pr_debug(__FILE__ ": starting Au1xxx EHCI USB Controller\n");
-
-        /* write HW defaults again in case Yamon cleared them */
-        if (au_readl(USB_HOST_CONFIG) == 0) {
-                au_writel(0x00d02000, USB_HOST_CONFIG);
-                au_readl(USB_HOST_CONFIG);
-                udelay(1000);
-        }
-        /* enable host controller */
-        au_writel(USBH_ENABLE_CE | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
-        udelay(1000);
-        au_writel(USBH_ENABLE_INIT | au_readl(USB_HOST_CONFIG),
-                  USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+        /* enable clock to EHCI block and HS PHY PLL*/
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_CE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
 
-        pr_debug(__FILE__ ": Clock to USB host has been enabled\n");
+        /* enable EHCI mmio */
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
+        au_sync();
+        udelay(1000);
 }
 
-static void au1xxx_stop_ehc(struct platform_device *dev)
+static void au1xxx_stop_ehc(void)
 {
-        pr_debug(__FILE__ ": stopping Au1xxx EHCI USB Controller\n");
+        unsigned long c;
 
         /* Disable mem */
-        au_writel(~USBH_DISABLE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
+        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_DISABLE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
-        /* Disable clock */
-        au_writel(~USB_MCFG_EHCCLKEN & au_readl(USB_HOST_CONFIG),
-                  USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+
+        /* Disable EHC clock. If the HS PHY is unused disable it too. */
+        c = au_readl(USB_HOST_CONFIG) & ~USB_MCFG_EHCCLKEN;
+        if (!(c & USB_MCFG_UCECLKEN))           /* UDC disabled? */
+                c &= ~USB_MCFG_PHYPLLEN;        /* yes: disable HS PHY PLL */
+        au_writel(c, USB_HOST_CONFIG);
+        au_sync();
 }
 
-/*-------------------------------------------------------------------------*/
+static const struct hc_driver ehci_au1xxx_hc_driver = {
+        .description            = hcd_name,
+        .product_desc           = "Au1xxx EHCI",
+        .hcd_priv_size          = sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq                    = ehci_irq,
+        .flags                  = HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         *
+         * FIXME -- ehci_init() doesn't do enough here.
+         * See ehci-ppc-soc for a complete implementation.
+         */
+        .reset                  = ehci_init,
+        .start                  = ehci_run,
+        .stop                   = ehci_stop,
+        .shutdown               = ehci_shutdown,
 
-/* configure so an HC device and id are always provided */
-/* always called with process context; sleeping is OK */
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue            = ehci_urb_enqueue,
+        .urb_dequeue            = ehci_urb_dequeue,
+        .endpoint_disable       = ehci_endpoint_disable,
 
-/**
- * usb_ehci_au1xxx_probe - initialize Au1xxx-based 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.
- *
- */
-int usb_ehci_au1xxx_probe(const struct hc_driver *driver,
-                          struct usb_hcd **hcd_out, struct platform_device *dev)
+        /*
+         * scheduling support
+         */
+        .get_frame_number       = ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data        = ehci_hub_status_data,
+        .hub_control            = ehci_hub_control,
+        .bus_suspend            = ehci_bus_suspend,
+        .bus_resume             = ehci_bus_resume,
+        .relinquish_port        = ehci_relinquish_port,
+        .port_handed_over       = ehci_port_handed_over,
+};
+
+static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 {
-        int retval;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
+        int ret;
 
-#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
+        if (usb_disabled())
+                return -ENODEV;
 
+#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
         /* Au1200 AB USB does not support coherent memory */
         if (!(read_c0_prid() & 0xff)) {
-                pr_info("%s: this is chip revision AB!\n", dev->name);
-                pr_info("%s: update your board or re-configure the kernel\n",
-                        dev->name);
+                printk(KERN_INFO "%s: this is chip revision AB!\n", pdev->name);
+                printk(KERN_INFO "%s: update your board or re-configure"
+                                 " the kernel\n", pdev->name);
                 return -ENODEV;
         }
 #endif
 
-        au1xxx_start_ehc(dev);
-
-        if (dev->resource[1].flags != IORESOURCE_IRQ) {
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
                 pr_debug("resource[1] is not IORESOURCE_IRQ");
-                retval = -ENOMEM;
+                return -ENOMEM;
         }
-        hcd = usb_create_hcd(driver, &dev->dev, "Au1xxx");
+        hcd = usb_create_hcd(&ehci_au1xxx_hc_driver, &pdev->dev, "Au1xxx");
         if (!hcd)
                 return -ENOMEM;
-        hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1;
+
+        hcd->rsrc_start = pdev->resource[0].start;
+        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
 
         if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
                 pr_debug("request_mem_region failed");
-                retval = -EBUSY;
+                ret = -EBUSY;
                 goto err1;
         }
 
         hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
                 pr_debug("ioremap failed");
-                retval = -ENOMEM;
+                ret = -ENOMEM;
                 goto err2;
         }
 
+        au1xxx_start_ehc();
+
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
         ehci->regs = hcd->regs + HC_LENGTH(readl(&ehci->caps->hc_capbase));
         /* cache this readonly data; minimize chip reads */
         ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
-        /* ehci_hcd_init(hcd_to_ehci(hcd)); */
-
-        retval =
-            usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED | IRQF_SHARED);
-        if (retval == 0)
-                return retval;
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_DISABLED | IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
 
-        au1xxx_stop_ehc(dev);
+        au1xxx_stop_ehc();
         iounmap(hcd->regs);
 err2:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
-        return retval;
+        return ret;
 }
 
-/* may be called without controller electrically present */
-/* may be called with controller, bus, and devices active */
-
-/**
- * usb_ehci_hcd_au1xxx_remove - shutdown processing for Au1xxx-based HCDs
- * @dev: USB Host Controller being removed
- * Context: !in_interrupt()
- *
- * Reverses the effect of usb_ehci_hcd_au1xxx_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
- * context, normally "rmmod", "apmd", or something similar.
- *
- */
-void usb_ehci_au1xxx_remove(struct usb_hcd *hcd, struct platform_device *dev)
+static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 {
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
-        au1xxx_stop_ehc(dev);
+        au1xxx_stop_ehc();
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
 }
 
-/*-------------------------------------------------------------------------*/
+#ifdef CONFIG_PM
+static int ehci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
+                                        pm_message_t message)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        unsigned long flags;
+        int rc;
 
-static const struct hc_driver ehci_au1xxx_hc_driver = {
-        .description = hcd_name,
-        .product_desc = "Au1xxx EHCI",
-        .hcd_priv_size = sizeof(struct ehci_hcd),
+        return 0;
+        rc = 0;
 
-        /*
-         * generic hardware linkage
-         */
-        .irq = ehci_irq,
-        .flags = HCD_MEMORY | HCD_USB2,
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(10);
 
-        /*
-         * basic lifecycle operations
+        /* Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible, bail out if RH has been resumed. Use
+         * the spinlock to properly synchronize with possible pending
+         * RH suspend or resume activity.
          *
-         * FIXME -- ehci_init() doesn't do enough here.
-         * See ehci-ppc-soc for a complete implementation.
-         */
-        .reset = ehci_init,
-        .start = ehci_run,
-        .stop = ehci_stop,
-        .shutdown = ehci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
+         * This is still racy as hcd->state is manipulated outside of
+         * any locks =P But that will be a different fix.
          */
-        .urb_enqueue = ehci_urb_enqueue,
-        .urb_dequeue = ehci_urb_dequeue,
-        .endpoint_disable = ehci_endpoint_disable,
+        spin_lock_irqsave(&ehci->lock, flags);
+        if (hcd->state != HC_STATE_SUSPENDED) {
+                rc = -EINVAL;
+                goto bail;
+        }
+        ehci_writel(ehci, 0, &ehci->regs->intr_enable);
+        (void)ehci_readl(ehci, &ehci->regs->intr_enable);
 
-        /*
-         * scheduling support
-         */
-        .get_frame_number = ehci_get_frame,
+        /* make sure snapshot being resumed re-enumerates everything */
+        if (message.event == PM_EVENT_PRETHAW) {
+                ehci_halt(ehci);
+                ehci_reset(ehci);
+        }
 
-        /*
-         * root hub support
-         */
-        .hub_status_data = ehci_hub_status_data,
-        .hub_control = ehci_hub_control,
-        .bus_suspend = ehci_bus_suspend,
-        .bus_resume = ehci_bus_resume,
-        .relinquish_port = ehci_relinquish_port,
-        .port_handed_over = ehci_port_handed_over,
-};
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
-/*-------------------------------------------------------------------------*/
+        au1xxx_stop_ehc();
 
-static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = NULL;
-        int ret;
+bail:
+        spin_unlock_irqrestore(&ehci->lock, flags);
 
-        pr_debug("In ehci_hcd_au1xxx_drv_probe\n");
+        // could save FLADJ in case of Vaux power loss
+        // ... we'd only use it to handle clock skew
 
-        if (usb_disabled())
-                return -ENODEV;
-
-        /* FIXME we only want one one probe() not two */
-        ret = usb_ehci_au1xxx_probe(&ehci_au1xxx_hc_driver, &hcd, pdev);
-        return ret;
+        return rc;
 }
 
-static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
+
+static int ehci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
-        /* FIXME we only want one one remove() not two */
-        usb_ehci_au1xxx_remove(hcd, pdev);
-        return 0;
-}
+        au1xxx_start_ehc();
 
- /*TBD*/
-/*static int ehci_hcd_au1xxx_drv_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        // maybe restore FLADJ
 
-        return 0;
-}
-static int ehci_hcd_au1xxx_drv_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        if (time_before(jiffies, ehci->next_statechange))
+                msleep(100);
+
+        /* Mark hardware accessible again as we are out of D3 state by now */
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        /* If CF is still set, we maintained PCI Vaux power.
+         * Just undo the effect of ehci_pci_suspend().
+         */
+        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF) {
+                int     mask = INTR_MASK;
+
+                if (!hcd->self.root_hub->do_remote_wakeup)
+                        mask &= ~STS_PCD;
+                ehci_writel(ehci, mask, &ehci->regs->intr_enable);
+                ehci_readl(ehci, &ehci->regs->intr_enable);
+                return 0;
+        }
+
+        ehci_dbg(ehci, "lost power, restarting\n");
+        usb_root_hub_lost_power(hcd->self.root_hub);
+
+        /* Else reset, to cope with power loss or flush-to-storage
+         * style "resume" having let BIOS kick in during reboot.
+         */
+        (void) ehci_halt(ehci);
+        (void) ehci_reset(ehci);
+
+        /* emptying the schedule aborts any urbs */
+        spin_lock_irq(&ehci->lock);
+        if (ehci->reclaim)
+                end_unlink_async(ehci);
+        ehci_work(ehci);
+        spin_unlock_irq(&ehci->lock);
+
+        ehci_writel(ehci, ehci->command, &ehci->regs->command);
+        ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag);
+        ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
+
+        /* here we "know" root ports should always stay powered */
+        ehci_port_power(ehci, 1);
+
+        hcd->state = HC_STATE_SUSPENDED;
 
         return 0;
 }
-*/
-MODULE_ALIAS("platform:au1xxx-ehci");
+
+#else
+#define ehci_hcd_au1xxx_drv_suspend NULL
+#define ehci_hcd_au1xxx_drv_resume NULL
+#endif
+
 static struct platform_driver ehci_hcd_au1xxx_driver = {
-        .probe = ehci_hcd_au1xxx_drv_probe,
-        .remove = ehci_hcd_au1xxx_drv_remove,
-        .shutdown = usb_hcd_platform_shutdown,
-        /*.suspend      = ehci_hcd_au1xxx_drv_suspend, */
-        /*.resume       = ehci_hcd_au1xxx_drv_resume, */
+        .probe          = ehci_hcd_au1xxx_drv_probe,
+        .remove         = ehci_hcd_au1xxx_drv_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .suspend        = ehci_hcd_au1xxx_drv_suspend,
+        .resume         = ehci_hcd_au1xxx_drv_resume,
         .driver = {
-                .name = "au1xxx-ehci",
+                .name   = "au1xxx-ehci",
+                .owner  = THIS_MODULE,
         }
 };
+
+MODULE_ALIAS("platform:au1xxx-ehci");
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 0f82fdcaef09..b0f8ed5a7fb9 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -676,7 +676,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
                         "%s\n"
                         "SUSPENDED (no register access)\n",
                         hcd->self.controller->bus->name,
-                        hcd->self.controller->bus_id,
+                        dev_name(hcd->self.controller),
                         hcd->product_desc);
                 goto done;
         }
@@ -688,7 +688,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
                 "%s\n"
                 "EHCI %x.%02x, hcd state %d\n",
                 hcd->self.controller->bus->name,
-                hcd->self.controller->bus_id,
+                dev_name(hcd->self.controller),
                 hcd->product_desc,
                 i >> 8, i & 0x0ff, hcd->state);
         size -= temp;
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 7370d6187c64..01c3da34f678 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -56,7 +56,7 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
         pdata = (struct fsl_usb2_platform_data *)pdev->dev.platform_data;
         if (!pdata) {
                 dev_err(&pdev->dev,
-                        "No platform data for %s.\n", pdev->dev.bus_id);
+                        "No platform data for %s.\n", dev_name(&pdev->dev));
                 return -ENODEV;
         }
 
@@ -69,7 +69,7 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
               (pdata->operating_mode == FSL_USB2_DR_OTG))) {
                 dev_err(&pdev->dev,
                         "Non Host Mode configured for %s. Wrong driver linked.\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 return -ENODEV;
         }
 
@@ -77,12 +77,12 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
         if (!res) {
                 dev_err(&pdev->dev,
                         "Found HC with no IRQ. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 return -ENODEV;
         }
         irq = res->start;
 
-        hcd = usb_create_hcd(driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
                 goto err1;
@@ -92,7 +92,7 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
         if (!res) {
                 dev_err(&pdev->dev,
                         "Found HC with no register addr. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 retval = -ENODEV;
                 goto err2;
         }
@@ -132,7 +132,7 @@ int usb_hcd_fsl_probe(const struct hc_driver *driver,
       err2:
         usb_put_hcd(hcd);
       err1:
-        dev_err(&pdev->dev, "init %s fail, %d\n", pdev->dev.bus_id, retval);
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
         return retval;
 }
 
@@ -230,8 +230,13 @@ static void mpc83xx_usb_setup(struct usb_hcd *hcd)
 
         /* put controller in host mode. */
         ehci_writel(ehci, 0x00000003, non_ehci + FSL_SOC_USB_USBMODE);
+#ifdef CONFIG_PPC_85xx
+        out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x00000008);
+        out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000080);
+#else
         out_be32(non_ehci + FSL_SOC_USB_PRICTRL, 0x0000000c);
         out_be32(non_ehci + FSL_SOC_USB_AGECNTTHRSH, 0x00000040);
+#endif
         out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
 }
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 369a8a5ea7bb..d9d53f289caf 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -84,7 +84,7 @@ static const char	hcd_name [] = "ehci_hcd";
 #define EHCI_IAA_MSECS          10              /* arbitrary */
 #define EHCI_IO_JIFFIES         (HZ/10)         /* io watchdog > irq_thresh */
 #define EHCI_ASYNC_JIFFIES      (HZ/20)         /* async idle timeout */
-#define EHCI_SHRINK_JIFFIES     (HZ/200)        /* async qh unlink delay */
+#define EHCI_SHRINK_FRAMES      5               /* async qh unlink delay */
 
 /* Initial IRQ latency:  faster than hw default */
 static int log2_irq_thresh = 0;         // 0 to 6
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 9d042f220097..f9575c409124 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -77,12 +77,12 @@ static int ixp4xx_ehci_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(&pdev->dev,
                         "Found HC with no IRQ. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 return -ENODEV;
         }
         irq = res->start;
 
-        hcd = usb_create_hcd(driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
                 goto fail_create_hcd;
@@ -92,7 +92,7 @@ static int ixp4xx_ehci_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(&pdev->dev,
                         "Found HC with no register addr. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 retval = -ENODEV;
                 goto fail_request_resource;
         }
@@ -126,7 +126,7 @@ fail_ioremap:
 fail_request_resource:
         usb_put_hcd(hcd);
 fail_create_hcd:
-        dev_err(&pdev->dev, "init %s fail, %d\n", pdev->dev.bus_id, retval);
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), retval);
         return retval;
 }
 
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index ab625f0ba1d9..5fbdc14e63b3 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -204,7 +204,7 @@ static int __init ehci_orion_drv_probe(struct platform_device *pdev)
         if (irq <= 0) {
                 dev_err(&pdev->dev,
                         "Found HC with no IRQ. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 err = -ENODEV;
                 goto err1;
         }
@@ -213,7 +213,7 @@ static int __init ehci_orion_drv_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(&pdev->dev,
                         "Found HC with no register addr. Check %s setup!\n",
-                        pdev->dev.bus_id);
+                        dev_name(&pdev->dev));
                 err = -ENODEV;
                 goto err1;
         }
@@ -233,7 +233,7 @@ static int __init ehci_orion_drv_probe(struct platform_device *pdev)
         }
 
         hcd = usb_create_hcd(&ehci_orion_hc_driver,
-                        &pdev->dev, pdev->dev.bus_id);
+                        &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 err = -ENOMEM;
                 goto err3;
@@ -276,7 +276,7 @@ err2:
         release_mem_region(res->start, res->end - res->start + 1);
 err1:
         dev_err(&pdev->dev, "init %s fail, %d\n",
-                pdev->dev.bus_id, err);
+                dev_name(&pdev->dev), err);
 
         return err;
 }
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 37e6abeb794c..0eba894bcb01 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -128,7 +128,7 @@ static int ps3_ehci_probe(struct ps3_system_bus_device *dev)
 
         dev->core.dma_mask = &dummy_mask; /* FIXME: for improper usb code */
 
-        hcd = usb_create_hcd(&ps3_ehci_hc_driver, &dev->core, dev->core.bus_id);
+        hcd = usb_create_hcd(&ps3_ehci_hc_driver, &dev->core, dev_name(&dev->core));
 
         if (!hcd) {
                 dev_dbg(&dev->core, "%s:%d: usb_create_hcd failed\n", __func__,
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index b85b54160cda..2622b6596d7c 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -1116,8 +1116,7 @@ static void scan_async (struct ehci_hcd *ehci)
         struct ehci_qh          *qh;
         enum ehci_timer_action  action = TIMER_IO_WATCHDOG;
 
-        if (!++(ehci->stamp))
-                ehci->stamp++;
+        ehci->stamp = ehci_readl(ehci, &ehci->regs->frame_index);
         timer_action_done (ehci, TIMER_ASYNC_SHRINK);
 rescan:
         qh = ehci->async->qh_next.qh;
@@ -1142,18 +1141,20 @@ rescan:
                                 }
                         }
 
-                        /* unlink idle entries, reducing HC PCI usage as well
+                        /* unlink idle entries, reducing DMA usage as well
                          * as HCD schedule-scanning costs.  delay for any qh
                          * we just scanned, there's a not-unusual case that it
                          * doesn't stay idle for long.
                          * (plus, avoids some kind of re-activation race.)
                          */
-                        if (list_empty (&qh->qtd_list)) {
-                                if (qh->stamp == ehci->stamp)
+                        if (list_empty(&qh->qtd_list)
+                                        && qh->qh_state == QH_STATE_LINKED) {
+                                if (!ehci->reclaim
+                                        && ((ehci->stamp - qh->stamp) & 0x1fff)
+                                                >= (EHCI_SHRINK_FRAMES * 8))
+                                        start_unlink_async(ehci, qh);
+                                else
                                         action = TIMER_ASYNC_SHRINK;
-                                else if (!ehci->reclaim
-                                            && qh->qh_state == QH_STATE_LINKED)
-                                        start_unlink_async (ehci, qh);
                         }
 
                         qh = qh->qh_next.qh;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 90245fd8bac4..5799298364fb 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -198,7 +198,10 @@ timer_action (struct ehci_hcd *ehci, enum ehci_timer_action action)
                         break;
                 // case TIMER_ASYNC_SHRINK:
                 default:
-                        t = EHCI_SHRINK_JIFFIES;
+                        /* add a jiffie since we synch against the
+                         * 8 KHz uframe counter.
+                         */
+                        t = DIV_ROUND_UP(EHCI_SHRINK_FRAMES * HZ, 1000) + 1;
                         break;
                 }
                 mod_timer(&ehci->watchdog, t + jiffies);
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 20b9a0d07420..31178e10cbbe 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -94,6 +94,10 @@ static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
         u16 w;
         int quot = len % 4;
 
+        /* buffer is already in 'usb data order', which is LE. */
+        /* When reading buffer as u16, we have to take care byte order */
+        /* doesn't get mixed up */
+
         if ((unsigned long)dp2 & 1) {
                 /* not aligned */
                 for (; len > 1; len -= 2) {
@@ -105,8 +109,11 @@ static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
                         isp116x_write_data16(isp116x, (u16) * dp);
         } else {
                 /* aligned */
-                for (; len > 1; len -= 2)
-                        isp116x_raw_write_data16(isp116x, *dp2++);
+                for (; len > 1; len -= 2) {
+                        /* Keep byte order ! */
+                        isp116x_raw_write_data16(isp116x, cpu_to_le16(*dp2++));
+                }
+
                 if (len)
                         isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
         }
@@ -124,6 +131,10 @@ static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
         u16 w;
         int quot = len % 4;
 
+        /* buffer is already in 'usb data order', which is LE. */
+        /* When reading buffer as u16, we have to take care byte order */
+        /* doesn't get mixed up */
+
         if ((unsigned long)dp2 & 1) {
                 /* not aligned */
                 for (; len > 1; len -= 2) {
@@ -131,12 +142,16 @@ static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
                         *dp++ = w & 0xff;
                         *dp++ = (w >> 8) & 0xff;
                 }
+
                 if (len)
                         *dp = 0xff & isp116x_read_data16(isp116x);
         } else {
                 /* aligned */
-                for (; len > 1; len -= 2)
-                        *dp2++ = isp116x_raw_read_data16(isp116x);
+                for (; len > 1; len -= 2) {
+                        /* Keep byte order! */
+                        *dp2++ = le16_to_cpu(isp116x_raw_read_data16(isp116x));
+                }
+
                 if (len)
                         *(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
         }
@@ -1592,7 +1607,7 @@ static int __devinit isp116x_probe(struct platform_device *pdev)
         }
 
         /* allocate and initialize hcd */
-        hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(&isp116x_hc_driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 ret = -ENOMEM;
                 goto err5;
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 65aa5ecf569a..c858f2adb929 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -38,6 +38,7 @@ struct isp1760_hcd {
         unsigned                i_thresh;
         unsigned long           reset_done;
         unsigned long           next_statechange;
+        unsigned int            devflags;
 };
 
 static inline struct isp1760_hcd *hcd_to_priv(struct usb_hcd *hcd)
@@ -378,9 +379,31 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         int result;
-        u32 scratch;
+        u32 scratch, hwmode;
+
+        /* Setup HW Mode Control: This assumes a level active-low interrupt */
+        hwmode = HW_DATA_BUS_32BIT;
+
+        if (priv->devflags & ISP1760_FLAG_BUS_WIDTH_16)
+                hwmode &= ~HW_DATA_BUS_32BIT;
+        if (priv->devflags & ISP1760_FLAG_ANALOG_OC)
+                hwmode |= HW_ANA_DIGI_OC;
+        if (priv->devflags & ISP1760_FLAG_DACK_POL_HIGH)
+                hwmode |= HW_DACK_POL_HIGH;
+        if (priv->devflags & ISP1760_FLAG_DREQ_POL_HIGH)
+                hwmode |= HW_DREQ_POL_HIGH;
+
+        /*
+         * We have to set this first in case we're in 16-bit mode.
+         * Write it twice to ensure correct upper bits if switching
+         * to 16-bit mode.
+         */
+        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
 
         isp1760_writel(0xdeadbabe, hcd->regs + HC_SCRATCH_REG);
+        /* Change bus pattern */
+        scratch = isp1760_readl(hcd->regs + HC_CHIP_ID_REG);
         scratch = isp1760_readl(hcd->regs + HC_SCRATCH_REG);
         if (scratch != 0xdeadbabe) {
                 printk(KERN_ERR "ISP1760: Scratch test failed.\n");
@@ -403,17 +426,29 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
 
         /* Step 11 passed */
 
-        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_REG);
-        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_ENABLE);
+        isp1760_info(priv, "bus width: %d, oc: %s\n",
+                           (priv->devflags & ISP1760_FLAG_BUS_WIDTH_16) ?
+                           16 : 32, (priv->devflags & ISP1760_FLAG_ANALOG_OC) ?
+                           "analog" : "digital");
 
         /* ATL reset */
-        scratch = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
-        isp1760_writel(scratch | ALL_ATX_RESET, hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(hwmode | ALL_ATX_RESET, hcd->regs + HC_HW_MODE_CTRL);
         mdelay(10);
-        isp1760_writel(scratch, hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(hwmode, hcd->regs + HC_HW_MODE_CTRL);
 
-        isp1760_writel(PORT1_POWER | PORT1_INIT2, hcd->regs + HC_PORT1_CTRL);
-        mdelay(10);
+        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_REG);
+        isp1760_writel(INTERRUPT_ENABLE_MASK, hcd->regs + HC_INTERRUPT_ENABLE);
+
+        /*
+         * PORT 1 Control register of the ISP1760 is the OTG control
+         * register on ISP1761.
+         */
+        if (!(priv->devflags & ISP1760_FLAG_ISP1761) &&
+            !(priv->devflags & ISP1760_FLAG_PORT1_DIS)) {
+                isp1760_writel(PORT1_POWER | PORT1_INIT2,
+                               hcd->regs + HC_PORT1_CTRL);
+                mdelay(10);
+        }
 
         priv->hcs_params = isp1760_readl(hcd->regs + HC_HCSPARAMS);
 
@@ -453,8 +488,7 @@ static int isp1760_run(struct usb_hcd *hcd)
         hcd->state = HC_STATE_RUNNING;
         isp1760_enable_interrupts(hcd);
         temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
-        temp |= FINAL_HW_CONFIG;
-        isp1760_writel(temp, hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(temp | HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
 
         command = isp1760_readl(hcd->regs + HC_USBCMD);
         command &= ~(CMD_LRESET|CMD_RESET);
@@ -782,8 +816,8 @@ static void enqueue_one_int_qtd(u32 int_regs, u32 payload,
         qtd->status |= slot << 16;
 }
 
-void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                struct isp1760_qtd *qtd)
+static void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                                  struct isp1760_qtd *qtd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         u32 skip_map, or_map;
@@ -816,8 +850,8 @@ void enqueue_an_ATL_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
         isp1760_writel(buffstatus, hcd->regs + HC_BUFFER_STATUS_REG);
 }
 
-void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
-                struct isp1760_qtd *qtd)
+static void enqueue_an_INT_packet(struct usb_hcd *hcd, struct isp1760_qh *qh,
+                                  struct isp1760_qtd *qtd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
         u32 skip_map, or_map;
@@ -1592,7 +1626,7 @@ static int isp1760_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
         struct inter_packet_info *ints;
         u32 i;
         u32 reg_base, or_reg, skip_reg;
-        int flags;
+        unsigned long flags;
         struct ptd ptd;
 
         switch (usb_pipetype(urb->pipe)) {
@@ -2061,7 +2095,7 @@ static void isp1760_endpoint_disable(struct usb_hcd *usb_hcd,
         struct isp1760_hcd *priv = hcd_to_priv(usb_hcd);
         struct isp1760_qh *qh;
         struct isp1760_qtd *qtd;
-        u32 flags;
+        unsigned long flags;
 
         spin_lock_irqsave(&priv->lock, flags);
         qh = ep->hcpriv;
@@ -2112,6 +2146,7 @@ static int isp1760_get_frame(struct usb_hcd *hcd)
 static void isp1760_stop(struct usb_hcd *hcd)
 {
         struct isp1760_hcd *priv = hcd_to_priv(hcd);
+        u32 temp;
 
         isp1760_hub_control(hcd, ClearPortFeature, USB_PORT_FEAT_POWER, 1,
                         NULL, 0);
@@ -2120,7 +2155,8 @@ static void isp1760_stop(struct usb_hcd *hcd)
         spin_lock_irq(&priv->lock);
         ehci_reset(priv);
         /* Disable IRQ */
-        isp1760_writel(HW_DATA_BUS_32BIT, hcd->regs + HC_HW_MODE_CTRL);
+        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
         spin_unlock_irq(&priv->lock);
 
         isp1760_writel(0, hcd->regs + HC_CONFIGFLAG);
@@ -2128,10 +2164,11 @@ static void isp1760_stop(struct usb_hcd *hcd)
 
 static void isp1760_shutdown(struct usb_hcd *hcd)
 {
-        u32 command;
+        u32 command, temp;
 
         isp1760_stop(hcd);
-        isp1760_writel(HW_DATA_BUS_32BIT, hcd->regs + HC_HW_MODE_CTRL);
+        temp = isp1760_readl(hcd->regs + HC_HW_MODE_CTRL);
+        isp1760_writel(temp &= ~HW_GLOBAL_INTR_EN, hcd->regs + HC_HW_MODE_CTRL);
 
         command = isp1760_readl(hcd->regs + HC_USBCMD);
         command &= ~CMD_RUN;
@@ -2183,7 +2220,8 @@ void deinit_kmem_cache(void)
 }
 
 struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
-                u64 irqflags, struct device *dev, const char *busname)
+                u64 irqflags, struct device *dev, const char *busname,
+                unsigned int devflags)
 {
         struct usb_hcd *hcd;
         struct isp1760_hcd *priv;
@@ -2195,11 +2233,12 @@ struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
         /* prevent usb-core allocating DMA pages */
         dev->dma_mask = NULL;
 
-        hcd = usb_create_hcd(&isp1760_hc_driver, dev, dev->bus_id);
+        hcd = usb_create_hcd(&isp1760_hc_driver, dev, dev_name(dev));
         if (!hcd)
                 return ERR_PTR(-ENOMEM);
 
         priv = hcd_to_priv(hcd);
+        priv->devflags = devflags;
         init_memory(priv);
         hcd->regs = ioremap(res_start, res_len);
         if (!hcd->regs) {
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 3d86d0f6b147..6473dd86993c 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -3,7 +3,8 @@
 
 /* exports for if */
 struct usb_hcd *isp1760_register(u64 res_start, u64 res_len, int irq,
-                u64 irqflags, struct device *dev, const char *busname);
+                u64 irqflags, struct device *dev, const char *busname,
+                unsigned int devflags);
 int init_kmem_once(void);
 void deinit_kmem_cache(void);
 
@@ -31,6 +32,7 @@ void deinit_kmem_cache(void);
 /* Configuration Register */
 #define HC_HW_MODE_CTRL         0x300
 #define ALL_ATX_RESET           (1 << 31)
+#define HW_ANA_DIGI_OC          (1 << 15)
 #define HW_DATA_BUS_32BIT       (1 << 8)
 #define HW_DACK_POL_HIGH        (1 << 6)
 #define HW_DREQ_POL_HIGH        (1 << 5)
@@ -56,13 +58,14 @@ void deinit_kmem_cache(void);
 #define PORT1_POWER             (3 << 3)
 #define PORT1_INIT1             (1 << 7)
 #define PORT1_INIT2             (1 << 23)
+#define HW_OTG_CTRL_SET         0x374
+#define HW_OTG_CTRL_CLR         0x376
 
 /* Interrupt Register */
 #define HC_INTERRUPT_REG        0x310
 
 #define HC_INTERRUPT_ENABLE     0x314
 #define INTERRUPT_ENABLE_MASK   (HC_INTL_INT | HC_ATL_INT | HC_EOT_INT)
-#define FINAL_HW_CONFIG (HW_GLOBAL_INTR_EN | HW_DATA_BUS_32BIT)
 
 #define HC_ISO_INT              (1 << 9)
 #define HC_ATL_INT              (1 << 8)
@@ -122,6 +125,19 @@ typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
 #define isp1760_err(priv, fmt, args...) \
         dev_err(priv_to_hcd(priv)->self.controller, fmt, ##args)
 
+/*
+ * Device flags that can vary from board to board.  All of these
+ * indicate the most "atypical" case, so that a devflags of 0 is
+ * a sane default configuration.
+ */
+#define ISP1760_FLAG_PORT1_DIS          0x00000001 /* Port 1 disabled */
+#define ISP1760_FLAG_BUS_WIDTH_16       0x00000002 /* 16-bit data bus width */
+#define ISP1760_FLAG_OTG_EN             0x00000004 /* Port 1 supports OTG */
+#define ISP1760_FLAG_ANALOG_OC          0x00000008 /* Analog overcurrent */
+#define ISP1760_FLAG_DACK_POL_HIGH      0x00000010 /* DACK active high */
+#define ISP1760_FLAG_DREQ_POL_HIGH      0x00000020 /* DREQ active high */
+#define ISP1760_FLAG_ISP1761            0x00000040 /* Chip is ISP1761 */
+
 /* chip memory management */
 struct memory_chunk {
         unsigned int start;
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index c9db3fe98726..051ef7b6bdc6 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -35,13 +35,15 @@ static int of_isp1760_probe(struct of_device *dev,
         int virq;
         u64 res_len;
         int ret;
+        const unsigned int *prop;
+        unsigned int devflags = 0;
 
         ret = of_address_to_resource(dp, 0, &memory);
         if (ret)
                 return -ENXIO;
 
         res = request_mem_region(memory.start, memory.end - memory.start + 1,
-                        dev->dev.bus_id);
+                        dev_name(&dev->dev));
         if (!res)
                 return -EBUSY;
 
@@ -55,8 +57,32 @@ static int of_isp1760_probe(struct of_device *dev,
         virq = irq_create_of_mapping(oirq.controller, oirq.specifier,
                         oirq.size);
 
+        if (of_device_is_compatible(dp, "nxp,usb-isp1761"))
+                devflags |= ISP1760_FLAG_ISP1761;
+
+        if (of_get_property(dp, "port1-disable", NULL) != NULL)
+                devflags |= ISP1760_FLAG_PORT1_DIS;
+
+        /* Some systems wire up only 16 of the 32 data lines */
+        prop = of_get_property(dp, "bus-width", NULL);
+        if (prop && *prop == 16)
+                devflags |= ISP1760_FLAG_BUS_WIDTH_16;
+
+        if (of_get_property(dp, "port1-otg", NULL) != NULL)
+                devflags |= ISP1760_FLAG_OTG_EN;
+
+        if (of_get_property(dp, "analog-oc", NULL) != NULL)
+                devflags |= ISP1760_FLAG_ANALOG_OC;
+
+        if (of_get_property(dp, "dack-polarity", NULL) != NULL)
+                devflags |= ISP1760_FLAG_DACK_POL_HIGH;
+
+        if (of_get_property(dp, "dreq-polarity", NULL) != NULL)
+                devflags |= ISP1760_FLAG_DREQ_POL_HIGH;
+
         hcd = isp1760_register(memory.start, res_len, virq,
-                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev->dev.bus_id);
+                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
+                devflags);
         if (IS_ERR(hcd)) {
                 ret = PTR_ERR(hcd);
                 goto release_reg;
@@ -87,6 +113,9 @@ static struct of_device_id of_isp1760_match[] = {
         {
                 .compatible = "nxp,usb-isp1760",
         },
+        {
+                .compatible = "nxp,usb-isp1761",
+        },
         { },
 };
 MODULE_DEVICE_TABLE(of, of_isp1760_match);
@@ -116,6 +145,7 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
         int length;
         int status = 1;
         struct usb_hcd *hcd;
+        unsigned int devflags = 0;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -200,7 +230,8 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
 
         dev->dev.dma_mask = NULL;
         hcd = isp1760_register(pci_mem_phy0, length, dev->irq,
-                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev->dev.bus_id);
+                IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
+                devflags);
         pci_set_drvdata(dev, hcd);
         if (!hcd)
                 return 0;
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index e534f9de0f05..a5d8e550d897 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -91,7 +91,7 @@ static void at91_stop_hc(struct platform_device *pdev)
 
 /*-------------------------------------------------------------------------*/
 
-static int usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
+static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
 
 /* configure so an HC device and id are always provided */
 /* always called with process context; sleeping is OK */
@@ -184,13 +184,14 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
  * context, "rmmod" or something similar.
  *
  */
-static int usb_hcd_at91_remove(struct usb_hcd *hcd,
+static void usb_hcd_at91_remove(struct usb_hcd *hcd,
                                 struct platform_device *pdev)
 {
         usb_remove_hcd(hcd);
         at91_stop_hc(pdev);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
 
         if (cpu_is_at91sam9261())
                 clk_put(hclk);
@@ -199,7 +200,6 @@ static int usb_hcd_at91_remove(struct usb_hcd *hcd,
         fclk = iclk = hclk = NULL;
 
         dev_set_drvdata(&pdev->dev, NULL);
-        return 0;
 }
 
 /*-------------------------------------------------------------------------*/
@@ -309,7 +309,8 @@ static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
         }
 
         device_init_wakeup(&pdev->dev, 0);
-        return usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
+        usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
+        return 0;
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 68c17f5ea8ea..c0948008fe3d 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -34,7 +34,8 @@
 #ifdef __LITTLE_ENDIAN
 #define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C)
 #elif __BIG_ENDIAN
-#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C | USBH_ENABLE_BE)
+#define USBH_ENABLE_INIT (USBH_ENABLE_CE | USBH_ENABLE_E | USBH_ENABLE_C | \
+                          USBH_ENABLE_BE)
 #else
 #error not byte order defined
 #endif
@@ -46,213 +47,87 @@
 #define USB_MCFG_RDCOMB   (1<<30)
 #define USB_MCFG_SSDEN    (1<<23)
 #define USB_MCFG_OHCCLKEN (1<<16)
+#ifdef CONFIG_DMA_COHERENT
 #define USB_MCFG_UCAM     (1<<7)
+#else
+#define USB_MCFG_UCAM     (0)
+#endif
 #define USB_MCFG_OBMEN    (1<<1)
 #define USB_MCFG_OMEMEN   (1<<0)
 
 #define USBH_ENABLE_CE    USB_MCFG_OHCCLKEN
-#ifdef CONFIG_DMA_COHERENT
-#define USBH_ENABLE_INIT  (USB_MCFG_OHCCLKEN \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN | USB_MCFG_UCAM \
-                         | USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
-#else
-#define USBH_ENABLE_INIT  (USB_MCFG_OHCCLKEN \
-                         | USB_MCFG_PFEN | USB_MCFG_RDCOMB \
-                         | USB_MCFG_SSDEN \
-                         | USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
-#endif
+
+#define USBH_ENABLE_INIT  (USB_MCFG_PFEN  | USB_MCFG_RDCOMB     |       \
+                           USBH_ENABLE_CE | USB_MCFG_SSDEN      |       \
+                           USB_MCFG_UCAM  |                             \
+                           USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
+
 #define USBH_DISABLE      (USB_MCFG_OBMEN | USB_MCFG_OMEMEN)
 
 #endif  /* Au1200 */
 
 extern int usb_disabled(void);
 
-/*-------------------------------------------------------------------------*/
-
-static void au1xxx_start_ohc(struct platform_device *dev)
+static void au1xxx_start_ohc(void)
 {
-        printk(KERN_DEBUG __FILE__
-                ": starting Au1xxx OHCI USB Controller\n");
-
         /* enable host controller */
-
 #ifndef CONFIG_SOC_AU1200
-
         au_writel(USBH_ENABLE_CE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
-        au_writel(USBH_ENABLE_INIT, USB_HOST_CONFIG);
-        udelay(1000);
-
-#else   /* Au1200 */
 
-        /* write HW defaults again in case Yamon cleared them */
-        if (au_readl(USB_HOST_CONFIG) == 0) {
-                au_writel(0x00d02000, USB_HOST_CONFIG);
-                au_readl(USB_HOST_CONFIG);
-                udelay(1000);
-        }
-        au_writel(USBH_ENABLE_CE | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
-        au_writel(USBH_ENABLE_INIT | au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
-        udelay(1000);
-
-#endif  /* Au1200 */
 
-#ifndef CONFIG_SOC_AU1200
         /* wait for reset complete (read register twice; see au1500 errata) */
         while (au_readl(USB_HOST_CONFIG),
                 !(au_readl(USB_HOST_CONFIG) & USBH_ENABLE_RD))
-#endif
                 udelay(1000);
 
-        printk(KERN_DEBUG __FILE__
-        ": Clock to USB host has been enabled \n");
-}
-
-static void au1xxx_stop_ohc(struct platform_device *dev)
-{
-        printk(KERN_DEBUG __FILE__
-               ": stopping Au1xxx OHCI USB Controller\n");
-
-#ifndef CONFIG_SOC_AU1200
-
-        /* Disable clock */
-        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_ENABLE_CE, USB_HOST_CONFIG);
-
 #else   /* Au1200 */
-
-        /* Disable mem */
-        au_writel(~USBH_DISABLE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_CE, USB_HOST_CONFIG);
+        au_sync();
         udelay(1000);
-        /* Disable clock */
-        au_writel(~USBH_ENABLE_CE & au_readl(USB_HOST_CONFIG), USB_HOST_CONFIG);
-        au_readl(USB_HOST_CONFIG);
+
+        au_writel(au_readl(USB_HOST_CONFIG) | USBH_ENABLE_INIT, USB_HOST_CONFIG);
+        au_sync();
+        udelay(2000);
 #endif  /* Au1200 */
 }
 
-
-/*-------------------------------------------------------------------------*/
-
-/* configure so an HC device and id are always provided */
-/* always called with process context; sleeping is OK */
-
-
-/**
- * usb_ohci_au1xxx_probe - initialize Au1xxx-based 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.
- *
- */
-static int usb_ohci_au1xxx_probe(const struct hc_driver *driver,
-                          struct platform_device *dev)
+static void au1xxx_stop_ohc(void)
 {
-        int retval;
-        struct usb_hcd *hcd;
-
-#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
-        /* Au1200 AB USB does not support coherent memory */
-        if (!(read_c0_prid() & 0xff)) {
-                pr_info("%s: this is chip revision AB !!\n",
-                        dev->name);
-                pr_info("%s: update your board or re-configure the kernel\n",
-                        dev->name);
-                return -ENODEV;
-        }
+#ifdef CONFIG_SOC_AU1200
+        /* Disable mem */
+        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_DISABLE, USB_HOST_CONFIG);
+        au_sync();
+        udelay(1000);
 #endif
-
-        if (dev->resource[1].flags != IORESOURCE_IRQ) {
-                pr_debug("resource[1] is not IORESOURCE_IRQ\n");
-                return -ENOMEM;
-        }
-
-        hcd = usb_create_hcd(driver, &dev->dev, "au1xxx");
-        if (!hcd)
-                return -ENOMEM;
-        hcd->rsrc_start = dev->resource[0].start;
-        hcd->rsrc_len = dev->resource[0].end - dev->resource[0].start + 1;
-
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug("request_mem_region failed\n");
-                retval = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                pr_debug("ioremap failed\n");
-                retval = -ENOMEM;
-                goto err2;
-        }
-
-        au1xxx_start_ohc(dev);
-        ohci_hcd_init(hcd_to_ohci(hcd));
-
-        retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED | IRQF_SHARED);
-        if (retval == 0)
-                return retval;
-
-        au1xxx_stop_ohc(dev);
-        iounmap(hcd->regs);
- err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
- err1:
-        usb_put_hcd(hcd);
-        return retval;
-}
-
-
-/* may be called without controller electrically present */
-/* may be called with controller, bus, and devices active */
-
-/**
- * usb_hcd_au1xxx_remove - shutdown processing for Au1xxx-based HCDs
- * @dev: USB Host Controller being removed
- * Context: !in_interrupt()
- *
- * Reverses the effect of usb_hcd_au1xxx_probe(), first invoking
- * the HCD's stop() method.  It is always called from a thread
- * context, normally "rmmod", "apmd", or something similar.
- *
- */
-static void usb_ohci_au1xxx_remove(struct usb_hcd *hcd, struct platform_device *dev)
-{
-        usb_remove_hcd(hcd);
-        au1xxx_stop_ohc(dev);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-        usb_put_hcd(hcd);
+        /* Disable clock */
+        au_writel(au_readl(USB_HOST_CONFIG) & ~USBH_ENABLE_CE, USB_HOST_CONFIG);
+        au_sync();
 }
 
-/*-------------------------------------------------------------------------*/
-
-static int __devinit
-ohci_au1xxx_start (struct usb_hcd *hcd)
+static int __devinit ohci_au1xxx_start(struct usb_hcd *hcd)
 {
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ret;
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        int ret;
 
-        ohci_dbg (ohci, "ohci_au1xxx_start, ohci:%p", ohci);
+        ohci_dbg(ohci, "ohci_au1xxx_start, ohci:%p", ohci);
 
-        if ((ret = ohci_init (ohci)) < 0)
+        if ((ret = ohci_init(ohci)) < 0)
                 return ret;
 
-        if ((ret = ohci_run (ohci)) < 0) {
+        if ((ret = ohci_run(ohci)) < 0) {
                 err ("can't start %s", hcd->self.bus_name);
-                ohci_stop (hcd);
+                ohci_stop(hcd);
                 return ret;
         }
 
         return 0;
 }
 
-/*-------------------------------------------------------------------------*/
-
 static const struct hc_driver ohci_au1xxx_hc_driver = {
         .description =          hcd_name,
         .product_desc =         "Au1xxx OHCI",
@@ -296,18 +171,66 @@ static const struct hc_driver ohci_au1xxx_hc_driver = {
         .start_port_reset =     ohci_start_port_reset,
 };
 
-/*-------------------------------------------------------------------------*/
-
 static int ohci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
 {
         int ret;
-
-        pr_debug ("In ohci_hcd_au1xxx_drv_probe");
+        struct usb_hcd *hcd;
 
         if (usb_disabled())
                 return -ENODEV;
 
-        ret = usb_ohci_au1xxx_probe(&ohci_au1xxx_hc_driver, pdev);
+#if defined(CONFIG_SOC_AU1200) && defined(CONFIG_DMA_COHERENT)
+        /* Au1200 AB USB does not support coherent memory */
+        if (!(read_c0_prid() & 0xff)) {
+                printk(KERN_INFO "%s: this is chip revision AB !!\n",
+                        pdev->name);
+                printk(KERN_INFO "%s: update your board or re-configure "
+                                 "the kernel\n", pdev->name);
+                return -ENODEV;
+        }
+#endif
+
+        if (pdev->resource[1].flags != IORESOURCE_IRQ) {
+                pr_debug("resource[1] is not IORESOURCE_IRQ\n");
+                return -ENOMEM;
+        }
+
+        hcd = usb_create_hcd(&ohci_au1xxx_hc_driver, &pdev->dev, "au1xxx");
+        if (!hcd)
+                return -ENOMEM;
+
+        hcd->rsrc_start = pdev->resource[0].start;
+        hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_debug("request_mem_region failed\n");
+                ret = -EBUSY;
+                goto err1;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_debug("ioremap failed\n");
+                ret = -ENOMEM;
+                goto err2;
+        }
+
+        au1xxx_start_ohc();
+        ohci_hcd_init(hcd_to_ohci(hcd));
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start,
+                          IRQF_DISABLED | IRQF_SHARED);
+        if (ret == 0) {
+                platform_set_drvdata(pdev, hcd);
+                return ret;
+        }
+
+        au1xxx_stop_ohc();
+        iounmap(hcd->regs);
+err2:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err1:
+        usb_put_hcd(hcd);
         return ret;
 }
 
@@ -315,30 +238,78 @@ static int ohci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
-        usb_ohci_au1xxx_remove(hcd, pdev);
+        usb_remove_hcd(hcd);
+        au1xxx_stop_ohc();
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
-        /*TBD*/
-/*static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *dev)
+
+#ifdef CONFIG_PM
+static int ohci_hcd_au1xxx_drv_suspend(struct platform_device *pdev,
+                                        pm_message_t message)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        unsigned long flags;
+        int rc;
+
+        rc = 0;
+
+        /* Root hub was already suspended. Disable irq emission and
+         * mark HW unaccessible, bail out if RH has been resumed. Use
+         * the spinlock to properly synchronize with possible pending
+         * RH suspend or resume activity.
+         *
+         * This is still racy as hcd->state is manipulated outside of
+         * any locks =P But that will be a different fix.
+         */
+        spin_lock_irqsave(&ohci->lock, flags);
+        if (hcd->state != HC_STATE_SUSPENDED) {
+                rc = -EINVAL;
+                goto bail;
+        }
+        ohci_writel(ohci, OHCI_INTR_MIE, &ohci->regs->intrdisable);
+        (void)ohci_readl(ohci, &ohci->regs->intrdisable);
 
-        return 0;
+        /* make sure snapshot being resumed re-enumerates everything */
+        if (message.event == PM_EVENT_PRETHAW)
+                ohci_usb_reset(ohci);
+
+        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+
+        au1xxx_stop_ohc();
+bail:
+        spin_unlock_irqrestore(&ohci->lock, flags);
+
+        return rc;
 }
-static int ohci_hcd_au1xxx_drv_resume(struct platform_device *dev)
+
+static int ohci_hcd_au1xxx_drv_resume(struct platform_device *pdev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        au1xxx_start_ohc();
+
+        set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        ohci_finish_controller_resume(hcd);
 
         return 0;
 }
-*/
+#else
+#define ohci_hcd_au1xxx_drv_suspend NULL
+#define ohci_hcd_au1xxx_drv_resume NULL
+#endif
 
 static struct platform_driver ohci_hcd_au1xxx_driver = {
         .probe          = ohci_hcd_au1xxx_drv_probe,
         .remove         = ohci_hcd_au1xxx_drv_remove,
         .shutdown       = usb_hcd_platform_shutdown,
-        /*.suspend      = ohci_hcd_au1xxx_drv_suspend, */
-        /*.resume       = ohci_hcd_au1xxx_drv_resume, */
+        .suspend        = ohci_hcd_au1xxx_drv_suspend,
+        .resume         = ohci_hcd_au1xxx_drv_resume,
         .driver         = {
                 .name   = "au1xxx-ohci",
                 .owner  = THIS_MODULE,
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index e06bfaebec54..7cef1d2f7ccc 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -651,7 +651,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
                 "%s\n"
                 "%s version " DRIVER_VERSION "\n",
                 hcd->self.controller->bus->name,
-                hcd->self.controller->bus_id,
+                dev_name(hcd->self.controller),
                 hcd->product_desc,
                 hcd_name);
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index a8160d65f32b..26bc47941d01 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -974,7 +974,7 @@ MODULE_LICENSE ("GPL");
 #define PCI_DRIVER              ohci_pci_driver
 #endif
 
-#ifdef CONFIG_SA1111
+#if defined(CONFIG_ARCH_SA1100) && defined(CONFIG_SA1111)
 #include "ohci-sa1111.c"
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index a19a4f80a6e1..6e5e5f81ac90 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -329,7 +329,7 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
         }
 
 
-        hcd = usb_create_hcd (driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd (driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
                 goto err0;
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index 28b458f20cc3..6ad8f2fc57b9 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -109,8 +109,6 @@ static struct clk *usb_clk;
 
 static int isp1301_probe(struct i2c_adapter *adap);
 static int isp1301_detach(struct i2c_client *client);
-static int isp1301_command(struct i2c_client *client, unsigned int cmd,
-                           void *arg);
 
 static const unsigned short normal_i2c[] =
     { ISP1301_I2C_ADDR, ISP1301_I2C_ADDR + 1, I2C_CLIENT_END };
@@ -123,30 +121,37 @@ static struct i2c_client_address_data addr_data = {
 };
 
 struct i2c_driver isp1301_driver = {
-        .class = I2C_CLASS_HWMON,
+        .driver = {
+                .name = "isp1301_pnx",
+        },
         .attach_adapter = isp1301_probe,
         .detach_client = isp1301_detach,
-        .command = isp1301_command
 };
 
 static int isp1301_attach(struct i2c_adapter *adap, int addr, int kind)
 {
         struct i2c_client *c;
+        int err;
 
         c = kzalloc(sizeof(*c), GFP_KERNEL);
-
         if (!c)
                 return -ENOMEM;
 
-        strcpy(c->name, "isp1301");
+        strlcpy(c->name, "isp1301_pnx", I2C_NAME_SIZE);
         c->flags = 0;
         c->addr = addr;
         c->adapter = adap;
         c->driver = &isp1301_driver;
 
+        err = i2c_attach_client(c);
+        if (err) {
+                kfree(c);
+                return err;
+        }
+
         isp1301_i2c_client = c;
 
-        return i2c_attach_client(c);
+        return 0;
 }
 
 static int isp1301_probe(struct i2c_adapter *adap)
@@ -161,13 +166,6 @@ static int isp1301_detach(struct i2c_client *client)
         return 0;
 }
 
-/* No commands defined */
-static int isp1301_command(struct i2c_client *client, unsigned int cmd,
-                           void *arg)
-{
-        return 0;
-}
-
 static void i2c_write(u8 buf, u8 subaddr)
 {
         char tmpbuf[2];
@@ -389,7 +387,7 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
         while ((__raw_readl(USB_OTG_CLK_STAT) & USB_CLOCK_MASK) !=
                USB_CLOCK_MASK) ;
 
-        hcd = usb_create_hcd (driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd (driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 err("Failed to allocate HC buffer");
                 ret = -ENOMEM;
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index a67252791223..91e6e101a4cc 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -14,8 +14,8 @@
  */
 
 #include <linux/signal.h>
+#include <linux/of_platform.h>
 
-#include <asm/of_platform.h>
 #include <asm/prom.h>
 
 
diff --git a/drivers/usb/host/ohci-ps3.c b/drivers/usb/host/ohci-ps3.c
index c1935ae537f8..55c95647f008 100644
--- a/drivers/usb/host/ohci-ps3.c
+++ b/drivers/usb/host/ohci-ps3.c
@@ -129,7 +129,7 @@ static int ps3_ohci_probe(struct ps3_system_bus_device *dev)
 
         dev->core.dma_mask = &dummy_mask; /* FIXME: for improper usb code */
 
-        hcd = usb_create_hcd(&ps3_ohci_hc_driver, &dev->core, dev->core.bus_id);
+        hcd = usb_create_hcd(&ps3_ohci_hc_driver, &dev->core, dev_name(&dev->core));
 
         if (!hcd) {
                 dev_dbg(&dev->core, "%s:%d: usb_create_hcd failed\n", __func__,
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index 9b547407c934..6a9b4c557953 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -159,9 +159,6 @@ static int ed_schedule (struct ohci_hcd *ohci, struct ed *ed)
 {
         int     branch;
 
-        if (ohci_to_hcd(ohci)->state == HC_STATE_QUIESCING)
-                return -EAGAIN;
-
         ed->state = ED_OPER;
         ed->ed_prev = NULL;
         ed->ed_next = NULL;
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index e610698c6b60..21b164e4abeb 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -143,7 +143,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        hcd = usb_create_hcd(driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
                 goto err2;
diff --git a/drivers/usb/host/ohci-ssb.c b/drivers/usb/host/ohci-ssb.c
index 7275186db315..3660c83d80af 100644
--- a/drivers/usb/host/ohci-ssb.c
+++ b/drivers/usb/host/ohci-ssb.c
@@ -113,7 +113,7 @@ static int ssb_ohci_attach(struct ssb_device *dev)
         ssb_device_enable(dev, flags);
 
         hcd = usb_create_hcd(&ssb_ohci_hc_driver, dev->dev,
-                        dev->dev->bus_id);
+                        dev_name(dev->dev));
         if (!hcd)
                 goto err_dev_disable;
         ohcidev = hcd_to_ssb_ohci(hcd);
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 16667342b3c3..d5f02dddb120 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -312,9 +312,9 @@ static void put_child_connect_map(struct r8a66597 *r8a66597, int address)
 static void set_pipe_reg_addr(struct r8a66597_pipe *pipe, u8 dma_ch)
 {
         u16 pipenum = pipe->info.pipenum;
-        unsigned long fifoaddr[] = {D0FIFO, D1FIFO, CFIFO};
-        unsigned long fifosel[] = {D0FIFOSEL, D1FIFOSEL, CFIFOSEL};
-        unsigned long fifoctr[] = {D0FIFOCTR, D1FIFOCTR, CFIFOCTR};
+        const unsigned long fifoaddr[] = {D0FIFO, D1FIFO, CFIFO};
+        const unsigned long fifosel[] = {D0FIFOSEL, D1FIFOSEL, CFIFOSEL};
+        const unsigned long fifoctr[] = {D0FIFOCTR, D1FIFOCTR, CFIFOCTR};
 
         if (dma_ch > R8A66597_PIPE_NO_DMA)      /* dma fifo not use? */
                 dma_ch = R8A66597_PIPE_NO_DMA;
@@ -863,6 +863,32 @@ static void disable_r8a66597_pipe_all(struct r8a66597 *r8a66597,
         dev->dma_map = 0;
 }
 
+static u16 get_interval(struct urb *urb, __u8 interval)
+{
+        u16 time = 1;
+        int i;
+
+        if (urb->dev->speed == USB_SPEED_HIGH) {
+                if (interval > IITV)
+                        time = IITV;
+                else
+                        time = interval ? interval - 1 : 0;
+        } else {
+                if (interval > 128) {
+                        time = IITV;
+                } else {
+                        /* calculate the nearest value for PIPEPERI */
+                        for (i = 0; i < 7; i++) {
+                                if ((1 << i) < interval &&
+                                    (1 << (i + 1) > interval))
+                                        time = 1 << i;
+                        }
+                }
+        }
+
+        return time;
+}
+
 static unsigned long get_timer_interval(struct urb *urb, __u8 interval)
 {
         __u8 i;
@@ -901,10 +927,7 @@ static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
                 info.interval = 0;
                 info.timer_interval = 0;
         } else {
-                if (ep->bInterval > IITV)
-                        info.interval = IITV;
-                else
-                        info.interval = ep->bInterval ? ep->bInterval - 1 : 0;
+                info.interval = get_interval(urb, ep->bInterval);
                 info.timer_interval = get_timer_interval(urb, ep->bInterval);
         }
         if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
@@ -2244,6 +2267,7 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         struct r8a66597 *r8a66597;
         int ret = 0;
         int i;
+        unsigned long irq_trigger;
 
         if (pdev->dev.dma_mask) {
                 ret = -EINVAL;
@@ -2302,7 +2326,11 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&r8a66597->child_device);
 
         hcd->rsrc_start = res->start;
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+        if (irq_sense == INTL)
+                irq_trigger = IRQF_TRIGGER_LOW;
+        else
+                irq_trigger = IRQF_TRIGGER_FALLING;
+        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
         if (ret != 0) {
                 err("Failed to add hcd");
                 goto clean_up;
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 426575247b23..340d72da554a 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1674,7 +1674,7 @@ sl811h_probe(struct platform_device *dev)
         }
 
         /* allocate and initialize hcd */
-        hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev->dev.bus_id);
+        hcd = usb_create_hcd(&sl811h_hc_driver, &dev->dev, dev_name(&dev->dev));
         if (!hcd) {
                 retval = -ENOMEM;
                 goto err5;
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index 9b6323f768b2..20ad3c48fcb2 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -3124,7 +3124,7 @@ static int __devinit u132_probe(struct platform_device *pdev)
         if (pdev->dev.dma_mask)
                 return -EINVAL;
 
-        hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, pdev->dev.bus_id);
+        hcd = usb_create_hcd(&u132_hc_driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 printk(KERN_ERR "failed to create the usb hcd struct for U132\n"
                         );
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 8e4427aebb14..885b585360b9 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -12,7 +12,7 @@
  * (C) Copyright 2004 Alan Stern, stern@rowland.harvard.edu
  */
 
-static __u8 root_hub_hub_des[] =
+static const __u8 root_hub_hub_des[] =
 {
         0x09,                   /*  __u8  bLength; */
         0x29,                   /*  __u8  bDescriptorType; Hub-descriptor */
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index 093938697426..d2f61d5510e7 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -1421,7 +1421,8 @@ ofail:	mutex_unlock(&cp->mutex);
 
 
 /* IOCTL functions */
-static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long auerchar_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         pauerchar_t ccp = (pauerchar_t) file->private_data;
         int ret = 0;
@@ -1452,7 +1453,7 @@ static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int
                 mutex_unlock(&ccp->mutex);
                 return -ENODEV;
         }
-
+        lock_kernel();
         switch (cmd) {
 
         /* return != 0 if Transmitt channel ready to send */
@@ -1547,9 +1548,10 @@ static int auerchar_ioctl (struct inode *inode, struct file *file, unsigned int
 
         default:
                 dbg ("IOCTL_AU_UNKNOWN");
-                ret = -ENOIOCTLCMD;
+                ret = -ENOTTY;
                 break;
         }
+        unlock_kernel();
         /* release the mutexes */
         mutex_unlock(&cp->mutex);
         mutex_unlock(&ccp->mutex);
@@ -1860,7 +1862,7 @@ static const struct file_operations auerswald_fops =
         .llseek =       no_llseek,
         .read =         auerchar_read,
         .write =        auerchar_write,
-        .ioctl =        auerchar_ioctl,
+        .unlocked_ioctl = auerchar_ioctl,
         .open =         auerchar_open,
         .release =      auerchar_release,
 };
diff --git a/drivers/usb/misc/emi62.c b/drivers/usb/misc/emi62.c
index 20886c21e739..5d859ded5bbf 100644
--- a/drivers/usb/misc/emi62.c
+++ b/drivers/usb/misc/emi62.c
@@ -6,8 +6,6 @@
  * 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, version 2.
- * 
- * $Id: emi62.c,v 1.15 2002/04/23 06:13:59 tapio Exp $
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index ec88b3bfee46..97c280971532 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -656,29 +656,6 @@ static int ftdi_elan_release(struct inode *inode, struct file *file)
 }
 
 
-#define FTDI_ELAN_IOC_MAGIC 0xA1
-#define FTDI_ELAN_IOCDEBUG _IOC(_IOC_WRITE, FTDI_ELAN_IOC_MAGIC, 1, 132)
-static int ftdi_elan_ioctl(struct inode *inode, struct file *file,
-        unsigned int cmd, unsigned long arg)
-{
-        switch (cmd) {
-        case FTDI_ELAN_IOCDEBUG:{
-                        char line[132];
-                        int size = strncpy_from_user(line,
-                                (const char __user *)arg, sizeof(line));
-                        if (size < 0) {
-                                return -EINVAL;
-                        } else {
-                                printk(KERN_ERR "TODO: ioctl %s\n", line);
-                                return 0;
-                        }
-                }
-        default:
-                return -EFAULT;
-        }
-}
-
-
 /*
 *
 * blocking bulk reads are used to get data from the device
@@ -1222,7 +1199,6 @@ error_1:
 static const struct file_operations ftdi_elan_fops = {
         .owner = THIS_MODULE,
         .llseek = no_llseek,
-        .ioctl = ftdi_elan_ioctl,
         .read = ftdi_elan_read,
         .write = ftdi_elan_write,
         .open = ftdi_elan_open,
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 1cb54a28347f..e6ca9979e3ae 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -474,8 +474,8 @@ exit:
 /**
  *      iowarrior_ioctl
  */
-static int iowarrior_ioctl(struct inode *inode, struct file *file,
-                           unsigned int cmd, unsigned long arg)
+static long iowarrior_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
 {
         struct iowarrior *dev = NULL;
         __u8 *buffer;
@@ -493,6 +493,7 @@ static int iowarrior_ioctl(struct inode *inode, struct file *file,
                 return -ENOMEM;
 
         /* lock this object */
+        lock_kernel();
         mutex_lock(&dev->mutex);
 
         /* verify that the device wasn't unplugged */
@@ -584,6 +585,7 @@ static int iowarrior_ioctl(struct inode *inode, struct file *file,
 error_out:
         /* unlock the device */
         mutex_unlock(&dev->mutex);
+        unlock_kernel();
         kfree(buffer);
         return retval;
 }
@@ -719,7 +721,7 @@ static const struct file_operations iowarrior_fops = {
         .owner = THIS_MODULE,
         .write = iowarrior_write,
         .read = iowarrior_read,
-        .ioctl = iowarrior_ioctl,
+        .unlocked_ioctl = iowarrior_ioctl,
         .open = iowarrior_open,
         .release = iowarrior_release,
         .poll = iowarrior_poll,
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index 330c18e390b8..248a12aacef6 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -104,9 +104,7 @@ static int close_rio(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int
-ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
-          unsigned long arg)
+static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct RioCommand rio_cmd;
         struct rio_usb_data *rio = &rio_instance;
@@ -116,6 +114,7 @@ ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
         int retries;
         int retval=0;
 
+        lock_kernel();
         mutex_lock(&(rio->lock));
         /* Sanity check to make sure rio is connected, powered, etc */
         if (rio->present == 0 || rio->rio_dev == NULL) {
@@ -254,6 +253,7 @@ ioctl_rio(struct inode *inode, struct file *file, unsigned int cmd,
 
 err_out:
         mutex_unlock(&(rio->lock));
+        unlock_kernel();
         return retval;
 }
 
@@ -433,7 +433,7 @@ file_operations usb_rio_fops = {
         .owner =        THIS_MODULE,
         .read =         read_rio,
         .write =        write_rio,
-        .ioctl =        ioctl_rio,
+        .unlocked_ioctl = ioctl_rio,
         .open =         open_rio,
         .release =      close_rio,
 };
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 33182f4c2267..fbace41a7cba 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -2982,9 +2982,8 @@ sisusb_handle_command(struct sisusb_usb_data *sisusb, struct sisusb_command *y,
         return retval;
 }
 
-static int
-sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
-                                                        unsigned long arg)
+static long
+sisusb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct sisusb_usb_data *sisusb;
         struct sisusb_info x;
@@ -2995,6 +2994,7 @@ sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
         if (!(sisusb = (struct sisusb_usb_data *)file->private_data))
                 return -ENODEV;
 
+        lock_kernel();
         mutex_lock(&sisusb->lock);
 
         /* Sanity check */
@@ -3053,6 +3053,7 @@ sisusb_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
 
 err_out:
         mutex_unlock(&sisusb->lock);
+        unlock_kernel();
         return retval;
 }
 
@@ -3066,9 +3067,7 @@ sisusb_compat_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
                 case SISUSB_GET_CONFIG_SIZE:
                 case SISUSB_GET_CONFIG:
                 case SISUSB_COMMAND:
-                        lock_kernel();
-                        retval = sisusb_ioctl(f->f_path.dentry->d_inode, f, cmd, arg);
-                        unlock_kernel();
+                        retval = sisusb_ioctl(f, cmd, arg);
                         return retval;
 
                 default:
@@ -3087,7 +3086,7 @@ static const struct file_operations usb_sisusb_fops = {
 #ifdef SISUSB_NEW_CONFIG_COMPAT
         .compat_ioctl = sisusb_compat_ioctl,
 #endif
-        .ioctl =        sisusb_ioctl
+        .unlocked_ioctl = sisusb_ioctl
 };
 
 static struct usb_class_driver usb_sisusb_class = {
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 7f7021ee4189..2db4228fbb01 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -146,7 +146,7 @@ static ssize_t lcd_read(struct file *file, char __user * buffer, size_t count, l
         return retval;
 }
 
-static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
+static long lcd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         struct usb_lcd *dev;
         u16 bcdDevice;
@@ -158,12 +158,14 @@ static int lcd_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
         
         switch (cmd) {
         case IOCTL_GET_HARD_VERSION:
+                lock_kernel();
                 bcdDevice = le16_to_cpu((dev->udev)->descriptor.bcdDevice);
                 sprintf(buf,"%1d%1d.%1d%1d",
                         (bcdDevice & 0xF000)>>12,
                         (bcdDevice & 0xF00)>>8,
                         (bcdDevice & 0xF0)>>4,
                         (bcdDevice & 0xF));
+                unlock_kernel();
                 if (copy_to_user((void __user *)arg,buf,strlen(buf))!=0)
                         return -EFAULT;
                 break;
@@ -272,7 +274,7 @@ static const struct file_operations lcd_fops = {
         .read =         lcd_read,
         .write =        lcd_write,
         .open =         lcd_open,
-        .ioctl =        lcd_ioctl,
+        .unlocked_ioctl = lcd_ioctl,
         .release =      lcd_release,
 };
 
diff --git a/drivers/usb/mon/mon_stat.c b/drivers/usb/mon/mon_stat.c
index c7a595cd648a..ac8b0d5ce7f8 100644
--- a/drivers/usb/mon/mon_stat.c
+++ b/drivers/usb/mon/mon_stat.c
@@ -9,6 +9,7 @@
 
 #include <linux/kernel.h>
 #include <linux/usb.h>
+#include <linux/fs.h>
 #include <asm/uaccess.h>
 
 #include "usb_mon.h"
@@ -42,19 +43,8 @@ static ssize_t mon_stat_read(struct file *file, char __user *buf,
                                 size_t nbytes, loff_t *ppos)
 {
         struct snap *sp = file->private_data;
-        loff_t pos = *ppos;
-        int cnt;
 
-        if (pos < 0 || pos >= sp->slen)
-                return 0;
-        if (nbytes == 0)
-                return 0;
-        if ((cnt = sp->slen - pos) > nbytes)
-                cnt = nbytes;
-        if (copy_to_user(buf, sp->str + pos, cnt))
-                return -EFAULT;
-        *ppos = pos + cnt;
-        return cnt;
+        return simple_read_from_buffer(buf, nbytes, ppos, sp->str, sp->slen);
 }
 
 static int mon_stat_release(struct inode *inode, struct file *file)
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 9a7681b55266..8878c1767fc8 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -64,14 +64,6 @@ config USB_SERIAL_AIRCABLE
             To compile this driver as a module, choose M here: the module
             will be called aircable.
 
-config USB_SERIAL_AIRPRIME
-        tristate "USB AirPrime CDMA Wireless Driver"
-        help
-          Say Y here if you want to use a AirPrime CDMA Wireless PC card.
-
-          To compile this driver as a module, choose M here: the
-          module will be called airprime.
-
 config USB_SERIAL_ARK3116
         tristate "USB ARK Micro 3116 USB Serial Driver"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 17a762ab6769..6047f818adfe 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -12,7 +12,6 @@ usbserial-obj-$(CONFIG_USB_EZUSB)		+= ezusb.o
 usbserial-objs  := usb-serial.o generic.o bus.o $(usbserial-obj-y)
 
 obj-$(CONFIG_USB_SERIAL_AIRCABLE)               += aircable.o
-obj-$(CONFIG_USB_SERIAL_AIRPRIME)               += airprime.o
 obj-$(CONFIG_USB_SERIAL_ARK3116)                += ark3116.o
 obj-$(CONFIG_USB_SERIAL_BELKIN)                 += belkin_sa.o
 obj-$(CONFIG_USB_SERIAL_CH341)                  += ch341.o
diff --git a/drivers/usb/serial/airprime.c b/drivers/usb/serial/airprime.c
deleted file mode 100644
index 0798c14ce787..000000000000
--- a/drivers/usb/serial/airprime.c
+++ /dev/null
@@ -1,353 +0,0 @@
-/*
- * AirPrime CDMA Wireless Serial USB driver
- *
- * Copyright (C) 2005-2006 Greg Kroah-Hartman <gregkh@suse.de>
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License version
- *      2 as published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/tty.h>
-#include <linux/tty_flip.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include <linux/usb/serial.h>
-
-static struct usb_device_id id_table [] = {
-        { USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera Wireless KPC650/Passport */
-        { },
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-
-#define URB_TRANSFER_BUFFER_SIZE        4096
-#define NUM_READ_URBS                   4
-#define NUM_WRITE_URBS                  4
-#define NUM_BULK_EPS                    3
-#define MAX_BULK_EPS                    6
-
-/* if overridden by the user, then use their value for the size of the
- * read and write urbs, and the number of endpoints */
-static int buffer_size = URB_TRANSFER_BUFFER_SIZE;
-static int endpoints = NUM_BULK_EPS;
-static int debug;
-struct airprime_private {
-        spinlock_t lock;
-        int outstanding_urbs;
-        int throttled;
-        struct urb *read_urbp[NUM_READ_URBS];
-
-        /* Settings for the port */
-        int rts_state;  /* Handshaking pins (outputs) */
-        int dtr_state;
-        int cts_state;  /* Handshaking pins (inputs) */
-        int dsr_state;
-        int dcd_state;
-        int ri_state;
-};
-
-static int airprime_send_setup(struct usb_serial_port *port)
-{
-        struct usb_serial *serial = port->serial;
-        struct airprime_private *priv;
-
-        dbg("%s", __func__);
-
-        if (port->number != 0)
-                return 0;
-
-        priv = usb_get_serial_port_data(port);
-
-        if (port->tty) {
-                int val = 0;
-                if (priv->dtr_state)
-                        val |= 0x01;
-                if (priv->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 0;
-}
-
-static void airprime_read_bulk_callback(struct urb *urb)
-{
-        struct usb_serial_port *port = urb->context;
-        unsigned char *data = urb->transfer_buffer;
-        struct tty_struct *tty;
-        int result;
-        int status = urb->status;
-
-        dbg("%s - port %d", __func__, port->number);
-
-        if (status) {
-                dbg("%s - nonzero read bulk status received: %d",
-                    __func__, status);
-                return;
-        }
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                                urb->actual_length, data);
-
-        tty = port->tty;
-        if (tty && urb->actual_length) {
-                tty_insert_flip_string(tty, data, urb->actual_length);
-                tty_flip_buffer_push(tty);
-        }
-
-        result = usb_submit_urb(urb, GFP_ATOMIC);
-        if (result)
-                dev_err(&port->dev,
-                        "%s - failed resubmitting read urb, error %d\n",
-                        __func__, result);
-        return;
-}
-
-static void airprime_write_bulk_callback(struct urb *urb)
-{
-        struct usb_serial_port *port = urb->context;
-        struct airprime_private *priv = usb_get_serial_port_data(port);
-        int status = urb->status;
-        unsigned long flags;
-
-        dbg("%s - port %d", __func__, port->number);
-
-        /* free up the transfer buffer, as usb_free_urb() does not do this */
-        kfree(urb->transfer_buffer);
-
-        if (status)
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
-        spin_lock_irqsave(&priv->lock, flags);
-        --priv->outstanding_urbs;
-        spin_unlock_irqrestore(&priv->lock, flags);
-
-        usb_serial_port_softint(port);
-}
-
-static int airprime_open(struct usb_serial_port *port, struct file *filp)
-{
-        struct airprime_private *priv = usb_get_serial_port_data(port);
-        struct usb_serial *serial = port->serial;
-        struct urb *urb;
-        char *buffer = NULL;
-        int i;
-        int result = 0;
-
-        dbg("%s - port %d", __func__, port->number);
-
-        /* initialize our private data structure if it isn't already created */
-        if (!priv) {
-                priv = kzalloc(sizeof(*priv), GFP_KERNEL);
-                if (!priv) {
-                        result = -ENOMEM;
-                        goto out;
-                }
-                spin_lock_init(&priv->lock);
-                usb_set_serial_port_data(port, priv);
-        }
-
-        /* Set some sane defaults */
-        priv->rts_state = 1;
-        priv->dtr_state = 1;
-
-        for (i = 0; i < NUM_READ_URBS; ++i) {
-                buffer = kmalloc(buffer_size, GFP_KERNEL);
-                if (!buffer) {
-                        dev_err(&port->dev, "%s - out of memory.\n",
-                                __func__);
-                        result = -ENOMEM;
-                        goto errout;
-                }
-                urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (!urb) {
-                        kfree(buffer);
-                        dev_err(&port->dev, "%s - no more urbs?\n",
-                                __func__);
-                        result = -ENOMEM;
-                        goto errout;
-                }
-                usb_fill_bulk_urb(urb, serial->dev,
-                                  usb_rcvbulkpipe(serial->dev,
-                                          port->bulk_out_endpointAddress),
-                                  buffer, buffer_size,
-                                  airprime_read_bulk_callback, port);
-                result = usb_submit_urb(urb, GFP_KERNEL);
-                if (result) {
-                        usb_free_urb(urb);
-                        kfree(buffer);
-                        dev_err(&port->dev,
-                                "%s - failed submitting read urb %d for port %d, error %d\n",
-                                __func__, i, port->number, result);
-                        goto errout;
-                }
-                /* remember this urb so we can kill it when the
-                   port is closed */
-                priv->read_urbp[i] = urb;
-        }
-
-        airprime_send_setup(port);
-
-        goto out;
-
- errout:
-        /* some error happened, cancel any submitted urbs and clean up
-           anything that got allocated successfully */
-
-        while (i-- != 0) {
-                urb = priv->read_urbp[i];
-                buffer = urb->transfer_buffer;
-                usb_kill_urb(urb);
-                usb_free_urb(urb);
-                kfree(buffer);
-        }
-
- out:
-        return result;
-}
-
-static void airprime_close(struct usb_serial_port *port, struct file *filp)
-{
-        struct airprime_private *priv = usb_get_serial_port_data(port);
-        int i;
-
-        dbg("%s - port %d", __func__, port->number);
-
-        priv->rts_state = 0;
-        priv->dtr_state = 0;
-
-        mutex_lock(&port->serial->disc_mutex);
-        if (!port->serial->disconnected)
-                airprime_send_setup(port);
-        mutex_unlock(&port->serial->disc_mutex);
-
-        for (i = 0; i < NUM_READ_URBS; ++i) {
-                usb_kill_urb(priv->read_urbp[i]);
-                kfree(priv->read_urbp[i]->transfer_buffer);
-                usb_free_urb(priv->read_urbp[i]);
-        }
-
-        /* free up private structure */
-        kfree(priv);
-        usb_set_serial_port_data(port, NULL);
-}
-
-static int airprime_write(struct usb_serial_port *port,
-                          const unsigned char *buf, int count)
-{
-        struct airprime_private *priv = usb_get_serial_port_data(port);
-        struct usb_serial *serial = port->serial;
-        struct urb *urb;
-        unsigned char *buffer;
-        unsigned long flags;
-        int status;
-        dbg("%s - port %d", __func__, port->number);
-
-        spin_lock_irqsave(&priv->lock, flags);
-        if (priv->outstanding_urbs > NUM_WRITE_URBS) {
-                spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit\n", __func__);
-                return 0;
-        }
-        spin_unlock_irqrestore(&priv->lock, flags);
-        buffer = kmalloc(count, GFP_ATOMIC);
-        if (!buffer) {
-                dev_err(&port->dev, "out of memory\n");
-                return -ENOMEM;
-        }
-        urb = usb_alloc_urb(0, GFP_ATOMIC);
-        if (!urb) {
-                dev_err(&port->dev, "no more free urbs\n");
-                kfree(buffer);
-                return -ENOMEM;
-        }
-        memcpy(buffer, buf, count);
-
-        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
-
-        usb_fill_bulk_urb(urb, serial->dev,
-                          usb_sndbulkpipe(serial->dev,
-                                          port->bulk_out_endpointAddress),
-                          buffer, count,
-                          airprime_write_bulk_callback, port);
-
-        /* send it down the pipe */
-        status = usb_submit_urb(urb, GFP_ATOMIC);
-        if (status) {
-                dev_err(&port->dev,
-                        "%s - usb_submit_urb(write bulk) failed with status = %d\n",
-                        __func__, status);
-                count = status;
-                kfree(buffer);
-        } else {
-                spin_lock_irqsave(&priv->lock, flags);
-                ++priv->outstanding_urbs;
-                spin_unlock_irqrestore(&priv->lock, flags);
-        }
-        /* we are done with this urb, so let the host driver
-         * really free it when it is finished with it */
-        usb_free_urb(urb);
-        return count;
-}
-
-static struct usb_driver airprime_driver = {
-        .name =         "airprime",
-        .probe =        usb_serial_probe,
-        .disconnect =   usb_serial_disconnect,
-        .id_table =     id_table,
-        .no_dynamic_id =        1,
-};
-
-static struct usb_serial_driver airprime_device = {
-        .driver = {
-                .owner =        THIS_MODULE,
-                .name =         "airprime",
-        },
-        .usb_driver =           &airprime_driver,
-        .id_table =             id_table,
-        .open =                 airprime_open,
-        .close =                airprime_close,
-        .write =                airprime_write,
-};
-
-static int __init airprime_init(void)
-{
-        int retval;
-
-        airprime_device.num_ports = endpoints;
-        if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
-                airprime_device.num_ports = NUM_BULK_EPS;
-
-        retval = usb_serial_register(&airprime_device);
-        if (retval)
-                return retval;
-        retval = usb_register(&airprime_driver);
-        if (retval)
-                usb_serial_deregister(&airprime_device);
-        return retval;
-}
-
-static void __exit airprime_exit(void)
-{
-        dbg("%s", __func__);
-
-        usb_deregister(&airprime_driver);
-        usb_serial_deregister(&airprime_device);
-}
-
-module_init(airprime_init);
-module_exit(airprime_exit);
-MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled");
-module_param(buffer_size, int, 0);
-MODULE_PARM_DESC(buffer_size,
-                "Size of the transfer buffers in bytes (default 4096)");
-module_param(endpoints, int, 0);
-MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index f5b57b196c5a..2bc5576c443a 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -365,8 +365,8 @@ static void cp2101_close (struct usb_serial_port *port, struct file * filp)
 static void cp2101_get_termios (struct usb_serial_port *port)
 {
         unsigned int cflag, modem_ctl[4];
-        int baud;
-        int bits;
+        unsigned int baud;
+        unsigned int bits;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -498,7 +498,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
                 struct ktermios *old_termios)
 {
         unsigned int cflag, old_cflag;
-        int baud=0, bits;
+        unsigned int baud = 0, bits;
         unsigned int modem_ctl[4];
 
         dbg("%s - port %d", __func__, port->number);
@@ -654,7 +654,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
 static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
                 unsigned int set, unsigned int clear)
 {
-        int control = 0;
+        unsigned int control = 0;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -683,7 +683,8 @@ static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
 
 static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
 {
-        int control, result;
+        unsigned int control;
+        int result;
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -703,7 +704,7 @@ static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
 
 static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
 {
-        int state;
+        unsigned int state;
 
         dbg("%s - port %d", __func__, port->number);
         if (break_state == 0)
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 04a56f300ea6..28bc6fcf44f0 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -229,8 +229,6 @@
 *    in case a wake up is lost.
 *  - Following Documentation/DocBook/kernel-locking.pdf no spin locks
 *    are held when calling copy_to/from_user or printk.
-*    
-*  $Id: digi_acceleport.c,v 1.80.1.2 2000/11/02 05:45:08 root Exp $
 */
 
 #include <linux/kernel.h>
@@ -573,6 +571,7 @@ static struct usb_serial_driver digi_acceleport_4_device = {
 static long cond_wait_interruptible_timeout_irqrestore(
         wait_queue_head_t *q, long timeout,
         spinlock_t *lock, unsigned long flags)
+__releases(lock)
 {
         DEFINE_WAIT(wait);
 
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 61daea3f7b2d..a58822a14a87 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -18,8 +18,8 @@
  *
  * Version history:
  *
- *      July 11, 2002   Removed 4 port device structure since all TI UMP 
- *                      chips have only 2 ports 
+ *      July 11, 2002   Removed 4 port device structure since all TI UMP
+ *                      chips have only 2 ports
  *                      David Iacovelli (davidi@ionetworks.com)
  *
  */
@@ -38,7 +38,7 @@
 #include <linux/serial.h>
 #include <linux/ioctl.h>
 #include <linux/firmware.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
@@ -57,18 +57,19 @@
 
 
 struct edgeport_uart_buf_desc {
-        __u32 count;            // Number of bytes currently in buffer
+        __u32 count;            /* Number of bytes currently in buffer */
 };
 
 /* different hardware types */
 #define HARDWARE_TYPE_930       0
 #define HARDWARE_TYPE_TIUMP     1
 
-// IOCTL_PRIVATE_TI_GET_MODE Definitions
-#define TI_MODE_CONFIGURING     0   // Device has not entered start device 
-#define TI_MODE_BOOT            1   // Staying in boot mode
-#define TI_MODE_DOWNLOAD        2   // Made it to download mode
-#define TI_MODE_TRANSITIONING   3   // Currently in boot mode but transitioning to download mode
+/* IOCTL_PRIVATE_TI_GET_MODE Definitions */
+#define TI_MODE_CONFIGURING     0   /* Device has not entered start device */
+#define TI_MODE_BOOT            1   /* Staying in boot mode                */
+#define TI_MODE_DOWNLOAD        2   /* Made it to download mode            */
+#define TI_MODE_TRANSITIONING   3   /* Currently in boot mode but
+                                       transitioning to download mode      */
 
 /* read urb state */
 #define EDGE_READ_URB_RUNNING   0
@@ -82,10 +83,9 @@ struct edgeport_uart_buf_desc {
 
 
 /* Product information read from the Edgeport */
-struct product_info
-{
-        int     TiMode;                 // Current TI Mode
-        __u8    hardware_type;          // Type of hardware
+struct product_info {
+        int     TiMode;                 /* Current TI Mode  */
+        __u8    hardware_type;          /* Type of hardware */
 } __attribute__((packed));
 
 /* circular buffer */
@@ -116,7 +116,7 @@ struct edgeport_port {
                                                    happen */
         struct edgeport_serial  *edge_serial;
         struct usb_serial_port  *port;
-        __u8 bUartMode;         /* Port type, 0: RS232, etc. */ 
+        __u8 bUartMode;         /* Port type, 0: RS232, etc. */
         spinlock_t ep_lock;
         int ep_read_urb_state;
         int ep_write_urb_in_use;
@@ -125,8 +125,9 @@ struct edgeport_port {
 
 struct edgeport_serial {
         struct product_info product_info;
-        u8 TI_I2C_Type;                 // Type of I2C in UMP
-        u8 TiReadI2C;                   // Set to TRUE if we have read the I2c in Boot Mode
+        u8 TI_I2C_Type;                 /* Type of I2C in UMP */
+        u8 TiReadI2C;                   /* Set to TRUE if we have read the
+                                           I2c in Boot Mode */
         struct mutex es_lock;
         int num_ports_open;
         struct usb_serial *serial;
@@ -214,7 +215,7 @@ static struct usb_device_id id_table_combined [] = {
         { }
 };
 
-MODULE_DEVICE_TABLE (usb, id_table_combined);
+MODULE_DEVICE_TABLE(usb, id_table_combined);
 
 static struct usb_driver io_driver = {
         .name =         "io_ti",
@@ -231,19 +232,19 @@ static unsigned short OperationalBuildNumber;
 
 static int debug;
 
-static int TIStayInBootMode = 0;
 static int low_latency = EDGE_LOW_LATENCY;
 static int closing_wait = EDGE_CLOSING_WAIT;
-static int ignore_cpu_rev = 0;
-static int default_uart_mode = 0;       /* RS232 */
-
+static int ignore_cpu_rev;
+static int default_uart_mode;           /* RS232 */
 
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned char *data, int length);
+static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
+                          unsigned char *data, int length);
 
 static void stop_read(struct edgeport_port *edge_port);
 static int restart_read(struct edgeport_port *edge_port);
 
-static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios);
+static void edge_set_termios(struct usb_serial_port *port,
+                             struct ktermios *old_termios);
 static void edge_send(struct usb_serial_port *port);
 
 /* sysfs attributes */
@@ -262,87 +263,57 @@ static unsigned int edge_buf_get(struct edge_buf *eb, char *buf,
         unsigned int count);
 
 
-static int TIReadVendorRequestSync (struct usb_device *dev,
-                                __u8            request,
-                                __u16           value,
-                                __u16           index,
-                                u8              *data,
-                                int             size)
+static int ti_vread_sync(struct usb_device *dev, __u8 request,
+                                __u16 value, __u16 index, u8 *data, int size)
 {
         int status;
 
-        status = usb_control_msg (dev,
-                                usb_rcvctrlpipe(dev, 0),
-                                request,
-                                (USB_TYPE_VENDOR | 
-                                 USB_RECIP_DEVICE | 
-                                 USB_DIR_IN),
-                                value,
-                                index,
-                                data,
-                                size,
-                                1000);
+        status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
+                        (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN),
+                        value, index, data, size, 1000);
         if (status < 0)
                 return status;
         if (status != size) {
-                dbg ("%s - wanted to write %d, but only wrote %d",
-                     __func__, size, status);
+                dbg("%s - wanted to write %d, but only wrote %d",
+                                             __func__, size, status);
                 return -ECOMM;
         }
         return 0;
 }
 
-static int TISendVendorRequestSync (struct usb_device *dev,
-                                __u8            request,
-                                __u16           value,
-                                __u16           index,
-                                u8              *data,
-                                int             size)
+static int ti_vsend_sync(struct usb_device *dev, __u8 request,
+                                __u16 value, __u16 index, u8 *data, int size)
 {
         int status;
 
-        status = usb_control_msg (dev,
-                                usb_sndctrlpipe(dev, 0),
-                                request,
-                                (USB_TYPE_VENDOR | 
-                                 USB_RECIP_DEVICE | 
-                                 USB_DIR_OUT),
-                                value,
-                                index,
-                                data,
-                                size,
-                                1000);
+        status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
+                        (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT),
+                        value, index, data, size, 1000);
         if (status < 0)
                 return status;
         if (status != size) {
-                dbg ("%s - wanted to write %d, but only wrote %d",
+                dbg("%s - wanted to write %d, but only wrote %d",
                      __func__, size, status);
                 return -ECOMM;
         }
         return 0;
 }
 
-static int TIWriteCommandSync (struct usb_device *dev, __u8 command,
+static int send_cmd(struct usb_device *dev, __u8 command,
                                 __u8 moduleid, __u16 value, u8 *data,
                                 int size)
 {
-        return TISendVendorRequestSync (dev,
-                                          command,                      // Request
-                                          value,                        // wValue 
-                                          moduleid,                     // wIndex
-                                          data,                         // TransferBuffer
-                                          size);                        // TransferBufferLength
-
+        return ti_vsend_sync(dev, command, value, moduleid, data, size);
 }
 
 /* clear tx/rx buffers and fifo in TI UMP */
-static int TIPurgeDataSync (struct usb_serial_port *port, __u16 mask)
+static int purge_port(struct usb_serial_port *port, __u16 mask)
 {
         int port_number = port->number - port->serial->minor;
 
-        dbg ("%s - port %d, mask %x", __func__, port_number, mask);
+        dbg("%s - port %d, mask %x", __func__, port_number, mask);
 
-        return TIWriteCommandSync (port->serial->dev,
+        return send_cmd(port->serial->dev,
                                         UMPC_PURGE_PORT,
                                         (__u8)(UMPM_UART1_PORT + port_number),
                                         mask,
@@ -351,92 +322,87 @@ static int TIPurgeDataSync (struct usb_serial_port *port, __u16 mask)
 }
 
 /**
- * TIReadDownloadMemory - Read edgeport memory from TI chip
+ * read_download_mem - Read edgeport memory from TI chip
  * @dev: usb device pointer
  * @start_address: Device CPU address at which to read
  * @length: Length of above data
  * @address_type: Can read both XDATA and I2C
  * @buffer: pointer to input data buffer
  */
-static int TIReadDownloadMemory(struct usb_device *dev, int start_address,
+static int read_download_mem(struct usb_device *dev, int start_address,
                                 int length, __u8 address_type, __u8 *buffer)
 {
         int status = 0;
         __u8 read_length;
         __be16 be_start_address;
-        
-        dbg ("%s - @ %x for %d", __func__, start_address, length);
+
+        dbg("%s - @ %x for %d", __func__, start_address, length);
 
         /* Read in blocks of 64 bytes
          * (TI firmware can't handle more than 64 byte reads)
          */
         while (length) {
                 if (length > 64)
-                        read_length= 64;
+                        read_length = 64;
                 else
                         read_length = (__u8)length;
 
                 if (read_length > 1) {
-                        dbg ("%s - @ %x for %d", __func__,
+                        dbg("%s - @ %x for %d", __func__,
                              start_address, read_length);
                 }
-                be_start_address = cpu_to_be16 (start_address);
-                status = TIReadVendorRequestSync (dev,
-                                                  UMPC_MEMORY_READ,     // Request
-                                                  (__u16)address_type,  // wValue (Address type)
-                                                  (__force __u16)be_start_address,      // wIndex (Address to read)
-                                                  buffer,               // TransferBuffer
-                                                  read_length); // TransferBufferLength
+                be_start_address = cpu_to_be16(start_address);
+                status = ti_vread_sync(dev, UMPC_MEMORY_READ,
+                                        (__u16)address_type,
+                                        (__force __u16)be_start_address,
+                                        buffer, read_length);
 
                 if (status) {
-                        dbg ("%s - ERROR %x", __func__, status);
+                        dbg("%s - ERROR %x", __func__, status);
                         return status;
                 }
 
-                if (read_length > 1) {
+                if (read_length > 1)
                         usb_serial_debug_data(debug, &dev->dev, __func__,
                                               read_length, buffer);
-                }
 
                 /* Update pointers/length */
                 start_address += read_length;
                 buffer += read_length;
                 length -= read_length;
         }
-        
+
         return status;
 }
 
-static int TIReadRam (struct usb_device *dev, int start_address, int length, __u8 *buffer)
+static int read_ram(struct usb_device *dev, int start_address,
+                                                int length, __u8 *buffer)
 {
-        return TIReadDownloadMemory (dev,
-                                     start_address,
-                                     length,
-                                     DTK_ADDR_SPACE_XDATA,
-                                     buffer);
+        return read_download_mem(dev, start_address, length,
+                                        DTK_ADDR_SPACE_XDATA, buffer);
 }
 
 /* Read edgeport memory to a given block */
-static int TIReadBootMemory (struct edgeport_serial *serial, int start_address, int length, __u8 * buffer)
+static int read_boot_mem(struct edgeport_serial *serial,
+                                int start_address, int length, __u8 *buffer)
 {
         int status = 0;
         int i;
 
-        for (i=0; i< length; i++) {
-                status = TIReadVendorRequestSync (serial->serial->dev,
-                                        UMPC_MEMORY_READ,               // Request
-                                        serial->TI_I2C_Type,            // wValue (Address type)
-                                        (__u16)(start_address+i),       // wIndex
-                                        &buffer[i],                     // TransferBuffer
-                                        0x01);                          // TransferBufferLength
+        for (i = 0; i < length; i++) {
+                status = ti_vread_sync(serial->serial->dev,
+                                UMPC_MEMORY_READ, serial->TI_I2C_Type,
+                                (__u16)(start_address+i), &buffer[i], 0x01);
                 if (status) {
-                        dbg ("%s - ERROR %x", __func__, status);
+                        dbg("%s - ERROR %x", __func__, status);
                         return status;
                 }
         }
 
-        dbg ("%s - start_address = %x, length = %d", __func__, start_address, length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, length, buffer);
+        dbg("%s - start_address = %x, length = %d",
+                                        __func__, start_address, length);
+        usb_serial_debug_data(debug, &serial->serial->dev->dev,
+                                        __func__, length, buffer);
 
         serial->TiReadI2C = 1;
 
@@ -444,7 +410,8 @@ static int TIReadBootMemory (struct edgeport_serial *serial, int start_address,
 }
 
 /* Write given block to TI EPROM memory */
-static int TIWriteBootMemory (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
+static int write_boot_mem(struct edgeport_serial *serial,
+                                int start_address, int length, __u8 *buffer)
 {
         int status = 0;
         int i;
@@ -452,57 +419,58 @@ static int TIWriteBootMemory (struct edgeport_serial *serial, int start_address,
 
         /* Must do a read before write */
         if (!serial->TiReadI2C) {
-                status = TIReadBootMemory(serial, 0, 1, &temp);
+                status = read_boot_mem(serial, 0, 1, &temp);
                 if (status)
                         return status;
         }
 
-        for (i=0; i < length; ++i) {
-                status = TISendVendorRequestSync (serial->serial->dev,
-                                                UMPC_MEMORY_WRITE,              // Request
-                                                buffer[i],                      // wValue
-                                                (__u16)(i+start_address),       // wIndex
-                                                NULL,                           // TransferBuffer
-                                                0);                             // TransferBufferLength
+        for (i = 0; i < length; ++i) {
+                status = ti_vsend_sync(serial->serial->dev,
+                                UMPC_MEMORY_WRITE, buffer[i],
+                                (__u16)(i + start_address), NULL, 0);
                 if (status)
                         return status;
         }
 
-        dbg ("%s - start_sddr = %x, length = %d", __func__, start_address, length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, length, buffer);
+        dbg("%s - start_sddr = %x, length = %d",
+                                        __func__, start_address, length);
+        usb_serial_debug_data(debug, &serial->serial->dev->dev,
+                                        __func__, length, buffer);
 
         return status;
 }
 
 
 /* Write edgeport I2C memory to TI chip */
-static int TIWriteDownloadI2C (struct edgeport_serial *serial, int start_address, int length, __u8 address_type, __u8 *buffer)
+static int write_i2c_mem(struct edgeport_serial *serial,
+                int start_address, int length, __u8 address_type, __u8 *buffer)
 {
         int status = 0;
         int write_length;
         __be16 be_start_address;
 
         /* We can only send a maximum of 1 aligned byte page at a time */
-        
+
         /* calulate the number of bytes left in the first page */
-        write_length = EPROM_PAGE_SIZE - (start_address & (EPROM_PAGE_SIZE - 1));
+        write_length = EPROM_PAGE_SIZE -
+                                (start_address & (EPROM_PAGE_SIZE - 1));
 
         if (write_length > length)
                 write_length = length;
 
-        dbg ("%s - BytesInFirstPage Addr = %x, length = %d", __func__, start_address, write_length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, write_length, buffer);
+        dbg("%s - BytesInFirstPage Addr = %x, length = %d",
+                                        __func__, start_address, write_length);
+        usb_serial_debug_data(debug, &serial->serial->dev->dev,
+                                                __func__, write_length, buffer);
 
         /* Write first page */
-        be_start_address = cpu_to_be16 (start_address);
-        status = TISendVendorRequestSync (serial->serial->dev,
-                                        UMPC_MEMORY_WRITE,      // Request
-                                        (__u16)address_type,    // wValue
-                                        (__force __u16)be_start_address,        // wIndex
-                                        buffer,                 // TransferBuffer
-                                        write_length);
+        be_start_address = cpu_to_be16(start_address);
+        status = ti_vsend_sync(serial->serial->dev,
+                                UMPC_MEMORY_WRITE, (__u16)address_type,
+                                (__force __u16)be_start_address,
+                                buffer, write_length);
         if (status) {
-                dbg ("%s - ERROR %d", __func__, status);
+                dbg("%s - ERROR %d", __func__, status);
                 return status;
         }
 
@@ -510,29 +478,31 @@ static int TIWriteDownloadI2C (struct edgeport_serial *serial, int start_address
         start_address   += write_length;
         buffer          += write_length;
 
-        /* We should be aligned now -- can write max page size bytes at a time */
+        /* We should be aligned now -- can write
+           max page size bytes at a time */
         while (length) {
                 if (length > EPROM_PAGE_SIZE)
                         write_length = EPROM_PAGE_SIZE;
                 else
                         write_length = length;
 
-                dbg ("%s - Page Write Addr = %x, length = %d", __func__, start_address, write_length);
-                usb_serial_debug_data(debug, &serial->serial->dev->dev, __func__, write_length, buffer);
+                dbg("%s - Page Write Addr = %x, length = %d",
+                                        __func__, start_address, write_length);
+                usb_serial_debug_data(debug, &serial->serial->dev->dev,
+                                        __func__, write_length, buffer);
 
                 /* Write next page */
-                be_start_address = cpu_to_be16 (start_address);
-                status = TISendVendorRequestSync (serial->serial->dev,
-                                                UMPC_MEMORY_WRITE,      // Request
-                                                (__u16)address_type,    // wValue
-                                                (__force __u16)be_start_address,        // wIndex
-                                                buffer,                 // TransferBuffer
-                                                write_length);          // TransferBufferLength
+                be_start_address = cpu_to_be16(start_address);
+                status = ti_vsend_sync(serial->serial->dev, UMPC_MEMORY_WRITE,
+                                (__u16)address_type,
+                                (__force __u16)be_start_address,
+                                buffer, write_length);
                 if (status) {
-                        dev_err (&serial->serial->dev->dev, "%s - ERROR %d\n", __func__, status);
+                        dev_err(&serial->serial->dev->dev, "%s - ERROR %d\n",
+                                        __func__, status);
                         return status;
                 }
-                
+
                 length          -= write_length;
                 start_address   += write_length;
                 buffer          += write_length;
@@ -541,25 +511,25 @@ static int TIWriteDownloadI2C (struct edgeport_serial *serial, int start_address
 }
 
 /* Examine the UMP DMA registers and LSR
- * 
+ *
  * Check the MSBit of the X and Y DMA byte count registers.
  * A zero in this bit indicates that the TX DMA buffers are empty
  * then check the TX Empty bit in the UART.
  */
-static int TIIsTxActive (struct edgeport_port *port)
+static int tx_active(struct edgeport_port *port)
 {
         int status;
         struct out_endpoint_desc_block *oedb;
         __u8 *lsr;
         int bytes_left = 0;
 
-        oedb = kmalloc (sizeof (* oedb), GFP_KERNEL);
+        oedb = kmalloc(sizeof(*oedb), GFP_KERNEL);
         if (!oedb) {
-                dev_err (&port->port->dev, "%s - out of memory\n", __func__);
+                dev_err(&port->port->dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
 
-        lsr = kmalloc (1, GFP_KERNEL);  /* Sigh, that's right, just one byte,
+        lsr = kmalloc(1, GFP_KERNEL);   /* Sigh, that's right, just one byte,
                                            as not all platforms can do DMA
                                            from stack */
         if (!lsr) {
@@ -567,43 +537,39 @@ static int TIIsTxActive (struct edgeport_port *port)
                 return -ENOMEM;
         }
         /* Read the DMA Count Registers */
-        status = TIReadRam (port->port->serial->dev,
-                            port->dma_address,
-                            sizeof( *oedb),
-                            (void *)oedb);
-
+        status = read_ram(port->port->serial->dev, port->dma_address,
+                                                sizeof(*oedb), (void *)oedb);
         if (status)
                 goto exit_is_tx_active;
 
-        dbg ("%s - XByteCount    0x%X", __func__, oedb->XByteCount);
+        dbg("%s - XByteCount    0x%X", __func__, oedb->XByteCount);
 
         /* and the LSR */
-        status = TIReadRam (port->port->serial->dev, 
-                            port->uart_base + UMPMEM_OFFS_UART_LSR,
-                            1,
-                            lsr);
+        status = read_ram(port->port->serial->dev,
+                        port->uart_base + UMPMEM_OFFS_UART_LSR, 1, lsr);
 
         if (status)
                 goto exit_is_tx_active;
-        dbg ("%s - LSR = 0x%X", __func__, *lsr);
-        
+        dbg("%s - LSR = 0x%X", __func__, *lsr);
+
         /* If either buffer has data or we are transmitting then return TRUE */
-        if ((oedb->XByteCount & 0x80 ) != 0 )
+        if ((oedb->XByteCount & 0x80) != 0)
                 bytes_left += 64;
 
-        if ((*lsr & UMP_UART_LSR_TX_MASK ) == 0 )
+        if ((*lsr & UMP_UART_LSR_TX_MASK) == 0)
                 bytes_left += 1;
 
         /* We return Not Active if we get any kind of error */
 exit_is_tx_active:
-        dbg ("%s - return %d", __func__, bytes_left );
+        dbg("%s - return %d", __func__, bytes_left);
 
         kfree(lsr);
         kfree(oedb);
         return bytes_left;
 }
 
-static void TIChasePort(struct edgeport_port *port, unsigned long timeout, int flush)
+static void chase_port(struct edgeport_port *port, unsigned long timeout,
+                                                                int flush)
 {
         int baud_rate;
         struct tty_struct *tty = port->port->tty;
@@ -611,7 +577,7 @@ static void TIChasePort(struct edgeport_port *port, unsigned long timeout, int f
         unsigned long flags;
 
         if (!timeout)
-                timeout = (HZ*EDGE_CLOSING_WAIT)/100;
+                timeout = (HZ * EDGE_CLOSING_WAIT)/100;
 
         /* wait for data to drain from the buffer */
         spin_lock_irqsave(&port->ep_lock, flags);
@@ -621,7 +587,8 @@ static void TIChasePort(struct edgeport_port *port, unsigned long timeout, int f
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (edge_buf_data_avail(port->ep_out_buf) == 0
                 || timeout == 0 || signal_pending(current)
-                || !usb_get_intfdata(port->port->serial->interface))  /* disconnect */
+                || !usb_get_intfdata(port->port->serial->interface))
+                        /* disconnect */
                         break;
                 spin_unlock_irqrestore(&port->ep_lock, flags);
                 timeout = schedule_timeout(timeout);
@@ -636,8 +603,9 @@ static void TIChasePort(struct edgeport_port *port, unsigned long timeout, int f
         /* wait for data to drain from the device */
         timeout += jiffies;
         while ((long)(jiffies - timeout) < 0 && !signal_pending(current)
-        && usb_get_intfdata(port->port->serial->interface)) {  /* not disconnected */
-                if (!TIIsTxActive(port))
+        && usb_get_intfdata(port->port->serial->interface)) {
+                /* not disconnected */
+                if (!tx_active(port))
                         break;
                 msleep(10);
         }
@@ -647,72 +615,72 @@ static void TIChasePort(struct edgeport_port *port, unsigned long timeout, int f
                 return;
 
         /* wait one more character time, based on baud rate */
-        /* (TIIsTxActive doesn't seem to wait for the last byte) */
-        if ((baud_rate=port->baud_rate) == 0)
+        /* (tx_active doesn't seem to wait for the last byte) */
+        baud_rate = port->baud_rate;
+        if (baud_rate == 0)
                 baud_rate = 50;
         msleep(max(1, DIV_ROUND_UP(10000, baud_rate)));
 }
 
-static int TIChooseConfiguration (struct usb_device *dev)
+static int choose_config(struct usb_device *dev)
 {
-        // There may be multiple configurations on this device, in which case
-        // we would need to read and parse all of them to find out which one
-        // we want. However, we just support one config at this point,
-        // configuration # 1, which is Config Descriptor 0.
+        /*
+         * There may be multiple configurations on this device, in which case
+         * we would need to read and parse all of them to find out which one
+         * we want. However, we just support one config at this point,
+         * configuration # 1, which is Config Descriptor 0.
+         */
 
-        dbg ("%s - Number of Interfaces = %d", __func__, dev->config->desc.bNumInterfaces);
-        dbg ("%s - MAX Power            = %d", __func__, dev->config->desc.bMaxPower*2);
+        dbg("%s - Number of Interfaces = %d",
+                                __func__, dev->config->desc.bNumInterfaces);
+        dbg("%s - MAX Power            = %d",
+                                __func__, dev->config->desc.bMaxPower * 2);
 
         if (dev->config->desc.bNumInterfaces != 1) {
-                dev_err (&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);
+                dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n",
+                                                                __func__);
                 return -ENODEV;
         }
 
         return 0;
 }
 
-static int TIReadRom (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
+static int read_rom(struct edgeport_serial *serial,
+                                int start_address, int length, __u8 *buffer)
 {
         int status;
 
         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
-                status = TIReadDownloadMemory (serial->serial->dev,
+                status = read_download_mem(serial->serial->dev,
                                                start_address,
                                                length,
                                                serial->TI_I2C_Type,
                                                buffer);
         } else {
-                status = TIReadBootMemory (serial,
-                                           start_address,
-                                           length,
-                                           buffer);
+                status = read_boot_mem(serial, start_address, length,
+                                                                buffer);
         }
-
         return status;
 }
 
-static int TIWriteRom (struct edgeport_serial *serial, int start_address, int length, __u8 *buffer)
+static int write_rom(struct edgeport_serial *serial, int start_address,
+                                                int length, __u8 *buffer)
 {
         if (serial->product_info.TiMode == TI_MODE_BOOT)
-                return TIWriteBootMemory (serial,
-                                          start_address,
-                                          length,
-                                          buffer);
+                return write_boot_mem(serial, start_address, length,
+                                                                buffer);
 
         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD)
-                return TIWriteDownloadI2C (serial,
-                                           start_address,
-                                           length,
-                                           serial->TI_I2C_Type,
-                                           buffer);
-
+                return write_i2c_mem(serial, start_address, length,
+                                                serial->TI_I2C_Type, buffer);
         return -EINVAL;
 }
 
 
 
 /* Read a descriptor header from I2C based on type */
-static int TIGetDescriptorAddress (struct edgeport_serial *serial, int desc_type, struct ti_i2c_desc *rom_desc)
+static int get_descriptor_addr(struct edgeport_serial *serial,
+                                int desc_type, struct ti_i2c_desc *rom_desc)
 {
         int start_address;
         int status;
@@ -720,41 +688,42 @@ static int TIGetDescriptorAddress (struct edgeport_serial *serial, int desc_type
         /* Search for requested descriptor in I2C */
         start_address = 2;
         do {
-                status = TIReadRom (serial,
+                status = read_rom(serial,
                                    start_address,
                                    sizeof(struct ti_i2c_desc),
-                                   (__u8 *)rom_desc );
+                                   (__u8 *)rom_desc);
                 if (status)
                         return 0;
 
                 if (rom_desc->Type == desc_type)
                         return start_address;
 
-                start_address = start_address + sizeof(struct ti_i2c_desc) +  rom_desc->Size;
+                start_address = start_address + sizeof(struct ti_i2c_desc)
+                                                        + rom_desc->Size;
 
         } while ((start_address < TI_MAX_I2C_SIZE) && rom_desc->Type);
-        
+
         return 0;
 }
 
 /* Validate descriptor checksum */
-static int ValidChecksum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
+static int valid_csum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
 {
         __u16 i;
         __u8 cs = 0;
 
-        for (i=0; i < rom_desc->Size; i++) {
+        for (i = 0; i < rom_desc->Size; i++)
                 cs = (__u8)(cs + buffer[i]);
-        }
+
         if (cs != rom_desc->CheckSum) {
-                dbg ("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
+                dbg("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
                 return -EINVAL;
         }
         return 0;
 }
 
 /* Make sure that the I2C image is good */
-static int TiValidateI2cImage (struct edgeport_serial *serial)
+static int check_i2c_image(struct edgeport_serial *serial)
 {
         struct device *dev = &serial->serial->dev->dev;
         int status = 0;
@@ -763,120 +732,124 @@ static int TiValidateI2cImage (struct edgeport_serial *serial)
         __u8 *buffer;
         __u16 ttype;
 
-        rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
+        rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
         if (!rom_desc) {
-                dev_err (dev, "%s - out of memory\n", __func__);
+                dev_err(dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
-        buffer = kmalloc (TI_MAX_I2C_SIZE, GFP_KERNEL);
+        buffer = kmalloc(TI_MAX_I2C_SIZE, GFP_KERNEL);
         if (!buffer) {
-                dev_err (dev, "%s - out of memory when allocating buffer\n", __func__);
-                kfree (rom_desc);
+                dev_err(dev, "%s - out of memory when allocating buffer\n",
+                                                                __func__);
+                kfree(rom_desc);
                 return -ENOMEM;
         }
 
-        // Read the first byte (Signature0) must be 0x52 or 0x10
-        status = TIReadRom (serial, 0, 1, buffer);
+        /* Read the first byte (Signature0) must be 0x52 or 0x10 */
+        status = read_rom(serial, 0, 1, buffer);
         if (status)
-                goto ExitTiValidateI2cImage; 
+                goto out;
 
         if (*buffer != UMP5152 && *buffer != UMP3410) {
-                dev_err (dev, "%s - invalid buffer signature\n", __func__);
+                dev_err(dev, "%s - invalid buffer signature\n", __func__);
                 status = -ENODEV;
-                goto ExitTiValidateI2cImage;
+                goto out;
         }
 
         do {
-                // Validate the I2C
-                status = TIReadRom (serial,
+                /* Validate the I2C */
+                status = read_rom(serial,
                                 start_address,
                                 sizeof(struct ti_i2c_desc),
                                 (__u8 *)rom_desc);
                 if (status)
                         break;
 
-                if ((start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size) > TI_MAX_I2C_SIZE) {
+                if ((start_address + sizeof(struct ti_i2c_desc) +
+                                        rom_desc->Size) > TI_MAX_I2C_SIZE) {
                         status = -ENODEV;
-                        dbg ("%s - structure too big, erroring out.", __func__);
+                        dbg("%s - structure too big, erroring out.", __func__);
                         break;
                 }
 
-                dbg ("%s Type = 0x%x", __func__, rom_desc->Type);
+                dbg("%s Type = 0x%x", __func__, rom_desc->Type);
 
-                // Skip type 2 record
+                /* Skip type 2 record */
                 ttype = rom_desc->Type & 0x0f;
-                if ( ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
-                        && ttype != I2C_DESC_TYPE_FIRMWARE_AUTO ) {
-                        // Read the descriptor data
-                        status = TIReadRom(serial,
-                                                start_address+sizeof(struct ti_i2c_desc),
-                                                rom_desc->Size,
-                                                buffer);
+                if (ttype != I2C_DESC_TYPE_FIRMWARE_BASIC
+                        && ttype != I2C_DESC_TYPE_FIRMWARE_AUTO) {
+                        /* Read the descriptor data */
+                        status = read_rom(serial, start_address +
+                                                sizeof(struct ti_i2c_desc),
+                                                rom_desc->Size, buffer);
                         if (status)
                                 break;
 
-                        status = ValidChecksum(rom_desc, buffer);
+                        status = valid_csum(rom_desc, buffer);
                         if (status)
                                 break;
                 }
-                start_address = start_address + sizeof(struct ti_i2c_desc) + rom_desc->Size;
+                start_address = start_address + sizeof(struct ti_i2c_desc) +
+                                                                rom_desc->Size;
 
-        } while ((rom_desc->Type != I2C_DESC_TYPE_ION) && (start_address < TI_MAX_I2C_SIZE));
+        } while ((rom_desc->Type != I2C_DESC_TYPE_ION) &&
+                                (start_address < TI_MAX_I2C_SIZE));
 
-        if ((rom_desc->Type != I2C_DESC_TYPE_ION) || (start_address > TI_MAX_I2C_SIZE))
+        if ((rom_desc->Type != I2C_DESC_TYPE_ION) ||
+                                (start_address > TI_MAX_I2C_SIZE))
                 status = -ENODEV;
 
-ExitTiValidateI2cImage: 
-        kfree (buffer);
-        kfree (rom_desc);
+out:
+        kfree(buffer);
+        kfree(rom_desc);
         return status;
 }
 
-static int TIReadManufDescriptor (struct edgeport_serial *serial, __u8 *buffer)
+static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
 {
         int status;
         int start_address;
         struct ti_i2c_desc *rom_desc;
         struct edge_ti_manuf_descriptor *desc;
 
-        rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
+        rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
         if (!rom_desc) {
-                dev_err (&serial->serial->dev->dev, "%s - out of memory\n", __func__);
+                dev_err(&serial->serial->dev->dev, "%s - out of memory\n",
+                                                                __func__);
                 return -ENOMEM;
         }
-        start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_ION, rom_desc);
+        start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
+                                                                rom_desc);
 
         if (!start_address) {
-                dbg ("%s - Edge Descriptor not found in I2C", __func__);
+                dbg("%s - Edge Descriptor not found in I2C", __func__);
                 status = -ENODEV;
                 goto exit;
         }
 
-        // Read the descriptor data
-        status = TIReadRom (serial,
-                                start_address+sizeof(struct ti_i2c_desc),
-                                rom_desc->Size,
-                                buffer);
+        /* Read the descriptor data */
+        status = read_rom(serial, start_address+sizeof(struct ti_i2c_desc),
+                                                rom_desc->Size, buffer);
         if (status)
                 goto exit;
-        
-        status = ValidChecksum(rom_desc, buffer);
-        
+
+        status = valid_csum(rom_desc, buffer);
+
         desc = (struct edge_ti_manuf_descriptor *)buffer;
-        dbg ( "%s - IonConfig      0x%x", __func__, desc->IonConfig     );
-        dbg ( "%s - Version          %d", __func__, desc->Version               );
-        dbg ( "%s - Cpu/Board      0x%x", __func__, desc->CpuRev_BoardRev       );
-        dbg ( "%s - NumPorts         %d", __func__, desc->NumPorts      );
-        dbg ( "%s - NumVirtualPorts  %d", __func__, desc->NumVirtualPorts       );
-        dbg ( "%s - TotalPorts       %d", __func__, desc->TotalPorts    );
+        dbg("%s - IonConfig      0x%x", __func__, desc->IonConfig);
+        dbg("%s - Version          %d", __func__, desc->Version);
+        dbg("%s - Cpu/Board      0x%x", __func__, desc->CpuRev_BoardRev);
+        dbg("%s - NumPorts         %d", __func__, desc->NumPorts);
+        dbg("%s - NumVirtualPorts  %d", __func__, desc->NumVirtualPorts);
+        dbg("%s - TotalPorts       %d", __func__, desc->TotalPorts);
 
 exit:
-        kfree (rom_desc);
+        kfree(rom_desc);
         return status;
 }
 
 /* Build firmware header used for firmware update */
-static int BuildI2CFirmwareHeader (__u8 *header, struct device *dev)
+static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
 {
         __u8 *buffer;
         int buffer_size;
@@ -889,24 +862,28 @@ static int BuildI2CFirmwareHeader (__u8 *header, struct device *dev)
         const struct firmware *fw;
         const char *fw_name = "edgeport/down3.bin";
 
-        // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
-        // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
-        // will download the latest firmware (padded to 15.5k) into the UMP ram. 
-        // And finally when the device comes back up in download mode the driver will cause 
-        // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
-        // the record type from 0xf2 to 0x02.
-        
-        // Allocate a 15.5k buffer + 2 bytes for version number (Firmware Record)
-        buffer_size = (((1024 * 16) - 512 )+ sizeof(struct ti_i2c_firmware_rec));
-
-        buffer = kmalloc (buffer_size, GFP_KERNEL);
+        /* In order to update the I2C firmware we must change the type 2 record
+         * to type 0xF2.  This will force the UMP to come up in Boot Mode.
+         * Then while in boot mode, the driver will download the latest
+         * firmware (padded to 15.5k) into the UMP ram.  And finally when the
+         * device comes back up in download mode the driver will cause the new
+         * firmware to be copied from the UMP Ram to I2C and the firmware will
+         * update the record type from 0xf2 to 0x02.
+         */
+
+        /* Allocate a 15.5k buffer + 2 bytes for version number
+         * (Firmware Record) */
+        buffer_size = (((1024 * 16) - 512 ) +
+                        sizeof(struct ti_i2c_firmware_rec));
+
+        buffer = kmalloc(buffer_size, GFP_KERNEL);
         if (!buffer) {
-                dev_err (dev, "%s - out of memory\n", __func__);
+                dev_err(dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
-        
+
         // Set entire image of 0xffs
-        memset (buffer, 0xff, buffer_size);
+        memset(buffer, 0xff, buffer_size);
 
         err = request_firmware(&fw, fw_name, dev);
         if (err) {
@@ -921,16 +898,16 @@ static int BuildI2CFirmwareHeader (__u8 *header, struct device *dev)
         OperationalMinorVersion = fw->data[1];
         OperationalBuildNumber = fw->data[2] | (fw->data[3] << 8);
 
-        // Copy version number into firmware record
+        /* Copy version number into firmware record */
         firmware_rec = (struct ti_i2c_firmware_rec *)buffer;
 
         firmware_rec->Ver_Major = OperationalMajorVersion;
         firmware_rec->Ver_Minor = OperationalMinorVersion;
 
-        // Pointer to fw_down memory image
+        /* Pointer to fw_down memory image */
         img_header = (struct ti_i2c_image_header *)&fw->data[4];
 
-        memcpy (buffer + sizeof(struct ti_i2c_firmware_rec),
+        memcpy(buffer + sizeof(struct ti_i2c_firmware_rec),
                 &fw->data[4 + sizeof(struct ti_i2c_image_header)],
                 le16_to_cpu(img_header->Length));
 
@@ -940,12 +917,12 @@ static int BuildI2CFirmwareHeader (__u8 *header, struct device *dev)
                 cs = (__u8)(cs + buffer[i]);
         }
 
-        kfree (buffer);
+        kfree(buffer);
 
-        // Build new header
+        /* Build new header */
         i2c_header =  (struct ti_i2c_desc *)header;
         firmware_rec =  (struct ti_i2c_firmware_rec*)i2c_header->Data;
-        
+
         i2c_header->Type        = I2C_DESC_TYPE_FIRMWARE_BLANK;
         i2c_header->Size        = (__u16)buffer_size;
         i2c_header->CheckSum    = cs;
@@ -956,103 +933,100 @@ static int BuildI2CFirmwareHeader (__u8 *header, struct device *dev)
 }
 
 /* Try to figure out what type of I2c we have */
-static int TIGetI2cTypeInBootMode (struct edgeport_serial *serial)
+static int i2c_type_bootmode(struct edgeport_serial *serial)
 {
         int status;
         __u8 data;
-                
-        // Try to read type 2
-        status = TIReadVendorRequestSync (serial->serial->dev,
-                                        UMPC_MEMORY_READ,               // Request
-                                        DTK_ADDR_SPACE_I2C_TYPE_II,     // wValue (Address type)
-                                        0,                              // wIndex
-                                        &data,                          // TransferBuffer
-                                        0x01);                          // TransferBufferLength
+
+        /* Try to read type 2 */
+        status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
+                                DTK_ADDR_SPACE_I2C_TYPE_II, 0, &data, 0x01);
         if (status)
-                dbg ("%s - read 2 status error = %d", __func__, status);
+                dbg("%s - read 2 status error = %d", __func__, status);
         else
-                dbg ("%s - read 2 data = 0x%x", __func__, data);
+                dbg("%s - read 2 data = 0x%x", __func__, data);
         if ((!status) && (data == UMP5152 || data == UMP3410)) {
-                dbg ("%s - ROM_TYPE_II", __func__);
+                dbg("%s - ROM_TYPE_II", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
                 return 0;
         }
 
-        // Try to read type 3
-        status = TIReadVendorRequestSync (serial->serial->dev,
-                                        UMPC_MEMORY_READ,               // Request
-                                        DTK_ADDR_SPACE_I2C_TYPE_III,    // wValue (Address type)
-                                        0,                              // wIndex
-                                        &data,                          // TransferBuffer
-                                        0x01);                          // TransferBufferLength
+        /* Try to read type 3 */
+        status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
+                                DTK_ADDR_SPACE_I2C_TYPE_III, 0, &data, 0x01);
         if (status)
-                dbg ("%s - read 3 status error = %d", __func__, status);
+                dbg("%s - read 3 status error = %d", __func__, status);
         else
-                dbg ("%s - read 2 data = 0x%x", __func__, data);
+                dbg("%s - read 2 data = 0x%x", __func__, data);
         if ((!status) && (data == UMP5152 || data == UMP3410)) {
-                dbg ("%s - ROM_TYPE_III", __func__);
+                dbg("%s - ROM_TYPE_III", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
                 return 0;
         }
 
-        dbg ("%s - Unknown", __func__);
+        dbg("%s - Unknown", __func__);
         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
         return -ENODEV;
 }
 
-static int TISendBulkTransferSync (struct usb_serial *serial, void *buffer, int length, int *num_sent)
+static int bulk_xfer(struct usb_serial *serial, void *buffer,
+                                                int length, int *num_sent)
 {
         int status;
 
-        status = usb_bulk_msg (serial->dev,
-                                usb_sndbulkpipe(serial->dev,
-                                                serial->port[0]->bulk_out_endpointAddress),
-                                buffer,
-                                length,
-                                num_sent,
-                                1000);
+        status = usb_bulk_msg(serial->dev,
+                        usb_sndbulkpipe(serial->dev,
+                                serial->port[0]->bulk_out_endpointAddress),
+                        buffer, length, num_sent, 1000);
         return status;
 }
 
 /* Download given firmware image to the device (IN BOOT MODE) */
-static int TIDownloadCodeImage (struct edgeport_serial *serial, __u8 *image, int image_length)
+static int download_code(struct edgeport_serial *serial, __u8 *image,
+                                                        int image_length)
 {
         int status = 0;
         int pos;
         int transfer;
         int done;
 
-        // Transfer firmware image
+        /* Transfer firmware image */
         for (pos = 0; pos < image_length; ) {
-                // Read the next buffer from file
+                /* Read the next buffer from file */
                 transfer = image_length - pos;
                 if (transfer > EDGE_FW_BULK_MAX_PACKET_SIZE)
                         transfer = EDGE_FW_BULK_MAX_PACKET_SIZE;
 
-                // Transfer data
-                status = TISendBulkTransferSync (serial->serial, &image[pos], transfer, &done);
+                /* Transfer data */
+                status = bulk_xfer(serial->serial, &image[pos],
+                                                        transfer, &done);
                 if (status)
                         break;
-                // Advance buffer pointer
+                /* Advance buffer pointer */
                 pos += done;
         }
 
         return status;
 }
 
-// FIXME!!!
-static int TIConfigureBootDevice (struct usb_device *dev)
+/* FIXME!!! */
+static int config_boot_dev(struct usb_device *dev)
 {
         return 0;
 }
 
+static int ti_cpu_rev(struct edge_ti_manuf_descriptor *desc)
+{
+        return TI_GET_CPU_REVISION(desc->CpuRev_BoardRev);
+}
+
 /**
  * DownloadTIFirmware - Download run-time operating firmware to the TI5052
- * 
+ *
  * This routine downloads the main operating code into the TI5052, using the
  * boot code already burned into E2PROM or ROM.
  */
-static int TIDownloadFirmware (struct edgeport_serial *serial)
+static int download_fw(struct edgeport_serial *serial)
 {
         struct device *dev = &serial->serial->dev->dev;
         int status = 0;
@@ -1071,22 +1045,25 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
         /* Default to type 2 i2c */
         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
 
-        status = TIChooseConfiguration (serial->serial->dev);
+        status = choose_config(serial->serial->dev);
         if (status)
                 return status;
 
         interface = &serial->serial->interface->cur_altsetting->desc;
         if (!interface) {
-                dev_err (dev, "%s - no interface set, error!\n", __func__);
+                dev_err(dev, "%s - no interface set, error!\n", __func__);
                 return -ENODEV;
         }
 
-        // Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
-        // if we have more than one endpoint we are definitely in download mode
+        /*
+         * Setup initial mode -- the default mode 0 is TI_MODE_CONFIGURING
+         * if we have more than one endpoint we are definitely in download
+         * mode
+         */
         if (interface->bNumEndpoints > 1)
                 serial->product_info.TiMode = TI_MODE_DOWNLOAD;
         else
-                // Otherwise we will remain in configuring mode
+                /* Otherwise we will remain in configuring mode */
                 serial->product_info.TiMode = TI_MODE_CONFIGURING;
 
         /********************************************************************/
@@ -1097,256 +1074,273 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
 
                 dbg("%s - RUNNING IN DOWNLOAD MODE", __func__);
 
-                status = TiValidateI2cImage (serial);
+                status = check_i2c_image(serial);
                 if (status) {
                         dbg("%s - DOWNLOAD MODE -- BAD I2C", __func__);
                         return status;
                 }
-                
+
                 /* Validate Hardware version number
                  * Read Manufacturing Descriptor from TI Based Edgeport
                  */
-                ti_manuf_desc = kmalloc (sizeof (*ti_manuf_desc), GFP_KERNEL);
+                ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
                 if (!ti_manuf_desc) {
-                        dev_err (dev, "%s - out of memory.\n", __func__);
+                        dev_err(dev, "%s - out of memory.\n", __func__);
                         return -ENOMEM;
                 }
-                status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
+                status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
                 if (status) {
-                        kfree (ti_manuf_desc);
+                        kfree(ti_manuf_desc);
                         return status;
                 }
 
-                // Check version number of ION descriptor
-                if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
-                        dbg ( "%s - Wrong CPU Rev %d (Must be 2)", __func__,
-                             TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
-                        kfree (ti_manuf_desc);
-                        return -EINVAL;
-                }
+                /* Check version number of ION descriptor */
+                if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
+                        dbg("%s - Wrong CPU Rev %d (Must be 2)",
+                                __func__, ti_cpu_rev(ti_manuf_desc));
+                        kfree(ti_manuf_desc);
+                        return -EINVAL;
+                }
 
-                rom_desc = kmalloc (sizeof (*rom_desc), GFP_KERNEL);
+                rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
                 if (!rom_desc) {
-                        dev_err (dev, "%s - out of memory.\n", __func__);
-                        kfree (ti_manuf_desc);
+                        dev_err(dev, "%s - out of memory.\n", __func__);
+                        kfree(ti_manuf_desc);
                         return -ENOMEM;
                 }
 
-                // Search for type 2 record (firmware record)
-                if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc)) != 0) {
+                /* Search for type 2 record (firmware record) */
+                start_address = get_descriptor_addr(serial,
+                                I2C_DESC_TYPE_FIRMWARE_BASIC, rom_desc);
+                if (start_address != 0) {
                         struct ti_i2c_firmware_rec *firmware_version;
                         __u8 record;
 
-                        dbg ("%s - Found Type FIRMWARE (Type 2) record", __func__);
+                        dbg("%s - Found Type FIRMWARE (Type 2) record",
+                                                                __func__);
 
-                        firmware_version = kmalloc (sizeof (*firmware_version), GFP_KERNEL);
+                        firmware_version = kmalloc(sizeof(*firmware_version),
+                                                                GFP_KERNEL);
                         if (!firmware_version) {
-                                dev_err (dev, "%s - out of memory.\n", __func__);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dev_err(dev, "%s - out of memory.\n", __func__);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return -ENOMEM;
                         }
 
-                        // Validate version number                              
-                        // Read the descriptor data
-                        status = TIReadRom (serial,
-                                        start_address+sizeof(struct ti_i2c_desc),
+                        /* Validate version number
+                         * Read the descriptor data
+                         */
+                        status = read_rom(serial, start_address +
+                                        sizeof(struct ti_i2c_desc),
                                         sizeof(struct ti_i2c_firmware_rec),
                                         (__u8 *)firmware_version);
                         if (status) {
-                                kfree (firmware_version);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                kfree(firmware_version);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
 
-                        // Check version number of download with current version in I2c
-                        download_cur_ver = (firmware_version->Ver_Major << 8) + 
+                        /* Check version number of download with current
+                           version in I2c */
+                        download_cur_ver = (firmware_version->Ver_Major << 8) +
                                            (firmware_version->Ver_Minor);
                         download_new_ver = (OperationalMajorVersion << 8) +
                                            (OperationalMinorVersion);
 
-                        dbg ("%s - >>>Firmware Versions Device %d.%d  Driver %d.%d",
-                             __func__,
-                             firmware_version->Ver_Major,
-                             firmware_version->Ver_Minor,
-                             OperationalMajorVersion,
-                             OperationalMinorVersion);
+                        dbg("%s - >> FW Versions Device %d.%d  Driver %d.%d",
+                            __func__,
+                            firmware_version->Ver_Major,
+                            firmware_version->Ver_Minor,
+                            OperationalMajorVersion,
+                            OperationalMinorVersion);
 
-                        // Check if we have an old version in the I2C and update if necessary
+                        /* Check if we have an old version in the I2C and
+                           update if necessary */
                         if (download_cur_ver != download_new_ver) {
-                                dbg ("%s - Update I2C Download from %d.%d to %d.%d",
-                                     __func__,
-                                     firmware_version->Ver_Major,
-                                     firmware_version->Ver_Minor,
-                                     OperationalMajorVersion,
-                                     OperationalMinorVersion);
-
-                                // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
-                                // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
-                                // will download the latest firmware (padded to 15.5k) into the UMP ram. 
-                                // And finally when the device comes back up in download mode the driver will cause 
-                                // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
-                                // the record type from 0xf2 to 0x02.
-
+                                dbg("%s - Update I2C dld from %d.%d to %d.%d",
+                                    __func__,
+                                    firmware_version->Ver_Major,
+                                    firmware_version->Ver_Minor,
+                                    OperationalMajorVersion,
+                                    OperationalMinorVersion);
+
+                                /* In order to update the I2C firmware we must
+                                 * change the type 2 record to type 0xF2. This
+                                 * will force the UMP to come up in Boot Mode.
+                                 * Then while in boot mode, the driver will
+                                 * download the latest firmware (padded to
+                                 * 15.5k) into the UMP ram. Finally when the
+                                 * device comes back up in download mode the
+                                 * driver will cause the new firmware to be
+                                 * copied from the UMP Ram to I2C and the
+                                 * firmware will update the record type from
+                                 * 0xf2 to 0x02.
+                                 */
                                 record = I2C_DESC_TYPE_FIRMWARE_BLANK;
 
-                                // Change the I2C Firmware record type to 0xf2 to trigger an update
-                                status = TIWriteRom (serial,
-                                                        start_address,
-                                                        sizeof(record),
-                                                        &record);
+                                /* Change the I2C Firmware record type to
+                                   0xf2 to trigger an update */
+                                status = write_rom(serial, start_address,
+                                                sizeof(record), &record);
                                 if (status) {
-                                        kfree (firmware_version);
-                                        kfree (rom_desc);
-                                        kfree (ti_manuf_desc);
+                                        kfree(firmware_version);
+                                        kfree(rom_desc);
+                                        kfree(ti_manuf_desc);
                                         return status;
                                 }
 
-                                // verify the write -- must do this in order for write to 
-                                // complete before we do the hardware reset
-                                status = TIReadRom (serial,
+                                /* verify the write -- must do this in order
+                                 * for write to complete before we do the
+                                 * hardware reset
+                                 */
+                                status = read_rom(serial,
                                                         start_address,
                                                         sizeof(record),
                                                         &record);
-
                                 if (status) {
-                                        kfree (firmware_version);
-                                        kfree (rom_desc);
-                                        kfree (ti_manuf_desc);
+                                        kfree(firmware_version);
+                                        kfree(rom_desc);
+                                        kfree(ti_manuf_desc);
                                         return status;
                                 }
 
                                 if (record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
-                                        dev_err (dev, "%s - error resetting device\n", __func__);
-                                        kfree (firmware_version);
-                                        kfree (rom_desc);
-                                        kfree (ti_manuf_desc);
+                                        dev_err(dev,
+                                                "%s - error resetting device\n",
+                                                __func__);
+                                        kfree(firmware_version);
+                                        kfree(rom_desc);
+                                        kfree(ti_manuf_desc);
                                         return -ENODEV;
                                 }
 
-                                dbg ("%s - HARDWARE RESET", __func__);
+                                dbg("%s - HARDWARE RESET", __func__);
 
-                                // Reset UMP -- Back to BOOT MODE
-                                status = TISendVendorRequestSync (serial->serial->dev,
-                                                                UMPC_HARDWARE_RESET,    // Request
-                                                                0,                      // wValue
-                                                                0,                      // wIndex
-                                                                NULL,                   // TransferBuffer
-                                                                0);                     // TransferBufferLength
+                                /* Reset UMP -- Back to BOOT MODE */
+                                status = ti_vsend_sync(serial->serial->dev,
+                                                UMPC_HARDWARE_RESET,
+                                                0, 0, NULL, 0);
 
-                                dbg ( "%s - HARDWARE RESET return %d", __func__, status);
+                                dbg("%s - HARDWARE RESET return %d",
+                                                __func__, status);
 
                                 /* return an error on purpose. */
-                                kfree (firmware_version);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                kfree(firmware_version);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return -ENODEV;
                         }
-                        kfree (firmware_version);
+                        kfree(firmware_version);
                 }
-                // Search for type 0xF2 record (firmware blank record)
-                else if ((start_address = TIGetDescriptorAddress (serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
-                        #define HEADER_SIZE     (sizeof(struct ti_i2c_desc) + sizeof(struct ti_i2c_firmware_rec))
+                /* Search for type 0xF2 record (firmware blank record) */
+                else if ((start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_FIRMWARE_BLANK, rom_desc)) != 0) {
+#define HEADER_SIZE     (sizeof(struct ti_i2c_desc) + \
+                                        sizeof(struct ti_i2c_firmware_rec))
                         __u8 *header;
                         __u8 *vheader;
 
-                        header  = kmalloc (HEADER_SIZE, GFP_KERNEL);
+                        header = kmalloc(HEADER_SIZE, GFP_KERNEL);
                         if (!header) {
-                                dev_err (dev, "%s - out of memory.\n", __func__);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dev_err(dev, "%s - out of memory.\n", __func__);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return -ENOMEM;
                         }
-                                
-                        vheader = kmalloc (HEADER_SIZE, GFP_KERNEL);
+
+                        vheader = kmalloc(HEADER_SIZE, GFP_KERNEL);
                         if (!vheader) {
-                                dev_err (dev, "%s - out of memory.\n", __func__);
-                                kfree (header);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dev_err(dev, "%s - out of memory.\n", __func__);
+                                kfree(header);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return -ENOMEM;
                         }
-                        
-                        dbg ("%s - Found Type BLANK FIRMWARE (Type F2) record", __func__);
-
-                        // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
-                        // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
-                        // will download the latest firmware (padded to 15.5k) into the UMP ram. 
-                        // And finally when the device comes back up in download mode the driver will cause 
-                        // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
-                        // the record type from 0xf2 to 0x02.
-                        status = BuildI2CFirmwareHeader(header, dev);
+
+                        dbg("%s - Found Type BLANK FIRMWARE (Type F2) record",
+                                                                __func__);
+
+                        /*
+                         * In order to update the I2C firmware we must change
+                         * the type 2 record to type 0xF2. This will force the
+                         * UMP to come up in Boot Mode.  Then while in boot
+                         * mode, the driver will download the latest firmware
+                         * (padded to 15.5k) into the UMP ram. Finally when the
+                         * device comes back up in download mode the driver
+                         * will cause the new firmware to be copied from the
+                         * UMP Ram to I2C and the firmware will update the
+                         * record type from 0xf2 to 0x02.
+                         */
+                        status = build_i2c_fw_hdr(header, dev);
                         if (status) {
-                                kfree (vheader);
-                                kfree (header);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                kfree(vheader);
+                                kfree(header);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
 
-                        // Update I2C with type 0xf2 record with correct size and checksum
-                        status = TIWriteRom (serial,
+                        /* Update I2C with type 0xf2 record with correct
+                           size and checksum */
+                        status = write_rom(serial,
                                                 start_address,
                                                 HEADER_SIZE,
                                                 header);
                         if (status) {
-                                kfree (vheader);
-                                kfree (header);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                kfree(vheader);
+                                kfree(header);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
 
-                        // verify the write -- must do this in order for write to 
-                        // complete before we do the hardware reset
-                        status = TIReadRom (serial,
-                                                start_address,
-                                                HEADER_SIZE,
-                                                vheader);
+                        /* verify the write -- must do this in order for
+                           write to complete before we do the hardware reset */
+                        status = read_rom(serial, start_address,
+                                                        HEADER_SIZE, vheader);
 
                         if (status) {
-                                dbg ("%s - can't read header back", __func__);
-                                kfree (vheader);
-                                kfree (header);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dbg("%s - can't read header back", __func__);
+                                kfree(vheader);
+                                kfree(header);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
                         if (memcmp(vheader, header, HEADER_SIZE)) {
-                                dbg ("%s - write download record failed", __func__);
-                                kfree (vheader);
-                                kfree (header);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dbg("%s - write download record failed",
+                                        __func__);
+                                kfree(vheader);
+                                kfree(header);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
 
-                        kfree (vheader);
-                        kfree (header);
+                        kfree(vheader);
+                        kfree(header);
 
-                        dbg ("%s - Start firmware update", __func__);
+                        dbg("%s - Start firmware update", __func__);
 
-                        // Tell firmware to copy download image into I2C 
-                        status = TISendVendorRequestSync (serial->serial->dev,
-                                                UMPC_COPY_DNLD_TO_I2C,  // Request
-                                                0,                      // wValue 
-                                                0,                      // wIndex
-                                                NULL,                   // TransferBuffer
-                                                0);                     // TransferBufferLength
+                        /* Tell firmware to copy download image into I2C */
+                        status = ti_vsend_sync(serial->serial->dev,
+                                        UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);
 
-                        dbg ("%s - Update complete 0x%x", __func__, status);
+                        dbg("%s - Update complete 0x%x", __func__, status);
                         if (status) {
-                                dev_err (dev, "%s - UMPC_COPY_DNLD_TO_I2C failed\n", __func__);
-                                kfree (rom_desc);
-                                kfree (ti_manuf_desc);
+                                dev_err(dev,
+                                        "%s - UMPC_COPY_DNLD_TO_I2C failed\n",
+                                                                __func__);
+                                kfree(rom_desc);
+                                kfree(ti_manuf_desc);
                                 return status;
                         }
                 }
 
                 // The device is running the download code
-                kfree (rom_desc);
-                kfree (ti_manuf_desc);
+                kfree(rom_desc);
+                kfree(ti_manuf_desc);
                 return 0;
         }
 
@@ -1355,32 +1349,26 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
         /********************************************************************/
         dbg("%s - RUNNING IN BOOT MODE", __func__);
 
-        // Configure the TI device so we can use the BULK pipes for download
-        status = TIConfigureBootDevice (serial->serial->dev);
+        /* Configure the TI device so we can use the BULK pipes for download */
+        status = config_boot_dev(serial->serial->dev);
         if (status)
                 return status;
 
-        if (le16_to_cpu(serial->serial->dev->descriptor.idVendor) != USB_VENDOR_ID_ION) {
-                dbg ("%s - VID = 0x%x", __func__,
+        if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)
+                                                        != USB_VENDOR_ID_ION) {
+                dbg("%s - VID = 0x%x", __func__,
                      le16_to_cpu(serial->serial->dev->descriptor.idVendor));
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
-                goto StayInBootMode;
-        }
-
-        // We have an ION device (I2c Must be programmed)
-        // Determine I2C image type
-        if (TIGetI2cTypeInBootMode(serial)) {
-                goto StayInBootMode;
+                goto stayinbootmode;
         }
 
-        // Registry variable set?
-        if (TIStayInBootMode) {
-                dbg ("%s - TIStayInBootMode", __func__);
-                goto StayInBootMode;
-        }
+        /* We have an ION device (I2c Must be programmed)
+           Determine I2C image type */
+        if (i2c_type_bootmode(serial))
+                goto stayinbootmode;
 
-        // Check for ION Vendor ID and that the I2C is valid
-        if (!TiValidateI2cImage(serial)) {
+        /* Check for ION Vendor ID and that the I2C is valid */
+        if (!check_i2c_image(serial)) {
                 struct ti_i2c_image_header *header;
                 int i;
                 __u8 cs = 0;
@@ -1393,49 +1381,52 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
                 /* Validate Hardware version number
                  * Read Manufacturing Descriptor from TI Based Edgeport
                  */
-                ti_manuf_desc = kmalloc (sizeof (*ti_manuf_desc), GFP_KERNEL);
+                ti_manuf_desc = kmalloc(sizeof(*ti_manuf_desc), GFP_KERNEL);
                 if (!ti_manuf_desc) {
-                        dev_err (dev, "%s - out of memory.\n", __func__);
+                        dev_err(dev, "%s - out of memory.\n", __func__);
                         return -ENOMEM;
                 }
-                status = TIReadManufDescriptor (serial, (__u8 *)ti_manuf_desc);
+                status = get_manuf_info(serial, (__u8 *)ti_manuf_desc);
                 if (status) {
-                        kfree (ti_manuf_desc);
-                        goto StayInBootMode;
+                        kfree(ti_manuf_desc);
+                        goto stayinbootmode;
                 }
 
-                // Check for version 2
-                if (!ignore_cpu_rev && TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev) < 2) {
-                        dbg ("%s - Wrong CPU Rev %d (Must be 2)", __func__,
-                             TI_GET_CPU_REVISION(ti_manuf_desc->CpuRev_BoardRev));
-                        kfree (ti_manuf_desc);
-                        goto StayInBootMode;
+                /* Check for version 2 */
+                if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
+                        dbg("%s - Wrong CPU Rev %d (Must be 2)",
+                                        __func__, ti_cpu_rev(ti_manuf_desc));
+                        kfree(ti_manuf_desc);
+                        goto stayinbootmode;
                 }
 
-                kfree (ti_manuf_desc);
+                kfree(ti_manuf_desc);
 
-                // In order to update the I2C firmware we must change the type 2 record to type 0xF2.
-                // This will force the UMP to come up in Boot Mode.  Then while in boot mode, the driver 
-                // will download the latest firmware (padded to 15.5k) into the UMP ram. 
-                // And finally when the device comes back up in download mode the driver will cause 
-                // the new firmware to be copied from the UMP Ram to I2C and the firmware will update
-                // the record type from 0xf2 to 0x02.
-                
                 /*
+                 * In order to update the I2C firmware we must change the type
+                 * 2 record to type 0xF2. This will force the UMP to come up
+                 * in Boot Mode.  Then while in boot mode, the driver will
+                 * download the latest firmware (padded to 15.5k) into the
+                 * UMP ram. Finally when the device comes back up in download
+                 * mode the driver will cause the new firmware to be copied
+                 * from the UMP Ram to I2C and the firmware will update the
+                 * record type from 0xf2 to 0x02.
+                 *
                  * Do we really have to copy the whole firmware image,
                  * or could we do this in place!
                  */
 
-                // Allocate a 15.5k buffer + 3 byte header
-                buffer_size = (((1024 * 16) - 512) + sizeof(struct ti_i2c_image_header));
-                buffer = kmalloc (buffer_size, GFP_KERNEL);
+                /* Allocate a 15.5k buffer + 3 byte header */
+                buffer_size = (((1024 * 16) - 512) +
+                                        sizeof(struct ti_i2c_image_header));
+                buffer = kmalloc(buffer_size, GFP_KERNEL);
                 if (!buffer) {
-                        dev_err (dev, "%s - out of memory\n", __func__);
+                        dev_err(dev, "%s - out of memory\n", __func__);
                         return -ENOMEM;
                 }
-                
-                // Initialize the buffer to 0xff (pad the buffer)
-                memset (buffer, 0xff, buffer_size);
+
+                /* Initialize the buffer to 0xff (pad the buffer) */
+                memset(buffer, 0xff, buffer_size);
 
                 err = request_firmware(&fw, fw_name, dev);
                 if (err) {
@@ -1447,38 +1438,43 @@ static int TIDownloadFirmware (struct edgeport_serial *serial)
                 memcpy(buffer, &fw->data[4], fw->size - 4);
                 release_firmware(fw);
 
-                for(i = sizeof(struct ti_i2c_image_header); i < buffer_size; i++) {
+                for (i = sizeof(struct ti_i2c_image_header);
+                                i < buffer_size; i++) {
                         cs = (__u8)(cs + buffer[i]);
                 }
-                
+
                 header = (struct ti_i2c_image_header *)buffer;
-                
-                // update length and checksum after padding
-                header->Length   = cpu_to_le16((__u16)(buffer_size - sizeof(struct ti_i2c_image_header)));
+
+                /* update length and checksum after padding */
+                header->Length   = cpu_to_le16((__u16)(buffer_size -
+                                        sizeof(struct ti_i2c_image_header)));
                 header->CheckSum = cs;
 
-                // Download the operational code 
-                dbg ("%s - Downloading operational code image (TI UMP)", __func__);
-                status = TIDownloadCodeImage (serial, buffer, buffer_size);
+                /* Download the operational code  */
+                dbg("%s - Downloading operational code image (TI UMP)",
+                                                                __func__);
+                status = download_code(serial, buffer, buffer_size);
 
-                kfree (buffer);
+                kfree(buffer);
 
                 if (status) {
-                        dbg ("%s - Error downloading operational code image", __func__);
+                        dbg("%s - Error downloading operational code image",
+                                                                __func__);
                         return status;
                 }
 
-                // Device will reboot
+                /* Device will reboot */
                 serial->product_info.TiMode = TI_MODE_TRANSITIONING;
 
-                dbg ("%s - Download successful -- Device rebooting...", __func__);
+                dbg("%s - Download successful -- Device rebooting...",
+                                                                __func__);
 
                 /* return an error on purpose */
                 return -ENODEV;
         }
 
-StayInBootMode:
-        // Eprom is invalid or blank stay in boot mode
+stayinbootmode:
+        /* Eprom is invalid or blank stay in boot mode */
         dbg("%s - STAYING IN BOOT MODE", __func__);
         serial->product_info.TiMode = TI_MODE_BOOT;
 
@@ -1486,156 +1482,33 @@ StayInBootMode:
 }
 
 
-static int TISetDtr (struct edgeport_port *port)
+static int ti_do_config(struct edgeport_port *port, int feature, int on)
 {
         int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-        port->shadow_mcr |= MCR_DTR;
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_DTR,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                1,      /* set */
-                                NULL,
-                                0);
+        on = !!on;      /* 1 or 0 not bitmask */
+        return send_cmd(port->port->serial->dev,
+                        feature, (__u8)(UMPM_UART1_PORT + port_number),
+                        on, NULL, 0);
 }
 
-static int TIClearDtr (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-        port->shadow_mcr &= ~MCR_DTR;
 
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_DTR,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                0,      /* clear */
-                                NULL,
-                                0);
-}
-
-static int TISetRts (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-        port->shadow_mcr |= MCR_RTS;
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_RTS,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                1,      /* set */
-                                NULL,
-                                0);
-}
-
-static int TIClearRts (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-        port->shadow_mcr &= ~MCR_RTS;
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_RTS,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                0,      /* clear */
-                                NULL,
-                                0);
-}
-
-static int TISetLoopBack (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_LOOPBACK,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                1,      /* set */
-                                NULL,
-                                0);
-}
-
-static int TIClearLoopBack (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_LOOPBACK,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                0,      /* clear */
-                                NULL,
-                                0);
-}
-
-static int TISetBreak (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_BREAK,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                1,      /* set */
-                                NULL,
-                                0);
-}
-
-static int TIClearBreak (struct edgeport_port *port)
-{
-        int port_number = port->port->number - port->port->serial->minor;
-
-        dbg ("%s", __func__);
-
-        return TIWriteCommandSync (port->port->serial->dev,
-                                UMPC_SET_CLR_BREAK,
-                                (__u8)(UMPM_UART1_PORT + port_number),
-                                0,      /* clear */
-                                NULL,
-                                0);
-}
-
-static int TIRestoreMCR (struct edgeport_port *port, __u8 mcr)
+static int restore_mcr(struct edgeport_port *port, __u8 mcr)
 {
         int status = 0;
 
-        dbg ("%s - %x", __func__, mcr);
-
-        if (mcr & MCR_DTR)
-                status = TISetDtr (port);
-        else
-                status = TIClearDtr (port);
+        dbg("%s - %x", __func__, mcr);
 
+        status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);
         if (status)
                 return status;
-
-        if (mcr & MCR_RTS)
-                status = TISetRts (port);
-        else
-                status = TIClearRts (port);
-
+        status = ti_do_config(port, UMPC_SET_CLR_RTS, mcr & MCR_RTS);
         if (status)
                 return status;
-
-        if (mcr & MCR_LOOPBACK)
-                status = TISetLoopBack (port);
-        else
-                status = TIClearLoopBack (port);
-
-        return status;
+        return ti_do_config(port, UMPC_SET_CLR_LOOPBACK, mcr & MCR_LOOPBACK);
 }
 
-
-
 /* Convert TI LSR to standard UART flags */
-static __u8 MapLineStatus (__u8 ti_lsr)
+static __u8 map_line_status(__u8 ti_lsr)
 {
         __u8 lsr = 0;
 
@@ -1647,22 +1520,23 @@ static __u8 MapLineStatus (__u8 ti_lsr)
         MAP_FLAG(UMP_UART_LSR_PE_MASK, LSR_PAR_ERR)     /* parity error */
         MAP_FLAG(UMP_UART_LSR_FE_MASK, LSR_FRM_ERR)     /* framing error */
         MAP_FLAG(UMP_UART_LSR_BR_MASK, LSR_BREAK)       /* break detected */
-        MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL)    /* receive data available */
-        MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY)    /* transmit holding register empty */
+        MAP_FLAG(UMP_UART_LSR_RX_MASK, LSR_RX_AVAIL)    /* rx data available */
+        MAP_FLAG(UMP_UART_LSR_TX_MASK, LSR_TX_EMPTY)    /* tx hold reg empty */
 
 #undef MAP_FLAG
 
         return lsr;
 }
 
-static void handle_new_msr (struct edgeport_port *edge_port, __u8 msr)
+static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
 {
         struct async_icount *icount;
         struct tty_struct *tty;
 
-        dbg ("%s - %02x", __func__, msr);
+        dbg("%s - %02x", __func__, msr);
 
-        if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR | EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
+        if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
+                        EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
                 icount = &edge_port->icount;
 
                 /* update input line counters */
@@ -1674,7 +1548,7 @@ static void handle_new_msr (struct edgeport_port *edge_port, __u8 msr)
                         icount->dcd++;
                 if (msr & EDGEPORT_MSR_DELTA_RI)
                         icount->rng++;
-                wake_up_interruptible (&edge_port->delta_msr_wait);
+                wake_up_interruptible(&edge_port->delta_msr_wait);
         }
 
         /* Save the new modem status */
@@ -1694,26 +1568,28 @@ static void handle_new_msr (struct edgeport_port *edge_port, __u8 msr)
         return;
 }
 
-static void handle_new_lsr (struct edgeport_port *edge_port, int lsr_data, __u8 lsr, __u8 data)
+static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
+                                                        __u8 lsr, __u8 data)
 {
         struct async_icount *icount;
-        __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
+        __u8 new_lsr = (__u8)(lsr & (__u8)(LSR_OVER_ERR | LSR_PAR_ERR |
+                                                LSR_FRM_ERR | LSR_BREAK));
 
-        dbg ("%s - %02x", __func__, new_lsr);
+        dbg("%s - %02x", __func__, new_lsr);
 
         edge_port->shadow_lsr = lsr;
 
-        if (new_lsr & LSR_BREAK) {
+        if (new_lsr & LSR_BREAK)
                 /*
                  * Parity and Framing errors only count if they
                  * occur exclusive of a break being received.
                  */
                 new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
-        }
 
         /* Place LSR data byte into Rx buffer */
         if (lsr_data && edge_port->port->tty)
-                edge_tty_recv(&edge_port->port->dev, edge_port->port->tty, &data, 1);
+                edge_tty_recv(&edge_port->port->dev, edge_port->port->tty,
+                                                                &data, 1);
 
         /* update input line counters */
         icount = &edge_port->icount;
@@ -1728,7 +1604,7 @@ static void handle_new_lsr (struct edgeport_port *edge_port, int lsr_data, __u8
 }
 
 
-static void edge_interrupt_callback (struct urb *urb)
+static void edge_interrupt_callback(struct urb *urb)
 {
         struct edgeport_serial *edge_serial = urb->context;
         struct usb_serial_port *port;
@@ -1762,66 +1638,71 @@ static void edge_interrupt_callback (struct urb *urb)
         }
 
         if (!length) {
-                dbg ("%s - no data in urb", __func__);
+                dbg("%s - no data in urb", __func__);
                 goto exit;
         }
-                
-        usb_serial_debug_data(debug, &edge_serial->serial->dev->dev, __func__, length, data);
-                
+
+        usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
+                                                __func__, length, data);
+
         if (length != 2) {
-                dbg ("%s - expecting packet of size 2, got %d", __func__, length);
+                dbg("%s - expecting packet of size 2, got %d",
+                                                        __func__, length);
                 goto exit;
         }
 
-        port_number = TIUMP_GET_PORT_FROM_CODE (data[0]);
-        function    = TIUMP_GET_FUNC_FROM_CODE (data[0]);
-        dbg ("%s - port_number %d, function %d, info 0x%x",
+        port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);
+        function    = TIUMP_GET_FUNC_FROM_CODE(data[0]);
+        dbg("%s - port_number %d, function %d, info 0x%x",
              __func__, port_number, function, data[1]);
         port = edge_serial->serial->port[port_number];
         edge_port = usb_get_serial_port_data(port);
         if (!edge_port) {
-                dbg ("%s - edge_port not found", __func__);
+                dbg("%s - edge_port not found", __func__);
                 return;
         }
         switch (function) {
         case TIUMP_INTERRUPT_CODE_LSR:
-                lsr = MapLineStatus(data[1]);
+                lsr = map_line_status(data[1]);
                 if (lsr & UMP_UART_LSR_DATA_MASK) {
-                        /* Save the LSR event for bulk read completion routine */
-                        dbg ("%s - LSR Event Port %u LSR Status = %02x",
+                        /* Save the LSR event for bulk read
+                           completion routine */
+                        dbg("%s - LSR Event Port %u LSR Status = %02x",
                              __func__, port_number, lsr);
                         edge_port->lsr_event = 1;
                         edge_port->lsr_mask = lsr;
                 } else {
-                        dbg ("%s - ===== Port %d LSR Status = %02x ======",
+                        dbg("%s - ===== Port %d LSR Status = %02x ======",
                              __func__, port_number, lsr);
-                        handle_new_lsr (edge_port, 0, lsr, 0);
+                        handle_new_lsr(edge_port, 0, lsr, 0);
                 }
                 break;
 
-        case TIUMP_INTERRUPT_CODE_MSR:  // MSR
+        case TIUMP_INTERRUPT_CODE_MSR:  /* MSR */
                 /* Copy MSR from UMP */
                 msr = data[1];
-                dbg ("%s - ===== Port %u MSR Status = %02x ======\n",
+                dbg("%s - ===== Port %u MSR Status = %02x ======\n",
                      __func__, port_number, msr);
-                handle_new_msr (edge_port, msr);
+                handle_new_msr(edge_port, msr);
                 break;
 
         default:
-                dev_err (&urb->dev->dev, "%s - Unknown Interrupt code from UMP %x\n",
-                         __func__, data[1]);
+                dev_err(&urb->dev->dev,
+                        "%s - Unknown Interrupt code from UMP %x\n",
+                        __func__, data[1]);
                 break;
-                
+
         }
 
 exit:
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
-                dev_err (&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
+                dev_err(&urb->dev->dev,
+                        "%s - usb_submit_urb failed with result %d\n",
                          __func__, retval);
 }
 
-static void edge_bulk_in_callback (struct urb *urb)
+static void edge_bulk_in_callback(struct urb *urb)
 {
         struct edgeport_port *edge_port = urb->context;
         unsigned char *data = urb->transfer_buffer;
@@ -1844,15 +1725,16 @@ static void edge_bulk_in_callback (struct urb *urb)
                     __func__, status);
                 return;
         default:
-                dev_err (&urb->dev->dev,"%s - nonzero read bulk status received: %d\n",
-                     __func__, status);
+                dev_err(&urb->dev->dev,
+                        "%s - nonzero read bulk status received: %d\n",
+                             __func__, status);
         }
 
         if (status == -EPIPE)
                 goto exit;
 
         if (status) {
-                dev_err(&urb->dev->dev,"%s - stopping read!\n", __func__);
+                dev_err(&urb->dev->dev, "%s - stopping read!\n", __func__);
                 return;
         }
 
@@ -1860,9 +1742,9 @@ static void edge_bulk_in_callback (struct urb *urb)
 
         if (edge_port->lsr_event) {
                 edge_port->lsr_event = 0;
-                dbg ("%s ===== Port %u LSR Status = %02x, Data = %02x ======",
+                dbg("%s ===== Port %u LSR Status = %02x, Data = %02x ======",
                      __func__, port_number, edge_port->lsr_mask, *data);
-                handle_new_lsr (edge_port, 1, edge_port->lsr_mask, *data);
+                handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);
                 /* Adjust buffer length/pointer */
                 --urb->actual_length;
                 ++data;
@@ -1870,13 +1752,14 @@ static void edge_bulk_in_callback (struct urb *urb)
 
         tty = edge_port->port->tty;
         if (tty && urb->actual_length) {
-                usb_serial_debug_data(debug, &edge_port->port->dev, __func__, urb->actual_length, data);
-
-                if (edge_port->close_pending) {
-                        dbg ("%s - close is pending, dropping data on the floor.", __func__);
-                } else {
-                        edge_tty_recv(&edge_port->port->dev, tty, data, urb->actual_length);
-                }
+                usb_serial_debug_data(debug, &edge_port->port->dev,
+                                        __func__, urb->actual_length, data);
+                if (edge_port->close_pending)
+                        dbg("%s - close pending, dropping data on the floor",
+                                                                __func__);
+                else
+                        edge_tty_recv(&edge_port->port->dev, tty, data,
+                                                        urb->actual_length);
                 edge_port->icount.rx += urb->actual_length;
         }
 
@@ -1891,37 +1774,31 @@ exit:
         }
         spin_unlock(&edge_port->ep_lock);
         if (retval)
-                dev_err (&urb->dev->dev, "%s - usb_submit_urb failed with result %d\n",
+                dev_err(&urb->dev->dev,
+                        "%s - usb_submit_urb failed with result %d\n",
                          __func__, retval);
 }
 
-static void edge_tty_recv(struct device *dev, struct tty_struct *tty, unsigned char *data, int length)
+static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
+                                        unsigned char *data, int length)
 {
-        int cnt;
-
-        do {
-                cnt = tty_buffer_request_room(tty, length);
-                if (cnt < length) {
-                        dev_err(dev, "%s - dropping data, %d bytes lost\n",
-                                __func__, length - cnt);
-                        if(cnt == 0)
-                                break;
-                }
-                tty_insert_flip_string(tty, data, cnt);
-                data += cnt;
-                length -= cnt;
-        } while (length > 0);
+        int queued;
 
+        tty_buffer_request_room(tty, length);
+        queued = tty_insert_flip_string(tty, data, length);
+        if (queued < length)
+                dev_err(dev, "%s - dropping data, %d bytes lost\n",
+                        __func__, length - queued);
         tty_flip_buffer_push(tty);
 }
 
-static void edge_bulk_out_callback (struct urb *urb)
+static void edge_bulk_out_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status = urb->status;
 
-        dbg ("%s - port %d", __func__, port->number);
+        dbg("%s - port %d", __func__, port->number);
 
         edge_port->ep_write_urb_in_use = 0;
 
@@ -1945,7 +1822,7 @@ static void edge_bulk_out_callback (struct urb *urb)
         edge_send(port);
 }
 
-static int edge_open (struct usb_serial_port *port, struct file * filp)
+static int edge_open(struct usb_serial_port *port, struct file *filp)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct edgeport_serial *edge_serial;
@@ -1965,118 +1842,119 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
 
         port_number = port->number - port->serial->minor;
         switch (port_number) {
-                case 0:
-                        edge_port->uart_base = UMPMEM_BASE_UART1;
-                        edge_port->dma_address = UMPD_OEDB1_ADDRESS;
-                        break;
-                case 1:
-                        edge_port->uart_base = UMPMEM_BASE_UART2;
-                        edge_port->dma_address = UMPD_OEDB2_ADDRESS;
-                        break;
-                default:
-                        dev_err (&port->dev, "Unknown port number!!!\n");
-                        return -ENODEV;
+        case 0:
+                edge_port->uart_base = UMPMEM_BASE_UART1;
+                edge_port->dma_address = UMPD_OEDB1_ADDRESS;
+                break;
+        case 1:
+                edge_port->uart_base = UMPMEM_BASE_UART2;
+                edge_port->dma_address = UMPD_OEDB2_ADDRESS;
+                break;
+        default:
+                dev_err(&port->dev, "Unknown port number!!!\n");
+                return -ENODEV;
         }
 
-        dbg ("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
-             __func__, port_number, edge_port->uart_base, edge_port->dma_address);
+        dbg("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
+                                __func__, port_number, edge_port->uart_base,
+                                edge_port->dma_address);
 
         dev = port->serial->dev;
 
-        memset (&(edge_port->icount), 0x00, sizeof(edge_port->icount));
-        init_waitqueue_head (&edge_port->delta_msr_wait);
+        memset(&(edge_port->icount), 0x00, sizeof(edge_port->icount));
+        init_waitqueue_head(&edge_port->delta_msr_wait);
 
         /* turn off loopback */
-        status = TIClearLoopBack (edge_port);
+        status = ti_do_config(edge_port, UMPC_SET_CLR_LOOPBACK, 0);
         if (status) {
-                dev_err(&port->dev,"%s - cannot send clear loopback command, %d\n",
+                dev_err(&port->dev,
+                                "%s - cannot send clear loopback command, %d\n",
                         __func__, status);
                 return status;
         }
-        
+
         /* set up the port settings */
-        edge_set_termios (port, port->tty->termios);
+        edge_set_termios(port, port->tty->termios);
 
         /* open up the port */
 
         /* milliseconds to timeout for DMA transfer */
         transaction_timeout = 2;
 
-        edge_port->ump_read_timeout = max (20, ((transaction_timeout * 3) / 2) );
+        edge_port->ump_read_timeout =
+                                max(20, ((transaction_timeout * 3) / 2));
 
-        // milliseconds to timeout for DMA transfer
-        open_settings = (u8)(UMP_DMA_MODE_CONTINOUS | 
-                             UMP_PIPE_TRANS_TIMEOUT_ENA | 
+        /* milliseconds to timeout for DMA transfer */
+        open_settings = (u8)(UMP_DMA_MODE_CONTINOUS |
+                             UMP_PIPE_TRANS_TIMEOUT_ENA |
                              (transaction_timeout << 2));
 
-        dbg ("%s - Sending UMPC_OPEN_PORT", __func__);
+        dbg("%s - Sending UMPC_OPEN_PORT", __func__);
 
         /* Tell TI to open and start the port */
-        status = TIWriteCommandSync (dev,
-                                        UMPC_OPEN_PORT,
-                                        (u8)(UMPM_UART1_PORT + port_number),
-                                        open_settings,
-                                        NULL,
-                                        0);
+        status = send_cmd(dev, UMPC_OPEN_PORT,
+                (u8)(UMPM_UART1_PORT + port_number), open_settings, NULL, 0);
         if (status) {
-                dev_err(&port->dev,"%s - cannot send open command, %d\n", __func__, status);
+                dev_err(&port->dev, "%s - cannot send open command, %d\n",
+                                                        __func__, status);
                 return status;
         }
 
         /* Start the DMA? */
-        status = TIWriteCommandSync (dev,
-                                        UMPC_START_PORT,
-                                        (u8)(UMPM_UART1_PORT + port_number),
-                                        0,
-                                        NULL,
-                                        0);
+        status = send_cmd(dev, UMPC_START_PORT,
+                (u8)(UMPM_UART1_PORT + port_number), 0, NULL, 0);
         if (status) {
-                dev_err(&port->dev,"%s - cannot send start DMA command, %d\n", __func__, status);
+                dev_err(&port->dev, "%s - cannot send start DMA command, %d\n",
+                                                        __func__, status);
                 return status;
         }
 
         /* Clear TX and RX buffers in UMP */
-        status = TIPurgeDataSync (port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
+        status = purge_port(port, UMP_PORT_DIR_OUT | UMP_PORT_DIR_IN);
         if (status) {
-                dev_err(&port->dev,"%s - cannot send clear buffers command, %d\n", __func__, status);
+                dev_err(&port->dev,
+                        "%s - cannot send clear buffers command, %d\n",
+                        __func__, status);
                 return status;
         }
 
         /* Read Initial MSR */
-        status = TIReadVendorRequestSync (dev,
-                                        UMPC_READ_MSR,  // Request
-                                        0,              // wValue
-                                        (__u16)(UMPM_UART1_PORT + port_number), // wIndex (Address)
-                                        &edge_port->shadow_msr,                 // TransferBuffer
-                                        1);                                     // TransferBufferLength
+        status = ti_vread_sync(dev, UMPC_READ_MSR, 0,
+                                (__u16)(UMPM_UART1_PORT + port_number),
+                                &edge_port->shadow_msr, 1);
         if (status) {
-                dev_err(&port->dev,"%s - cannot send read MSR command, %d\n", __func__, status);
+                dev_err(&port->dev, "%s - cannot send read MSR command, %d\n",
+                                                        __func__, status);
                 return status;
         }
 
-        dbg ("ShadowMSR 0x%X", edge_port->shadow_msr);
- 
+        dbg("ShadowMSR 0x%X", edge_port->shadow_msr);
+
         /* Set Initial MCR */
         edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
-        dbg ("ShadowMCR 0x%X", edge_port->shadow_mcr);
+        dbg("ShadowMCR 0x%X", edge_port->shadow_mcr);
 
         edge_serial = edge_port->edge_serial;
         if (mutex_lock_interruptible(&edge_serial->es_lock))
                 return -ERESTARTSYS;
         if (edge_serial->num_ports_open == 0) {
-                /* we are the first port to be opened, let's post the interrupt urb */
+                /* we are the first port to open, post the interrupt urb */
                 urb = edge_serial->serial->port[0]->interrupt_in_urb;
                 if (!urb) {
-                        dev_err (&port->dev, "%s - no interrupt urb present, exiting\n", __func__);
+                        dev_err(&port->dev,
+                                "%s - no interrupt urb present, exiting\n",
+                                __func__);
                         status = -EINVAL;
                         goto release_es_lock;
                 }
                 urb->complete = edge_interrupt_callback;
                 urb->context = edge_serial;
                 urb->dev = dev;
-                status = usb_submit_urb (urb, GFP_KERNEL);
+                status = usb_submit_urb(urb, GFP_KERNEL);
                 if (status) {
-                        dev_err (&port->dev, "%s - usb_submit_urb failed with value %d\n", __func__, status);
+                        dev_err(&port->dev,
+                                "%s - usb_submit_urb failed with value %d\n",
+                                        __func__, status);
                         goto release_es_lock;
                 }
         }
@@ -2085,13 +1963,14 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
          * reset the data toggle on the bulk endpoints to work around bug in
          * host controllers where things get out of sync some times
          */
-        usb_clear_halt (dev, port->write_urb->pipe);
-        usb_clear_halt (dev, port->read_urb->pipe);
+        usb_clear_halt(dev, port->write_urb->pipe);
+        usb_clear_halt(dev, port->read_urb->pipe);
 
         /* start up our bulk read urb */
         urb = port->read_urb;
         if (!urb) {
-                dev_err (&port->dev, "%s - no read urb present, exiting\n", __func__);
+                dev_err(&port->dev, "%s - no read urb present, exiting\n",
+                                                                __func__);
                 status = -EINVAL;
                 goto unlink_int_urb;
         }
@@ -2099,9 +1978,11 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
         urb->complete = edge_bulk_in_callback;
         urb->context = edge_port;
         urb->dev = dev;
-        status = usb_submit_urb (urb, GFP_KERNEL);
+        status = usb_submit_urb(urb, GFP_KERNEL);
         if (status) {
-                dev_err (&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __func__, status);
+                dev_err(&port->dev,
+                        "%s - read bulk usb_submit_urb failed with value %d\n",
+                                __func__, status);
                 goto unlink_int_urb;
         }
 
@@ -2119,7 +2000,7 @@ release_es_lock:
         return status;
 }
 
-static void edge_close (struct usb_serial_port *port, struct file *filp)
+static void edge_close(struct usb_serial_port *port, struct file *filp)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
@@ -2127,18 +2008,18 @@ static void edge_close (struct usb_serial_port *port, struct file *filp)
         int status;
 
         dbg("%s - port %d", __func__, port->number);
-                         
+
         edge_serial = usb_get_serial_data(port->serial);
         edge_port = usb_get_serial_port_data(port);
-        if ((edge_serial == NULL) || (edge_port == NULL))
+        if (edge_serial == NULL || edge_port == NULL)
                 return;
-        
-        /* The bulkreadcompletion routine will check 
+
+        /* The bulkreadcompletion routine will check
          * this flag and dump add read data */
         edge_port->close_pending = 1;
 
         /* chase the port close and flush */
-        TIChasePort (edge_port, (HZ*closing_wait)/100, 1);
+        chase_port(edge_port, (HZ * closing_wait) / 100, 1);
 
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->write_urb);
@@ -2148,7 +2029,7 @@ static void edge_close (struct usb_serial_port *port, struct file *filp)
          * send a close port command to it */
         dbg("%s - send umpc_close_port", __func__);
         port_number = port->number - port->serial->minor;
-        status = TIWriteCommandSync (port->serial->dev,
+        status = send_cmd(port->serial->dev,
                                      UMPC_CLOSE_PORT,
                                      (__u8)(UMPM_UART1_PORT + port_number),
                                      0,
@@ -2167,7 +2048,8 @@ static void edge_close (struct usb_serial_port *port, struct file *filp)
         dbg("%s - exited", __func__);
 }
 
-static int edge_write (struct usb_serial_port *port, const unsigned char *data, int count)
+static int edge_write(struct usb_serial_port *port, const unsigned char *data,
+                                                                int count)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned long flags;
@@ -2223,11 +2105,12 @@ static void edge_send(struct usb_serial_port *port)
 
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count, port->write_urb->transfer_buffer);
+        usb_serial_debug_data(debug, &port->dev, __func__, count,
+                                port->write_urb->transfer_buffer);
 
         /* set up our urb */
-        usb_fill_bulk_urb (port->write_urb, port->serial->dev,
-                           usb_sndbulkpipe (port->serial->dev,
+        usb_fill_bulk_urb(port->write_urb, port->serial->dev,
+                           usb_sndbulkpipe(port->serial->dev,
                                             port->bulk_out_endpointAddress),
                            port->write_urb->transfer_buffer, count,
                            edge_bulk_out_callback,
@@ -2236,22 +2119,21 @@ static void edge_send(struct usb_serial_port *port)
         /* send the data out the bulk port */
         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
         if (result) {
-                dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__, result);
+                dev_err(&port->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                                __func__, result);
                 edge_port->ep_write_urb_in_use = 0;
-                // TODO: reschedule edge_send
-        } else {
+                /* TODO: reschedule edge_send */
+        } else
                 edge_port->icount.tx += count;
-        }
 
         /* wakeup any process waiting for writes to complete */
         /* there is now more room in the buffer for new writes */
-        if (tty) {
-                /* let the tty driver wakeup if it has a special write_wakeup function */
+        if (tty)
                 tty_wakeup(tty);
-        }
 }
 
-static int edge_write_room (struct usb_serial_port *port)
+static int edge_write_room(struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int room = 0;
@@ -2260,9 +2142,9 @@ static int edge_write_room (struct usb_serial_port *port)
         dbg("%s - port %d", __func__, port->number);
 
         if (edge_port == NULL)
-                return -ENODEV;
+                return 0;
         if (edge_port->close_pending == 1)
-                return -ENODEV;
+                return 0;
 
         spin_lock_irqsave(&edge_port->ep_lock, flags);
         room = edge_buf_space_avail(edge_port->ep_out_buf);
@@ -2272,7 +2154,7 @@ static int edge_write_room (struct usb_serial_port *port)
         return room;
 }
 
-static int edge_chars_in_buffer (struct usb_serial_port *port)
+static int edge_chars_in_buffer(struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int chars = 0;
@@ -2281,22 +2163,22 @@ static int edge_chars_in_buffer (struct usb_serial_port *port)
         dbg("%s - port %d", __func__, port->number);
 
         if (edge_port == NULL)
-                return -ENODEV;
+                return 0;
         if (edge_port->close_pending == 1)
-                return -ENODEV;
+                return 0;
 
         spin_lock_irqsave(&edge_port->ep_lock, flags);
         chars = edge_buf_data_avail(edge_port->ep_out_buf);
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        dbg ("%s - returns %d", __func__, chars);
+        dbg("%s - returns %d", __func__, chars);
         return chars;
 }
 
-static void edge_throttle (struct usb_serial_port *port)
+static void edge_throttle(struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
+        struct tty_struct *tty = port->tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -2304,19 +2186,14 @@ static void edge_throttle (struct usb_serial_port *port)
         if (edge_port == NULL)
                 return;
 
-        tty = port->tty;
-        if (!tty) {
-                dbg ("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
-                status = edge_write (port, &stop_char, 1);
-                if (status <= 0) {
-                        dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
-                }
+                status = edge_write(port, &stop_char, 1);
+                if (status <= 0)
+                        dev_err(&port->dev,
+                                "%s - failed to write stop character, %d\n",
+                                                        __func__, status);
         }
 
         /* if we are implementing RTS/CTS, stop reads */
@@ -2326,10 +2203,10 @@ static void edge_throttle (struct usb_serial_port *port)
 
 }
 
-static void edge_unthrottle (struct usb_serial_port *port)
+static void edge_unthrottle(struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
-        struct tty_struct *tty;
+        struct tty_struct *tty = port->tty;
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -2337,27 +2214,23 @@ static void edge_unthrottle (struct usb_serial_port *port)
         if (edge_port == NULL)
                 return;
 
-        tty = port->tty;
-        if (!tty) {
-                dbg ("%s - no tty available", __func__);
-                return;
-        }
-
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
-                status = edge_write (port, &start_char, 1);
-                if (status <= 0) {
-                        dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
-                }
+                status = edge_write(port, &start_char, 1);
+                if (status <= 0)
+                        dev_err(&port->dev,
+                                "%s - failed to write start character, %d\n",
+                                                        __func__, status);
         }
-
         /* if we are implementing RTS/CTS, restart reads */
         /* are the Edgeport will assert the RTS line */
         if (C_CRTSCTS(tty)) {
                 status = restart_read(edge_port);
                 if (status)
-                        dev_err(&port->dev, "%s - read bulk usb_submit_urb failed with value %d\n", __func__, status);
+                        dev_err(&port->dev,
+                                "%s - read bulk usb_submit_urb failed: %d\n",
+                                                        __func__, status);
         }
 
 }
@@ -2398,22 +2271,26 @@ static int restart_read(struct edgeport_port *edge_port)
         return status;
 }
 
-static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios)
+static void change_port_settings(struct edgeport_port *edge_port,
+                                                struct ktermios *old_termios)
 {
         struct ump_uart_config *config;
         struct tty_struct *tty;
         int baud;
         unsigned cflag;
         int status;
-        int port_number = edge_port->port->number - edge_port->port->serial->minor;
+        int port_number = edge_port->port->number -
+                                        edge_port->port->serial->minor;
 
         dbg("%s - port %d", __func__, edge_port->port->number);
 
         tty = edge_port->port->tty;
 
-        config = kmalloc (sizeof (*config), GFP_KERNEL);
+        config = kmalloc(sizeof(*config), GFP_KERNEL);
         if (!config) {
-                dev_err (&edge_port->port->dev, "%s - out of memory\n", __func__);
+                *tty->termios = *old_termios;
+                dev_err(&edge_port->port->dev, "%s - out of memory\n",
+                                                                __func__);
                 return;
         }
 
@@ -2427,22 +2304,22 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
         config->bUartMode = (__u8)(edge_port->bUartMode);
 
         switch (cflag & CSIZE) {
-                case CS5:
-                            config->bDataBits = UMP_UART_CHAR5BITS;
-                            dbg ("%s - data bits = 5", __func__);
-                            break;
-                case CS6:
-                            config->bDataBits = UMP_UART_CHAR6BITS;
-                            dbg ("%s - data bits = 6", __func__);
-                            break;
-                case CS7:
-                            config->bDataBits = UMP_UART_CHAR7BITS;
-                            dbg ("%s - data bits = 7", __func__);
-                            break;
-                default:
-                case CS8:
-                            config->bDataBits = UMP_UART_CHAR8BITS;
-                            dbg ("%s - data bits = 8", __func__);
+        case CS5:
+                    config->bDataBits = UMP_UART_CHAR5BITS;
+                    dbg("%s - data bits = 5", __func__);
+                    break;
+        case CS6:
+                    config->bDataBits = UMP_UART_CHAR6BITS;
+                    dbg("%s - data bits = 6", __func__);
+                    break;
+        case CS7:
+                    config->bDataBits = UMP_UART_CHAR7BITS;
+                    dbg("%s - data bits = 7", __func__);
+                    break;
+        default:
+        case CS8:
+                    config->bDataBits = UMP_UART_CHAR8BITS;
+                    dbg("%s - data bits = 8", __func__);
                             break;
         }
 
@@ -2457,7 +2334,7 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
                         dbg("%s - parity = even", __func__);
                 }
         } else {
-                config->bParity = UMP_UART_NOPARITY;    
+                config->bParity = UMP_UART_NOPARITY;
                 dbg("%s - parity = none", __func__);
         }
 
@@ -2480,29 +2357,26 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
                 restart_read(edge_port);
         }
 
-        /* if we are implementing XON/XOFF, set the start and stop character in the device */
-        if (I_IXOFF(tty) || I_IXON(tty)) {
-                config->cXon  = START_CHAR(tty);
-                config->cXoff = STOP_CHAR(tty);
+        /* if we are implementing XON/XOFF, set the start and stop
+           character in the device */
+        config->cXon  = START_CHAR(tty);
+        config->cXoff = STOP_CHAR(tty);
 
-                /* if we are implementing INBOUND XON/XOFF */
-                if (I_IXOFF(tty)) {
-                        config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
-                        dbg ("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                             __func__, config->cXon, config->cXoff);
-                } else {
-                        dbg ("%s - INBOUND XON/XOFF is disabled", __func__);
-                }
+        /* if we are implementing INBOUND XON/XOFF */
+        if (I_IXOFF(tty)) {
+                config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
+                dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
+                     __func__, config->cXon, config->cXoff);
+        } else
+                dbg("%s - INBOUND XON/XOFF is disabled", __func__);
 
-                /* if we are implementing OUTBOUND XON/XOFF */
-                if (I_IXON(tty)) {
-                        config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
-                        dbg ("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                             __func__, config->cXon, config->cXoff);
-                } else {
-                        dbg ("%s - OUTBOUND XON/XOFF is disabled", __func__);
-                }
-        }
+        /* if we are implementing OUTBOUND XON/XOFF */
+        if (I_IXON(tty)) {
+                config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
+                dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
+                     __func__, config->cXon, config->cXoff);
+        } else
+                dbg("%s - OUTBOUND XON/XOFF is disabled", __func__);
 
         tty->termios->c_cflag &= ~CMSPAR;
 
@@ -2519,62 +2393,52 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
 
         /* FIXME: Recompute actual baud from divisor here */
 
-        dbg ("%s - baud rate = %d, wBaudRate = %d", __func__, baud, config->wBaudRate);
+        dbg("%s - baud rate = %d, wBaudRate = %d", __func__, baud,
+                                                        config->wBaudRate);
 
-        dbg ("wBaudRate:   %d", (int)(461550L / config->wBaudRate));
-        dbg ("wFlags:    0x%x", config->wFlags);
-        dbg ("bDataBits:   %d", config->bDataBits);
-        dbg ("bParity:     %d", config->bParity);
-        dbg ("bStopBits:   %d", config->bStopBits);
-        dbg ("cXon:        %d", config->cXon);
-        dbg ("cXoff:       %d", config->cXoff);
-        dbg ("bUartMode:   %d", config->bUartMode);
+        dbg("wBaudRate:   %d", (int)(461550L / config->wBaudRate));
+        dbg("wFlags:    0x%x", config->wFlags);
+        dbg("bDataBits:   %d", config->bDataBits);
+        dbg("bParity:     %d", config->bParity);
+        dbg("bStopBits:   %d", config->bStopBits);
+        dbg("cXon:        %d", config->cXon);
+        dbg("cXoff:       %d", config->cXoff);
+        dbg("bUartMode:   %d", config->bUartMode);
 
         /* move the word values into big endian mode */
-        cpu_to_be16s (&config->wFlags);
-        cpu_to_be16s (&config->wBaudRate);
+        cpu_to_be16s(&config->wFlags);
+        cpu_to_be16s(&config->wBaudRate);
 
-        status = TIWriteCommandSync (edge_port->port->serial->dev,
-                                UMPC_SET_CONFIG,
+        status = send_cmd(edge_port->port->serial->dev, UMPC_SET_CONFIG,
                                 (__u8)(UMPM_UART1_PORT + port_number),
-                                0,
-                                (__u8 *)config,
-                                sizeof(*config));
-        if (status) {
-                dbg ("%s - error %d when trying to write config to device",
+                                0, (__u8 *)config, sizeof(*config));
+        if (status)
+                dbg("%s - error %d when trying to write config to device",
                      __func__, status);
-        }
-
-        kfree (config);
-        
+        kfree(config);
         return;
 }
 
-static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void edge_set_termios(struct usb_serial_port *port,
+                                        struct ktermios *old_termios)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct tty_struct *tty = port->tty;
-        unsigned int cflag;
-
-        cflag = tty->termios->c_cflag;
 
         dbg("%s - clfag %08x iflag %08x", __func__,
             tty->termios->c_cflag, tty->termios->c_iflag);
         dbg("%s - old clfag %08x old iflag %08x", __func__,
             old_termios->c_cflag, old_termios->c_iflag);
-
         dbg("%s - port %d", __func__, port->number);
 
         if (edge_port == NULL)
                 return;
-
         /* change the port settings to the new ones specified */
-        change_port_settings (edge_port, old_termios);
-
-        return;
+        change_port_settings(edge_port, old_termios);
 }
 
-static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear)
+static int edge_tiocmset(struct usb_serial_port *port, struct file *file,
+                                        unsigned int set, unsigned int clear)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int mcr;
@@ -2601,8 +2465,7 @@ static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsig
         edge_port->shadow_mcr = mcr;
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        TIRestoreMCR (edge_port, mcr);
-
+        restore_mcr(edge_port, mcr);
         return 0;
 }
 
@@ -2634,7 +2497,8 @@ static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
         return result;
 }
 
-static int get_serial_info (struct edgeport_port *edge_port, struct serial_struct __user *retinfo)
+static int get_serial_info(struct edgeport_port *edge_port,
+                                struct serial_struct __user *retinfo)
 {
         struct serial_struct tmp;
 
@@ -2652,17 +2516,14 @@ static int get_serial_info (struct edgeport_port *edge_port, struct serial_struc
         tmp.baud_base           = 9600;
         tmp.close_delay         = 5*HZ;
         tmp.closing_wait        = closing_wait;
-//      tmp.custom_divisor      = state->custom_divisor;
-//      tmp.hub6                = state->hub6;
-//      tmp.io_type             = state->io_type;
-
 
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
         return 0;
 }
 
-static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
+static int edge_ioctl(struct usb_serial_port *port, struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct async_icount cnow;
@@ -2671,81 +2532,63 @@ static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned
         dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
 
         switch (cmd) {
-                case TIOCINQ:
-                        dbg("%s - (%d) TIOCINQ", __func__, port->number);
-//                      return get_number_bytes_avail(edge_port, (unsigned int *) arg);
-                        break;
-
-                case TIOCSERGETLSR:
-                        dbg("%s - (%d) TIOCSERGETLSR", __func__, port->number);
-//                      return get_lsr_info(edge_port, (unsigned int *) arg);
-                        break;
-
-                case TIOCGSERIAL:
-                        dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
-                        return get_serial_info(edge_port, (struct serial_struct __user *) arg);
-                        break;
-
-                case TIOCSSERIAL:
-                        dbg("%s - (%d) TIOCSSERIAL", __func__, port->number);
-                        break;
-
-                case TIOCMIWAIT:
-                        dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
-                        cprev = edge_port->icount;
-                        while (1) {
-                                interruptible_sleep_on(&edge_port->delta_msr_wait);
-                                /* see if a signal did it */
-                                if (signal_pending(current))
-                                        return -ERESTARTSYS;
-                                cnow = edge_port->icount;
-                                if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
-                                    cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
-                                        return -EIO; /* no change => error */
-                                if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
-                                    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
-                                    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
-                                    ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
-                                        return 0;
-                                }
-                                cprev = cnow;
+        case TIOCGSERIAL:
+                dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
+                return get_serial_info(edge_port,
+                                (struct serial_struct __user *) arg);
+        case TIOCMIWAIT:
+                dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
+                cprev = edge_port->icount;
+                while (1) {
+                        interruptible_sleep_on(&edge_port->delta_msr_wait);
+                        /* see if a signal did it */
+                        if (signal_pending(current))
+                                return -ERESTARTSYS;
+                        cnow = edge_port->icount;
+                        if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
+                            cnow.dcd == cprev.dcd && cnow.cts == cprev.cts)
+                                return -EIO; /* no change => error */
+                        if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
+                            ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
+                            ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
+                            ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                                return 0;
                         }
-                        /* not reached */
-                        break;
-
-                case TIOCGICOUNT:
-                        dbg ("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                             port->number, edge_port->icount.rx, edge_port->icount.tx);
-                        if (copy_to_user((void __user *)arg, &edge_port->icount, sizeof(edge_port->icount)))
-                                return -EFAULT;
-                        return 0;
+                        cprev = cnow;
+                }
+                /* not reached */
+                break;
+        case TIOCGICOUNT:
+                dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
+                     port->number, edge_port->icount.rx, edge_port->icount.tx);
+                if (copy_to_user((void __user *)arg, &edge_port->icount,
+                                sizeof(edge_port->icount)))
+                        return -EFAULT;
+                return 0;
         }
-
         return -ENOIOCTLCMD;
 }
 
-static void edge_break (struct usb_serial_port *port, int break_state)
+static void edge_break(struct usb_serial_port *port, int on)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
+        int bv = 0;     /* Off */
 
-        dbg ("%s - state = %d", __func__, break_state);
+        dbg("%s - state = %d", __func__, on);
 
         /* chase the port close */
-        TIChasePort (edge_port, 0, 0);
+        chase_port(edge_port, 0, 0);
 
-        if (break_state == -1) {
-                status = TISetBreak (edge_port);
-        } else {
-                status = TIClearBreak (edge_port);
-        }
-        if (status) {
-                dbg ("%s - error %d sending break set/clear command.",
+        if (on == -1)
+                bv = 1; /* On */
+        status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
+        if (status)
+                dbg("%s - error %d sending break set/clear command.",
                      __func__, status);
-        }
 }
 
-static int edge_startup (struct usb_serial *serial)
+static int edge_startup(struct usb_serial *serial)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
@@ -2765,9 +2608,9 @@ static int edge_startup (struct usb_serial *serial)
         edge_serial->serial = serial;
         usb_set_serial_data(serial, edge_serial);
 
-        status = TIDownloadFirmware (edge_serial);
+        status = download_fw(edge_serial);
         if (status) {
-                kfree (edge_serial);
+                kfree(edge_serial);
                 return status;
         }
 
@@ -2775,13 +2618,15 @@ static int edge_startup (struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; ++i) {
                 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
                 if (edge_port == NULL) {
-                        dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+                        dev_err(&serial->dev->dev, "%s - Out of memory\n",
+                                                                __func__);
                         goto cleanup;
                 }
                 spin_lock_init(&edge_port->ep_lock);
                 edge_port->ep_out_buf = edge_buf_alloc(EDGE_OUT_BUF_SIZE);
                 if (edge_port->ep_out_buf == NULL) {
-                        dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+                        dev_err(&serial->dev->dev, "%s - Out of memory\n",
+                                                                __func__);
                         kfree(edge_port);
                         goto cleanup;
                 }
@@ -2790,27 +2635,27 @@ static int edge_startup (struct usb_serial *serial)
                 usb_set_serial_port_data(serial->port[i], edge_port);
                 edge_port->bUartMode = default_uart_mode;
         }
-        
+
         return 0;
 
 cleanup:
-        for (--i; i>=0; --i) {
+        for (--i; i >= 0; --i) {
                 edge_port = usb_get_serial_port_data(serial->port[i]);
                 edge_buf_free(edge_port->ep_out_buf);
                 kfree(edge_port);
                 usb_set_serial_port_data(serial->port[i], NULL);
         }
-        kfree (edge_serial);
+        kfree(edge_serial);
         usb_set_serial_data(serial, NULL);
         return -ENOMEM;
 }
 
-static void edge_shutdown (struct usb_serial *serial)
+static void edge_shutdown(struct usb_serial *serial)
 {
         int i;
         struct edgeport_port *edge_port;
 
-        dbg ("%s", __func__);
+        dbg("%s", __func__);
 
         for (i = 0; i < serial->num_ports; ++i) {
                 edge_port = usb_get_serial_port_data(serial->port[i]);
@@ -2852,7 +2697,8 @@ static ssize_t store_uart_mode(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode, store_uart_mode);
+static DEVICE_ATTR(uart_mode, S_IWUSR | S_IRUGO, show_uart_mode,
+                                                        store_uart_mode);
 
 static int edge_create_sysfs_attrs(struct usb_serial_port *port)
 {
@@ -2922,9 +2768,9 @@ static void edge_buf_free(struct edge_buf *eb)
 
 static void edge_buf_clear(struct edge_buf *eb)
 {
-        if (eb != NULL)
-                eb->buf_get = eb->buf_put;
-                /* equivalent to a get of all data available */
+        if (eb != NULL)
+                eb->buf_get = eb->buf_put;
+        /* equivalent to a get of all data available */
 }
 
 
@@ -2937,10 +2783,9 @@ static void edge_buf_clear(struct edge_buf *eb)
 
 static unsigned int edge_buf_data_avail(struct edge_buf *eb)
 {
-        if (eb != NULL)
-                return ((eb->buf_size + eb->buf_put - eb->buf_get) % eb->buf_size);
-        else
+        if (eb == NULL)
                 return 0;
+        return ((eb->buf_size + eb->buf_put - eb->buf_get) % eb->buf_size);
 }
 
 
@@ -2953,10 +2798,9 @@ static unsigned int edge_buf_data_avail(struct edge_buf *eb)
 
 static unsigned int edge_buf_space_avail(struct edge_buf *eb)
 {
-        if (eb != NULL)
-                return ((eb->buf_size + eb->buf_get - eb->buf_put - 1) % eb->buf_size);
-        else
+        if (eb == NULL)
                 return 0;
+        return ((eb->buf_size + eb->buf_get - eb->buf_put - 1) % eb->buf_size);
 }
 
 
@@ -3113,7 +2957,7 @@ static int __init edgeport_init(void)
         if (retval)
                 goto failed_2port_device_register;
         retval = usb_register(&io_driver);
-        if (retval) 
+        if (retval)
                 goto failed_usb_register;
         info(DRIVER_DESC " " DRIVER_VERSION);
         return 0;
@@ -3125,11 +2969,11 @@ failed_1port_device_register:
         return retval;
 }
 
-static void __exit edgeport_exit (void)
+static void __exit edgeport_exit(void)
 {
-        usb_deregister (&io_driver);
-        usb_serial_deregister (&edgeport_1port_device);
-        usb_serial_deregister (&edgeport_2port_device);
+        usb_deregister(&io_driver);
+        usb_serial_deregister(&edgeport_1port_device);
+        usb_serial_deregister(&edgeport_2port_device);
 }
 
 module_init(edgeport_init);
@@ -3151,8 +2995,8 @@ module_param(closing_wait, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
 
 module_param(ignore_cpu_rev, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(ignore_cpu_rev, "Ignore the cpu revision when connecting to a device");
+MODULE_PARM_DESC(ignore_cpu_rev,
+                        "Ignore the cpu revision when connecting to a device");
 
 module_param(default_uart_mode, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(default_uart_mode, "Default uart_mode, 0=RS232, ...");
-
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index d9fb3768a2d7..80d9ec5570d6 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -646,12 +646,13 @@ static int ipaq_open(struct usb_serial_port *port, struct file *filp)
          */
 
         kfree(port->bulk_in_buffer);
-        kfree(port->bulk_out_buffer);
         port->bulk_in_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
         if (port->bulk_in_buffer == NULL) {
                 port->bulk_out_buffer = NULL; /* prevent double free */
                 goto enomem;
         }
+
+        kfree(port->bulk_out_buffer);
         port->bulk_out_buffer = kmalloc(URBDATA_SIZE, GFP_KERNEL);
         if (port->bulk_out_buffer == NULL) {
                 kfree(port->bulk_in_buffer);
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 004d57385a75..0063c11c8081 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -19,7 +19,12 @@
  * was written by Roman Weissgaerber <weissg@vienna.at>, Dag Brattli
  * <dag@brattli.net>, and Jean Tourrilhes <jt@hpl.hp.com>
  *
- * See Documentation/usb/usb-serial.txt for more information on using this driver
+ * See Documentation/usb/usb-serial.txt for more information on using this
+ * driver
+ *
+ * 2008_Jun_02  Felipe Balbi <me@felipebalbi.com>
+ *      Introduced common header to be used also in USB Gadget Framework.
+ *      Still needs some other style fixes.
  *
  * 2007_Jun_21  Alan Cox <alan@redhat.com>
  *      Minimal cleanups for some of the driver problens and tty layer abuse.
@@ -59,9 +64,10 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/usb/irda.h>
 
 /*
  * Version Information
@@ -70,100 +76,75 @@
 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
 #define DRIVER_DESC "USB IR Dongle driver"
 
-/* USB IrDA class spec information */
-#define USB_CLASS_IRDA          0x02
-#define USB_DT_IRDA             0x21
-#define IU_REQ_GET_CLASS_DESC   0x06
-#define SPEED_2400              0x01
-#define SPEED_9600              0x02
-#define SPEED_19200             0x03
-#define SPEED_38400             0x04
-#define SPEED_57600             0x05
-#define SPEED_115200            0x06
-#define SPEED_576000            0x07
-#define SPEED_1152000           0x08
-#define SPEED_4000000           0x09
-
-struct irda_class_desc {
-        u8      bLength;
-        u8      bDescriptorType;
-        u16     bcdSpecRevision;
-        u8      bmDataSize;
-        u8      bmWindowSize;
-        u8      bmMinTurnaroundTime;
-        u16     wBaudRate;
-        u8      bmAdditionalBOFs;
-        u8      bIrdaRateSniff;
-        u8      bMaxUnicastList;
-} __attribute__ ((packed));
-
 static int debug;
 
 /* if overridden by the user, then use their value for the size of the read and
  * write urbs */
 static int buffer_size;
+
 /* if overridden by the user, then use the specified number of XBOFs */
 static int xbof = -1;
 
-static int  ir_startup (struct usb_serial *serial);
-static int  ir_open (struct usb_serial_port *port, struct file *filep);
-static void ir_close (struct usb_serial_port *port, struct file *filep);
-static int  ir_write (struct usb_serial_port *port, const unsigned char *buf, int count);
-static void ir_write_bulk_callback (struct urb *urb);
-static void ir_read_bulk_callback (struct urb *urb);
-static void ir_set_termios (struct usb_serial_port *port, struct ktermios *old_termios);
+static int ir_startup(struct usb_serial *serial);
+static int ir_open(struct usb_serial_port *port, struct file *filep);
+static void ir_close(struct usb_serial_port *port, struct file *filep);
+static int ir_write(struct usb_serial_port *port,
+                const unsigned char *buf, int count);
+static void ir_write_bulk_callback(struct urb *urb);
+static void ir_read_bulk_callback(struct urb *urb);
+static void ir_set_termios(struct usb_serial_port *port,
+                struct ktermios *old_termios);
 
 /* Not that this lot means you can only have one per system */
-static u8 ir_baud = 0;
-static u8 ir_xbof = 0;
-static u8 ir_add_bof = 0;
+static u8 ir_baud;
+static u8 ir_xbof;
+static u8 ir_add_bof;
 
-static struct usb_device_id id_table [] = {
+static struct usb_device_id ir_id_table[] = {
         { USB_DEVICE(0x050f, 0x0180) },         /* KC Technology, KC-180 */
         { USB_DEVICE(0x08e9, 0x0100) },         /* XTNDAccess */
         { USB_DEVICE(0x09c4, 0x0011) },         /* ACTiSys ACT-IR2000U */
-        { USB_INTERFACE_INFO (USB_CLASS_APP_SPEC, USB_CLASS_IRDA, 0) },
+        { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, USB_SUBCLASS_IRDA, 0) },
         { }                                     /* Terminating entry */
 };
 
-MODULE_DEVICE_TABLE (usb, id_table);
+MODULE_DEVICE_TABLE(usb, ir_id_table);
 
 static struct usb_driver ir_driver = {
-        .name =         "ir-usb",
-        .probe =        usb_serial_probe,
-        .disconnect =   usb_serial_disconnect,
-        .id_table =     id_table,
-        .no_dynamic_id =        1,
+        .name           = "ir-usb",
+        .probe          = usb_serial_probe,
+        .disconnect     = usb_serial_disconnect,
+        .id_table       = ir_id_table,
+        .no_dynamic_id  = 1,
 };
 
-
 static struct usb_serial_driver ir_device = {
-        .driver = {
-                .owner =        THIS_MODULE,
-                .name =         "ir-usb",
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "ir-usb",
         },
-        .description =          "IR Dongle",
-        .usb_driver =           &ir_driver,
-        .id_table =             id_table,
-        .num_ports =            1,
-        .set_termios =          ir_set_termios,
-        .attach =               ir_startup,
-        .open =                 ir_open,
-        .close =                ir_close,
-        .write =                ir_write,
-        .write_bulk_callback =  ir_write_bulk_callback,
-        .read_bulk_callback =   ir_read_bulk_callback,
+        .description            = "IR Dongle",
+        .usb_driver             = &ir_driver,
+        .id_table               = ir_id_table,
+        .num_ports              = 1,
+        .set_termios            = ir_set_termios,
+        .attach                 = ir_startup,
+        .open                   = ir_open,
+        .close                  = ir_close,
+        .write                  = ir_write,
+        .write_bulk_callback    = ir_write_bulk_callback,
+        .read_bulk_callback     = ir_read_bulk_callback,
 };
 
-static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc)
+static inline void irda_usb_dump_class_desc(struct usb_irda_cs_descriptor *desc)
 {
         dbg("bLength=%x", desc->bLength);
         dbg("bDescriptorType=%x", desc->bDescriptorType);
-        dbg("bcdSpecRevision=%x", desc->bcdSpecRevision); 
+        dbg("bcdSpecRevision=%x", __le16_to_cpu(desc->bcdSpecRevision));
         dbg("bmDataSize=%x", desc->bmDataSize);
         dbg("bmWindowSize=%x", desc->bmWindowSize);
         dbg("bmMinTurnaroundTime=%d", desc->bmMinTurnaroundTime);
-        dbg("wBaudRate=%x", desc->wBaudRate);
+        dbg("wBaudRate=%x", __le16_to_cpu(desc->wBaudRate));
         dbg("bmAdditionalBOFs=%x", desc->bmAdditionalBOFs);
         dbg("bIrdaRateSniff=%x", desc->bIrdaRateSniff);
         dbg("bMaxUnicastList=%x", desc->bMaxUnicastList);
@@ -181,35 +162,37 @@ static inline void irda_usb_dump_class_desc(struct irda_class_desc *desc)
  *
  * Based on the same function in drivers/net/irda/irda-usb.c
  */
-static struct irda_class_desc *irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum)
+static struct usb_irda_cs_descriptor *
+irda_usb_find_class_desc(struct usb_device *dev, unsigned int ifnum)
 {
-        struct irda_class_desc *desc;
+        struct usb_irda_cs_descriptor *desc;
         int ret;
-                
-        desc = kzalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
-        if (desc == NULL) 
+
+        desc = kzalloc(sizeof(*desc), GFP_KERNEL);
+        if (!desc)
                 return NULL;
-        
-        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
-                        IU_REQ_GET_CLASS_DESC,
+
+        ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
+                        USB_REQ_CS_IRDA_GET_CLASS_DESC,
                         USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         0, ifnum, desc, sizeof(*desc), 1000);
-        
+
         dbg("%s -  ret=%d", __func__, ret);
         if (ret < sizeof(*desc)) {
                 dbg("%s - class descriptor read %s (%d)",
                                 __func__,
-                                (ret<0) ? "failed" : "too short",
+                                (ret < 0) ? "failed" : "too short",
                                 ret);
                 goto error;
         }
-        if (desc->bDescriptorType != USB_DT_IRDA) {
+        if (desc->bDescriptorType != USB_DT_CS_IRDA) {
                 dbg("%s - bad class descriptor type", __func__);
                 goto error;
         }
-        
+
         irda_usb_dump_class_desc(desc);
         return desc;
+
 error:
         kfree(desc);
         return NULL;
@@ -219,64 +202,100 @@ error:
 static u8 ir_xbof_change(u8 xbof)
 {
         u8 result;
+
         /* reference irda-usb.c */
-        switch(xbof) {
-                case 48: result = 0x10; break;
-                case 28:
-                case 24: result = 0x20; break;
-                default:
-                case 12: result = 0x30; break;
-                case  5:
-                case  6: result = 0x40; break;
-                case  3: result = 0x50; break;
-                case  2: result = 0x60; break;
-                case  1: result = 0x70; break;
-                case  0: result = 0x80; break;
+        switch (xbof) {
+        case 48:
+                result = 0x10;
+                break;
+        case 28:
+        case 24:
+                result = 0x20;
+                break;
+        default:
+        case 12:
+                result = 0x30;
+                break;
+        case  5:
+        case  6:
+                result = 0x40;
+                break;
+        case  3:
+                result = 0x50;
+                break;
+        case  2:
+                result = 0x60;
+                break;
+        case  1:
+                result = 0x70;
+                break;
+        case  0:
+                result = 0x80;
+                break;
         }
+
         return(result);
 }
 
 
-static int ir_startup (struct usb_serial *serial)
+static int ir_startup(struct usb_serial *serial)
 {
-        struct irda_class_desc *irda_desc;
+        struct usb_irda_cs_descriptor *irda_desc;
 
-        irda_desc = irda_usb_find_class_desc (serial->dev, 0);
-        if (irda_desc == NULL) {
-                dev_err (&serial->dev->dev, "IRDA class descriptor not found, device not bound\n");
+        irda_desc = irda_usb_find_class_desc(serial->dev, 0);
+        if (!irda_desc) {
+                dev_err(&serial->dev->dev,
+                        "IRDA class descriptor not found, device not bound\n");
                 return -ENODEV;
         }
 
-        dbg ("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s",
+        dbg("%s - Baud rates supported:%s%s%s%s%s%s%s%s%s",
                 __func__,
-                (irda_desc->wBaudRate & 0x0001) ? " 2400"    : "",
-                (irda_desc->wBaudRate & 0x0002) ? " 9600"    : "",
-                (irda_desc->wBaudRate & 0x0004) ? " 19200"   : "",
-                (irda_desc->wBaudRate & 0x0008) ? " 38400"   : "",
-                (irda_desc->wBaudRate & 0x0010) ? " 57600"   : "",
-                (irda_desc->wBaudRate & 0x0020) ? " 115200"  : "",
-                (irda_desc->wBaudRate & 0x0040) ? " 576000"  : "",
-                (irda_desc->wBaudRate & 0x0080) ? " 1152000" : "",
-                (irda_desc->wBaudRate & 0x0100) ? " 4000000" : "");
-
-        switch( irda_desc->bmAdditionalBOFs ) {
-                case 0x01: ir_add_bof = 48; break;
-                case 0x02: ir_add_bof = 24; break;
-                case 0x04: ir_add_bof = 12; break;
-                case 0x08: ir_add_bof =  6; break;
-                case 0x10: ir_add_bof =  3; break;
-                case 0x20: ir_add_bof =  2; break;
-                case 0x40: ir_add_bof =  1; break;
-                case 0x80: ir_add_bof =  0; break;
-                default:;
+                (irda_desc->wBaudRate & USB_IRDA_BR_2400) ? " 2400" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_9600) ? " 9600" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_19200) ? " 19200" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_38400) ? " 38400" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_57600) ? " 57600" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_115200) ? " 115200" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_576000) ? " 576000" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_1152000) ? " 1152000" : "",
+                (irda_desc->wBaudRate & USB_IRDA_BR_4000000) ? " 4000000" : "");
+
+        switch (irda_desc->bmAdditionalBOFs) {
+        case USB_IRDA_AB_48:
+                ir_add_bof = 48;
+                break;
+        case USB_IRDA_AB_24:
+                ir_add_bof = 24;
+                break;
+        case USB_IRDA_AB_12:
+                ir_add_bof = 12;
+                break;
+        case USB_IRDA_AB_6:
+                ir_add_bof = 6;
+                break;
+        case USB_IRDA_AB_3:
+                ir_add_bof = 3;
+                break;
+        case USB_IRDA_AB_2:
+                ir_add_bof = 2;
+                break;
+        case USB_IRDA_AB_1:
+                ir_add_bof = 1;
+                break;
+        case USB_IRDA_AB_0:
+                ir_add_bof = 0;
+                break;
+        default:
+                break;
         }
 
-        kfree (irda_desc);
+        kfree(irda_desc);
 
-        return 0;               
+        return 0;
 }
 
-static int ir_open (struct usb_serial_port *port, struct file *filp)
+static int ir_open(struct usb_serial_port *port, struct file *filp)
 {
         char *buffer;
         int result = 0;
@@ -285,51 +304,55 @@ static int ir_open (struct usb_serial_port *port, struct file *filp)
 
         if (buffer_size) {
                 /* override the default buffer sizes */
-                buffer = kmalloc (buffer_size, GFP_KERNEL);
+                buffer = kmalloc(buffer_size, GFP_KERNEL);
                 if (!buffer) {
-                        dev_err (&port->dev, "%s - out of memory.\n", __func__);
+                        dev_err(&port->dev, "%s - out of memory.\n", __func__);
                         return -ENOMEM;
                 }
-                kfree (port->read_urb->transfer_buffer);
+                kfree(port->read_urb->transfer_buffer);
                 port->read_urb->transfer_buffer = buffer;
                 port->read_urb->transfer_buffer_length = buffer_size;
 
-                buffer = kmalloc (buffer_size, GFP_KERNEL);
+                buffer = kmalloc(buffer_size, GFP_KERNEL);
                 if (!buffer) {
-                        dev_err (&port->dev, "%s - out of memory.\n", __func__);
+                        dev_err(&port->dev, "%s - out of memory.\n", __func__);
                         return -ENOMEM;
                 }
-                kfree (port->write_urb->transfer_buffer);
+                kfree(port->write_urb->transfer_buffer);
                 port->write_urb->transfer_buffer = buffer;
                 port->write_urb->transfer_buffer_length = buffer_size;
                 port->bulk_out_size = buffer_size;
         }
 
         /* Start reading from the device */
-        usb_fill_bulk_urb (
+        usb_fill_bulk_urb(
                 port->read_urb,
-                port->serial->dev, 
-                usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
+                port->serial->dev,
+                usb_rcvbulkpipe(port->serial->dev,
+                        port->bulk_in_endpointAddress),
                 port->read_urb->transfer_buffer,
                 port->read_urb->transfer_buffer_length,
                 ir_read_bulk_callback,
                 port);
         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
         if (result)
-                dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __func__, result);
+                dev_err(&port->dev,
+                        "%s - failed submitting read urb, error %d\n",
+                        __func__, result);
 
         return result;
 }
 
-static void ir_close (struct usb_serial_port *port, struct file * filp)
+static void ir_close(struct usb_serial_port *port, struct file *filp)
 {
         dbg("%s - port %d", __func__, port->number);
-                         
+
         /* shutdown our bulk read */
         usb_kill_urb(port->read_urb);
 }
 
-static int ir_write (struct usb_serial_port *port, const unsigned char *buf, int count)
+static int ir_write(struct usb_serial_port *port,
+                const unsigned char *buf, int count)
 {
         unsigned char *transfer_buffer;
         int result;
@@ -338,7 +361,7 @@ static int ir_write (struct usb_serial_port *port, const unsigned char *buf, int
         dbg("%s - port = %d, count = %d", __func__, port->number, count);
 
         if (!port->tty) {
-                dev_err (&port->dev, "%s - no tty???\n", __func__);
+                dev_err(&port->dev, "%s - no tty???\n", __func__);
                 return 0;
         }
 
@@ -359,7 +382,7 @@ static int ir_write (struct usb_serial_port *port, const unsigned char *buf, int
 
         /*
          * The first byte of the packet we send to the device contains an
-         * inband header which indicates an additional number of BOFs and
+         * inbound header which indicates an additional number of BOFs and
          * a baud rate change.
          *
          * See section 5.4.2.2 of the USB IrDA spec.
@@ -367,9 +390,9 @@ static int ir_write (struct usb_serial_port *port, const unsigned char *buf, int
         *transfer_buffer = ir_xbof | ir_baud;
         ++transfer_buffer;
 
-        memcpy (transfer_buffer, buf, transfer_size);
+        memcpy(transfer_buffer, buf, transfer_size);
 
-        usb_fill_bulk_urb (
+        usb_fill_bulk_urb(
                 port->write_urb,
                 port->serial->dev,
                 usb_sndbulkpipe(port->serial->dev,
@@ -381,17 +404,19 @@ static int ir_write (struct usb_serial_port *port, const unsigned char *buf, int
 
         port->write_urb->transfer_flags = URB_ZERO_PACKET;
 
-        result = usb_submit_urb (port->write_urb, GFP_ATOMIC);
+        result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
         if (result) {
                 port->write_urb_busy = 0;
-                dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__, result);
+                dev_err(&port->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                        __func__, result);
         } else
                 result = transfer_size;
 
         return result;
 }
 
-static void ir_write_bulk_callback (struct urb *urb)
+static void ir_write_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         int status = urb->status;
@@ -405,7 +430,7 @@ static void ir_write_bulk_callback (struct urb *urb)
                 return;
         }
 
-        usb_serial_debug_data (
+        usb_serial_debug_data(
                 debug,
                 &port->dev,
                 __func__,
@@ -415,7 +440,7 @@ static void ir_write_bulk_callback (struct urb *urb)
         usb_serial_port_softint(port);
 }
 
-static void ir_read_bulk_callback (struct urb *urb)
+static void ir_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct tty_struct *tty;
@@ -431,68 +456,69 @@ static void ir_read_bulk_callback (struct urb *urb)
         }
 
         switch (status) {
-                case 0: /* Successful */
-
-                        /*
-                         * The first byte of the packet we get from the device
-                         * contains a busy indicator and baud rate change.
-                         * See section 5.4.1.2 of the USB IrDA spec.
-                         */
-                        if ((*data & 0x0f) > 0)
-                                ir_baud = *data & 0x0f;
-
-                        usb_serial_debug_data (
-                                debug,
-                                &port->dev,
-                                __func__,
-                                urb->actual_length,
-                                data);
-
-                        tty = port->tty;
-
-                        if (tty_buffer_request_room(tty, urb->actual_length - 1)) {
-                                tty_insert_flip_string(tty, data+1, urb->actual_length - 1);
-                                tty_flip_buffer_push(tty);
-                        }
-
-                        /*
-                         * No break here.
-                         * We want to resubmit the urb so we can read
-                         * again.
-                         */
-
-                case -EPROTO: /* taking inspiration from pl2303.c */
-
-                        /* Continue trying to always read */
-                        usb_fill_bulk_urb (
-                                port->read_urb,
-                                port->serial->dev, 
-                                usb_rcvbulkpipe(port->serial->dev,
-                                        port->bulk_in_endpointAddress),
-                                port->read_urb->transfer_buffer,
-                                port->read_urb->transfer_buffer_length,
-                                ir_read_bulk_callback,
-                                port);
-
-                        result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
-                        if (result)
-                                dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
-                                        __func__, result);
-
-                        break ;
-
-                default:
-                        dbg("%s - nonzero read bulk status received: %d",
-                                __func__,
-                                status);
-                        break ;
+        case 0: /* Successful */
+
+                /*
+                 * The first byte of the packet we get from the device
+                 * contains a busy indicator and baud rate change.
+                 * See section 5.4.1.2 of the USB IrDA spec.
+                 */
+                if ((*data & 0x0f) > 0)
+                        ir_baud = *data & 0x0f;
+
+                usb_serial_debug_data(
+                        debug,
+                        &port->dev,
+                        __func__,
+                        urb->actual_length,
+                        data);
+
+                tty = port->tty;
+
+                if (tty_buffer_request_room(tty, urb->actual_length - 1)) {
+                        tty_insert_flip_string(tty, data + 1,
+                                        urb->actual_length - 1);
+                        tty_flip_buffer_push(tty);
+                }
 
+                /*
+                 * No break here.
+                 * We want to resubmit the urb so we can read
+                 * again.
+                 */
+
+        case -EPROTO: /* taking inspiration from pl2303.c */
+
+                /* Continue trying to always read */
+                usb_fill_bulk_urb(
+                        port->read_urb,
+                        port->serial->dev,
+                        usb_rcvbulkpipe(port->serial->dev,
+                                port->bulk_in_endpointAddress),
+                        port->read_urb->transfer_buffer,
+                        port->read_urb->transfer_buffer_length,
+                        ir_read_bulk_callback,
+                        port);
+
+                result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
+                if (result)
+                        dev_err(&port->dev,
+                                "%s - failed resubmitting read urb, error %d\n",
+                                __func__, result);
+                break;
+
+        default:
+                dbg("%s - nonzero read bulk status received: %d",
+                        __func__,
+                        status);
+                break;
         }
 
         return;
 }
 
-static void ir_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
+static void ir_set_termios(struct usb_serial_port *port,
+                struct ktermios *old_termios)
 {
         unsigned char *transfer_buffer;
         int result;
@@ -510,19 +536,36 @@ static void ir_set_termios (struct usb_serial_port *port, struct ktermios *old_t
          */
 
         switch (baud) {
-                case 2400:      ir_baud = SPEED_2400; break;
-                case 9600:      ir_baud = SPEED_9600; break;
-                case 19200:     ir_baud = SPEED_19200; break;
-                case 38400:     ir_baud = SPEED_38400; break;
-                case 57600:     ir_baud = SPEED_57600; break;
-                case 115200:    ir_baud = SPEED_115200; break;
-                case 576000:    ir_baud = SPEED_576000; break;
-                case 1152000:   ir_baud = SPEED_1152000; break;
-                case 4000000:   ir_baud = SPEED_4000000; break;
-                        break;
-                default:
-                        ir_baud = SPEED_9600;
-                        baud = 9600;
+        case 2400:
+                ir_baud = USB_IRDA_BR_2400;
+                break;
+        case 9600:
+                ir_baud = USB_IRDA_BR_9600;
+                break;
+        case 19200:
+                ir_baud = USB_IRDA_BR_19200;
+                break;
+        case 38400:
+                ir_baud = USB_IRDA_BR_38400;
+                break;
+        case 57600:
+                ir_baud = USB_IRDA_BR_57600;
+                break;
+        case 115200:
+                ir_baud = USB_IRDA_BR_115200;
+                break;
+        case 576000:
+                ir_baud = USB_IRDA_BR_576000;
+                break;
+        case 1152000:
+                ir_baud = USB_IRDA_BR_1152000;
+                break;
+        case 4000000:
+                ir_baud = USB_IRDA_BR_4000000;
+                break;
+        default:
+                ir_baud = USB_IRDA_BR_9600;
+                baud = 9600;
         }
 
         if (xbof == -1)
@@ -538,10 +581,11 @@ static void ir_set_termios (struct usb_serial_port *port, struct ktermios *old_t
         transfer_buffer = port->write_urb->transfer_buffer;
         *transfer_buffer = ir_xbof | ir_baud;
 
-        usb_fill_bulk_urb (
+        usb_fill_bulk_urb(
                 port->write_urb,
                 port->serial->dev,
-                usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
+                usb_sndbulkpipe(port->serial->dev,
+                        port->bulk_out_endpointAddress),
                 port->write_urb->transfer_buffer,
                 1,
                 ir_write_bulk_callback,
@@ -549,38 +593,44 @@ static void ir_set_termios (struct usb_serial_port *port, struct ktermios *old_t
 
         port->write_urb->transfer_flags = URB_ZERO_PACKET;
 
-        result = usb_submit_urb (port->write_urb, GFP_KERNEL);
+        result = usb_submit_urb(port->write_urb, GFP_KERNEL);
         if (result)
-                dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__, result);
+                dev_err(&port->dev,
+                                "%s - failed submitting write urb, error %d\n",
+                                __func__, result);
 
         /* Only speed changes are supported */
         tty_termios_copy_hw(port->tty->termios, old_termios);
         tty_encode_baud_rate(port->tty, baud, baud);
 }
 
-
-static int __init ir_init (void)
+static int __init ir_init(void)
 {
         int retval;
+
         retval = usb_serial_register(&ir_device);
         if (retval)
                 goto failed_usb_serial_register;
+
         retval = usb_register(&ir_driver);
-        if (retval) 
+        if (retval)
                 goto failed_usb_register;
+
         info(DRIVER_DESC " " DRIVER_VERSION);
+
         return 0;
+
 failed_usb_register:
         usb_serial_deregister(&ir_device);
+
 failed_usb_serial_register:
         return retval;
 }
 
-
-static void __exit ir_exit (void)
+static void __exit ir_exit(void)
 {
-        usb_deregister (&ir_driver);
-        usb_serial_deregister (&ir_device);
+        usb_deregister(&ir_driver);
+        usb_serial_deregister(&ir_device);
 }
 
 
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index b52fb657a244..8bf72639b148 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -138,7 +138,8 @@ static int  keyspan_usa67_send_setup	(struct usb_serial *serial,
 
 /* Product IDs post-renumeration.  Note that the 28x and 28xb
    have the same id's post-renumeration but behave identically
-   so it's not an issue. */
+   so it's not an issue. As such, the 28xb is not listed in any
+   of the device tables. */
 #define keyspan_usa18x_product_id               0x0112
 #define keyspan_usa19_product_id                0x0107
 #define keyspan_usa19qi_product_id              0x010c
@@ -482,7 +483,6 @@ static struct usb_device_id keyspan_ids_combined[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
-        { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49w_product_id)},
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa49wlc_product_id)},
@@ -532,7 +532,6 @@ static struct usb_device_id keyspan_2port_ids[] = {
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28x_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xa_product_id) },
-        { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xb_product_id) },
         { USB_DEVICE(KEYSPAN_VENDOR_ID, keyspan_usa28xg_product_id) },
         { } /* Terminating entry */
 };
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 644a1eaaa376..60b3e22bd633 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -408,7 +408,7 @@ static int keyspan_pda_get_modem_info(struct usb_serial *serial,
                              3, /* get pins */
                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
                              0, 0, &data, 1, 2000);
-        if (rc > 0)
+        if (rc >= 0)
                 *value = data;
         return rc;
 }
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index f328948d74e3..79787eda9524 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -236,7 +236,7 @@ static int klsi_105_get_line_state(struct usb_serial_port *port,
         if (rc < 0)
                 err("Reading line status failed (error = %d)", rc);
         else {
-                status = le16_to_cpu(get_unaligned((__le16 *)status_buf));
+                status = get_unaligned_le16(status_buf);
 
                 info("%s - read status %x %x", __func__,
                      status_buf[0], status_buf[1]);
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index a73420dd052a..1e936a1cbe0b 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -173,6 +173,7 @@ static int  option_send_setup(struct usb_serial_port *port);
 #define DELL_VENDOR_ID                          0x413C
 
 #define KYOCERA_VENDOR_ID                       0x0c88
+#define KYOCERA_PRODUCT_KPC650                  0x17da
 #define KYOCERA_PRODUCT_KPC680                  0x180a
 
 #define ANYDATA_VENDOR_ID                       0x16d5
@@ -305,6 +306,7 @@ static struct usb_device_id option_ids[] = {
         { USB_DEVICE(ONDA_VENDOR_ID, ONDA_PRODUCT_ET502HS) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_1) },
         { USB_DEVICE(BANDRICH_VENDOR_ID, BANDRICH_PRODUCT_C100_2) },
+        { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC650) },
         { USB_DEVICE(KYOCERA_VENDOR_ID, KYOCERA_PRODUCT_KPC680) },
         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6000)}, /* ZTE AC8700 */
         { USB_DEVICE(QUALCOMM_VENDOR_ID, 0x6613)}, /* Onda H600/ZTE MF330 */
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 0cb0d77dc429..353798631903 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -283,7 +283,10 @@ static void serial_close(struct tty_struct *tty, struct file * filp)
         }
 
         if (port->open_count == 0) {
-                usb_autopm_put_interface(port->serial->interface);
+                mutex_lock(&port->serial->disc_mutex);
+                if (!port->serial->disconnected)
+                        usb_autopm_put_interface(port->serial->interface);
+                mutex_unlock(&port->serial->disc_mutex);
                 module_put(port->serial->type->driver.owner);
         }
 
@@ -505,7 +508,7 @@ static void port_release(struct device *dev)
 {
         struct usb_serial_port *port = to_usb_serial_port(dev);
 
-        dbg ("%s - %s", __func__, dev->bus_id);
+        dbg ("%s - %s", __func__, dev_name(dev));
         port_free(port);
 }
 
@@ -625,7 +628,7 @@ int usb_serial_probe(struct usb_interface *interface,
         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
         struct usb_serial_driver *type = NULL;
         int retval;
-        int minor;
+        unsigned int minor;
         int buffer_size;
         int i;
         int num_interrupt_in = 0;
@@ -938,8 +941,8 @@ int usb_serial_probe(struct usb_interface *interface,
                 port->dev.bus = &usb_serial_bus_type;
                 port->dev.release = &port_release;
 
-                snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
-                dbg ("%s - registering %s", __func__, port->dev.bus_id);
+                dev_set_name(&port->dev, "ttyUSB%d", port->number);
+                dbg ("%s - registering %s", __func__, dev_name(&port->dev));
                 retval = device_register(&port->dev);
                 if (retval)
                         dev_err(&port->dev, "Error registering port device, "
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index f9fc926b56d8..9ca4d4db1ddd 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -15,6 +15,8 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
+#define USB_DEBUG_MAX_PACKET_SIZE       8
+
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x0525, 0x127a) },
         { },
@@ -29,6 +31,12 @@ static struct usb_driver debug_driver = {
         .no_dynamic_id =        1,
 };
 
+int usb_debug_open(struct usb_serial_port *port, struct file *filp)
+{
+        port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
+        return usb_serial_generic_open(port, filp);
+}
+
 static struct usb_serial_driver debug_device = {
         .driver = {
                 .owner =        THIS_MODULE,
@@ -36,6 +44,7 @@ static struct usb_serial_driver debug_device = {
         },
         .id_table =             id_table,
         .num_ports =            1,
+        .open =                 usb_debug_open,
 };
 
 static int __init debug_init(void)
diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c
index 579e9f52053a..17f1ae232919 100644
--- a/drivers/usb/storage/datafab.c
+++ b/drivers/usb/storage/datafab.c
@@ -1,7 +1,5 @@
 /* Driver for Datafab USB Compact Flash reader
  *
- * $Id: datafab.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $
- *
  * datafab driver v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/debug.c b/drivers/usb/storage/debug.c
index 01e430654a13..a2b5526c9fa0 100644
--- a/drivers/usb/storage/debug.c
+++ b/drivers/usb/storage/debug.c
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Debugging Functions Source Code File
  *
- * $Id: debug.c,v 1.9 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/debug.h b/drivers/usb/storage/debug.h
index 77e244a8c376..dbb985d52423 100644
--- a/drivers/usb/storage/debug.h
+++ b/drivers/usb/storage/debug.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Debugging Functions Header File
  *
- * $Id: debug.h,v 1.6 2001/01/12 23:51:04 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/dpcm.c b/drivers/usb/storage/dpcm.c
index 9a410b5a6e5b..939923471af4 100644
--- a/drivers/usb/storage/dpcm.c
+++ b/drivers/usb/storage/dpcm.c
@@ -1,7 +1,5 @@
 /* Driver for Microtech DPCM-USB CompactFlash/SmartMedia reader
  *
- * $Id: dpcm.c,v 1.4 2001/06/11 02:54:25 mdharm Exp $
- *
  * DPCM driver v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/dpcm.h b/drivers/usb/storage/dpcm.h
index 81b464cfcc1e..e7b7b0f120d7 100644
--- a/drivers/usb/storage/dpcm.h
+++ b/drivers/usb/storage/dpcm.h
@@ -1,7 +1,5 @@
 /* Driver for Microtech DPCM-USB CompactFlash/SmartMedia reader
  *
- * $Id: dpcm.h,v 1.2 2000/08/25 00:13:51 mdharm Exp $
- *
  * DPCM driver v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/freecom.c b/drivers/usb/storage/freecom.c
index f5a4e8d6a3b1..7a4d45677227 100644
--- a/drivers/usb/storage/freecom.c
+++ b/drivers/usb/storage/freecom.c
@@ -1,7 +1,5 @@
 /* Driver for Freecom USB/IDE adaptor
  *
- * $Id: freecom.c,v 1.22 2002/04/22 03:39:43 mdharm Exp $
- *
  * Freecom v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/freecom.h b/drivers/usb/storage/freecom.h
index 1b012d62d0a8..20d0fe6ba0c8 100644
--- a/drivers/usb/storage/freecom.h
+++ b/drivers/usb/storage/freecom.h
@@ -1,7 +1,5 @@
 /* Driver for Freecom USB/IDE adaptor
  *
- * $Id: freecom.h,v 1.4 2000/08/29 14:49:15 dlbrown Exp $
- *
  * Freecom v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/initializers.c b/drivers/usb/storage/initializers.c
index 187dd1e01093..4995bb595aef 100644
--- a/drivers/usb/storage/initializers.c
+++ b/drivers/usb/storage/initializers.c
@@ -1,7 +1,5 @@
 /* Special Initializers for certain USB Mass Storage devices
  *
- * $Id: initializers.c,v 1.2 2000/09/06 22:35:57 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/initializers.h b/drivers/usb/storage/initializers.h
index ad3ffd4236c2..529327fbb06b 100644
--- a/drivers/usb/storage/initializers.h
+++ b/drivers/usb/storage/initializers.h
@@ -1,7 +1,5 @@
 /* Header file for Special Initializers for certain USB Mass Storage devices
  *
- * $Id: initializers.h,v 1.1 2000/08/29 23:07:02 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 3addcd8f827b..383abf2516a5 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -1,7 +1,5 @@
 /* Transport & Protocol Driver for In-System Design, Inc. ISD200 ASIC
  *
- * $Id: isd200.c,v 1.16 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance:
  *   (C) 2001-2002 Björn Stenberg (bjorn@haxx.se)
  *
@@ -586,7 +584,7 @@ static void isd200_invoke_transport( struct us_data *us,
         /* if the command gets aborted by the higher layers, we need to
          * short-circuit all other processing
          */
-        if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
+        if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                 US_DEBUGP("-- command was aborted\n");
                 goto Handle_Abort;
         }
@@ -633,7 +631,7 @@ static void isd200_invoke_transport( struct us_data *us,
 
         if (need_auto_sense) {
                 result = isd200_read_regs(us);
-                if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
+                if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                         US_DEBUGP("-- auto-sense aborted\n");
                         goto Handle_Abort;
                 }
@@ -663,7 +661,7 @@ static void isd200_invoke_transport( struct us_data *us,
         srb->result = DID_ABORT << 16;
 
         /* permit the reset transfer to take place */
-        clear_bit(US_FLIDX_ABORTING, &us->flags);
+        clear_bit(US_FLIDX_ABORTING, &us->dflags);
         /* Need reset here */
 }
 
diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c
index 61097cbb1585..df67f13c9e73 100644
--- a/drivers/usb/storage/jumpshot.c
+++ b/drivers/usb/storage/jumpshot.c
@@ -1,7 +1,5 @@
 /* Driver for Lexar "Jumpshot" Compact Flash reader
  *
- * $Id: jumpshot.c,v 1.7 2002/02/25 00:40:13 mdharm Exp $
- *
  * jumpshot driver v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
index b9b8ede61fb3..3b3357e20ea7 100644
--- a/drivers/usb/storage/protocol.c
+++ b/drivers/usb/storage/protocol.c
@@ -1,7 +1,5 @@
 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: protocol.c,v 1.14 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/protocol.h b/drivers/usb/storage/protocol.h
index 8737a36891ca..487056ffb516 100644
--- a/drivers/usb/storage/protocol.h
+++ b/drivers/usb/storage/protocol.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Protocol Functions Header File
  *
- * $Id: protocol.h,v 1.4 2001/02/13 07:10:03 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 3fcde9f0fa5f..09779f6a8179 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * SCSI layer glue code
  *
- * $Id: scsiglue.c,v 1.26 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
@@ -73,7 +71,6 @@ static const char* host_info(struct Scsi_Host *host)
 static int slave_alloc (struct scsi_device *sdev)
 {
         struct us_data *us = host_to_us(sdev->host);
-        struct usb_host_endpoint *bulk_in_ep;
 
         /*
          * Set the INQUIRY transfer length to 36.  We don't use any of
@@ -82,16 +79,22 @@ static int slave_alloc (struct scsi_device *sdev)
          */
         sdev->inquiry_len = 36;
 
-        /* Scatter-gather buffers (all but the last) must have a length
-         * divisible by the bulk maxpacket size.  Otherwise a data packet
-         * would end up being short, causing a premature end to the data
-         * transfer.  We'll use the maxpacket value of the bulk-IN pipe
-         * to set the SCSI device queue's DMA alignment mask.
+        /* USB has unusual DMA-alignment requirements: Although the
+         * starting address of each scatter-gather element doesn't matter,
+         * the length of each element except the last must be divisible
+         * by the Bulk maxpacket value.  There's currently no way to
+         * express this by block-layer constraints, so we'll cop out
+         * and simply require addresses to be aligned at 512-byte
+         * boundaries.  This is okay since most block I/O involves
+         * hardware sectors that are multiples of 512 bytes in length,
+         * and since host controllers up through USB 2.0 have maxpacket
+         * values no larger than 512.
+         *
+         * But it doesn't suffice for Wireless USB, where Bulk maxpacket
+         * values can be as large as 2048.  To make that work properly
+         * will require changes to the block layer.
          */
-        bulk_in_ep = us->pusb_dev->ep_in[usb_pipeendpoint(us->recv_bulk_pipe)];
-        blk_queue_update_dma_alignment(sdev->request_queue,
-                        le16_to_cpu(bulk_in_ep->desc.wMaxPacketSize) - 1);
-                        /* wMaxPacketSize must be a power of 2 */
+        blk_queue_update_dma_alignment(sdev->request_queue, (512 - 1));
 
         /*
          * The UFI spec treates the Peripheral Qualifier bits in an
@@ -116,10 +119,10 @@ static int slave_configure(struct scsi_device *sdev)
          * while others have trouble with more than 64K. At this time we
          * are limiting both to 32K (64 sectores).
          */
-        if (us->flags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
+        if (us->fflags & (US_FL_MAX_SECTORS_64 | US_FL_MAX_SECTORS_MIN)) {
                 unsigned int max_sectors = 64;
 
-                if (us->flags & US_FL_MAX_SECTORS_MIN)
+                if (us->fflags & US_FL_MAX_SECTORS_MIN)
                         max_sectors = PAGE_CACHE_SIZE >> 9;
                 if (sdev->request_queue->max_sectors > max_sectors)
                         blk_queue_max_sectors(sdev->request_queue,
@@ -148,7 +151,7 @@ static int slave_configure(struct scsi_device *sdev)
                  * majority of devices work fine, but a few still can't
                  * handle it.  The sd driver will simply assume those
                  * devices are write-enabled. */
-                if (us->flags & US_FL_NO_WP_DETECT)
+                if (us->fflags & US_FL_NO_WP_DETECT)
                         sdev->skip_ms_page_3f = 1;
 
                 /* A number of devices have problems with MODE SENSE for
@@ -158,13 +161,13 @@ static int slave_configure(struct scsi_device *sdev)
                 /* Some disks return the total number of blocks in response
                  * to READ CAPACITY rather than the highest block number.
                  * If this device makes that mistake, tell the sd driver. */
-                if (us->flags & US_FL_FIX_CAPACITY)
+                if (us->fflags & US_FL_FIX_CAPACITY)
                         sdev->fix_capacity = 1;
 
                 /* A few disks have two indistinguishable version, one of
                  * which reports the correct capacity and the other does not.
                  * The sd driver has to guess which is the case. */
-                if (us->flags & US_FL_CAPACITY_HEURISTICS)
+                if (us->fflags & US_FL_CAPACITY_HEURISTICS)
                         sdev->guess_capacity = 1;
 
                 /* Some devices report a SCSI revision level above 2 but are
@@ -213,7 +216,7 @@ static int slave_configure(struct scsi_device *sdev)
 
         /* Some devices choke when they receive a PREVENT-ALLOW MEDIUM
          * REMOVAL command, so suppress those commands. */
-        if (us->flags & US_FL_NOT_LOCKABLE)
+        if (us->fflags & US_FL_NOT_LOCKABLE)
                 sdev->lockable = 0;
 
         /* this is to satisfy the compiler, tho I don't think the 
@@ -238,7 +241,7 @@ static int queuecommand(struct scsi_cmnd *srb,
         }
 
         /* fail the command if we are disconnecting */
-        if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+        if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
                 US_DEBUGP("Fail command during disconnect\n");
                 srb->result = DID_NO_CONNECT << 16;
                 done(srb);
@@ -248,7 +251,7 @@ static int queuecommand(struct scsi_cmnd *srb,
         /* enqueue the command and wake up the control thread */
         srb->scsi_done = done;
         us->srb = srb;
-        up(&(us->sema));
+        complete(&us->cmnd_ready);
 
         return 0;
 }
@@ -280,9 +283,9 @@ static int command_abort(struct scsi_cmnd *srb)
          * 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);
+        set_bit(US_FLIDX_TIMED_OUT, &us->dflags);
+        if (!test_bit(US_FLIDX_RESETTING, &us->dflags)) {
+                set_bit(US_FLIDX_ABORTING, &us->dflags);
                 usb_stor_stop_transport(us);
         }
         scsi_unlock(us_to_host(us));
@@ -329,7 +332,7 @@ void usb_stor_report_device_reset(struct us_data *us)
         struct Scsi_Host *host = us_to_host(us);
 
         scsi_report_device_reset(host, 0, 0);
-        if (us->flags & US_FL_SCM_MULT_TARG) {
+        if (us->fflags & US_FL_SCM_MULT_TARG) {
                 for (i = 1; i < host->max_id; ++i)
                         scsi_report_device_reset(host, 0, i);
         }
@@ -400,7 +403,7 @@ static int proc_info (struct Scsi_Host *host, char *buffer,
                 pos += sprintf(pos, "       Quirks:");
 
 #define US_FLAG(name, value) \
-        if (us->flags & value) pos += sprintf(pos, " " #name);
+        if (us->fflags & value) pos += sprintf(pos, " " #name);
 US_DO_ALL_FLAGS
 #undef US_FLAG
 
diff --git a/drivers/usb/storage/scsiglue.h b/drivers/usb/storage/scsiglue.h
index 737e4fa6045f..ffa1cca93d2c 100644
--- a/drivers/usb/storage/scsiglue.h
+++ b/drivers/usb/storage/scsiglue.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * SCSI Connecting Glue Header File
  *
- * $Id: scsiglue.h,v 1.4 2000/08/25 00:13:51 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index 8972b17da843..c5a54b872c24 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -1,6 +1,5 @@
 /* Driver for SanDisk SDDR-09 SmartMedia reader
  *
- * $Id: sddr09.c,v 1.24 2002/04/22 03:39:43 mdharm Exp $
  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  *   (c) 2002 Andries Brouwer (aeb@cwi.nl)
  * Developed with the assistance of:
diff --git a/drivers/usb/storage/sddr09.h b/drivers/usb/storage/sddr09.h
index c03089a9ec38..e50033ad7b19 100644
--- a/drivers/usb/storage/sddr09.h
+++ b/drivers/usb/storage/sddr09.h
@@ -1,8 +1,6 @@
 /* Driver for SanDisk SDDR-09 SmartMedia reader
  * Header File
  *
- * $Id: sddr09.h,v 1.5 2000/08/25 00:13:51 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 2000 Robert Baruch (autophile@dol.net)
  *   (c) 2002 Andries Brouwer (aeb@cwi.nl)
diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c
index 6d14327c921d..0d8df7577899 100644
--- a/drivers/usb/storage/sddr55.c
+++ b/drivers/usb/storage/sddr55.c
@@ -1,7 +1,5 @@
 /* Driver for SanDisk SDDR-55 SmartMedia reader
  *
- * $Id:$
- *
  * SDDR55 driver v0.1:
  *
  * First release
diff --git a/drivers/usb/storage/sddr55.h b/drivers/usb/storage/sddr55.h
index d6bd32f6c9f3..a815a0470c84 100644
--- a/drivers/usb/storage/sddr55.h
+++ b/drivers/usb/storage/sddr55.h
@@ -1,8 +1,6 @@
 /* Driver for SanDisk SDDR-55 SmartMedia reader
  * Header File
  *
- * $Id:$
- *
  * Current development and maintenance by:
  *   (c) 2002 Simon Munton
  *
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index 570c1250f6f3..ae6d64810d2a 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -1,7 +1,5 @@
 /* Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable
  *
- * $Id: shuttle_usbat.c,v 1.17 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 2000, 2001 Robert Baruch (autophile@starband.net)
  *   (c) 2004, 2005 Daniel Drake <dsd@gentoo.org>
diff --git a/drivers/usb/storage/shuttle_usbat.h b/drivers/usb/storage/shuttle_usbat.h
index 3ddf143a1dec..d8bfc43e9044 100644
--- a/drivers/usb/storage/shuttle_usbat.h
+++ b/drivers/usb/storage/shuttle_usbat.h
@@ -1,8 +1,6 @@
 /* Driver for SCM Microsystems USB-ATAPI cable
  * Header File
  *
- * $Id: shuttle_usbat.h,v 1.5 2000/09/17 14:44:52 groovyjava Exp $
- *
  * Current development and maintenance by:
  *   (c) 2000 Robert Baruch (autophile@dol.net)
  *   (c) 2004, 2005 Daniel Drake <dsd@gentoo.org>
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 6610d2dd1e7f..fcbbfdb7b2b0 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -1,7 +1,5 @@
 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: transport.c,v 1.47 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
@@ -75,14 +73,14 @@
  * by a separate code path.)
  *
  * The abort function (usb_storage_command_abort() in scsiglue.c) first
- * sets the machine state and the ABORTING bit in us->flags to prevent
+ * sets the machine state and the ABORTING bit in us->dflags to prevent
  * new URBs from being submitted.  It then calls usb_stor_stop_transport()
- * below, which atomically tests-and-clears the URB_ACTIVE bit in us->flags
+ * below, which atomically tests-and-clears the URB_ACTIVE bit in us->dflags
  * to see if the current_urb needs to be stopped.  Likewise, the SG_ACTIVE
  * bit is tested to see if the current_sg scatter-gather request needs to be
  * stopped.  The timeout callback routine does much the same thing.
  *
- * When a disconnect occurs, the DISCONNECTING bit in us->flags is set to
+ * When a disconnect occurs, the DISCONNECTING bit in us->dflags is set to
  * prevent new URBs from being submitted, and usb_stor_stop_transport() is
  * called to stop any ongoing requests.
  *
@@ -127,8 +125,8 @@ static int usb_stor_msg_common(struct us_data *us, int timeout)
         long timeleft;
         int status;
 
-        /* don't submit URBs during abort/disconnect processing */
-        if (us->flags & ABORTING_OR_DISCONNECTING)
+        /* don't submit URBs during abort processing */
+        if (test_bit(US_FLIDX_ABORTING, &us->dflags))
                 return -EIO;
 
         /* set up data structures for the wakeup system */
@@ -159,13 +157,13 @@ static int usb_stor_msg_common(struct us_data *us, int timeout)
 
         /* since the URB has been submitted successfully, it's now okay
          * to cancel it */
-        set_bit(US_FLIDX_URB_ACTIVE, &us->flags);
+        set_bit(US_FLIDX_URB_ACTIVE, &us->dflags);
 
-        /* did an abort/disconnect occur during the submission? */
-        if (us->flags & ABORTING_OR_DISCONNECTING) {
+        /* did an abort occur during the submission? */
+        if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {
 
                 /* cancel the URB, if it hasn't been cancelled already */
-                if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
+                if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags)) {
                         US_DEBUGP("-- cancelling URB\n");
                         usb_unlink_urb(us->current_urb);
                 }
@@ -175,7 +173,7 @@ static int usb_stor_msg_common(struct us_data *us, int timeout)
         timeleft = wait_for_completion_interruptible_timeout(
                         &urb_done, timeout ? : MAX_SCHEDULE_TIMEOUT);
  
-        clear_bit(US_FLIDX_URB_ACTIVE, &us->flags);
+        clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags);
 
         if (timeleft <= 0) {
                 US_DEBUGP("%s -- cancelling URB\n",
@@ -419,8 +417,8 @@ static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
 {
         int result;
 
-        /* don't submit s-g requests during abort/disconnect processing */
-        if (us->flags & ABORTING_OR_DISCONNECTING)
+        /* don't submit s-g requests during abort processing */
+        if (test_bit(US_FLIDX_ABORTING, &us->dflags))
                 return USB_STOR_XFER_ERROR;
 
         /* initialize the scatter-gather request block */
@@ -435,13 +433,13 @@ static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
 
         /* since the block has been initialized successfully, it's now
          * okay to cancel it */
-        set_bit(US_FLIDX_SG_ACTIVE, &us->flags);
+        set_bit(US_FLIDX_SG_ACTIVE, &us->dflags);
 
-        /* did an abort/disconnect occur during the submission? */
-        if (us->flags & ABORTING_OR_DISCONNECTING) {
+        /* did an abort occur during the submission? */
+        if (test_bit(US_FLIDX_ABORTING, &us->dflags)) {
 
                 /* cancel the request, if it hasn't been cancelled already */
-                if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
+                if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->dflags)) {
                         US_DEBUGP("-- cancelling sg request\n");
                         usb_sg_cancel(&us->current_sg);
                 }
@@ -449,7 +447,7 @@ static int usb_stor_bulk_transfer_sglist(struct us_data *us, unsigned int pipe,
 
         /* wait for the completion of the transfer */
         usb_sg_wait(&us->current_sg);
-        clear_bit(US_FLIDX_SG_ACTIVE, &us->flags);
+        clear_bit(US_FLIDX_SG_ACTIVE, &us->dflags);
 
         result = us->current_sg.status;
         if (act_len)
@@ -530,7 +528,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* if the command gets aborted by the higher layers, we need to
          * short-circuit all other processing
          */
-        if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
+        if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                 US_DEBUGP("-- command was aborted\n");
                 srb->result = DID_ABORT << 16;
                 goto Handle_Errors;
@@ -616,7 +614,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 /* let's clean up right away */
                 scsi_eh_restore_cmnd(srb, &ses);
 
-                if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
+                if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                         US_DEBUGP("-- auto-sense aborted\n");
                         srb->result = DID_ABORT << 16;
                         goto Handle_Errors;
@@ -629,7 +627,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                          * auto-sense is perfectly valid
                          */
                         srb->result = DID_ERROR << 16;
-                        if (!(us->flags & US_FL_SCM_MULT_TARG))
+                        if (!(us->fflags & US_FL_SCM_MULT_TARG))
                                 goto Handle_Errors;
                         return;
                 }
@@ -679,8 +677,8 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* Set the RESETTING bit, and clear the ABORTING bit so that
          * the reset may proceed. */
         scsi_lock(us_to_host(us));
-        set_bit(US_FLIDX_RESETTING, &us->flags);
-        clear_bit(US_FLIDX_ABORTING, &us->flags);
+        set_bit(US_FLIDX_RESETTING, &us->dflags);
+        clear_bit(US_FLIDX_ABORTING, &us->dflags);
         scsi_unlock(us_to_host(us));
 
         /* We must release the device lock because the pre_reset routine
@@ -695,7 +693,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 scsi_unlock(us_to_host(us));
                 us->transport_reset(us);
         }
-        clear_bit(US_FLIDX_RESETTING, &us->flags);
+        clear_bit(US_FLIDX_RESETTING, &us->dflags);
 }
 
 /* Stop the current URB transfer */
@@ -707,13 +705,13 @@ void usb_stor_stop_transport(struct us_data *us)
          * let's wake it up.  The test_and_clear_bit() call
          * guarantees that if a URB has just been submitted,
          * it won't be cancelled more than once. */
-        if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->flags)) {
+        if (test_and_clear_bit(US_FLIDX_URB_ACTIVE, &us->dflags)) {
                 US_DEBUGP("-- cancelling URB\n");
                 usb_unlink_urb(us->current_urb);
         }
 
         /* If we are waiting for a scatter-gather operation, cancel it. */
-        if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->flags)) {
+        if (test_and_clear_bit(US_FLIDX_SG_ACTIVE, &us->dflags)) {
                 US_DEBUGP("-- cancelling sg request\n");
                 usb_sg_cancel(&us->current_sg);
         }
@@ -914,7 +912,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         unsigned int cbwlen = US_BULK_CB_WRAP_LEN;
 
         /* Take care of BULK32 devices; set extra byte to 0 */
-        if ( unlikely(us->flags & US_FL_BULK32)) {
+        if (unlikely(us->fflags & US_FL_BULK32)) {
                 cbwlen = 32;
                 us->iobuf[31] = 0;
         }
@@ -925,7 +923,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         bcb->Flags = srb->sc_data_direction == DMA_FROM_DEVICE ? 1 << 7 : 0;
         bcb->Tag = ++us->tag;
         bcb->Lun = srb->device->lun;
-        if (us->flags & US_FL_SCM_MULT_TARG)
+        if (us->fflags & US_FL_SCM_MULT_TARG)
                 bcb->Lun |= srb->device->id << 4;
         bcb->Length = srb->cmd_len;
 
@@ -951,7 +949,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* Some USB-IDE converter chips need a 100us delay between the
          * command phase and the data phase.  Some devices need a little
          * more than that, probably because of clock rate inaccuracies. */
-        if (unlikely(us->flags & US_FL_GO_SLOW))
+        if (unlikely(us->fflags & US_FL_GO_SLOW))
                 udelay(125);
 
         if (transfer_length) {
@@ -1010,7 +1008,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 == us->tag || (us->flags & US_FL_BULK_IGNORE_TAG)) ||
+        if (!(bcs->Tag == us->tag || (us->fflags & US_FL_BULK_IGNORE_TAG)) ||
                 bcs->Status > US_BULK_STAT_PHASE) {
                 US_DEBUGP("Bulk logical error\n");
                 return USB_STOR_TRANSPORT_ERROR;
@@ -1035,7 +1033,7 @@ int usb_stor_Bulk_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* try to compute the actual residue, based on how much data
          * was really transferred and what the device tells us */
         if (residue) {
-                if (!(us->flags & US_FL_IGNORE_RESIDUE)) {
+                if (!(us->fflags & US_FL_IGNORE_RESIDUE)) {
                         residue = min(residue, transfer_length);
                         scsi_set_resid(srb, max(scsi_get_resid(srb),
                                                                (int) residue));
@@ -1090,7 +1088,7 @@ static int usb_stor_reset_common(struct us_data *us,
         int result;
         int result2;
 
-        if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+        if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
                 US_DEBUGP("No reset during disconnect\n");
                 return -EIO;
         }
@@ -1103,12 +1101,12 @@ static int usb_stor_reset_common(struct us_data *us,
                 return result;
         }
 
-        /* Give the device some time to recover from the reset,
-         * but don't delay disconnect processing. */
-        wait_event_interruptible_timeout(us->delay_wait,
-                        test_bit(US_FLIDX_DISCONNECTING, &us->flags),
-                        HZ*6);
-        if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+        /* Give the device some time to recover from the reset,
+         * but don't delay disconnect processing. */
+        wait_event_interruptible_timeout(us->delay_wait,
+                        test_bit(US_FLIDX_DISCONNECTING, &us->dflags),
+                        HZ*6);
+        if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
                 US_DEBUGP("Reset interrupted by disconnect\n");
                 return -EIO;
         }
@@ -1170,13 +1168,12 @@ int usb_stor_port_reset(struct us_data *us)
                 US_DEBUGP("unable to lock device for reset: %d\n", result);
         else {
                 /* Were we disconnected while waiting for the lock? */
-                if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+                if (test_bit(US_FLIDX_DISCONNECTING, &us->dflags)) {
                         result = -EIO;
                         US_DEBUGP("No reset during disconnect\n");
                 } else {
-                        result = usb_reset_composite_device(
-                                        us->pusb_dev, us->pusb_intf);
-                        US_DEBUGP("usb_reset_composite_device returns %d\n",
+                        result = usb_reset_device(us->pusb_dev);
+                        US_DEBUGP("usb_reset_device returns %d\n",
                                         result);
                 }
                 if (rc_lock)
diff --git a/drivers/usb/storage/transport.h b/drivers/usb/storage/transport.h
index ada7c2f43f84..e70b88182f0e 100644
--- a/drivers/usb/storage/transport.h
+++ b/drivers/usb/storage/transport.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Transport Functions Header File
  *
- * $Id: transport.h,v 1.18 2002/04/21 02:57:59 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999, 2000 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 39a7c11795c4..7ae69f55aa96 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Unusual Devices File
  *
- * $Id: unusual_devs.h,v 1.32 2002/02/25 02:41:24 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 2000-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
@@ -1234,6 +1232,17 @@ UNUSUAL_DEV(  0x0851, 0x1543, 0x0200, 0x0200,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_NOT_LOCKABLE),
 
+/* Andrew Lunn <andrew@lunn.ch>
+ * PanDigital Digital Picture Frame. Does not like ALLOW_MEDIUM_REMOVAL
+ * on LUN 4.
+ * Note: Vend:Prod clash with "Ltd Maxell WS30 Slim Digital Camera"
+*/
+UNUSUAL_DEV(  0x0851, 0x1543, 0x0200, 0x0200,
+                "PanDigital",
+                "Photo Frame",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_NOT_LOCKABLE),
+
 /* Submitted by Jan De Luyck <lkml@kcore.org> */
 UNUSUAL_DEV(  0x08bd, 0x1100, 0x0000, 0x0000,
                 "CITIZEN",
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index e268aacb773a..bfea851be985 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -1,7 +1,5 @@
 /* Driver for USB Mass Storage compliant devices
  *
- * $Id: usb.c,v 1.75 2002/04/22 03:39:43 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2003 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
@@ -312,26 +310,27 @@ static int usb_stor_control_thread(void * __us)
 
         for(;;) {
                 US_DEBUGP("*** thread sleeping.\n");
-                if(down_interruptible(&us->sema))
+                if (wait_for_completion_interruptible(&us->cmnd_ready))
                         break;
-                        
+
                 US_DEBUGP("*** thread awakened.\n");
 
                 /* lock the device pointers */
                 mutex_lock(&(us->dev_mutex));
 
-                /* if the device has disconnected, we are free to exit */
-                if (test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
-                        US_DEBUGP("-- exiting\n");
+                /* lock access to the state */
+                scsi_lock(host);
+
+                /* When we are called with no command pending, we're done */
+                if (us->srb == NULL) {
+                        scsi_unlock(host);
                         mutex_unlock(&us->dev_mutex);
+                        US_DEBUGP("-- exiting\n");
                         break;
                 }
 
-                /* lock access to the state */
-                scsi_lock(host);
-
                 /* has the command timed out *already* ? */
-                if (test_bit(US_FLIDX_TIMED_OUT, &us->flags)) {
+                if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                         us->srb->result = DID_ABORT << 16;
                         goto SkipForAbort;
                 }
@@ -350,7 +349,7 @@ static int usb_stor_control_thread(void * __us)
                  * the maximum known LUN
                  */
                 else if (us->srb->device->id && 
-                                !(us->flags & US_FL_SCM_MULT_TARG)) {
+                                !(us->fflags & US_FL_SCM_MULT_TARG)) {
                         US_DEBUGP("Bad target number (%d:%d)\n",
                                   us->srb->device->id, us->srb->device->lun);
                         us->srb->result = DID_BAD_TARGET << 16;
@@ -365,7 +364,7 @@ static int usb_stor_control_thread(void * __us)
                 /* Handle those devices which need us to fake 
                  * their inquiry data */
                 else if ((us->srb->cmnd[0] == INQUIRY) &&
-                            (us->flags & US_FL_FIX_INQUIRY)) {
+                            (us->fflags & US_FL_FIX_INQUIRY)) {
                         unsigned char data_ptr[36] = {
                             0x00, 0x80, 0x02, 0x02,
                             0x1F, 0x00, 0x00, 0x00};
@@ -384,12 +383,8 @@ static int usb_stor_control_thread(void * __us)
                 /* lock access to the state */
                 scsi_lock(host);
 
-                /* did the command already complete because of a disconnect? */
-                if (!us->srb)
-                        ;               /* nothing to do */
-
                 /* indicate that the command is done */
-                else if (us->srb->result != DID_ABORT << 16) {
+                if (us->srb->result != DID_ABORT << 16) {
                         US_DEBUGP("scsi cmd done, result=0x%x\n", 
                                    us->srb->result);
                         us->srb->scsi_done(us->srb);
@@ -403,12 +398,12 @@ SkipForAbort:
                  * the TIMED_OUT flag, not srb->result == DID_ABORT, because
                  * 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)) {
+                if (test_bit(US_FLIDX_TIMED_OUT, &us->dflags)) {
                         complete(&(us->notify));
 
                         /* Allow USB transfers to resume */
-                        clear_bit(US_FLIDX_ABORTING, &us->flags);
-                        clear_bit(US_FLIDX_TIMED_OUT, &us->flags);
+                        clear_bit(US_FLIDX_ABORTING, &us->dflags);
+                        clear_bit(US_FLIDX_TIMED_OUT, &us->dflags);
                 }
 
                 /* finished working on this command */
@@ -500,9 +495,9 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
         us->protocol = (unusual_dev->useTransport == US_PR_DEVICE) ?
                         idesc->bInterfaceProtocol :
                         unusual_dev->useTransport;
-        us->flags = USB_US_ORIG_FLAGS(id->driver_info);
+        us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
 
-        if (us->flags & US_FL_IGNORE_DEVICE) {
+        if (us->fflags & US_FL_IGNORE_DEVICE) {
                 printk(KERN_INFO USB_STORAGE "device ignored\n");
                 return -ENODEV;
         }
@@ -512,7 +507,7 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
          * disable it if we're in full-speed
          */
         if (dev->speed != USB_SPEED_HIGH)
-                us->flags &= ~US_FL_GO_SLOW;
+                us->fflags &= ~US_FL_GO_SLOW;
 
         /* Log a message if a non-generic unusual_dev entry contains an
          * unnecessary subclass or protocol override.  This may stimulate
@@ -533,7 +528,7 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
                 if (unusual_dev->useTransport != US_PR_DEVICE &&
                         us->protocol == idesc->bInterfaceProtocol)
                         msg += 2;
-                if (msg >= 0 && !(us->flags & US_FL_NEED_OVERRIDE))
+                if (msg >= 0 && !(us->fflags & US_FL_NEED_OVERRIDE))
                         printk(KERN_NOTICE USB_STORAGE "This device "
                                 "(%04x,%04x,%04x S %02x P %02x)"
                                 " has %s in unusual_devs.h (kernel"
@@ -663,7 +658,7 @@ static int get_transport(struct us_data *us)
         US_DEBUGP("Transport: %s\n", us->transport_name);
 
         /* fix for single-lun devices */
-        if (us->flags & US_FL_SINGLE_LUN)
+        if (us->fflags & US_FL_SINGLE_LUN)
                 us->max_lun = 0;
         return 0;
 }
@@ -820,12 +815,11 @@ static void usb_stor_release_resources(struct us_data *us)
         US_DEBUGP("-- %s\n", __func__);
 
         /* Tell the control thread to exit.  The SCSI host must
-         * already have been removed so it won't try to queue
-         * any more commands.
+         * already have been removed and the DISCONNECTING flag set
+         * so that we won't accept any more commands.
          */
         US_DEBUGP("-- sending exit command to thread\n");
-        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
-        up(&us->sema);
+        complete(&us->cmnd_ready);
         if (us->ctl_thread)
                 kthread_stop(us->ctl_thread);
 
@@ -859,39 +853,36 @@ 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 */
+/* First stage of disconnect processing: stop SCSI scanning,
+ * remove the host, and stop accepting new commands
+ */
 static void quiesce_and_remove_host(struct us_data *us)
 {
         struct Scsi_Host *host = us_to_host(us);
 
-        /* Prevent new USB transfers, stop the current command, and
-         * interrupt a SCSI-scan or device-reset delay */
-        scsi_lock(host);
-        set_bit(US_FLIDX_DISCONNECTING, &us->flags);
-        scsi_unlock(host);
-        usb_stor_stop_transport(us);
-        wake_up(&us->delay_wait);
+        /* If the device is really gone, cut short reset delays */
+        if (us->pusb_dev->state == USB_STATE_NOTATTACHED)
+                set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
 
-        /* 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. */
-        mutex_lock(&us->dev_mutex);
-        if (us->srb) {
-                us->srb->result = DID_NO_CONNECT << 16;
-                scsi_lock(host);
-                us->srb->scsi_done(us->srb);
-                us->srb = NULL;
-                complete(&us->notify);          /* in case of an abort */
-                scsi_unlock(host);
-        }
-        mutex_unlock(&us->dev_mutex);
+        /* Prevent SCSI-scanning (if it hasn't started yet)
+         * and wait for the SCSI-scanning thread to stop.
+         */
+        set_bit(US_FLIDX_DONT_SCAN, &us->dflags);
+        wake_up(&us->delay_wait);
+        wait_for_completion(&us->scanning_done);
 
-        /* Now we own no commands so it's safe to remove the SCSI host */
+        /* Removing the host will perform an orderly shutdown: caches
+         * synchronized, disks spun down, etc.
+         */
         scsi_remove_host(host);
 
-        /* Wait for the SCSI-scanning thread to stop */
-        wait_for_completion(&us->scanning_done);
+        /* Prevent any new commands from being accepted and cut short
+         * reset delays.
+         */
+        scsi_lock(host);
+        set_bit(US_FLIDX_DISCONNECTING, &us->dflags);
+        scsi_unlock(host);
+        wake_up(&us->delay_wait);
 }
 
 /* Second stage of disconnect processing: deallocate all resources */
@@ -919,16 +910,16 @@ static int usb_stor_scan_thread(void * __us)
                 printk(KERN_DEBUG "usb-storage: waiting for device "
                                 "to settle before scanning\n");
                 wait_event_freezable_timeout(us->delay_wait,
-                                test_bit(US_FLIDX_DISCONNECTING, &us->flags),
+                                test_bit(US_FLIDX_DONT_SCAN, &us->dflags),
                                 delay_use * HZ);
         }
 
         /* If the device is still connected, perform the scanning */
-        if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+        if (!test_bit(US_FLIDX_DONT_SCAN, &us->dflags)) {
 
                 /* For bulk-only devices, determine the max LUN value */
                 if (us->protocol == US_PR_BULK &&
-                                !(us->flags & US_FL_SINGLE_LUN)) {
+                                !(us->fflags & US_FL_SINGLE_LUN)) {
                         mutex_lock(&us->dev_mutex);
                         us->max_lun = usb_stor_Bulk_max_lun(us);
                         mutex_unlock(&us->dev_mutex);
@@ -975,7 +966,7 @@ static int storage_probe(struct usb_interface *intf,
         us = host_to_us(host);
         memset(us, 0, sizeof(struct us_data));
         mutex_init(&(us->dev_mutex));
-        init_MUTEX_LOCKED(&(us->sema));
+        init_completion(&us->cmnd_ready);
         init_completion(&(us->notify));
         init_waitqueue_head(&us->delay_wait);
         init_completion(&us->scanning_done);
@@ -1023,6 +1014,7 @@ static int storage_probe(struct usb_interface *intf,
         if (IS_ERR(th)) {
                 printk(KERN_WARNING USB_STORAGE 
                        "Unable to start the device-scanning thread\n");
+                complete(&us->scanning_done);
                 quiesce_and_remove_host(us);
                 result = PTR_ERR(th);
                 goto BadDevice;
@@ -1065,6 +1057,7 @@ static struct usb_driver usb_storage_driver = {
         .pre_reset =    storage_pre_reset,
         .post_reset =   storage_post_reset,
         .id_table =     storage_usb_ids,
+        .soft_unbind =  1,
 };
 
 static int __init usb_stor_init(void)
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index 8d87503e2560..a4ad73bd832d 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -1,8 +1,6 @@
 /* Driver for USB Mass Storage compliant devices
  * Main Header File
  *
- * $Id: usb.h,v 1.21 2002/04/21 02:57:59 mdharm Exp $
- *
  * Current development and maintenance by:
  *   (c) 1999-2002 Matthew Dharm (mdharm-usb@one-eyed-alien.net)
  *
@@ -67,16 +65,14 @@ struct us_unusual_dev {
 };
 
 
-/* Dynamic flag definitions: used in set_bit() etc. */
-#define US_FLIDX_URB_ACTIVE     18  /* 0x00040000  current_urb is in use  */
-#define US_FLIDX_SG_ACTIVE      19  /* 0x00080000  current_sg is in use   */
-#define US_FLIDX_ABORTING       20  /* 0x00100000  abort is in progress   */
-#define US_FLIDX_DISCONNECTING  21  /* 0x00200000  disconnect in progress */
-#define ABORTING_OR_DISCONNECTING       ((1UL << US_FLIDX_ABORTING) | \
-                                         (1UL << US_FLIDX_DISCONNECTING))
-#define US_FLIDX_RESETTING      22  /* 0x00400000  device reset in progress */
-#define US_FLIDX_TIMED_OUT      23  /* 0x00800000  SCSI midlayer timed out  */
-
+/* Dynamic bitflag definitions (us->dflags): used in set_bit() etc. */
+#define US_FLIDX_URB_ACTIVE     0       /* current_urb is in use    */
+#define US_FLIDX_SG_ACTIVE      1       /* current_sg is in use     */
+#define US_FLIDX_ABORTING       2       /* abort is in progress     */
+#define US_FLIDX_DISCONNECTING  3       /* disconnect in progress   */
+#define US_FLIDX_RESETTING      4       /* device reset in progress */
+#define US_FLIDX_TIMED_OUT      5       /* SCSI midlayer timed out  */
+#define US_FLIDX_DONT_SCAN      6       /* don't scan (disconnect)  */
 
 #define USB_STOR_STRING_LEN 32
 
@@ -109,7 +105,8 @@ struct us_data {
         struct usb_device       *pusb_dev;       /* this usb_device */
         struct usb_interface    *pusb_intf;      /* this interface */
         struct us_unusual_dev   *unusual_dev;    /* device-filter entry     */
-        unsigned long           flags;           /* from filter initially */
+        unsigned long           fflags;          /* fixed flags from filter */
+        unsigned long           dflags;          /* dynamic atomic bitflags */
         unsigned int            send_bulk_pipe;  /* cached pipe values */
         unsigned int            recv_bulk_pipe;
         unsigned int            send_ctrl_pipe;
@@ -147,7 +144,7 @@ struct us_data {
         struct task_struct      *ctl_thread;     /* the control thread   */
 
         /* mutual exclusion and synchronization structures */
-        struct semaphore        sema;            /* to sleep thread on      */
+        struct completion       cmnd_ready;      /* to sleep thread on      */
         struct completion       notify;          /* thread begin/end        */
         wait_queue_head_t       delay_wait;      /* wait during scan, reset */
         struct completion       scanning_done;   /* wait for scan thread    */