142 files changed, 11623 insertions, 8951 deletions

diff --git a/Documentation/DocBook/gadget.tmpl b/Documentation/DocBook/gadget.tmpl
index 5a8ffa761e09..ea3bc9565e6a 100644
--- a/Documentation/DocBook/gadget.tmpl
+++ b/Documentation/DocBook/gadget.tmpl
@@ -524,6 +524,44 @@ These utilities include endpoint autoconfiguration.
 <!-- !Edrivers/usb/gadget/epautoconf.c -->
 </sect1>
 
+<sect1 id="composite"><title>Composite Device Framework</title>
+
+<para>The core API is sufficient for writing drivers for composite
+USB devices (with more than one function in a given configuration),
+and also multi-configuration devices (also more than one function,
+but not necessarily sharing a given configuration).
+There is however an optional framework which makes it easier to
+reuse and combine functions.
+</para>
+
+<para>Devices using this framework provide a <emphasis>struct
+usb_composite_driver</emphasis>, which in turn provides one or
+more <emphasis>struct usb_configuration</emphasis> instances.
+Each such configuration includes at least one
+<emphasis>struct usb_function</emphasis>, which packages a user
+visible role such as "network link" or "mass storage device".
+Management functions may also exist, such as "Device Firmware
+Upgrade".
+</para>
+
+!Iinclude/linux/usb/composite.h
+!Edrivers/usb/gadget/composite.c
+
+</sect1>
+
+<sect1 id="functions"><title>Composite Device Functions</title>
+
+<para>At this writing, a few of the current gadget drivers have
+been converted to this framework.
+Near-term plans include converting all of them, except for "gadgetfs".
+</para>
+
+!Edrivers/usb/gadget/f_acm.c
+!Edrivers/usb/gadget/f_serial.c
+
+</sect1>
+
+
 </chapter>
 
 <chapter id="controllers"><title>Peripheral Controller Drivers</title>
diff --git a/Documentation/usb/gadget_serial.txt b/Documentation/usb/gadget_serial.txt
index 815f5c2301ff..9b22bd14c348 100644
--- a/Documentation/usb/gadget_serial.txt
+++ b/Documentation/usb/gadget_serial.txt
@@ -1,6 +1,7 @@
 
                  Linux Gadget Serial Driver v2.0
                            11/20/2004
+                  (updated 8-May-2008 for v2.3)
 
 
 License and Disclaimer
@@ -31,7 +32,7 @@ Prerequisites
 -------------
 Versions of the gadget serial driver are available for the
 2.4 Linux kernels, but this document assumes you are using
-version 2.0 or later of the gadget serial driver in a 2.6
+version 2.3 or later of the gadget serial driver in a 2.6
 Linux kernel.
 
 This document assumes that you are familiar with Linux and
@@ -40,6 +41,12 @@ standard utilities, use minicom and HyperTerminal, and work with
 USB and serial devices.  It also assumes you configure the Linux
 gadget and usb drivers as modules.
 
+With version 2.3 of the driver, major and minor device nodes are
+no longer statically defined.  Your Linux based system should mount
+sysfs in /sys, and use "mdev" (in Busybox) or "udev" to make the
+/dev nodes matching the sysfs /sys/class/tty files.
+
+
 
 Overview
 --------
@@ -104,15 +111,8 @@ driver.  All this are listed under "USB Gadget Support" when
 configuring the kernel.  Then rebuild and install the kernel or
 modules.
 
-The gadget serial driver uses major number 127, for now.  So you
-will need to create a device node for it, like this:
-
-  mknod /dev/ttygserial c 127 0
-
-You only need to do this once.
-
 Then you must load the gadget serial driver.  To load it as an
-ACM device, do this:
+ACM device (recommended for interoperability), do this:
 
   modprobe g_serial use_acm=1
 
@@ -125,6 +125,23 @@ controller driver.  This must be done each time you reboot the gadget
 side Linux system.  You can add this to the start up scripts, if
 desired.
 
+Your system should use mdev (from busybox) or udev to make the
+device nodes.  After this gadget driver has been set up you should
+then see a /dev/ttyGS0 node:
+
+  # ls -l /dev/ttyGS0 | cat
+  crw-rw----    1 root     root     253,   0 May  8 14:10 /dev/ttyGS0
+  #
+
+Note that the major number (253, above) is system-specific.  If
+you need to create /dev nodes by hand, the right numbers to use
+will be in the /sys/class/tty/ttyGS0/dev file.
+
+When you link this gadget driver early, perhaps even statically,
+you may want to set up an /etc/inittab entry to run "getty" on it.
+The /dev/ttyGS0 line should work like most any other serial port.
+
+
 If gadget serial is loaded as an ACM device you will want to use
 either the Windows or Linux ACM driver on the host side.  If gadget
 serial is loaded as a bulk in/out device, you will want to use the
diff --git a/Documentation/usb/persist.txt b/Documentation/usb/persist.txt
index d56cb1a11550..074b159b77c2 100644
--- a/Documentation/usb/persist.txt
+++ b/Documentation/usb/persist.txt
@@ -81,8 +81,11 @@ re-enumeration shows that the device now attached to that port has the
 same descriptors as before, including the Vendor and Product IDs, then
 the kernel continues to use the same device structure.  In effect, the
 kernel treats the device as though it had merely been reset instead of
-unplugged.  The same thing happens if the host controller is in the
-expected state but a USB device was unplugged and then replugged.
+unplugged.
+
+The same thing happens if the host controller is in the expected state
+but a USB device was unplugged and then replugged, or if a USB device
+fails to carry out a normal resume.
 
 If no device is now attached to the port, or if the descriptors are
 different from what the kernel remembers, then the treatment is what
diff --git a/Documentation/usb/uhci.txt b/Documentation/usb/uhci.txt
deleted file mode 100644
index 2f25952c86c6..000000000000
--- a/Documentation/usb/uhci.txt
+++ /dev/null
@@ -1,165 +0,0 @@
-Specification and Internals for the New UHCI Driver (Whitepaper...)
-
-        brought to you by
-
-        Georg Acher, acher@in.tum.de (executive slave) (base guitar)
-        Deti Fliegl, deti@fliegl.de (executive slave) (lead voice)
-        Thomas Sailer, sailer@ife.ee.ethz.ch (chief consultant) (cheer leader)
- 
-        $Id: README.uhci,v 1.1 1999/12/14 14:03:02 fliegl Exp $
-
-This document and the new uhci sources can be found on
-                http://hotswap.in.tum.de/usb
-
-1. General issues
-
-1.1 Why a new UHCI driver, we already have one?!?
-
-Correct, but its internal structure got more and more mixed up by the (still
-ongoing) efforts to get isochronous transfers (ISO) to work.
-Since there is an increasing need for reliable ISO-transfers (especially 
-for USB-audio needed by TS and for a DAB-USB-Receiver build by GA and DF), 
-this state was a bit unsatisfying in our opinion, so we've decided (based
-on knowledge and experiences with the old UHCI driver) to start 
-from scratch with a new approach, much simpler but at the same time more 
-powerful.
-It is inspired by the way Win98/Win2000 handles USB requests via URBs,
-but it's definitely 100% free of MS-code and doesn't crash while 
-unplugging an used ISO-device like Win98 ;-)
-Some code for HW setup and root hub management was taken from the 
-original UHCI driver, but heavily modified to fit into the new code.
-The invention of the basic concept, and major coding were completed in two 
-days (and nights) on the 16th and 17th of October 1999, now known as the
-great USB-October-Revolution started by GA, DF, and TS ;-)
-
-Since the concept is in no way UHCI dependent, we hope that it will also be 
-transferred to the OHCI-driver, so both drivers share a common API.
-
-1.2. Advantages and disadvantages
-
-+ All USB transfer types work now!
-+ Asynchronous operation
-+ Simple, but powerful interface (only two calls for start and cancel)
-+ Easy migration to the new API, simplified by a compatibility API
-+ Simple usage of ISO transfers
-+ Automatic linking of requests
-+ ISO transfers allow variable length for each frame and striping
-+ No CPU dependent and non-portable atomic memory access, no asm()-inlines
-+ Tested on x86 and Alpha
-
-- Rewriting for ISO transfers needed
-
-1.3. Is there some compatibility to the old API?
-
-Yes, but only for control, bulk and interrupt transfers. We've implemented 
-some wrapper calls for these transfer types. The usbcore works fine with 
-these wrappers. For ISO there's no compatibility, because the old ISO-API 
-and its semantics were unnecessary complicated in our opinion.
-
-1.4. What's really working?
-
-As said above, CTRL and BULK already work fine even with the wrappers,
-so legacy code wouldn't notice the change.
-Regarding to Thomas, ISO transfers now run stable with USB audio.
-INT transfers (e.g. mouse driver) work fine, too.
-
-1.5. Are there any bugs?
-
-No ;-)
-Hm...
-Well, of course this implementation needs extensive testing on all available
-hardware, but we believe that any fixes shouldn't harm the overall concept.
-
-1.6. What should be done next?
-
-A large part of the request handling seems to be identical for UHCI and 
-OHCI, so it would be a good idea to extract the common parts and have only 
-the HW specific stuff in uhci.c. Furthermore, all other USB device drivers
-should need URBification, if they use isochronous or interrupt transfers.
-One thing missing in the current implementation (and the old UHCI driver) 
-is fair queueing for BULK transfers. Since this would need (in principle) 
-the alteration of already constructed TD chains (to switch from depth to 
-breadth execution), another way has to be found. Maybe some simple 
-heuristics work with the same effect.
-
----------------------------------------------------------------------------
-
-2. Internal structure and mechanisms
-
-To get quickly familiar with the internal structures, here's a short
-description how the new UHCI driver works. However, the ultimate source of
-truth is only uhci.c!
-
-2.1. Descriptor structure (QHs and TDs)
-
-During initialization, the following skeleton is allocated in init_skel:
-
-         framespecific           |           common chain     
-
-framelist[]
-[  0 ]-----> TD --> TD -------\
-[  1 ]-----> TD --> TD --------> TD ----> QH -------> QH -------> QH ---> NULL
-  ...        TD --> TD -------/
-[1023]-----> TD --> TD ------/
-             
-             ^^     ^^           ^^       ^^          ^^          ^^
-   1024 TDs for   7 TDs for    1 TD for   Start of    Start of    End Chain
-            ISO  INT (2-128ms) 1ms-INT    CTRL Chain  BULK Chain
-
-For each CTRL or BULK transfer a new QH is allocated and the containing data
-transfers are appended as (vertical) TDs. After building the whole QH with its
-dangling TDs, the QH is inserted before the BULK Chain QH (for CTRL) or
-before the End Chain QH (for BULK). Since only the QH->next pointers are
-affected, no atomic memory operation is required. The three QHs in the
-common chain are never equipped with TDs!
-
-For ISO or INT, the TD for each frame is simply inserted into the appropriate
-ISO/INT-TD-chain for the desired frame. The 7 skeleton INT-TDs are scattered
-among the 1024 frames similar to the old UHCI driver.
-
-For CTRL/BULK/ISO, the last TD in the transfer has the IOC-bit set. For INT,
-every TD (there is only one...) has the IOC-bit set.
-
-Besides the data for the UHCI controller (2 or 4 32bit words), the descriptors
-are double-linked through the .vertical and .horizontal elements in the 
-SW data of the descriptor (using the double-linked list structures and 
-operations), but SW-linking occurs only in closed domains, i.e. for each of
-the 1024 ISO-chains and the 8 INT-chains there is a closed cycle. This 
-simplifies all insertions and unlinking operations and avoids costly 
-bus_to_virt()-calls.
-
-2.2. URB structure and linking to QH/TDs
-
-During assembly of the QH and TDs of the requested action, these descriptors
-are stored in urb->urb_list, so the allocated QH/TD descriptors are bound to
-this URB.
-If the assembly was successful and the descriptors were added to the HW chain,
-the corresponding URB is inserted into a global URB list for this controller.
-This list stores all pending URBs.
-
-2.3. Interrupt processing
-
-Since UHCI provides no means to directly detect completed transactions, the
-following is done in each UHCI interrupt (uhci_interrupt()):
-
-For each URB in the pending queue (process_urb()), the ACTIVE-flag of the 
-associated TDs are processed (depending on the transfer type 
-process_{transfer|interrupt|iso}()). If the TDs are not active anymore, 
-they indicate the completion of the transaction and the status is calculated. 
-Inactive QH/TDs are removed from the HW chain (since the host controller
-already removed the TDs from the QH, no atomic access is needed) and 
-eventually the URB is marked as completed (OK or errors) and removed from the 
-pending queue. Then the next linked URB is submitted. After (or immediately 
-before) that, the completion handler is called.
-
-2.4. Unlinking URBs
-
-First, all QH/TDs stored in the URB are unlinked from the HW chain. 
-To ensure that the host controller really left a vertical TD chain, we 
-wait for one frame. After that, the TDs are physically destroyed.
-
-2.5. URB linking and the consequences
-
-Since URBs can be linked and the corresponding submit_urb is called in
-the UHCI-interrupt, all work associated with URB/QH/TD assembly has to be
-interrupt save. This forces kmalloc to use GFP_ATOMIC in the interrupt.
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    */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index c08689ea9b4b..5811c5da69f9 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -160,6 +160,7 @@ struct usb_interface {
         unsigned is_active:1;           /* the interface is not suspended */
         unsigned sysfs_files_created:1; /* the sysfs attributes exist */
         unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
+        unsigned needs_binding:1;       /* needs delayed unbind/rebind */
 
         struct device dev;              /* interface specific device info */
         struct device *usb_dev;
@@ -293,7 +294,7 @@ struct usb_devmap {
 struct usb_bus {
         struct device *controller;      /* host/master side hardware */
         int busnum;                     /* Bus number (in order of reg) */
-        char *bus_name;                 /* stable id (PCI slot_name etc) */
+        const char *bus_name;           /* stable id (PCI slot_name etc) */
         u8 uses_dma;                    /* Does the host controller use DMA? */
         u8 otg_port;                    /* 0, or number of OTG/HNP port */
         unsigned is_b_host:1;           /* true during some HNP roleswitches */
@@ -497,8 +498,6 @@ extern int usb_lock_device_for_reset(struct usb_device *udev,
 
 /* USB port reset for device reinitialization */
 extern int usb_reset_device(struct usb_device *dev);
-extern int usb_reset_composite_device(struct usb_device *dev,
-                struct usb_interface *iface);
 
 extern struct usb_device *usb_find_device(u16 vendor_id, u16 product_id);
 
@@ -958,9 +957,9 @@ struct usbdrv_wrap {
  * @resume: Called when the device is being resumed by the system.
  * @reset_resume: Called when the suspended device has been reset instead
  *      of being resumed.
- * @pre_reset: Called by usb_reset_composite_device() when the device
+ * @pre_reset: Called by usb_reset_device() when the device
  *      is about to be reset.
- * @post_reset: Called by usb_reset_composite_device() after the device
+ * @post_reset: Called by usb_reset_device() after the device
  *      has been reset
  * @id_table: USB drivers use ID table to support hotplugging.
  *      Export this with MODULE_DEVICE_TABLE(usb,...).  This must be set
@@ -972,6 +971,8 @@ struct usbdrv_wrap {
  *      added to this driver by preventing the sysfs file from being created.
  * @supports_autosuspend: if set to 0, the USB core will not allow autosuspend
  *      for interfaces bound to this driver.
+ * @soft_unbind: if set to 1, the USB core will not kill URBs and disable
+ *      endpoints before calling the driver's disconnect method.
  *
  * USB interface drivers must provide a name, probe() and disconnect()
  * methods, and an id_table.  Other driver fields are optional.
@@ -1012,6 +1013,7 @@ struct usb_driver {
         struct usbdrv_wrap drvwrap;
         unsigned int no_dynamic_id:1;
         unsigned int supports_autosuspend:1;
+        unsigned int soft_unbind:1;
 };
 #define to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)
 
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
new file mode 100644
index 000000000000..747c3a49cdc9
--- /dev/null
+++ b/include/linux/usb/composite.h
@@ -0,0 +1,338 @@
+/*
+ * composite.h -- framework for usb gadgets which are composite devices
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __LINUX_USB_COMPOSITE_H
+#define __LINUX_USB_COMPOSITE_H
+
+/*
+ * This framework is an optional layer on top of the USB Gadget interface,
+ * making it easier to build (a) Composite devices, supporting multiple
+ * functions within any single configuration, and (b) Multi-configuration
+ * devices, also supporting multiple functions but without necessarily
+ * having more than one function per configuration.
+ *
+ * Example:  a device with a single configuration supporting both network
+ * link and mass storage functions is a composite device.  Those functions
+ * might alternatively be packaged in individual configurations, but in
+ * the composite model the host can use both functions at the same time.
+ */
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+
+struct usb_configuration;
+
+/**
+ * struct usb_function - describes one function of a configuration
+ * @name: For diagnostics, identifies the function.
+ * @strings: tables of strings, keyed by identifiers assigned during bind()
+ *      and by language IDs provided in control requests
+ * @descriptors: Table of full (or low) speed descriptors, using interface and
+ *      string identifiers assigned during @bind().  If this pointer is null,
+ *      the function will not be available at full speed (or at low speed).
+ * @hs_descriptors: Table of high speed descriptors, using interface and
+ *      string identifiers assigned during @bind().  If this pointer is null,
+ *      the function will not be available at high speed.
+ * @config: assigned when @usb_add_function() is called; this is the
+ *      configuration with which this function is associated.
+ * @bind: Before the gadget can register, all of its functions bind() to the
+ *      available resources including string and interface identifiers used
+ *      in interface or class descriptors; endpoints; I/O buffers; and so on.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *      driver which added this function.
+ * @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
+ *      initialize usb_ep.driver data at this time (when it is used).
+ *      Note that setting an interface to its current altsetting resets
+ *      interface state, and that all interfaces have a disabled state.
+ * @get_alt: Returns the active altsetting.  If this is not provided,
+ *      then only altsetting zero is supported.
+ * @disable: (REQUIRED) Indicates the function should be disabled.  Reasons
+ *      include host resetting or reconfiguring the gadget, and disconnection.
+ * @setup: Used for interface-specific control requests.
+ * @suspend: Notifies functions when the host stops sending USB traffic.
+ * @resume: Notifies functions when the host restarts USB traffic.
+ *
+ * A single USB function uses one or more interfaces, and should in most
+ * cases support operation at both full and high speeds.  Each function is
+ * associated by @usb_add_function() with a one configuration; that function
+ * causes @bind() to be called so resources can be allocated as part of
+ * setting up a gadget driver.  Those resources include endpoints, which
+ * should be allocated using @usb_ep_autoconfig().
+ *
+ * To support dual speed operation, a function driver provides descriptors
+ * for both high and full speed operation.  Except in rare cases that don't
+ * involve bulk endpoints, each speed needs different endpoint descriptors.
+ *
+ * Function drivers choose their own strategies for managing instance data.
+ * The simplest strategy just declares it "static', which means the function
+ * can only be activated once.  If the function needs to be exposed in more
+ * than one configuration at a given speed, it needs to support multiple
+ * usb_function structures (one for each configuration).
+ *
+ * A more complex strategy might encapsulate a @usb_function structure inside
+ * a driver-specific instance structure to allows multiple activations.  An
+ * example of multiple activations might be a CDC ACM function that supports
+ * two or more distinct instances within the same configuration, providing
+ * several independent logical data links to a USB host.
+ */
+struct usb_function {
+        const char                      *name;
+        struct usb_gadget_strings       **strings;
+        struct usb_descriptor_header    **descriptors;
+        struct usb_descriptor_header    **hs_descriptors;
+
+        struct usb_configuration        *config;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching.
+         * Related:  unbind() may kfree() but bind() won't...
+         */
+
+        /* configuration management:  bind/unbind */
+        int                     (*bind)(struct usb_configuration *,
+                                        struct usb_function *);
+        void                    (*unbind)(struct usb_configuration *,
+                                        struct usb_function *);
+
+        /* runtime state management */
+        int                     (*set_alt)(struct usb_function *,
+                                        unsigned interface, unsigned alt);
+        int                     (*get_alt)(struct usb_function *,
+                                        unsigned interface);
+        void                    (*disable)(struct usb_function *);
+        int                     (*setup)(struct usb_function *,
+                                        const struct usb_ctrlrequest *);
+        void                    (*suspend)(struct usb_function *);
+        void                    (*resume)(struct usb_function *);
+
+        /* internals */
+        struct list_head                list;
+};
+
+int usb_add_function(struct usb_configuration *, struct usb_function *);
+
+int usb_interface_id(struct usb_configuration *, struct usb_function *);
+
+/**
+ * ep_choose - select descriptor endpoint at current device speed
+ * @g: gadget, connected and running at some speed
+ * @hs: descriptor to use for high speed operation
+ * @fs: descriptor to use for full or low speed operation
+ */
+static inline struct usb_endpoint_descriptor *
+ep_choose(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 MAX_CONFIG_INTERFACES           16      /* arbitrary; max 255 */
+
+/**
+ * struct usb_configuration - represents one gadget configuration
+ * @label: For diagnostics, describes the configuration.
+ * @strings: Tables of strings, keyed by identifiers assigned during @bind()
+ *      and by language IDs provided in control requests.
+ * @descriptors: Table of descriptors preceding all function descriptors.
+ *      Examples include OTG and vendor-specific descriptors.
+ * @bind: Called from @usb_add_config() to allocate resources unique to this
+ *      configuration and to call @usb_add_function() for each function used.
+ * @unbind: Reverses @bind; called as a side effect of unregistering the
+ *      driver which added this configuration.
+ * @setup: Used to delegate control requests that aren't handled by standard
+ *      device infrastructure or directed at a specific interface.
+ * @bConfigurationValue: Copied into configuration descriptor.
+ * @iConfiguration: Copied into configuration descriptor.
+ * @bmAttributes: Copied into configuration descriptor.
+ * @bMaxPower: Copied into configuration descriptor.
+ * @cdev: assigned by @usb_add_config() before calling @bind(); this is
+ *      the device associated with this configuration.
+ *
+ * Configurations are building blocks for gadget drivers structured around
+ * function drivers.  Simple USB gadgets require only one function and one
+ * configuration, and handle dual-speed hardware by always providing the same
+ * functionality.  Slightly more complex gadgets may have more than one
+ * single-function configuration at a given speed; or have configurations
+ * that only work at one speed.
+ *
+ * Composite devices are, by definition, ones with configurations which
+ * include more than one function.
+ *
+ * The lifecycle of a usb_configuration includes allocation, initialization
+ * of the fields described above, and calling @usb_add_config() to set up
+ * internal data and bind it to a specific device.  The configuration's
+ * @bind() method is then used to initialize all the functions and then
+ * call @usb_add_function() for them.
+ *
+ * Those functions would normally be independant of each other, but that's
+ * not mandatory.  CDC WMC devices are an example where functions often
+ * depend on other functions, with some functions subsidiary to others.
+ * Such interdependency may be managed in any way, so long as all of the
+ * descriptors complete by the time the composite driver returns from
+ * its bind() routine.
+ */
+struct usb_configuration {
+        const char                      *label;
+        struct usb_gadget_strings       **strings;
+        const struct usb_descriptor_header **descriptors;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching...
+         */
+
+        /* configuration management:  bind/unbind */
+        int                     (*bind)(struct usb_configuration *);
+        void                    (*unbind)(struct usb_configuration *);
+        int                     (*setup)(struct usb_configuration *,
+                                        const struct usb_ctrlrequest *);
+
+        /* fields in the config descriptor */
+        u8                      bConfigurationValue;
+        u8                      iConfiguration;
+        u8                      bmAttributes;
+        u8                      bMaxPower;
+
+        struct usb_composite_dev        *cdev;
+
+        /* internals */
+        struct list_head        list;
+        struct list_head        functions;
+        u8                      next_interface_id;
+        unsigned                highspeed:1;
+        unsigned                fullspeed:1;
+        struct usb_function     *interface[MAX_CONFIG_INTERFACES];
+};
+
+int usb_add_config(struct usb_composite_dev *,
+                struct usb_configuration *);
+
+/**
+ * struct usb_composite_driver - groups configurations into a gadget
+ * @name: For diagnostics, identifies the driver.
+ * @dev: Template descriptor for the device, including default device
+ *      identifiers.
+ * @strings: tables of strings, keyed by identifiers assigned during bind()
+ *      and language IDs provided in control requests
+ * @bind: (REQUIRED) Used to allocate resources that are shared across the
+ *      whole device, such as string IDs, and add its configurations using
+ *      @usb_add_config().  This may fail by returning a negative errno
+ *      value; it should return zero on successful initialization.
+ * @unbind: Reverses @bind(); called as a side effect of unregistering
+ *      this driver.
+ *
+ * Devices default to reporting self powered operation.  Devices which rely
+ * on bus powered operation should report this in their @bind() method.
+ *
+ * Before returning from @bind, various fields in the template descriptor
+ * may be overridden.  These include the idVendor/idProduct/bcdDevice values
+ * normally to bind the appropriate host side driver, and the three strings
+ * (iManufacturer, iProduct, iSerialNumber) normally used to provide user
+ * meaningful device identifiers.  (The strings will not be defined unless
+ * they are defined in @dev and @strings.)  The correct ep0 maxpacket size
+ * is also reported, as defined by the underlying controller driver.
+ */
+struct usb_composite_driver {
+        const char                              *name;
+        const struct usb_device_descriptor      *dev;
+        struct usb_gadget_strings               **strings;
+
+        /* REVISIT:  bind() functions can be marked __init, which
+         * makes trouble for section mismatch analysis.  See if
+         * we can't restructure things to avoid mismatching...
+         */
+
+        int                     (*bind)(struct usb_composite_dev *);
+        int                     (*unbind)(struct usb_composite_dev *);
+};
+
+extern int usb_composite_register(struct usb_composite_driver *);
+extern void usb_composite_unregister(struct usb_composite_driver *);
+
+
+/**
+ * struct usb_composite_device - represents one composite usb gadget
+ * @gadget: read-only, abstracts the gadget's usb peripheral controller
+ * @req: used for control responses; buffer is pre-allocated
+ * @bufsiz: size of buffer pre-allocated in @req
+ * @config: the currently active configuration
+ *
+ * One of these devices is allocated and initialized before the
+ * associated device driver's bind() is called.
+ *
+ * OPEN ISSUE:  it appears that some WUSB devices will need to be
+ * built by combining a normal (wired) gadget with a wireless one.
+ * This revision of the gadget framework should probably try to make
+ * sure doing that won't hurt too much.
+ *
+ * One notion for how to handle Wireless USB devices involves:
+ * (a) a second gadget here, discovery mechanism TBD, but likely
+ *     needing separate "register/unregister WUSB gadget" calls;
+ * (b) updates to usb_gadget to include flags "is it wireless",
+ *     "is it wired", plus (presumably in a wrapper structure)
+ *     bandgroup and PHY info;
+ * (c) presumably a wireless_ep wrapping a usb_ep, and reporting
+ *     wireless-specific parameters like maxburst and maxsequence;
+ * (d) configurations that are specific to wireless links;
+ * (e) function drivers that understand wireless configs and will
+ *     support wireless for (additional) function instances;
+ * (f) a function to support association setup (like CBAF), not
+ *     necessarily requiring a wireless adapter;
+ * (g) composite device setup that can create one or more wireless
+ *     configs, including appropriate association setup support;
+ * (h) more, TBD.
+ */
+struct usb_composite_dev {
+        struct usb_gadget               *gadget;
+        struct usb_request              *req;
+        unsigned                        bufsiz;
+
+        struct usb_configuration        *config;
+
+        /* internals */
+        struct usb_device_descriptor    desc;
+        struct list_head                configs;
+        struct usb_composite_driver     *driver;
+        u8                              next_string_id;
+
+        spinlock_t                      lock;
+
+        /* REVISIT use and existence of lock ... */
+};
+
+extern int usb_string_id(struct usb_composite_dev *c);
+
+/* messaging utils */
+#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)
+
+#endif  /* __LINUX_USB_COMPOSITE_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index cf468fbdbf8e..0460a746480c 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -33,7 +33,8 @@ struct usb_ep;
  * @short_not_ok: When reading data, makes short packets be
  *     treated as errors (queue stops advancing till cleanup).
  * @complete: Function called when request completes, so this request and
- *      its buffer may be re-used.
+ *      its buffer may be re-used.  The function will always be called with
+ *      interrupts disabled, and it must not sleep.
  *      Reads terminate with a short packet, or when the buffer fills,
  *      whichever comes first.  When writes terminate, some data bytes
  *      will usually still be in flight (often in a hardware fifo).
@@ -271,7 +272,10 @@ static inline void usb_ep_free_request(struct usb_ep *ep,
  * (Note that some USB device controllers disallow protocol stall responses
  * in some cases.)  When control responses are deferred (the response is
  * written after the setup callback returns), then usb_ep_set_halt() may be
- * used on ep0 to trigger protocol stalls.
+ * used on ep0 to trigger protocol stalls.  Depending on the controller,
+ * it may not be possible to trigger a status-stage protocol stall when the
+ * data stage is over, that is, from within the response's completion
+ * routine.
  *
  * For periodic endpoints, like interrupt or isochronous ones, the usb host
  * arranges to poll once per interval, and the gadget driver usually will
@@ -858,6 +862,25 @@ int usb_descriptor_fillbuf(void *, unsigned,
 int usb_gadget_config_buf(const struct usb_config_descriptor *config,
         void *buf, unsigned buflen, const struct usb_descriptor_header **desc);
 
+/* copy a NULL-terminated vector of descriptors */
+struct usb_descriptor_header **usb_copy_descriptors(
+                struct usb_descriptor_header **);
+
+/* return copy of endpoint descriptor given original descriptor set */
+struct usb_endpoint_descriptor *usb_find_endpoint(
+        struct usb_descriptor_header **src,
+        struct usb_descriptor_header **copy,
+        struct usb_endpoint_descriptor *match);
+
+/**
+ * usb_free_descriptors - free descriptors returned by usb_copy_descriptors()
+ * @v: vector of descriptors
+ */
+static inline void usb_free_descriptors(struct usb_descriptor_header **v)
+{
+        kfree(v);
+}
+
 /*-------------------------------------------------------------------------*/
 
 /* utility wrapping a simple endpoint selection policy */
diff --git a/include/linux/usb/irda.h b/include/linux/usb/irda.h
new file mode 100644
index 000000000000..e345ceaf72d6
--- /dev/null
+++ b/include/linux/usb/irda.h
@@ -0,0 +1,151 @@
+/*
+ * USB IrDA Bridge Device Definition
+ */
+
+#ifndef __LINUX_USB_IRDA_H
+#define __LINUX_USB_IRDA_H
+
+/* This device should use Application-specific class */
+
+#define USB_SUBCLASS_IRDA                       0x02
+
+/*-------------------------------------------------------------------------*/
+
+/* Class-Specific requests (bRequest field) */
+
+#define USB_REQ_CS_IRDA_RECEIVING               1
+#define USB_REQ_CS_IRDA_CHECK_MEDIA_BUSY        3
+#define USB_REQ_CS_IRDA_RATE_SNIFF              4
+#define USB_REQ_CS_IRDA_UNICAST_LIST            5
+#define USB_REQ_CS_IRDA_GET_CLASS_DESC          6
+
+/*-------------------------------------------------------------------------*/
+
+/* Class-Specific descriptor */
+
+#define USB_DT_CS_IRDA                          0x21
+
+/*-------------------------------------------------------------------------*/
+
+/* Data sizes */
+
+#define USB_IRDA_DS_2048                        (1 << 5)
+#define USB_IRDA_DS_1024                        (1 << 4)
+#define USB_IRDA_DS_512                         (1 << 3)
+#define USB_IRDA_DS_256                         (1 << 2)
+#define USB_IRDA_DS_128                         (1 << 1)
+#define USB_IRDA_DS_64                          (1 << 0)
+
+/* Window sizes */
+
+#define USB_IRDA_WS_7                           (1 << 6)
+#define USB_IRDA_WS_6                           (1 << 5)
+#define USB_IRDA_WS_5                           (1 << 4)
+#define USB_IRDA_WS_4                           (1 << 3)
+#define USB_IRDA_WS_3                           (1 << 2)
+#define USB_IRDA_WS_2                           (1 << 1)
+#define USB_IRDA_WS_1                           (1 << 0)
+
+/* Min turnaround times in usecs */
+
+#define USB_IRDA_MTT_0                          (1 << 7)
+#define USB_IRDA_MTT_10                         (1 << 6)
+#define USB_IRDA_MTT_50                         (1 << 5)
+#define USB_IRDA_MTT_100                        (1 << 4)
+#define USB_IRDA_MTT_500                        (1 << 3)
+#define USB_IRDA_MTT_1000                       (1 << 2)
+#define USB_IRDA_MTT_5000                       (1 << 1)
+#define USB_IRDA_MTT_10000                      (1 << 0)
+
+/* Baud rates */
+
+#define USB_IRDA_BR_4000000                     (1 << 8)
+#define USB_IRDA_BR_1152000                     (1 << 7)
+#define USB_IRDA_BR_576000                      (1 << 6)
+#define USB_IRDA_BR_115200                      (1 << 5)
+#define USB_IRDA_BR_57600                       (1 << 4)
+#define USB_IRDA_BR_38400                       (1 << 3)
+#define USB_IRDA_BR_19200                       (1 << 2)
+#define USB_IRDA_BR_9600                        (1 << 1)
+#define USB_IRDA_BR_2400                        (1 << 0)
+
+/* Additional BOFs */
+
+#define USB_IRDA_AB_0                           (1 << 7)
+#define USB_IRDA_AB_1                           (1 << 6)
+#define USB_IRDA_AB_2                           (1 << 5)
+#define USB_IRDA_AB_3                           (1 << 4)
+#define USB_IRDA_AB_6                           (1 << 3)
+#define USB_IRDA_AB_12                          (1 << 2)
+#define USB_IRDA_AB_24                          (1 << 1)
+#define USB_IRDA_AB_48                          (1 << 0)
+
+/* IRDA Rate Sniff */
+
+#define USB_IRDA_RATE_SNIFF                     1
+
+/*-------------------------------------------------------------------------*/
+
+struct usb_irda_cs_descriptor {
+        __u8    bLength;
+        __u8    bDescriptorType;
+
+        __le16  bcdSpecRevision;
+        __u8    bmDataSize;
+        __u8    bmWindowSize;
+        __u8    bmMinTurnaroundTime;
+        __le16  wBaudRate;
+        __u8    bmAdditionalBOFs;
+        __u8    bIrdaRateSniff;
+        __u8    bMaxUnicastList;
+} __attribute__ ((packed));
+
+/*-------------------------------------------------------------------------*/
+
+/* Data Format */
+
+#define USB_IRDA_STATUS_MEDIA_BUSY      (1 << 7)
+
+/* The following is a 4-bit value used for both
+ * inbound and outbound headers:
+ *
+ * 0 - speed ignored
+ * 1 - 2400 bps
+ * 2 - 9600 bps
+ * 3 - 19200 bps
+ * 4 - 38400 bps
+ * 5 - 57600 bps
+ * 6 - 115200 bps
+ * 7 - 576000 bps
+ * 8 - 1.152 Mbps
+ * 9 - 5 mbps
+ * 10..15 - Reserved
+ */
+#define USB_IRDA_STATUS_LINK_SPEED      0x0f
+
+/* The following is a 4-bit value used only for
+ * outbound header:
+ *
+ * 0 - No change (BOF ignored)
+ * 1 - 48 BOFs
+ * 2 - 24 BOFs
+ * 3 - 12 BOFs
+ * 4 - 6 BOFs
+ * 5 - 3 BOFs
+ * 6 - 2 BOFs
+ * 7 - 1 BOFs
+ * 8 - 0 BOFs
+ * 9..15 - Reserved
+ */
+#define USB_IRDA_EXTRA_BOFS             0xf0
+
+struct usb_irda_inbound_header {
+        __u8            bmStatus;
+};
+
+struct usb_irda_outbound_header {
+        __u8            bmChange;
+};
+
+#endif /* __LINUX_USB_IRDA_H */
+
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index 3118ede2c67b..0044d9b4cb85 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -22,8 +22,6 @@
  *
  *  History:
  *   0.1  04.01.2000  Created
- *
- *  $Id: usbdevice_fs.h,v 1.1 2000/01/06 18:40:41 tom Exp $
  */
 
 /*****************************************************************************/