Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6

114 files changed, 15601 insertions, 1307 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 289d81adfb9c..83babb0a1df7 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -150,4 +150,6 @@ source "drivers/usb/atm/Kconfig"
 
 source "drivers/usb/gadget/Kconfig"
 
+source "drivers/usb/otg/Kconfig"
+
 endif # USB_SUPPORT
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index d50a99f70aee..00b47ea24f86 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1275,7 +1275,7 @@ 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) {
+        if (message.event & PM_EVENT_AUTO) {
                 int b;
 
                 spin_lock_irq(&acm->read_lock);
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 5a8ecc045e3f..3771d6e6d0cc 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -764,7 +764,8 @@ static int wdm_suspend(struct usb_interface *intf, pm_message_t message)
 
         mutex_lock(&desc->plock);
 #ifdef CONFIG_PM
-        if (interface_to_usbdev(desc->intf)->auto_pm && test_bit(WDM_IN_USE, &desc->flags)) {
+        if ((message.event & PM_EVENT_AUTO) &&
+                        test_bit(WDM_IN_USE, &desc->flags)) {
                 rv = -EBUSY;
         } else {
 #endif
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index 43a863c5cc43..0f5c05f6f9df 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -21,6 +21,7 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/uaccess.h>
 #include <linux/kref.h>
@@ -482,7 +483,6 @@ static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
         int retval;
         int actual;
         unsigned long int n_bytes;
-        int n;
         int remaining;
         int done;
         int this_part;
@@ -526,11 +526,8 @@ static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
                         goto exit;
                 }
 
-                n_bytes = 12 + this_part;
-                if (this_part % 4)
-                        n_bytes += 4 - this_part % 4;
-                        for (n = 12 + this_part; n < n_bytes; n++)
-                                buffer[n] = 0;
+                n_bytes = roundup(12 + this_part, 4);
+                memset(buffer + 12 + this_part, 0, n_bytes - (12 + this_part));
 
                 retval = usb_bulk_msg(data->usb_dev,
                                       usb_sndbulkpipe(data->usb_dev,
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index aa79280df15d..26fece124e0e 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -981,9 +981,6 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                 return -EINVAL;
         if (!uurb->buffer)
                 return -EINVAL;
-        if (uurb->signr != 0 && (uurb->signr < SIGRTMIN ||
-                                 uurb->signr > SIGRTMAX))
-                return -EINVAL;
         if (!(uurb->type == USBDEVFS_URB_TYPE_CONTROL &&
             (uurb->endpoint & ~USB_ENDPOINT_DIR_MASK) == 0)) {
                 ifnum = findintfep(ps->dev, uurb->endpoint);
@@ -1320,7 +1317,7 @@ static int get_urb32(struct usbdevfs_urb *kurb,
         if (__get_user(uptr, &uurb->buffer))
                 return -EFAULT;
         kurb->buffer = compat_ptr(uptr);
-        if (__get_user(uptr, &uurb->buffer))
+        if (__get_user(uptr, &uurb->usercontext))
                 return -EFAULT;
         kurb->usercontext = compat_ptr(uptr);
 
@@ -1401,8 +1398,6 @@ static int proc_disconnectsignal(struct dev_state *ps, void __user *arg)
 
         if (copy_from_user(&ds, arg, sizeof(ds)))
                 return -EFAULT;
-        if (ds.signr != 0 && (ds.signr < SIGRTMIN || ds.signr > SIGRTMAX))
-                return -EINVAL;
         ps->discsignr = ds.signr;
         ps->disccontext = ds.context;
         return 0;
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 8c081308b0e2..98760553bc95 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -184,6 +184,20 @@ static int usb_unbind_device(struct device *dev)
         return 0;
 }
 
+/*
+ * Cancel any pending scheduled resets
+ *
+ * [see usb_queue_reset_device()]
+ *
+ * Called after unconfiguring / when releasing interfaces. See
+ * comments in __usb_queue_reset_device() regarding
+ * udev->reset_running.
+ */
+static void usb_cancel_queued_reset(struct usb_interface *iface)
+{
+        if (iface->reset_running == 0)
+                cancel_work_sync(&iface->reset_ws);
+}
 
 /* called from driver core with dev locked */
 static int usb_probe_interface(struct device *dev)
@@ -242,6 +256,7 @@ static int usb_probe_interface(struct device *dev)
                         mark_quiesced(intf);
                         intf->needs_remote_wakeup = 0;
                         intf->condition = USB_INTERFACE_UNBOUND;
+                        usb_cancel_queued_reset(intf);
                 } else
                         intf->condition = USB_INTERFACE_BOUND;
 
@@ -272,6 +287,7 @@ static int usb_unbind_interface(struct device *dev)
                 usb_disable_interface(udev, intf);
 
         driver->disconnect(intf);
+        usb_cancel_queued_reset(intf);
 
         /* Reset other interface state.
          * We cannot do a Set-Interface if the device is suspended or
@@ -279,9 +295,12 @@ static int usb_unbind_interface(struct device *dev)
          * altsetting means creating new endpoint device entries).
          * When either of these happens, defer the Set-Interface.
          */
-        if (intf->cur_altsetting->desc.bAlternateSetting == 0)
-                ;       /* Already in altsetting 0 so skip Set-Interface */
-        else if (!error && intf->dev.power.status == DPM_ON)
+        if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
+                /* Already in altsetting 0 so skip Set-Interface.
+                 * Just re-enable it without affecting the endpoint toggles.
+                 */
+                usb_enable_interface(udev, intf, false);
+        } else if (!error && intf->dev.power.status == DPM_ON)
                 usb_set_interface(udev, intf->altsetting[0].
                                 desc.bInterfaceNumber, 0);
         else
@@ -380,8 +399,10 @@ void usb_driver_release_interface(struct usb_driver *driver,
         if (device_is_registered(dev)) {
                 iface->condition = USB_INTERFACE_UNBINDING;
                 device_release_driver(dev);
+        } else {
+                iface->condition = USB_INTERFACE_UNBOUND;
+                usb_cancel_queued_reset(iface);
         }
-
         dev->driver = NULL;
         usb_set_intfdata(iface, NULL);
 
@@ -904,7 +925,7 @@ static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
 }
 
 /* Caller has locked udev's pm_mutex */
-static int usb_resume_device(struct usb_device *udev)
+static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_device_driver        *udriver;
         int                             status = 0;
@@ -922,7 +943,7 @@ static int usb_resume_device(struct usb_device *udev)
                 udev->reset_resume = 1;
 
         udriver = to_usb_device_driver(udev->dev.driver);
-        status = udriver->resume(udev);
+        status = udriver->resume(udev, msg);
 
  done:
         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
@@ -942,7 +963,8 @@ static int usb_suspend_interface(struct usb_device *udev,
         if (udev->state == USB_STATE_NOTATTACHED || !is_active(intf))
                 goto done;
 
-        if (intf->condition == USB_INTERFACE_UNBOUND)   /* This can't happen */
+        /* This can happen; see usb_driver_release_interface() */
+        if (intf->condition == USB_INTERFACE_UNBOUND)
                 goto done;
         driver = to_usb_driver(intf->dev.driver);
 
@@ -950,7 +972,7 @@ static int usb_suspend_interface(struct usb_device *udev,
                 status = driver->suspend(intf, msg);
                 if (status == 0)
                         mark_quiesced(intf);
-                else if (!udev->auto_pm)
+                else if (!(msg.event & PM_EVENT_AUTO))
                         dev_err(&intf->dev, "%s error %d\n",
                                         "suspend", status);
         } else {
@@ -968,7 +990,7 @@ static int usb_suspend_interface(struct usb_device *udev,
 
 /* Caller has locked intf's usb_device's pm_mutex */
 static int usb_resume_interface(struct usb_device *udev,
-                struct usb_interface *intf, int reset_resume)
+                struct usb_interface *intf, pm_message_t msg, int reset_resume)
 {
         struct usb_driver       *driver;
         int                     status = 0;
@@ -1092,7 +1114,7 @@ static int autosuspend_check(struct usb_device *udev, int reschedule)
         if (reschedule) {
                 if (!timer_pending(&udev->autosuspend.timer)) {
                         queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
-                                round_jiffies_relative(suspend_time - j));
+                                round_jiffies_up_relative(suspend_time - j));
                 }
                 return -EAGAIN;
         }
@@ -1119,10 +1141,9 @@ static inline int autosuspend_check(struct usb_device *udev, int reschedule)
  * all the interfaces which were suspended are resumed so that they remain
  * in the same state as the device.
  *
- * If an autosuspend is in progress (@udev->auto_pm is set), the routine
- * checks first to make sure that neither the device itself or any of its
- * active interfaces is in use (pm_usage_cnt is greater than 0).  If they
- * are, the autosuspend fails.
+ * If an autosuspend is in progress the routine checks first to make sure
+ * that neither the device itself or any of its active interfaces is in use
+ * (pm_usage_cnt is greater than 0).  If they are, the autosuspend fails.
  *
  * If the suspend succeeds, the routine recursively queues an autosuspend
  * request for @udev's parent device, thereby propagating the change up
@@ -1157,7 +1178,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 
         udev->do_remote_wakeup = device_may_wakeup(&udev->dev);
 
-        if (udev->auto_pm) {
+        if (msg.event & PM_EVENT_AUTO) {
                 status = autosuspend_check(udev, 0);
                 if (status < 0)
                         goto done;
@@ -1177,13 +1198,16 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 
         /* If the suspend failed, resume interfaces that did get suspended */
         if (status != 0) {
+                pm_message_t msg2;
+
+                msg2.event = msg.event ^ (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
                 while (--i >= 0) {
                         intf = udev->actconfig->interface[i];
-                        usb_resume_interface(udev, intf, 0);
+                        usb_resume_interface(udev, intf, msg2, 0);
                 }
 
                 /* Try another autosuspend when the interfaces aren't busy */
-                if (udev->auto_pm)
+                if (msg.event & PM_EVENT_AUTO)
                         autosuspend_check(udev, status == -EBUSY);
 
         /* If the suspend succeeded then prevent any more URB submissions,
@@ -1213,6 +1237,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
 /**
  * usb_resume_both - resume a USB device and its interfaces
  * @udev: the usb_device to resume
+ * @msg: Power Management message describing this state transition
  *
  * This is the central routine for resuming USB devices.  It calls the
  * the resume method for @udev and then calls the resume methods for all
@@ -1238,7 +1263,7 @@ static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
  *
  * This routine can run only in process context.
  */
-static int usb_resume_both(struct usb_device *udev)
+static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
 {
         int                     status = 0;
         int                     i;
@@ -1254,14 +1279,15 @@ static int usb_resume_both(struct usb_device *udev)
 
         /* Propagate the resume up the tree, if necessary */
         if (udev->state == USB_STATE_SUSPENDED) {
-                if (udev->auto_pm && udev->autoresume_disabled) {
+                if ((msg.event & PM_EVENT_AUTO) &&
+                                udev->autoresume_disabled) {
                         status = -EPERM;
                         goto done;
                 }
                 if (parent) {
                         status = usb_autoresume_device(parent);
                         if (status == 0) {
-                                status = usb_resume_device(udev);
+                                status = usb_resume_device(udev, msg);
                                 if (status || udev->state ==
                                                 USB_STATE_NOTATTACHED) {
                                         usb_autosuspend_device(parent);
@@ -1284,15 +1310,16 @@ static int usb_resume_both(struct usb_device *udev)
                         /* We can't progagate beyond the USB subsystem,
                          * so if a root hub's controller is suspended
                          * then we're stuck. */
-                        status = usb_resume_device(udev);
+                        status = usb_resume_device(udev, msg);
                 }
         } else if (udev->reset_resume)
-                status = usb_resume_device(udev);
+                status = usb_resume_device(udev, msg);
 
         if (status == 0 && udev->actconfig) {
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         intf = udev->actconfig->interface[i];
-                        usb_resume_interface(udev, intf, udev->reset_resume);
+                        usb_resume_interface(udev, intf, msg,
+                                        udev->reset_resume);
                 }
         }
 
@@ -1320,13 +1347,13 @@ static int usb_autopm_do_device(struct usb_device *udev, int inc_usage_cnt)
                 udev->last_busy = jiffies;
         if (inc_usage_cnt >= 0 && udev->pm_usage_cnt > 0) {
                 if (udev->state == USB_STATE_SUSPENDED)
-                        status = usb_resume_both(udev);
+                        status = usb_resume_both(udev, PMSG_AUTO_RESUME);
                 if (status != 0)
                         udev->pm_usage_cnt -= inc_usage_cnt;
                 else if (inc_usage_cnt)
                         udev->last_busy = jiffies;
         } else if (inc_usage_cnt <= 0 && udev->pm_usage_cnt <= 0) {
-                status = usb_suspend_both(udev, PMSG_SUSPEND);
+                status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
         }
         usb_pm_unlock(udev);
         return status;
@@ -1341,6 +1368,19 @@ void usb_autosuspend_work(struct work_struct *work)
         usb_autopm_do_device(udev, 0);
 }
 
+/* usb_autoresume_work - callback routine to autoresume a USB device */
+void usb_autoresume_work(struct work_struct *work)
+{
+        struct usb_device *udev =
+                container_of(work, struct usb_device, autoresume);
+
+        /* Wake it up, let the drivers do their thing, and then put it
+         * back to sleep.
+         */
+        if (usb_autopm_do_device(udev, 1) == 0)
+                usb_autopm_do_device(udev, -1);
+}
+
 /**
  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
  * @udev: the usb_device to autosuspend
@@ -1437,13 +1477,14 @@ static int usb_autopm_do_interface(struct usb_interface *intf,
                 udev->last_busy = jiffies;
                 if (inc_usage_cnt >= 0 && intf->pm_usage_cnt > 0) {
                         if (udev->state == USB_STATE_SUSPENDED)
-                                status = usb_resume_both(udev);
+                                status = usb_resume_both(udev,
+                                                PMSG_AUTO_RESUME);
                         if (status != 0)
                                 intf->pm_usage_cnt -= inc_usage_cnt;
                         else
                                 udev->last_busy = jiffies;
                 } else if (inc_usage_cnt <= 0 && intf->pm_usage_cnt <= 0) {
-                        status = usb_suspend_both(udev, PMSG_SUSPEND);
+                        status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
                 }
         }
         usb_pm_unlock(udev);
@@ -1492,6 +1533,45 @@ void usb_autopm_put_interface(struct usb_interface *intf)
 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
 
 /**
+ * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
+ * @intf: the usb_interface whose counter should be decremented
+ *
+ * This routine does essentially the same thing as
+ * usb_autopm_put_interface(): it decrements @intf's usage counter and
+ * queues a delayed autosuspend request if the counter is <= 0.  The
+ * difference is that it does not acquire the device's pm_mutex;
+ * callers must handle all synchronization issues themselves.
+ *
+ * Typically a driver would call this routine during an URB's completion
+ * handler, if no more URBs were pending.
+ *
+ * This routine can run in atomic context.
+ */
+void usb_autopm_put_interface_async(struct usb_interface *intf)
+{
+        struct usb_device       *udev = interface_to_usbdev(intf);
+        int                     status = 0;
+
+        if (intf->condition == USB_INTERFACE_UNBOUND) {
+                status = -ENODEV;
+        } else {
+                udev->last_busy = jiffies;
+                --intf->pm_usage_cnt;
+                if (udev->autosuspend_disabled || udev->autosuspend_delay < 0)
+                        status = -EPERM;
+                else if (intf->pm_usage_cnt <= 0 &&
+                                !timer_pending(&udev->autosuspend.timer)) {
+                        queue_delayed_work(ksuspend_usb_wq, &udev->autosuspend,
+                                        round_jiffies_up_relative(
+                                                udev->autosuspend_delay));
+                }
+        }
+        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
+                        __func__, status, intf->pm_usage_cnt);
+}
+EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
+
+/**
  * usb_autopm_get_interface - increment a USB interface's PM-usage counter
  * @intf: the usb_interface whose counter should be incremented
  *
@@ -1537,6 +1617,37 @@ int usb_autopm_get_interface(struct usb_interface *intf)
 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
 
 /**
+ * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
+ * @intf: the usb_interface whose counter should be incremented
+ *
+ * This routine does much the same thing as
+ * usb_autopm_get_interface(): it increments @intf's usage counter and
+ * queues an autoresume request if the result is > 0.  The differences
+ * are that it does not acquire the device's pm_mutex (callers must
+ * handle all synchronization issues themselves), and it does not
+ * autoresume the device directly (it only queues a request).  After a
+ * successful call, the device will generally not yet be resumed.
+ *
+ * This routine can run in atomic context.
+ */
+int usb_autopm_get_interface_async(struct usb_interface *intf)
+{
+        struct usb_device       *udev = interface_to_usbdev(intf);
+        int                     status = 0;
+
+        if (intf->condition == USB_INTERFACE_UNBOUND)
+                status = -ENODEV;
+        else if (udev->autoresume_disabled)
+                status = -EPERM;
+        else if (++intf->pm_usage_cnt > 0 && udev->state == USB_STATE_SUSPENDED)
+                queue_work(ksuspend_usb_wq, &udev->autoresume);
+        dev_vdbg(&intf->dev, "%s: status %d cnt %d\n",
+                        __func__, status, intf->pm_usage_cnt);
+        return status;
+}
+EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
+
+/**
  * usb_autopm_set_interface - set a USB interface's autosuspend state
  * @intf: the usb_interface whose state should be set
  *
@@ -1563,6 +1674,9 @@ EXPORT_SYMBOL_GPL(usb_autopm_set_interface);
 void usb_autosuspend_work(struct work_struct *work)
 {}
 
+void usb_autoresume_work(struct work_struct *work)
+{}
+
 #endif /* CONFIG_USB_SUSPEND */
 
 /**
@@ -1595,6 +1709,7 @@ int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
 /**
  * usb_external_resume_device - external resume of a USB device and its interfaces
  * @udev: the usb_device to resume
+ * @msg: Power Management message describing this state transition
  *
  * This routine handles external resume requests: ones not generated
  * internally by a USB driver (autoresume) but rather coming from the user
@@ -1603,13 +1718,13 @@ int usb_external_suspend_device(struct usb_device *udev, pm_message_t msg)
  *
  * The caller must hold @udev's device lock.
  */
-int usb_external_resume_device(struct usb_device *udev)
+int usb_external_resume_device(struct usb_device *udev, pm_message_t msg)
 {
         int     status;
 
         usb_pm_lock(udev);
         udev->auto_pm = 0;
-        status = usb_resume_both(udev);
+        status = usb_resume_both(udev, msg);
         udev->last_busy = jiffies;
         usb_pm_unlock(udev);
         if (status == 0)
@@ -1622,7 +1737,7 @@ int usb_external_resume_device(struct usb_device *udev)
         return status;
 }
 
-int usb_suspend(struct device *dev, pm_message_t message)
+int usb_suspend(struct device *dev, pm_message_t msg)
 {
         struct usb_device       *udev;
 
@@ -1641,10 +1756,10 @@ int usb_suspend(struct device *dev, pm_message_t message)
         }
 
         udev->skip_sys_resume = 0;
-        return usb_external_suspend_device(udev, message);
+        return usb_external_suspend_device(udev, msg);
 }
 
-int usb_resume(struct device *dev)
+int usb_resume(struct device *dev, pm_message_t msg)
 {
         struct usb_device       *udev;
 
@@ -1656,7 +1771,7 @@ int usb_resume(struct device *dev)
          */
         if (udev->skip_sys_resume)
                 return 0;
-        return usb_external_resume_device(udev);
+        return usb_external_resume_device(udev, msg);
 }
 
 #endif /* CONFIG_PM */
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index 946fae43d622..e1710f260b4f 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -276,7 +276,7 @@ static void ep_device_release(struct device *dev)
         kfree(ep_dev);
 }
 
-int usb_create_ep_files(struct device *parent,
+int usb_create_ep_devs(struct device *parent,
                         struct usb_host_endpoint *endpoint,
                         struct usb_device *udev)
 {
@@ -340,7 +340,7 @@ exit:
         return retval;
 }
 
-void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
+void usb_remove_ep_devs(struct usb_host_endpoint *endpoint)
 {
         struct ep_device *ep_dev = endpoint->ep_dev;
 
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index 7e912f21fd36..30ecac3af15a 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -200,18 +200,18 @@ static int generic_suspend(struct usb_device *udev, pm_message_t msg)
          * interfaces manually by doing a bus (or "global") suspend.
          */
         if (!udev->parent)
-                rc = hcd_bus_suspend(udev);
+                rc = hcd_bus_suspend(udev, msg);
 
         /* Non-root devices don't need to do anything for FREEZE or PRETHAW */
         else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW)
                 rc = 0;
         else
-                rc = usb_port_suspend(udev);
+                rc = usb_port_suspend(udev, msg);
 
         return rc;
 }
 
-static int generic_resume(struct usb_device *udev)
+static int generic_resume(struct usb_device *udev, pm_message_t msg)
 {
         int rc;
 
@@ -221,9 +221,9 @@ static int generic_resume(struct usb_device *udev)
          * interfaces manually by doing a bus (or "global") resume.
          */
         if (!udev->parent)
-                rc = hcd_bus_resume(udev);
+                rc = hcd_bus_resume(udev, msg);
         else
-                rc = usb_port_resume(udev);
+                rc = usb_port_resume(udev, msg);
         return rc;
 }
 
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 5b87ae7f0a6a..507741ed4482 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -128,6 +128,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         }
 
         pci_set_master(dev);
+        device_set_wakeup_enable(&dev->dev, 1);
 
         retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
         if (retval != 0)
@@ -191,17 +192,15 @@ EXPORT_SYMBOL_GPL(usb_hcd_pci_remove);
 /**
  * usb_hcd_pci_suspend - power management suspend of a PCI-based HCD
  * @dev: USB Host Controller being suspended
- * @message: semantics in flux
+ * @message: Power Management message describing this state transition
  *
- * Store this function in the HCD's struct pci_driver as suspend().
+ * Store this function in the HCD's struct pci_driver as .suspend.
  */
 int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message)
 {
-        struct usb_hcd          *hcd;
+        struct usb_hcd          *hcd = pci_get_drvdata(dev);
         int                     retval = 0;
-        int                     has_pci_pm;
-
-        hcd = pci_get_drvdata(dev);
+        int                     wake, w;
 
         /* Root hub suspend should have stopped all downstream traffic,
          * and all bus master traffic.  And done so for both the interface
@@ -212,8 +211,15 @@ int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message)
          * otherwise the swsusp will save (and restore) garbage state.
          */
         if (!(hcd->state == HC_STATE_SUSPENDED ||
-                        hcd->state == HC_STATE_HALT))
-                return -EBUSY;
+                        hcd->state == HC_STATE_HALT)) {
+                dev_warn(&dev->dev, "Root hub is not suspended\n");
+                retval = -EBUSY;
+                goto done;
+        }
+
+        /* We might already be suspended (runtime PM -- not yet written) */
+        if (dev->current_state != PCI_D0)
+                goto done;
 
         if (hcd->driver->pci_suspend) {
                 retval = hcd->driver->pci_suspend(hcd, message);
@@ -221,49 +227,60 @@ int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message)
                 if (retval)
                         goto done;
         }
-        synchronize_irq(dev->irq);
 
-        /* FIXME until the generic PM interfaces change a lot more, this
-         * can't use PCI D1 and D2 states.  For example, the confusion
-         * between messages and states will need to vanish, and messages
-         * will need to provide a target system state again.
-         *
-         * It'll be important to learn characteristics of the target state,
-         * especially on embedded hardware where the HCD will often be in
-         * charge of an external VBUS power supply and one or more clocks.
-         * Some target system states will leave them active; others won't.
-         * (With PCI, that's often handled by platform BIOS code.)
-         */
+        synchronize_irq(dev->irq);
 
-        /* even when the PCI layer rejects some of the PCI calls
-         * below, HCs can try global suspend and reduce DMA traffic.
-         * PM-sensitive HCDs may already have done this.
+        /* Don't fail on error to enable wakeup.  We rely on pci code
+         * to reject requests the hardware can't implement, rather
+         * than coding the same thing.
          */
-        has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM);
+        wake = (hcd->state == HC_STATE_SUSPENDED &&
+                        device_may_wakeup(&dev->dev));
+        w = pci_wake_from_d3(dev, wake);
+        if (w < 0)
+                wake = w;
+        dev_dbg(&dev->dev, "wakeup: %d\n", wake);
 
         /* Downstream ports from this root hub should already be quiesced, so
          * there will be no DMA activity.  Now we can shut down the upstream
          * link (except maybe for PME# resume signaling) and enter some PCI
          * low power state, if the hardware allows.
          */
-        if (hcd->state == HC_STATE_SUSPENDED) {
+        pci_disable_device(dev);
+ done:
+        return retval;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_pci_suspend);
 
-                /* no DMA or IRQs except when HC is active */
-                if (dev->current_state == PCI_D0) {
-                        pci_save_state(dev);
-                        pci_disable_device(dev);
-                }
+/**
+ * usb_hcd_pci_suspend_late - suspend a PCI-based HCD after IRQs are disabled
+ * @dev: USB Host Controller being suspended
+ * @message: Power Management message describing this state transition
+ *
+ * Store this function in the HCD's struct pci_driver as .suspend_late.
+ */
+int usb_hcd_pci_suspend_late(struct pci_dev *dev, pm_message_t message)
+{
+        int                     retval = 0;
+        int                     has_pci_pm;
 
-                if (message.event == PM_EVENT_FREEZE ||
-                                message.event == PM_EVENT_PRETHAW) {
-                        dev_dbg(hcd->self.controller, "--> no state change\n");
-                        goto done;
-                }
+        /* We might already be suspended (runtime PM -- not yet written) */
+        if (dev->current_state != PCI_D0)
+                goto done;
 
-                if (!has_pci_pm) {
-                        dev_dbg(hcd->self.controller, "--> PCI D0/legacy\n");
-                        goto done;
-                }
+        pci_save_state(dev);
+
+        /* Don't change state if we don't need to */
+        if (message.event == PM_EVENT_FREEZE ||
+                        message.event == PM_EVENT_PRETHAW) {
+                dev_dbg(&dev->dev, "--> no state change\n");
+                goto done;
+        }
+
+        has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM);
+        if (!has_pci_pm) {
+                dev_dbg(&dev->dev, "--> PCI D0 legacy\n");
+        } else {
 
                 /* NOTE:  dev->current_state becomes nonzero only here, and
                  * only for devices that support PCI PM.  Also, exiting
@@ -273,35 +290,16 @@ int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t message)
                 retval = pci_set_power_state(dev, PCI_D3hot);
                 suspend_report_result(pci_set_power_state, retval);
                 if (retval == 0) {
-                        int wake = device_can_wakeup(&hcd->self.root_hub->dev);
-
-                        wake = wake && device_may_wakeup(hcd->self.controller);
-
-                        dev_dbg(hcd->self.controller, "--> PCI D3%s\n",
-                                        wake ? "/wakeup" : "");
-
-                        /* Ignore these return values.  We rely on pci code to
-                         * reject requests the hardware can't implement, rather
-                         * than coding the same thing.
-                         */
-                        (void) pci_enable_wake(dev, PCI_D3hot, wake);
-                        (void) pci_enable_wake(dev, PCI_D3cold, wake);
+                        dev_dbg(&dev->dev, "--> PCI D3\n");
                 } else {
                         dev_dbg(&dev->dev, "PCI D3 suspend fail, %d\n",
                                         retval);
-                        (void) usb_hcd_pci_resume(dev);
+                        pci_restore_state(dev);
                 }
-
-        } else if (hcd->state != HC_STATE_HALT) {
-                dev_dbg(hcd->self.controller, "hcd state %d; not suspended\n",
-                        hcd->state);
-                WARN_ON(1);
-                retval = -EINVAL;
         }
 
-done:
-        if (retval == 0) {
 #ifdef CONFIG_PPC_PMAC
+        if (retval == 0) {
                 /* Disable ASIC clocks for USB */
                 if (machine_is(powermac)) {
                         struct device_node      *of_node;
@@ -311,30 +309,24 @@ done:
                                 pmac_call_feature(PMAC_FTR_USB_ENABLE,
                                                         of_node, 0, 0);
                 }
-#endif
         }
+#endif
 
+ done:
         return retval;
 }
-EXPORT_SYMBOL_GPL(usb_hcd_pci_suspend);
+EXPORT_SYMBOL_GPL(usb_hcd_pci_suspend_late);
 
 /**
- * usb_hcd_pci_resume - power management resume of a PCI-based HCD
+ * usb_hcd_pci_resume_early - resume a PCI-based HCD before IRQs are enabled
  * @dev: USB Host Controller being resumed
  *
- * Store this function in the HCD's struct pci_driver as resume().
+ * Store this function in the HCD's struct pci_driver as .resume_early.
  */
-int usb_hcd_pci_resume(struct pci_dev *dev)
+int usb_hcd_pci_resume_early(struct pci_dev *dev)
 {
-        struct usb_hcd          *hcd;
-        int                     retval;
-
-        hcd = pci_get_drvdata(dev);
-        if (hcd->state != HC_STATE_SUSPENDED) {
-                dev_dbg(hcd->self.controller,
-                                "can't resume, not suspended!\n");
-                return 0;
-        }
+        int             retval = 0;
+        pci_power_t     state = dev->current_state;
 
 #ifdef CONFIG_PPC_PMAC
         /* Reenable ASIC clocks for USB */
@@ -352,7 +344,7 @@ int usb_hcd_pci_resume(struct pci_dev *dev)
          * calls "standby", "suspend to RAM", and so on).  There are also
          * dirty cases when swsusp fakes a suspend in "shutdown" mode.
          */
-        if (dev->current_state != PCI_D0) {
+        if (state != PCI_D0) {
 #ifdef  DEBUG
                 int     pci_pm;
                 u16     pmcr;
@@ -364,8 +356,7 @@ int usb_hcd_pci_resume(struct pci_dev *dev)
                         /* Clean case:  power to USB and to HC registers was
                          * maintained; remote wakeup is easy.
                          */
-                        dev_dbg(hcd->self.controller, "resume from PCI D%d\n",
-                                        pmcr);
+                        dev_dbg(&dev->dev, "resume from PCI D%d\n", pmcr);
                 } else {
                         /* Clean:  HC lost Vcc power, D0 uninitialized
                          *   + Vaux may have preserved port and transceiver
@@ -376,32 +367,55 @@ int usb_hcd_pci_resume(struct pci_dev *dev)
                          *   + after BIOS init
                          *   + after Linux init (HCD statically linked)
                          */
-                        dev_dbg(hcd->self.controller,
-                                "PCI D0, from previous PCI D%d\n",
-                                dev->current_state);
+                        dev_dbg(&dev->dev, "resume from previous PCI D%d\n",
+                                        state);
                 }
 #endif
-                /* yes, ignore these results too... */
-                (void) pci_enable_wake(dev, dev->current_state, 0);
-                (void) pci_enable_wake(dev, PCI_D3cold, 0);
+
+                retval = pci_set_power_state(dev, PCI_D0);
         } else {
                 /* Same basic cases: clean (powered/not), dirty */
-                dev_dbg(hcd->self.controller, "PCI legacy resume\n");
+                dev_dbg(&dev->dev, "PCI legacy resume\n");
+        }
+
+        if (retval < 0)
+                dev_err(&dev->dev, "can't resume: %d\n", retval);
+        else
+                pci_restore_state(dev);
+
+        return retval;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_pci_resume_early);
+
+/**
+ * usb_hcd_pci_resume - power management resume of a PCI-based HCD
+ * @dev: USB Host Controller being resumed
+ *
+ * Store this function in the HCD's struct pci_driver as .resume.
+ */
+int usb_hcd_pci_resume(struct pci_dev *dev)
+{
+        struct usb_hcd          *hcd;
+        int                     retval;
+
+        hcd = pci_get_drvdata(dev);
+        if (hcd->state != HC_STATE_SUSPENDED) {
+                dev_dbg(hcd->self.controller,
+                                "can't resume, not suspended!\n");
+                return 0;
         }
 
-        /* NOTE:  the PCI API itself is asymmetric here.  We don't need to
-         * pci_set_power_state(PCI_D0) since that's part of re-enabling;
-         * but that won't re-enable bus mastering.  Yet pci_disable_device()
-         * explicitly disables bus mastering...
-         */
         retval = pci_enable_device(dev);
         if (retval < 0) {
-                dev_err(hcd->self.controller,
-                        "can't re-enable after resume, %d!\n", retval);
+                dev_err(&dev->dev, "can't re-enable after resume, %d!\n",
+                                retval);
                 return retval;
         }
+
         pci_set_master(dev);
-        pci_restore_state(dev);
+
+        /* yes, ignore this result too... */
+        (void) pci_wake_from_d3(dev, 0);
 
         clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
 
@@ -413,7 +427,6 @@ int usb_hcd_pci_resume(struct pci_dev *dev)
                         usb_hc_died(hcd);
                 }
         }
-
         return retval;
 }
 EXPORT_SYMBOL_GPL(usb_hcd_pci_resume);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index e1b42626d04d..3c711db55d86 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1010,7 +1010,7 @@ int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
         spin_lock(&hcd_urb_list_lock);
 
         /* Check that the URB isn't being killed */
-        if (unlikely(urb->reject)) {
+        if (unlikely(atomic_read(&urb->reject))) {
                 rc = -EPERM;
                 goto done;
         }
@@ -1340,7 +1340,7 @@ int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
                 INIT_LIST_HEAD(&urb->urb_list);
                 atomic_dec(&urb->use_count);
                 atomic_dec(&urb->dev->urbnum);
-                if (urb->reject)
+                if (atomic_read(&urb->reject))
                         wake_up(&usb_kill_urb_queue);
                 usb_put_urb(urb);
         }
@@ -1444,7 +1444,7 @@ void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
         urb->status = status;
         urb->complete (urb);
         atomic_dec (&urb->use_count);
-        if (unlikely (urb->reject))
+        if (unlikely(atomic_read(&urb->reject)))
                 wake_up (&usb_kill_urb_queue);
         usb_put_urb (urb);
 }
@@ -1573,14 +1573,14 @@ int usb_hcd_get_frame_number (struct usb_device *udev)
 
 #ifdef  CONFIG_PM
 
-int hcd_bus_suspend(struct usb_device *rhdev)
+int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
 {
         struct usb_hcd  *hcd = container_of(rhdev->bus, struct usb_hcd, self);
         int             status;
         int             old_state = hcd->state;
 
         dev_dbg(&rhdev->dev, "bus %s%s\n",
-                        rhdev->auto_pm ? "auto-" : "", "suspend");
+                        (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
         if (!hcd->driver->bus_suspend) {
                 status = -ENOENT;
         } else {
@@ -1598,14 +1598,14 @@ int hcd_bus_suspend(struct usb_device *rhdev)
         return status;
 }
 
-int hcd_bus_resume(struct usb_device *rhdev)
+int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
 {
         struct usb_hcd  *hcd = container_of(rhdev->bus, struct usb_hcd, self);
         int             status;
         int             old_state = hcd->state;
 
         dev_dbg(&rhdev->dev, "usb %s%s\n",
-                        rhdev->auto_pm ? "auto-" : "", "resume");
+                        (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume");
         if (!hcd->driver->bus_resume)
                 return -ENOENT;
         if (hcd->state == HC_STATE_RUNNING)
@@ -1638,7 +1638,7 @@ static void hcd_resume_work(struct work_struct *work)
 
         usb_lock_device(udev);
         usb_mark_last_busy(udev);
-        usb_external_resume_device(udev);
+        usb_external_resume_device(udev, PMSG_REMOTE_RESUME);
         usb_unlock_device(udev);
 }
 
@@ -2028,7 +2028,7 @@ EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
 
 /*-------------------------------------------------------------------------*/
 
-#if defined(CONFIG_USB_MON)
+#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
 
 struct usb_mon_operations *mon_ops;
 
@@ -2064,4 +2064,4 @@ void usb_mon_deregister (void)
 }
 EXPORT_SYMBOL_GPL (usb_mon_deregister);
 
-#endif /* CONFIG_USB_MON */
+#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 9465e70f4dd0..572d2cf46e8d 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -16,6 +16,8 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#ifndef __USB_CORE_HCD_H
+#define __USB_CORE_HCD_H
 
 #ifdef __KERNEL__
 
@@ -254,7 +256,9 @@ extern int usb_hcd_pci_probe(struct pci_dev *dev,
 extern void usb_hcd_pci_remove(struct pci_dev *dev);
 
 #ifdef CONFIG_PM
-extern int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t state);
+extern int usb_hcd_pci_suspend(struct pci_dev *dev, pm_message_t msg);
+extern int usb_hcd_pci_suspend_late(struct pci_dev *dev, pm_message_t msg);
+extern int usb_hcd_pci_resume_early(struct pci_dev *dev);
 extern int usb_hcd_pci_resume(struct pci_dev *dev);
 #endif /* CONFIG_PM */
 
@@ -386,8 +390,8 @@ extern int usb_find_interface_driver(struct usb_device *dev,
 #ifdef CONFIG_PM
 extern void usb_hcd_resume_root_hub(struct usb_hcd *hcd);
 extern void usb_root_hub_lost_power(struct usb_device *rhdev);
-extern int hcd_bus_suspend(struct usb_device *rhdev);
-extern int hcd_bus_resume(struct usb_device *rhdev);
+extern int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg);
+extern int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg);
 #else
 static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
 {
@@ -419,7 +423,7 @@ static inline void usbfs_cleanup(void) { }
 
 /*-------------------------------------------------------------------------*/
 
-#if defined(CONFIG_USB_MON)
+#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
 
 struct usb_mon_operations {
         void (*urb_submit)(struct usb_bus *bus, struct urb *urb);
@@ -461,7 +465,7 @@ static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
 static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb,
                 int status) {}
 
-#endif /* CONFIG_USB_MON */
+#endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
 
 /*-------------------------------------------------------------------------*/
 
@@ -490,3 +494,5 @@ extern struct rw_semaphore ehci_cf_port_reset_rwsem;
 extern unsigned long usb_hcds_loaded;
 
 #endif /* __KERNEL__ */
+
+#endif /* __USB_CORE_HCD_H */
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index b19cbfcd51da..d5d0e40b1e2d 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -107,7 +107,9 @@ MODULE_PARM_DESC (blinkenlights, "true to cycle leds on hubs");
 /* define initial 64-byte descriptor request timeout in milliseconds */
 static int initial_descriptor_timeout = USB_CTRL_GET_TIMEOUT;
 module_param(initial_descriptor_timeout, int, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(initial_descriptor_timeout, "initial 64-byte descriptor request timeout in milliseconds (default 5000 - 5.0 seconds)");
+MODULE_PARM_DESC(initial_descriptor_timeout,
+                "initial 64-byte descriptor request timeout in milliseconds "
+                "(default 5000 - 5.0 seconds)");
 
 /*
  * As of 2.6.10 we introduce a new USB device initialization scheme which
@@ -1136,8 +1138,8 @@ static int hub_probe(struct usb_interface *intf, const struct usb_device_id *id)
         hdev = interface_to_usbdev(intf);
 
         if (hdev->level == MAX_TOPO_LEVEL) {
-                dev_err(&intf->dev, "Unsupported bus topology: "
-                                "hub nested too deep\n");
+                dev_err(&intf->dev,
+                        "Unsupported bus topology: hub nested too deep\n");
                 return -E2BIG;
         }
 
@@ -1374,8 +1376,9 @@ static void usb_stop_pm(struct usb_device *udev)
                 usb_autosuspend_device(udev->parent);
         usb_pm_unlock(udev);
 
-        /* Stop any autosuspend requests already submitted */
-        cancel_rearming_delayed_work(&udev->autosuspend);
+        /* Stop any autosuspend or autoresume requests already submitted */
+        cancel_delayed_work_sync(&udev->autosuspend);
+        cancel_work_sync(&udev->autoresume);
 }
 
 #else
@@ -1434,17 +1437,12 @@ void usb_disconnect(struct usb_device **pdev)
         usb_disable_device(udev, 0);
         usb_hcd_synchronize_unlinks(udev);
 
+        usb_remove_ep_devs(&udev->ep0);
         usb_unlock_device(udev);
 
-        /* Remove the device-specific files from sysfs.  This must be
-         * done with udev unlocked, because some of the attribute
-         * routines try to acquire the device lock.
-         */
-        usb_remove_sysfs_dev_files(udev);
-
         /* Unregister the device.  The device driver is responsible
-         * for removing the device files from usbfs and sysfs and for
-         * de-configuring the device.
+         * for de-configuring the device and invoking the remove-device
+         * notifier chain (used by usbfs and possibly others).
          */
         device_del(&udev->dev);
 
@@ -1476,8 +1474,8 @@ static void announce_device(struct usb_device *udev)
         dev_info(&udev->dev, "New USB device found, idVendor=%04x, idProduct=%04x\n",
                 le16_to_cpu(udev->descriptor.idVendor),
                 le16_to_cpu(udev->descriptor.idProduct));
-        dev_info(&udev->dev, "New USB device strings: Mfr=%d, Product=%d, "
-                "SerialNumber=%d\n",
+        dev_info(&udev->dev,
+                "New USB device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
                 udev->descriptor.iManufacturer,
                 udev->descriptor.iProduct,
                 udev->descriptor.iSerialNumber);
@@ -1542,7 +1540,7 @@ static int usb_configure_device_otg(struct usb_device *udev)
                                          * customize to match your product.
                                          */
                                         dev_info(&udev->dev,
-                                                "can't set HNP mode; %d\n",
+                                                "can't set HNP mode: %d\n",
                                                 err);
                                         bus->b_hnp_enable = 0;
                                 }
@@ -1635,6 +1633,10 @@ int usb_new_device(struct usb_device *udev)
 {
         int err;
 
+        /* Increment the parent's count of unsuspended children */
+        if (udev->parent)
+                usb_autoresume_device(udev->parent);
+
         usb_detect_quirks(udev);                /* Determine quirks */
         err = usb_configure_device(udev);       /* detect & probe dev/intfs */
         if (err < 0)
@@ -1643,13 +1645,12 @@ int usb_new_device(struct usb_device *udev)
         udev->dev.devt = MKDEV(USB_DEVICE_MAJOR,
                         (((udev->bus->busnum-1) * 128) + (udev->devnum-1)));
 
-        /* Increment the parent's count of unsuspended children */
-        if (udev->parent)
-                usb_autoresume_device(udev->parent);
+        /* Tell the world! */
+        announce_device(udev);
 
         /* Register the device.  The device driver is responsible
-         * for adding the device files to sysfs and for configuring
-         * the device.
+         * for configuring the device and invoking the add-device
+         * notifier chain (used by usbfs and possibly others).
          */
         err = device_add(&udev->dev);
         if (err) {
@@ -1657,15 +1658,12 @@ int usb_new_device(struct usb_device *udev)
                 goto fail;
         }
 
-        /* put device-specific files into sysfs */
-        usb_create_sysfs_dev_files(udev);
-
-        /* Tell the world! */
-        announce_device(udev);
+        (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
         return err;
 
 fail:
         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
+        usb_stop_pm(udev);
         return err;
 }
 
@@ -1982,7 +1980,7 @@ static int check_port_resume_type(struct usb_device *udev,
  *
  * Returns 0 on success, else negative errno.
  */
-int usb_port_suspend(struct usb_device *udev)
+int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_hub  *hub = hdev_to_hub(udev->parent);
         int             port1 = udev->portnum;
@@ -2021,7 +2019,7 @@ int usb_port_suspend(struct usb_device *udev)
         } else {
                 /* device has up to 10 msec to fully suspend */
                 dev_dbg(&udev->dev, "usb %ssuspend\n",
-                                udev->auto_pm ? "auto-" : "");
+                                (msg.event & PM_EVENT_AUTO ? "auto-" : ""));
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
                 msleep(10);
         }
@@ -2045,8 +2043,8 @@ static int finish_port_resume(struct usb_device *udev)
         u16     devstatus;
 
         /* caller owns the udev device lock */
-        dev_dbg(&udev->dev, "finish %sresume\n",
-                        udev->reset_resume ? "reset-" : "");
+        dev_dbg(&udev->dev, "%s\n",
+                udev->reset_resume ? "finish reset-resume" : "finish resume");
 
         /* usb ch9 identifies four variants of SUSPENDED, based on what
          * state the device resumes to.  Linux currently won't see the
@@ -2098,8 +2096,9 @@ static int finish_port_resume(struct usb_device *udev)
                                         NULL, 0,
                                         USB_CTRL_SET_TIMEOUT);
                         if (status)
-                                dev_dbg(&udev->dev, "disable remote "
-                                        "wakeup, status %d\n", status);
+                                dev_dbg(&udev->dev,
+                                        "disable remote wakeup, status %d\n",
+                                        status);
                 }
                 status = 0;
         }
@@ -2140,7 +2139,7 @@ static int finish_port_resume(struct usb_device *udev)
  *
  * Returns 0 on success, else negative errno.
  */
-int usb_port_resume(struct usb_device *udev)
+int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_hub  *hub = hdev_to_hub(udev->parent);
         int             port1 = udev->portnum;
@@ -2165,7 +2164,7 @@ int usb_port_resume(struct usb_device *udev)
         } else {
                 /* drive resume for at least 20 msec */
                 dev_dbg(&udev->dev, "usb %sresume\n",
-                                udev->auto_pm ? "auto-" : "");
+                                (msg.event & PM_EVENT_AUTO ? "auto-" : ""));
                 msleep(25);
 
                 /* Virtual root hubs can trigger on GET_PORT_STATUS to
@@ -2206,7 +2205,7 @@ static int remote_wakeup(struct usb_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);
+                status = usb_external_resume_device(udev, PMSG_REMOTE_RESUME);
         }
         return status;
 }
@@ -2215,14 +2214,14 @@ static int remote_wakeup(struct usb_device *udev)
 
 /* When CONFIG_USB_SUSPEND isn't set, we never suspend or resume any ports. */
 
-int usb_port_suspend(struct usb_device *udev)
+int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
 {
         return 0;
 }
 
 /* However we may need to do a reset-resume */
 
-int usb_port_resume(struct usb_device *udev)
+int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 {
         struct usb_hub  *hub = hdev_to_hub(udev->parent);
         int             port1 = udev->portnum;
@@ -2262,7 +2261,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
 
                 udev = hdev->children [port1-1];
                 if (udev && udev->can_submit) {
-                        if (!hdev->auto_pm)
+                        if (!(msg.event & PM_EVENT_AUTO))
                                 dev_dbg(&intf->dev, "port %d nyet suspended\n",
                                                 port1);
                         return -EBUSY;
@@ -2385,7 +2384,7 @@ void usb_ep0_reinit(struct usb_device *udev)
 {
         usb_disable_endpoint(udev, 0 + USB_DIR_IN);
         usb_disable_endpoint(udev, 0 + USB_DIR_OUT);
-        usb_enable_endpoint(udev, &udev->ep0);
+        usb_enable_endpoint(udev, &udev->ep0, true);
 }
 EXPORT_SYMBOL_GPL(usb_ep0_reinit);
 
@@ -2582,9 +2581,9 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                                 goto fail;
                         }
                         if (r) {
-                                dev_err(&udev->dev, "device descriptor "
-                                                "read/%s, error %d\n",
-                                                "64", r);
+                                dev_err(&udev->dev,
+                                        "device descriptor read/64, error %d\n",
+                                        r);
                                 retval = -EMSGSIZE;
                                 continue;
                         }
@@ -2621,9 +2620,9 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 
                 retval = usb_get_device_descriptor(udev, 8);
                 if (retval < 8) {
-                        dev_err(&udev->dev, "device descriptor "
-                                        "read/%s, error %d\n",
-                                        "8", retval);
+                        dev_err(&udev->dev,
+                                        "device descriptor read/8, error %d\n",
+                                        retval);
                         if (retval >= 0)
                                 retval = -EMSGSIZE;
                 } else {
@@ -2650,8 +2649,8 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
   
         retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
         if (retval < (signed)sizeof(udev->descriptor)) {
-                dev_err(&udev->dev, "device descriptor read/%s, error %d\n",
-                        "all", retval);
+                dev_err(&udev->dev, "device descriptor read/all, error %d\n",
+                        retval);
                 if (retval >= 0)
                         retval = -ENOMSG;
                 goto fail;
@@ -2719,9 +2718,9 @@ hub_power_remaining (struct usb_hub *hub)
                 else
                         delta = 8;
                 if (delta > hub->mA_per_port)
-                        dev_warn(&udev->dev, "%dmA is over %umA budget "
-                                        "for port %d!\n",
-                                        delta, hub->mA_per_port, port1);
+                        dev_warn(&udev->dev,
+                                 "%dmA is over %umA budget for port %d!\n",
+                                 delta, hub->mA_per_port, port1);
                 remaining -= delta;
         }
         if (remaining < 0) {
@@ -3517,3 +3516,46 @@ int usb_reset_device(struct usb_device *udev)
         return ret;
 }
 EXPORT_SYMBOL_GPL(usb_reset_device);
+
+
+/**
+ * usb_queue_reset_device - Reset a USB device from an atomic context
+ * @iface: USB interface belonging to the device to reset
+ *
+ * This function can be used to reset a USB device from an atomic
+ * context, where usb_reset_device() won't work (as it blocks).
+ *
+ * Doing a reset via this method is functionally equivalent to calling
+ * usb_reset_device(), except for the fact that it is delayed to a
+ * workqueue. This means that any drivers bound to other interfaces
+ * might be unbound, as well as users from usbfs in user space.
+ *
+ * Corner cases:
+ *
+ * - Scheduling two resets at the same time from two different drivers
+ *   attached to two different interfaces of the same device is
+ *   possible; depending on how the driver attached to each interface
+ *   handles ->pre_reset(), the second reset might happen or not.
+ *
+ * - If a driver is unbound and it had a pending reset, the reset will
+ *   be cancelled.
+ *
+ * - This function can be called during .probe() or .disconnect()
+ *   times. On return from .disconnect(), any pending resets will be
+ *   cancelled.
+ *
+ * There is no no need to lock/unlock the @reset_ws as schedule_work()
+ * does its own.
+ *
+ * NOTE: We don't do any reference count tracking because it is not
+ *     needed. The lifecycle of the work_struct is tied to the
+ *     usb_interface. Before destroying the interface we cancel the
+ *     work_struct, so the fact that work_struct is queued and or
+ *     running means the interface (and thus, the device) exist and
+ *     are referenced.
+ */
+void usb_queue_reset_device(struct usb_interface *iface)
+{
+        schedule_work(&iface->reset_ws);
+}
+EXPORT_SYMBOL_GPL(usb_queue_reset_device);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 6d1048faf08e..de51667dd64d 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -18,6 +18,8 @@
 #include "hcd.h"        /* for usbcore internals */
 #include "usb.h"
 
+static void cancel_async_set_config(struct usb_device *udev);
+
 struct api_context {
         struct completion       done;
         int                     status;
@@ -139,9 +141,9 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
 
         dr->bRequestType = requesttype;
         dr->bRequest = request;
-        dr->wValue = cpu_to_le16p(&value);
-        dr->wIndex = cpu_to_le16p(&index);
-        dr->wLength = cpu_to_le16p(&size);
+        dr->wValue = cpu_to_le16(value);
+        dr->wIndex = cpu_to_le16(index);
+        dr->wLength = cpu_to_le16(size);
 
         /* dbg("usb_control_msg"); */
 
@@ -1004,6 +1006,34 @@ int usb_clear_halt(struct usb_device *dev, int pipe)
 }
 EXPORT_SYMBOL_GPL(usb_clear_halt);
 
+static int create_intf_ep_devs(struct usb_interface *intf)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct usb_host_interface *alt = intf->cur_altsetting;
+        int i;
+
+        if (intf->ep_devs_created || intf->unregistering)
+                return 0;
+
+        for (i = 0; i < alt->desc.bNumEndpoints; ++i)
+                (void) usb_create_ep_devs(&intf->dev, &alt->endpoint[i], udev);
+        intf->ep_devs_created = 1;
+        return 0;
+}
+
+static void remove_intf_ep_devs(struct usb_interface *intf)
+{
+        struct usb_host_interface *alt = intf->cur_altsetting;
+        int i;
+
+        if (!intf->ep_devs_created)
+                return;
+
+        for (i = 0; i < alt->desc.bNumEndpoints; ++i)
+                usb_remove_ep_devs(&alt->endpoint[i]);
+        intf->ep_devs_created = 0;
+}
+
 /**
  * usb_disable_endpoint -- Disable an endpoint by address
  * @dev: the device whose endpoint is being disabled
@@ -1092,7 +1122,7 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                         dev_dbg(&dev->dev, "unregistering interface %s\n",
                                 dev_name(&interface->dev));
                         interface->unregistering = 1;
-                        usb_remove_sysfs_intf_files(interface);
+                        remove_intf_ep_devs(interface);
                         device_del(&interface->dev);
                 }
 
@@ -1113,22 +1143,26 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
  * usb_enable_endpoint - Enable an endpoint for USB communications
  * @dev: the device whose interface is being enabled
  * @ep: the endpoint
+ * @reset_toggle: flag to set the endpoint's toggle back to 0
  *
- * Resets the endpoint toggle, and sets dev->ep_{in,out} pointers.
+ * Resets the endpoint toggle if asked, and sets dev->ep_{in,out} pointers.
  * For control endpoints, both the input and output sides are handled.
  */
-void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
+void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep,
+                bool reset_toggle)
 {
         int epnum = usb_endpoint_num(&ep->desc);
         int is_out = usb_endpoint_dir_out(&ep->desc);
         int is_control = usb_endpoint_xfer_control(&ep->desc);
 
         if (is_out || is_control) {
-                usb_settoggle(dev, epnum, 1, 0);
+                if (reset_toggle)
+                        usb_settoggle(dev, epnum, 1, 0);
                 dev->ep_out[epnum] = ep;
         }
         if (!is_out || is_control) {
-                usb_settoggle(dev, epnum, 0, 0);
+                if (reset_toggle)
+                        usb_settoggle(dev, epnum, 0, 0);
                 dev->ep_in[epnum] = ep;
         }
         ep->enabled = 1;
@@ -1138,17 +1172,18 @@ void usb_enable_endpoint(struct usb_device *dev, struct usb_host_endpoint *ep)
  * usb_enable_interface - Enable all the endpoints for an interface
  * @dev: the device whose interface is being enabled
  * @intf: pointer to the interface descriptor
+ * @reset_toggles: flag to set the endpoints' toggles back to 0
  *
  * Enables all the endpoints for the interface's current altsetting.
  */
-static void usb_enable_interface(struct usb_device *dev,
-                                 struct usb_interface *intf)
+void usb_enable_interface(struct usb_device *dev,
+                struct usb_interface *intf, bool reset_toggles)
 {
         struct usb_host_interface *alt = intf->cur_altsetting;
         int i;
 
         for (i = 0; i < alt->desc.bNumEndpoints; ++i)
-                usb_enable_endpoint(dev, &alt->endpoint[i]);
+                usb_enable_endpoint(dev, &alt->endpoint[i], reset_toggles);
 }
 
 /**
@@ -1235,8 +1270,10 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          */
 
         /* prevent submissions using previous endpoint settings */
-        if (iface->cur_altsetting != alt)
+        if (iface->cur_altsetting != alt) {
+                remove_intf_ep_devs(iface);
                 usb_remove_sysfs_intf_files(iface);
+        }
         usb_disable_interface(dev, iface);
 
         iface->cur_altsetting = alt;
@@ -1271,10 +1308,11 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          * during the SETUP stage - hence EP0 toggles are "don't care" here.
          * (Likewise, EP0 never "halts" on well designed devices.)
          */
-        usb_enable_interface(dev, iface);
-        if (device_is_registered(&iface->dev))
+        usb_enable_interface(dev, iface, true);
+        if (device_is_registered(&iface->dev)) {
                 usb_create_sysfs_intf_files(iface);
-
+                create_intf_ep_devs(iface);
+        }
         return 0;
 }
 EXPORT_SYMBOL_GPL(usb_set_interface);
@@ -1334,7 +1372,6 @@ int usb_reset_configuration(struct usb_device *dev)
                 struct usb_interface *intf = config->interface[i];
                 struct usb_host_interface *alt;
 
-                usb_remove_sysfs_intf_files(intf);
                 alt = usb_altnum_to_altsetting(intf, 0);
 
                 /* No altsetting 0?  We'll assume the first altsetting.
@@ -1345,10 +1382,16 @@ int usb_reset_configuration(struct usb_device *dev)
                 if (!alt)
                         alt = &intf->altsetting[0];
 
+                if (alt != intf->cur_altsetting) {
+                        remove_intf_ep_devs(intf);
+                        usb_remove_sysfs_intf_files(intf);
+                }
                 intf->cur_altsetting = alt;
-                usb_enable_interface(dev, intf);
-                if (device_is_registered(&intf->dev))
+                usb_enable_interface(dev, intf, true);
+                if (device_is_registered(&intf->dev)) {
                         usb_create_sysfs_intf_files(intf);
+                        create_intf_ep_devs(intf);
+                }
         }
         return 0;
 }
@@ -1441,6 +1484,46 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
         return retval;
 }
 
+
+/*
+ * Internal function to queue a device reset
+ *
+ * This is initialized into the workstruct in 'struct
+ * usb_device->reset_ws' that is launched by
+ * message.c:usb_set_configuration() when initializing each 'struct
+ * usb_interface'.
+ *
+ * It is safe to get the USB device without reference counts because
+ * the life cycle of @iface is bound to the life cycle of @udev. Then,
+ * this function will be ran only if @iface is alive (and before
+ * freeing it any scheduled instances of it will have been cancelled).
+ *
+ * We need to set a flag (usb_dev->reset_running) because when we call
+ * the reset, the interfaces might be unbound. The current interface
+ * cannot try to remove the queued work as it would cause a deadlock
+ * (you cannot remove your work from within your executing
+ * workqueue). This flag lets it know, so that
+ * usb_cancel_queued_reset() doesn't try to do it.
+ *
+ * See usb_queue_reset_device() for more details
+ */
+void __usb_queue_reset_device(struct work_struct *ws)
+{
+        int rc;
+        struct usb_interface *iface =
+                container_of(ws, struct usb_interface, reset_ws);
+        struct usb_device *udev = interface_to_usbdev(iface);
+
+        rc = usb_lock_device_for_reset(udev, iface);
+        if (rc >= 0) {
+                iface->reset_running = 1;
+                usb_reset_device(udev);
+                iface->reset_running = 0;
+                usb_unlock_device(udev);
+        }
+}
+
+
 /*
  * usb_set_configuration - Makes a particular device setting be current
  * @dev: the device whose configuration is being updated
@@ -1560,6 +1643,9 @@ free_interfaces:
         if (dev->state != USB_STATE_ADDRESS)
                 usb_disable_device(dev, 1);     /* Skip ep0 */
 
+        /* Get rid of pending async Set-Config requests for this device */
+        cancel_async_set_config(dev);
+
         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                               USB_REQ_SET_CONFIGURATION, 0, configuration, 0,
                               NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -1604,13 +1690,14 @@ free_interfaces:
                         alt = &intf->altsetting[0];
 
                 intf->cur_altsetting = alt;
-                usb_enable_interface(dev, intf);
+                usb_enable_interface(dev, intf, true);
                 intf->dev.parent = &dev->dev;
                 intf->dev.driver = NULL;
                 intf->dev.bus = &usb_bus_type;
                 intf->dev.type = &usb_if_device_type;
                 intf->dev.groups = usb_interface_groups;
                 intf->dev.dma_mask = dev->dev.dma_mask;
+                INIT_WORK(&intf->reset_ws, __usb_queue_reset_device);
                 device_initialize(&intf->dev);
                 mark_quiesced(intf);
                 dev_set_name(&intf->dev, "%d-%s:%d.%d",
@@ -1641,17 +1728,21 @@ free_interfaces:
                                 dev_name(&intf->dev), ret);
                         continue;
                 }
-                usb_create_sysfs_intf_files(intf);
+                create_intf_ep_devs(intf);
         }
 
         usb_autosuspend_device(dev);
         return 0;
 }
 
+static LIST_HEAD(set_config_list);
+static DEFINE_SPINLOCK(set_config_lock);
+
 struct set_config_request {
         struct usb_device       *udev;
         int                     config;
         struct work_struct      work;
+        struct list_head        node;
 };
 
 /* Worker routine for usb_driver_set_configuration() */
@@ -1659,14 +1750,35 @@ static void driver_set_config_work(struct work_struct *work)
 {
         struct set_config_request *req =
                 container_of(work, struct set_config_request, work);
+        struct usb_device *udev = req->udev;
+
+        usb_lock_device(udev);
+        spin_lock(&set_config_lock);
+        list_del(&req->node);
+        spin_unlock(&set_config_lock);
 
-        usb_lock_device(req->udev);
-        usb_set_configuration(req->udev, req->config);
-        usb_unlock_device(req->udev);
-        usb_put_dev(req->udev);
+        if (req->config >= -1)          /* Is req still valid? */
+                usb_set_configuration(udev, req->config);
+        usb_unlock_device(udev);
+        usb_put_dev(udev);
         kfree(req);
 }
 
+/* Cancel pending Set-Config requests for a device whose configuration
+ * was just changed
+ */
+static void cancel_async_set_config(struct usb_device *udev)
+{
+        struct set_config_request *req;
+
+        spin_lock(&set_config_lock);
+        list_for_each_entry(req, &set_config_list, node) {
+                if (req->udev == udev)
+                        req->config = -999;     /* Mark as cancelled */
+        }
+        spin_unlock(&set_config_lock);
+}
+
 /**
  * usb_driver_set_configuration - Provide a way for drivers to change device configurations
  * @udev: the device whose configuration is being updated
@@ -1698,6 +1810,10 @@ int usb_driver_set_configuration(struct usb_device *udev, int config)
         req->config = config;
         INIT_WORK(&req->work, driver_set_config_work);
 
+        spin_lock(&set_config_lock);
+        list_add(&req->node, &set_config_list);
+        spin_unlock(&set_config_lock);
+
         usb_get_dev(udev);
         schedule_work(&req->work);
         return 0;
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 4fb65fdc9dc3..4cc2456ef3be 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -359,19 +359,19 @@ set_level(struct device *dev, struct device_attribute *attr,
                         strncmp(buf, on_string, len) == 0) {
                 udev->autosuspend_disabled = 1;
                 udev->autoresume_disabled = 0;
-                rc = usb_external_resume_device(udev);
+                rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
 
         } else if (len == sizeof auto_string - 1 &&
                         strncmp(buf, auto_string, len) == 0) {
                 udev->autosuspend_disabled = 0;
                 udev->autoresume_disabled = 0;
-                rc = usb_external_resume_device(udev);
+                rc = usb_external_resume_device(udev, PMSG_USER_RESUME);
 
         } else if (len == sizeof suspend_string - 1 &&
                         strncmp(buf, suspend_string, len) == 0) {
                 udev->autosuspend_disabled = 0;
                 udev->autoresume_disabled = 1;
-                rc = usb_external_suspend_device(udev, PMSG_SUSPEND);
+                rc = usb_external_suspend_device(udev, PMSG_USER_SUSPEND);
 
         } else
                 rc = -EINVAL;
@@ -629,9 +629,6 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         struct device *dev = &udev->dev;
         int retval;
 
-        /* Unforunately these attributes cannot be created before
-         * the uevent is broadcast.
-         */
         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
         if (retval)
                 goto error;
@@ -643,11 +640,7 @@ int usb_create_sysfs_dev_files(struct usb_device *udev)
         retval = add_power_attributes(dev);
         if (retval)
                 goto error;
-
-        retval = usb_create_ep_files(dev, &udev->ep0, udev);
-        if (retval)
-                goto error;
-        return 0;
+        return retval;
 error:
         usb_remove_sysfs_dev_files(udev);
         return retval;
@@ -657,7 +650,6 @@ void usb_remove_sysfs_dev_files(struct usb_device *udev)
 {
         struct device *dev = &udev->dev;
 
-        usb_remove_ep_files(&udev->ep0);
         remove_power_attributes(dev);
         remove_persist_attributes(dev);
         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
@@ -812,28 +804,6 @@ struct attribute_group *usb_interface_groups[] = {
         NULL
 };
 
-static inline void usb_create_intf_ep_files(struct usb_interface *intf,
-                struct usb_device *udev)
-{
-        struct usb_host_interface *iface_desc;
-        int i;
-
-        iface_desc = intf->cur_altsetting;
-        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
-                usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i],
-                                udev);
-}
-
-static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
-{
-        struct usb_host_interface *iface_desc;
-        int i;
-
-        iface_desc = intf->cur_altsetting;
-        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
-                usb_remove_ep_files(&iface_desc->endpoint[i]);
-}
-
 int usb_create_sysfs_intf_files(struct usb_interface *intf)
 {
         struct usb_device *udev = interface_to_usbdev(intf);
@@ -843,26 +813,19 @@ int usb_create_sysfs_intf_files(struct usb_interface *intf)
         if (intf->sysfs_files_created || intf->unregistering)
                 return 0;
 
-        /* The interface string may be present in some altsettings
-         * and missing in others.  Hence its attribute cannot be created
-         * before the uevent is broadcast.
-         */
         if (alt->string == NULL)
                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
         if (alt->string)
                 retval = device_create_file(&intf->dev, &dev_attr_interface);
-        usb_create_intf_ep_files(intf, udev);
         intf->sysfs_files_created = 1;
         return 0;
 }
 
 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
 {
-        struct device *dev = &intf->dev;
-
         if (!intf->sysfs_files_created)
                 return;
-        usb_remove_intf_ep_files(intf);
-        device_remove_file(dev, &dev_attr_interface);
+
+        device_remove_file(&intf->dev, &dev_attr_interface);
         intf->sysfs_files_created = 0;
 }
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index 1f68af9db3f7..58bc5e3c2560 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -10,7 +10,6 @@
 
 #define to_urb(d) container_of(d, struct urb, kref)
 
-static DEFINE_SPINLOCK(usb_reject_lock);
 
 static void urb_destroy(struct kref *kref)
 {
@@ -131,9 +130,7 @@ void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
         urb->anchor = anchor;
 
         if (unlikely(anchor->poisoned)) {
-                spin_lock(&usb_reject_lock);
-                urb->reject++;
-                spin_unlock(&usb_reject_lock);
+                atomic_inc(&urb->reject);
         }
 
         spin_unlock_irqrestore(&anchor->lock, flags);
@@ -565,16 +562,12 @@ void usb_kill_urb(struct urb *urb)
         might_sleep();
         if (!(urb && urb->dev && urb->ep))
                 return;
-        spin_lock_irq(&usb_reject_lock);
-        ++urb->reject;
-        spin_unlock_irq(&usb_reject_lock);
+        atomic_inc(&urb->reject);
 
         usb_hcd_unlink_urb(urb, -ENOENT);
         wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
 
-        spin_lock_irq(&usb_reject_lock);
-        --urb->reject;
-        spin_unlock_irq(&usb_reject_lock);
+        atomic_dec(&urb->reject);
 }
 EXPORT_SYMBOL_GPL(usb_kill_urb);
 
@@ -606,9 +599,7 @@ void usb_poison_urb(struct urb *urb)
         might_sleep();
         if (!(urb && urb->dev && urb->ep))
                 return;
-        spin_lock_irq(&usb_reject_lock);
-        ++urb->reject;
-        spin_unlock_irq(&usb_reject_lock);
+        atomic_inc(&urb->reject);
 
         usb_hcd_unlink_urb(urb, -ENOENT);
         wait_event(usb_kill_urb_queue, atomic_read(&urb->use_count) == 0);
@@ -617,14 +608,10 @@ EXPORT_SYMBOL_GPL(usb_poison_urb);
 
 void usb_unpoison_urb(struct urb *urb)
 {
-        unsigned long flags;
-
         if (!urb)
                 return;
 
-        spin_lock_irqsave(&usb_reject_lock, flags);
-        --urb->reject;
-        spin_unlock_irqrestore(&usb_reject_lock, flags);
+        atomic_dec(&urb->reject);
 }
 EXPORT_SYMBOL_GPL(usb_unpoison_urb);
 
@@ -692,6 +679,26 @@ void usb_poison_anchored_urbs(struct usb_anchor *anchor)
 EXPORT_SYMBOL_GPL(usb_poison_anchored_urbs);
 
 /**
+ * usb_unpoison_anchored_urbs - let an anchor be used successfully again
+ * @anchor: anchor the requests are bound to
+ *
+ * Reverses the effect of usb_poison_anchored_urbs
+ * the anchor can be used normally after it returns
+ */
+void usb_unpoison_anchored_urbs(struct usb_anchor *anchor)
+{
+        unsigned long flags;
+        struct urb *lazarus;
+
+        spin_lock_irqsave(&anchor->lock, flags);
+        list_for_each_entry(lazarus, &anchor->urb_list, anchor_list) {
+                usb_unpoison_urb(lazarus);
+        }
+        anchor->poisoned = 0;
+        spin_unlock_irqrestore(&anchor->lock, flags);
+}
+EXPORT_SYMBOL_GPL(usb_unpoison_anchored_urbs);
+/**
  * usb_unlink_anchored_urbs - asynchronously cancel transfer requests en masse
  * @anchor: anchor the requests are bound to
  *
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index be1fa0723f2c..dcfc072630c1 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -253,7 +253,7 @@ static int usb_dev_prepare(struct device *dev)
 static void usb_dev_complete(struct device *dev)
 {
         /* Currently used only for rebinding interfaces */
-        usb_resume(dev);        /* Implement eventually? */
+        usb_resume(dev, PMSG_RESUME);   /* Message event is meaningless */
 }
 
 static int usb_dev_suspend(struct device *dev)
@@ -263,7 +263,7 @@ static int usb_dev_suspend(struct device *dev)
 
 static int usb_dev_resume(struct device *dev)
 {
-        return usb_resume(dev);
+        return usb_resume(dev, PMSG_RESUME);
 }
 
 static int usb_dev_freeze(struct device *dev)
@@ -273,7 +273,7 @@ static int usb_dev_freeze(struct device *dev)
 
 static int usb_dev_thaw(struct device *dev)
 {
-        return usb_resume(dev);
+        return usb_resume(dev, PMSG_THAW);
 }
 
 static int usb_dev_poweroff(struct device *dev)
@@ -283,10 +283,10 @@ static int usb_dev_poweroff(struct device *dev)
 
 static int usb_dev_restore(struct device *dev)
 {
-        return usb_resume(dev);
+        return usb_resume(dev, PMSG_RESTORE);
 }
 
-static struct pm_ops usb_device_pm_ops = {
+static struct dev_pm_ops usb_device_pm_ops = {
         .prepare =      usb_dev_prepare,
         .complete =     usb_dev_complete,
         .suspend =      usb_dev_suspend,
@@ -301,7 +301,7 @@ static struct pm_ops usb_device_pm_ops = {
 
 #define ksuspend_usb_init()     0
 #define ksuspend_usb_cleanup()  do {} while (0)
-#define usb_device_pm_ops       (*(struct pm_ops *)0)
+#define usb_device_pm_ops       (*(struct dev_pm_ops *)0)
 
 #endif  /* CONFIG_PM */
 
@@ -362,7 +362,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
         dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
         dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
         /* ep0 maxpacket comes later, from device descriptor */
-        usb_enable_endpoint(dev, &dev->ep0);
+        usb_enable_endpoint(dev, &dev->ep0, true);
         dev->can_submit = 1;
 
         /* Save readable and stable topology id, distinguishing devices
@@ -402,6 +402,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
 #ifdef  CONFIG_PM
         mutex_init(&dev->pm_mutex);
         INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
+        INIT_WORK(&dev->autoresume, usb_autoresume_work);
         dev->autosuspend_delay = usb_autosuspend_delay * HZ;
         dev->connect_time = jiffies;
         dev->active_duration = -jiffies;
@@ -513,10 +514,7 @@ EXPORT_SYMBOL_GPL(usb_put_intf);
  * disconnect; in some drivers (such as usb-storage) the disconnect()
  * or suspend() method will block waiting for a device reset to complete.
  *
- * Returns a negative error code for failure, otherwise 1 or 0 to indicate
- * that the device will or will not have to be unlocked.  (0 can be
- * returned when an interface is given and is BINDING, because in that
- * case the driver already owns the device lock.)
+ * Returns a negative error code for failure, otherwise 0.
  */
 int usb_lock_device_for_reset(struct usb_device *udev,
                               const struct usb_interface *iface)
@@ -527,16 +525,9 @@ int usb_lock_device_for_reset(struct usb_device *udev,
                 return -ENODEV;
         if (udev->state == USB_STATE_SUSPENDED)
                 return -EHOSTUNREACH;
-        if (iface) {
-                switch (iface->condition) {
-                case USB_INTERFACE_BINDING:
-                        return 0;
-                case USB_INTERFACE_BOUND:
-                        break;
-                default:
-                        return -EINTR;
-                }
-        }
+        if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
+                        iface->condition == USB_INTERFACE_UNBOUND))
+                return -EINTR;
 
         while (usb_trylock_device(udev) != 0) {
 
@@ -550,10 +541,11 @@ int usb_lock_device_for_reset(struct usb_device *udev,
                         return -ENODEV;
                 if (udev->state == USB_STATE_SUSPENDED)
                         return -EHOSTUNREACH;
-                if (iface && iface->condition != USB_INTERFACE_BOUND)
+                if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
+                                iface->condition == USB_INTERFACE_UNBOUND))
                         return -EINTR;
         }
-        return 1;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
 
@@ -962,8 +954,12 @@ void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
 }
 EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
 
-/* format to disable USB on kernel command line is: nousb */
-__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);
+/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
+#ifdef MODULE
+module_param(nousb, bool, 0444);
+#else
+core_param(nousb, nousb, bool, 0444);
+#endif
 
 /*
  * for external read access to <nousb>
@@ -975,6 +971,37 @@ int usb_disabled(void)
 EXPORT_SYMBOL_GPL(usb_disabled);
 
 /*
+ * Notifications of device and interface registration
+ */
+static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
+                void *data)
+{
+        struct device *dev = data;
+
+        switch (action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                if (dev->type == &usb_device_type)
+                        (void) usb_create_sysfs_dev_files(to_usb_device(dev));
+                else if (dev->type == &usb_if_device_type)
+                        (void) usb_create_sysfs_intf_files(
+                                        to_usb_interface(dev));
+                break;
+
+        case BUS_NOTIFY_DEL_DEVICE:
+                if (dev->type == &usb_device_type)
+                        usb_remove_sysfs_dev_files(to_usb_device(dev));
+                else if (dev->type == &usb_if_device_type)
+                        usb_remove_sysfs_intf_files(to_usb_interface(dev));
+                break;
+        }
+        return 0;
+}
+
+static struct notifier_block usb_bus_nb = {
+        .notifier_call = usb_bus_notify,
+};
+
+/*
  * Init
  */
 static int __init usb_init(void)
@@ -991,6 +1018,9 @@ static int __init usb_init(void)
         retval = bus_register(&usb_bus_type);
         if (retval)
                 goto bus_register_failed;
+        retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
+        if (retval)
+                goto bus_notifier_failed;
         retval = usb_host_init();
         if (retval)
                 goto host_init_failed;
@@ -1025,6 +1055,8 @@ driver_register_failed:
 major_init_failed:
         usb_host_cleanup();
 host_init_failed:
+        bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
+bus_notifier_failed:
         bus_unregister(&usb_bus_type);
 bus_register_failed:
         ksuspend_usb_cleanup();
@@ -1048,6 +1080,7 @@ static void __exit usb_exit(void)
         usb_devio_cleanup();
         usb_hub_cleanup();
         usb_host_cleanup();
+        bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
         bus_unregister(&usb_bus_type);
         ksuspend_usb_cleanup();
 }
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 9a1a45ac3add..386177867a8a 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -1,16 +1,20 @@
+#include <linux/pm.h>
+
 /* Functions local to drivers/usb/core/ */
 
 extern int usb_create_sysfs_dev_files(struct usb_device *dev);
 extern void usb_remove_sysfs_dev_files(struct usb_device *dev);
 extern int usb_create_sysfs_intf_files(struct usb_interface *intf);
 extern void usb_remove_sysfs_intf_files(struct usb_interface *intf);
-extern int usb_create_ep_files(struct device *parent,
+extern int usb_create_ep_devs(struct device *parent,
                                 struct usb_host_endpoint *endpoint,
                                 struct usb_device *udev);
-extern void usb_remove_ep_files(struct usb_host_endpoint *endpoint);
+extern void usb_remove_ep_devs(struct usb_host_endpoint *endpoint);
 
 extern void usb_enable_endpoint(struct usb_device *dev,
-                struct usb_host_endpoint *ep);
+                struct usb_host_endpoint *ep, bool reset_toggle);
+extern void usb_enable_interface(struct usb_device *dev,
+                struct usb_interface *intf, bool reset_toggles);
 extern void usb_disable_endpoint(struct usb_device *dev, unsigned int epaddr);
 extern void usb_disable_interface(struct usb_device *dev,
                 struct usb_interface *intf);
@@ -42,14 +46,16 @@ extern void usb_host_cleanup(void);
 #ifdef  CONFIG_PM
 
 extern int usb_suspend(struct device *dev, pm_message_t msg);
-extern int usb_resume(struct device *dev);
+extern int usb_resume(struct device *dev, pm_message_t msg);
 
 extern void usb_autosuspend_work(struct work_struct *work);
-extern int usb_port_suspend(struct usb_device *dev);
-extern int usb_port_resume(struct usb_device *dev);
+extern void usb_autoresume_work(struct work_struct *work);
+extern int usb_port_suspend(struct usb_device *dev, pm_message_t msg);
+extern int usb_port_resume(struct usb_device *dev, pm_message_t msg);
 extern int usb_external_suspend_device(struct usb_device *udev,
                 pm_message_t msg);
-extern int usb_external_resume_device(struct usb_device *udev);
+extern int usb_external_resume_device(struct usb_device *udev,
+                pm_message_t msg);
 
 static inline void usb_pm_lock(struct usb_device *udev)
 {
@@ -63,12 +69,12 @@ static inline void usb_pm_unlock(struct usb_device *udev)
 
 #else
 
-static inline int usb_port_suspend(struct usb_device *udev)
+static inline int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
 {
         return 0;
 }
 
-static inline int usb_port_resume(struct usb_device *udev)
+static inline int usb_port_resume(struct usb_device *udev, pm_message_t msg)
 {
         return 0;
 }
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index dd4cd5a51370..3219d137340a 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -297,13 +297,34 @@ config USB_S3C2410_DEBUG
 
 # musb builds in ../musb along with host support
 config USB_GADGET_MUSB_HDRC
-        boolean "Inventra HDRC USB Peripheral (TI, ...)"
+        boolean "Inventra HDRC USB Peripheral (TI, ADI, ...)"
         depends on USB_MUSB_HDRC && (USB_MUSB_PERIPHERAL || USB_MUSB_OTG)
         select USB_GADGET_DUALSPEED
         select USB_GADGET_SELECTED
         help
           This OTG-capable silicon IP is used in dual designs including
-          the TI DaVinci, OMAP 243x, OMAP 343x, and TUSB 6010.
+          the TI DaVinci, OMAP 243x, OMAP 343x, TUSB 6010, and ADI Blackfin
+
+config USB_GADGET_IMX
+        boolean "Freescale IMX USB Peripheral Controller"
+        depends on ARCH_MX1
+        help
+           Freescale's IMX series include an integrated full speed
+           USB 1.1 device controller.  The controller in the IMX series
+           is register-compatible.
+
+           It has Six fixed-function endpoints, as well as endpoint
+           zero (for control transfers).
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "imx_udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_IMX
+        tristate
+        depends on USB_GADGET_IMX
+        default USB_GADGET
+        select USB_GADGET_SELECTED
 
 config USB_GADGET_M66592
         boolean "Renesas M66592 USB Peripheral Controller"
@@ -377,6 +398,24 @@ config USB_FSL_QE
         default USB_GADGET
         select USB_GADGET_SELECTED
 
+config USB_GADGET_CI13XXX
+        boolean "MIPS USB CI13xxx"
+        depends on PCI
+        select USB_GADGET_DUALSPEED
+        help
+          MIPS USB IP core family device controller
+          Currently it only supports IP part number CI13412
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "ci13xxx_udc" and force all
+          gadget drivers to also be dynamically linked.
+
+config USB_CI13XXX
+        tristate
+        depends on USB_GADGET_CI13XXX
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_NET2280
         boolean "NetChip 228x"
         depends on PCI
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index bd4041b47dce..39a51d746cb7 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -10,6 +10,7 @@ obj-$(CONFIG_USB_NET2280)	+= net2280.o
 obj-$(CONFIG_USB_AMD5536UDC)    += amd5536udc.o
 obj-$(CONFIG_USB_PXA25X)        += pxa25x_udc.o
 obj-$(CONFIG_USB_PXA27X)        += pxa27x_udc.o
+obj-$(CONFIG_USB_IMX)           += imx_udc.o
 obj-$(CONFIG_USB_GOKU)          += goku_udc.o
 obj-$(CONFIG_USB_OMAP)          += omap_udc.o
 obj-$(CONFIG_USB_LH7A40X)       += lh7a40x_udc.o
@@ -19,6 +20,7 @@ obj-$(CONFIG_USB_ATMEL_USBA)	+= atmel_usba_udc.o
 obj-$(CONFIG_USB_FSL_USB2)      += fsl_usb2_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
+obj-$(CONFIG_USB_CI13XXX)       += ci13xxx_udc.o
 
 #
 # USB gadget drivers
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index a8a1de413321..0b2bb8f0706d 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -1474,7 +1474,7 @@ static struct at91_udc controller = {
                 .ep0    = &controller.ep[0].ep,
                 .name   = driver_name,
                 .dev    = {
-                        .bus_id = "gadget",
+                        .init_name = "gadget",
                         .release = nop_release,
                 }
         },
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index ae30ab1d264f..65b03e3445a1 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1034,7 +1034,7 @@ static struct usba_udc the_udc = {
                 .is_dualspeed   = 1,
                 .name           = "atmel_usba_udc",
                 .dev    = {
-                        .bus_id         = "gadget",
+                        .init_name      = "gadget",
                         .release        = nop_release,
                 },
         },
diff --git a/drivers/usb/gadget/ci13xxx_udc.c b/drivers/usb/gadget/ci13xxx_udc.c
new file mode 100644
index 000000000000..bebf911c7e5f
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_udc.c
@@ -0,0 +1,2830 @@
+/*
+ * ci13xxx_udc.c - MIPS USB IP core family device controller
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * 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.
+ */
+
+/*
+ * Description: MIPS USB IP core family device controller
+ *              Currently it only supports IP part number CI13412
+ *
+ * This driver is composed of several blocks:
+ * - HW:     hardware interface
+ * - DBG:    debug facilities (optional)
+ * - UTIL:   utilities
+ * - ISR:    interrupts handling
+ * - ENDPT:  endpoint operations (Gadget API)
+ * - GADGET: gadget operations (Gadget API)
+ * - BUS:    bus glue code, bus abstraction layer
+ * - PCI:    PCI core interface and PCI resources (interrupts, memory...)
+ *
+ * Compile Options
+ * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
+ * - STALL_IN:  non-empty bulk-in pipes cannot be halted
+ *              if defined mass storage compliance succeeds but with warnings
+ *              => case 4: Hi >  Dn
+ *              => case 5: Hi >  Di
+ *              => case 8: Hi <> Do
+ *              if undefined usbtest 13 fails
+ * - TRACE:     enable function tracing (depends on DEBUG)
+ *
+ * Main Features
+ * - Chapter 9 & Mass Storage Compliance with Gadget File Storage
+ * - Chapter 9 Compliance with Gadget Zero (STALL_IN undefined)
+ * - Normal & LPM support
+ *
+ * USBTEST Report
+ * - OK: 0-12, 13 (STALL_IN defined) & 14
+ * - Not Supported: 15 & 16 (ISO)
+ *
+ * TODO List
+ * - OTG
+ * - Isochronous & Interrupt Traffic
+ * - Handle requests which spawns into several TDs
+ * - GET_STATUS(device) - always reports 0
+ * - Gadget API (majority of optional features)
+ * - Suspend & Remote Wakeup
+ */
+#include <linux/device.h>
+#include <linux/dmapool.h>
+#include <linux/dma-mapping.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include "ci13xxx_udc.h"
+
+
+/******************************************************************************
+ * DEFINE
+ *****************************************************************************/
+/* ctrl register bank access */
+static DEFINE_SPINLOCK(udc_lock);
+
+/* driver name */
+#define UDC_DRIVER_NAME   "ci13xxx_udc"
+
+/* control endpoint description */
+static const struct usb_endpoint_descriptor
+ctrl_endpt_desc = {
+        .bLength         = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType = USB_DT_ENDPOINT,
+
+        .bmAttributes    = USB_ENDPOINT_XFER_CONTROL,
+        .wMaxPacketSize  = cpu_to_le16(CTRL_PAYLOAD_MAX),
+};
+
+/* UDC descriptor */
+static struct ci13xxx *_udc;
+
+/* Interrupt statistics */
+#define ISR_MASK   0x1F
+static struct {
+        u32 test;
+        u32 ui;
+        u32 uei;
+        u32 pci;
+        u32 uri;
+        u32 sli;
+        u32 none;
+        struct {
+                u32 cnt;
+                u32 buf[ISR_MASK+1];
+                u32 idx;
+        } hndl;
+} isr_statistics;
+
+/**
+ * ffs_nr: find first (least significant) bit set
+ * @x: the word to search
+ *
+ * This function returns bit number (instead of position)
+ */
+static int ffs_nr(u32 x)
+{
+        int n = ffs(x);
+
+        return n ? n-1 : 32;
+}
+
+/******************************************************************************
+ * HW block
+ *****************************************************************************/
+/* register bank descriptor */
+static struct {
+        unsigned      lpm;    /* is LPM? */
+        void __iomem *abs;    /* bus map offset */
+        void __iomem *cap;    /* bus map offset + CAP offset + CAP data */
+        size_t        size;   /* bank size */
+} hw_bank;
+
+/* UDC register map */
+#define ABS_CAPLENGTH       (0x100UL)
+#define ABS_HCCPARAMS       (0x108UL)
+#define ABS_DCCPARAMS       (0x124UL)
+#define ABS_TESTMODE        (hw_bank.lpm ? 0x0FCUL : 0x138UL)
+/* offset to CAPLENTGH (addr + data) */
+#define CAP_USBCMD          (0x000UL)
+#define CAP_USBSTS          (0x004UL)
+#define CAP_USBINTR         (0x008UL)
+#define CAP_DEVICEADDR      (0x014UL)
+#define CAP_ENDPTLISTADDR   (0x018UL)
+#define CAP_PORTSC          (0x044UL)
+#define CAP_DEVLC           (0x0B4UL)
+#define CAP_USBMODE         (hw_bank.lpm ? 0x0C8UL : 0x068UL)
+#define CAP_ENDPTSETUPSTAT  (hw_bank.lpm ? 0x0D8UL : 0x06CUL)
+#define CAP_ENDPTPRIME      (hw_bank.lpm ? 0x0DCUL : 0x070UL)
+#define CAP_ENDPTFLUSH      (hw_bank.lpm ? 0x0E0UL : 0x074UL)
+#define CAP_ENDPTSTAT       (hw_bank.lpm ? 0x0E4UL : 0x078UL)
+#define CAP_ENDPTCOMPLETE   (hw_bank.lpm ? 0x0E8UL : 0x07CUL)
+#define CAP_ENDPTCTRL       (hw_bank.lpm ? 0x0ECUL : 0x080UL)
+#define CAP_LAST            (hw_bank.lpm ? 0x12CUL : 0x0C0UL)
+
+/* maximum number of enpoints: valid only after hw_device_reset() */
+static unsigned hw_ep_max;
+
+/**
+ * hw_ep_bit: calculates the bit number
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns bit number
+ */
+static inline int hw_ep_bit(int num, int dir)
+{
+        return num + (dir ? 16 : 0);
+}
+
+/**
+ * hw_aread: reads from register bitfield
+ * @addr: address relative to bus map
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_aread(u32 addr, u32 mask)
+{
+        return ioread32(addr + hw_bank.abs) & mask;
+}
+
+/**
+ * hw_awrite: writes to register bitfield
+ * @addr: address relative to bus map
+ * @mask: bitfield mask
+ * @data: new data
+ */
+static void hw_awrite(u32 addr, u32 mask, u32 data)
+{
+        iowrite32(hw_aread(addr, ~mask) | (data & mask),
+                  addr + hw_bank.abs);
+}
+
+/**
+ * hw_cread: reads from register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_cread(u32 addr, u32 mask)
+{
+        return ioread32(addr + hw_bank.cap) & mask;
+}
+
+/**
+ * hw_cwrite: writes to register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ * @data: new data
+ */
+static void hw_cwrite(u32 addr, u32 mask, u32 data)
+{
+        iowrite32(hw_cread(addr, ~mask) | (data & mask),
+                  addr + hw_bank.cap);
+}
+
+/**
+ * hw_ctest_and_clear: tests & clears register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_ctest_and_clear(u32 addr, u32 mask)
+{
+        u32 reg = hw_cread(addr, mask);
+
+        iowrite32(reg, addr + hw_bank.cap);
+        return reg;
+}
+
+/**
+ * hw_ctest_and_write: tests & writes register bitfield
+ * @addr: address relative to CAP offset plus content
+ * @mask: bitfield mask
+ * @data: new data
+ *
+ * This function returns register bitfield data
+ */
+static u32 hw_ctest_and_write(u32 addr, u32 mask, u32 data)
+{
+        u32 reg = hw_cread(addr, ~0);
+
+        iowrite32((reg & ~mask) | (data & mask), addr + hw_bank.cap);
+        return (reg & mask) >> ffs_nr(mask);
+}
+
+/**
+ * hw_device_reset: resets chip (execute without interruption)
+ * @base: register base address
+ *
+ * This function returns an error code
+ */
+static int hw_device_reset(void __iomem *base)
+{
+        u32 reg;
+
+        /* bank is a module variable */
+        hw_bank.abs = base;
+
+        hw_bank.cap = hw_bank.abs;
+        hw_bank.cap += ABS_CAPLENGTH;
+        hw_bank.cap += ioread8(hw_bank.cap);
+
+        reg = hw_aread(ABS_HCCPARAMS, HCCPARAMS_LEN) >> ffs_nr(HCCPARAMS_LEN);
+        hw_bank.lpm  = reg;
+        hw_bank.size = hw_bank.cap - hw_bank.abs;
+        hw_bank.size += CAP_LAST;
+        hw_bank.size /= sizeof(u32);
+
+        /* should flush & stop before reset */
+        hw_cwrite(CAP_ENDPTFLUSH, ~0, ~0);
+        hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
+
+        hw_cwrite(CAP_USBCMD, USBCMD_RST, USBCMD_RST);
+        while (hw_cread(CAP_USBCMD, USBCMD_RST))
+                udelay(10);             /* not RTOS friendly */
+
+        /* USBMODE should be configured step by step */
+        hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_IDLE);
+        hw_cwrite(CAP_USBMODE, USBMODE_CM, USBMODE_CM_DEVICE);
+        hw_cwrite(CAP_USBMODE, USBMODE_SLOM, USBMODE_SLOM);  /* HW >= 2.3 */
+
+        if (hw_cread(CAP_USBMODE, USBMODE_CM) != USBMODE_CM_DEVICE) {
+                pr_err("cannot enter in device mode");
+                pr_err("lpm = %i", hw_bank.lpm);
+                return -ENODEV;
+        }
+
+        reg = hw_aread(ABS_DCCPARAMS, DCCPARAMS_DEN) >> ffs_nr(DCCPARAMS_DEN);
+        if (reg == 0 || reg > ENDPT_MAX)
+                return -ENODEV;
+
+        hw_ep_max = reg;   /* cache hw ENDPT_MAX */
+
+        /* setup lock mode ? */
+
+        /* ENDPTSETUPSTAT is '0' by default */
+
+        /* HCSPARAMS.bf.ppc SHOULD BE zero for device */
+
+        return 0;
+}
+
+/**
+ * hw_device_state: enables/disables interrupts & starts/stops device (execute
+ *                  without interruption)
+ * @dma: 0 => disable, !0 => enable and set dma engine
+ *
+ * This function returns an error code
+ */
+static int hw_device_state(u32 dma)
+{
+        if (dma) {
+                hw_cwrite(CAP_ENDPTLISTADDR, ~0, dma);
+                /* interrupt, error, port change, reset, sleep/suspend */
+                hw_cwrite(CAP_USBINTR, ~0,
+                             USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
+                hw_cwrite(CAP_USBCMD, USBCMD_RS, USBCMD_RS);
+        } else {
+                hw_cwrite(CAP_USBCMD, USBCMD_RS, 0);
+                hw_cwrite(CAP_USBINTR, ~0, 0);
+        }
+        return 0;
+}
+
+/**
+ * hw_ep_flush: flush endpoint fifo (execute without interruption)
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns an error code
+ */
+static int hw_ep_flush(int num, int dir)
+{
+        int n = hw_ep_bit(num, dir);
+
+        do {
+                /* flush any pending transfer */
+                hw_cwrite(CAP_ENDPTFLUSH, BIT(n), BIT(n));
+                while (hw_cread(CAP_ENDPTFLUSH, BIT(n)))
+                        cpu_relax();
+        } while (hw_cread(CAP_ENDPTSTAT, BIT(n)));
+
+        return 0;
+}
+
+/**
+ * hw_ep_disable: disables endpoint (execute without interruption)
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns an error code
+ */
+static int hw_ep_disable(int num, int dir)
+{
+        hw_ep_flush(num, dir);
+        hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32),
+                  dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
+        return 0;
+}
+
+/**
+ * hw_ep_enable: enables endpoint (execute without interruption)
+ * @num:  endpoint number
+ * @dir:  endpoint direction
+ * @type: endpoint type
+ *
+ * This function returns an error code
+ */
+static int hw_ep_enable(int num, int dir, int type)
+{
+        u32 mask, data;
+
+        if (dir) {
+                mask  = ENDPTCTRL_TXT;  /* type    */
+                data  = type << ffs_nr(mask);
+
+                mask |= ENDPTCTRL_TXS;  /* unstall */
+                mask |= ENDPTCTRL_TXR;  /* reset data toggle */
+                data |= ENDPTCTRL_TXR;
+                mask |= ENDPTCTRL_TXE;  /* enable  */
+                data |= ENDPTCTRL_TXE;
+        } else {
+                mask  = ENDPTCTRL_RXT;  /* type    */
+                data  = type << ffs_nr(mask);
+
+                mask |= ENDPTCTRL_RXS;  /* unstall */
+                mask |= ENDPTCTRL_RXR;  /* reset data toggle */
+                data |= ENDPTCTRL_RXR;
+                mask |= ENDPTCTRL_RXE;  /* enable  */
+                data |= ENDPTCTRL_RXE;
+        }
+        hw_cwrite(CAP_ENDPTCTRL + num * sizeof(u32), mask, data);
+        return 0;
+}
+
+/**
+ * hw_ep_get_halt: return endpoint halt status
+ * @num: endpoint number
+ * @dir: endpoint direction
+ *
+ * This function returns 1 if endpoint halted
+ */
+static int hw_ep_get_halt(int num, int dir)
+{
+        u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
+
+        return hw_cread(CAP_ENDPTCTRL + num * sizeof(u32), mask) ? 1 : 0;
+}
+
+/**
+ * hw_ep_is_primed: test if endpoint is primed (execute without interruption)
+ * @num:   endpoint number
+ * @dir:   endpoint direction
+ *
+ * This function returns true if endpoint primed
+ */
+static int hw_ep_is_primed(int num, int dir)
+{
+        u32 reg = hw_cread(CAP_ENDPTPRIME, ~0) | hw_cread(CAP_ENDPTSTAT, ~0);
+
+        return test_bit(hw_ep_bit(num, dir), (void *)&reg);
+}
+
+/**
+ * hw_test_and_clear_setup_status: test & clear setup status (execute without
+ *                                 interruption)
+ * @n: bit number (endpoint)
+ *
+ * This function returns setup status
+ */
+static int hw_test_and_clear_setup_status(int n)
+{
+        return hw_ctest_and_clear(CAP_ENDPTSETUPSTAT, BIT(n));
+}
+
+/**
+ * hw_ep_prime: primes endpoint (execute without interruption)
+ * @num:     endpoint number
+ * @dir:     endpoint direction
+ * @is_ctrl: true if control endpoint
+ *
+ * This function returns an error code
+ */
+static int hw_ep_prime(int num, int dir, int is_ctrl)
+{
+        int n = hw_ep_bit(num, dir);
+
+        /* the caller should flush first */
+        if (hw_ep_is_primed(num, dir))
+                return -EBUSY;
+
+        if (is_ctrl && dir == RX && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
+                return -EAGAIN;
+
+        hw_cwrite(CAP_ENDPTPRIME, BIT(n), BIT(n));
+
+        while (hw_cread(CAP_ENDPTPRIME, BIT(n)))
+                cpu_relax();
+        if (is_ctrl && dir == RX  && hw_cread(CAP_ENDPTSETUPSTAT, BIT(num)))
+                return -EAGAIN;
+
+        /* status shoult be tested according with manual but it doesn't work */
+        return 0;
+}
+
+/**
+ * hw_ep_set_halt: configures ep halt & resets data toggle after clear (execute
+ *                 without interruption)
+ * @num:   endpoint number
+ * @dir:   endpoint direction
+ * @value: true => stall, false => unstall
+ *
+ * This function returns an error code
+ */
+static int hw_ep_set_halt(int num, int dir, int value)
+{
+        if (value != 0 && value != 1)
+                return -EINVAL;
+
+        do {
+                u32 addr = CAP_ENDPTCTRL + num * sizeof(u32);
+                u32 mask_xs = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
+                u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
+
+                /* data toggle - reserved for EP0 but it's in ESS */
+                hw_cwrite(addr, mask_xs|mask_xr, value ? mask_xs : mask_xr);
+
+        } while (value != hw_ep_get_halt(num, dir));
+
+        return 0;
+}
+
+/**
+ * hw_intr_clear: disables interrupt & clears interrupt status (execute without
+ *                interruption)
+ * @n: interrupt bit
+ *
+ * This function returns an error code
+ */
+static int hw_intr_clear(int n)
+{
+        if (n >= REG_BITS)
+                return -EINVAL;
+
+        hw_cwrite(CAP_USBINTR, BIT(n), 0);
+        hw_cwrite(CAP_USBSTS,  BIT(n), BIT(n));
+        return 0;
+}
+
+/**
+ * hw_intr_force: enables interrupt & forces interrupt status (execute without
+ *                interruption)
+ * @n: interrupt bit
+ *
+ * This function returns an error code
+ */
+static int hw_intr_force(int n)
+{
+        if (n >= REG_BITS)
+                return -EINVAL;
+
+        hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, TESTMODE_FORCE);
+        hw_cwrite(CAP_USBINTR,  BIT(n), BIT(n));
+        hw_cwrite(CAP_USBSTS,   BIT(n), BIT(n));
+        hw_awrite(ABS_TESTMODE, TESTMODE_FORCE, 0);
+        return 0;
+}
+
+/**
+ * hw_is_port_high_speed: test if port is high speed
+ *
+ * This function returns true if high speed port
+ */
+static int hw_port_is_high_speed(void)
+{
+        return hw_bank.lpm ? hw_cread(CAP_DEVLC, DEVLC_PSPD) :
+                hw_cread(CAP_PORTSC, PORTSC_HSP);
+}
+
+/**
+ * hw_port_test_get: reads port test mode value
+ *
+ * This function returns port test mode value
+ */
+static u8 hw_port_test_get(void)
+{
+        return hw_cread(CAP_PORTSC, PORTSC_PTC) >> ffs_nr(PORTSC_PTC);
+}
+
+/**
+ * hw_port_test_set: writes port test mode (execute without interruption)
+ * @mode: new value
+ *
+ * This function returns an error code
+ */
+static int hw_port_test_set(u8 mode)
+{
+        const u8 TEST_MODE_MAX = 7;
+
+        if (mode > TEST_MODE_MAX)
+                return -EINVAL;
+
+        hw_cwrite(CAP_PORTSC, PORTSC_PTC, mode << ffs_nr(PORTSC_PTC));
+        return 0;
+}
+
+/**
+ * hw_read_intr_enable: returns interrupt enable register
+ *
+ * This function returns register data
+ */
+static u32 hw_read_intr_enable(void)
+{
+        return hw_cread(CAP_USBINTR, ~0);
+}
+
+/**
+ * hw_read_intr_status: returns interrupt status register
+ *
+ * This function returns register data
+ */
+static u32 hw_read_intr_status(void)
+{
+        return hw_cread(CAP_USBSTS, ~0);
+}
+
+/**
+ * hw_register_read: reads all device registers (execute without interruption)
+ * @buf:  destination buffer
+ * @size: buffer size
+ *
+ * This function returns number of registers read
+ */
+static size_t hw_register_read(u32 *buf, size_t size)
+{
+        unsigned i;
+
+        if (size > hw_bank.size)
+                size = hw_bank.size;
+
+        for (i = 0; i < size; i++)
+                buf[i] = hw_aread(i * sizeof(u32), ~0);
+
+        return size;
+}
+
+/**
+ * hw_register_write: writes to register
+ * @addr: register address
+ * @data: register value
+ *
+ * This function returns an error code
+ */
+static int hw_register_write(u16 addr, u32 data)
+{
+        /* align */
+        addr /= sizeof(u32);
+
+        if (addr >= hw_bank.size)
+                return -EINVAL;
+
+        /* align */
+        addr *= sizeof(u32);
+
+        hw_awrite(addr, ~0, data);
+        return 0;
+}
+
+/**
+ * hw_test_and_clear_complete: test & clear complete status (execute without
+ *                             interruption)
+ * @n: bit number (endpoint)
+ *
+ * This function returns complete status
+ */
+static int hw_test_and_clear_complete(int n)
+{
+        return hw_ctest_and_clear(CAP_ENDPTCOMPLETE, BIT(n));
+}
+
+/**
+ * hw_test_and_clear_intr_active: test & clear active interrupts (execute
+ *                                without interruption)
+ *
+ * This function returns active interrutps
+ */
+static u32 hw_test_and_clear_intr_active(void)
+{
+        u32 reg = hw_read_intr_status() & hw_read_intr_enable();
+
+        hw_cwrite(CAP_USBSTS, ~0, reg);
+        return reg;
+}
+
+/**
+ * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
+ *                                interruption)
+ *
+ * This function returns guard value
+ */
+static int hw_test_and_clear_setup_guard(void)
+{
+        return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, 0);
+}
+
+/**
+ * hw_test_and_set_setup_guard: test & set setup guard (execute without
+ *                              interruption)
+ *
+ * This function returns guard value
+ */
+static int hw_test_and_set_setup_guard(void)
+{
+        return hw_ctest_and_write(CAP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
+}
+
+/**
+ * hw_usb_set_address: configures USB address (execute without interruption)
+ * @value: new USB address
+ *
+ * This function returns an error code
+ */
+static int hw_usb_set_address(u8 value)
+{
+        /* advance */
+        hw_cwrite(CAP_DEVICEADDR, DEVICEADDR_USBADR | DEVICEADDR_USBADRA,
+                  value << ffs_nr(DEVICEADDR_USBADR) | DEVICEADDR_USBADRA);
+        return 0;
+}
+
+/**
+ * hw_usb_reset: restart device after a bus reset (execute without
+ *               interruption)
+ *
+ * This function returns an error code
+ */
+static int hw_usb_reset(void)
+{
+        hw_usb_set_address(0);
+
+        /* ESS flushes only at end?!? */
+        hw_cwrite(CAP_ENDPTFLUSH,    ~0, ~0);   /* flush all EPs */
+
+        /* clear setup token semaphores */
+        hw_cwrite(CAP_ENDPTSETUPSTAT, 0,  0);   /* writes its content */
+
+        /* clear complete status */
+        hw_cwrite(CAP_ENDPTCOMPLETE,  0,  0);   /* writes its content */
+
+        /* wait until all bits cleared */
+        while (hw_cread(CAP_ENDPTPRIME, ~0))
+                udelay(10);             /* not RTOS friendly */
+
+        /* reset all endpoints ? */
+
+        /* reset internal status and wait for further instructions
+           no need to verify the port reset status (ESS does it) */
+
+        return 0;
+}
+
+/******************************************************************************
+ * DBG block
+ *****************************************************************************/
+/**
+ * show_device: prints information about device capabilities and status
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_device(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        struct usb_gadget *gadget = &udc->gadget;
+        int n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "speed             = %d\n",
+                       gadget->speed);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_dualspeed      = %d\n",
+                       gadget->is_dualspeed);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_otg            = %d\n",
+                       gadget->is_otg);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "is_a_peripheral   = %d\n",
+                       gadget->is_a_peripheral);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "b_hnp_enable      = %d\n",
+                       gadget->b_hnp_enable);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "a_hnp_support     = %d\n",
+                       gadget->a_hnp_support);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "a_alt_hnp_support = %d\n",
+                       gadget->a_alt_hnp_support);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "name              = %s\n",
+                       (gadget->name ? gadget->name : ""));
+
+        return n;
+}
+static DEVICE_ATTR(device, S_IRUSR, show_device, NULL);
+
+/**
+ * show_driver: prints information about attached gadget (if any)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_driver(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        struct usb_gadget_driver *driver = udc->driver;
+        int n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        if (driver == NULL)
+                return scnprintf(buf, PAGE_SIZE,
+                                 "There is no gadget attached!\n");
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "function  = %s\n",
+                       (driver->function ? driver->function : ""));
+        n += scnprintf(buf + n, PAGE_SIZE - n, "max speed = %d\n",
+                       driver->speed);
+
+        return n;
+}
+static DEVICE_ATTR(driver, S_IRUSR, show_driver, NULL);
+
+/* Maximum event message length */
+#define DBG_DATA_MSG   64UL
+
+/* Maximum event messages */
+#define DBG_DATA_MAX   128UL
+
+/* Event buffer descriptor */
+static struct {
+        char     (buf[DBG_DATA_MAX])[DBG_DATA_MSG];   /* buffer */
+        unsigned idx;   /* index */
+        unsigned tty;   /* print to console? */
+        rwlock_t lck;   /* lock */
+} dbg_data = {
+        .idx = 0,
+        .tty = 0,
+        .lck = __RW_LOCK_UNLOCKED(lck)
+};
+
+/**
+ * dbg_dec: decrements debug event index
+ * @idx: buffer index
+ */
+static void dbg_dec(unsigned *idx)
+{
+        *idx = (*idx - 1) & (DBG_DATA_MAX-1);
+}
+
+/**
+ * dbg_inc: increments debug event index
+ * @idx: buffer index
+ */
+static void dbg_inc(unsigned *idx)
+{
+        *idx = (*idx + 1) & (DBG_DATA_MAX-1);
+}
+
+/**
+ * dbg_print:  prints the common part of the event
+ * @addr:   endpoint address
+ * @name:   event name
+ * @status: status
+ * @extra:  extra information
+ */
+static void dbg_print(u8 addr, const char *name, int status, const char *extra)
+{
+        struct timeval tval;
+        unsigned int stamp;
+        unsigned long flags;
+
+        write_lock_irqsave(&dbg_data.lck, flags);
+
+        do_gettimeofday(&tval);
+        stamp = tval.tv_sec & 0xFFFF;   /* 2^32 = 4294967296. Limit to 4096s */
+        stamp = stamp * 1000000 + tval.tv_usec;
+
+        scnprintf(dbg_data.buf[dbg_data.idx], DBG_DATA_MSG,
+                  "%04X\t» %02X %-7.7s %4i «\t%s\n",
+                  stamp, addr, name, status, extra);
+
+        dbg_inc(&dbg_data.idx);
+
+        write_unlock_irqrestore(&dbg_data.lck, flags);
+
+        if (dbg_data.tty != 0)
+                pr_notice("%04X\t» %02X %-7.7s %4i «\t%s\n",
+                          stamp, addr, name, status, extra);
+}
+
+/**
+ * dbg_done: prints a DONE event
+ * @addr:   endpoint address
+ * @td:     transfer descriptor
+ * @status: status
+ */
+static void dbg_done(u8 addr, const u32 token, int status)
+{
+        char msg[DBG_DATA_MSG];
+
+        scnprintf(msg, sizeof(msg), "%d %02X",
+                  (int)(token & TD_TOTAL_BYTES) >> ffs_nr(TD_TOTAL_BYTES),
+                  (int)(token & TD_STATUS)      >> ffs_nr(TD_STATUS));
+        dbg_print(addr, "DONE", status, msg);
+}
+
+/**
+ * dbg_event: prints a generic event
+ * @addr:   endpoint address
+ * @name:   event name
+ * @status: status
+ */
+static void dbg_event(u8 addr, const char *name, int status)
+{
+        if (name != NULL)
+                dbg_print(addr, name, status, "");
+}
+
+/*
+ * dbg_queue: prints a QUEUE event
+ * @addr:   endpoint address
+ * @req:    USB request
+ * @status: status
+ */
+static void dbg_queue(u8 addr, const struct usb_request *req, int status)
+{
+        char msg[DBG_DATA_MSG];
+
+        if (req != NULL) {
+                scnprintf(msg, sizeof(msg),
+                          "%d %d", !req->no_interrupt, req->length);
+                dbg_print(addr, "QUEUE", status, msg);
+        }
+}
+
+/**
+ * dbg_setup: prints a SETUP event
+ * @addr: endpoint address
+ * @req:  setup request
+ */
+static void dbg_setup(u8 addr, const struct usb_ctrlrequest *req)
+{
+        char msg[DBG_DATA_MSG];
+
+        if (req != NULL) {
+                scnprintf(msg, sizeof(msg),
+                          "%02X %02X %04X %04X %d", req->bRequestType,
+                          req->bRequest, le16_to_cpu(req->wValue),
+                          le16_to_cpu(req->wIndex), le16_to_cpu(req->wLength));
+                dbg_print(addr, "SETUP", 0, msg);
+        }
+}
+
+/**
+ * show_events: displays the event buffer
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_events(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        unsigned long flags;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        read_lock_irqsave(&dbg_data.lck, flags);
+
+        i = dbg_data.idx;
+        for (dbg_dec(&i); i != dbg_data.idx; dbg_dec(&i)) {
+                n += strlen(dbg_data.buf[i]);
+                if (n >= PAGE_SIZE) {
+                        n -= strlen(dbg_data.buf[i]);
+                        break;
+                }
+        }
+        for (j = 0, dbg_inc(&i); j < n; dbg_inc(&i))
+                j += scnprintf(buf + j, PAGE_SIZE - j,
+                               "%s", dbg_data.buf[i]);
+
+        read_unlock_irqrestore(&dbg_data.lck, flags);
+
+        return n;
+}
+
+/**
+ * store_events: configure if events are going to be also printed to console
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_events(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        unsigned tty;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u", &tty) != 1 || tty > 1) {
+                dev_err(dev, "<1|0>: enable|disable console log\n");
+                goto done;
+        }
+
+        dbg_data.tty = tty;
+        dev_info(dev, "tty = %u", dbg_data.tty);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(events, S_IRUSR | S_IWUSR, show_events, store_events);
+
+/**
+ * show_inters: interrupt status, enable status and historic
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_inters(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        u32 intr;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        n += scnprintf(buf + n, PAGE_SIZE - n,
+                       "status = %08x\n", hw_read_intr_status());
+        n += scnprintf(buf + n, PAGE_SIZE - n,
+                       "enable = %08x\n", hw_read_intr_enable());
+
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*test = %d\n",
+                       isr_statistics.test);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» ui  = %d\n",
+                       isr_statistics.ui);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» uei = %d\n",
+                       isr_statistics.uei);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» pci = %d\n",
+                       isr_statistics.pci);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» uri = %d\n",
+                       isr_statistics.uri);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "» sli = %d\n",
+                       isr_statistics.sli);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*none = %d\n",
+                       isr_statistics.none);
+        n += scnprintf(buf + n, PAGE_SIZE - n, "*hndl = %d\n",
+                       isr_statistics.hndl.cnt);
+
+        for (i = isr_statistics.hndl.idx, j = 0; j <= ISR_MASK; j++, i++) {
+                i   &= ISR_MASK;
+                intr = isr_statistics.hndl.buf[i];
+
+                if (USBi_UI  & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "ui  ");
+                intr &= ~USBi_UI;
+                if (USBi_UEI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "uei ");
+                intr &= ~USBi_UEI;
+                if (USBi_PCI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "pci ");
+                intr &= ~USBi_PCI;
+                if (USBi_URI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "uri ");
+                intr &= ~USBi_URI;
+                if (USBi_SLI & intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "sli ");
+                intr &= ~USBi_SLI;
+                if (intr)
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "??? ");
+                if (isr_statistics.hndl.buf[i])
+                        n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
+        }
+
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+
+/**
+ * store_inters: enable & force or disable an individual interrutps
+ *                   (to be used for test purposes only)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_inters(struct device *dev, struct device_attribute *attr,
+                            const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned en, bit;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u %u", &en, &bit) != 2 || en > 1) {
+                dev_err(dev, "<1|0> <bit>: enable|disable interrupt");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (en) {
+                if (hw_intr_force(bit))
+                        dev_err(dev, "invalid bit number\n");
+                else
+                        isr_statistics.test++;
+        } else {
+                if (hw_intr_clear(bit))
+                        dev_err(dev, "invalid bit number\n");
+        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(inters, S_IRUSR | S_IWUSR, show_inters, store_inters);
+
+/**
+ * show_port_test: reads port test mode
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_port_test(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned mode;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        mode = hw_port_test_get();
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return scnprintf(buf, PAGE_SIZE, "mode = %u\n", mode);
+}
+
+/**
+ * store_port_test: writes port test mode
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_port_test(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned mode;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%u", &mode) != 1) {
+                dev_err(dev, "<mode>: set port test mode");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (hw_port_test_set(mode))
+                dev_err(dev, "invalid mode\n");
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(port_test, S_IRUSR | S_IWUSR,
+                   show_port_test, store_port_test);
+
+/**
+ * show_qheads: DMA contents of all queue heads
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_qheads(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        unsigned i, j, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+                n += scnprintf(buf + n, PAGE_SIZE - n,
+                               "EP=%02i: RX=%08X TX=%08X\n",
+                               i, (u32)mEp->qh[RX].dma, (u32)mEp->qh[TX].dma);
+                for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++) {
+                        n += scnprintf(buf + n, PAGE_SIZE - n,
+                                       " %04X:    %08X    %08X\n", j,
+                                       *((u32 *)mEp->qh[RX].ptr + j),
+                                       *((u32 *)mEp->qh[TX].ptr + j));
+                }
+        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+static DEVICE_ATTR(qheads, S_IRUSR, show_qheads, NULL);
+
+/**
+ * show_registers: dumps all registers
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_registers(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        u32 dump[512];
+        unsigned i, k, n = 0;
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        k = hw_register_read(dump, sizeof(dump)/sizeof(u32));
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        for (i = 0; i < k; i++) {
+                n += scnprintf(buf + n, PAGE_SIZE - n,
+                               "reg[0x%04X] = 0x%08X\n",
+                               i * (unsigned)sizeof(u32), dump[i]);
+        }
+
+        return n;
+}
+
+/**
+ * store_registers: writes value to register address
+ *
+ * Check "device.h" for details
+ */
+static ssize_t store_registers(struct device *dev,
+                               struct device_attribute *attr,
+                               const char *buf, size_t count)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long addr, data, flags;
+
+        dbg_trace("[%s] %p, %d\n", __func__, buf, count);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                goto done;
+        }
+
+        if (sscanf(buf, "%li %li", &addr, &data) != 2) {
+                dev_err(dev, "<addr> <data>: write data to register address");
+                goto done;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        if (hw_register_write(addr, data))
+                dev_err(dev, "invalid address range\n");
+        spin_unlock_irqrestore(udc->lock, flags);
+
+ done:
+        return count;
+}
+static DEVICE_ATTR(registers, S_IRUSR | S_IWUSR,
+                   show_registers, store_registers);
+
+/**
+ * show_requests: DMA contents of all requests currently queued (all endpts)
+ *
+ * Check "device.h" for details
+ */
+static ssize_t show_requests(struct device *dev, struct device_attribute *attr,
+                             char *buf)
+{
+        struct ci13xxx *udc = container_of(dev, struct ci13xxx, gadget.dev);
+        unsigned long flags;
+        struct list_head   *ptr = NULL;
+        struct ci13xxx_req *req = NULL;
+        unsigned i, j, k, n = 0, qSize = sizeof(struct ci13xxx_td)/sizeof(u32);
+
+        dbg_trace("[%s] %p\n", __func__, buf);
+        if (attr == NULL || buf == NULL) {
+                dev_err(dev, "[%s] EINVAL\n", __func__);
+                return 0;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+        for (i = 0; i < hw_ep_max; i++)
+                for (k = RX; k <= TX; k++)
+                        list_for_each(ptr, &udc->ci13xxx_ep[i].qh[k].queue)
+                        {
+                                req = list_entry(ptr,
+                                                 struct ci13xxx_req, queue);
+
+                                n += scnprintf(buf + n, PAGE_SIZE - n,
+                                               "EP=%02i: TD=%08X %s\n",
+                                               i, (u32)req->dma,
+                                               ((k == RX) ? "RX" : "TX"));
+
+                                for (j = 0; j < qSize; j++)
+                                        n += scnprintf(buf + n, PAGE_SIZE - n,
+                                                       " %04X:    %08X\n", j,
+                                                       *((u32 *)req->ptr + j));
+                        }
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        return n;
+}
+static DEVICE_ATTR(requests, S_IRUSR, show_requests, NULL);
+
+/**
+ * dbg_create_files: initializes the attribute interface
+ * @dev: device
+ *
+ * This function returns an error code
+ */
+__maybe_unused static int dbg_create_files(struct device *dev)
+{
+        int retval = 0;
+
+        if (dev == NULL)
+                return -EINVAL;
+        retval = device_create_file(dev, &dev_attr_device);
+        if (retval)
+                goto done;
+        retval = device_create_file(dev, &dev_attr_driver);
+        if (retval)
+                goto rm_device;
+        retval = device_create_file(dev, &dev_attr_events);
+        if (retval)
+                goto rm_driver;
+        retval = device_create_file(dev, &dev_attr_inters);
+        if (retval)
+                goto rm_events;
+        retval = device_create_file(dev, &dev_attr_port_test);
+        if (retval)
+                goto rm_inters;
+        retval = device_create_file(dev, &dev_attr_qheads);
+        if (retval)
+                goto rm_port_test;
+        retval = device_create_file(dev, &dev_attr_registers);
+        if (retval)
+                goto rm_qheads;
+        retval = device_create_file(dev, &dev_attr_requests);
+        if (retval)
+                goto rm_registers;
+        return 0;
+
+ rm_registers:
+        device_remove_file(dev, &dev_attr_registers);
+ rm_qheads:
+        device_remove_file(dev, &dev_attr_qheads);
+ rm_port_test:
+        device_remove_file(dev, &dev_attr_port_test);
+ rm_inters:
+        device_remove_file(dev, &dev_attr_inters);
+ rm_events:
+        device_remove_file(dev, &dev_attr_events);
+ rm_driver:
+        device_remove_file(dev, &dev_attr_driver);
+ rm_device:
+        device_remove_file(dev, &dev_attr_device);
+ done:
+        return retval;
+}
+
+/**
+ * dbg_remove_files: destroys the attribute interface
+ * @dev: device
+ *
+ * This function returns an error code
+ */
+__maybe_unused static int dbg_remove_files(struct device *dev)
+{
+        if (dev == NULL)
+                return -EINVAL;
+        device_remove_file(dev, &dev_attr_requests);
+        device_remove_file(dev, &dev_attr_registers);
+        device_remove_file(dev, &dev_attr_qheads);
+        device_remove_file(dev, &dev_attr_port_test);
+        device_remove_file(dev, &dev_attr_inters);
+        device_remove_file(dev, &dev_attr_events);
+        device_remove_file(dev, &dev_attr_driver);
+        device_remove_file(dev, &dev_attr_device);
+        return 0;
+}
+
+/******************************************************************************
+ * UTIL block
+ *****************************************************************************/
+/**
+ * _usb_addr: calculates endpoint address from direction & number
+ * @ep:  endpoint
+ */
+static inline u8 _usb_addr(struct ci13xxx_ep *ep)
+{
+        return ((ep->dir == TX) ? USB_ENDPOINT_DIR_MASK : 0) | ep->num;
+}
+
+/**
+ * _hardware_queue: configures a request at hardware level
+ * @gadget: gadget
+ * @mEp:    endpoint
+ *
+ * This function returns an error code
+ */
+static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
+{
+        unsigned i;
+
+        trace("%p, %p", mEp, mReq);
+
+        /* don't queue twice */
+        if (mReq->req.status == -EALREADY)
+                return -EALREADY;
+
+        if (hw_ep_is_primed(mEp->num, mEp->dir))
+                return -EBUSY;
+
+        mReq->req.status = -EALREADY;
+
+        if (mReq->req.length && !mReq->req.dma) {
+                mReq->req.dma = \
+                        dma_map_single(mEp->device, mReq->req.buf,
+                                       mReq->req.length, mEp->dir ?
+                                       DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                if (mReq->req.dma == 0)
+                        return -ENOMEM;
+
+                mReq->map = 1;
+        }
+
+        /*
+         * TD configuration
+         * TODO - handle requests which spawns into several TDs
+         */
+        memset(mReq->ptr, 0, sizeof(*mReq->ptr));
+        mReq->ptr->next    |= TD_TERMINATE;
+        mReq->ptr->token    = mReq->req.length << ffs_nr(TD_TOTAL_BYTES);
+        mReq->ptr->token   &= TD_TOTAL_BYTES;
+        mReq->ptr->token   |= TD_IOC;
+        mReq->ptr->token   |= TD_STATUS_ACTIVE;
+        mReq->ptr->page[0]  = mReq->req.dma;
+        for (i = 1; i < 5; i++)
+                mReq->ptr->page[i] =
+                        (mReq->req.dma + i * PAGE_SIZE) & ~TD_RESERVED_MASK;
+
+        /*
+         *  QH configuration
+         *  At this point it's guaranteed exclusive access to qhead
+         *  (endpt is not primed) so it's no need to use tripwire
+         */
+        mEp->qh[mEp->dir].ptr->td.next   = mReq->dma;    /* TERMINATE = 0 */
+        mEp->qh[mEp->dir].ptr->td.token &= ~TD_STATUS;   /* clear status */
+        if (mReq->req.zero == 0)
+                mEp->qh[mEp->dir].ptr->cap |=  QH_ZLT;
+        else
+                mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+
+        wmb();   /* synchronize before ep prime */
+
+        return hw_ep_prime(mEp->num, mEp->dir,
+                           mEp->type == USB_ENDPOINT_XFER_CONTROL);
+}
+
+/**
+ * _hardware_dequeue: handles a request at hardware level
+ * @gadget: gadget
+ * @mEp:    endpoint
+ *
+ * This function returns an error code
+ */
+static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
+{
+        trace("%p, %p", mEp, mReq);
+
+        if (mReq->req.status != -EALREADY)
+                return -EINVAL;
+
+        if (hw_ep_is_primed(mEp->num, mEp->dir))
+                hw_ep_flush(mEp->num, mEp->dir);
+
+        mReq->req.status = 0;
+
+        if (mReq->map) {
+                dma_unmap_single(mEp->device, mReq->req.dma, mReq->req.length,
+                                 mEp->dir ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
+                mReq->req.dma = 0;
+                mReq->map     = 0;
+        }
+
+        mReq->req.status = mReq->ptr->token & TD_STATUS;
+        if      ((TD_STATUS_ACTIVE & mReq->req.status) != 0)
+                mReq->req.status = -ECONNRESET;
+        else if ((TD_STATUS_HALTED & mReq->req.status) != 0)
+                mReq->req.status = -1;
+        else if ((TD_STATUS_DT_ERR & mReq->req.status) != 0)
+                mReq->req.status = -1;
+        else if ((TD_STATUS_TR_ERR & mReq->req.status) != 0)
+                mReq->req.status = -1;
+
+        mReq->req.actual   = mReq->ptr->token & TD_TOTAL_BYTES;
+        mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
+        mReq->req.actual   = mReq->req.length - mReq->req.actual;
+        mReq->req.actual   = mReq->req.status ? 0 : mReq->req.actual;
+
+        return mReq->req.actual;
+}
+
+/**
+ * _ep_nuke: dequeues all endpoint requests
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int _ep_nuke(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        trace("%p", mEp);
+
+        if (mEp == NULL)
+                return -EINVAL;
+
+        hw_ep_flush(mEp->num, mEp->dir);
+
+        while (!list_empty(&mEp->qh[mEp->dir].queue)) {
+
+                /* pop oldest request */
+                struct ci13xxx_req *mReq = \
+                        list_entry(mEp->qh[mEp->dir].queue.next,
+                                   struct ci13xxx_req, queue);
+                list_del_init(&mReq->queue);
+                mReq->req.status = -ESHUTDOWN;
+
+                if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                        spin_unlock(mEp->lock);
+                        mReq->req.complete(&mEp->ep, &mReq->req);
+                        spin_lock(mEp->lock);
+                }
+        }
+        return 0;
+}
+
+/**
+ * _gadget_stop_activity: stops all USB activity, flushes & disables all endpts
+ * @gadget: gadget
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int _gadget_stop_activity(struct usb_gadget *gadget)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        struct usb_ep *ep;
+        struct ci13xxx    *udc = container_of(gadget, struct ci13xxx, gadget);
+        struct ci13xxx_ep *mEp = container_of(gadget->ep0,
+                                              struct ci13xxx_ep, ep);
+
+        trace("%p", gadget);
+
+        if (gadget == NULL)
+                return -EINVAL;
+
+        spin_unlock(udc->lock);
+
+        /* flush all endpoints */
+        gadget_for_each_ep(ep, gadget) {
+                usb_ep_fifo_flush(ep);
+        }
+        usb_ep_fifo_flush(gadget->ep0);
+
+        udc->driver->disconnect(gadget);
+
+        /* make sure to disable all endpoints */
+        gadget_for_each_ep(ep, gadget) {
+                usb_ep_disable(ep);
+        }
+        usb_ep_disable(gadget->ep0);
+
+        if (mEp->status != NULL) {
+                usb_ep_free_request(gadget->ep0, mEp->status);
+                mEp->status = NULL;
+        }
+
+        spin_lock(udc->lock);
+
+        return 0;
+}
+
+/******************************************************************************
+ * ISR block
+ *****************************************************************************/
+/**
+ * isr_reset_handler: USB reset interrupt handler
+ * @udc: UDC device
+ *
+ * This function resets USB engine after a bus reset occurred
+ */
+static void isr_reset_handler(struct ci13xxx *udc)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[0];
+        int retval;
+
+        trace("%p", udc);
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        dbg_event(0xFF, "BUS RST", 0);
+
+        retval = _gadget_stop_activity(&udc->gadget);
+        if (retval)
+                goto done;
+
+        retval = hw_usb_reset();
+        if (retval)
+                goto done;
+
+        spin_unlock(udc->lock);
+        retval = usb_ep_enable(&mEp->ep, &ctrl_endpt_desc);
+        if (!retval) {
+                mEp->status = usb_ep_alloc_request(&mEp->ep, GFP_KERNEL);
+                if (mEp->status == NULL) {
+                        usb_ep_disable(&mEp->ep);
+                        retval = -ENOMEM;
+                }
+        }
+        spin_lock(udc->lock);
+
+ done:
+        if (retval)
+                err("error: %i", retval);
+}
+
+/**
+ * isr_get_status_complete: get_status request complete function
+ * @ep:  endpoint
+ * @req: request handled
+ *
+ * Caller must release lock
+ */
+static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
+{
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        kfree(req->buf);
+        usb_ep_free_request(ep, req);
+}
+
+/**
+ * isr_get_status_response: get_status request response
+ * @ep:    endpoint
+ * @setup: setup request packet
+ *
+ * This function returns an error code
+ */
+static int isr_get_status_response(struct ci13xxx_ep *mEp,
+                                   struct usb_ctrlrequest *setup)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        struct usb_request *req = NULL;
+        gfp_t gfp_flags = GFP_ATOMIC;
+        int dir, num, retval;
+
+        trace("%p, %p", mEp, setup);
+
+        if (mEp == NULL || setup == NULL)
+                return -EINVAL;
+
+        spin_unlock(mEp->lock);
+        req = usb_ep_alloc_request(&mEp->ep, gfp_flags);
+        spin_lock(mEp->lock);
+        if (req == NULL)
+                return -ENOMEM;
+
+        req->complete = isr_get_status_complete;
+        req->length   = 2;
+        req->buf      = kzalloc(req->length, gfp_flags);
+        if (req->buf == NULL) {
+                retval = -ENOMEM;
+                goto err_free_req;
+        }
+
+        if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
+                /* TODO: D1 - Remote Wakeup; D0 - Self Powered */
+                retval = 0;
+        } else if ((setup->bRequestType & USB_RECIP_MASK) \
+                   == USB_RECIP_ENDPOINT) {
+                dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
+                        TX : RX;
+                num =  le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
+                *((u16 *)req->buf) = hw_ep_get_halt(num, dir);
+        }
+        /* else do nothing; reserved for future use */
+
+        spin_unlock(mEp->lock);
+        retval = usb_ep_queue(&mEp->ep, req, gfp_flags);
+        spin_lock(mEp->lock);
+        if (retval)
+                goto err_free_buf;
+
+        return 0;
+
+ err_free_buf:
+        kfree(req->buf);
+ err_free_req:
+        spin_unlock(mEp->lock);
+        usb_ep_free_request(&mEp->ep, req);
+        spin_lock(mEp->lock);
+        return retval;
+}
+
+/**
+ * isr_setup_status_phase: queues the status phase of a setup transation
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ */
+static int isr_setup_status_phase(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        int retval;
+
+        trace("%p", mEp);
+
+        /* mEp is always valid & configured */
+
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        mEp->status->no_interrupt = 1;
+
+        spin_unlock(mEp->lock);
+        retval = usb_ep_queue(&mEp->ep, mEp->status, GFP_ATOMIC);
+        spin_lock(mEp->lock);
+
+        return retval;
+}
+
+/**
+ * isr_tr_complete_low: transaction complete low level handler
+ * @mEp: endpoint
+ *
+ * This function returns an error code
+ * Caller must hold lock
+ */
+static int isr_tr_complete_low(struct ci13xxx_ep *mEp)
+__releases(mEp->lock)
+__acquires(mEp->lock)
+{
+        struct ci13xxx_req *mReq;
+        int retval;
+
+        trace("%p", mEp);
+
+        if (list_empty(&mEp->qh[mEp->dir].queue))
+                return -EINVAL;
+
+        /* pop oldest request */
+        mReq = list_entry(mEp->qh[mEp->dir].queue.next,
+                          struct ci13xxx_req, queue);
+        list_del_init(&mReq->queue);
+
+        retval = _hardware_dequeue(mEp, mReq);
+        if (retval < 0) {
+                dbg_event(_usb_addr(mEp), "DONE", retval);
+                goto done;
+        }
+
+        dbg_done(_usb_addr(mEp), mReq->ptr->token, retval);
+
+        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                spin_unlock(mEp->lock);
+                mReq->req.complete(&mEp->ep, &mReq->req);
+                spin_lock(mEp->lock);
+        }
+
+        if (!list_empty(&mEp->qh[mEp->dir].queue)) {
+                mReq = list_entry(mEp->qh[mEp->dir].queue.next,
+                                  struct ci13xxx_req, queue);
+                _hardware_enqueue(mEp, mReq);
+        }
+
+ done:
+        return retval;
+}
+
+/**
+ * isr_tr_complete_handler: transaction complete interrupt handler
+ * @udc: UDC descriptor
+ *
+ * This function handles traffic events
+ */
+static void isr_tr_complete_handler(struct ci13xxx *udc)
+__releases(udc->lock)
+__acquires(udc->lock)
+{
+        unsigned i;
+
+        trace("%p", udc);
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp  = &udc->ci13xxx_ep[i];
+                int type, num, err = -EINVAL;
+                struct usb_ctrlrequest req;
+
+
+                if (mEp->desc == NULL)
+                        continue;   /* not configured */
+
+                if ((mEp->dir == RX && hw_test_and_clear_complete(i)) ||
+                    (mEp->dir == TX && hw_test_and_clear_complete(i + 16))) {
+                        err = isr_tr_complete_low(mEp);
+                        if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
+                                if (err > 0)   /* needs status phase */
+                                        err = isr_setup_status_phase(mEp);
+                                if (err < 0) {
+                                        dbg_event(_usb_addr(mEp),
+                                                  "ERROR", err);
+                                        spin_unlock(udc->lock);
+                                        if (usb_ep_set_halt(&mEp->ep))
+                                                err("error: ep_set_halt");
+                                        spin_lock(udc->lock);
+                                }
+                        }
+                }
+
+                if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
+                    !hw_test_and_clear_setup_status(i))
+                        continue;
+
+                if (i != 0) {
+                        warn("ctrl traffic received at endpoint");
+                        continue;
+                }
+
+                /* read_setup_packet */
+                do {
+                        hw_test_and_set_setup_guard();
+                        memcpy(&req, &mEp->qh[RX].ptr->setup, sizeof(req));
+                } while (!hw_test_and_clear_setup_guard());
+
+                type = req.bRequestType;
+
+                mEp->dir = (type & USB_DIR_IN) ? TX : RX;
+
+                dbg_setup(_usb_addr(mEp), &req);
+
+                switch (req.bRequest) {
+                case USB_REQ_CLEAR_FEATURE:
+                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
+                                goto delegate;
+                        if (req.wLength != 0)
+                                break;
+                        num  = le16_to_cpu(req.wIndex);
+                        num &= USB_ENDPOINT_NUMBER_MASK;
+                        if (!udc->ci13xxx_ep[num].wedge) {
+                                spin_unlock(udc->lock);
+                                err = usb_ep_clear_halt(
+                                        &udc->ci13xxx_ep[num].ep);
+                                spin_lock(udc->lock);
+                                if (err)
+                                        break;
+                        }
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                case USB_REQ_GET_STATUS:
+                        if (type != (USB_DIR_IN|USB_RECIP_DEVICE)   &&
+                            type != (USB_DIR_IN|USB_RECIP_ENDPOINT) &&
+                            type != (USB_DIR_IN|USB_RECIP_INTERFACE))
+                                goto delegate;
+                        if (le16_to_cpu(req.wLength) != 2 ||
+                            le16_to_cpu(req.wValue)  != 0)
+                                break;
+                        err = isr_get_status_response(mEp, &req);
+                        break;
+                case USB_REQ_SET_ADDRESS:
+                        if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
+                                goto delegate;
+                        if (le16_to_cpu(req.wLength) != 0 ||
+                            le16_to_cpu(req.wIndex)  != 0)
+                                break;
+                        err = hw_usb_set_address((u8)le16_to_cpu(req.wValue));
+                        if (err)
+                                break;
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                case USB_REQ_SET_FEATURE:
+                        if (type != (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
+                            le16_to_cpu(req.wValue) != USB_ENDPOINT_HALT)
+                                goto delegate;
+                        if (req.wLength != 0)
+                                break;
+                        num  = le16_to_cpu(req.wIndex);
+                        num &= USB_ENDPOINT_NUMBER_MASK;
+
+                        spin_unlock(udc->lock);
+                        err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep);
+                        spin_lock(udc->lock);
+                        if (err)
+                                break;
+                        err = isr_setup_status_phase(mEp);
+                        break;
+                default:
+delegate:
+                        if (req.wLength == 0)   /* no data phase */
+                                mEp->dir = TX;
+
+                        spin_unlock(udc->lock);
+                        err = udc->driver->setup(&udc->gadget, &req);
+                        spin_lock(udc->lock);
+                        break;
+                }
+
+                if (err < 0) {
+                        dbg_event(_usb_addr(mEp), "ERROR", err);
+
+                        spin_unlock(udc->lock);
+                        if (usb_ep_set_halt(&mEp->ep))
+                                err("error: ep_set_halt");
+                        spin_lock(udc->lock);
+                }
+        }
+}
+
+/******************************************************************************
+ * ENDPT block
+ *****************************************************************************/
+/**
+ * ep_enable: configure endpoint, making it usable
+ *
+ * Check usb_ep_enable() at "usb_gadget.h" for details
+ */
+static int ep_enable(struct usb_ep *ep,
+                     const struct usb_endpoint_descriptor *desc)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p, %p", ep, desc);
+
+        if (ep == NULL || desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        /* only internal SW should enable ctrl endpts */
+
+        mEp->desc = desc;
+
+        if (!list_empty(&mEp->qh[mEp->dir].queue))
+                warn("enabling a non-empty endpoint!");
+
+        mEp->dir  = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? TX : RX;
+        mEp->num  =  desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        mEp->type =  desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
+
+        mEp->ep.maxpacket = __constant_le16_to_cpu(desc->wMaxPacketSize);
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "ENABLE", 0);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->qh[mEp->dir].ptr->cap |=  QH_IOS;
+                else if (mEp->type == USB_ENDPOINT_XFER_ISOC)
+                        mEp->qh[mEp->dir].ptr->cap &= ~QH_MULT;
+                else
+                        mEp->qh[mEp->dir].ptr->cap &= ~QH_ZLT;
+
+                mEp->qh[mEp->dir].ptr->cap |=
+                        (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
+                mEp->qh[mEp->dir].ptr->td.next |= TD_TERMINATE;   /* needed? */
+
+                retval |= hw_ep_enable(mEp->num, mEp->dir, mEp->type);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_disable: endpoint is no longer usable
+ *
+ * Check usb_ep_disable() at "usb_gadget.h" for details
+ */
+static int ep_disable(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL)
+                return -EINVAL;
+        else if (mEp->desc == NULL)
+                return -EBUSY;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        /* only internal SW should disable ctrl endpts */
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "DISABLE", 0);
+
+                retval |= _ep_nuke(mEp);
+                retval |= hw_ep_disable(mEp->num, mEp->dir);
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        mEp->desc = NULL;
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_alloc_request: allocate a request object to use with this endpoint
+ *
+ * Check usb_ep_alloc_request() at "usb_gadget.h" for details
+ */
+static struct usb_request *ep_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep, struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = NULL;
+        unsigned long flags;
+
+        trace("%p, %i", ep, gfp_flags);
+
+        if (ep == NULL) {
+                err("EINVAL");
+                return NULL;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        mReq = kzalloc(sizeof(struct ci13xxx_req), gfp_flags);
+        if (mReq != NULL) {
+                INIT_LIST_HEAD(&mReq->queue);
+
+                mReq->ptr = dma_pool_alloc(mEp->td_pool, gfp_flags,
+                                           &mReq->dma);
+                if (mReq->ptr == NULL) {
+                        kfree(mReq);
+                        mReq = NULL;
+                }
+        }
+
+        dbg_event(_usb_addr(mEp), "ALLOC", mReq == NULL);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+
+        return (mReq == NULL) ? NULL : &mReq->req;
+}
+
+/**
+ * ep_free_request: frees a request object
+ *
+ * Check usb_ep_free_request() at "usb_gadget.h" for details
+ */
+static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        unsigned long flags;
+
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL) {
+                err("EINVAL");
+                return;
+        } else if (!list_empty(&mReq->queue)) {
+                err("EBUSY");
+                return;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        if (mReq->ptr)
+                dma_pool_free(mEp->td_pool, mReq->ptr, mReq->dma);
+        kfree(mReq);
+
+        dbg_event(_usb_addr(mEp), "FREE", 0);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+}
+
+/**
+ * ep_queue: queues (submits) an I/O request to an endpoint
+ *
+ * Check usb_ep_queue()* at usb_gadget.h" for details
+ */
+static int ep_queue(struct usb_ep *ep, struct usb_request *req,
+                    gfp_t __maybe_unused gfp_flags)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        int retval = 0;
+        unsigned long flags;
+
+        trace("%p, %p, %X", ep, req, gfp_flags);
+
+        if (ep == NULL || req == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        if (mEp->type == USB_ENDPOINT_XFER_CONTROL &&
+            !list_empty(&mEp->qh[mEp->dir].queue)) {
+                _ep_nuke(mEp);
+                retval = -EOVERFLOW;
+                warn("endpoint ctrl %X nuked", _usb_addr(mEp));
+        }
+
+        /* first nuke then test link, e.g. previous status has not sent */
+        if (!list_empty(&mReq->queue)) {
+                retval = -EBUSY;
+                err("request already in queue");
+                goto done;
+        }
+
+        if (req->length > (4 * PAGE_SIZE)) {
+                req->length = (4 * PAGE_SIZE);
+                retval = -EMSGSIZE;
+                warn("request length truncated");
+        }
+
+        dbg_queue(_usb_addr(mEp), req, retval);
+
+        /* push request */
+        mReq->req.status = -EINPROGRESS;
+        mReq->req.actual = 0;
+        list_add_tail(&mReq->queue, &mEp->qh[mEp->dir].queue);
+
+        retval = _hardware_enqueue(mEp, mReq);
+        if (retval == -EALREADY || retval == -EBUSY) {
+                dbg_event(_usb_addr(mEp), "QUEUE", retval);
+                retval = 0;
+        }
+
+ done:
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_dequeue: dequeues (cancels, unlinks) an I/O request from an endpoint
+ *
+ * Check usb_ep_dequeue() at "usb_gadget.h" for details
+ */
+static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
+{
+        struct ci13xxx_ep  *mEp  = container_of(ep,  struct ci13xxx_ep, ep);
+        struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
+        unsigned long flags;
+
+        trace("%p, %p", ep, req);
+
+        if (ep == NULL || req == NULL || mEp->desc == NULL ||
+            list_empty(&mReq->queue)  || list_empty(&mEp->qh[mEp->dir].queue))
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
+
+        if (mReq->req.status == -EALREADY)
+                _hardware_dequeue(mEp, mReq);
+
+        /* pop request */
+        list_del_init(&mReq->queue);
+        req->status = -ECONNRESET;
+
+        if (!mReq->req.no_interrupt && mReq->req.complete != NULL) {
+                spin_unlock(mEp->lock);
+                mReq->req.complete(&mEp->ep, &mReq->req);
+                spin_lock(mEp->lock);
+        }
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return 0;
+}
+
+/**
+ * ep_set_halt: sets the endpoint halt feature
+ *
+ * Check usb_ep_set_halt() at "usb_gadget.h" for details
+ */
+static int ep_set_halt(struct usb_ep *ep, int value)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        int direction, retval = 0;
+        unsigned long flags;
+
+        trace("%p, %i", ep, value);
+
+        if (ep == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+#ifndef STALL_IN
+        /* g_file_storage MS compliant but g_zero fails chapter 9 compliance */
+        if (value && mEp->type == USB_ENDPOINT_XFER_BULK && mEp->dir == TX &&
+            !list_empty(&mEp->qh[mEp->dir].queue)) {
+                spin_unlock_irqrestore(mEp->lock, flags);
+                return -EAGAIN;
+        }
+#endif
+
+        direction = mEp->dir;
+        do {
+                dbg_event(_usb_addr(mEp), "HALT", value);
+                retval |= hw_ep_set_halt(mEp->num, mEp->dir, value);
+
+                if (!value)
+                        mEp->wedge = 0;
+
+                if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
+                        mEp->dir = (mEp->dir == TX) ? RX : TX;
+
+        } while (mEp->dir != direction);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+        return retval;
+}
+
+/**
+ * ep_set_wedge: sets the halt feature and ignores clear requests
+ *
+ * Check usb_ep_set_wedge() at "usb_gadget.h" for details
+ */
+static int ep_set_wedge(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL || mEp->desc == NULL)
+                return -EINVAL;
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "WEDGE", 0);
+        mEp->wedge = 1;
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+
+        return usb_ep_set_halt(ep);
+}
+
+/**
+ * ep_fifo_flush: flushes contents of a fifo
+ *
+ * Check usb_ep_fifo_flush() at "usb_gadget.h" for details
+ */
+static void ep_fifo_flush(struct usb_ep *ep)
+{
+        struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
+        unsigned long flags;
+
+        trace("%p", ep);
+
+        if (ep == NULL) {
+                err("%02X: -EINVAL", _usb_addr(mEp));
+                return;
+        }
+
+        spin_lock_irqsave(mEp->lock, flags);
+
+        dbg_event(_usb_addr(mEp), "FFLUSH", 0);
+        hw_ep_flush(mEp->num, mEp->dir);
+
+        spin_unlock_irqrestore(mEp->lock, flags);
+}
+
+/**
+ * Endpoint-specific part of the API to the USB controller hardware
+ * Check "usb_gadget.h" for details
+ */
+static const struct usb_ep_ops usb_ep_ops = {
+        .enable        = ep_enable,
+        .disable       = ep_disable,
+        .alloc_request = ep_alloc_request,
+        .free_request  = ep_free_request,
+        .queue         = ep_queue,
+        .dequeue       = ep_dequeue,
+        .set_halt      = ep_set_halt,
+        .set_wedge     = ep_set_wedge,
+        .fifo_flush    = ep_fifo_flush,
+};
+
+/******************************************************************************
+ * GADGET block
+ *****************************************************************************/
+/**
+ * Device operations part of the API to the USB controller hardware,
+ * which don't involve endpoints (or i/o)
+ * Check  "usb_gadget.h" for details
+ */
+static const struct usb_gadget_ops usb_gadget_ops;
+
+/**
+ * usb_gadget_register_driver: register a gadget driver
+ *
+ * Check usb_gadget_register_driver() at "usb_gadget.h" for details
+ * Interrupts are enabled here
+ */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct ci13xxx *udc = _udc;
+        unsigned long i, k, flags;
+        int retval = -ENOMEM;
+
+        trace("%p", driver);
+
+        if (driver             == NULL ||
+            driver->bind       == NULL ||
+            driver->unbind     == NULL ||
+            driver->setup      == NULL ||
+            driver->disconnect == NULL ||
+            driver->suspend    == NULL ||
+            driver->resume     == NULL)
+                return -EINVAL;
+        else if (udc         == NULL)
+                return -ENODEV;
+        else if (udc->driver != NULL)
+                return -EBUSY;
+
+        /* alloc resources */
+        udc->qh_pool = dma_pool_create("ci13xxx_qh", &udc->gadget.dev,
+                                       sizeof(struct ci13xxx_qh),
+                                       64, PAGE_SIZE);
+        if (udc->qh_pool == NULL)
+                return -ENOMEM;
+
+        udc->td_pool = dma_pool_create("ci13xxx_td", &udc->gadget.dev,
+                                       sizeof(struct ci13xxx_td),
+                                       64, PAGE_SIZE);
+        if (udc->td_pool == NULL) {
+                dma_pool_destroy(udc->qh_pool);
+                udc->qh_pool = NULL;
+                return -ENOMEM;
+        }
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        info("hw_ep_max = %d", hw_ep_max);
+
+        udc->driver = driver;
+        udc->gadget.ops        = NULL;
+        udc->gadget.dev.driver = NULL;
+
+        retval = 0;
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+
+                scnprintf(mEp->name, sizeof(mEp->name), "ep%i", (int)i);
+
+                mEp->lock         = udc->lock;
+                mEp->device       = &udc->gadget.dev;
+                mEp->td_pool      = udc->td_pool;
+
+                mEp->ep.name      = mEp->name;
+                mEp->ep.ops       = &usb_ep_ops;
+                mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
+
+                /* this allocation cannot be random */
+                for (k = RX; k <= TX; k++) {
+                        INIT_LIST_HEAD(&mEp->qh[k].queue);
+                        mEp->qh[k].ptr = dma_pool_alloc(udc->qh_pool,
+                                                        GFP_KERNEL,
+                                                        &mEp->qh[k].dma);
+                        if (mEp->qh[k].ptr == NULL)
+                                retval = -ENOMEM;
+                        else
+                                memset(mEp->qh[k].ptr, 0,
+                                       sizeof(*mEp->qh[k].ptr));
+                }
+                if (i == 0)
+                        udc->gadget.ep0 = &mEp->ep;
+                else
+                        list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list);
+        }
+        if (retval)
+                goto done;
+
+        /* bind gadget */
+        driver->driver.bus     = NULL;
+        udc->gadget.ops        = &usb_gadget_ops;
+        udc->gadget.dev.driver = &driver->driver;
+
+        spin_unlock_irqrestore(udc->lock, flags);
+        retval = driver->bind(&udc->gadget);                /* MAY SLEEP */
+        spin_lock_irqsave(udc->lock, flags);
+
+        if (retval) {
+                udc->gadget.ops        = NULL;
+                udc->gadget.dev.driver = NULL;
+                goto done;
+        }
+
+        retval = hw_device_state(udc->ci13xxx_ep[0].qh[RX].dma);
+
+ done:
+        spin_unlock_irqrestore(udc->lock, flags);
+        if (retval)
+                usb_gadget_unregister_driver(driver);
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+/**
+ * usb_gadget_unregister_driver: unregister a gadget driver
+ *
+ * Check usb_gadget_unregister_driver() at "usb_gadget.h" for details
+ */
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct ci13xxx *udc = _udc;
+        unsigned long i, k, flags;
+
+        trace("%p", driver);
+
+        if (driver             == NULL ||
+            driver->bind       == NULL ||
+            driver->unbind     == NULL ||
+            driver->setup      == NULL ||
+            driver->disconnect == NULL ||
+            driver->suspend    == NULL ||
+            driver->resume     == NULL ||
+            driver             != udc->driver)
+                return -EINVAL;
+
+        spin_lock_irqsave(udc->lock, flags);
+
+        hw_device_state(0);
+
+        /* unbind gadget */
+        if (udc->gadget.ops != NULL) {
+                _gadget_stop_activity(&udc->gadget);
+
+                spin_unlock_irqrestore(udc->lock, flags);
+                driver->unbind(&udc->gadget);               /* MAY SLEEP */
+                spin_lock_irqsave(udc->lock, flags);
+
+                udc->gadget.ops        = NULL;
+                udc->gadget.dev.driver = NULL;
+        }
+
+        /* free resources */
+        for (i = 0; i < hw_ep_max; i++) {
+                struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i];
+
+                if (i == 0)
+                        udc->gadget.ep0 = NULL;
+                else if (!list_empty(&mEp->ep.ep_list))
+                        list_del_init(&mEp->ep.ep_list);
+
+                for (k = RX; k <= TX; k++)
+                        if (mEp->qh[k].ptr != NULL)
+                                dma_pool_free(udc->qh_pool,
+                                              mEp->qh[k].ptr, mEp->qh[k].dma);
+        }
+
+        udc->driver = NULL;
+
+        spin_unlock_irqrestore(udc->lock, flags);
+
+        if (udc->td_pool != NULL) {
+                dma_pool_destroy(udc->td_pool);
+                udc->td_pool = NULL;
+        }
+        if (udc->qh_pool != NULL) {
+                dma_pool_destroy(udc->qh_pool);
+                udc->qh_pool = NULL;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/******************************************************************************
+ * BUS block
+ *****************************************************************************/
+/**
+ * udc_irq: global interrupt handler
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * It locks access to registers
+ */
+static irqreturn_t udc_irq(void)
+{
+        struct ci13xxx *udc = _udc;
+        irqreturn_t retval;
+        u32 intr;
+
+        trace();
+
+        if (udc == NULL) {
+                err("ENODEV");
+                return IRQ_HANDLED;
+        }
+
+        spin_lock(udc->lock);
+        intr = hw_test_and_clear_intr_active();
+        if (intr) {
+                isr_statistics.hndl.buf[isr_statistics.hndl.idx++] = intr;
+                isr_statistics.hndl.idx &= ISR_MASK;
+                isr_statistics.hndl.cnt++;
+
+                /* order defines priority - do NOT change it */
+                if (USBi_URI & intr) {
+                        isr_statistics.uri++;
+                        isr_reset_handler(udc);
+                }
+                if (USBi_PCI & intr) {
+                        isr_statistics.pci++;
+                        udc->gadget.speed = hw_port_is_high_speed() ?
+                                USB_SPEED_HIGH : USB_SPEED_FULL;
+                }
+                if (USBi_UEI & intr)
+                        isr_statistics.uei++;
+                if (USBi_UI  & intr) {
+                        isr_statistics.ui++;
+                        isr_tr_complete_handler(udc);
+                }
+                if (USBi_SLI & intr)
+                        isr_statistics.sli++;
+                retval = IRQ_HANDLED;
+        } else {
+                isr_statistics.none++;
+                retval = IRQ_NONE;
+        }
+        spin_unlock(udc->lock);
+
+        return retval;
+}
+
+/**
+ * udc_release: driver release function
+ * @dev: device
+ *
+ * Currently does nothing
+ */
+static void udc_release(struct device *dev)
+{
+        trace("%p", dev);
+
+        if (dev == NULL)
+                err("EINVAL");
+}
+
+/**
+ * udc_probe: parent probe must call this to initialize UDC
+ * @dev:  parent device
+ * @regs: registers base address
+ * @name: driver name
+ *
+ * This function returns an error code
+ * No interrupts active, the IRQ has not been requested yet
+ * Kernel assumes 32-bit DMA operations by default, no need to dma_set_mask
+ */
+static int udc_probe(struct device *dev, void __iomem *regs, const char *name)
+{
+        struct ci13xxx *udc;
+        int retval = 0;
+
+        trace("%p, %p, %p", dev, regs, name);
+
+        if (dev == NULL || regs == NULL || name == NULL)
+                return -EINVAL;
+
+        udc = kzalloc(sizeof(struct ci13xxx), GFP_KERNEL);
+        if (udc == NULL)
+                return -ENOMEM;
+
+        udc->lock = &udc_lock;
+
+        retval = hw_device_reset(regs);
+        if (retval)
+                goto done;
+
+        udc->gadget.ops          = NULL;
+        udc->gadget.speed        = USB_SPEED_UNKNOWN;
+        udc->gadget.is_dualspeed = 1;
+        udc->gadget.is_otg       = 0;
+        udc->gadget.name         = name;
+
+        INIT_LIST_HEAD(&udc->gadget.ep_list);
+        udc->gadget.ep0 = NULL;
+
+        strcpy(udc->gadget.dev.bus_id, "gadget");
+        udc->gadget.dev.dma_mask = dev->dma_mask;
+        udc->gadget.dev.parent   = dev;
+        udc->gadget.dev.release  = udc_release;
+
+        retval = device_register(&udc->gadget.dev);
+        if (retval)
+                goto done;
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        retval = dbg_create_files(&udc->gadget.dev);
+#endif
+        if (retval) {
+                device_unregister(&udc->gadget.dev);
+                goto done;
+        }
+
+        _udc = udc;
+        return retval;
+
+ done:
+        err("error = %i", retval);
+        kfree(udc);
+        _udc = NULL;
+        return retval;
+}
+
+/**
+ * udc_remove: parent remove must call this to remove UDC
+ *
+ * No interrupts active, the IRQ has been released
+ */
+static void udc_remove(void)
+{
+        struct ci13xxx *udc = _udc;
+
+        if (udc == NULL) {
+                err("EINVAL");
+                return;
+        }
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        dbg_remove_files(&udc->gadget.dev);
+#endif
+        device_unregister(&udc->gadget.dev);
+
+        kfree(udc);
+        _udc = NULL;
+}
+
+/******************************************************************************
+ * PCI block
+ *****************************************************************************/
+/**
+ * ci13xxx_pci_irq: interrut handler
+ * @irq:  irq number
+ * @pdev: USB Device Controller interrupt source
+ *
+ * This function returns IRQ_HANDLED if the IRQ has been handled
+ * This is an ISR don't trace, use attribute interface instead
+ */
+static irqreturn_t ci13xxx_pci_irq(int irq, void *pdev)
+{
+        if (irq == 0) {
+                dev_err(&((struct pci_dev *)pdev)->dev, "Invalid IRQ0 usage!");
+                return IRQ_HANDLED;
+        }
+        return udc_irq();
+}
+
+/**
+ * ci13xxx_pci_probe: PCI probe
+ * @pdev: USB device controller being probed
+ * @id:   PCI hotplug ID connecting controller to UDC framework
+ *
+ * This function returns an error code
+ * Allocates basic PCI resources for this USB device controller, and then
+ * invokes the udc_probe() method to start the UDC associated with it
+ */
+static int __devinit ci13xxx_pci_probe(struct pci_dev *pdev,
+                                       const struct pci_device_id *id)
+{
+        void __iomem *regs = NULL;
+        int retval = 0;
+
+        if (id == NULL)
+                return -EINVAL;
+
+        retval = pci_enable_device(pdev);
+        if (retval)
+                goto done;
+
+        if (!pdev->irq) {
+                dev_err(&pdev->dev, "No IRQ, check BIOS/PCI setup!");
+                retval = -ENODEV;
+                goto disable_device;
+        }
+
+        retval = pci_request_regions(pdev, UDC_DRIVER_NAME);
+        if (retval)
+                goto disable_device;
+
+        /* BAR 0 holds all the registers */
+        regs = pci_iomap(pdev, 0, 0);
+        if (!regs) {
+                dev_err(&pdev->dev, "Error mapping memory!");
+                retval = -EFAULT;
+                goto release_regions;
+        }
+        pci_set_drvdata(pdev, (__force void *)regs);
+
+        pci_set_master(pdev);
+        pci_try_set_mwi(pdev);
+
+        retval = udc_probe(&pdev->dev, regs, UDC_DRIVER_NAME);
+        if (retval)
+                goto iounmap;
+
+        /* our device does not have MSI capability */
+
+        retval = request_irq(pdev->irq, ci13xxx_pci_irq, IRQF_SHARED,
+                             UDC_DRIVER_NAME, pdev);
+        if (retval)
+                goto gadget_remove;
+
+        return 0;
+
+ gadget_remove:
+        udc_remove();
+ iounmap:
+        pci_iounmap(pdev, regs);
+ release_regions:
+        pci_release_regions(pdev);
+ disable_device:
+        pci_disable_device(pdev);
+ done:
+        return retval;
+}
+
+/**
+ * ci13xxx_pci_remove: PCI remove
+ * @pdev: USB Device Controller being removed
+ *
+ * Reverses the effect of ci13xxx_pci_probe(),
+ * first invoking the udc_remove() and then releases
+ * all PCI resources allocated for this USB device controller
+ */
+static void __devexit ci13xxx_pci_remove(struct pci_dev *pdev)
+{
+        free_irq(pdev->irq, pdev);
+        udc_remove();
+        pci_iounmap(pdev, (__force void __iomem *)pci_get_drvdata(pdev));
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+}
+
+/**
+ * PCI device table
+ * PCI device structure
+ *
+ * Check "pci.h" for details
+ */
+static DEFINE_PCI_DEVICE_TABLE(ci13xxx_pci_id_table) = {
+        { PCI_DEVICE(0x153F, 0x1004) },
+        { PCI_DEVICE(0x153F, 0x1006) },
+        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE(pci, ci13xxx_pci_id_table);
+
+static struct pci_driver ci13xxx_pci_driver = {
+        .name         = UDC_DRIVER_NAME,
+        .id_table     = ci13xxx_pci_id_table,
+        .probe        = ci13xxx_pci_probe,
+        .remove       = __devexit_p(ci13xxx_pci_remove),
+};
+
+/**
+ * ci13xxx_pci_init: module init
+ *
+ * Driver load
+ */
+static int __init ci13xxx_pci_init(void)
+{
+        return pci_register_driver(&ci13xxx_pci_driver);
+}
+module_init(ci13xxx_pci_init);
+
+/**
+ * ci13xxx_pci_exit: module exit
+ *
+ * Driver unload
+ */
+static void __exit ci13xxx_pci_exit(void)
+{
+        pci_unregister_driver(&ci13xxx_pci_driver);
+}
+module_exit(ci13xxx_pci_exit);
+
+MODULE_AUTHOR("MIPS - David Lopo <dlopo@chipidea.mips.com>");
+MODULE_DESCRIPTION("MIPS CI13XXX USB Peripheral Controller");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("June 2008");
diff --git a/drivers/usb/gadget/ci13xxx_udc.h b/drivers/usb/gadget/ci13xxx_udc.h
new file mode 100644
index 000000000000..4026e9cede34
--- /dev/null
+++ b/drivers/usb/gadget/ci13xxx_udc.h
@@ -0,0 +1,195 @@
+/*
+ * ci13xxx_udc.h - structures, registers, and macros MIPS USB IP core
+ *
+ * Copyright (C) 2008 Chipidea - MIPS Technologies, Inc. All rights reserved.
+ *
+ * Author: David Lopo
+ *
+ * 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.
+ *
+ * Description: MIPS USB IP core family device controller
+ *              Structures, registers and logging macros
+ */
+
+#ifndef _CI13XXX_h_
+#define _CI13XXX_h_
+
+/******************************************************************************
+ * DEFINE
+ *****************************************************************************/
+#define ENDPT_MAX          (16)
+#define CTRL_PAYLOAD_MAX   (64)
+#define RX        (0)  /* similar to USB_DIR_OUT but can be used as an index */
+#define TX        (1)  /* similar to USB_DIR_IN  but can be used as an index */
+
+/******************************************************************************
+ * STRUCTURES
+ *****************************************************************************/
+/* DMA layout of transfer descriptors */
+struct ci13xxx_td {
+        /* 0 */
+        u32 next;
+#define TD_TERMINATE          BIT(0)
+        /* 1 */
+        u32 token;
+#define TD_STATUS             (0x00FFUL <<  0)
+#define TD_STATUS_TR_ERR      BIT(3)
+#define TD_STATUS_DT_ERR      BIT(5)
+#define TD_STATUS_HALTED      BIT(6)
+#define TD_STATUS_ACTIVE      BIT(7)
+#define TD_MULTO              (0x0003UL << 10)
+#define TD_IOC                BIT(15)
+#define TD_TOTAL_BYTES        (0x7FFFUL << 16)
+        /* 2 */
+        u32 page[5];
+#define TD_CURR_OFFSET        (0x0FFFUL <<  0)
+#define TD_FRAME_NUM          (0x07FFUL <<  0)
+#define TD_RESERVED_MASK      (0x0FFFUL <<  0)
+} __attribute__ ((packed));
+
+/* DMA layout of queue heads */
+struct ci13xxx_qh {
+        /* 0 */
+        u32 cap;
+#define QH_IOS                BIT(15)
+#define QH_MAX_PKT            (0x07FFUL << 16)
+#define QH_ZLT                BIT(29)
+#define QH_MULT               (0x0003UL << 30)
+        /* 1 */
+        u32 curr;
+        /* 2 - 8 */
+        struct ci13xxx_td        td;
+        /* 9 */
+        u32 RESERVED;
+        struct usb_ctrlrequest   setup;
+} __attribute__ ((packed));
+
+/* Extension of usb_request */
+struct ci13xxx_req {
+        struct usb_request   req;
+        unsigned             map;
+        struct list_head     queue;
+        struct ci13xxx_td   *ptr;
+        dma_addr_t           dma;
+};
+
+/* Extension of usb_ep */
+struct ci13xxx_ep {
+        struct usb_ep                          ep;
+        const struct usb_endpoint_descriptor  *desc;
+        u8                                     dir;
+        u8                                     num;
+        u8                                     type;
+        char                                   name[16];
+        struct {
+                struct list_head   queue;
+                struct ci13xxx_qh *ptr;
+                dma_addr_t         dma;
+        }                                      qh[2];
+        struct usb_request                    *status;
+        int                                    wedge;
+
+        /* global resources */
+        spinlock_t                            *lock;
+        struct device                         *device;
+        struct dma_pool                       *td_pool;
+};
+
+/* CI13XXX UDC descriptor & global resources */
+struct ci13xxx {
+        spinlock_t                *lock;      /* ctrl register bank access */
+
+        struct dma_pool           *qh_pool;   /* DMA pool for queue heads */
+        struct dma_pool           *td_pool;   /* DMA pool for transfer descs */
+
+        struct usb_gadget          gadget;     /* USB slave device */
+        struct ci13xxx_ep          ci13xxx_ep[ENDPT_MAX]; /* extended endpts */
+
+        struct usb_gadget_driver  *driver;     /* 3rd party gadget driver */
+};
+
+/******************************************************************************
+ * REGISTERS
+ *****************************************************************************/
+/* register size */
+#define REG_BITS   (32)
+
+/* HCCPARAMS */
+#define HCCPARAMS_LEN         BIT(17)
+
+/* DCCPARAMS */
+#define DCCPARAMS_DEN         (0x1F << 0)
+#define DCCPARAMS_DC          BIT(7)
+
+/* TESTMODE */
+#define TESTMODE_FORCE        BIT(0)
+
+/* USBCMD */
+#define USBCMD_RS             BIT(0)
+#define USBCMD_RST            BIT(1)
+#define USBCMD_SUTW           BIT(13)
+
+/* USBSTS & USBINTR */
+#define USBi_UI               BIT(0)
+#define USBi_UEI              BIT(1)
+#define USBi_PCI              BIT(2)
+#define USBi_URI              BIT(6)
+#define USBi_SLI              BIT(8)
+
+/* DEVICEADDR */
+#define DEVICEADDR_USBADRA    BIT(24)
+#define DEVICEADDR_USBADR     (0x7FUL << 25)
+
+/* PORTSC */
+#define PORTSC_SUSP           BIT(7)
+#define PORTSC_HSP            BIT(9)
+#define PORTSC_PTC            (0x0FUL << 16)
+
+/* DEVLC */
+#define DEVLC_PSPD            (0x03UL << 25)
+#define    DEVLC_PSPD_HS      (0x02UL << 25)
+
+/* USBMODE */
+#define USBMODE_CM            (0x03UL <<  0)
+#define    USBMODE_CM_IDLE    (0x00UL <<  0)
+#define    USBMODE_CM_DEVICE  (0x02UL <<  0)
+#define    USBMODE_CM_HOST    (0x03UL <<  0)
+#define USBMODE_SLOM          BIT(3)
+
+/* ENDPTCTRL */
+#define ENDPTCTRL_RXS         BIT(0)
+#define ENDPTCTRL_RXT         (0x03UL <<  2)
+#define ENDPTCTRL_RXR         BIT(6)         /* reserved for port 0 */
+#define ENDPTCTRL_RXE         BIT(7)
+#define ENDPTCTRL_TXS         BIT(16)
+#define ENDPTCTRL_TXT         (0x03UL << 18)
+#define ENDPTCTRL_TXR         BIT(22)        /* reserved for port 0 */
+#define ENDPTCTRL_TXE         BIT(23)
+
+/******************************************************************************
+ * LOGGING
+ *****************************************************************************/
+#define ci13xxx_printk(level, format, args...) \
+do { \
+        if (_udc == NULL) \
+                printk(level "[%s] " format "\n", __func__, ## args); \
+        else \
+                dev_printk(level, _udc->gadget.dev.parent, \
+                           "[%s] " format "\n", __func__, ## args); \
+} while (0)
+
+#define err(format, args...)    ci13xxx_printk(KERN_ERR, format, ## args)
+#define warn(format, args...)   ci13xxx_printk(KERN_WARNING, format, ## args)
+#define info(format, args...)   ci13xxx_printk(KERN_INFO, format, ## args)
+
+#ifdef TRACE
+#define trace(format, args...)      ci13xxx_printk(KERN_DEBUG, format, ## args)
+#define dbg_trace(format, args...)  dev_dbg(dev, format, ##args)
+#else
+#define trace(format, args...)      do {} while (0)
+#define dbg_trace(format, args...)  do {} while (0)
+#endif
+
+#endif  /* _CI13XXX_h_ */
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 9462e30192d8..a36b1175b18d 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -161,7 +161,7 @@ ep_matches (
         /* report address */
         desc->bEndpointAddress &= USB_DIR_IN;
         if (isdigit (ep->name [2])) {
-                u8      num = simple_strtol (&ep->name [2], NULL, 10);
+                u8      num = simple_strtoul (&ep->name [2], NULL, 10);
                 desc->bEndpointAddress |= num;
 #ifdef  MANY_ENDPOINTS
         } else if (desc->bEndpointAddress & USB_DIR_IN) {
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index 2e71368f45b4..b10fa31cc915 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -1,7 +1,7 @@
 /*
  * file_storage.c -- File-backed USB Storage Gadget, for USB development
  *
- * Copyright (C) 2003-2007 Alan Stern
+ * Copyright (C) 2003-2008 Alan Stern
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -38,16 +38,17 @@
 
 /*
  * The File-backed Storage Gadget acts as a USB Mass Storage device,
- * appearing to the host as a disk drive.  In addition to providing an
- * example of a genuinely useful gadget driver for a USB device, it also
- * illustrates a technique of double-buffering for increased throughput.
- * Last but not least, it gives an easy way to probe the behavior of the
- * Mass Storage drivers in a USB host.
+ * appearing to the host as a disk drive or as a CD-ROM drive.  In addition
+ * to providing an example of a genuinely useful gadget driver for a USB
+ * device, it also illustrates a technique of double-buffering for increased
+ * throughput.  Last but not least, it gives an easy way to probe the
+ * behavior of the Mass Storage drivers in a USB host.
  *
  * Backing storage is provided by a regular file or a block device, specified
  * by the "file" module parameter.  Access can be limited to read-only by
- * setting the optional "ro" module parameter.  The gadget will indicate that
- * it has removable media if the optional "removable" module parameter is set.
+ * setting the optional "ro" module parameter.  (For CD-ROM emulation,
+ * access is always read-only.)  The gadget will indicate that it has
+ * removable media if the optional "removable" module parameter is set.
  *
  * The gadget supports the Control-Bulk (CB), Control-Bulk-Interrupt (CBI),
  * and Bulk-Only (also known as Bulk-Bulk-Bulk or BBB) transports, selected
@@ -64,7 +65,12 @@
  * The default number of LUNs is taken from the number of "file" elements;
  * it is 1 if "file" is not given.  If "removable" is not set then a backing
  * file must be specified for each LUN.  If it is set, then an unspecified
- * or empty backing filename means the LUN's medium is not loaded.
+ * or empty backing filename means the LUN's medium is not loaded.  Ideally
+ * each LUN would be settable independently as a disk drive or a CD-ROM
+ * drive, but currently all LUNs have to be the same type.  The CD-ROM
+ * emulation includes a single data track and no audio tracks; hence there
+ * need be only one backing file per LUN.  Note also that the CD-ROM block
+ * length is set to 512 rather than the more common value 2048.
  *
  * Requirements are modest; only a bulk-in and a bulk-out endpoint are
  * needed (an interrupt-out endpoint is also needed for CBI).  The memory
@@ -91,6 +97,8 @@
  *                                      USB device controller (usually true),
  *                                      boolean to permit the driver to halt
  *                                      bulk endpoints
+ *      cdrom                   Default false, boolean for whether to emulate
+ *                                      a CD-ROM drive
  *      transport=XXX           Default BBB, transport name (CB, CBI, or BBB)
  *      protocol=YYY            Default SCSI, protocol name (RBC, 8020 or
  *                                      ATAPI, QIC, UFI, 8070, or SCSI;
@@ -103,15 +111,16 @@
  *                                      PAGE_CACHE_SIZE)
  *
  * If CONFIG_USB_FILE_STORAGE_TEST is not set, only the "file", "ro",
- * "removable", "luns", and "stall" options are available; default values
- * are used for everything else.
+ * "removable", "luns", "stall", and "cdrom" options are available; default
+ * values are used for everything else.
  *
  * The pathnames of the backing files and the ro settings are available in
  * the attribute files "file" and "ro" in the lun<n> subdirectory of the
  * gadget's sysfs directory.  If the "removable" option is set, writing to
  * these files will simulate ejecting/loading the medium (writing an empty
  * line means eject) and adjusting a write-enable tab.  Changes to the ro
- * setting are not allowed when the medium is loaded.
+ * setting are not allowed when the medium is loaded or if CD-ROM emulation
+ * is being used.
  *
  * This gadget driver is heavily based on "Gadget Zero" by David Brownell.
  * The driver's SCSI command interface was based on the "Information
@@ -261,7 +270,7 @@
 
 #define DRIVER_DESC             "File-backed Storage Gadget"
 #define DRIVER_NAME             "g_file_storage"
-#define DRIVER_VERSION          "7 August 2007"
+#define DRIVER_VERSION          "20 November 2008"
 
 static const char longname[] = DRIVER_DESC;
 static const char shortname[] = DRIVER_NAME;
@@ -341,6 +350,7 @@ static struct {
 
         int             removable;
         int             can_stall;
+        int             cdrom;
 
         char            *transport_parm;
         char            *protocol_parm;
@@ -359,6 +369,7 @@ static struct {
         .protocol_parm          = "SCSI",
         .removable              = 0,
         .can_stall              = 1,
+        .cdrom                  = 0,
         .vendor                 = DRIVER_VENDOR_ID,
         .product                = DRIVER_PRODUCT_ID,
         .release                = 0xffff,       // Use controller chip type
@@ -382,6 +393,9 @@ MODULE_PARM_DESC(removable, "true to simulate removable media");
 module_param_named(stall, mod_data.can_stall, bool, S_IRUGO);
 MODULE_PARM_DESC(stall, "false to prevent bulk stalls");
 
+module_param_named(cdrom, mod_data.cdrom, bool, S_IRUGO);
+MODULE_PARM_DESC(cdrom, "true to emulate cdrom instead of disk");
+
 
 /* In the non-TEST version, only the module parameters listed above
  * are available. */
@@ -411,6 +425,10 @@ MODULE_PARM_DESC(buflen, "I/O buffer size");
 
 /*-------------------------------------------------------------------------*/
 
+/* SCSI device types */
+#define TYPE_DISK       0x00
+#define TYPE_CDROM      0x05
+
 /* USB protocol value = the transport method */
 #define USB_PR_CBI      0x00            // Control/Bulk/Interrupt
 #define USB_PR_CB       0x01            // Control/Bulk w/o interrupt
@@ -487,6 +505,8 @@ struct interrupt_data {
 #define SC_READ_12                      0xa8
 #define SC_READ_CAPACITY                0x25
 #define SC_READ_FORMAT_CAPACITIES       0x23
+#define SC_READ_HEADER                  0x44
+#define SC_READ_TOC                     0x43
 #define SC_RELEASE                      0x17
 #define SC_REQUEST_SENSE                0x03
 #define SC_RESERVE                      0x16
@@ -2006,23 +2026,28 @@ static int do_inquiry(struct fsg_dev *fsg, struct fsg_buffhd *bh)
         u8      *buf = (u8 *) bh->buf;
 
         static char vendor_id[] = "Linux   ";
-        static char product_id[] = "File-Stor Gadget";
+        static char product_disk_id[] = "File-Stor Gadget";
+        static char product_cdrom_id[] = "File-CD Gadget  ";
 
         if (!fsg->curlun) {             // Unsupported LUNs are okay
                 fsg->bad_lun_okay = 1;
                 memset(buf, 0, 36);
                 buf[0] = 0x7f;          // Unsupported, no device-type
+                buf[4] = 31;            // Additional length
                 return 36;
         }
 
-        memset(buf, 0, 8);      // Non-removable, direct-access device
+        memset(buf, 0, 8);
+        buf[0] = (mod_data.cdrom ? TYPE_CDROM : TYPE_DISK);
         if (mod_data.removable)
                 buf[1] = 0x80;
         buf[2] = 2;             // ANSI SCSI level 2
         buf[3] = 2;             // SCSI-2 INQUIRY data format
         buf[4] = 31;            // Additional length
                                 // No special options
-        sprintf(buf + 8, "%-8s%-16s%04x", vendor_id, product_id,
+        sprintf(buf + 8, "%-8s%-16s%04x", vendor_id,
+                        (mod_data.cdrom ? product_cdrom_id :
+                                product_disk_id),
                         mod_data.release);
         return 36;
 }
@@ -2101,6 +2126,75 @@ static int do_read_capacity(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 }
 
 
+static void store_cdrom_address(u8 *dest, int msf, u32 addr)
+{
+        if (msf) {
+                /* Convert to Minutes-Seconds-Frames */
+                addr >>= 2;             /* Convert to 2048-byte frames */
+                addr += 2*75;           /* Lead-in occupies 2 seconds */
+                dest[3] = addr % 75;    /* Frames */
+                addr /= 75;
+                dest[2] = addr % 60;    /* Seconds */
+                addr /= 60;
+                dest[1] = addr;         /* Minutes */
+                dest[0] = 0;            /* Reserved */
+        } else {
+                /* Absolute sector */
+                put_be32(dest, addr);
+        }
+}
+
+static int do_read_header(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+{
+        struct lun      *curlun = fsg->curlun;
+        int             msf = fsg->cmnd[1] & 0x02;
+        u32             lba = get_be32(&fsg->cmnd[2]);
+        u8              *buf = (u8 *) bh->buf;
+
+        if ((fsg->cmnd[1] & ~0x02) != 0) {              /* Mask away MSF */
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+        if (lba >= curlun->num_sectors) {
+                curlun->sense_data = SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE;
+                return -EINVAL;
+        }
+
+        memset(buf, 0, 8);
+        buf[0] = 0x01;          /* 2048 bytes of user data, rest is EC */
+        store_cdrom_address(&buf[4], msf, lba);
+        return 8;
+}
+
+
+static int do_read_toc(struct fsg_dev *fsg, struct fsg_buffhd *bh)
+{
+        struct lun      *curlun = fsg->curlun;
+        int             msf = fsg->cmnd[1] & 0x02;
+        int             start_track = fsg->cmnd[6];
+        u8              *buf = (u8 *) bh->buf;
+
+        if ((fsg->cmnd[1] & ~0x02) != 0 ||              /* Mask away MSF */
+                        start_track > 1) {
+                curlun->sense_data = SS_INVALID_FIELD_IN_CDB;
+                return -EINVAL;
+        }
+
+        memset(buf, 0, 20);
+        buf[1] = (20-2);                /* TOC data length */
+        buf[2] = 1;                     /* First track number */
+        buf[3] = 1;                     /* Last track number */
+        buf[5] = 0x16;                  /* Data track, copying allowed */
+        buf[6] = 0x01;                  /* Only track is number 1 */
+        store_cdrom_address(&buf[8], msf, 0);
+
+        buf[13] = 0x16;                 /* Lead-out track is data */
+        buf[14] = 0xAA;                 /* Lead-out track number */
+        store_cdrom_address(&buf[16], msf, curlun->num_sectors);
+        return 20;
+}
+
+
 static int do_mode_sense(struct fsg_dev *fsg, struct fsg_buffhd *bh)
 {
         struct lun      *curlun = fsg->curlun;
@@ -2848,6 +2942,26 @@ static int do_scsi_command(struct fsg_dev *fsg)
                         reply = do_read_capacity(fsg, bh);
                 break;
 
+        case SC_READ_HEADER:
+                if (!mod_data.cdrom)
+                        goto unknown_cmnd;
+                fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
+                if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
+                                (3<<7) | (0x1f<<1), 1,
+                                "READ HEADER")) == 0)
+                        reply = do_read_header(fsg, bh);
+                break;
+
+        case SC_READ_TOC:
+                if (!mod_data.cdrom)
+                        goto unknown_cmnd;
+                fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
+                if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
+                                (7<<6) | (1<<1), 1,
+                                "READ TOC")) == 0)
+                        reply = do_read_toc(fsg, bh);
+                break;
+
         case SC_READ_FORMAT_CAPACITIES:
                 fsg->data_size_from_cmnd = get_be16(&fsg->cmnd[7]);
                 if ((reply = check_command(fsg, 10, DATA_DIR_TO_HOST,
@@ -2933,6 +3047,7 @@ static int do_scsi_command(struct fsg_dev *fsg)
                 // Fall through
 
         default:
+ unknown_cmnd:
                 fsg->data_size_from_cmnd = 0;
                 sprintf(unknown, "Unknown x%02x", fsg->cmnd[0]);
                 if ((reply = check_command(fsg, fsg->cmnd_size,
@@ -3498,6 +3613,7 @@ static int open_backing_file(struct lun *curlun, const char *filename)
         struct inode                    *inode = NULL;
         loff_t                          size;
         loff_t                          num_sectors;
+        loff_t                          min_sectors;
 
         /* R/W if we can, R/O if we must */
         ro = curlun->ro;
@@ -3541,8 +3657,19 @@ static int open_backing_file(struct lun *curlun, const char *filename)
                 rc = (int) size;
                 goto out;
         }
-        num_sectors = size >> 9;        // File size in 512-byte sectors
-        if (num_sectors == 0) {
+        num_sectors = size >> 9;        // File size in 512-byte blocks
+        min_sectors = 1;
+        if (mod_data.cdrom) {
+                num_sectors &= ~3;      // Reduce to a multiple of 2048
+                min_sectors = 300*4;    // Smallest track is 300 frames
+                if (num_sectors >= 256*60*75*4) {
+                        num_sectors = (256*60*75 - 1) * 4;
+                        LINFO(curlun, "file too big: %s\n", filename);
+                        LINFO(curlun, "using only first %d blocks\n",
+                                        (int) num_sectors);
+                }
+        }
+        if (num_sectors < min_sectors) {
                 LINFO(curlun, "file too small: %s\n", filename);
                 rc = -ETOOSMALL;
                 goto out;
@@ -3845,9 +3972,12 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 goto out;
 
         if (mod_data.removable) {       // Enable the store_xxx attributes
-                dev_attr_ro.attr.mode = dev_attr_file.attr.mode = 0644;
-                dev_attr_ro.store = store_ro;
+                dev_attr_file.attr.mode = 0644;
                 dev_attr_file.store = store_file;
+                if (!mod_data.cdrom) {
+                        dev_attr_ro.attr.mode = 0644;
+                        dev_attr_ro.store = store_ro;
+                }
         }
 
         /* Find out how many LUNs there should be */
@@ -3872,6 +4002,8 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         for (i = 0; i < fsg->nluns; ++i) {
                 curlun = &fsg->luns[i];
                 curlun->ro = mod_data.ro[i];
+                if (mod_data.cdrom)
+                        curlun->ro = 1;
                 curlun->dev.release = lun_release;
                 curlun->dev.parent = &gadget->dev;
                 curlun->dev.driver = &fsg_driver.driver;
@@ -4031,9 +4163,9 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                         mod_data.protocol_name, mod_data.protocol_type);
         DBG(fsg, "VendorID=x%04x, ProductID=x%04x, Release=x%04x\n",
                         mod_data.vendor, mod_data.product, mod_data.release);
-        DBG(fsg, "removable=%d, stall=%d, buflen=%u\n",
+        DBG(fsg, "removable=%d, stall=%d, cdrom=%d, buflen=%u\n",
                         mod_data.removable, mod_data.can_stall,
-                        mod_data.buflen);
+                        mod_data.cdrom, mod_data.buflen);
         DBG(fsg, "I/O thread pid: %d\n", task_pid_nr(fsg->thread_task));
 
         set_bit(REGISTERED, &fsg->atomic_bitflags);
@@ -4050,6 +4182,7 @@ out:
         fsg->state = FSG_STATE_TERMINATED;      // The thread is dead
         fsg_unbind(gadget);
         close_all_backing_files(fsg);
+        complete(&fsg->thread_notifier);
         return rc;
 }
 
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index b3408ff39fba..d6c5bcd40064 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -26,6 +26,7 @@
 #include <linux/ioport.h>
 #include <linux/types.h>
 #include <linux/errno.h>
+#include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
@@ -370,6 +371,9 @@ static int qe_ep_bd_init(struct qe_udc *udc, unsigned char pipe_num)
         /* alloc multi-ram for BD rings and set the ep parameters */
         tmp_addr = cpm_muram_alloc(sizeof(struct qe_bd) * (bdring_len +
                                 USB_BDRING_LEN_TX), QE_ALIGNMENT_OF_BD);
+        if (IS_ERR_VALUE(tmp_addr))
+                return -ENOMEM;
+
         out_be16(&epparam->rbase, (u16)tmp_addr);
         out_be16(&epparam->tbase, (u16)(tmp_addr +
                                 (sizeof(struct qe_bd) * bdring_len)));
@@ -689,7 +693,7 @@ en_done2:
 en_done1:
         spin_unlock_irqrestore(&udc->lock, flags);
 en_done:
-        dev_dbg(udc->dev, "failed to initialize %s\n", ep->ep.name);
+        dev_err(udc->dev, "failed to initialize %s\n", ep->ep.name);
         return -ENODEV;
 }
 
@@ -2408,6 +2412,8 @@ static struct qe_udc __devinit *qe_udc_config(struct of_device *ofdev)
         tmp_addr = cpm_muram_alloc((USB_MAX_ENDPOINTS *
                                         sizeof(struct usb_ep_para)),
                                            USB_EP_PARA_ALIGNMENT);
+        if (IS_ERR_VALUE(tmp_addr))
+                goto cleanup;
 
         for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
                 out_be16(&usbpram->epptr[i], (u16)tmp_addr);
@@ -2513,7 +2519,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
         /* Initialize the udc structure including QH member and other member */
         udc_controller = qe_udc_config(ofdev);
         if (!udc_controller) {
-                dev_dbg(&ofdev->dev, "udc_controll is NULL\n");
+                dev_err(&ofdev->dev, "failed to initialize\n");
                 return -ENOMEM;
         }
 
@@ -2545,7 +2551,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
 
         device_initialize(&udc_controller->gadget.dev);
 
-        strcpy(udc_controller->gadget.dev.bus_id, "gadget");
+        dev_set_name(&udc_controller->gadget.dev, "gadget");
 
         udc_controller->gadget.dev.release = qe_udc_release;
         udc_controller->gadget.dev.parent = &ofdev->dev;
@@ -2568,7 +2574,7 @@ static int __devinit qe_udc_probe(struct of_device *ofdev,
         /* create a buf for ZLP send, need to remain zeroed */
         udc_controller->nullbuf = kzalloc(256, GFP_KERNEL);
         if (udc_controller->nullbuf == NULL) {
-                dev_dbg(udc_controller->dev, "cannot alloc nullbuf\n");
+                dev_err(udc_controller->dev, "cannot alloc nullbuf\n");
                 ret = -ENOMEM;
                 goto err3;
         }
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index 4e3107dd2f34..ec6d439a2aa5 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -110,7 +110,6 @@
 #define gadget_is_at91(g)       0
 #endif
 
-/* status unclear */
 #ifdef CONFIG_USB_GADGET_IMX
 #define gadget_is_imx(g)        !strcmp("imx_udc", (g)->name)
 #else
@@ -158,6 +157,11 @@
 #define gadget_is_fsl_qe(g)     0
 #endif
 
+#ifdef CONFIG_USB_GADGET_CI13XXX
+#define gadget_is_ci13xxx(g)    (!strcmp("ci13xxx_udc", (g)->name))
+#else
+#define gadget_is_ci13xxx(g)    0
+#endif
 
 // CONFIG_USB_GADGET_SX2
 // CONFIG_USB_GADGET_AU1X00
@@ -225,6 +229,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x21;
         else if (gadget_is_fsl_qe(gadget))
                 return 0x22;
+        else if (gadget_is_ci13xxx(gadget))
+                return 0x23;
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 60aa04847b18..63419c4d503c 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1349,7 +1349,7 @@ int usb_gadget_register_driver(struct usb_gadget_driver *driver)
         int                     retval;
 
         if (!driver
-                        || driver->speed != USB_SPEED_FULL
+                        || driver->speed < USB_SPEED_FULL
                         || !driver->bind
                         || !driver->disconnect
                         || !driver->setup)
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
new file mode 100644
index 000000000000..cde8fdf15d5b
--- /dev/null
+++ b/drivers/usb/gadget/imx_udc.c
@@ -0,0 +1,1516 @@
+/*
+ *      driver/usb/gadget/imx_udc.c
+ *
+ *      Copyright (C) 2005 Mike Lee(eemike@gmail.com)
+ *      Copyright (C) 2008 Darius Augulis <augulis.darius@gmail.com>
+ *
+ *      This program is free software; you can redistribute it and/or modify
+ *      it under the terms of the GNU General Public License as published by
+ *      the Free Software Foundation; either version 2 of the License, or
+ *      (at your option) any later version.
+ *
+ *      This program is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *      GNU General Public License for more details.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include <mach/usb.h>
+#include <mach/hardware.h>
+
+#include "imx_udc.h"
+
+static const char driver_name[] = "imx_udc";
+static const char ep0name[] = "ep0";
+
+void ep0_chg_stat(const char *label, struct imx_udc_struct *imx_usb,
+                                                        enum ep0_state stat);
+
+/*******************************************************************************
+ * IMX UDC hardware related functions
+ *******************************************************************************
+ */
+
+void imx_udc_enable(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_CTRL);
+        __raw_writel(temp | CTRL_FE_ENA | CTRL_AFE_ENA, imx_usb->base + USB_CTRL);
+        imx_usb->gadget.speed = USB_SPEED_FULL;
+}
+
+void imx_udc_disable(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_CTRL);
+
+        __raw_writel(temp & ~(CTRL_FE_ENA | CTRL_AFE_ENA),
+                 imx_usb->base + USB_CTRL);
+
+        ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
+        imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+}
+
+void imx_udc_reset(struct imx_udc_struct *imx_usb)
+{
+        int temp = __raw_readl(imx_usb->base + USB_ENAB);
+
+        /* set RST bit */
+        __raw_writel(temp | ENAB_RST, imx_usb->base + USB_ENAB);
+
+        /* wait RST bit to clear */
+        do {} while (__raw_readl(imx_usb->base + USB_ENAB) & ENAB_RST);
+
+        /* wait CFG bit to assert */
+        do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
+
+        /* udc module is now ready */
+}
+
+void imx_udc_config(struct imx_udc_struct *imx_usb)
+{
+        u8 ep_conf[5];
+        u8 i, j, cfg;
+        struct imx_ep_struct *imx_ep;
+
+        /* wait CFG bit to assert */
+        do {} while (!(__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG));
+
+        /* Download the endpoint buffer for endpoint 0. */
+        for (j = 0; j < 5; j++) {
+                i = (j == 2 ? imx_usb->imx_ep[0].fifosize : 0x00);
+                __raw_writeb(i, imx_usb->base + USB_DDAT);
+                do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_BSY);
+        }
+
+        /* Download the endpoint buffers for endpoints 1-5.
+         * We specify two configurations, one interface
+         */
+        for (cfg = 1; cfg < 3; cfg++) {
+                for (i = 1; i < IMX_USB_NB_EP; i++) {
+                        imx_ep = &imx_usb->imx_ep[i];
+                        /* EP no | Config no */
+                        ep_conf[0] = (i << 4) | (cfg << 2);
+                        /* Type | Direction */
+                        ep_conf[1] = (imx_ep->bmAttributes << 3) |
+                                        (EP_DIR(imx_ep) << 2);
+                        /* Max packet size */
+                        ep_conf[2] = imx_ep->fifosize;
+                        /* TRXTYP */
+                        ep_conf[3] = 0xC0;
+                        /* FIFO no */
+                        ep_conf[4] = i;
+
+                        D_INI(imx_usb->dev,
+                                "<%s> ep%d_conf[%d]:"
+                                "[%02x-%02x-%02x-%02x-%02x]\n",
+                                __func__, i, cfg,
+                                ep_conf[0], ep_conf[1], ep_conf[2],
+                                ep_conf[3], ep_conf[4]);
+
+                        for (j = 0; j < 5; j++) {
+                                __raw_writeb(ep_conf[j],
+                                        imx_usb->base + USB_DDAT);
+                                do {} while (__raw_readl(imx_usb->base + USB_DADR)
+                                        & DADR_BSY);
+                        }
+                }
+        }
+
+        /* wait CFG bit to clear */
+        do {} while (__raw_readl(imx_usb->base + USB_DADR) & DADR_CFG);
+}
+
+void imx_udc_init_irq(struct imx_udc_struct *imx_usb)
+{
+        int i;
+
+        /* Mask and clear all irqs */
+        __raw_writel(0xFFFFFFFF, imx_usb->base + USB_MASK);
+        __raw_writel(0xFFFFFFFF, imx_usb->base + USB_INTR);
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                __raw_writel(0x1FF, imx_usb->base + USB_EP_MASK(i));
+                __raw_writel(0x1FF, imx_usb->base + USB_EP_INTR(i));
+        }
+
+        /* Enable USB irqs */
+        __raw_writel(INTR_MSOF | INTR_FRAME_MATCH, imx_usb->base + USB_MASK);
+
+        /* Enable EP0 irqs */
+        __raw_writel(0x1FF & ~(EPINTR_DEVREQ | EPINTR_MDEVREQ | EPINTR_EOT
+                | EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL),
+                imx_usb->base + USB_EP_MASK(0));
+}
+
+void imx_udc_init_ep(struct imx_udc_struct *imx_usb)
+{
+        int i, max, temp;
+        struct imx_ep_struct *imx_ep;
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+                switch (imx_ep->fifosize) {
+                case 8:
+                        max = 0;
+                        break;
+                case 16:
+                        max = 1;
+                        break;
+                case 32:
+                        max = 2;
+                        break;
+                case 64:
+                        max = 3;
+                        break;
+                default:
+                        max = 1;
+                        break;
+                }
+                temp = (EP_DIR(imx_ep) << 7) | (max << 5)
+                        | (imx_ep->bmAttributes << 3);
+                __raw_writel(temp, imx_usb->base + USB_EP_STAT(i));
+                __raw_writel(temp | EPSTAT_FLUSH, imx_usb->base + USB_EP_STAT(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_stat %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_STAT(i)));
+        }
+}
+
+void imx_udc_init_fifo(struct imx_udc_struct *imx_usb)
+{
+        int i, temp;
+        struct imx_ep_struct *imx_ep;
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+
+                /* Fifo control */
+                temp = EP_DIR(imx_ep) ? 0x0B000000 : 0x0F000000;
+                __raw_writel(temp, imx_usb->base + USB_EP_FCTRL(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_fctrl %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_FCTRL(i)));
+
+                /* Fifo alarm */
+                temp = (i ? imx_ep->fifosize / 2 : 0);
+                __raw_writel(temp, imx_usb->base + USB_EP_FALRM(i));
+                D_INI(imx_usb->dev, "<%s> ep%d_falrm %08x\n", __func__, i,
+                        __raw_readl(imx_usb->base + USB_EP_FALRM(i)));
+        }
+}
+
+static void imx_udc_init(struct imx_udc_struct *imx_usb)
+{
+        /* Reset UDC */
+        imx_udc_reset(imx_usb);
+
+        /* Download config to enpoint buffer */
+        imx_udc_config(imx_usb);
+
+        /* Setup interrups */
+        imx_udc_init_irq(imx_usb);
+
+        /* Setup endpoints */
+        imx_udc_init_ep(imx_usb);
+
+        /* Setup fifos */
+        imx_udc_init_fifo(imx_usb);
+}
+
+void imx_ep_irq_enable(struct imx_ep_struct *imx_ep)
+{
+
+        int i = EP_NO(imx_ep);
+
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
+        __raw_writel(0x1FF & ~(EPINTR_EOT | EPINTR_EOF),
+                imx_ep->imx_usb->base + USB_EP_MASK(i));
+}
+
+void imx_ep_irq_disable(struct imx_ep_struct *imx_ep)
+{
+
+        int i = EP_NO(imx_ep);
+
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_MASK(i));
+        __raw_writel(0x1FF, imx_ep->imx_usb->base + USB_EP_INTR(i));
+}
+
+int imx_ep_empty(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        return __raw_readl(imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
+                        & FSTAT_EMPTY;
+}
+
+unsigned imx_fifo_bcount(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        return (__raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)))
+                        & EPSTAT_BCOUNT) >> 16;
+}
+
+void imx_flush(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+
+        int temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+        __raw_writel(temp | EPSTAT_FLUSH,
+                imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+}
+
+void imx_ep_stall(struct imx_ep_struct *imx_ep)
+{
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+        int temp, i;
+
+        D_ERR(imx_usb->dev, "<%s> Forced stall on %s\n", __func__, imx_ep->ep.name);
+
+        imx_flush(imx_ep);
+
+        /* Special care for ep0 */
+        if (EP_NO(imx_ep)) {
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp | CTRL_CMDOVER | CTRL_CMDERROR, imx_usb->base + USB_CTRL);
+                do { } while (__raw_readl(imx_usb->base + USB_CTRL) & CTRL_CMDOVER);
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp & ~CTRL_CMDERROR, imx_usb->base + USB_CTRL);
+        }
+        else {
+                temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                __raw_writel(temp | EPSTAT_STALL,
+                        imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+
+                for (i = 0; i < 100; i ++) {
+                        temp = __raw_readl(imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+                        if (!temp & EPSTAT_STALL)
+                                break;
+                        udelay(20);
+                }
+                if (i == 50)
+                        D_ERR(imx_usb->dev, "<%s> Non finished stall on %s\n",
+                                __func__, imx_ep->ep.name);
+        }
+}
+
+static int imx_udc_get_frame(struct usb_gadget *_gadget)
+{
+        struct imx_udc_struct *imx_usb = container_of(_gadget,
+                        struct imx_udc_struct, gadget);
+
+        return __raw_readl(imx_usb->base + USB_FRAME) & 0x7FF;
+}
+
+static int imx_udc_wakeup(struct usb_gadget *_gadget)
+{
+        return 0;
+}
+
+/*******************************************************************************
+ * USB request control functions
+ *******************************************************************************
+ */
+
+static void ep_add_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        if (unlikely(!req))
+                return;
+
+        req->in_use = 1;
+        list_add_tail(&req->queue, &imx_ep->queue);
+}
+
+static void ep_del_request(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        if (unlikely(!req))
+                return;
+
+        list_del_init(&req->queue);
+        req->in_use = 0;
+}
+
+static void done(struct imx_ep_struct *imx_ep, struct imx_request *req, int status)
+{
+        ep_del_request(imx_ep, req);
+
+        if (likely(req->req.status == -EINPROGRESS))
+                req->req.status = status;
+        else
+                status = req->req.status;
+
+        if (status && status != -ESHUTDOWN)
+                D_ERR(imx_ep->imx_usb->dev,
+                        "<%s> complete %s req %p stat %d len %u/%u\n", __func__,
+                        imx_ep->ep.name, &req->req, status,
+                        req->req.actual, req->req.length);
+
+        req->req.complete(&imx_ep->ep, &req->req);
+}
+
+static void nuke(struct imx_ep_struct *imx_ep, int status)
+{
+        struct imx_request *req;
+
+        while (!list_empty(&imx_ep->queue)) {
+                req = list_entry(imx_ep->queue.next, struct imx_request, queue);
+                done(imx_ep, req, status);
+        }
+}
+
+/*******************************************************************************
+ * Data tansfer over USB functions
+ *******************************************************************************
+ */
+static int read_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        u8      *buf;
+        int     bytes_ep, bufferspace, count, i;
+
+        bytes_ep = imx_fifo_bcount(imx_ep);
+        bufferspace = req->req.length - req->req.actual;
+
+        buf = req->req.buf + req->req.actual;
+        prefetchw(buf);
+
+        if (unlikely(imx_ep_empty(imx_ep)))
+                count = 0;      /* zlp */
+        else
+                count = min(bytes_ep, bufferspace);
+
+        for (i = count; i > 0; i--)
+                *buf++ = __raw_readb(imx_ep->imx_usb->base
+                                                + USB_EP_FDAT0(EP_NO(imx_ep)));
+        req->req.actual += count;
+
+        return count;
+}
+
+static int write_packet(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        u8      *buf;
+        int     length, count, temp;
+
+        buf = req->req.buf + req->req.actual;
+        prefetch(buf);
+
+        length = min(req->req.length - req->req.actual, (u32)imx_ep->fifosize);
+
+        if (imx_fifo_bcount(imx_ep) + length > imx_ep->fifosize) {
+                D_TRX(imx_ep->imx_usb->dev, "<%s> packet overfill %s fifo\n",
+                        __func__, imx_ep->ep.name);
+                return -1;
+        }
+
+        req->req.actual += length;
+        count = length;
+
+        if (!count && req->req.zero) {  /* zlp */
+                temp = __raw_readl(imx_ep->imx_usb->base
+                        + USB_EP_STAT(EP_NO(imx_ep)));
+                __raw_writel(temp | EPSTAT_ZLPS, imx_ep->imx_usb->base
+                        + USB_EP_STAT(EP_NO(imx_ep)));
+                D_TRX(imx_ep->imx_usb->dev, "<%s> zero packet\n", __func__);
+                return 0;
+        }
+
+        while (count--) {
+                if (count == 0) {       /* last byte */
+                        temp = __raw_readl(imx_ep->imx_usb->base
+                                + USB_EP_FCTRL(EP_NO(imx_ep)));
+                        __raw_writel(temp | FCTRL_WFR, imx_ep->imx_usb->base
+                                + USB_EP_FCTRL(EP_NO(imx_ep)));
+                }
+                __raw_writeb(*buf++,
+                        imx_ep->imx_usb->base + USB_EP_FDAT0(EP_NO(imx_ep)));
+        }
+
+        return length;
+}
+
+static int read_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        int     bytes = 0,
+                count,
+                completed = 0;
+
+        while (__raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)))
+                & FSTAT_FR) {
+                        count = read_packet(imx_ep, req);
+                        bytes += count;
+
+                        completed = (count != imx_ep->fifosize);
+                        if (completed || req->req.actual == req->req.length) {
+                                completed = 1;
+                                break;
+                        }
+        }
+
+        if (completed || !req->req.length) {
+                done(imx_ep, req, 0);
+                D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
+                        __func__, imx_ep->ep.name, req,
+                        completed ? "completed" : "not completed");
+                if (!EP_NO(imx_ep))
+                        ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
+        }
+
+        D_TRX(imx_ep->imx_usb->dev, "<%s> bytes read: %d\n", __func__, bytes);
+
+        return completed;
+}
+
+static int write_fifo(struct imx_ep_struct *imx_ep, struct imx_request *req)
+{
+        int     bytes = 0,
+                count,
+                completed = 0;
+
+        while (!completed) {
+                count = write_packet(imx_ep, req);
+                if (count < 0)
+                        break; /* busy */
+                bytes += count;
+
+                /* last packet "must be" short (or a zlp) */
+                completed = (count != imx_ep->fifosize);
+
+                if (unlikely(completed)) {
+                        done(imx_ep, req, 0);
+                        D_REQ(imx_ep->imx_usb->dev, "<%s> %s req<%p> %s\n",
+                                __func__, imx_ep->ep.name, req,
+                                completed ? "completed" : "not completed");
+                        if (!EP_NO(imx_ep))
+                                ep0_chg_stat(__func__, imx_ep->imx_usb, EP0_IDLE);
+                }
+        }
+
+        D_TRX(imx_ep->imx_usb->dev, "<%s> bytes sent: %d\n", __func__, bytes);
+
+        return completed;
+}
+
+/*******************************************************************************
+ * Endpoint handlers
+ *******************************************************************************
+ */
+static int handle_ep(struct imx_ep_struct *imx_ep)
+{
+        struct imx_request *req;
+        int completed = 0;
+
+        do {
+                if (!list_empty(&imx_ep->queue))
+                        req = list_entry(imx_ep->queue.next,
+                                struct imx_request, queue);
+                else {
+                        D_REQ(imx_ep->imx_usb->dev, "<%s> no request on %s\n",
+                                __func__, imx_ep->ep.name);
+                        return 0;
+                }
+
+                if (EP_DIR(imx_ep))     /* to host */
+                        completed = write_fifo(imx_ep, req);
+                else                    /* to device */
+                        completed = read_fifo(imx_ep, req);
+
+                dump_ep_stat(__func__, imx_ep);
+
+        } while (completed);
+
+        return 0;
+}
+
+static int handle_ep0(struct imx_ep_struct *imx_ep)
+{
+        struct imx_request *req = NULL;
+        int ret = 0;
+
+        if (!list_empty(&imx_ep->queue))
+                req = list_entry(imx_ep->queue.next, struct imx_request, queue);
+
+        if (req) {
+                switch (imx_ep->imx_usb->ep0state) {
+
+                case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR */
+                        write_fifo(imx_ep, req);
+                        break;
+                case EP0_OUT_DATA_PHASE:                /* SET_DESCRIPTOR */
+                        read_fifo(imx_ep, req);
+                        break;
+                default:
+                        D_EP0(imx_ep->imx_usb->dev,
+                                "<%s> ep0 i/o, odd state %d\n",
+                                __func__, imx_ep->imx_usb->ep0state);
+                        ep_del_request(imx_ep, req);
+                        ret = -EL2HLT;
+                        break;
+                }
+        }
+
+        return ret;
+}
+
+static void handle_ep0_devreq(struct imx_udc_struct *imx_usb)
+{
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[0];
+        union {
+                struct usb_ctrlrequest  r;
+                u8                      raw[8];
+                u32                     word[2];
+        } u;
+        int temp, i;
+
+        nuke(imx_ep, -EPROTO);
+
+        /* read SETUP packet */
+        for (i = 0; i < 2; i++) {
+                if (imx_ep_empty(imx_ep)) {
+                        D_ERR(imx_usb->dev,
+                                "<%s> no setup packet received\n", __func__);
+                        goto stall;
+                }
+                u.word[i] = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
+        }
+
+        temp = imx_ep_empty(imx_ep);
+        while (!imx_ep_empty(imx_ep)) {
+                i = __raw_readl(imx_usb->base + USB_EP_FDAT(EP_NO(imx_ep)));
+                D_ERR(imx_usb->dev,
+                        "<%s> wrong to have extra bytes for setup : 0x%08x\n",
+                        __func__, i);
+        }
+        if (!temp)
+                goto stall;
+
+        le16_to_cpus(&u.r.wValue);
+        le16_to_cpus(&u.r.wIndex);
+        le16_to_cpus(&u.r.wLength);
+
+        D_REQ(imx_usb->dev, "<%s> SETUP %02x.%02x v%04x i%04x l%04x\n",
+                __func__, u.r.bRequestType, u.r.bRequest,
+                u.r.wValue, u.r.wIndex, u.r.wLength);
+
+        if (imx_usb->set_config) {
+                /* NACK the host by using CMDOVER */
+                temp = __raw_readl(imx_usb->base + USB_CTRL);
+                __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
+
+                D_ERR(imx_usb->dev,
+                        "<%s> set config req is pending, NACK the host\n",
+                        __func__);
+                return;
+        }
+
+        if (u.r.bRequestType & USB_DIR_IN)
+                ep0_chg_stat(__func__, imx_usb, EP0_IN_DATA_PHASE);
+        else
+                ep0_chg_stat(__func__, imx_usb, EP0_OUT_DATA_PHASE);
+
+        i = imx_usb->driver->setup(&imx_usb->gadget, &u.r);
+        if (i < 0) {
+                D_ERR(imx_usb->dev, "<%s> device setup error %d\n",
+                        __func__, i);
+                goto stall;
+        }
+
+        return;
+stall:
+        D_ERR(imx_usb->dev, "<%s> protocol STALL\n", __func__);
+        imx_ep_stall(imx_ep);
+        ep0_chg_stat(__func__, imx_usb, EP0_STALL);
+        return;
+}
+
+/*******************************************************************************
+ * USB gadget callback functions
+ *******************************************************************************
+ */
+
+static int imx_ep_enable(struct usb_ep *usb_ep,
+                                const struct usb_endpoint_descriptor *desc)
+{
+        struct imx_ep_struct *imx_ep = container_of(usb_ep,
+                                                struct imx_ep_struct, ep);
+        struct imx_udc_struct *imx_usb = imx_ep->imx_usb;
+        unsigned long flags;
+
+        if (!usb_ep
+                || !desc
+                || !EP_NO(imx_ep)
+                || desc->bDescriptorType != USB_DT_ENDPOINT
+                || imx_ep->bEndpointAddress != desc->bEndpointAddress) {
+                        D_ERR(imx_usb->dev,
+                                "<%s> bad ep or descriptor\n", __func__);
+                        return -EINVAL;
+        }
+
+        if (imx_ep->bmAttributes != desc->bmAttributes) {
+                D_ERR(imx_usb->dev,
+                        "<%s> %s type mismatch\n", __func__, usb_ep->name);
+                return -EINVAL;
+        }
+
+        if (imx_ep->fifosize < le16_to_cpu(desc->wMaxPacketSize)) {
+                D_ERR(imx_usb->dev,
+                        "<%s> bad %s maxpacket\n", __func__, usb_ep->name);
+                return -ERANGE;
+        }
+
+        if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
+                D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
+                return -ESHUTDOWN;
+        }
+
+        local_irq_save(flags);
+
+        imx_ep->stopped = 0;
+        imx_flush(imx_ep);
+        imx_ep_irq_enable(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_usb->dev, "<%s> ENABLED %s\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static int imx_ep_disable(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of(usb_ep,
+                                                struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> %s can not be disabled\n",
+                        __func__, usb_ep ? imx_ep->ep.name : NULL);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        imx_ep->stopped = 1;
+        nuke(imx_ep, -ESHUTDOWN);
+        imx_flush(imx_ep);
+        imx_ep_irq_disable(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_ep->imx_usb->dev,
+                "<%s> DISABLED %s\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static struct usb_request *imx_ep_alloc_request
+                                        (struct usb_ep *usb_ep, gfp_t gfp_flags)
+{
+        struct imx_request *req;
+
+        req = kzalloc(sizeof *req, gfp_flags);
+        if (!req || !usb_ep)
+                return 0;
+
+        INIT_LIST_HEAD(&req->queue);
+        req->in_use = 0;
+
+        return &req->req;
+}
+
+static void imx_ep_free_request
+                        (struct usb_ep *usb_ep, struct usb_request *usb_req)
+{
+        struct imx_request *req;
+
+        req = container_of(usb_req, struct imx_request, req);
+        WARN_ON(!list_empty(&req->queue));
+        kfree(req);
+}
+
+static int imx_ep_queue
+        (struct usb_ep *usb_ep, struct usb_request *usb_req, gfp_t gfp_flags)
+{
+        struct imx_ep_struct    *imx_ep;
+        struct imx_udc_struct   *imx_usb;
+        struct imx_request      *req;
+        unsigned long           flags;
+        int                     ret = 0;
+
+        imx_ep = container_of(usb_ep, struct imx_ep_struct, ep);
+        imx_usb = imx_ep->imx_usb;
+        req = container_of(usb_req, struct imx_request, req);
+
+        /*
+          Special care on IMX udc.
+          Ignore enqueue when after set configuration from the
+          host. This assume all gadget drivers reply set
+          configuration with the next ep0 req enqueue.
+        */
+        if (imx_usb->set_config && !EP_NO(imx_ep)) {
+                imx_usb->set_config = 0;
+                D_EPX(imx_usb->dev,
+                        "<%s> gadget reply set config\n", __func__);
+                return 0;
+        }
+
+        if (unlikely(!usb_req || !req || !usb_req->complete || !usb_req->buf)) {
+                D_ERR(imx_usb->dev, "<%s> bad params\n", __func__);
+                return -EINVAL;
+        }
+
+        if (unlikely(!usb_ep || !imx_ep)) {
+                D_ERR(imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        if (!imx_usb->driver || imx_usb->gadget.speed == USB_SPEED_UNKNOWN) {
+                D_ERR(imx_usb->dev, "<%s> bogus device state\n", __func__);
+                return -ESHUTDOWN;
+        }
+
+        local_irq_save(flags);
+
+        /* Debug */
+        D_REQ(imx_usb->dev, "<%s> ep%d %s request for [%d] bytes\n",
+                __func__, EP_NO(imx_ep),
+                ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                || (EP_NO(imx_ep) && EP_DIR(imx_ep))) ? "IN" : "OUT", usb_req->length);
+        dump_req(__func__, imx_ep, usb_req);
+
+        if (imx_ep->stopped) {
+                usb_req->status = -ESHUTDOWN;
+                ret = -ESHUTDOWN;
+                goto out;
+        }
+
+        if (req->in_use) {
+                D_ERR(imx_usb->dev,
+                        "<%s> refusing to queue req %p (already queued)\n",
+                        __func__, req);
+                goto out;
+        }
+
+        usb_req->status = -EINPROGRESS;
+        usb_req->actual = 0;
+
+        ep_add_request(imx_ep, req);
+
+        if (!EP_NO(imx_ep))
+                ret = handle_ep0(imx_ep);
+        else
+                ret = handle_ep(imx_ep);
+out:
+        local_irq_restore(flags);
+        return ret;
+}
+
+static int imx_ep_dequeue(struct usb_ep *usb_ep, struct usb_request *usb_req)
+{
+
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        struct imx_request *req;
+        unsigned long flags;
+
+        if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        /* make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &imx_ep->queue, queue) {
+                if (&req->req == usb_req)
+                        break;
+        }
+        if (&req->req != usb_req) {
+                local_irq_restore(flags);
+                return -EINVAL;
+        }
+
+        done(imx_ep, req, -ECONNRESET);
+
+        local_irq_restore(flags);
+        return 0;
+}
+
+static int imx_ep_set_halt(struct usb_ep *usb_ep, int value)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        if (unlikely(!usb_ep || !EP_NO(imx_ep))) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -EINVAL;
+        }
+
+        local_irq_save(flags);
+
+        if ((imx_ep->bEndpointAddress & USB_DIR_IN)
+                && !list_empty(&imx_ep->queue)) {
+                        local_irq_restore(flags);
+                        return -EAGAIN;
+        }
+
+        imx_ep_stall(imx_ep);
+
+        local_irq_restore(flags);
+
+        D_EPX(imx_ep->imx_usb->dev, "<%s> %s halt\n", __func__, usb_ep->name);
+        return 0;
+}
+
+static int imx_ep_fifo_status(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+
+        if (!usb_ep) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                return -ENODEV;
+        }
+
+        if (imx_ep->imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
+                return 0;
+        else
+                return imx_fifo_bcount(imx_ep);
+}
+
+static void imx_ep_fifo_flush(struct usb_ep *usb_ep)
+{
+        struct imx_ep_struct *imx_ep = container_of
+                                        (usb_ep, struct imx_ep_struct, ep);
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        if (!usb_ep || !EP_NO(imx_ep) || !list_empty(&imx_ep->queue)) {
+                D_ERR(imx_ep->imx_usb->dev, "<%s> bad ep\n", __func__);
+                local_irq_restore(flags);
+                return;
+        }
+
+        /* toggle and halt bits stay unchanged */
+        imx_flush(imx_ep);
+
+        local_irq_restore(flags);
+}
+
+static struct usb_ep_ops imx_ep_ops = {
+        .enable         = imx_ep_enable,
+        .disable        = imx_ep_disable,
+
+        .alloc_request  = imx_ep_alloc_request,
+        .free_request   = imx_ep_free_request,
+
+        .queue          = imx_ep_queue,
+        .dequeue        = imx_ep_dequeue,
+
+        .set_halt       = imx_ep_set_halt,
+        .fifo_status    = imx_ep_fifo_status,
+        .fifo_flush     = imx_ep_fifo_flush,
+};
+
+/*******************************************************************************
+ * USB endpoint control functions
+ *******************************************************************************
+ */
+
+void ep0_chg_stat(const char *label,
+                        struct imx_udc_struct *imx_usb, enum ep0_state stat)
+{
+        D_EP0(imx_usb->dev, "<%s> from %15s to %15s\n",
+                label, state_name[imx_usb->ep0state], state_name[stat]);
+
+        if (imx_usb->ep0state == stat)
+                return;
+
+        imx_usb->ep0state = stat;
+}
+
+static void usb_init_data(struct imx_udc_struct *imx_usb)
+{
+        struct imx_ep_struct *imx_ep;
+        u8 i;
+
+        /* device/ep0 records init */
+        INIT_LIST_HEAD(&imx_usb->gadget.ep_list);
+        INIT_LIST_HEAD(&imx_usb->gadget.ep0->ep_list);
+        ep0_chg_stat(__func__, imx_usb, EP0_IDLE);
+
+        /* basic endpoint records init */
+        for (i = 0; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+
+                if (i) {
+                        list_add_tail(&imx_ep->ep.ep_list,
+                                &imx_usb->gadget.ep_list);
+                        imx_ep->stopped = 1;
+                } else
+                        imx_ep->stopped = 0;
+
+                INIT_LIST_HEAD(&imx_ep->queue);
+        }
+}
+
+static void udc_stop_activity(struct imx_udc_struct *imx_usb,
+                                        struct usb_gadget_driver *driver)
+{
+        struct imx_ep_struct *imx_ep;
+        int i;
+
+        if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN)
+                driver = NULL;
+
+        /* prevent new request submissions, kill any outstanding requests  */
+        for (i = 1; i < IMX_USB_NB_EP; i++) {
+                imx_ep = &imx_usb->imx_ep[i];
+                imx_flush(imx_ep);
+                imx_ep->stopped = 1;
+                imx_ep_irq_disable(imx_ep);
+                nuke(imx_ep, -ESHUTDOWN);
+        }
+
+        imx_usb->cfg = 0;
+        imx_usb->intf = 0;
+        imx_usb->alt = 0;
+
+        if (driver)
+                driver->disconnect(&imx_usb->gadget);
+}
+
+/*******************************************************************************
+ * Interrupt handlers
+ *******************************************************************************
+ */
+
+static irqreturn_t imx_udc_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        struct usb_ctrlrequest u;
+        int temp, cfg, intf, alt;
+        int intr = __raw_readl(imx_usb->base + USB_INTR);
+
+        if (intr & (INTR_WAKEUP | INTR_SUSPEND | INTR_RESUME | INTR_RESET_START
+                        | INTR_RESET_STOP | INTR_CFG_CHG)) {
+                                dump_intr(__func__, intr, imx_usb->dev);
+                                dump_usb_stat(__func__, imx_usb);
+        }
+
+        if (!imx_usb->driver) {
+                /*imx_udc_disable(imx_usb);*/
+                goto end_irq;
+        }
+
+        if (intr & INTR_WAKEUP) {
+                if (imx_usb->gadget.speed == USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->resume)
+                                imx_usb->driver->resume(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_FULL;
+        }
+
+        if (intr & INTR_SUSPEND) {
+                if (imx_usb->gadget.speed != USB_SPEED_UNKNOWN
+                        && imx_usb->driver && imx_usb->driver->suspend)
+                                imx_usb->driver->suspend(&imx_usb->gadget);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+
+        if (intr & INTR_RESET_START) {
+                __raw_writel(intr, imx_usb->base + USB_INTR);
+                udc_stop_activity(imx_usb, imx_usb->driver);
+                imx_usb->set_config = 0;
+                imx_usb->gadget.speed = USB_SPEED_UNKNOWN;
+        }
+
+        if (intr & INTR_RESET_STOP)
+                imx_usb->gadget.speed = USB_SPEED_FULL;
+
+        if (intr & INTR_CFG_CHG) {
+                __raw_writel(INTR_CFG_CHG, imx_usb->base + USB_INTR);
+                temp = __raw_readl(imx_usb->base + USB_STAT);
+                cfg  = (temp & STAT_CFG) >> 5;
+                intf = (temp & STAT_INTF) >> 3;
+                alt  =  temp & STAT_ALTSET;
+
+                D_REQ(imx_usb->dev,
+                        "<%s> orig config C=%d, I=%d, A=%d / "
+                        "req config C=%d, I=%d, A=%d\n",
+                        __func__, imx_usb->cfg, imx_usb->intf, imx_usb->alt,
+                        cfg, intf, alt);
+
+                if (cfg != 1 && cfg != 2)
+                        goto end_irq;
+
+                imx_usb->set_config = 0;
+
+                /* Config setup */
+                if (imx_usb->cfg != cfg) {
+                        D_REQ(imx_usb->dev, "<%s> Change config start\n",__func__);
+                        u.bRequest = USB_REQ_SET_CONFIGURATION;
+                        u.bRequestType = USB_DIR_OUT |
+                                        USB_TYPE_STANDARD |
+                                        USB_RECIP_DEVICE;
+                        u.wValue = cfg;
+                        u.wIndex = 0;
+                        u.wLength = 0;
+                        imx_usb->cfg = cfg;
+                        imx_usb->set_config = 1;
+                        imx_usb->driver->setup(&imx_usb->gadget, &u);
+                        imx_usb->set_config = 0;
+                        D_REQ(imx_usb->dev, "<%s> Change config done\n",__func__);
+
+                }
+                if (imx_usb->intf != intf || imx_usb->alt != alt) {
+                        D_REQ(imx_usb->dev, "<%s> Change interface start\n",__func__);
+                        u.bRequest = USB_REQ_SET_INTERFACE;
+                        u.bRequestType = USB_DIR_OUT |
+                                          USB_TYPE_STANDARD |
+                                          USB_RECIP_INTERFACE;
+                        u.wValue = alt;
+                        u.wIndex = intf;
+                        u.wLength = 0;
+                        imx_usb->intf = intf;
+                        imx_usb->alt = alt;
+                        imx_usb->set_config = 1;
+                        imx_usb->driver->setup(&imx_usb->gadget, &u);
+                        imx_usb->set_config = 0;
+                        D_REQ(imx_usb->dev, "<%s> Change interface done\n",__func__);
+                }
+        }
+
+        if (intr & INTR_SOF) {
+                if (imx_usb->ep0state == EP0_IDLE) {
+                        temp = __raw_readl(imx_usb->base + USB_CTRL);
+                        __raw_writel(temp | CTRL_CMDOVER, imx_usb->base + USB_CTRL);
+                }
+        }
+
+end_irq:
+        __raw_writel(intr, imx_usb->base + USB_INTR);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t imx_udc_ctrl_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        int intr = __raw_readl(imx_usb->base + USB_EP_INTR(0));
+
+        dump_ep_intr(__func__, 0, intr, imx_usb->dev);
+
+        if (!imx_usb->driver) {
+                __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
+                return IRQ_HANDLED;
+        }
+
+        /* DEVREQ IRQ has highest priority */
+        if (intr & (EPINTR_DEVREQ | EPINTR_MDEVREQ))
+                handle_ep0_devreq(imx_usb);
+        /* Seem i.MX is missing EOF interrupt sometimes.
+         * Therefore we monitor both EOF and FIFO_EMPTY interrups
+         * when transmiting, and both EOF and FIFO_FULL when
+         * receiving data.
+         */
+        else if (intr & (EPINTR_EOF | EPINTR_FIFO_EMPTY | EPINTR_FIFO_FULL))
+                handle_ep0(&imx_usb->imx_ep[0]);
+
+        __raw_writel(intr, imx_usb->base + USB_EP_INTR(0));
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t imx_udc_bulk_irq(int irq, void *dev)
+{
+        struct imx_udc_struct *imx_usb = dev;
+        struct imx_ep_struct *imx_ep = &imx_usb->imx_ep[irq - USBD_INT0];
+        int intr = __raw_readl(imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+        dump_ep_intr(__func__, irq - USBD_INT0, intr, imx_usb->dev);
+
+        if (!imx_usb->driver) {
+                __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+                return IRQ_HANDLED;
+        }
+
+        handle_ep(imx_ep);
+
+        __raw_writel(intr, imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+        return IRQ_HANDLED;
+}
+
+irq_handler_t intr_handler(int i)
+{
+        switch (i) {
+        case 0:
+                return imx_udc_ctrl_irq;
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+                return imx_udc_bulk_irq;
+        default:
+                return imx_udc_irq;
+        }
+}
+
+/*******************************************************************************
+ * Static defined IMX UDC structure
+ *******************************************************************************
+ */
+
+static const struct usb_gadget_ops imx_udc_ops = {
+        .get_frame       = imx_udc_get_frame,
+        .wakeup          = imx_udc_wakeup,
+};
+
+static struct imx_udc_struct controller = {
+        .gadget = {
+                .ops            = &imx_udc_ops,
+                .ep0            = &controller.imx_ep[0].ep,
+                .name           = driver_name,
+                .dev = {
+                         .bus_id        = "gadget",
+                 },
+        },
+
+        .imx_ep[0] = {
+                .ep = {
+                        .name           = ep0name,
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = 0,
+                .bmAttributes           = USB_ENDPOINT_XFER_CONTROL,
+         },
+        .imx_ep[1] = {
+                .ep = {
+                        .name           = "ep1in-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 64,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 64,
+                .bEndpointAddress       = USB_DIR_IN | 1,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[2] = {
+                .ep = {
+                        .name           = "ep2out-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 64,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 64,
+                .bEndpointAddress       = USB_DIR_OUT | 2,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[3] = {
+                .ep = {
+                        .name           = "ep3out-bulk",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_OUT | 3,
+                .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+         },
+        .imx_ep[4] = {
+                .ep = {
+                        .name           = "ep4in-int",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                 },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_IN | 4,
+                .bmAttributes           = USB_ENDPOINT_XFER_INT,
+         },
+        .imx_ep[5] = {
+                .ep = {
+                        .name           = "ep5out-int",
+                        .ops            = &imx_ep_ops,
+                        .maxpacket      = 32,
+                },
+                .imx_usb                = &controller,
+                .fifosize               = 32,
+                .bEndpointAddress       = USB_DIR_OUT | 5,
+                .bmAttributes           = USB_ENDPOINT_XFER_INT,
+         },
+};
+
+/*******************************************************************************
+ * USB gadged driver functions
+ *******************************************************************************
+ */
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+        int retval;
+
+        if (!driver
+                || driver->speed < USB_SPEED_FULL
+                || !driver->bind
+                || !driver->disconnect
+                || !driver->setup)
+                        return -EINVAL;
+        if (!imx_usb)
+                return -ENODEV;
+        if (imx_usb->driver)
+                return -EBUSY;
+
+        /* first hook up the driver ... */
+        imx_usb->driver = driver;
+        imx_usb->gadget.dev.driver = &driver->driver;
+
+        retval = device_add(&imx_usb->gadget.dev);
+        if (retval)
+                goto fail;
+        retval = driver->bind(&imx_usb->gadget);
+        if (retval) {
+                D_ERR(imx_usb->dev, "<%s> bind to driver %s --> error %d\n",
+                        __func__, driver->driver.name, retval);
+                device_del(&imx_usb->gadget.dev);
+
+                goto fail;
+        }
+
+        D_INI(imx_usb->dev, "<%s> registered gadget driver '%s'\n",
+                __func__, driver->driver.name);
+
+        imx_udc_enable(imx_usb);
+
+        return 0;
+fail:
+        imx_usb->driver = NULL;
+        imx_usb->gadget.dev.driver = NULL;
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+
+        if (!imx_usb)
+                return -ENODEV;
+        if (!driver || driver != imx_usb->driver || !driver->unbind)
+                return -EINVAL;
+
+        udc_stop_activity(imx_usb, driver);
+        imx_udc_disable(imx_usb);
+
+        driver->unbind(&imx_usb->gadget);
+        imx_usb->gadget.dev.driver = NULL;
+        imx_usb->driver = NULL;
+
+        device_del(&imx_usb->gadget.dev);
+
+        D_INI(imx_usb->dev, "<%s> unregistered gadget driver '%s'\n",
+                __func__, driver->driver.name);
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/*******************************************************************************
+ * Module functions
+ *******************************************************************************
+ */
+
+static int __init imx_udc_probe(struct platform_device *pdev)
+{
+        struct imx_udc_struct *imx_usb = &controller;
+        struct resource *res;
+        struct imxusb_platform_data *pdata;
+        struct clk *clk;
+        void __iomem *base;
+        int ret = 0;
+        int i, res_size;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "can't get device resources\n");
+                return -ENODEV;
+        }
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "driver needs platform data\n");
+                return -ENODEV;
+        }
+
+        res_size = res->end - res->start + 1;
+        if (!request_mem_region(res->start, res_size, res->name)) {
+                dev_err(&pdev->dev, "can't allocate %d bytes at %d address\n",
+                        res_size, res->start);
+                return -ENOMEM;
+        }
+
+        if (pdata->init) {
+                ret = pdata->init(&pdev->dev);
+                if (ret)
+                        goto fail0;
+        }
+
+        base = ioremap(res->start, res_size);
+        if (!base) {
+                dev_err(&pdev->dev, "ioremap failed\n");
+                ret = -EIO;
+                goto fail1;
+        }
+
+        clk = clk_get(NULL, "usbd_clk");
+        if (IS_ERR(clk)) {
+                ret = PTR_ERR(clk);
+                dev_err(&pdev->dev, "can't get USB clock\n");
+                goto fail2;
+        }
+        clk_enable(clk);
+
+        if (clk_get_rate(clk) != 48000000) {
+                D_INI(&pdev->dev,
+                        "Bad USB clock (%d Hz), changing to 48000000 Hz\n",
+                        (int)clk_get_rate(clk));
+                if (clk_set_rate(clk, 48000000)) {
+                        dev_err(&pdev->dev,
+                                "Unable to set correct USB clock (48MHz)\n");
+                        ret = -EIO;
+                        goto fail3;
+                }
+        }
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
+                imx_usb->usbd_int[i] = platform_get_irq(pdev, i);
+                if (imx_usb->usbd_int[i] < 0) {
+                        dev_err(&pdev->dev, "can't get irq number\n");
+                        ret = -ENODEV;
+                        goto fail3;
+                }
+        }
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
+                ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
+                                     IRQF_DISABLED, driver_name, imx_usb);
+                if (ret) {
+                        dev_err(&pdev->dev, "can't get irq %i, err %d\n",
+                                imx_usb->usbd_int[i], ret);
+                        for (--i; i >= 0; i--)
+                                free_irq(imx_usb->usbd_int[i], imx_usb);
+                        goto fail3;
+                }
+        }
+
+        imx_usb->res = res;
+        imx_usb->base = base;
+        imx_usb->clk = clk;
+        imx_usb->dev = &pdev->dev;
+
+        device_initialize(&imx_usb->gadget.dev);
+
+        imx_usb->gadget.dev.parent = &pdev->dev;
+        imx_usb->gadget.dev.dma_mask = pdev->dev.dma_mask;
+
+        platform_set_drvdata(pdev, imx_usb);
+
+        usb_init_data(imx_usb);
+        imx_udc_init(imx_usb);
+
+        return 0;
+
+fail3:
+        clk_put(clk);
+        clk_disable(clk);
+fail2:
+        iounmap(base);
+fail1:
+        if (pdata->exit)
+                pdata->exit(&pdev->dev);
+fail0:
+        release_mem_region(res->start, res_size);
+        return ret;
+}
+
+static int __exit imx_udc_remove(struct platform_device *pdev)
+{
+        struct imx_udc_struct *imx_usb = platform_get_drvdata(pdev);
+        struct imxusb_platform_data *pdata = pdev->dev.platform_data;
+        int i;
+
+        imx_udc_disable(imx_usb);
+
+        for (i = 0; i < IMX_USB_NB_EP + 1; i++)
+                free_irq(imx_usb->usbd_int[i], imx_usb);
+
+        clk_put(imx_usb->clk);
+        clk_disable(imx_usb->clk);
+        iounmap(imx_usb->base);
+
+        release_mem_region(imx_usb->res->start,
+                imx_usb->res->end - imx_usb->res->start + 1);
+
+        if (pdata->exit)
+                pdata->exit(&pdev->dev);
+
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+/*----------------------------------------------------------------------------*/
+
+#ifdef  CONFIG_PM
+#define imx_udc_suspend NULL
+#define imx_udc_resume  NULL
+#else
+#define imx_udc_suspend NULL
+#define imx_udc_resume  NULL
+#endif
+
+/*----------------------------------------------------------------------------*/
+
+static struct platform_driver udc_driver = {
+        .driver         = {
+                .name   = driver_name,
+                .owner  = THIS_MODULE,
+        },
+        .remove         = __exit_p(imx_udc_remove),
+        .suspend        = imx_udc_suspend,
+        .resume         = imx_udc_resume,
+};
+
+static int __init udc_init(void)
+{
+        return platform_driver_probe(&udc_driver, imx_udc_probe);
+}
+module_init(udc_init);
+
+static void __exit udc_exit(void)
+{
+        platform_driver_unregister(&udc_driver);
+}
+module_exit(udc_exit);
+
+MODULE_DESCRIPTION("IMX USB Device Controller driver");
+MODULE_AUTHOR("Darius Augulis <augulis.darius@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:imx_udc");
diff --git a/drivers/usb/gadget/imx_udc.h b/drivers/usb/gadget/imx_udc.h
new file mode 100644
index 000000000000..850076937d8d
--- /dev/null
+++ b/drivers/usb/gadget/imx_udc.h
@@ -0,0 +1,344 @@
+/*
+ *      Copyright (C) 2005 Mike Lee(eemike@gmail.com)
+ *
+ *      This udc driver is now under testing and code is based on pxa2xx_udc.h
+ *      Please use it with your own risk!
+ *
+ *      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.
+ */
+
+#ifndef __LINUX_USB_GADGET_IMX_H
+#define __LINUX_USB_GADGET_IMX_H
+
+#include <linux/types.h>
+
+/* Helper macros */
+#define EP_NO(ep)       ((ep->bEndpointAddress) & ~USB_DIR_IN) /* IN:1, OUT:0 */
+#define EP_DIR(ep)      ((ep->bEndpointAddress) & USB_DIR_IN ? 1 : 0)
+#define irq_to_ep(irq)  (((irq) >= USBD_INT0) || ((irq) <= USBD_INT6) ? ((irq) - USBD_INT0) : (USBD_INT6)) /*should not happen*/
+#define ep_to_irq(ep)   (EP_NO((ep)) + USBD_INT0)
+#define IMX_USB_NB_EP   6
+
+/* Driver structures */
+struct imx_request {
+        struct usb_request                      req;
+        struct list_head                        queue;
+        unsigned int                            in_use;
+};
+
+enum ep0_state {
+        EP0_IDLE,
+        EP0_IN_DATA_PHASE,
+        EP0_OUT_DATA_PHASE,
+        EP0_CONFIG,
+        EP0_STALL,
+};
+
+struct imx_ep_struct {
+        struct usb_ep                           ep;
+        struct imx_udc_struct                   *imx_usb;
+        struct list_head                        queue;
+        unsigned char                           stopped;
+        unsigned char                           fifosize;
+        unsigned char                           bEndpointAddress;
+        unsigned char                           bmAttributes;
+};
+
+struct imx_udc_struct {
+        struct usb_gadget                       gadget;
+        struct usb_gadget_driver                *driver;
+        struct device                           *dev;
+        struct imx_ep_struct                    imx_ep[IMX_USB_NB_EP];
+        struct clk                              *clk;
+        enum ep0_state                          ep0state;
+        struct resource                         *res;
+        void __iomem                            *base;
+        unsigned char                           set_config;
+        int                                     cfg,
+                                                intf,
+                                                alt,
+                                                usbd_int[7];
+};
+
+/* USB registers */
+#define  USB_FRAME              (0x00)  /* USB frame */
+#define  USB_SPEC               (0x04)  /* USB Spec */
+#define  USB_STAT               (0x08)  /* USB Status */
+#define  USB_CTRL               (0x0C)  /* USB Control */
+#define  USB_DADR               (0x10)  /* USB Desc RAM addr */
+#define  USB_DDAT               (0x14)  /* USB Desc RAM/EP buffer data */
+#define  USB_INTR               (0x18)  /* USB interrupt */
+#define  USB_MASK               (0x1C)  /* USB Mask */
+#define  USB_ENAB               (0x24)  /* USB Enable */
+#define  USB_EP_STAT(x)         (0x30 + (x*0x30)) /* USB status/control */
+#define  USB_EP_INTR(x)         (0x34 + (x*0x30)) /* USB interrupt */
+#define  USB_EP_MASK(x)         (0x38 + (x*0x30)) /* USB mask */
+#define  USB_EP_FDAT(x)         (0x3C + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT0(x)        (0x3C + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT1(x)        (0x3D + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT2(x)        (0x3E + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FDAT3(x)        (0x3F + (x*0x30)) /* USB FIFO data */
+#define  USB_EP_FSTAT(x)        (0x40 + (x*0x30)) /* USB FIFO status */
+#define  USB_EP_FCTRL(x)        (0x44 + (x*0x30)) /* USB FIFO control */
+#define  USB_EP_LRFP(x)         (0x48 + (x*0x30)) /* USB last read frame pointer */
+#define  USB_EP_LWFP(x)         (0x4C + (x*0x30)) /* USB last write frame pointer */
+#define  USB_EP_FALRM(x)        (0x50 + (x*0x30)) /* USB FIFO alarm */
+#define  USB_EP_FRDP(x)         (0x54 + (x*0x30)) /* USB FIFO read pointer */
+#define  USB_EP_FWRP(x)         (0x58 + (x*0x30)) /* USB FIFO write pointer */
+/* USB Control Register Bit Fields.*/
+#define CTRL_CMDOVER            (1<<6)  /* UDC status */
+#define CTRL_CMDERROR           (1<<5)  /* UDC status */
+#define CTRL_FE_ENA             (1<<3)  /* Enable Font End logic */
+#define CTRL_UDC_RST            (1<<2)  /* UDC reset */
+#define CTRL_AFE_ENA            (1<<1)  /* Analog Font end enable */
+#define CTRL_RESUME             (1<<0)  /* UDC resume */
+/* USB Status Register Bit Fields.*/
+#define STAT_RST                (1<<8)
+#define STAT_SUSP               (1<<7)
+#define STAT_CFG                (3<<5)
+#define STAT_INTF               (3<<3)
+#define STAT_ALTSET             (7<<0)
+/* USB Interrupt Status/Mask Registers Bit fields */
+#define INTR_WAKEUP             (1<<31) /* Wake up Interrupt */
+#define INTR_MSOF               (1<<7)  /* Missed Start of Frame */
+#define INTR_SOF                (1<<6)  /* Start of Frame */
+#define INTR_RESET_STOP         (1<<5)  /* Reset Signaling stop */
+#define INTR_RESET_START        (1<<4)  /* Reset Signaling start */
+#define INTR_RESUME             (1<<3)  /* Suspend to resume */
+#define INTR_SUSPEND            (1<<2)  /* Active to suspend */
+#define INTR_FRAME_MATCH        (1<<1)  /* Frame matched */
+#define INTR_CFG_CHG            (1<<0)  /* Configuration change occurred */
+/* USB Enable Register Bit Fields.*/
+#define ENAB_RST                (1<<31) /* Reset USB modules */
+#define ENAB_ENAB               (1<<30) /* Enable USB modules*/
+#define ENAB_SUSPEND            (1<<29) /* Suspend USB modules */
+#define ENAB_ENDIAN             (1<<28) /* Endian of USB modules */
+#define ENAB_PWRMD              (1<<0)  /* Power mode of USB modules */
+/* USB Descriptor Ram Address Register bit fields */
+#define DADR_CFG                (1<<31) /* Configuration */
+#define DADR_BSY                (1<<30) /* Busy status */
+#define DADR_DADR               (0x1FF) /* Descriptor Ram Address */
+/* USB Descriptor RAM/Endpoint Buffer Data Register bit fields */
+#define DDAT_DDAT               (0xFF)  /* Descriptor Endpoint Buffer */
+/* USB Endpoint Status Register bit fields */
+#define EPSTAT_BCOUNT           (0x7F<<16)      /* Endpoint FIFO byte count */
+#define EPSTAT_SIP              (1<<8)  /* Endpoint setup in progress */
+#define EPSTAT_DIR              (1<<7)  /* Endpoint transfer direction */
+#define EPSTAT_MAX              (3<<5)  /* Endpoint Max packet size */
+#define EPSTAT_TYP              (3<<3)  /* Endpoint type */
+#define EPSTAT_ZLPS             (1<<2)  /* Send zero length packet */
+#define EPSTAT_FLUSH            (1<<1)  /* Endpoint FIFO Flush */
+#define EPSTAT_STALL            (1<<0)  /* Force stall */
+/* USB Endpoint FIFO Status Register bit fields */
+#define FSTAT_FRAME_STAT        (0xF<<24)       /* Frame status bit [0-3] */
+#define FSTAT_ERR               (1<<22) /* FIFO error */
+#define FSTAT_UF                (1<<21) /* FIFO underflow */
+#define FSTAT_OF                (1<<20) /* FIFO overflow */
+#define FSTAT_FR                (1<<19) /* FIFO frame ready */
+#define FSTAT_FULL              (1<<18) /* FIFO full */
+#define FSTAT_ALRM              (1<<17) /* FIFO alarm */
+#define FSTAT_EMPTY             (1<<16) /* FIFO empty */
+/* USB Endpoint FIFO Control Register bit fields */
+#define FCTRL_WFR               (1<<29) /* Write frame end */
+/* USB Endpoint Interrupt Status Regsiter bit fields */
+#define EPINTR_FIFO_FULL        (1<<8)  /* fifo full */
+#define EPINTR_FIFO_EMPTY       (1<<7)  /* fifo empty */
+#define EPINTR_FIFO_ERROR       (1<<6)  /* fifo error */
+#define EPINTR_FIFO_HIGH        (1<<5)  /* fifo high */
+#define EPINTR_FIFO_LOW         (1<<4)  /* fifo low */
+#define EPINTR_MDEVREQ          (1<<3)  /* multi Device request */
+#define EPINTR_EOT              (1<<2)  /* fifo end of transfer */
+#define EPINTR_DEVREQ           (1<<1)  /* Device request */
+#define EPINTR_EOF              (1<<0)  /* fifo end of frame */
+
+/* Debug macros */
+#ifdef DEBUG
+
+/* #define DEBUG_REQ */
+/* #define DEBUG_TRX */
+/* #define DEBUG_INIT */
+/* #define DEBUG_EP0 */
+/* #define DEBUG_EPX */
+/* #define DEBUG_IRQ */
+/* #define DEBUG_EPIRQ */
+/* #define DEBUG_DUMP */
+#define DEBUG_ERR
+
+#ifdef DEBUG_REQ
+        #define D_REQ(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_REQ(dev, args...)     do {} while (0)
+#endif /* DEBUG_REQ */
+
+#ifdef DEBUG_TRX
+        #define D_TRX(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_TRX(dev, args...)     do {} while (0)
+#endif /* DEBUG_TRX */
+
+#ifdef DEBUG_INIT
+        #define D_INI(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_INI(dev, args...)     do {} while (0)
+#endif /* DEBUG_INIT */
+
+#ifdef DEBUG_EP0
+        static const char *state_name[] = {
+                "EP0_IDLE",
+                "EP0_IN_DATA_PHASE",
+                "EP0_OUT_DATA_PHASE",
+                "EP0_CONFIG",
+                "EP0_STALL"
+        };
+        #define D_EP0(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_EP0(dev, args...)     do {} while (0)
+#endif /* DEBUG_EP0 */
+
+#ifdef DEBUG_EPX
+        #define D_EPX(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_EPX(dev, args...)     do {} while (0)
+#endif /* DEBUG_EP0 */
+
+#ifdef DEBUG_IRQ
+        static void dump_intr(const char *label, int irqreg, struct device *dev)
+        {
+                dev_dbg(dev, "<%s> USB_INTR=[%s%s%s%s%s%s%s%s%s]\n", label,
+                        (irqreg & INTR_WAKEUP) ? " wake" : "",
+                        (irqreg & INTR_MSOF) ? " msof" : "",
+                        (irqreg & INTR_SOF) ? " sof" : "",
+                        (irqreg & INTR_RESUME) ? " resume" : "",
+                        (irqreg & INTR_SUSPEND) ? " suspend" : "",
+                        (irqreg & INTR_RESET_STOP) ? " noreset" : "",
+                        (irqreg & INTR_RESET_START) ? " reset" : "",
+                        (irqreg & INTR_FRAME_MATCH) ? " fmatch" : "",
+                        (irqreg & INTR_CFG_CHG) ? " config" : "");
+        }
+#else
+        #define dump_intr(x, y, z)              do {} while (0)
+#endif /* DEBUG_IRQ */
+
+#ifdef DEBUG_EPIRQ
+        static void dump_ep_intr(const char *label, int nr, int irqreg, struct device *dev)
+        {
+                dev_dbg(dev, "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, nr,
+                        (irqreg & EPINTR_FIFO_FULL) ? " full" : "",
+                        (irqreg & EPINTR_FIFO_EMPTY) ? " fempty" : "",
+                        (irqreg & EPINTR_FIFO_ERROR) ? " ferr" : "",
+                        (irqreg & EPINTR_FIFO_HIGH) ? " fhigh" : "",
+                        (irqreg & EPINTR_FIFO_LOW) ? " flow" : "",
+                        (irqreg & EPINTR_MDEVREQ) ? " mreq" : "",
+                        (irqreg & EPINTR_EOF) ? " eof" : "",
+                        (irqreg & EPINTR_DEVREQ) ? " devreq" : "",
+                        (irqreg & EPINTR_EOT) ? " eot" : "");
+        }
+#else
+        #define dump_ep_intr(x, y, z, i)        do {} while (0)
+#endif /* DEBUG_IRQ */
+
+#ifdef DEBUG_DUMP
+        static void dump_usb_stat(const char *label, struct imx_udc_struct *imx_usb)
+        {
+                int temp = __raw_readl(imx_usb->base + USB_STAT);
+
+                dev_dbg(imx_usb->dev,
+                        "<%s> USB_STAT=[%s%s CFG=%d, INTF=%d, ALTR=%d]\n", label,
+                        (temp & STAT_RST) ? " reset" : "",
+                        (temp & STAT_SUSP) ? " suspend" : "",
+                        (temp & STAT_CFG) >> 5,
+                        (temp & STAT_INTF) >> 3,
+                        (temp & STAT_ALTSET));
+        }
+
+        static void dump_ep_stat(const char *label, struct imx_ep_struct *imx_ep)
+        {
+                int temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_INTR(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_INTR=[%s%s%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        (temp & EPINTR_FIFO_FULL) ? " full" : "",
+                        (temp & EPINTR_FIFO_EMPTY) ? " fempty" : "",
+                        (temp & EPINTR_FIFO_ERROR) ? " ferr" : "",
+                        (temp & EPINTR_FIFO_HIGH) ? " fhigh" : "",
+                        (temp & EPINTR_FIFO_LOW) ? " flow" : "",
+                        (temp & EPINTR_MDEVREQ) ? " mreq" : "",
+                        (temp & EPINTR_EOF) ? " eof" : "",
+                        (temp & EPINTR_DEVREQ) ? " devreq" : "",
+                        (temp & EPINTR_EOT) ? " eot" : "");
+
+                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_STAT(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_STAT=[%s%s bcount=%d]\n", label, EP_NO(imx_ep),
+                        (temp & EPSTAT_SIP) ? " sip" : "",
+                        (temp & EPSTAT_STALL) ? " stall" : "",
+                        (temp & EPSTAT_BCOUNT) >> 16);
+
+                temp = __raw_readl(imx_ep->imx_usb->base + USB_EP_FSTAT(EP_NO(imx_ep)));
+
+                dev_dbg(imx_ep->imx_usb->dev,
+                        "<%s> EP%d_FSTAT=[%s%s%s%s%s%s%s]\n", label, EP_NO(imx_ep),
+                        (temp & FSTAT_ERR) ? " ferr" : "",
+                        (temp & FSTAT_UF) ? " funder" : "",
+                        (temp & FSTAT_OF) ? " fover" : "",
+                        (temp & FSTAT_FR) ? " fready" : "",
+                        (temp & FSTAT_FULL) ? " ffull" : "",
+                        (temp & FSTAT_ALRM) ? " falarm" : "",
+                        (temp & FSTAT_EMPTY) ? " fempty" : "");
+        }
+
+        static void dump_req(const char *label, struct imx_ep_struct *imx_ep, struct usb_request *req)
+        {
+                int i;
+
+                if (!req || !req->buf) {
+                        dev_dbg(imx_ep->imx_usb->dev, "<%s> req or req buf is free\n", label);
+                        return;
+                }
+
+                if ((!EP_NO(imx_ep) && imx_ep->imx_usb->ep0state == EP0_IN_DATA_PHASE)
+                        || (EP_NO(imx_ep) && EP_DIR(imx_ep))) {
+
+                        dev_dbg(imx_ep->imx_usb->dev, "<%s> request dump <", label);
+                        for (i = 0; i < req->length; i++)
+                                printk("%02x-", *((u8 *)req->buf + i));
+                        printk(">\n");
+                }
+        }
+
+#else
+        #define dump_ep_stat(x, y)              do {} while (0)
+        #define dump_usb_stat(x, y)             do {} while (0)
+        #define dump_req(x, y, z)               do {} while (0)
+#endif /* DEBUG_DUMP */
+
+#ifdef DEBUG_ERR
+        #define D_ERR(dev, args...)     dev_dbg(dev, ## args)
+#else
+        #define D_ERR(dev, args...)     do {} while (0)
+#endif
+
+#else
+        #define D_REQ(dev, args...)             do {} while (0)
+        #define D_TRX(dev, args...)             do {} while (0)
+        #define D_INI(dev, args...)             do {} while (0)
+        #define D_EP0(dev, args...)             do {} while (0)
+        #define D_EPX(dev, args...)             do {} while (0)
+        #define dump_ep_intr(x, y, z, i)        do {} while (0)
+        #define dump_intr(x, y, z)              do {} while (0)
+        #define dump_ep_stat(x, y)              do {} while (0)
+        #define dump_usb_stat(x, y)             do {} while (0)
+        #define dump_req(x, y, z)               do {} while (0)
+        #define D_ERR(dev, args...)             do {} while (0)
+#endif /* DEBUG */
+
+#endif /* __LINUX_USB_GADGET_IMX_H */
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
index c6e7df04c69a..d554b0895603 100644
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ b/drivers/usb/gadget/lh7a40x_udc.c
@@ -1981,7 +1981,7 @@ static struct lh7a40x_udc memory = {
                    .ep0 = &memory.ep[0].ep,
                    .name = driver_name,
                    .dev = {
-                           .bus_id = "gadget",
+                           .init_name = "gadget",
                            .release = nop_release,
                            },
                    },
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 3a8879ec2061..43dcf9e1af6b 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1546,8 +1546,6 @@ static void nop_completion(struct usb_ep *ep, struct usb_request *r)
 {
 }
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
-
 static int __init m66592_probe(struct platform_device *pdev)
 {
         struct resource *res;
@@ -1560,11 +1558,10 @@ static int __init m66592_probe(struct platform_device *pdev)
         int ret = 0;
         int i;
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                        (char *)udc_name);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 ret = -ENODEV;
-                pr_err("platform_get_resource_byname error.\n");
+                pr_err("platform_get_resource error.\n");
                 goto clean_up;
         }
 
@@ -1575,7 +1572,7 @@ static int __init m66592_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
-        reg = ioremap(res->start, resource_len(res));
+        reg = ioremap(res->start, resource_size(res));
         if (reg == NULL) {
                 ret = -ENOMEM;
                 pr_err("ioremap error.\n");
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 8ae70de2c37d..12c6d83b218c 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -669,7 +669,7 @@ fill_dma_desc (struct net2280_ep *ep, struct net2280_request *req, int valid)
 
         /* 2280 may be polling VALID_BIT through ep->dma->dmadesc */
         wmb ();
-        td->dmacount = cpu_to_le32p (&dmacount);
+        td->dmacount = cpu_to_le32(dmacount);
 }
 
 static const u32 dmactl_default =
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 34e9e393f929..57d9641c6bf8 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -3006,7 +3006,7 @@ cleanup1:
 
 cleanup0:
         if (xceiv)
-                put_device(xceiv->dev);
+                otg_put_transceiver(xceiv);
 
         if (cpu_is_omap16xx() || cpu_is_omap24xx()) {
                 clk_disable(hhc_clk);
@@ -3034,7 +3034,7 @@ static int __exit omap_udc_remove(struct platform_device *pdev)
 
         pullup_disable(udc);
         if (udc->transceiver) {
-                put_device(udc->transceiver->dev);
+                otg_put_transceiver(udc->transceiver);
                 udc->transceiver = NULL;
         }
         omap_writew(0, UDC_SYSCON1);
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index 8c5026be79d4..9b36205c5759 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -1833,7 +1833,7 @@ static struct pxa25x_udc memory = {
                 .ep0            = &memory.ep[0].ep,
                 .name           = driver_name,
                 .dev = {
-                        .bus_id         = "gadget",
+                        .init_name      = "gadget",
                         .release        = nop_release,
                 },
         },
@@ -2198,7 +2198,7 @@ static int __init pxa25x_udc_probe(struct platform_device *pdev)
         udc_disable(dev);
         udc_reinit(dev);
 
-        dev->vbus = is_vbus_present();
+        dev->vbus = !!is_vbus_present();
 
         /* irq setup after old hardware state is cleaned up */
         retval = request_irq(irq, pxa25x_udc_irq,
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 944e4ff641df..990f40f988d4 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -430,7 +430,6 @@ static void pio_irq_enable(struct pxa_ep *ep)
 /**
  * pio_irq_disable - Disables irq generation for one endpoint
  * @ep: udc endpoint
- * @index: endpoint number
  */
 static void pio_irq_disable(struct pxa_ep *ep)
 {
@@ -586,7 +585,6 @@ static void inc_ep_stats_reqs(struct pxa_ep *ep, int is_in)
  * inc_ep_stats_bytes - Update ep stats counts
  * @ep: physical endpoint
  * @count: bytes transfered on endpoint
- * @req: usb request
  * @is_in: ep direction (USB_DIR_IN or 0)
  */
 static void inc_ep_stats_bytes(struct pxa_ep *ep, int count, int is_in)
@@ -2162,7 +2160,7 @@ static struct pxa_udc memory = {
                 .ep0            = &memory.udc_usb_ep[0].usb_ep,
                 .name           = driver_name,
                 .dev = {
-                        .bus_id         = "gadget",
+                        .init_name      = "gadget",
                 },
         },
 
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index 8d8d65165983..9a2b8920532d 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -36,6 +36,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/gpio.h>
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -51,7 +52,6 @@
 #include <mach/irqs.h>
 
 #include <mach/hardware.h>
-#include <mach/regs-gpio.h>
 
 #include <plat/regs-udc.h>
 #include <plat/udc.h>
@@ -1510,11 +1510,7 @@ static irqreturn_t s3c2410_udc_vbus_irq(int irq, void *_dev)
 
         dprintk(DEBUG_NORMAL, "%s()\n", __func__);
 
-        /* some cpus cannot read from an line configured to IRQ! */
-        s3c2410_gpio_cfgpin(udc_info->vbus_pin, S3C2410_GPIO_INPUT);
-        value = s3c2410_gpio_getpin(udc_info->vbus_pin);
-        s3c2410_gpio_cfgpin(udc_info->vbus_pin, S3C2410_GPIO_SFN2);
-
+        value = gpio_get_value(udc_info->vbus_pin) ? 1 : 0;
         if (udc_info->vbus_pin_inverted)
                 value = !value;
 
@@ -1727,7 +1723,7 @@ static struct s3c2410_udc memory = {
                 .ep0            = &memory.ep[0].ep,
                 .name           = gadget_name,
                 .dev = {
-                        .bus_id         = "gadget",
+                        .init_name      = "gadget",
                 },
         },
 
@@ -1802,7 +1798,7 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
         struct s3c2410_udc *udc = &memory;
         struct device *dev = &pdev->dev;
         int retval;
-        unsigned int irq;
+        int irq;
 
         dev_dbg(dev, "%s()\n", __func__);
 
@@ -1861,7 +1857,7 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
 
         /* irq setup after old hardware state is cleaned up */
         retval = request_irq(IRQ_USBD, s3c2410_udc_irq,
-                        IRQF_DISABLED, gadget_name, udc);
+                             IRQF_DISABLED, gadget_name, udc);
 
         if (retval != 0) {
                 dev_err(dev, "cannot get irq %i, err %d\n", IRQ_USBD, retval);
@@ -1872,17 +1868,28 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
         dev_dbg(dev, "got irq %i\n", IRQ_USBD);
 
         if (udc_info && udc_info->vbus_pin > 0) {
-                irq = s3c2410_gpio_getirq(udc_info->vbus_pin);
+                retval = gpio_request(udc_info->vbus_pin, "udc vbus");
+                if (retval < 0) {
+                        dev_err(dev, "cannot claim vbus pin\n");
+                        goto err_int;
+                }
+
+                irq = gpio_to_irq(udc_info->vbus_pin);
+                if (irq < 0) {
+                        dev_err(dev, "no irq for gpio vbus pin\n");
+                        goto err_gpio_claim;
+                }
+
                 retval = request_irq(irq, s3c2410_udc_vbus_irq,
                                      IRQF_DISABLED | IRQF_TRIGGER_RISING
                                      | IRQF_TRIGGER_FALLING | IRQF_SHARED,
                                      gadget_name, udc);
 
                 if (retval != 0) {
-                        dev_err(dev, "can't get vbus irq %i, err %d\n",
+                        dev_err(dev, "can't get vbus irq %d, err %d\n",
                                 irq, retval);
                         retval = -EBUSY;
-                        goto err_int;
+                        goto err_gpio_claim;
                 }
 
                 dev_dbg(dev, "got irq %i\n", irq);
@@ -1902,6 +1909,9 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
 
         return 0;
 
+err_gpio_claim:
+        if (udc_info && udc_info->vbus_pin > 0)
+                gpio_free(udc_info->vbus_pin);
 err_int:
         free_irq(IRQ_USBD, udc);
 err_map:
@@ -1927,7 +1937,7 @@ static int s3c2410_udc_remove(struct platform_device *pdev)
         debugfs_remove(udc->regs_info);
 
         if (udc_info && udc_info->vbus_pin > 0) {
-                irq = s3c2410_gpio_getirq(udc_info->vbus_pin);
+                irq = gpio_to_irq(udc_info->vbus_pin);
                 free_irq(irq, udc);
         }
 
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index f3a75a929e0a..2b476b6b3d4d 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -96,6 +96,19 @@ config USB_EHCI_HCD_PPC_OF
           Enables support for the USB controller present on the PowerPC
           OpenFirmware platform bus.
 
+config USB_OXU210HP_HCD
+        tristate "OXU210HP HCD support"
+        depends on USB
+        ---help---
+          The OXU210HP is an USB host/OTG/device controller. Enable this
+          option if your board has this chip. If unsure, say N.
+
+          This driver does not support isochronous transfers and doesn't
+          implement OTG nor USB device controllers.
+
+          To compile this driver as a module, choose M here: the
+          module will be called oxu210hp-hcd.
+
 config USB_ISP116X_HCD
         tristate "ISP116X HCD support"
         depends on USB
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 23be22224044..e5f3f20787e4 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_USB_WHCI_HCD)	+= whci/
 obj-$(CONFIG_PCI)               += pci-quirks.o
 
 obj-$(CONFIG_USB_EHCI_HCD)      += ehci-hcd.o
+obj-$(CONFIG_USB_OXU210HP_HCD)  += oxu210hp-hcd.o
 obj-$(CONFIG_USB_ISP116X_HCD)   += isp116x-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
 obj-$(CONFIG_USB_UHCI_HCD)      += uhci-hcd.o
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 0cb53ca8d343..7f4ace73d44a 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -455,9 +455,7 @@ static void qh_lines (
                                 (scratch >> 16) & 0x7fff,
                                 scratch,
                                 td->urb);
-                if (temp < 0)
-                        temp = 0;
-                else if (size < temp)
+                if (size < temp)
                         temp = size;
                 size -= temp;
                 next += temp;
@@ -466,9 +464,7 @@ static void qh_lines (
         }
 
         temp = snprintf (next, size, "\n");
-        if (temp < 0)
-                temp = 0;
-        else if (size < temp)
+        if (size < temp)
                 temp = size;
         size -= temp;
         next += temp;
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 218f9660d7ee..97a53a48a3d8 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -194,6 +194,7 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         u32                     temp;
         u32                     power_okay;
         int                     i;
+        u8                      resume_needed = 0;
 
         if (time_before (jiffies, ehci->next_statechange))
                 msleep(5);
@@ -228,7 +229,9 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
 
         /* Some controller/firmware combinations need a delay during which
          * they set up the port statuses.  See Bugzilla #8190. */
-        mdelay(8);
+        spin_unlock_irq(&ehci->lock);
+        msleep(8);
+        spin_lock_irq(&ehci->lock);
 
         /* manually resume the ports we suspended during bus_suspend() */
         i = HCS_N_PORTS (ehci->hcs_params);
@@ -236,12 +239,21 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
                 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
                 if (test_bit(i, &ehci->bus_suspended) &&
-                                (temp & PORT_SUSPEND))
+                                (temp & PORT_SUSPEND)) {
                         temp |= PORT_RESUME;
+                        resume_needed = 1;
+                }
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
+
+        /* msleep for 20ms only if code is trying to resume port */
+        if (resume_needed) {
+                spin_unlock_irq(&ehci->lock);
+                msleep(20);
+                spin_lock_irq(&ehci->lock);
+        }
+
         i = HCS_N_PORTS (ehci->hcs_params);
-        mdelay (20);
         while (i--) {
                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
                 if (test_bit(i, &ehci->bus_suspended) &&
@@ -422,8 +434,15 @@ static int check_reset_complete (
                 port_status &= ~PORT_RWC_BITS;
                 ehci_writel(ehci, port_status, status_reg);
 
-        } else
+                /* ensure 440EPX ohci controller state is operational */
+                if (ehci->has_amcc_usb23)
+                        set_ohci_hcfs(ehci, 1);
+        } else {
                 ehci_dbg (ehci, "port %d high speed\n", index + 1);
+                /* ensure 440EPx ohci controller state is suspended */
+                if (ehci->has_amcc_usb23)
+                        set_ohci_hcfs(ehci, 0);
+        }
 
         return port_status;
 }
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 36864f958444..bdc6e86e1f8b 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -219,15 +219,19 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
         /* Serial Bus Release Number is at PCI 0x60 offset */
         pci_read_config_byte(pdev, 0x60, &ehci->sbrn);
 
-        /* Workaround current PCI init glitch:  wakeup bits aren't
-         * being set from PCI PM capability.
+        /* Keep this around for a while just in case some EHCI
+         * implementation uses legacy PCI PM support.  This test
+         * can be removed on 17 Dec 2009 if the dev_warn() hasn't
+         * been triggered by then.
          */
         if (!device_can_wakeup(&pdev->dev)) {
                 u16     port_wake;
 
                 pci_read_config_word(pdev, 0x62, &port_wake);
-                if (port_wake & 0x0001)
+                if (port_wake & 0x0001) {
+                        dev_warn(&pdev->dev, "Enabling legacy PCI PM\n");
                         device_init_wakeup(&pdev->dev, 1);
+                }
         }
 
 #ifdef  CONFIG_USB_SUSPEND
@@ -428,6 +432,8 @@ static struct pci_driver ehci_pci_driver = {
 
 #ifdef  CONFIG_PM
         .suspend =      usb_hcd_pci_suspend,
+        .suspend_late = usb_hcd_pci_suspend_late,
+        .resume_early = usb_hcd_pci_resume_early,
         .resume =       usb_hcd_pci_resume,
 #endif
         .shutdown =     usb_hcd_pci_shutdown,
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index b018deed2e8f..ef732b704f53 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -107,11 +107,13 @@ ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
 {
         struct device_node *dn = op->node;
         struct usb_hcd *hcd;
-        struct ehci_hcd *ehci;
+        struct ehci_hcd *ehci = NULL;
         struct resource res;
         int irq;
         int rv;
 
+        struct device_node *np;
+
         if (usb_disabled())
                 return -ENODEV;
 
@@ -149,6 +151,20 @@ ehci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
         }
 
         ehci = hcd_to_ehci(hcd);
+        np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
+        if (np != NULL) {
+                /* claim we really affected by usb23 erratum */
+                if (!of_address_to_resource(np, 0, &res))
+                        ehci->ohci_hcctrl_reg = ioremap(res.start +
+                                        OHCI_HCCTRL_OFFSET, OHCI_HCCTRL_LEN);
+                else
+                        pr_debug(__FILE__ ": no ohci offset in fdt\n");
+                if (!ehci->ohci_hcctrl_reg) {
+                        pr_debug(__FILE__ ": ioremap for ohci hcctrl failed\n");
+                } else {
+                        ehci->has_amcc_usb23 = 1;
+                }
+        }
 
         if (of_get_property(dn, "big-endian", NULL)) {
                 ehci->big_endian_mmio = 1;
@@ -181,6 +197,9 @@ err_ioremap:
         irq_dispose_mapping(irq);
 err_irq:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+
+        if (ehci->has_amcc_usb23)
+                iounmap(ehci->ohci_hcctrl_reg);
 err_rmr:
         usb_put_hcd(hcd);
 
@@ -191,6 +210,11 @@ err_rmr:
 static int ehci_hcd_ppc_of_remove(struct of_device *op)
 {
         struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+
+        struct device_node *np;
+        struct resource res;
+
         dev_set_drvdata(&op->dev, NULL);
 
         dev_dbg(&op->dev, "stopping PPC-OF USB Controller\n");
@@ -201,6 +225,25 @@ static int ehci_hcd_ppc_of_remove(struct of_device *op)
         irq_dispose_mapping(hcd->irq);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
+        /* use request_mem_region to test if the ohci driver is loaded.  if so
+         * ensure the ohci core is operational.
+         */
+        if (ehci->has_amcc_usb23) {
+                np = of_find_compatible_node(NULL, NULL, "ibm,usb-ohci-440epx");
+                if (np != NULL) {
+                        if (!of_address_to_resource(np, 0, &res))
+                                if (!request_mem_region(res.start,
+                                                            0x4, hcd_name))
+                                        set_ohci_hcfs(ehci, 1);
+                                else
+                                        release_mem_region(res.start, 0x4);
+                        else
+                                pr_debug(__FILE__ ": no ohci offset in fdt\n");
+                        of_node_put(np);
+                }
+
+                iounmap(ehci->ohci_hcctrl_reg);
+        }
         usb_put_hcd(hcd);
 
         return 0;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index c7d4b5a06bdb..fb7054ccf4fc 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -120,6 +120,16 @@ struct ehci_hcd {			/* one per controller */
         unsigned                has_fsl_port_bug:1; /* FreeScale */
         unsigned                big_endian_mmio:1;
         unsigned                big_endian_desc:1;
+        unsigned                has_amcc_usb23:1;
+
+        /* required for usb32 quirk */
+        #define OHCI_CTRL_HCFS          (3 << 6)
+        #define OHCI_USB_OPER           (2 << 6)
+        #define OHCI_USB_SUSPEND        (3 << 6)
+
+        #define OHCI_HCCTRL_OFFSET      0x4
+        #define OHCI_HCCTRL_LEN         0x4
+        __hc32                  *ohci_hcctrl_reg;
 
         u8                      sbrn;           /* packed release number */
 
@@ -636,6 +646,30 @@ static inline void ehci_writel(const struct ehci_hcd *ehci,
 #endif
 }
 
+/*
+ * On certain ppc-44x SoC there is a HW issue, that could only worked around with
+ * explicit suspend/operate of OHCI. This function hereby makes sense only on that arch.
+ * Other common bits are dependant on has_amcc_usb23 quirk flag.
+ */
+#ifdef CONFIG_44x
+static inline void set_ohci_hcfs(struct ehci_hcd *ehci, int operational)
+{
+        u32 hc_control;
+
+        hc_control = (readl_be(ehci->ohci_hcctrl_reg) & ~OHCI_CTRL_HCFS);
+        if (operational)
+                hc_control |= OHCI_USB_OPER;
+        else
+                hc_control |= OHCI_USB_SUSPEND;
+
+        writel_be(hc_control, ehci->ohci_hcctrl_reg);
+        (void) readl_be(ehci->ohci_hcctrl_reg);
+}
+#else
+static inline void set_ohci_hcfs(struct ehci_hcd *ehci, int operational)
+{ }
+#endif
+
 /*-------------------------------------------------------------------------*/
 
 /*
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 8017f1cf78e2..b899f1a59c26 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -435,14 +435,13 @@ static int isp1760_hc_setup(struct usb_hcd *hcd)
 
         /*
          * PORT 1 Control register of the ISP1760 is the OTG control
-         * register on ISP1761.
+         * register on ISP1761. Since there is no OTG or device controller
+         * support in this driver, we use port 1 as a "normal" USB host port on
+         * both chips.
          */
-        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);
-        }
+        isp1760_writel(PORT1_POWER | PORT1_INIT2,
+                       hcd->regs + HC_PORT1_CTRL);
+        mdelay(10);
 
         priv->hcs_params = isp1760_readl(hcd->regs + HC_HCSPARAMS);
 
diff --git a/drivers/usb/host/isp1760-hcd.h b/drivers/usb/host/isp1760-hcd.h
index 4377277667d9..a9daea587962 100644
--- a/drivers/usb/host/isp1760-hcd.h
+++ b/drivers/usb/host/isp1760-hcd.h
@@ -135,7 +135,6 @@ typedef void (packet_enqueue)(struct usb_hcd *hcd, struct isp1760_qh *qh,
  * 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 */
diff --git a/drivers/usb/host/isp1760-if.c b/drivers/usb/host/isp1760-if.c
index b87ca7cf4b37..4cf7ca428b33 100644
--- a/drivers/usb/host/isp1760-if.c
+++ b/drivers/usb/host/isp1760-if.c
@@ -60,9 +60,6 @@ static int of_isp1760_probe(struct of_device *dev,
         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)
@@ -129,23 +126,23 @@ static struct of_platform_driver isp1760_of_driver = {
 #endif
 
 #ifdef CONFIG_PCI
-static u32 nxp_pci_io_base;
-static u32 iolength;
-static u32 pci_mem_phy0;
-static u32 length;
-static u8 __iomem *chip_addr;
-static u8 __iomem *iobase;
-
 static int __devinit isp1761_pci_probe(struct pci_dev *dev,
                 const struct pci_device_id *id)
 {
         u8 latency, limit;
         __u32 reg_data;
         int retry_count;
-        int length;
-        int status = 1;
         struct usb_hcd *hcd;
         unsigned int devflags = 0;
+        int ret_status = 0;
+
+        resource_size_t pci_mem_phy0;
+        resource_size_t memlength;
+
+        u8 __iomem *chip_addr;
+        u8 __iomem *iobase;
+        resource_size_t nxp_pci_io_base;
+        resource_size_t iolength;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -168,26 +165,30 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
         iobase = ioremap_nocache(nxp_pci_io_base, iolength);
         if (!iobase) {
                 printk(KERN_ERR "ioremap #1\n");
-                release_mem_region(nxp_pci_io_base, iolength);
-                return -ENOMEM;
+                ret_status = -ENOMEM;
+                goto cleanup1;
         }
         /* Grab the PLX PCI shared memory of the ISP 1761 we need  */
         pci_mem_phy0 = pci_resource_start(dev, 3);
-        length = pci_resource_len(dev, 3);
-
-        if (length < 0xffff) {
-                printk(KERN_ERR "memory length for this resource is less than "
-                                "required\n");
-                release_mem_region(nxp_pci_io_base, iolength);
-                iounmap(iobase);
-                return  -ENOMEM;
+        memlength = pci_resource_len(dev, 3);
+        if (memlength < 0xffff) {
+                printk(KERN_ERR "memory length for this resource is wrong\n");
+                ret_status = -ENOMEM;
+                goto cleanup2;
         }
 
-        if (!request_mem_region(pci_mem_phy0, length, "ISP-PCI")) {
+        if (!request_mem_region(pci_mem_phy0, memlength, "ISP-PCI")) {
                 printk(KERN_ERR "host controller already in use\n");
-                release_mem_region(nxp_pci_io_base, iolength);
-                iounmap(iobase);
-                return -EBUSY;
+                ret_status = -EBUSY;
+                goto cleanup2;
+        }
+
+        /* map available memory */
+        chip_addr = ioremap_nocache(pci_mem_phy0,memlength);
+        if (!chip_addr) {
+                printk(KERN_ERR "Error ioremap failed\n");
+                ret_status = -ENOMEM;
+                goto cleanup3;
         }
 
         /* bad pci latencies can contribute to overruns */
@@ -210,39 +211,54 @@ static int __devinit isp1761_pci_probe(struct pci_dev *dev,
                  * */
                 writel(0xface, chip_addr + HC_SCRATCH_REG);
                 udelay(100);
-                reg_data = readl(chip_addr + HC_SCRATCH_REG);
+                reg_data = readl(chip_addr + HC_SCRATCH_REG) & 0x0000ffff;
                 retry_count--;
         }
 
+        iounmap(chip_addr);
+
         /* Host Controller presence is detected by writing to scratch register
          * and reading back and checking the contents are same or not
          */
         if (reg_data != 0xFACE) {
                 dev_err(&dev->dev, "scratch register mismatch %x\n", reg_data);
-                goto clean;
+                ret_status = -ENOMEM;
+                goto cleanup3;
         }
 
         pci_set_master(dev);
 
-        status = readl(iobase + 0x68);
-        status |= 0x900;
-        writel(status, iobase + 0x68);
+        /* configure PLX PCI chip to pass interrupts */
+#define PLX_INT_CSR_REG 0x68
+        reg_data = readl(iobase + PLX_INT_CSR_REG);
+        reg_data |= 0x900;
+        writel(reg_data, iobase + PLX_INT_CSR_REG);
 
         dev->dev.dma_mask = NULL;
-        hcd = isp1760_register(pci_mem_phy0, length, dev->irq,
+        hcd = isp1760_register(pci_mem_phy0, memlength, dev->irq,
                 IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
                 devflags);
-        if (!IS_ERR(hcd)) {
-                pci_set_drvdata(dev, hcd);
-                return 0;
+        if (IS_ERR(hcd)) {
+                ret_status = -ENODEV;
+                goto cleanup3;
         }
-clean:
-        status = -ENODEV;
+
+        /* done with PLX IO access */
+        iounmap(iobase);
+        release_mem_region(nxp_pci_io_base, iolength);
+
+        pci_set_drvdata(dev, hcd);
+        return 0;
+
+cleanup3:
+        release_mem_region(pci_mem_phy0, memlength);
+cleanup2:
         iounmap(iobase);
-        release_mem_region(pci_mem_phy0, length);
+cleanup1:
         release_mem_region(nxp_pci_io_base, iolength);
-        return status;
+        return ret_status;
 }
+
 static void isp1761_pci_remove(struct pci_dev *dev)
 {
         struct usb_hcd *hcd;
@@ -255,12 +271,6 @@ static void isp1761_pci_remove(struct pci_dev *dev)
         usb_put_hcd(hcd);
 
         pci_disable_device(dev);
-
-        iounmap(iobase);
-        iounmap(chip_addr);
-
-        release_mem_region(nxp_pci_io_base, iolength);
-        release_mem_region(pci_mem_phy0, length);
 }
 
 static void isp1761_pci_shutdown(struct pci_dev *dev)
@@ -268,12 +278,16 @@ static void isp1761_pci_shutdown(struct pci_dev *dev)
         printk(KERN_ERR "ips1761_pci_shutdown\n");
 }
 
-static const struct pci_device_id isp1760_plx [] = { {
-        /* handle any USB 2.0 EHCI controller */
-        PCI_DEVICE_CLASS(((PCI_CLASS_BRIDGE_OTHER << 8) | (0x06 << 16)), ~0),
-                .driver_data = 0,
-},
-{ /* end: all zeroes */ }
+static const struct pci_device_id isp1760_plx [] = {
+        {
+                .class          = PCI_CLASS_BRIDGE_OTHER << 8,
+                .class_mask     = ~0,
+                .vendor         = PCI_VENDOR_ID_PLX,
+                .device         = 0x5406,
+                .subvendor      = PCI_VENDOR_ID_PLX,
+                .subdevice      = 0x9054,
+        },
+        { }
 };
 MODULE_DEVICE_TABLE(pci, isp1760_plx);
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 8aa3f4556a32..65a9609f4ad6 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -589,13 +589,15 @@ static int ohci_run (struct ohci_hcd *ohci)
                 /* also: power/overcurrent flags in roothub.a */
         }
 
-        /* Reset USB nearly "by the book".  RemoteWakeupConnected was
-         * saved if boot firmware (BIOS/SMM/...) told us it's connected,
-         * or if bus glue did the same (e.g. for PCI add-in cards with
-         * PCI PM support).
+        /* Reset USB nearly "by the book".  RemoteWakeupConnected has
+         * to be checked in case boot firmware (BIOS/SMM/...) has set up
+         * wakeup in a way the bus isn't aware of (e.g., legacy PCI PM).
+         * If the bus glue detected wakeup capability then it should
+         * already be enabled.  Either way, if wakeup should be enabled
+         * but isn't, we'll enable it now.
          */
         if ((ohci->hc_control & OHCI_CTRL_RWC) != 0
-                        && !device_may_wakeup(hcd->self.controller))
+                        && !device_can_wakeup(hcd->self.controller))
                 device_init_wakeup(hcd->self.controller, 1);
 
         switch (ohci->hc_control & OHCI_CTRL_HCFS) {
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index a9c2ae36c7ad..8b28ae7865ba 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -355,9 +355,9 @@ static int __devinit ohci_pci_start (struct usb_hcd *hcd)
 
                 /* RWC may not be set for add-in PCI cards, since boot
                  * firmware probably ignored them.  This transfers PCI
-                 * PM wakeup capabilities (once the PCI layer is fixed).
+                 * PM wakeup capabilities.
                  */
-                if (device_may_wakeup(&pdev->dev))
+                if (device_can_wakeup(&pdev->dev))
                         ohci->hc_control |= OHCI_CTRL_RWC;
         }
 #endif /* CONFIG_PM */
@@ -487,6 +487,8 @@ static struct pci_driver ohci_pci_driver = {
 
 #ifdef  CONFIG_PM
         .suspend =      usb_hcd_pci_suspend,
+        .suspend_late = usb_hcd_pci_suspend_late,
+        .resume_early = usb_hcd_pci_resume_early,
         .resume =       usb_hcd_pci_resume,
 #endif
 
diff --git a/drivers/usb/host/ohci-pnx4008.c b/drivers/usb/host/ohci-pnx4008.c
index e306ca6aef3d..100bf3d8437c 100644
--- a/drivers/usb/host/ohci-pnx4008.c
+++ b/drivers/usb/host/ohci-pnx4008.c
@@ -106,65 +106,34 @@ extern int ocpi_enable(void);
 
 static struct clk *usb_clk;
 
-static int isp1301_probe(struct i2c_adapter *adap);
-static int isp1301_detach(struct i2c_client *client);
-
 static const unsigned short normal_i2c[] =
     { ISP1301_I2C_ADDR, ISP1301_I2C_ADDR + 1, I2C_CLIENT_END };
-static const unsigned short dummy_i2c_addrlist[] = { I2C_CLIENT_END };
-
-static struct i2c_client_address_data addr_data = {
-        .normal_i2c = normal_i2c,
-        .probe = dummy_i2c_addrlist,
-        .ignore = dummy_i2c_addrlist,
-};
-
-struct i2c_driver isp1301_driver = {
-        .driver = {
-                .name = "isp1301_pnx",
-        },
-        .attach_adapter = isp1301_probe,
-        .detach_client = isp1301_detach,
-};
 
-static int isp1301_attach(struct i2c_adapter *adap, int addr, int kind)
+static int isp1301_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
 {
-        struct i2c_client *c;
-        int err;
-
-        c = kzalloc(sizeof(*c), GFP_KERNEL);
-        if (!c)
-                return -ENOMEM;
-
-        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 0;
 }
 
-static int isp1301_probe(struct i2c_adapter *adap)
+static int isp1301_remove(struct i2c_client *client)
 {
-        return i2c_probe(adap, &addr_data, isp1301_attach);
-}
-
-static int isp1301_detach(struct i2c_client *client)
-{
-        i2c_detach_client(client);
-        kfree(isp1301_i2c_client);
         return 0;
 }
 
+const struct i2c_device_id isp1301_id[] = {
+        { "isp1301_pnx", 0 },
+        { }
+};
+
+struct i2c_driver isp1301_driver = {
+        .driver = {
+                .name = "isp1301_pnx",
+        },
+        .probe = isp1301_probe,
+        .remove = isp1301_remove,
+        .id_table = isp1301_id,
+};
+
 static void i2c_write(u8 buf, u8 subaddr)
 {
         char tmpbuf[2];
@@ -328,6 +297,8 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
         struct usb_hcd *hcd = 0;
         struct ohci_hcd *ohci;
         const struct hc_driver *driver = &ohci_pnx4008_hc_driver;
+        struct i2c_adapter *i2c_adap;
+        struct i2c_board_info i2c_info;
 
         int ret = 0, irq;
 
@@ -351,9 +322,20 @@ static int __devinit usb_hcd_pnx4008_probe(struct platform_device *pdev)
 
         ret = i2c_add_driver(&isp1301_driver);
         if (ret < 0) {
-                err("failed to connect I2C to ISP1301 USB Transceiver");
+                err("failed to add ISP1301 driver");
                 goto out;
         }
+        i2c_adap = i2c_get_adapter(2);
+        memset(&i2c_info, 0, sizeof(struct i2c_board_info));
+        strlcpy(i2c_info.name, "isp1301_pnx", I2C_NAME_SIZE);
+        isp1301_i2c_client = i2c_new_probed_device(i2c_adap, &i2c_info,
+                                                   normal_i2c);
+        i2c_put_adapter(i2c_adap);
+        if (!isp1301_i2c_client) {
+                err("failed to connect I2C to ISP1301 USB Transceiver");
+                ret = -ENODEV;
+                goto out_i2c_driver;
+        }
 
         isp1301_configure();
 
@@ -429,6 +411,9 @@ out3:
 out2:
         clk_put(usb_clk);
 out1:
+        i2c_unregister_client(isp1301_i2c_client);
+        isp1301_i2c_client = NULL;
+out_i2c_driver:
         i2c_del_driver(&isp1301_driver);
 out:
         return ret;
@@ -445,6 +430,8 @@ static int usb_hcd_pnx4008_remove(struct platform_device *pdev)
         pnx4008_unset_usb_bits();
         clk_disable(usb_clk);
         clk_put(usb_clk);
+        i2c_unregister_client(isp1301_i2c_client);
+        isp1301_i2c_client = NULL;
         i2c_del_driver(&isp1301_driver);
 
         platform_set_drvdata(pdev, NULL);
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 7ac53264ead3..68a301710297 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -91,6 +91,7 @@ ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
 
         int rv;
         int is_bigendian;
+        struct device_node *np;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -147,6 +148,30 @@ ohci_hcd_ppc_of_probe(struct of_device *op, const struct of_device_id *match)
         if (rv == 0)
                 return 0;
 
+        /* by now, 440epx is known to show usb_23 erratum */
+        np = of_find_compatible_node(NULL, NULL, "ibm,usb-ehci-440epx");
+
+        /* Work around - At this point ohci_run has executed, the
+        * controller is running, everything, the root ports, etc., is
+        * set up.  If the ehci driver is loaded, put the ohci core in
+        * the suspended state.  The ehci driver will bring it out of
+        * suspended state when / if a non-high speed USB device is
+        * attached to the USB Host port.  If the ehci driver is not
+        * loaded, do nothing. request_mem_region is used to test if
+        * the ehci driver is loaded.
+        */
+        if (np !=  NULL) {
+                if (!of_address_to_resource(np, 0, &res)) {
+                        if (!request_mem_region(res.start, 0x4, hcd_name)) {
+                                writel_be((readl_be(&ohci->regs->control) |
+                                        OHCI_USB_SUSPEND), &ohci->regs->control);
+                                        (void) readl_be(&ohci->regs->control);
+                        } else
+                                release_mem_region(res.start, 0x4);
+                } else
+                    pr_debug(__FILE__ ": cannot get ehci offset from fdt\n");
+        }
+
         iounmap(hcd->regs);
 err_ioremap:
         irq_dispose_mapping(irq);
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index f9f134af0bd1..8dabe8e31d8c 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -201,7 +201,7 @@ static int __devinit ohci_hcd_tmio_drv_probe(struct platform_device *dev)
         if (!cell)
                 return -EINVAL;
 
-        hcd = usb_create_hcd(&ohci_tmio_hc_driver, &dev->dev, dev->dev.bus_id);
+        hcd = usb_create_hcd(&ohci_tmio_hc_driver, &dev->dev, dev_name(&dev->dev));
         if (!hcd) {
                 ret = -ENOMEM;
                 goto err_usb_create_hcd;
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
new file mode 100644
index 000000000000..75548f7c716b
--- /dev/null
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -0,0 +1,3985 @@
+/*
+ * Copyright (c) 2008 Rodolfo Giometti <giometti@linux.it>
+ * Copyright (c) 2008 Eurotech S.p.A. <info@eurtech.it>
+ *
+ * This code is *strongly* based on EHCI-HCD code by David Brownell since
+ * the chip is a quasi-EHCI compatible.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dmapool.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/ioport.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/reboot.h>
+#include <linux/usb.h>
+#include <linux/moduleparam.h>
+#include <linux/dma-mapping.h>
+#include <linux/io.h>
+
+#include "../core/hcd.h"
+
+#include <asm/irq.h>
+#include <asm/system.h>
+#include <asm/unaligned.h>
+
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+
+#include "oxu210hp.h"
+
+#define DRIVER_VERSION "0.0.50"
+
+/*
+ * Main defines
+ */
+
+#define oxu_dbg(oxu, fmt, args...) \
+                dev_dbg(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
+#define oxu_err(oxu, fmt, args...) \
+                dev_err(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
+#define oxu_info(oxu, fmt, args...) \
+                dev_info(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
+
+static inline struct usb_hcd *oxu_to_hcd(struct oxu_hcd *oxu)
+{
+        return container_of((void *) oxu, struct usb_hcd, hcd_priv);
+}
+
+static inline struct oxu_hcd *hcd_to_oxu(struct usb_hcd *hcd)
+{
+        return (struct oxu_hcd *) (hcd->hcd_priv);
+}
+
+/*
+ * Debug stuff
+ */
+
+#undef OXU_URB_TRACE
+#undef OXU_VERBOSE_DEBUG
+
+#ifdef OXU_VERBOSE_DEBUG
+#define oxu_vdbg                        oxu_dbg
+#else
+#define oxu_vdbg(oxu, fmt, args...)     /* Nop */
+#endif
+
+#ifdef DEBUG
+
+static int __attribute__((__unused__))
+dbg_status_buf(char *buf, unsigned len, const char *label, u32 status)
+{
+        return scnprintf(buf, len, "%s%sstatus %04x%s%s%s%s%s%s%s%s%s%s",
+                label, label[0] ? " " : "", status,
+                (status & STS_ASS) ? " Async" : "",
+                (status & STS_PSS) ? " Periodic" : "",
+                (status & STS_RECL) ? " Recl" : "",
+                (status & STS_HALT) ? " Halt" : "",
+                (status & STS_IAA) ? " IAA" : "",
+                (status & STS_FATAL) ? " FATAL" : "",
+                (status & STS_FLR) ? " FLR" : "",
+                (status & STS_PCD) ? " PCD" : "",
+                (status & STS_ERR) ? " ERR" : "",
+                (status & STS_INT) ? " INT" : ""
+                );
+}
+
+static int __attribute__((__unused__))
+dbg_intr_buf(char *buf, unsigned len, const char *label, u32 enable)
+{
+        return scnprintf(buf, len, "%s%sintrenable %02x%s%s%s%s%s%s",
+                label, label[0] ? " " : "", enable,
+                (enable & STS_IAA) ? " IAA" : "",
+                (enable & STS_FATAL) ? " FATAL" : "",
+                (enable & STS_FLR) ? " FLR" : "",
+                (enable & STS_PCD) ? " PCD" : "",
+                (enable & STS_ERR) ? " ERR" : "",
+                (enable & STS_INT) ? " INT" : ""
+                );
+}
+
+static const char *const fls_strings[] =
+    { "1024", "512", "256", "??" };
+
+static int dbg_command_buf(char *buf, unsigned len,
+                                const char *label, u32 command)
+{
+        return scnprintf(buf, len,
+                "%s%scommand %06x %s=%d ithresh=%d%s%s%s%s period=%s%s %s",
+                label, label[0] ? " " : "", command,
+                (command & CMD_PARK) ? "park" : "(park)",
+                CMD_PARK_CNT(command),
+                (command >> 16) & 0x3f,
+                (command & CMD_LRESET) ? " LReset" : "",
+                (command & CMD_IAAD) ? " IAAD" : "",
+                (command & CMD_ASE) ? " Async" : "",
+                (command & CMD_PSE) ? " Periodic" : "",
+                fls_strings[(command >> 2) & 0x3],
+                (command & CMD_RESET) ? " Reset" : "",
+                (command & CMD_RUN) ? "RUN" : "HALT"
+                );
+}
+
+static int dbg_port_buf(char *buf, unsigned len, const char *label,
+                                int port, u32 status)
+{
+        char    *sig;
+
+        /* signaling state */
+        switch (status & (3 << 10)) {
+        case 0 << 10:
+                sig = "se0";
+                break;
+        case 1 << 10:
+                sig = "k";      /* low speed */
+                break;
+        case 2 << 10:
+                sig = "j";
+                break;
+        default:
+                sig = "?";
+                break;
+        }
+
+        return scnprintf(buf, len,
+                "%s%sport %d status %06x%s%s sig=%s%s%s%s%s%s%s%s%s%s",
+                label, label[0] ? " " : "", port, status,
+                (status & PORT_POWER) ? " POWER" : "",
+                (status & PORT_OWNER) ? " OWNER" : "",
+                sig,
+                (status & PORT_RESET) ? " RESET" : "",
+                (status & PORT_SUSPEND) ? " SUSPEND" : "",
+                (status & PORT_RESUME) ? " RESUME" : "",
+                (status & PORT_OCC) ? " OCC" : "",
+                (status & PORT_OC) ? " OC" : "",
+                (status & PORT_PEC) ? " PEC" : "",
+                (status & PORT_PE) ? " PE" : "",
+                (status & PORT_CSC) ? " CSC" : "",
+                (status & PORT_CONNECT) ? " CONNECT" : ""
+            );
+}
+
+#else
+
+static inline int __attribute__((__unused__))
+dbg_status_buf(char *buf, unsigned len, const char *label, u32 status)
+{ return 0; }
+
+static inline int __attribute__((__unused__))
+dbg_command_buf(char *buf, unsigned len, const char *label, u32 command)
+{ return 0; }
+
+static inline int __attribute__((__unused__))
+dbg_intr_buf(char *buf, unsigned len, const char *label, u32 enable)
+{ return 0; }
+
+static inline int __attribute__((__unused__))
+dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
+{ return 0; }
+
+#endif /* DEBUG */
+
+/* functions have the "wrong" filename when they're output... */
+#define dbg_status(oxu, label, status) { \
+        char _buf[80]; \
+        dbg_status_buf(_buf, sizeof _buf, label, status); \
+        oxu_dbg(oxu, "%s\n", _buf); \
+}
+
+#define dbg_cmd(oxu, label, command) { \
+        char _buf[80]; \
+        dbg_command_buf(_buf, sizeof _buf, label, command); \
+        oxu_dbg(oxu, "%s\n", _buf); \
+}
+
+#define dbg_port(oxu, label, port, status) { \
+        char _buf[80]; \
+        dbg_port_buf(_buf, sizeof _buf, label, port, status); \
+        oxu_dbg(oxu, "%s\n", _buf); \
+}
+
+/*
+ * Module parameters
+ */
+
+/* Initial IRQ latency: faster than hw default */
+static int log2_irq_thresh;                     /* 0 to 6 */
+module_param(log2_irq_thresh, int, S_IRUGO);
+MODULE_PARM_DESC(log2_irq_thresh, "log2 IRQ latency, 1-64 microframes");
+
+/* Initial park setting: slower than hw default */
+static unsigned park;
+module_param(park, uint, S_IRUGO);
+MODULE_PARM_DESC(park, "park setting; 1-3 back-to-back async packets");
+
+/* For flakey hardware, ignore overcurrent indicators */
+static int ignore_oc;
+module_param(ignore_oc, bool, S_IRUGO);
+MODULE_PARM_DESC(ignore_oc, "ignore bogus hardware overcurrent indications");
+
+
+static void ehci_work(struct oxu_hcd *oxu);
+static int oxu_hub_control(struct usb_hcd *hcd,
+                                u16 typeReq, u16 wValue, u16 wIndex,
+                                char *buf, u16 wLength);
+
+/*
+ * Local functions
+ */
+
+/* Low level read/write registers functions */
+static inline u32 oxu_readl(void *base, u32 reg)
+{
+        return readl(base + reg);
+}
+
+static inline void oxu_writel(void *base, u32 reg, u32 val)
+{
+        writel(val, base + reg);
+}
+
+static inline void timer_action_done(struct oxu_hcd *oxu,
+                                        enum ehci_timer_action action)
+{
+        clear_bit(action, &oxu->actions);
+}
+
+static inline void timer_action(struct oxu_hcd *oxu,
+                                        enum ehci_timer_action action)
+{
+        if (!test_and_set_bit(action, &oxu->actions)) {
+                unsigned long t;
+
+                switch (action) {
+                case TIMER_IAA_WATCHDOG:
+                        t = EHCI_IAA_JIFFIES;
+                        break;
+                case TIMER_IO_WATCHDOG:
+                        t = EHCI_IO_JIFFIES;
+                        break;
+                case TIMER_ASYNC_OFF:
+                        t = EHCI_ASYNC_JIFFIES;
+                        break;
+                case TIMER_ASYNC_SHRINK:
+                default:
+                        t = EHCI_SHRINK_JIFFIES;
+                        break;
+                }
+                t += jiffies;
+                /* all timings except IAA watchdog can be overridden.
+                 * async queue SHRINK often precedes IAA.  while it's ready
+                 * to go OFF neither can matter, and afterwards the IO
+                 * watchdog stops unless there's still periodic traffic.
+                 */
+                if (action != TIMER_IAA_WATCHDOG
+                                && t > oxu->watchdog.expires
+                                && timer_pending(&oxu->watchdog))
+                        return;
+                mod_timer(&oxu->watchdog, t);
+        }
+}
+
+/*
+ * handshake - spin reading hc until handshake completes or fails
+ * @ptr: address of hc register to be read
+ * @mask: bits to look at in result of read
+ * @done: value of those bits when handshake succeeds
+ * @usec: timeout in microseconds
+ *
+ * Returns negative errno, or zero on success
+ *
+ * Success happens when the "mask" bits have the specified value (hardware
+ * handshake done).  There are two failure modes:  "usec" have passed (major
+ * hardware flakeout), or the register reads as all-ones (hardware removed).
+ *
+ * That last failure should_only happen in cases like physical cardbus eject
+ * before driver shutdown. But it also seems to be caused by bugs in cardbus
+ * bridge shutdown:  shutting down the bridge before the devices using it.
+ */
+static int handshake(struct oxu_hcd *oxu, void __iomem *ptr,
+                                        u32 mask, u32 done, int usec)
+{
+        u32 result;
+
+        do {
+                result = readl(ptr);
+                if (result == ~(u32)0)          /* card removed */
+                        return -ENODEV;
+                result &= mask;
+                if (result == done)
+                        return 0;
+                udelay(1);
+                usec--;
+        } while (usec > 0);
+        return -ETIMEDOUT;
+}
+
+/* Force HC to halt state from unknown (EHCI spec section 2.3) */
+static int ehci_halt(struct oxu_hcd *oxu)
+{
+        u32     temp = readl(&oxu->regs->status);
+
+        /* disable any irqs left enabled by previous code */
+        writel(0, &oxu->regs->intr_enable);
+
+        if ((temp & STS_HALT) != 0)
+                return 0;
+
+        temp = readl(&oxu->regs->command);
+        temp &= ~CMD_RUN;
+        writel(temp, &oxu->regs->command);
+        return handshake(oxu, &oxu->regs->status,
+                          STS_HALT, STS_HALT, 16 * 125);
+}
+
+/* Put TDI/ARC silicon into EHCI mode */
+static void tdi_reset(struct oxu_hcd *oxu)
+{
+        u32 __iomem *reg_ptr;
+        u32 tmp;
+
+        reg_ptr = (u32 __iomem *)(((u8 __iomem *)oxu->regs) + 0x68);
+        tmp = readl(reg_ptr);
+        tmp |= 0x3;
+        writel(tmp, reg_ptr);
+}
+
+/* Reset a non-running (STS_HALT == 1) controller */
+static int ehci_reset(struct oxu_hcd *oxu)
+{
+        int     retval;
+        u32     command = readl(&oxu->regs->command);
+
+        command |= CMD_RESET;
+        dbg_cmd(oxu, "reset", command);
+        writel(command, &oxu->regs->command);
+        oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+        oxu->next_statechange = jiffies;
+        retval = handshake(oxu, &oxu->regs->command,
+                            CMD_RESET, 0, 250 * 1000);
+
+        if (retval)
+                return retval;
+
+        tdi_reset(oxu);
+
+        return retval;
+}
+
+/* Idle the controller (from running) */
+static void ehci_quiesce(struct oxu_hcd *oxu)
+{
+        u32     temp;
+
+#ifdef DEBUG
+        if (!HC_IS_RUNNING(oxu_to_hcd(oxu)->state))
+                BUG();
+#endif
+
+        /* wait for any schedule enables/disables to take effect */
+        temp = readl(&oxu->regs->command) << 10;
+        temp &= STS_ASS | STS_PSS;
+        if (handshake(oxu, &oxu->regs->status, STS_ASS | STS_PSS,
+                                temp, 16 * 125) != 0) {
+                oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                return;
+        }
+
+        /* then disable anything that's still active */
+        temp = readl(&oxu->regs->command);
+        temp &= ~(CMD_ASE | CMD_IAAD | CMD_PSE);
+        writel(temp, &oxu->regs->command);
+
+        /* hardware can take 16 microframes to turn off ... */
+        if (handshake(oxu, &oxu->regs->status, STS_ASS | STS_PSS,
+                                0, 16 * 125) != 0) {
+                oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                return;
+        }
+}
+
+static int check_reset_complete(struct oxu_hcd *oxu, int index,
+                                u32 __iomem *status_reg, int port_status)
+{
+        if (!(port_status & PORT_CONNECT)) {
+                oxu->reset_done[index] = 0;
+                return port_status;
+        }
+
+        /* if reset finished and it's still not enabled -- handoff */
+        if (!(port_status & PORT_PE)) {
+                oxu_dbg(oxu, "Failed to enable port %d on root hub TT\n",
+                                index+1);
+                return port_status;
+        } else
+                oxu_dbg(oxu, "port %d high speed\n", index + 1);
+
+        return port_status;
+}
+
+static void ehci_hub_descriptor(struct oxu_hcd *oxu,
+                                struct usb_hub_descriptor *desc)
+{
+        int ports = HCS_N_PORTS(oxu->hcs_params);
+        u16 temp;
+
+        desc->bDescriptorType = 0x29;
+        desc->bPwrOn2PwrGood = 10;      /* oxu 1.0, 2.3.9 says 20ms max */
+        desc->bHubContrCurrent = 0;
+
+        desc->bNbrPorts = ports;
+        temp = 1 + (ports / 8);
+        desc->bDescLength = 7 + 2 * temp;
+
+        /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
+        memset(&desc->bitmap[0], 0, temp);
+        memset(&desc->bitmap[temp], 0xff, temp);
+
+        temp = 0x0008;                  /* per-port overcurrent reporting */
+        if (HCS_PPC(oxu->hcs_params))
+                temp |= 0x0001;         /* per-port power control */
+        else
+                temp |= 0x0002;         /* no power switching */
+        desc->wHubCharacteristics = (__force __u16)cpu_to_le16(temp);
+}
+
+
+/* Allocate an OXU210HP on-chip memory data buffer
+ *
+ * An on-chip memory data buffer is required for each OXU210HP USB transfer.
+ * Each transfer descriptor has one or more on-chip memory data buffers.
+ *
+ * Data buffers are allocated from a fix sized pool of data blocks.
+ * To minimise fragmentation and give reasonable memory utlisation,
+ * data buffers are allocated with sizes the power of 2 multiples of
+ * the block size, starting on an address a multiple of the allocated size.
+ *
+ * FIXME: callers of this function require a buffer to be allocated for
+ * len=0. This is a waste of on-chip memory and should be fix. Then this
+ * function should be changed to not allocate a buffer for len=0.
+ */
+static int oxu_buf_alloc(struct oxu_hcd *oxu, struct ehci_qtd *qtd, int len)
+{
+        int n_blocks;   /* minium blocks needed to hold len */
+        int a_blocks;   /* blocks allocated */
+        int i, j;
+
+        /* Don't allocte bigger than supported */
+        if (len > BUFFER_SIZE * BUFFER_NUM) {
+                oxu_err(oxu, "buffer too big (%d)\n", len);
+                return -ENOMEM;
+        }
+
+        spin_lock(&oxu->mem_lock);
+
+        /* Number of blocks needed to hold len */
+        n_blocks = (len + BUFFER_SIZE - 1) / BUFFER_SIZE;
+
+        /* Round the number of blocks up to the power of 2 */
+        for (a_blocks = 1; a_blocks < n_blocks; a_blocks <<= 1)
+                ;
+
+        /* Find a suitable available data buffer */
+        for (i = 0; i < BUFFER_NUM;
+                        i += max(a_blocks, (int)oxu->db_used[i])) {
+
+                /* Check all the required blocks are available */
+                for (j = 0; j < a_blocks; j++)
+                        if (oxu->db_used[i + j])
+                                break;
+
+                if (j != a_blocks)
+                        continue;
+
+                /* Allocate blocks found! */
+                qtd->buffer = (void *) &oxu->mem->db_pool[i];
+                qtd->buffer_dma = virt_to_phys(qtd->buffer);
+
+                qtd->qtd_buffer_len = BUFFER_SIZE * a_blocks;
+                oxu->db_used[i] = a_blocks;
+
+                spin_unlock(&oxu->mem_lock);
+
+                return 0;
+        }
+
+        /* Failed */
+
+        spin_unlock(&oxu->mem_lock);
+
+        return -ENOMEM;
+}
+
+static void oxu_buf_free(struct oxu_hcd *oxu, struct ehci_qtd *qtd)
+{
+        int index;
+
+        spin_lock(&oxu->mem_lock);
+
+        index = (qtd->buffer - (void *) &oxu->mem->db_pool[0])
+                                                         / BUFFER_SIZE;
+        oxu->db_used[index] = 0;
+        qtd->qtd_buffer_len = 0;
+        qtd->buffer_dma = 0;
+        qtd->buffer = NULL;
+
+        spin_unlock(&oxu->mem_lock);
+
+        return;
+}
+
+static inline void ehci_qtd_init(struct ehci_qtd *qtd, dma_addr_t dma)
+{
+        memset(qtd, 0, sizeof *qtd);
+        qtd->qtd_dma = dma;
+        qtd->hw_token = cpu_to_le32(QTD_STS_HALT);
+        qtd->hw_next = EHCI_LIST_END;
+        qtd->hw_alt_next = EHCI_LIST_END;
+        INIT_LIST_HEAD(&qtd->qtd_list);
+}
+
+static inline void oxu_qtd_free(struct oxu_hcd *oxu, struct ehci_qtd *qtd)
+{
+        int index;
+
+        if (qtd->buffer)
+                oxu_buf_free(oxu, qtd);
+
+        spin_lock(&oxu->mem_lock);
+
+        index = qtd - &oxu->mem->qtd_pool[0];
+        oxu->qtd_used[index] = 0;
+
+        spin_unlock(&oxu->mem_lock);
+
+        return;
+}
+
+static struct ehci_qtd *ehci_qtd_alloc(struct oxu_hcd *oxu)
+{
+        int i;
+        struct ehci_qtd *qtd = NULL;
+
+        spin_lock(&oxu->mem_lock);
+
+        for (i = 0; i < QTD_NUM; i++)
+                if (!oxu->qtd_used[i])
+                        break;
+
+        if (i < QTD_NUM) {
+                qtd = (struct ehci_qtd *) &oxu->mem->qtd_pool[i];
+                memset(qtd, 0, sizeof *qtd);
+
+                qtd->hw_token = cpu_to_le32(QTD_STS_HALT);
+                qtd->hw_next = EHCI_LIST_END;
+                qtd->hw_alt_next = EHCI_LIST_END;
+                INIT_LIST_HEAD(&qtd->qtd_list);
+
+                qtd->qtd_dma = virt_to_phys(qtd);
+
+                oxu->qtd_used[i] = 1;
+        }
+
+        spin_unlock(&oxu->mem_lock);
+
+        return qtd;
+}
+
+static void oxu_qh_free(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        int index;
+
+        spin_lock(&oxu->mem_lock);
+
+        index = qh - &oxu->mem->qh_pool[0];
+        oxu->qh_used[index] = 0;
+
+        spin_unlock(&oxu->mem_lock);
+
+        return;
+}
+
+static void qh_destroy(struct kref *kref)
+{
+        struct ehci_qh *qh = container_of(kref, struct ehci_qh, kref);
+        struct oxu_hcd *oxu = qh->oxu;
+
+        /* clean qtds first, and know this is not linked */
+        if (!list_empty(&qh->qtd_list) || qh->qh_next.ptr) {
+                oxu_dbg(oxu, "unused qh not empty!\n");
+                BUG();
+        }
+        if (qh->dummy)
+                oxu_qtd_free(oxu, qh->dummy);
+        oxu_qh_free(oxu, qh);
+}
+
+static struct ehci_qh *oxu_qh_alloc(struct oxu_hcd *oxu)
+{
+        int i;
+        struct ehci_qh *qh = NULL;
+
+        spin_lock(&oxu->mem_lock);
+
+        for (i = 0; i < QHEAD_NUM; i++)
+                if (!oxu->qh_used[i])
+                        break;
+
+        if (i < QHEAD_NUM) {
+                qh = (struct ehci_qh *) &oxu->mem->qh_pool[i];
+                memset(qh, 0, sizeof *qh);
+
+                kref_init(&qh->kref);
+                qh->oxu = oxu;
+                qh->qh_dma = virt_to_phys(qh);
+                INIT_LIST_HEAD(&qh->qtd_list);
+
+                /* dummy td enables safe urb queuing */
+                qh->dummy = ehci_qtd_alloc(oxu);
+                if (qh->dummy == NULL) {
+                        oxu_dbg(oxu, "no dummy td\n");
+                        oxu->qh_used[i] = 0;
+
+                        return NULL;
+                }
+
+                oxu->qh_used[i] = 1;
+        }
+
+        spin_unlock(&oxu->mem_lock);
+
+        return qh;
+}
+
+/* to share a qh (cpu threads, or hc) */
+static inline struct ehci_qh *qh_get(struct ehci_qh *qh)
+{
+        kref_get(&qh->kref);
+        return qh;
+}
+
+static inline void qh_put(struct ehci_qh *qh)
+{
+        kref_put(&qh->kref, qh_destroy);
+}
+
+static void oxu_murb_free(struct oxu_hcd *oxu, struct oxu_murb *murb)
+{
+        int index;
+
+        spin_lock(&oxu->mem_lock);
+
+        index = murb - &oxu->murb_pool[0];
+        oxu->murb_used[index] = 0;
+
+        spin_unlock(&oxu->mem_lock);
+
+        return;
+}
+
+static struct oxu_murb *oxu_murb_alloc(struct oxu_hcd *oxu)
+
+{
+        int i;
+        struct oxu_murb *murb = NULL;
+
+        spin_lock(&oxu->mem_lock);
+
+        for (i = 0; i < MURB_NUM; i++)
+                if (!oxu->murb_used[i])
+                        break;
+
+        if (i < MURB_NUM) {
+                murb = &(oxu->murb_pool)[i];
+
+                oxu->murb_used[i] = 1;
+        }
+
+        spin_unlock(&oxu->mem_lock);
+
+        return murb;
+}
+
+/* The queue heads and transfer descriptors are managed from pools tied
+ * to each of the "per device" structures.
+ * This is the initialisation and cleanup code.
+ */
+static void ehci_mem_cleanup(struct oxu_hcd *oxu)
+{
+        kfree(oxu->murb_pool);
+        oxu->murb_pool = NULL;
+
+        if (oxu->async)
+                qh_put(oxu->async);
+        oxu->async = NULL;
+
+        del_timer(&oxu->urb_timer);
+
+        oxu->periodic = NULL;
+
+        /* shadow periodic table */
+        kfree(oxu->pshadow);
+        oxu->pshadow = NULL;
+}
+
+/* Remember to add cleanup code (above) if you add anything here.
+ */
+static int ehci_mem_init(struct oxu_hcd *oxu, gfp_t flags)
+{
+        int i;
+
+        for (i = 0; i < oxu->periodic_size; i++)
+                oxu->mem->frame_list[i] = EHCI_LIST_END;
+        for (i = 0; i < QHEAD_NUM; i++)
+                oxu->qh_used[i] = 0;
+        for (i = 0; i < QTD_NUM; i++)
+                oxu->qtd_used[i] = 0;
+
+        oxu->murb_pool = kcalloc(MURB_NUM, sizeof(struct oxu_murb), flags);
+        if (!oxu->murb_pool)
+                goto fail;
+
+        for (i = 0; i < MURB_NUM; i++)
+                oxu->murb_used[i] = 0;
+
+        oxu->async = oxu_qh_alloc(oxu);
+        if (!oxu->async)
+                goto fail;
+
+        oxu->periodic = (__le32 *) &oxu->mem->frame_list;
+        oxu->periodic_dma = virt_to_phys(oxu->periodic);
+
+        for (i = 0; i < oxu->periodic_size; i++)
+                oxu->periodic[i] = EHCI_LIST_END;
+
+        /* software shadow of hardware table */
+        oxu->pshadow = kcalloc(oxu->periodic_size, sizeof(void *), flags);
+        if (oxu->pshadow != NULL)
+                return 0;
+
+fail:
+        oxu_dbg(oxu, "couldn't init memory\n");
+        ehci_mem_cleanup(oxu);
+        return -ENOMEM;
+}
+
+/* Fill a qtd, returning how much of the buffer we were able to queue up.
+ */
+static int qtd_fill(struct ehci_qtd *qtd, dma_addr_t buf, size_t len,
+                                int token, int maxpacket)
+{
+        int i, count;
+        u64 addr = buf;
+
+        /* one buffer entry per 4K ... first might be short or unaligned */
+        qtd->hw_buf[0] = cpu_to_le32((u32)addr);
+        qtd->hw_buf_hi[0] = cpu_to_le32((u32)(addr >> 32));
+        count = 0x1000 - (buf & 0x0fff);        /* rest of that page */
+        if (likely(len < count))                /* ... iff needed */
+                count = len;
+        else {
+                buf +=  0x1000;
+                buf &= ~0x0fff;
+
+                /* per-qtd limit: from 16K to 20K (best alignment) */
+                for (i = 1; count < len && i < 5; i++) {
+                        addr = buf;
+                        qtd->hw_buf[i] = cpu_to_le32((u32)addr);
+                        qtd->hw_buf_hi[i] = cpu_to_le32((u32)(addr >> 32));
+                        buf += 0x1000;
+                        if ((count + 0x1000) < len)
+                                count += 0x1000;
+                        else
+                                count = len;
+                }
+
+                /* short packets may only terminate transfers */
+                if (count != len)
+                        count -= (count % maxpacket);
+        }
+        qtd->hw_token = cpu_to_le32((count << 16) | token);
+        qtd->length = count;
+
+        return count;
+}
+
+static inline void qh_update(struct oxu_hcd *oxu,
+                                struct ehci_qh *qh, struct ehci_qtd *qtd)
+{
+        /* writes to an active overlay are unsafe */
+        BUG_ON(qh->qh_state != QH_STATE_IDLE);
+
+        qh->hw_qtd_next = QTD_NEXT(qtd->qtd_dma);
+        qh->hw_alt_next = EHCI_LIST_END;
+
+        /* Except for control endpoints, we make hardware maintain data
+         * toggle (like OHCI) ... here (re)initialize the toggle in the QH,
+         * and set the pseudo-toggle in udev. Only usb_clear_halt() will
+         * ever clear it.
+         */
+        if (!(qh->hw_info1 & cpu_to_le32(1 << 14))) {
+                unsigned        is_out, epnum;
+
+                is_out = !(qtd->hw_token & cpu_to_le32(1 << 8));
+                epnum = (le32_to_cpup(&qh->hw_info1) >> 8) & 0x0f;
+                if (unlikely(!usb_gettoggle(qh->dev, epnum, is_out))) {
+                        qh->hw_token &= ~__constant_cpu_to_le32(QTD_TOGGLE);
+                        usb_settoggle(qh->dev, epnum, is_out, 1);
+                }
+        }
+
+        /* HC must see latest qtd and qh data before we clear ACTIVE+HALT */
+        wmb();
+        qh->hw_token &= __constant_cpu_to_le32(QTD_TOGGLE | QTD_STS_PING);
+}
+
+/* If it weren't for a common silicon quirk (writing the dummy into the qh
+ * overlay, so qh->hw_token wrongly becomes inactive/halted), only fault
+ * recovery (including urb dequeue) would need software changes to a QH...
+ */
+static void qh_refresh(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        struct ehci_qtd *qtd;
+
+        if (list_empty(&qh->qtd_list))
+                qtd = qh->dummy;
+        else {
+                qtd = list_entry(qh->qtd_list.next,
+                                struct ehci_qtd, qtd_list);
+                /* first qtd may already be partially processed */
+                if (cpu_to_le32(qtd->qtd_dma) == qh->hw_current)
+                        qtd = NULL;
+        }
+
+        if (qtd)
+                qh_update(oxu, qh, qtd);
+}
+
+static void qtd_copy_status(struct oxu_hcd *oxu, struct urb *urb,
+                                size_t length, u32 token)
+{
+        /* count IN/OUT bytes, not SETUP (even short packets) */
+        if (likely(QTD_PID(token) != 2))
+                urb->actual_length += length - QTD_LENGTH(token);
+
+        /* don't modify error codes */
+        if (unlikely(urb->status != -EINPROGRESS))
+                return;
+
+        /* force cleanup after short read; not always an error */
+        if (unlikely(IS_SHORT_READ(token)))
+                urb->status = -EREMOTEIO;
+
+        /* serious "can't proceed" faults reported by the hardware */
+        if (token & QTD_STS_HALT) {
+                if (token & QTD_STS_BABBLE) {
+                        /* FIXME "must" disable babbling device's port too */
+                        urb->status = -EOVERFLOW;
+                } else if (token & QTD_STS_MMF) {
+                        /* fs/ls interrupt xfer missed the complete-split */
+                        urb->status = -EPROTO;
+                } else if (token & QTD_STS_DBE) {
+                        urb->status = (QTD_PID(token) == 1) /* IN ? */
+                                ? -ENOSR  /* hc couldn't read data */
+                                : -ECOMM; /* hc couldn't write data */
+                } else if (token & QTD_STS_XACT) {
+                        /* timeout, bad crc, wrong PID, etc; retried */
+                        if (QTD_CERR(token))
+                                urb->status = -EPIPE;
+                        else {
+                                oxu_dbg(oxu, "devpath %s ep%d%s 3strikes\n",
+                                        urb->dev->devpath,
+                                        usb_pipeendpoint(urb->pipe),
+                                        usb_pipein(urb->pipe) ? "in" : "out");
+                                urb->status = -EPROTO;
+                        }
+                /* CERR nonzero + no errors + halt --> stall */
+                } else if (QTD_CERR(token))
+                        urb->status = -EPIPE;
+                else    /* unknown */
+                        urb->status = -EPROTO;
+
+                oxu_vdbg(oxu, "dev%d ep%d%s qtd token %08x --> status %d\n",
+                        usb_pipedevice(urb->pipe),
+                        usb_pipeendpoint(urb->pipe),
+                        usb_pipein(urb->pipe) ? "in" : "out",
+                        token, urb->status);
+        }
+}
+
+static void ehci_urb_done(struct oxu_hcd *oxu, struct urb *urb)
+__releases(oxu->lock)
+__acquires(oxu->lock)
+{
+        if (likely(urb->hcpriv != NULL)) {
+                struct ehci_qh  *qh = (struct ehci_qh *) urb->hcpriv;
+
+                /* S-mask in a QH means it's an interrupt urb */
+                if ((qh->hw_info2 & __constant_cpu_to_le32(QH_SMASK)) != 0) {
+
+                        /* ... update hc-wide periodic stats (for usbfs) */
+                        oxu_to_hcd(oxu)->self.bandwidth_int_reqs--;
+                }
+                qh_put(qh);
+        }
+
+        urb->hcpriv = NULL;
+        switch (urb->status) {
+        case -EINPROGRESS:              /* success */
+                urb->status = 0;
+        default:                        /* fault */
+                break;
+        case -EREMOTEIO:                /* fault or normal */
+                if (!(urb->transfer_flags & URB_SHORT_NOT_OK))
+                        urb->status = 0;
+                break;
+        case -ECONNRESET:               /* canceled */
+        case -ENOENT:
+                break;
+        }
+
+#ifdef OXU_URB_TRACE
+        oxu_dbg(oxu, "%s %s urb %p ep%d%s status %d len %d/%d\n",
+                __func__, urb->dev->devpath, urb,
+                usb_pipeendpoint(urb->pipe),
+                usb_pipein(urb->pipe) ? "in" : "out",
+                urb->status,
+                urb->actual_length, urb->transfer_buffer_length);
+#endif
+
+        /* complete() can reenter this HCD */
+        spin_unlock(&oxu->lock);
+        usb_hcd_giveback_urb(oxu_to_hcd(oxu), urb, urb->status);
+        spin_lock(&oxu->lock);
+}
+
+static void start_unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh);
+static void unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh);
+
+static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
+static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh);
+
+#define HALT_BIT __constant_cpu_to_le32(QTD_STS_HALT)
+
+/* Process and free completed qtds for a qh, returning URBs to drivers.
+ * Chases up to qh->hw_current.  Returns number of completions called,
+ * indicating how much "real" work we did.
+ */
+static unsigned qh_completions(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        struct ehci_qtd *last = NULL, *end = qh->dummy;
+        struct list_head *entry, *tmp;
+        int stopped;
+        unsigned count = 0;
+        int do_status = 0;
+        u8 state;
+        struct oxu_murb *murb = NULL;
+
+        if (unlikely(list_empty(&qh->qtd_list)))
+                return count;
+
+        /* completions (or tasks on other cpus) must never clobber HALT
+         * till we've gone through and cleaned everything up, even when
+         * they add urbs to this qh's queue or mark them for unlinking.
+         *
+         * NOTE:  unlinking expects to be done in queue order.
+         */
+        state = qh->qh_state;
+        qh->qh_state = QH_STATE_COMPLETING;
+        stopped = (state == QH_STATE_IDLE);
+
+        /* remove de-activated QTDs from front of queue.
+         * after faults (including short reads), cleanup this urb
+         * then let the queue advance.
+         * if queue is stopped, handles unlinks.
+         */
+        list_for_each_safe(entry, tmp, &qh->qtd_list) {
+                struct ehci_qtd *qtd;
+                struct urb *urb;
+                u32 token = 0;
+
+                qtd = list_entry(entry, struct ehci_qtd, qtd_list);
+                urb = qtd->urb;
+
+                /* Clean up any state from previous QTD ...*/
+                if (last) {
+                        if (likely(last->urb != urb)) {
+                                if (last->urb->complete == NULL) {
+                                        murb = (struct oxu_murb *) last->urb;
+                                        last->urb = murb->main;
+                                        if (murb->last) {
+                                                ehci_urb_done(oxu, last->urb);
+                                                count++;
+                                        }
+                                        oxu_murb_free(oxu, murb);
+                                } else {
+                                        ehci_urb_done(oxu, last->urb);
+                                        count++;
+                                }
+                        }
+                        oxu_qtd_free(oxu, last);
+                        last = NULL;
+                }
+
+                /* ignore urbs submitted during completions we reported */
+                if (qtd == end)
+                        break;
+
+                /* hardware copies qtd out of qh overlay */
+                rmb();
+                token = le32_to_cpu(qtd->hw_token);
+
+                /* always clean up qtds the hc de-activated */
+                if ((token & QTD_STS_ACTIVE) == 0) {
+
+                        if ((token & QTD_STS_HALT) != 0) {
+                                stopped = 1;
+
+                        /* magic dummy for some short reads; qh won't advance.
+                         * that silicon quirk can kick in with this dummy too.
+                         */
+                        } else if (IS_SHORT_READ(token) &&
+                                        !(qtd->hw_alt_next & EHCI_LIST_END)) {
+                                stopped = 1;
+                                goto halt;
+                        }
+
+                /* stop scanning when we reach qtds the hc is using */
+                } else if (likely(!stopped &&
+                                HC_IS_RUNNING(oxu_to_hcd(oxu)->state))) {
+                        break;
+
+                } else {
+                        stopped = 1;
+
+                        if (unlikely(!HC_IS_RUNNING(oxu_to_hcd(oxu)->state)))
+                                urb->status = -ESHUTDOWN;
+
+                        /* ignore active urbs unless some previous qtd
+                         * for the urb faulted (including short read) or
+                         * its urb was canceled.  we may patch qh or qtds.
+                         */
+                        if (likely(urb->status == -EINPROGRESS))
+                                continue;
+
+                        /* issue status after short control reads */
+                        if (unlikely(do_status != 0)
+                                        && QTD_PID(token) == 0 /* OUT */) {
+                                do_status = 0;
+                                continue;
+                        }
+
+                        /* token in overlay may be most current */
+                        if (state == QH_STATE_IDLE
+                                        && cpu_to_le32(qtd->qtd_dma)
+                                                == qh->hw_current)
+                                token = le32_to_cpu(qh->hw_token);
+
+                        /* force halt for unlinked or blocked qh, so we'll
+                         * patch the qh later and so that completions can't
+                         * activate it while we "know" it's stopped.
+                         */
+                        if ((HALT_BIT & qh->hw_token) == 0) {
+halt:
+                                qh->hw_token |= HALT_BIT;
+                                wmb();
+                        }
+                }
+
+                /* Remove it from the queue */
+                qtd_copy_status(oxu, urb->complete ?
+                                        urb : ((struct oxu_murb *) urb)->main,
+                                qtd->length, token);
+                if ((usb_pipein(qtd->urb->pipe)) &&
+                                (NULL != qtd->transfer_buffer))
+                        memcpy(qtd->transfer_buffer, qtd->buffer, qtd->length);
+                do_status = (urb->status == -EREMOTEIO)
+                                && usb_pipecontrol(urb->pipe);
+
+                if (stopped && qtd->qtd_list.prev != &qh->qtd_list) {
+                        last = list_entry(qtd->qtd_list.prev,
+                                        struct ehci_qtd, qtd_list);
+                        last->hw_next = qtd->hw_next;
+                }
+                list_del(&qtd->qtd_list);
+                last = qtd;
+        }
+
+        /* last urb's completion might still need calling */
+        if (likely(last != NULL)) {
+                if (last->urb->complete == NULL) {
+                        murb = (struct oxu_murb *) last->urb;
+                        last->urb = murb->main;
+                        if (murb->last) {
+                                ehci_urb_done(oxu, last->urb);
+                                count++;
+                        }
+                        oxu_murb_free(oxu, murb);
+                } else {
+                        ehci_urb_done(oxu, last->urb);
+                        count++;
+                }
+                oxu_qtd_free(oxu, last);
+        }
+
+        /* restore original state; caller must unlink or relink */
+        qh->qh_state = state;
+
+        /* be sure the hardware's done with the qh before refreshing
+         * it after fault cleanup, or recovering from silicon wrongly
+         * overlaying the dummy qtd (which reduces DMA chatter).
+         */
+        if (stopped != 0 || qh->hw_qtd_next == EHCI_LIST_END) {
+                switch (state) {
+                case QH_STATE_IDLE:
+                        qh_refresh(oxu, qh);
+                        break;
+                case QH_STATE_LINKED:
+                        /* should be rare for periodic transfers,
+                         * except maybe high bandwidth ...
+                         */
+                        if ((__constant_cpu_to_le32(QH_SMASK)
+                                        & qh->hw_info2) != 0) {
+                                intr_deschedule(oxu, qh);
+                                (void) qh_schedule(oxu, qh);
+                        } else
+                                unlink_async(oxu, qh);
+                        break;
+                /* otherwise, unlink already started */
+                }
+        }
+
+        return count;
+}
+
+/* High bandwidth multiplier, as encoded in highspeed endpoint descriptors */
+#define hb_mult(wMaxPacketSize)         (1 + (((wMaxPacketSize) >> 11) & 0x03))
+/* ... and packet size, for any kind of endpoint descriptor */
+#define max_packet(wMaxPacketSize)      ((wMaxPacketSize) & 0x07ff)
+
+/* Reverse of qh_urb_transaction: free a list of TDs.
+ * used for cleanup after errors, before HC sees an URB's TDs.
+ */
+static void qtd_list_free(struct oxu_hcd *oxu,
+                                struct urb *urb, struct list_head *qtd_list)
+{
+        struct list_head *entry, *temp;
+
+        list_for_each_safe(entry, temp, qtd_list) {
+                struct ehci_qtd *qtd;
+
+                qtd = list_entry(entry, struct ehci_qtd, qtd_list);
+                list_del(&qtd->qtd_list);
+                oxu_qtd_free(oxu, qtd);
+        }
+}
+
+/* Create a list of filled qtds for this URB; won't link into qh.
+ */
+static struct list_head *qh_urb_transaction(struct oxu_hcd *oxu,
+                                                struct urb *urb,
+                                                struct list_head *head,
+                                                gfp_t flags)
+{
+        struct ehci_qtd *qtd, *qtd_prev;
+        dma_addr_t buf;
+        int len, maxpacket;
+        int is_input;
+        u32 token;
+        void *transfer_buf = NULL;
+        int ret;
+
+        /*
+         * URBs map to sequences of QTDs: one logical transaction
+         */
+        qtd = ehci_qtd_alloc(oxu);
+        if (unlikely(!qtd))
+                return NULL;
+        list_add_tail(&qtd->qtd_list, head);
+        qtd->urb = urb;
+
+        token = QTD_STS_ACTIVE;
+        token |= (EHCI_TUNE_CERR << 10);
+        /* for split transactions, SplitXState initialized to zero */
+
+        len = urb->transfer_buffer_length;
+        is_input = usb_pipein(urb->pipe);
+        if (!urb->transfer_buffer && urb->transfer_buffer_length && is_input)
+                urb->transfer_buffer = phys_to_virt(urb->transfer_dma);
+
+        if (usb_pipecontrol(urb->pipe)) {
+                /* SETUP pid */
+                ret = oxu_buf_alloc(oxu, qtd, sizeof(struct usb_ctrlrequest));
+                if (ret)
+                        goto cleanup;
+
+                qtd_fill(qtd, qtd->buffer_dma, sizeof(struct usb_ctrlrequest),
+                                token | (2 /* "setup" */ << 8), 8);
+                memcpy(qtd->buffer, qtd->urb->setup_packet,
+                                sizeof(struct usb_ctrlrequest));
+
+                /* ... and always at least one more pid */
+                token ^= QTD_TOGGLE;
+                qtd_prev = qtd;
+                qtd = ehci_qtd_alloc(oxu);
+                if (unlikely(!qtd))
+                        goto cleanup;
+                qtd->urb = urb;
+                qtd_prev->hw_next = QTD_NEXT(qtd->qtd_dma);
+                list_add_tail(&qtd->qtd_list, head);
+
+                /* for zero length DATA stages, STATUS is always IN */
+                if (len == 0)
+                        token |= (1 /* "in" */ << 8);
+        }
+
+        /*
+         * Data transfer stage: buffer setup
+         */
+
+        ret = oxu_buf_alloc(oxu, qtd, len);
+        if (ret)
+                goto cleanup;
+
+        buf = qtd->buffer_dma;
+        transfer_buf = urb->transfer_buffer;
+
+        if (!is_input)
+                memcpy(qtd->buffer, qtd->urb->transfer_buffer, len);
+
+        if (is_input)
+                token |= (1 /* "in" */ << 8);
+        /* else it's already initted to "out" pid (0 << 8) */
+
+        maxpacket = max_packet(usb_maxpacket(urb->dev, urb->pipe, !is_input));
+
+        /*
+         * buffer gets wrapped in one or more qtds;
+         * last one may be "short" (including zero len)
+         * and may serve as a control status ack
+         */
+        for (;;) {
+                int this_qtd_len;
+
+                this_qtd_len = qtd_fill(qtd, buf, len, token, maxpacket);
+                qtd->transfer_buffer = transfer_buf;
+                len -= this_qtd_len;
+                buf += this_qtd_len;
+                transfer_buf += this_qtd_len;
+                if (is_input)
+                        qtd->hw_alt_next = oxu->async->hw_alt_next;
+
+                /* qh makes control packets use qtd toggle; maybe switch it */
+                if ((maxpacket & (this_qtd_len + (maxpacket - 1))) == 0)
+                        token ^= QTD_TOGGLE;
+
+                if (likely(len <= 0))
+                        break;
+
+                qtd_prev = qtd;
+                qtd = ehci_qtd_alloc(oxu);
+                if (unlikely(!qtd))
+                        goto cleanup;
+                if (likely(len > 0)) {
+                        ret = oxu_buf_alloc(oxu, qtd, len);
+                        if (ret)
+                                goto cleanup;
+                }
+                qtd->urb = urb;
+                qtd_prev->hw_next = QTD_NEXT(qtd->qtd_dma);
+                list_add_tail(&qtd->qtd_list, head);
+        }
+
+        /* unless the bulk/interrupt caller wants a chance to clean
+         * up after short reads, hc should advance qh past this urb
+         */
+        if (likely((urb->transfer_flags & URB_SHORT_NOT_OK) == 0
+                                || usb_pipecontrol(urb->pipe)))
+                qtd->hw_alt_next = EHCI_LIST_END;
+
+        /*
+         * control requests may need a terminating data "status" ack;
+         * bulk ones may need a terminating short packet (zero length).
+         */
+        if (likely(urb->transfer_buffer_length != 0)) {
+                int     one_more = 0;
+
+                if (usb_pipecontrol(urb->pipe)) {
+                        one_more = 1;
+                        token ^= 0x0100;        /* "in" <--> "out"  */
+                        token |= QTD_TOGGLE;    /* force DATA1 */
+                } else if (usb_pipebulk(urb->pipe)
+                                && (urb->transfer_flags & URB_ZERO_PACKET)
+                                && !(urb->transfer_buffer_length % maxpacket)) {
+                        one_more = 1;
+                }
+                if (one_more) {
+                        qtd_prev = qtd;
+                        qtd = ehci_qtd_alloc(oxu);
+                        if (unlikely(!qtd))
+                                goto cleanup;
+                        qtd->urb = urb;
+                        qtd_prev->hw_next = QTD_NEXT(qtd->qtd_dma);
+                        list_add_tail(&qtd->qtd_list, head);
+
+                        /* never any data in such packets */
+                        qtd_fill(qtd, 0, 0, token, 0);
+                }
+        }
+
+        /* by default, enable interrupt on urb completion */
+                qtd->hw_token |= __constant_cpu_to_le32(QTD_IOC);
+        return head;
+
+cleanup:
+        qtd_list_free(oxu, urb, head);
+        return NULL;
+}
+
+/* Each QH holds a qtd list; a QH is used for everything except iso.
+ *
+ * For interrupt urbs, the scheduler must set the microframe scheduling
+ * mask(s) each time the QH gets scheduled.  For highspeed, that's
+ * just one microframe in the s-mask.  For split interrupt transactions
+ * there are additional complications: c-mask, maybe FSTNs.
+ */
+static struct ehci_qh *qh_make(struct oxu_hcd *oxu,
+                                struct urb *urb, gfp_t flags)
+{
+        struct ehci_qh *qh = oxu_qh_alloc(oxu);
+        u32 info1 = 0, info2 = 0;
+        int is_input, type;
+        int maxp = 0;
+
+        if (!qh)
+                return qh;
+
+        /*
+         * init endpoint/device data for this QH
+         */
+        info1 |= usb_pipeendpoint(urb->pipe) << 8;
+        info1 |= usb_pipedevice(urb->pipe) << 0;
+
+        is_input = usb_pipein(urb->pipe);
+        type = usb_pipetype(urb->pipe);
+        maxp = usb_maxpacket(urb->dev, urb->pipe, !is_input);
+
+        /* Compute interrupt scheduling parameters just once, and save.
+         * - allowing for high bandwidth, how many nsec/uframe are used?
+         * - split transactions need a second CSPLIT uframe; same question
+         * - splits also need a schedule gap (for full/low speed I/O)
+         * - qh has a polling interval
+         *
+         * For control/bulk requests, the HC or TT handles these.
+         */
+        if (type == PIPE_INTERRUPT) {
+                qh->usecs = NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH,
+                                                                is_input, 0,
+                                hb_mult(maxp) * max_packet(maxp)));
+                qh->start = NO_FRAME;
+
+                if (urb->dev->speed == USB_SPEED_HIGH) {
+                        qh->c_usecs = 0;
+                        qh->gap_uf = 0;
+
+                        qh->period = urb->interval >> 3;
+                        if (qh->period == 0 && urb->interval != 1) {
+                                /* NOTE interval 2 or 4 uframes could work.
+                                 * But interval 1 scheduling is simpler, and
+                                 * includes high bandwidth.
+                                 */
+                                dbg("intr period %d uframes, NYET!",
+                                                urb->interval);
+                                goto done;
+                        }
+                } else {
+                        struct usb_tt   *tt = urb->dev->tt;
+                        int             think_time;
+
+                        /* gap is f(FS/LS transfer times) */
+                        qh->gap_uf = 1 + usb_calc_bus_time(urb->dev->speed,
+                                        is_input, 0, maxp) / (125 * 1000);
+
+                        /* FIXME this just approximates SPLIT/CSPLIT times */
+                        if (is_input) {         /* SPLIT, gap, CSPLIT+DATA */
+                                qh->c_usecs = qh->usecs + HS_USECS(0);
+                                qh->usecs = HS_USECS(1);
+                        } else {                /* SPLIT+DATA, gap, CSPLIT */
+                                qh->usecs += HS_USECS(1);
+                                qh->c_usecs = HS_USECS(0);
+                        }
+
+                        think_time = tt ? tt->think_time : 0;
+                        qh->tt_usecs = NS_TO_US(think_time +
+                                        usb_calc_bus_time(urb->dev->speed,
+                                        is_input, 0, max_packet(maxp)));
+                        qh->period = urb->interval;
+                }
+        }
+
+        /* support for tt scheduling, and access to toggles */
+        qh->dev = urb->dev;
+
+        /* using TT? */
+        switch (urb->dev->speed) {
+        case USB_SPEED_LOW:
+                info1 |= (1 << 12);     /* EPS "low" */
+                /* FALL THROUGH */
+
+        case USB_SPEED_FULL:
+                /* EPS 0 means "full" */
+                if (type != PIPE_INTERRUPT)
+                        info1 |= (EHCI_TUNE_RL_TT << 28);
+                if (type == PIPE_CONTROL) {
+                        info1 |= (1 << 27);     /* for TT */
+                        info1 |= 1 << 14;       /* toggle from qtd */
+                }
+                info1 |= maxp << 16;
+
+                info2 |= (EHCI_TUNE_MULT_TT << 30);
+                info2 |= urb->dev->ttport << 23;
+
+                /* NOTE:  if (PIPE_INTERRUPT) { scheduler sets c-mask } */
+
+                break;
+
+        case USB_SPEED_HIGH:            /* no TT involved */
+                info1 |= (2 << 12);     /* EPS "high" */
+                if (type == PIPE_CONTROL) {
+                        info1 |= (EHCI_TUNE_RL_HS << 28);
+                        info1 |= 64 << 16;      /* usb2 fixed maxpacket */
+                        info1 |= 1 << 14;       /* toggle from qtd */
+                        info2 |= (EHCI_TUNE_MULT_HS << 30);
+                } else if (type == PIPE_BULK) {
+                        info1 |= (EHCI_TUNE_RL_HS << 28);
+                        info1 |= 512 << 16;     /* usb2 fixed maxpacket */
+                        info2 |= (EHCI_TUNE_MULT_HS << 30);
+                } else {                /* PIPE_INTERRUPT */
+                        info1 |= max_packet(maxp) << 16;
+                        info2 |= hb_mult(maxp) << 30;
+                }
+                break;
+        default:
+                dbg("bogus dev %p speed %d", urb->dev, urb->dev->speed);
+done:
+                qh_put(qh);
+                return NULL;
+        }
+
+        /* NOTE:  if (PIPE_INTERRUPT) { scheduler sets s-mask } */
+
+        /* init as live, toggle clear, advance to dummy */
+        qh->qh_state = QH_STATE_IDLE;
+        qh->hw_info1 = cpu_to_le32(info1);
+        qh->hw_info2 = cpu_to_le32(info2);
+        usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), !is_input, 1);
+        qh_refresh(oxu, qh);
+        return qh;
+}
+
+/* Move qh (and its qtds) onto async queue; maybe enable queue.
+ */
+static void qh_link_async(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        __le32 dma = QH_NEXT(qh->qh_dma);
+        struct ehci_qh *head;
+
+        /* (re)start the async schedule? */
+        head = oxu->async;
+        timer_action_done(oxu, TIMER_ASYNC_OFF);
+        if (!head->qh_next.qh) {
+                u32     cmd = readl(&oxu->regs->command);
+
+                if (!(cmd & CMD_ASE)) {
+                        /* in case a clear of CMD_ASE didn't take yet */
+                        (void)handshake(oxu, &oxu->regs->status,
+                                        STS_ASS, 0, 150);
+                        cmd |= CMD_ASE | CMD_RUN;
+                        writel(cmd, &oxu->regs->command);
+                        oxu_to_hcd(oxu)->state = HC_STATE_RUNNING;
+                        /* posted write need not be known to HC yet ... */
+                }
+        }
+
+        /* clear halt and/or toggle; and maybe recover from silicon quirk */
+        if (qh->qh_state == QH_STATE_IDLE)
+                qh_refresh(oxu, qh);
+
+        /* splice right after start */
+        qh->qh_next = head->qh_next;
+        qh->hw_next = head->hw_next;
+        wmb();
+
+        head->qh_next.qh = qh;
+        head->hw_next = dma;
+
+        qh->qh_state = QH_STATE_LINKED;
+        /* qtd completions reported later by interrupt */
+}
+
+#define QH_ADDR_MASK    __constant_cpu_to_le32(0x7f)
+
+/*
+ * For control/bulk/interrupt, return QH with these TDs appended.
+ * Allocates and initializes the QH if necessary.
+ * Returns null if it can't allocate a QH it needs to.
+ * If the QH has TDs (urbs) already, that's great.
+ */
+static struct ehci_qh *qh_append_tds(struct oxu_hcd *oxu,
+                                struct urb *urb, struct list_head *qtd_list,
+                                int epnum, void **ptr)
+{
+        struct ehci_qh *qh = NULL;
+
+        qh = (struct ehci_qh *) *ptr;
+        if (unlikely(qh == NULL)) {
+                /* can't sleep here, we have oxu->lock... */
+                qh = qh_make(oxu, urb, GFP_ATOMIC);
+                *ptr = qh;
+        }
+        if (likely(qh != NULL)) {
+                struct ehci_qtd *qtd;
+
+                if (unlikely(list_empty(qtd_list)))
+                        qtd = NULL;
+                else
+                        qtd = list_entry(qtd_list->next, struct ehci_qtd,
+                                        qtd_list);
+
+                /* control qh may need patching ... */
+                if (unlikely(epnum == 0)) {
+
+                        /* usb_reset_device() briefly reverts to address 0 */
+                        if (usb_pipedevice(urb->pipe) == 0)
+                                qh->hw_info1 &= ~QH_ADDR_MASK;
+                }
+
+                /* just one way to queue requests: swap with the dummy qtd.
+                 * only hc or qh_refresh() ever modify the overlay.
+                 */
+                if (likely(qtd != NULL)) {
+                        struct ehci_qtd *dummy;
+                        dma_addr_t dma;
+                        __le32 token;
+
+                        /* to avoid racing the HC, use the dummy td instead of
+                         * the first td of our list (becomes new dummy).  both
+                         * tds stay deactivated until we're done, when the
+                         * HC is allowed to fetch the old dummy (4.10.2).
+                         */
+                        token = qtd->hw_token;
+                        qtd->hw_token = HALT_BIT;
+                        wmb();
+                        dummy = qh->dummy;
+
+                        dma = dummy->qtd_dma;
+                        *dummy = *qtd;
+                        dummy->qtd_dma = dma;
+
+                        list_del(&qtd->qtd_list);
+                        list_add(&dummy->qtd_list, qtd_list);
+                        list_splice(qtd_list, qh->qtd_list.prev);
+
+                        ehci_qtd_init(qtd, qtd->qtd_dma);
+                        qh->dummy = qtd;
+
+                        /* hc must see the new dummy at list end */
+                        dma = qtd->qtd_dma;
+                        qtd = list_entry(qh->qtd_list.prev,
+                                        struct ehci_qtd, qtd_list);
+                        qtd->hw_next = QTD_NEXT(dma);
+
+                        /* let the hc process these next qtds */
+                        dummy->hw_token = (token & ~(0x80));
+                        wmb();
+                        dummy->hw_token = token;
+
+                        urb->hcpriv = qh_get(qh);
+                }
+        }
+        return qh;
+}
+
+static int submit_async(struct oxu_hcd  *oxu, struct urb *urb,
+                        struct list_head *qtd_list, gfp_t mem_flags)
+{
+        struct ehci_qtd *qtd;
+        int epnum;
+        unsigned long flags;
+        struct ehci_qh *qh = NULL;
+        int rc = 0;
+
+        qtd = list_entry(qtd_list->next, struct ehci_qtd, qtd_list);
+        epnum = urb->ep->desc.bEndpointAddress;
+
+#ifdef OXU_URB_TRACE
+        oxu_dbg(oxu, "%s %s urb %p ep%d%s len %d, qtd %p [qh %p]\n",
+                __func__, urb->dev->devpath, urb,
+                epnum & 0x0f, (epnum & USB_DIR_IN) ? "in" : "out",
+                urb->transfer_buffer_length,
+                qtd, urb->ep->hcpriv);
+#endif
+
+        spin_lock_irqsave(&oxu->lock, flags);
+        if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE,
+                               &oxu_to_hcd(oxu)->flags))) {
+                rc = -ESHUTDOWN;
+                goto done;
+        }
+
+        qh = qh_append_tds(oxu, urb, qtd_list, epnum, &urb->ep->hcpriv);
+        if (unlikely(qh == NULL)) {
+                rc = -ENOMEM;
+                goto done;
+        }
+
+        /* Control/bulk operations through TTs don't need scheduling,
+         * the HC and TT handle it when the TT has a buffer ready.
+         */
+        if (likely(qh->qh_state == QH_STATE_IDLE))
+                qh_link_async(oxu, qh_get(qh));
+done:
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        if (unlikely(qh == NULL))
+                qtd_list_free(oxu, urb, qtd_list);
+        return rc;
+}
+
+/* The async qh for the qtds being reclaimed are now unlinked from the HC */
+
+static void end_unlink_async(struct oxu_hcd *oxu)
+{
+        struct ehci_qh *qh = oxu->reclaim;
+        struct ehci_qh *next;
+
+        timer_action_done(oxu, TIMER_IAA_WATCHDOG);
+
+        qh->qh_state = QH_STATE_IDLE;
+        qh->qh_next.qh = NULL;
+        qh_put(qh);                     /* refcount from reclaim */
+
+        /* other unlink(s) may be pending (in QH_STATE_UNLINK_WAIT) */
+        next = qh->reclaim;
+        oxu->reclaim = next;
+        oxu->reclaim_ready = 0;
+        qh->reclaim = NULL;
+
+        qh_completions(oxu, qh);
+
+        if (!list_empty(&qh->qtd_list)
+                        && HC_IS_RUNNING(oxu_to_hcd(oxu)->state))
+                qh_link_async(oxu, qh);
+        else {
+                qh_put(qh);             /* refcount from async list */
+
+                /* it's not free to turn the async schedule on/off; leave it
+                 * active but idle for a while once it empties.
+                 */
+                if (HC_IS_RUNNING(oxu_to_hcd(oxu)->state)
+                                && oxu->async->qh_next.qh == NULL)
+                        timer_action(oxu, TIMER_ASYNC_OFF);
+        }
+
+        if (next) {
+                oxu->reclaim = NULL;
+                start_unlink_async(oxu, next);
+        }
+}
+
+/* makes sure the async qh will become idle */
+/* caller must own oxu->lock */
+
+static void start_unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        int cmd = readl(&oxu->regs->command);
+        struct ehci_qh *prev;
+
+#ifdef DEBUG
+        assert_spin_locked(&oxu->lock);
+        if (oxu->reclaim || (qh->qh_state != QH_STATE_LINKED
+                                && qh->qh_state != QH_STATE_UNLINK_WAIT))
+                BUG();
+#endif
+
+        /* stop async schedule right now? */
+        if (unlikely(qh == oxu->async)) {
+                /* can't get here without STS_ASS set */
+                if (oxu_to_hcd(oxu)->state != HC_STATE_HALT
+                                && !oxu->reclaim) {
+                        /* ... and CMD_IAAD clear */
+                        writel(cmd & ~CMD_ASE, &oxu->regs->command);
+                        wmb();
+                        /* handshake later, if we need to */
+                        timer_action_done(oxu, TIMER_ASYNC_OFF);
+                }
+                return;
+        }
+
+        qh->qh_state = QH_STATE_UNLINK;
+        oxu->reclaim = qh = qh_get(qh);
+
+        prev = oxu->async;
+        while (prev->qh_next.qh != qh)
+                prev = prev->qh_next.qh;
+
+        prev->hw_next = qh->hw_next;
+        prev->qh_next = qh->qh_next;
+        wmb();
+
+        if (unlikely(oxu_to_hcd(oxu)->state == HC_STATE_HALT)) {
+                /* if (unlikely(qh->reclaim != 0))
+                 *      this will recurse, probably not much
+                 */
+                end_unlink_async(oxu);
+                return;
+        }
+
+        oxu->reclaim_ready = 0;
+        cmd |= CMD_IAAD;
+        writel(cmd, &oxu->regs->command);
+        (void) readl(&oxu->regs->command);
+        timer_action(oxu, TIMER_IAA_WATCHDOG);
+}
+
+static void scan_async(struct oxu_hcd *oxu)
+{
+        struct ehci_qh *qh;
+        enum ehci_timer_action action = TIMER_IO_WATCHDOG;
+
+        if (!++(oxu->stamp))
+                oxu->stamp++;
+        timer_action_done(oxu, TIMER_ASYNC_SHRINK);
+rescan:
+        qh = oxu->async->qh_next.qh;
+        if (likely(qh != NULL)) {
+                do {
+                        /* clean any finished work for this qh */
+                        if (!list_empty(&qh->qtd_list)
+                                        && qh->stamp != oxu->stamp) {
+                                int temp;
+
+                                /* unlinks could happen here; completion
+                                 * reporting drops the lock.  rescan using
+                                 * the latest schedule, but don't rescan
+                                 * qhs we already finished (no looping).
+                                 */
+                                qh = qh_get(qh);
+                                qh->stamp = oxu->stamp;
+                                temp = qh_completions(oxu, qh);
+                                qh_put(qh);
+                                if (temp != 0)
+                                        goto rescan;
+                        }
+
+                        /* unlink idle entries, reducing HC PCI 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 == oxu->stamp)
+                                        action = TIMER_ASYNC_SHRINK;
+                                else if (!oxu->reclaim
+                                            && qh->qh_state == QH_STATE_LINKED)
+                                        start_unlink_async(oxu, qh);
+                        }
+
+                        qh = qh->qh_next.qh;
+                } while (qh);
+        }
+        if (action == TIMER_ASYNC_SHRINK)
+                timer_action(oxu, TIMER_ASYNC_SHRINK);
+}
+
+/*
+ * periodic_next_shadow - return "next" pointer on shadow list
+ * @periodic: host pointer to qh/itd/sitd
+ * @tag: hardware tag for type of this record
+ */
+static union ehci_shadow *periodic_next_shadow(union ehci_shadow *periodic,
+                                                __le32 tag)
+{
+        switch (tag) {
+        default:
+        case Q_TYPE_QH:
+                return &periodic->qh->qh_next;
+        }
+}
+
+/* caller must hold oxu->lock */
+static void periodic_unlink(struct oxu_hcd *oxu, unsigned frame, void *ptr)
+{
+        union ehci_shadow *prev_p = &oxu->pshadow[frame];
+        __le32 *hw_p = &oxu->periodic[frame];
+        union ehci_shadow here = *prev_p;
+
+        /* find predecessor of "ptr"; hw and shadow lists are in sync */
+        while (here.ptr && here.ptr != ptr) {
+                prev_p = periodic_next_shadow(prev_p, Q_NEXT_TYPE(*hw_p));
+                hw_p = here.hw_next;
+                here = *prev_p;
+        }
+        /* an interrupt entry (at list end) could have been shared */
+        if (!here.ptr)
+                return;
+
+        /* update shadow and hardware lists ... the old "next" pointers
+         * from ptr may still be in use, the caller updates them.
+         */
+        *prev_p = *periodic_next_shadow(&here, Q_NEXT_TYPE(*hw_p));
+        *hw_p = *here.hw_next;
+}
+
+/* how many of the uframe's 125 usecs are allocated? */
+static unsigned short periodic_usecs(struct oxu_hcd *oxu,
+                                        unsigned frame, unsigned uframe)
+{
+        __le32 *hw_p = &oxu->periodic[frame];
+        union ehci_shadow *q = &oxu->pshadow[frame];
+        unsigned usecs = 0;
+
+        while (q->ptr) {
+                switch (Q_NEXT_TYPE(*hw_p)) {
+                case Q_TYPE_QH:
+                default:
+                        /* is it in the S-mask? */
+                        if (q->qh->hw_info2 & cpu_to_le32(1 << uframe))
+                                usecs += q->qh->usecs;
+                        /* ... or C-mask? */
+                        if (q->qh->hw_info2 & cpu_to_le32(1 << (8 + uframe)))
+                                usecs += q->qh->c_usecs;
+                        hw_p = &q->qh->hw_next;
+                        q = &q->qh->qh_next;
+                        break;
+                }
+        }
+#ifdef DEBUG
+        if (usecs > 100)
+                oxu_err(oxu, "uframe %d sched overrun: %d usecs\n",
+                                                frame * 8 + uframe, usecs);
+#endif
+        return usecs;
+}
+
+static int enable_periodic(struct oxu_hcd *oxu)
+{
+        u32 cmd;
+        int status;
+
+        /* did clearing PSE did take effect yet?
+         * takes effect only at frame boundaries...
+         */
+        status = handshake(oxu, &oxu->regs->status, STS_PSS, 0, 9 * 125);
+        if (status != 0) {
+                oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                return status;
+        }
+
+        cmd = readl(&oxu->regs->command) | CMD_PSE;
+        writel(cmd, &oxu->regs->command);
+        /* posted write ... PSS happens later */
+        oxu_to_hcd(oxu)->state = HC_STATE_RUNNING;
+
+        /* make sure ehci_work scans these */
+        oxu->next_uframe = readl(&oxu->regs->frame_index)
+                % (oxu->periodic_size << 3);
+        return 0;
+}
+
+static int disable_periodic(struct oxu_hcd *oxu)
+{
+        u32 cmd;
+        int status;
+
+        /* did setting PSE not take effect yet?
+         * takes effect only at frame boundaries...
+         */
+        status = handshake(oxu, &oxu->regs->status, STS_PSS, STS_PSS, 9 * 125);
+        if (status != 0) {
+                oxu_to_hcd(oxu)->state = HC_STATE_HALT;
+                return status;
+        }
+
+        cmd = readl(&oxu->regs->command) & ~CMD_PSE;
+        writel(cmd, &oxu->regs->command);
+        /* posted write ... */
+
+        oxu->next_uframe = -1;
+        return 0;
+}
+
+/* periodic schedule slots have iso tds (normal or split) first, then a
+ * sparse tree for active interrupt transfers.
+ *
+ * this just links in a qh; caller guarantees uframe masks are set right.
+ * no FSTN support (yet; oxu 0.96+)
+ */
+static int qh_link_periodic(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        unsigned i;
+        unsigned period = qh->period;
+
+        dev_dbg(&qh->dev->dev,
+                "link qh%d-%04x/%p start %d [%d/%d us]\n",
+                period, le32_to_cpup(&qh->hw_info2) & (QH_CMASK | QH_SMASK),
+                qh, qh->start, qh->usecs, qh->c_usecs);
+
+        /* high bandwidth, or otherwise every microframe */
+        if (period == 0)
+                period = 1;
+
+        for (i = qh->start; i < oxu->periodic_size; i += period) {
+                union ehci_shadow       *prev = &oxu->pshadow[i];
+                __le32                  *hw_p = &oxu->periodic[i];
+                union ehci_shadow       here = *prev;
+                __le32                  type = 0;
+
+                /* skip the iso nodes at list head */
+                while (here.ptr) {
+                        type = Q_NEXT_TYPE(*hw_p);
+                        if (type == Q_TYPE_QH)
+                                break;
+                        prev = periodic_next_shadow(prev, type);
+                        hw_p = &here.qh->hw_next;
+                        here = *prev;
+                }
+
+                /* sorting each branch by period (slow-->fast)
+                 * enables sharing interior tree nodes
+                 */
+                while (here.ptr && qh != here.qh) {
+                        if (qh->period > here.qh->period)
+                                break;
+                        prev = &here.qh->qh_next;
+                        hw_p = &here.qh->hw_next;
+                        here = *prev;
+                }
+                /* link in this qh, unless some earlier pass did that */
+                if (qh != here.qh) {
+                        qh->qh_next = here;
+                        if (here.qh)
+                                qh->hw_next = *hw_p;
+                        wmb();
+                        prev->qh = qh;
+                        *hw_p = QH_NEXT(qh->qh_dma);
+                }
+        }
+        qh->qh_state = QH_STATE_LINKED;
+        qh_get(qh);
+
+        /* update per-qh bandwidth for usbfs */
+        oxu_to_hcd(oxu)->self.bandwidth_allocated += qh->period
+                ? ((qh->usecs + qh->c_usecs) / qh->period)
+                : (qh->usecs * 8);
+
+        /* maybe enable periodic schedule processing */
+        if (!oxu->periodic_sched++)
+                return enable_periodic(oxu);
+
+        return 0;
+}
+
+static void qh_unlink_periodic(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        unsigned i;
+        unsigned period;
+
+        /* FIXME:
+         *   IF this isn't high speed
+         *   and this qh is active in the current uframe
+         *   (and overlay token SplitXstate is false?)
+         * THEN
+         *   qh->hw_info1 |= __constant_cpu_to_le32(1 << 7 "ignore");
+         */
+
+        /* high bandwidth, or otherwise part of every microframe */
+        period = qh->period;
+        if (period == 0)
+                period = 1;
+
+        for (i = qh->start; i < oxu->periodic_size; i += period)
+                periodic_unlink(oxu, i, qh);
+
+        /* update per-qh bandwidth for usbfs */
+        oxu_to_hcd(oxu)->self.bandwidth_allocated -= qh->period
+                ? ((qh->usecs + qh->c_usecs) / qh->period)
+                : (qh->usecs * 8);
+
+        dev_dbg(&qh->dev->dev,
+                "unlink qh%d-%04x/%p start %d [%d/%d us]\n",
+                qh->period,
+                le32_to_cpup(&qh->hw_info2) & (QH_CMASK | QH_SMASK),
+                qh, qh->start, qh->usecs, qh->c_usecs);
+
+        /* qh->qh_next still "live" to HC */
+        qh->qh_state = QH_STATE_UNLINK;
+        qh->qh_next.ptr = NULL;
+        qh_put(qh);
+
+        /* maybe turn off periodic schedule */
+        oxu->periodic_sched--;
+        if (!oxu->periodic_sched)
+                (void) disable_periodic(oxu);
+}
+
+static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        unsigned wait;
+
+        qh_unlink_periodic(oxu, qh);
+
+        /* simple/paranoid:  always delay, expecting the HC needs to read
+         * qh->hw_next or finish a writeback after SPLIT/CSPLIT ... and
+         * expect khubd to clean up after any CSPLITs we won't issue.
+         * active high speed queues may need bigger delays...
+         */
+        if (list_empty(&qh->qtd_list)
+                || (__constant_cpu_to_le32(QH_CMASK) & qh->hw_info2) != 0)
+                wait = 2;
+        else
+                wait = 55;      /* worst case: 3 * 1024 */
+
+        udelay(wait);
+        qh->qh_state = QH_STATE_IDLE;
+        qh->hw_next = EHCI_LIST_END;
+        wmb();
+}
+
+static int check_period(struct oxu_hcd *oxu,
+                        unsigned frame, unsigned uframe,
+                        unsigned period, unsigned usecs)
+{
+        int claimed;
+
+        /* complete split running into next frame?
+         * given FSTN support, we could sometimes check...
+         */
+        if (uframe >= 8)
+                return 0;
+
+        /*
+         * 80% periodic == 100 usec/uframe available
+         * convert "usecs we need" to "max already claimed"
+         */
+        usecs = 100 - usecs;
+
+        /* we "know" 2 and 4 uframe intervals were rejected; so
+         * for period 0, check _every_ microframe in the schedule.
+         */
+        if (unlikely(period == 0)) {
+                do {
+                        for (uframe = 0; uframe < 7; uframe++) {
+                                claimed = periodic_usecs(oxu, frame, uframe);
+                                if (claimed > usecs)
+                                        return 0;
+                        }
+                } while ((frame += 1) < oxu->periodic_size);
+
+        /* just check the specified uframe, at that period */
+        } else {
+                do {
+                        claimed = periodic_usecs(oxu, frame, uframe);
+                        if (claimed > usecs)
+                                return 0;
+                } while ((frame += period) < oxu->periodic_size);
+        }
+
+        return 1;
+}
+
+static int check_intr_schedule(struct oxu_hcd   *oxu,
+                                unsigned frame, unsigned uframe,
+                                const struct ehci_qh *qh, __le32 *c_maskp)
+{
+        int retval = -ENOSPC;
+
+        if (qh->c_usecs && uframe >= 6)         /* FSTN territory? */
+                goto done;
+
+        if (!check_period(oxu, frame, uframe, qh->period, qh->usecs))
+                goto done;
+        if (!qh->c_usecs) {
+                retval = 0;
+                *c_maskp = 0;
+                goto done;
+        }
+
+done:
+        return retval;
+}
+
+/* "first fit" scheduling policy used the first time through,
+ * or when the previous schedule slot can't be re-used.
+ */
+static int qh_schedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        int             status;
+        unsigned        uframe;
+        __le32          c_mask;
+        unsigned        frame;          /* 0..(qh->period - 1), or NO_FRAME */
+
+        qh_refresh(oxu, qh);
+        qh->hw_next = EHCI_LIST_END;
+        frame = qh->start;
+
+        /* reuse the previous schedule slots, if we can */
+        if (frame < qh->period) {
+                uframe = ffs(le32_to_cpup(&qh->hw_info2) & QH_SMASK);
+                status = check_intr_schedule(oxu, frame, --uframe,
+                                qh, &c_mask);
+        } else {
+                uframe = 0;
+                c_mask = 0;
+                status = -ENOSPC;
+        }
+
+        /* else scan the schedule to find a group of slots such that all
+         * uframes have enough periodic bandwidth available.
+         */
+        if (status) {
+                /* "normal" case, uframing flexible except with splits */
+                if (qh->period) {
+                        frame = qh->period - 1;
+                        do {
+                                for (uframe = 0; uframe < 8; uframe++) {
+                                        status = check_intr_schedule(oxu,
+                                                        frame, uframe, qh,
+                                                        &c_mask);
+                                        if (status == 0)
+                                                break;
+                                }
+                        } while (status && frame--);
+
+                /* qh->period == 0 means every uframe */
+                } else {
+                        frame = 0;
+                        status = check_intr_schedule(oxu, 0, 0, qh, &c_mask);
+                }
+                if (status)
+                        goto done;
+                qh->start = frame;
+
+                /* reset S-frame and (maybe) C-frame masks */
+                qh->hw_info2 &= __constant_cpu_to_le32(~(QH_CMASK | QH_SMASK));
+                qh->hw_info2 |= qh->period
+                        ? cpu_to_le32(1 << uframe)
+                        : __constant_cpu_to_le32(QH_SMASK);
+                qh->hw_info2 |= c_mask;
+        } else
+                oxu_dbg(oxu, "reused qh %p schedule\n", qh);
+
+        /* stuff into the periodic schedule */
+        status = qh_link_periodic(oxu, qh);
+done:
+        return status;
+}
+
+static int intr_submit(struct oxu_hcd *oxu, struct urb *urb,
+                        struct list_head *qtd_list, gfp_t mem_flags)
+{
+        unsigned epnum;
+        unsigned long flags;
+        struct ehci_qh *qh;
+        int status = 0;
+        struct list_head        empty;
+
+        /* get endpoint and transfer/schedule data */
+        epnum = urb->ep->desc.bEndpointAddress;
+
+        spin_lock_irqsave(&oxu->lock, flags);
+
+        if (unlikely(!test_bit(HCD_FLAG_HW_ACCESSIBLE,
+                               &oxu_to_hcd(oxu)->flags))) {
+                status = -ESHUTDOWN;
+                goto done;
+        }
+
+        /* get qh and force any scheduling errors */
+        INIT_LIST_HEAD(&empty);
+        qh = qh_append_tds(oxu, urb, &empty, epnum, &urb->ep->hcpriv);
+        if (qh == NULL) {
+                status = -ENOMEM;
+                goto done;
+        }
+        if (qh->qh_state == QH_STATE_IDLE) {
+                status = qh_schedule(oxu, qh);
+                if (status != 0)
+                        goto done;
+        }
+
+        /* then queue the urb's tds to the qh */
+        qh = qh_append_tds(oxu, urb, qtd_list, epnum, &urb->ep->hcpriv);
+        BUG_ON(qh == NULL);
+
+        /* ... update usbfs periodic stats */
+        oxu_to_hcd(oxu)->self.bandwidth_int_reqs++;
+
+done:
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        if (status)
+                qtd_list_free(oxu, urb, qtd_list);
+
+        return status;
+}
+
+static inline int itd_submit(struct oxu_hcd *oxu, struct urb *urb,
+                                                gfp_t mem_flags)
+{
+        oxu_dbg(oxu, "iso support is missing!\n");
+        return -ENOSYS;
+}
+
+static inline int sitd_submit(struct oxu_hcd *oxu, struct urb *urb,
+                                                gfp_t mem_flags)
+{
+        oxu_dbg(oxu, "split iso support is missing!\n");
+        return -ENOSYS;
+}
+
+static void scan_periodic(struct oxu_hcd *oxu)
+{
+        unsigned frame, clock, now_uframe, mod;
+        unsigned modified;
+
+        mod = oxu->periodic_size << 3;
+
+        /*
+         * When running, scan from last scan point up to "now"
+         * else clean up by scanning everything that's left.
+         * Touches as few pages as possible:  cache-friendly.
+         */
+        now_uframe = oxu->next_uframe;
+        if (HC_IS_RUNNING(oxu_to_hcd(oxu)->state))
+                clock = readl(&oxu->regs->frame_index);
+        else
+                clock = now_uframe + mod - 1;
+        clock %= mod;
+
+        for (;;) {
+                union ehci_shadow       q, *q_p;
+                __le32                  type, *hw_p;
+                unsigned                uframes;
+
+                /* don't scan past the live uframe */
+                frame = now_uframe >> 3;
+                if (frame == (clock >> 3))
+                        uframes = now_uframe & 0x07;
+                else {
+                        /* safe to scan the whole frame at once */
+                        now_uframe |= 0x07;
+                        uframes = 8;
+                }
+
+restart:
+                /* scan each element in frame's queue for completions */
+                q_p = &oxu->pshadow[frame];
+                hw_p = &oxu->periodic[frame];
+                q.ptr = q_p->ptr;
+                type = Q_NEXT_TYPE(*hw_p);
+                modified = 0;
+
+                while (q.ptr != NULL) {
+                        union ehci_shadow temp;
+                        int live;
+
+                        live = HC_IS_RUNNING(oxu_to_hcd(oxu)->state);
+                        switch (type) {
+                        case Q_TYPE_QH:
+                                /* handle any completions */
+                                temp.qh = qh_get(q.qh);
+                                type = Q_NEXT_TYPE(q.qh->hw_next);
+                                q = q.qh->qh_next;
+                                modified = qh_completions(oxu, temp.qh);
+                                if (unlikely(list_empty(&temp.qh->qtd_list)))
+                                        intr_deschedule(oxu, temp.qh);
+                                qh_put(temp.qh);
+                                break;
+                        default:
+                                dbg("corrupt type %d frame %d shadow %p",
+                                        type, frame, q.ptr);
+                                q.ptr = NULL;
+                        }
+
+                        /* assume completion callbacks modify the queue */
+                        if (unlikely(modified))
+                                goto restart;
+                }
+
+                /* Stop when we catch up to the HC */
+
+                /* FIXME:  this assumes we won't get lapped when
+                 * latencies climb; that should be rare, but...
+                 * detect it, and just go all the way around.
+                 * FLR might help detect this case, so long as latencies
+                 * don't exceed periodic_size msec (default 1.024 sec).
+                 */
+
+                /* FIXME: likewise assumes HC doesn't halt mid-scan */
+
+                if (now_uframe == clock) {
+                        unsigned        now;
+
+                        if (!HC_IS_RUNNING(oxu_to_hcd(oxu)->state))
+                                break;
+                        oxu->next_uframe = now_uframe;
+                        now = readl(&oxu->regs->frame_index) % mod;
+                        if (now_uframe == now)
+                                break;
+
+                        /* rescan the rest of this frame, then ... */
+                        clock = now;
+                } else {
+                        now_uframe++;
+                        now_uframe %= mod;
+                }
+        }
+}
+
+/* On some systems, leaving remote wakeup enabled prevents system shutdown.
+ * The firmware seems to think that powering off is a wakeup event!
+ * This routine turns off remote wakeup and everything else, on all ports.
+ */
+static void ehci_turn_off_all_ports(struct oxu_hcd *oxu)
+{
+        int port = HCS_N_PORTS(oxu->hcs_params);
+
+        while (port--)
+                writel(PORT_RWC_BITS, &oxu->regs->port_status[port]);
+}
+
+static void ehci_port_power(struct oxu_hcd *oxu, int is_on)
+{
+        unsigned port;
+
+        if (!HCS_PPC(oxu->hcs_params))
+                return;
+
+        oxu_dbg(oxu, "...power%s ports...\n", is_on ? "up" : "down");
+        for (port = HCS_N_PORTS(oxu->hcs_params); port > 0; )
+                (void) oxu_hub_control(oxu_to_hcd(oxu),
+                                is_on ? SetPortFeature : ClearPortFeature,
+                                USB_PORT_FEAT_POWER,
+                                port--, NULL, 0);
+        msleep(20);
+}
+
+/* Called from some interrupts, timers, and so on.
+ * It calls driver completion functions, after dropping oxu->lock.
+ */
+static void ehci_work(struct oxu_hcd *oxu)
+{
+        timer_action_done(oxu, TIMER_IO_WATCHDOG);
+        if (oxu->reclaim_ready)
+                end_unlink_async(oxu);
+
+        /* another CPU may drop oxu->lock during a schedule scan while
+         * it reports urb completions.  this flag guards against bogus
+         * attempts at re-entrant schedule scanning.
+         */
+        if (oxu->scanning)
+                return;
+        oxu->scanning = 1;
+        scan_async(oxu);
+        if (oxu->next_uframe != -1)
+                scan_periodic(oxu);
+        oxu->scanning = 0;
+
+        /* the IO watchdog guards against hardware or driver bugs that
+         * misplace IRQs, and should let us run completely without IRQs.
+         * such lossage has been observed on both VT6202 and VT8235.
+         */
+        if (HC_IS_RUNNING(oxu_to_hcd(oxu)->state) &&
+                        (oxu->async->qh_next.ptr != NULL ||
+                         oxu->periodic_sched != 0))
+                timer_action(oxu, TIMER_IO_WATCHDOG);
+}
+
+static void unlink_async(struct oxu_hcd *oxu, struct ehci_qh *qh)
+{
+        /* if we need to use IAA and it's busy, defer */
+        if (qh->qh_state == QH_STATE_LINKED
+                        && oxu->reclaim
+                        && HC_IS_RUNNING(oxu_to_hcd(oxu)->state)) {
+                struct ehci_qh          *last;
+
+                for (last = oxu->reclaim;
+                                last->reclaim;
+                                last = last->reclaim)
+                        continue;
+                qh->qh_state = QH_STATE_UNLINK_WAIT;
+                last->reclaim = qh;
+
+        /* bypass IAA if the hc can't care */
+        } else if (!HC_IS_RUNNING(oxu_to_hcd(oxu)->state) && oxu->reclaim)
+                end_unlink_async(oxu);
+
+        /* something else might have unlinked the qh by now */
+        if (qh->qh_state == QH_STATE_LINKED)
+                start_unlink_async(oxu, qh);
+}
+
+/*
+ * USB host controller methods
+ */
+
+static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        u32 status, pcd_status = 0;
+        int bh;
+
+        spin_lock(&oxu->lock);
+
+        status = readl(&oxu->regs->status);
+
+        /* e.g. cardbus physical eject */
+        if (status == ~(u32) 0) {
+                oxu_dbg(oxu, "device removed\n");
+                goto dead;
+        }
+
+        status &= INTR_MASK;
+        if (!status) {                  /* irq sharing? */
+                spin_unlock(&oxu->lock);
+                return IRQ_NONE;
+        }
+
+        /* clear (just) interrupts */
+        writel(status, &oxu->regs->status);
+        readl(&oxu->regs->command);     /* unblock posted write */
+        bh = 0;
+
+#ifdef OXU_VERBOSE_DEBUG
+        /* unrequested/ignored: Frame List Rollover */
+        dbg_status(oxu, "irq", status);
+#endif
+
+        /* INT, ERR, and IAA interrupt rates can be throttled */
+
+        /* normal [4.15.1.2] or error [4.15.1.1] completion */
+        if (likely((status & (STS_INT|STS_ERR)) != 0))
+                bh = 1;
+
+        /* complete the unlinking of some qh [4.15.2.3] */
+        if (status & STS_IAA) {
+                oxu->reclaim_ready = 1;
+                bh = 1;
+        }
+
+        /* remote wakeup [4.3.1] */
+        if (status & STS_PCD) {
+                unsigned i = HCS_N_PORTS(oxu->hcs_params);
+                pcd_status = status;
+
+                /* resume root hub? */
+                if (!(readl(&oxu->regs->command) & CMD_RUN))
+                        usb_hcd_resume_root_hub(hcd);
+
+                while (i--) {
+                        int pstatus = readl(&oxu->regs->port_status[i]);
+
+                        if (pstatus & PORT_OWNER)
+                                continue;
+                        if (!(pstatus & PORT_RESUME)
+                                        || oxu->reset_done[i] != 0)
+                                continue;
+
+                        /* start 20 msec resume signaling from this port,
+                         * and make khubd collect PORT_STAT_C_SUSPEND to
+                         * stop that signaling.
+                         */
+                        oxu->reset_done[i] = jiffies + msecs_to_jiffies(20);
+                        oxu_dbg(oxu, "port %d remote wakeup\n", i + 1);
+                        mod_timer(&hcd->rh_timer, oxu->reset_done[i]);
+                }
+        }
+
+        /* PCI errors [4.15.2.4] */
+        if (unlikely((status & STS_FATAL) != 0)) {
+                /* bogus "fatal" IRQs appear on some chips... why?  */
+                status = readl(&oxu->regs->status);
+                dbg_cmd(oxu, "fatal", readl(&oxu->regs->command));
+                dbg_status(oxu, "fatal", status);
+                if (status & STS_HALT) {
+                        oxu_err(oxu, "fatal error\n");
+dead:
+                        ehci_reset(oxu);
+                        writel(0, &oxu->regs->configured_flag);
+                        /* generic layer kills/unlinks all urbs, then
+                         * uses oxu_stop to clean up the rest
+                         */
+                        bh = 1;
+                }
+        }
+
+        if (bh)
+                ehci_work(oxu);
+        spin_unlock(&oxu->lock);
+        if (pcd_status & STS_PCD)
+                usb_hcd_poll_rh_status(hcd);
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t oxu_irq(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int ret = IRQ_HANDLED;
+
+        u32 status = oxu_readl(hcd->regs, OXU_CHIPIRQSTATUS);
+        u32 enable = oxu_readl(hcd->regs, OXU_CHIPIRQEN_SET);
+
+        /* Disable all interrupt */
+        oxu_writel(hcd->regs, OXU_CHIPIRQEN_CLR, enable);
+
+        if ((oxu->is_otg && (status & OXU_USBOTGI)) ||
+                (!oxu->is_otg && (status & OXU_USBSPHI)))
+                oxu210_hcd_irq(hcd);
+        else
+                ret = IRQ_NONE;
+
+        /* Enable all interrupt back */
+        oxu_writel(hcd->regs, OXU_CHIPIRQEN_SET, enable);
+
+        return ret;
+}
+
+static void oxu_watchdog(unsigned long param)
+{
+        struct oxu_hcd  *oxu = (struct oxu_hcd *) param;
+        unsigned long flags;
+
+        spin_lock_irqsave(&oxu->lock, flags);
+
+        /* lost IAA irqs wedge things badly; seen with a vt8235 */
+        if (oxu->reclaim) {
+                u32 status = readl(&oxu->regs->status);
+                if (status & STS_IAA) {
+                        oxu_vdbg(oxu, "lost IAA\n");
+                        writel(STS_IAA, &oxu->regs->status);
+                        oxu->reclaim_ready = 1;
+                }
+        }
+
+        /* stop async processing after it's idled a bit */
+        if (test_bit(TIMER_ASYNC_OFF, &oxu->actions))
+                start_unlink_async(oxu, oxu->async);
+
+        /* oxu could run by timer, without IRQs ... */
+        ehci_work(oxu);
+
+        spin_unlock_irqrestore(&oxu->lock, flags);
+}
+
+/* One-time init, only for memory state.
+ */
+static int oxu_hcd_init(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        u32 temp;
+        int retval;
+        u32 hcc_params;
+
+        spin_lock_init(&oxu->lock);
+
+        init_timer(&oxu->watchdog);
+        oxu->watchdog.function = oxu_watchdog;
+        oxu->watchdog.data = (unsigned long) oxu;
+
+        /*
+         * hw default: 1K periodic list heads, one per frame.
+         * periodic_size can shrink by USBCMD update if hcc_params allows.
+         */
+        oxu->periodic_size = DEFAULT_I_TDPS;
+        retval = ehci_mem_init(oxu, GFP_KERNEL);
+        if (retval < 0)
+                return retval;
+
+        /* controllers may cache some of the periodic schedule ... */
+        hcc_params = readl(&oxu->caps->hcc_params);
+        if (HCC_ISOC_CACHE(hcc_params))         /* full frame cache */
+                oxu->i_thresh = 8;
+        else                                    /* N microframes cached */
+                oxu->i_thresh = 2 + HCC_ISOC_THRES(hcc_params);
+
+        oxu->reclaim = NULL;
+        oxu->reclaim_ready = 0;
+        oxu->next_uframe = -1;
+
+        /*
+         * dedicate a qh for the async ring head, since we couldn't unlink
+         * a 'real' qh without stopping the async schedule [4.8].  use it
+         * as the 'reclamation list head' too.
+         * its dummy is used in hw_alt_next of many tds, to prevent the qh
+         * from automatically advancing to the next td after short reads.
+         */
+        oxu->async->qh_next.qh = NULL;
+        oxu->async->hw_next = QH_NEXT(oxu->async->qh_dma);
+        oxu->async->hw_info1 = cpu_to_le32(QH_HEAD);
+        oxu->async->hw_token = cpu_to_le32(QTD_STS_HALT);
+        oxu->async->hw_qtd_next = EHCI_LIST_END;
+        oxu->async->qh_state = QH_STATE_LINKED;
+        oxu->async->hw_alt_next = QTD_NEXT(oxu->async->dummy->qtd_dma);
+
+        /* clear interrupt enables, set irq latency */
+        if (log2_irq_thresh < 0 || log2_irq_thresh > 6)
+                log2_irq_thresh = 0;
+        temp = 1 << (16 + log2_irq_thresh);
+        if (HCC_CANPARK(hcc_params)) {
+                /* HW default park == 3, on hardware that supports it (like
+                 * NVidia and ALI silicon), maximizes throughput on the async
+                 * schedule by avoiding QH fetches between transfers.
+                 *
+                 * With fast usb storage devices and NForce2, "park" seems to
+                 * make problems:  throughput reduction (!), data errors...
+                 */
+                if (park) {
+                        park = min(park, (unsigned) 3);
+                        temp |= CMD_PARK;
+                        temp |= park << 8;
+                }
+                oxu_dbg(oxu, "park %d\n", park);
+        }
+        if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
+                /* periodic schedule size can be smaller than default */
+                temp &= ~(3 << 2);
+                temp |= (EHCI_TUNE_FLS << 2);
+        }
+        oxu->command = temp;
+
+        return 0;
+}
+
+/* Called during probe() after chip reset completes.
+ */
+static int oxu_reset(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int ret;
+
+        spin_lock_init(&oxu->mem_lock);
+        INIT_LIST_HEAD(&oxu->urb_list);
+        oxu->urb_len = 0;
+
+        /* FIMXE */
+        hcd->self.controller->dma_mask = 0UL;
+
+        if (oxu->is_otg) {
+                oxu->caps = hcd->regs + OXU_OTG_CAP_OFFSET;
+                oxu->regs = hcd->regs + OXU_OTG_CAP_OFFSET + \
+                        HC_LENGTH(readl(&oxu->caps->hc_capbase));
+
+                oxu->mem = hcd->regs + OXU_SPH_MEM;
+        } else {
+                oxu->caps = hcd->regs + OXU_SPH_CAP_OFFSET;
+                oxu->regs = hcd->regs + OXU_SPH_CAP_OFFSET + \
+                        HC_LENGTH(readl(&oxu->caps->hc_capbase));
+
+                oxu->mem = hcd->regs + OXU_OTG_MEM;
+        }
+
+        oxu->hcs_params = readl(&oxu->caps->hcs_params);
+        oxu->sbrn = 0x20;
+
+        ret = oxu_hcd_init(hcd);
+        if (ret)
+                return ret;
+
+        return 0;
+}
+
+static int oxu_run(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int retval;
+        u32 temp, hcc_params;
+
+        hcd->uses_new_polling = 1;
+        hcd->poll_rh = 0;
+
+        /* EHCI spec section 4.1 */
+        retval = ehci_reset(oxu);
+        if (retval != 0) {
+                ehci_mem_cleanup(oxu);
+                return retval;
+        }
+        writel(oxu->periodic_dma, &oxu->regs->frame_list);
+        writel((u32) oxu->async->qh_dma, &oxu->regs->async_next);
+
+        /* hcc_params controls whether oxu->regs->segment must (!!!)
+         * be used; it constrains QH/ITD/SITD and QTD locations.
+         * pci_pool consistent memory always uses segment zero.
+         * streaming mappings for I/O buffers, like pci_map_single(),
+         * can return segments above 4GB, if the device allows.
+         *
+         * NOTE:  the dma mask is visible through dma_supported(), so
+         * drivers can pass this info along ... like NETIF_F_HIGHDMA,
+         * Scsi_Host.highmem_io, and so forth.  It's readonly to all
+         * host side drivers though.
+         */
+        hcc_params = readl(&oxu->caps->hcc_params);
+        if (HCC_64BIT_ADDR(hcc_params))
+                writel(0, &oxu->regs->segment);
+
+        oxu->command &= ~(CMD_LRESET | CMD_IAAD | CMD_PSE |
+                                CMD_ASE | CMD_RESET);
+        oxu->command |= CMD_RUN;
+        writel(oxu->command, &oxu->regs->command);
+        dbg_cmd(oxu, "init", oxu->command);
+
+        /*
+         * Start, enabling full USB 2.0 functionality ... usb 1.1 devices
+         * are explicitly handed to companion controller(s), so no TT is
+         * involved with the root hub.  (Except where one is integrated,
+         * and there's no companion controller unless maybe for USB OTG.)
+         */
+        hcd->state = HC_STATE_RUNNING;
+        writel(FLAG_CF, &oxu->regs->configured_flag);
+        readl(&oxu->regs->command);     /* unblock posted writes */
+
+        temp = HC_VERSION(readl(&oxu->caps->hc_capbase));
+        oxu_info(oxu, "USB %x.%x started, quasi-EHCI %x.%02x, driver %s%s\n",
+                ((oxu->sbrn & 0xf0)>>4), (oxu->sbrn & 0x0f),
+                temp >> 8, temp & 0xff, DRIVER_VERSION,
+                ignore_oc ? ", overcurrent ignored" : "");
+
+        writel(INTR_MASK, &oxu->regs->intr_enable); /* Turn On Interrupts */
+
+        return 0;
+}
+
+static void oxu_stop(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+
+        /* Turn off port power on all root hub ports. */
+        ehci_port_power(oxu, 0);
+
+        /* no more interrupts ... */
+        del_timer_sync(&oxu->watchdog);
+
+        spin_lock_irq(&oxu->lock);
+        if (HC_IS_RUNNING(hcd->state))
+                ehci_quiesce(oxu);
+
+        ehci_reset(oxu);
+        writel(0, &oxu->regs->intr_enable);
+        spin_unlock_irq(&oxu->lock);
+
+        /* let companion controllers work when we aren't */
+        writel(0, &oxu->regs->configured_flag);
+
+        /* root hub is shut down separately (first, when possible) */
+        spin_lock_irq(&oxu->lock);
+        if (oxu->async)
+                ehci_work(oxu);
+        spin_unlock_irq(&oxu->lock);
+        ehci_mem_cleanup(oxu);
+
+        dbg_status(oxu, "oxu_stop completed", readl(&oxu->regs->status));
+}
+
+/* Kick in for silicon on any bus (not just pci, etc).
+ * This forcibly disables dma and IRQs, helping kexec and other cases
+ * where the next system software may expect clean state.
+ */
+static void oxu_shutdown(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+
+        (void) ehci_halt(oxu);
+        ehci_turn_off_all_ports(oxu);
+
+        /* make BIOS/etc use companion controller during reboot */
+        writel(0, &oxu->regs->configured_flag);
+
+        /* unblock posted writes */
+        readl(&oxu->regs->configured_flag);
+}
+
+/* Non-error returns are a promise to giveback() the urb later
+ * we drop ownership so next owner (or urb unlink) can get it
+ *
+ * urb + dev is in hcd.self.controller.urb_list
+ * we're queueing TDs onto software and hardware lists
+ *
+ * hcd-specific init for hcpriv hasn't been done yet
+ *
+ * NOTE:  control, bulk, and interrupt share the same code to append TDs
+ * to a (possibly active) QH, and the same QH scanning code.
+ */
+static int __oxu_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+                                gfp_t mem_flags)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        struct list_head qtd_list;
+
+        INIT_LIST_HEAD(&qtd_list);
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+        case PIPE_BULK:
+        default:
+                if (!qh_urb_transaction(oxu, urb, &qtd_list, mem_flags))
+                        return -ENOMEM;
+                return submit_async(oxu, urb, &qtd_list, mem_flags);
+
+        case PIPE_INTERRUPT:
+                if (!qh_urb_transaction(oxu, urb, &qtd_list, mem_flags))
+                        return -ENOMEM;
+                return intr_submit(oxu, urb, &qtd_list, mem_flags);
+
+        case PIPE_ISOCHRONOUS:
+                if (urb->dev->speed == USB_SPEED_HIGH)
+                        return itd_submit(oxu, urb, mem_flags);
+                else
+                        return sitd_submit(oxu, urb, mem_flags);
+        }
+}
+
+/* This function is responsible for breaking URBs with big data size
+ * into smaller size and processing small urbs in sequence.
+ */
+static int oxu_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
+                                gfp_t mem_flags)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int num, rem;
+        int transfer_buffer_length;
+        void *transfer_buffer;
+        struct urb *murb;
+        int i, ret;
+
+        /* If not bulk pipe just enqueue the URB */
+        if (!usb_pipebulk(urb->pipe))
+                return __oxu_urb_enqueue(hcd, urb, mem_flags);
+
+        /* Otherwise we should verify the USB transfer buffer size! */
+        transfer_buffer = urb->transfer_buffer;
+        transfer_buffer_length = urb->transfer_buffer_length;
+
+        num = urb->transfer_buffer_length / 4096;
+        rem = urb->transfer_buffer_length % 4096;
+        if (rem != 0)
+                num++;
+
+        /* If URB is smaller than 4096 bytes just enqueue it! */
+        if (num == 1)
+                return __oxu_urb_enqueue(hcd, urb, mem_flags);
+
+        /* Ok, we have more job to do! :) */
+
+        for (i = 0; i < num - 1; i++) {
+                /* Get free micro URB poll till a free urb is recieved */
+
+                do {
+                        murb = (struct urb *) oxu_murb_alloc(oxu);
+                        if (!murb)
+                                schedule();
+                } while (!murb);
+
+                /* Coping the urb */
+                memcpy(murb, urb, sizeof(struct urb));
+
+                murb->transfer_buffer_length = 4096;
+                murb->transfer_buffer = transfer_buffer + i * 4096;
+
+                /* Null pointer for the encodes that this is a micro urb */
+                murb->complete = NULL;
+
+                ((struct oxu_murb *) murb)->main = urb;
+                ((struct oxu_murb *) murb)->last = 0;
+
+                /* This loop is to guarantee urb to be processed when there's
+                 * not enough resources at a particular time by retrying.
+                 */
+                do {
+                        ret  = __oxu_urb_enqueue(hcd, murb, mem_flags);
+                        if (ret)
+                                schedule();
+                } while (ret);
+        }
+
+        /* Last urb requires special handling  */
+
+        /* Get free micro URB poll till a free urb is recieved */
+        do {
+                murb = (struct urb *) oxu_murb_alloc(oxu);
+                if (!murb)
+                        schedule();
+        } while (!murb);
+
+        /* Coping the urb */
+        memcpy(murb, urb, sizeof(struct urb));
+
+        murb->transfer_buffer_length = rem > 0 ? rem : 4096;
+        murb->transfer_buffer = transfer_buffer + (num - 1) * 4096;
+
+        /* Null pointer for the encodes that this is a micro urb */
+        murb->complete = NULL;
+
+        ((struct oxu_murb *) murb)->main = urb;
+        ((struct oxu_murb *) murb)->last = 1;
+
+        do {
+                ret = __oxu_urb_enqueue(hcd, murb, mem_flags);
+                if (ret)
+                        schedule();
+        } while (ret);
+
+        return ret;
+}
+
+/* Remove from hardware lists.
+ * Completions normally happen asynchronously
+ */
+static int oxu_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        struct ehci_qh *qh;
+        unsigned long flags;
+
+        spin_lock_irqsave(&oxu->lock, flags);
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_CONTROL:
+        case PIPE_BULK:
+        default:
+                qh = (struct ehci_qh *) urb->hcpriv;
+                if (!qh)
+                        break;
+                unlink_async(oxu, qh);
+                break;
+
+        case PIPE_INTERRUPT:
+                qh = (struct ehci_qh *) urb->hcpriv;
+                if (!qh)
+                        break;
+                switch (qh->qh_state) {
+                case QH_STATE_LINKED:
+                        intr_deschedule(oxu, qh);
+                        /* FALL THROUGH */
+                case QH_STATE_IDLE:
+                        qh_completions(oxu, qh);
+                        break;
+                default:
+                        oxu_dbg(oxu, "bogus qh %p state %d\n",
+                                        qh, qh->qh_state);
+                        goto done;
+                }
+
+                /* reschedule QH iff another request is queued */
+                if (!list_empty(&qh->qtd_list)
+                                && HC_IS_RUNNING(hcd->state)) {
+                        int status;
+
+                        status = qh_schedule(oxu, qh);
+                        spin_unlock_irqrestore(&oxu->lock, flags);
+
+                        if (status != 0) {
+                                /* shouldn't happen often, but ...
+                                 * FIXME kill those tds' urbs
+                                 */
+                                err("can't reschedule qh %p, err %d",
+                                        qh, status);
+                        }
+                        return status;
+                }
+                break;
+        }
+done:
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        return 0;
+}
+
+/* Bulk qh holds the data toggle */
+static void oxu_endpoint_disable(struct usb_hcd *hcd,
+                                        struct usb_host_endpoint *ep)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        unsigned long           flags;
+        struct ehci_qh          *qh, *tmp;
+
+        /* ASSERT:  any requests/urbs are being unlinked */
+        /* ASSERT:  nobody can be submitting urbs for this any more */
+
+rescan:
+        spin_lock_irqsave(&oxu->lock, flags);
+        qh = ep->hcpriv;
+        if (!qh)
+                goto done;
+
+        /* endpoints can be iso streams.  for now, we don't
+         * accelerate iso completions ... so spin a while.
+         */
+        if (qh->hw_info1 == 0) {
+                oxu_vdbg(oxu, "iso delay\n");
+                goto idle_timeout;
+        }
+
+        if (!HC_IS_RUNNING(hcd->state))
+                qh->qh_state = QH_STATE_IDLE;
+        switch (qh->qh_state) {
+        case QH_STATE_LINKED:
+                for (tmp = oxu->async->qh_next.qh;
+                                tmp && tmp != qh;
+                                tmp = tmp->qh_next.qh)
+                        continue;
+                /* periodic qh self-unlinks on empty */
+                if (!tmp)
+                        goto nogood;
+                unlink_async(oxu, qh);
+                /* FALL THROUGH */
+        case QH_STATE_UNLINK:           /* wait for hw to finish? */
+idle_timeout:
+                spin_unlock_irqrestore(&oxu->lock, flags);
+                schedule_timeout_uninterruptible(1);
+                goto rescan;
+        case QH_STATE_IDLE:             /* fully unlinked */
+                if (list_empty(&qh->qtd_list)) {
+                        qh_put(qh);
+                        break;
+                }
+                /* else FALL THROUGH */
+        default:
+nogood:
+                /* caller was supposed to have unlinked any requests;
+                 * that's not our job.  just leak this memory.
+                 */
+                oxu_err(oxu, "qh %p (#%02x) state %d%s\n",
+                        qh, ep->desc.bEndpointAddress, qh->qh_state,
+                        list_empty(&qh->qtd_list) ? "" : "(has tds)");
+                break;
+        }
+        ep->hcpriv = NULL;
+done:
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        return;
+}
+
+static int oxu_get_frame(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+
+        return (readl(&oxu->regs->frame_index) >> 3) %
+                oxu->periodic_size;
+}
+
+/* Build "status change" packet (one or two bytes) from HC registers */
+static int oxu_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        u32 temp, mask, status = 0;
+        int ports, i, retval = 1;
+        unsigned long flags;
+
+        /* if !USB_SUSPEND, root hub timers won't get shut down ... */
+        if (!HC_IS_RUNNING(hcd->state))
+                return 0;
+
+        /* init status to no-changes */
+        buf[0] = 0;
+        ports = HCS_N_PORTS(oxu->hcs_params);
+        if (ports > 7) {
+                buf[1] = 0;
+                retval++;
+        }
+
+        /* Some boards (mostly VIA?) report bogus overcurrent indications,
+         * causing massive log spam unless we completely ignore them.  It
+         * may be relevant that VIA VT8235 controlers, where PORT_POWER is
+         * always set, seem to clear PORT_OCC and PORT_CSC when writing to
+         * PORT_POWER; that's surprising, but maybe within-spec.
+         */
+        if (!ignore_oc)
+                mask = PORT_CSC | PORT_PEC | PORT_OCC;
+        else
+                mask = PORT_CSC | PORT_PEC;
+
+        /* no hub change reports (bit 0) for now (power, ...) */
+
+        /* port N changes (bit N)? */
+        spin_lock_irqsave(&oxu->lock, flags);
+        for (i = 0; i < ports; i++) {
+                temp = readl(&oxu->regs->port_status[i]);
+
+                /*
+                 * Return status information even for ports with OWNER set.
+                 * Otherwise khubd wouldn't see the disconnect event when a
+                 * high-speed device is switched over to the companion
+                 * controller by the user.
+                 */
+
+                if (!(temp & PORT_CONNECT))
+                        oxu->reset_done[i] = 0;
+                if ((temp & mask) != 0 || ((temp & PORT_RESUME) != 0 &&
+                                time_after_eq(jiffies, oxu->reset_done[i]))) {
+                        if (i < 7)
+                                buf[0] |= 1 << (i + 1);
+                        else
+                                buf[1] |= 1 << (i - 7);
+                        status = STS_PCD;
+                }
+        }
+        /* FIXME autosuspend idle root hubs */
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        return status ? retval : 0;
+}
+
+/* Returns the speed of a device attached to a port on the root hub. */
+static inline unsigned int oxu_port_speed(struct oxu_hcd *oxu,
+                                                unsigned int portsc)
+{
+        switch ((portsc >> 26) & 3) {
+        case 0:
+                return 0;
+        case 1:
+                return 1 << USB_PORT_FEAT_LOWSPEED;
+        case 2:
+        default:
+                return 1 << USB_PORT_FEAT_HIGHSPEED;
+        }
+}
+
+#define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
+static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
+                                u16 wValue, u16 wIndex, char *buf, u16 wLength)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int ports = HCS_N_PORTS(oxu->hcs_params);
+        u32 __iomem *status_reg = &oxu->regs->port_status[wIndex - 1];
+        u32 temp, status;
+        unsigned long   flags;
+        int retval = 0;
+        unsigned selector;
+
+        /*
+         * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
+         * HCS_INDICATOR may say we can change LEDs to off/amber/green.
+         * (track current state ourselves) ... blink for diagnostics,
+         * power, "this is the one", etc.  EHCI spec supports this.
+         */
+
+        spin_lock_irqsave(&oxu->lock, flags);
+        switch (typeReq) {
+        case ClearHubFeature:
+                switch (wValue) {
+                case C_HUB_LOCAL_POWER:
+                case C_HUB_OVER_CURRENT:
+                        /* no hub-wide feature/status flags */
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case ClearPortFeature:
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                temp = readl(status_reg);
+
+                /*
+                 * Even if OWNER is set, so the port is owned by the
+                 * companion controller, khubd needs to be able to clear
+                 * the port-change status bits (especially
+                 * USB_PORT_FEAT_C_CONNECTION).
+                 */
+
+                switch (wValue) {
+                case USB_PORT_FEAT_ENABLE:
+                        writel(temp & ~PORT_PE, status_reg);
+                        break;
+                case USB_PORT_FEAT_C_ENABLE:
+                        writel((temp & ~PORT_RWC_BITS) | PORT_PEC, status_reg);
+                        break;
+                case USB_PORT_FEAT_SUSPEND:
+                        if (temp & PORT_RESET)
+                                goto error;
+                        if (temp & PORT_SUSPEND) {
+                                if ((temp & PORT_PE) == 0)
+                                        goto error;
+                                /* resume signaling for 20 msec */
+                                temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
+                                writel(temp | PORT_RESUME, status_reg);
+                                oxu->reset_done[wIndex] = jiffies
+                                                + msecs_to_jiffies(20);
+                        }
+                        break;
+                case USB_PORT_FEAT_C_SUSPEND:
+                        /* we auto-clear this feature */
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        if (HCS_PPC(oxu->hcs_params))
+                                writel(temp & ~(PORT_RWC_BITS | PORT_POWER),
+                                          status_reg);
+                        break;
+                case USB_PORT_FEAT_C_CONNECTION:
+                        writel((temp & ~PORT_RWC_BITS) | PORT_CSC, status_reg);
+                        break;
+                case USB_PORT_FEAT_C_OVER_CURRENT:
+                        writel((temp & ~PORT_RWC_BITS) | PORT_OCC, status_reg);
+                        break;
+                case USB_PORT_FEAT_C_RESET:
+                        /* GetPortStatus clears reset */
+                        break;
+                default:
+                        goto error;
+                }
+                readl(&oxu->regs->command);     /* unblock posted write */
+                break;
+        case GetHubDescriptor:
+                ehci_hub_descriptor(oxu, (struct usb_hub_descriptor *)
+                        buf);
+                break;
+        case GetHubStatus:
+                /* no hub-wide feature/status flags */
+                memset(buf, 0, 4);
+                break;
+        case GetPortStatus:
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                status = 0;
+                temp = readl(status_reg);
+
+                /* wPortChange bits */
+                if (temp & PORT_CSC)
+                        status |= 1 << USB_PORT_FEAT_C_CONNECTION;
+                if (temp & PORT_PEC)
+                        status |= 1 << USB_PORT_FEAT_C_ENABLE;
+                if ((temp & PORT_OCC) && !ignore_oc)
+                        status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
+
+                /* whoever resumes must GetPortStatus to complete it!! */
+                if (temp & PORT_RESUME) {
+
+                        /* Remote Wakeup received? */
+                        if (!oxu->reset_done[wIndex]) {
+                                /* resume signaling for 20 msec */
+                                oxu->reset_done[wIndex] = jiffies
+                                                + msecs_to_jiffies(20);
+                                /* check the port again */
+                                mod_timer(&oxu_to_hcd(oxu)->rh_timer,
+                                                oxu->reset_done[wIndex]);
+                        }
+
+                        /* resume completed? */
+                        else if (time_after_eq(jiffies,
+                                        oxu->reset_done[wIndex])) {
+                                status |= 1 << USB_PORT_FEAT_C_SUSPEND;
+                                oxu->reset_done[wIndex] = 0;
+
+                                /* stop resume signaling */
+                                temp = readl(status_reg);
+                                writel(temp & ~(PORT_RWC_BITS | PORT_RESUME),
+                                        status_reg);
+                                retval = handshake(oxu, status_reg,
+                                           PORT_RESUME, 0, 2000 /* 2msec */);
+                                if (retval != 0) {
+                                        oxu_err(oxu,
+                                                "port %d resume error %d\n",
+                                                wIndex + 1, retval);
+                                        goto error;
+                                }
+                                temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
+                        }
+                }
+
+                /* whoever resets must GetPortStatus to complete it!! */
+                if ((temp & PORT_RESET)
+                                && time_after_eq(jiffies,
+                                        oxu->reset_done[wIndex])) {
+                        status |= 1 << USB_PORT_FEAT_C_RESET;
+                        oxu->reset_done[wIndex] = 0;
+
+                        /* force reset to complete */
+                        writel(temp & ~(PORT_RWC_BITS | PORT_RESET),
+                                        status_reg);
+                        /* REVISIT:  some hardware needs 550+ usec to clear
+                         * this bit; seems too long to spin routinely...
+                         */
+                        retval = handshake(oxu, status_reg,
+                                        PORT_RESET, 0, 750);
+                        if (retval != 0) {
+                                oxu_err(oxu, "port %d reset error %d\n",
+                                        wIndex + 1, retval);
+                                goto error;
+                        }
+
+                        /* see what we found out */
+                        temp = check_reset_complete(oxu, wIndex, status_reg,
+                                        readl(status_reg));
+                }
+
+                /* transfer dedicated ports to the companion hc */
+                if ((temp & PORT_CONNECT) &&
+                                test_bit(wIndex, &oxu->companion_ports)) {
+                        temp &= ~PORT_RWC_BITS;
+                        temp |= PORT_OWNER;
+                        writel(temp, status_reg);
+                        oxu_dbg(oxu, "port %d --> companion\n", wIndex + 1);
+                        temp = readl(status_reg);
+                }
+
+                /*
+                 * Even if OWNER is set, there's no harm letting khubd
+                 * see the wPortStatus values (they should all be 0 except
+                 * for PORT_POWER anyway).
+                 */
+
+                if (temp & PORT_CONNECT) {
+                        status |= 1 << USB_PORT_FEAT_CONNECTION;
+                        /* status may be from integrated TT */
+                        status |= oxu_port_speed(oxu, temp);
+                }
+                if (temp & PORT_PE)
+                        status |= 1 << USB_PORT_FEAT_ENABLE;
+                if (temp & (PORT_SUSPEND|PORT_RESUME))
+                        status |= 1 << USB_PORT_FEAT_SUSPEND;
+                if (temp & PORT_OC)
+                        status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
+                if (temp & PORT_RESET)
+                        status |= 1 << USB_PORT_FEAT_RESET;
+                if (temp & PORT_POWER)
+                        status |= 1 << USB_PORT_FEAT_POWER;
+
+#ifndef OXU_VERBOSE_DEBUG
+        if (status & ~0xffff)   /* only if wPortChange is interesting */
+#endif
+                dbg_port(oxu, "GetStatus", wIndex + 1, temp);
+                put_unaligned(cpu_to_le32(status), (__le32 *) buf);
+                break;
+        case SetHubFeature:
+                switch (wValue) {
+                case C_HUB_LOCAL_POWER:
+                case C_HUB_OVER_CURRENT:
+                        /* no hub-wide feature/status flags */
+                        break;
+                default:
+                        goto error;
+                }
+                break;
+        case SetPortFeature:
+                selector = wIndex >> 8;
+                wIndex &= 0xff;
+                if (!wIndex || wIndex > ports)
+                        goto error;
+                wIndex--;
+                temp = readl(status_reg);
+                if (temp & PORT_OWNER)
+                        break;
+
+                temp &= ~PORT_RWC_BITS;
+                switch (wValue) {
+                case USB_PORT_FEAT_SUSPEND:
+                        if ((temp & PORT_PE) == 0
+                                        || (temp & PORT_RESET) != 0)
+                                goto error;
+                        if (device_may_wakeup(&hcd->self.root_hub->dev))
+                                temp |= PORT_WAKE_BITS;
+                        writel(temp | PORT_SUSPEND, status_reg);
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        if (HCS_PPC(oxu->hcs_params))
+                                writel(temp | PORT_POWER, status_reg);
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        if (temp & PORT_RESUME)
+                                goto error;
+                        /* line status bits may report this as low speed,
+                         * which can be fine if this root hub has a
+                         * transaction translator built in.
+                         */
+                        oxu_vdbg(oxu, "port %d reset\n", wIndex + 1);
+                        temp |= PORT_RESET;
+                        temp &= ~PORT_PE;
+
+                        /*
+                         * caller must wait, then call GetPortStatus
+                         * usb 2.0 spec says 50 ms resets on root
+                         */
+                        oxu->reset_done[wIndex] = jiffies
+                                        + msecs_to_jiffies(50);
+                        writel(temp, status_reg);
+                        break;
+
+                /* For downstream facing ports (these):  one hub port is put
+                 * into test mode according to USB2 11.24.2.13, then the hub
+                 * must be reset (which for root hub now means rmmod+modprobe,
+                 * or else system reboot).  See EHCI 2.3.9 and 4.14 for info
+                 * about the EHCI-specific stuff.
+                 */
+                case USB_PORT_FEAT_TEST:
+                        if (!selector || selector > 5)
+                                goto error;
+                        ehci_quiesce(oxu);
+                        ehci_halt(oxu);
+                        temp |= selector << 16;
+                        writel(temp, status_reg);
+                        break;
+
+                default:
+                        goto error;
+                }
+                readl(&oxu->regs->command);     /* unblock posted writes */
+                break;
+
+        default:
+error:
+                /* "stall" on error */
+                retval = -EPIPE;
+        }
+        spin_unlock_irqrestore(&oxu->lock, flags);
+        return retval;
+}
+
+#ifdef CONFIG_PM
+
+static int oxu_bus_suspend(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        int port;
+        int mask;
+
+        oxu_dbg(oxu, "suspend root hub\n");
+
+        if (time_before(jiffies, oxu->next_statechange))
+                msleep(5);
+
+        port = HCS_N_PORTS(oxu->hcs_params);
+        spin_lock_irq(&oxu->lock);
+
+        /* stop schedules, clean any completed work */
+        if (HC_IS_RUNNING(hcd->state)) {
+                ehci_quiesce(oxu);
+                hcd->state = HC_STATE_QUIESCING;
+        }
+        oxu->command = readl(&oxu->regs->command);
+        if (oxu->reclaim)
+                oxu->reclaim_ready = 1;
+        ehci_work(oxu);
+
+        /* Unlike other USB host controller types, EHCI doesn't have
+         * any notion of "global" or bus-wide suspend.  The driver has
+         * to manually suspend all the active unsuspended ports, and
+         * then manually resume them in the bus_resume() routine.
+         */
+        oxu->bus_suspended = 0;
+        while (port--) {
+                u32 __iomem *reg = &oxu->regs->port_status[port];
+                u32 t1 = readl(reg) & ~PORT_RWC_BITS;
+                u32 t2 = t1;
+
+                /* keep track of which ports we suspend */
+                if ((t1 & PORT_PE) && !(t1 & PORT_OWNER) &&
+                                !(t1 & PORT_SUSPEND)) {
+                        t2 |= PORT_SUSPEND;
+                        set_bit(port, &oxu->bus_suspended);
+                }
+
+                /* enable remote wakeup on all ports */
+                if (device_may_wakeup(&hcd->self.root_hub->dev))
+                        t2 |= PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E;
+                else
+                        t2 &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E);
+
+                if (t1 != t2) {
+                        oxu_vdbg(oxu, "port %d, %08x -> %08x\n",
+                                port + 1, t1, t2);
+                        writel(t2, reg);
+                }
+        }
+
+        /* turn off now-idle HC */
+        del_timer_sync(&oxu->watchdog);
+        ehci_halt(oxu);
+        hcd->state = HC_STATE_SUSPENDED;
+
+        /* allow remote wakeup */
+        mask = INTR_MASK;
+        if (!device_may_wakeup(&hcd->self.root_hub->dev))
+                mask &= ~STS_PCD;
+        writel(mask, &oxu->regs->intr_enable);
+        readl(&oxu->regs->intr_enable);
+
+        oxu->next_statechange = jiffies + msecs_to_jiffies(10);
+        spin_unlock_irq(&oxu->lock);
+        return 0;
+}
+
+/* Caller has locked the root hub, and should reset/reinit on error */
+static int oxu_bus_resume(struct usb_hcd *hcd)
+{
+        struct oxu_hcd *oxu = hcd_to_oxu(hcd);
+        u32 temp;
+        int i;
+
+        if (time_before(jiffies, oxu->next_statechange))
+                msleep(5);
+        spin_lock_irq(&oxu->lock);
+
+        /* Ideally and we've got a real resume here, and no port's power
+         * was lost.  (For PCI, that means Vaux was maintained.)  But we
+         * could instead be restoring a swsusp snapshot -- so that BIOS was
+         * the last user of the controller, not reset/pm hardware keeping
+         * state we gave to it.
+         */
+        temp = readl(&oxu->regs->intr_enable);
+        oxu_dbg(oxu, "resume root hub%s\n", temp ? "" : " after power loss");
+
+        /* at least some APM implementations will try to deliver
+         * IRQs right away, so delay them until we're ready.
+         */
+        writel(0, &oxu->regs->intr_enable);
+
+        /* re-init operational registers */
+        writel(0, &oxu->regs->segment);
+        writel(oxu->periodic_dma, &oxu->regs->frame_list);
+        writel((u32) oxu->async->qh_dma, &oxu->regs->async_next);
+
+        /* restore CMD_RUN, framelist size, and irq threshold */
+        writel(oxu->command, &oxu->regs->command);
+
+        /* Some controller/firmware combinations need a delay during which
+         * they set up the port statuses.  See Bugzilla #8190. */
+        mdelay(8);
+
+        /* manually resume the ports we suspended during bus_suspend() */
+        i = HCS_N_PORTS(oxu->hcs_params);
+        while (i--) {
+                temp = readl(&oxu->regs->port_status[i]);
+                temp &= ~(PORT_RWC_BITS
+                        | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E);
+                if (test_bit(i, &oxu->bus_suspended) && (temp & PORT_SUSPEND)) {
+                        oxu->reset_done[i] = jiffies + msecs_to_jiffies(20);
+                        temp |= PORT_RESUME;
+                }
+                writel(temp, &oxu->regs->port_status[i]);
+        }
+        i = HCS_N_PORTS(oxu->hcs_params);
+        mdelay(20);
+        while (i--) {
+                temp = readl(&oxu->regs->port_status[i]);
+                if (test_bit(i, &oxu->bus_suspended) && (temp & PORT_SUSPEND)) {
+                        temp &= ~(PORT_RWC_BITS | PORT_RESUME);
+                        writel(temp, &oxu->regs->port_status[i]);
+                        oxu_vdbg(oxu, "resumed port %d\n", i + 1);
+                }
+        }
+        (void) readl(&oxu->regs->command);
+
+        /* maybe re-activate the schedule(s) */
+        temp = 0;
+        if (oxu->async->qh_next.qh)
+                temp |= CMD_ASE;
+        if (oxu->periodic_sched)
+                temp |= CMD_PSE;
+        if (temp) {
+                oxu->command |= temp;
+                writel(oxu->command, &oxu->regs->command);
+        }
+
+        oxu->next_statechange = jiffies + msecs_to_jiffies(5);
+        hcd->state = HC_STATE_RUNNING;
+
+        /* Now we can safely re-enable irqs */
+        writel(INTR_MASK, &oxu->regs->intr_enable);
+
+        spin_unlock_irq(&oxu->lock);
+        return 0;
+}
+
+#else
+
+static int oxu_bus_suspend(struct usb_hcd *hcd)
+{
+        return 0;
+}
+
+static int oxu_bus_resume(struct usb_hcd *hcd)
+{
+        return 0;
+}
+
+#endif  /* CONFIG_PM */
+
+static const struct hc_driver oxu_hc_driver = {
+        .description =          "oxu210hp_hcd",
+        .product_desc =         "oxu210hp HCD",
+        .hcd_priv_size =        sizeof(struct oxu_hcd),
+
+        /*
+         * Generic hardware linkage
+         */
+        .irq =                  oxu_irq,
+        .flags =                HCD_MEMORY | HCD_USB2,
+
+        /*
+         * Basic lifecycle operations
+         */
+        .reset =                oxu_reset,
+        .start =                oxu_run,
+        .stop =                 oxu_stop,
+        .shutdown =             oxu_shutdown,
+
+        /*
+         * Managing i/o requests and associated device resources
+         */
+        .urb_enqueue =          oxu_urb_enqueue,
+        .urb_dequeue =          oxu_urb_dequeue,
+        .endpoint_disable =     oxu_endpoint_disable,
+
+        /*
+         * Scheduling support
+         */
+        .get_frame_number =     oxu_get_frame,
+
+        /*
+         * Root hub support
+         */
+        .hub_status_data =      oxu_hub_status_data,
+        .hub_control =          oxu_hub_control,
+        .bus_suspend =          oxu_bus_suspend,
+        .bus_resume =           oxu_bus_resume,
+};
+
+/*
+ * Module stuff
+ */
+
+static void oxu_configuration(struct platform_device *pdev, void *base)
+{
+        u32 tmp;
+
+        /* Initialize top level registers.
+         * First write ever
+         */
+        oxu_writel(base, OXU_HOSTIFCONFIG, 0x0000037D);
+        oxu_writel(base, OXU_SOFTRESET, OXU_SRESET);
+        oxu_writel(base, OXU_HOSTIFCONFIG, 0x0000037D);
+
+        tmp = oxu_readl(base, OXU_PIOBURSTREADCTRL);
+        oxu_writel(base, OXU_PIOBURSTREADCTRL, tmp | 0x0040);
+
+        oxu_writel(base, OXU_ASO, OXU_SPHPOEN | OXU_OVRCCURPUPDEN |
+                                        OXU_COMPARATOR | OXU_ASO_OP);
+
+        tmp = oxu_readl(base, OXU_CLKCTRL_SET);
+        oxu_writel(base, OXU_CLKCTRL_SET, tmp | OXU_SYSCLKEN | OXU_USBOTGCLKEN);
+
+        /* Clear all top interrupt enable */
+        oxu_writel(base, OXU_CHIPIRQEN_CLR, 0xff);
+
+        /* Clear all top interrupt status */
+        oxu_writel(base, OXU_CHIPIRQSTATUS, 0xff);
+
+        /* Enable all needed top interrupt except OTG SPH core */
+        oxu_writel(base, OXU_CHIPIRQEN_SET, OXU_USBSPHLPWUI | OXU_USBOTGLPWUI);
+}
+
+static int oxu_verify_id(struct platform_device *pdev, void *base)
+{
+        u32 id;
+        char *bo[] = {
+                "reserved",
+                "128-pin LQFP",
+                "84-pin TFBGA",
+                "reserved",
+        };
+
+        /* Read controller signature register to find a match */
+        id = oxu_readl(base, OXU_DEVICEID);
+        dev_info(&pdev->dev, "device ID %x\n", id);
+        if ((id & OXU_REV_MASK) != (OXU_REV_2100 << OXU_REV_SHIFT))
+                return -1;
+
+        dev_info(&pdev->dev, "found device %x %s (%04x:%04x)\n",
+                id >> OXU_REV_SHIFT,
+                bo[(id & OXU_BO_MASK) >> OXU_BO_SHIFT],
+                (id & OXU_MAJ_REV_MASK) >> OXU_MAJ_REV_SHIFT,
+                (id & OXU_MIN_REV_MASK) >> OXU_MIN_REV_SHIFT);
+
+        return 0;
+}
+
+static const struct hc_driver oxu_hc_driver;
+static struct usb_hcd *oxu_create(struct platform_device *pdev,
+                                unsigned long memstart, unsigned long memlen,
+                                void *base, int irq, int otg)
+{
+        struct device *dev = &pdev->dev;
+
+        struct usb_hcd *hcd;
+        struct oxu_hcd *oxu;
+        int ret;
+
+        /* Set endian mode and host mode */
+        oxu_writel(base + (otg ? OXU_OTG_CORE_OFFSET : OXU_SPH_CORE_OFFSET),
+                                OXU_USBMODE,
+                                OXU_CM_HOST_ONLY | OXU_ES_LITTLE | OXU_VBPS);
+
+        hcd = usb_create_hcd(&oxu_hc_driver, dev,
+                                otg ? "oxu210hp_otg" : "oxu210hp_sph");
+        if (!hcd)
+                return ERR_PTR(-ENOMEM);
+
+        hcd->rsrc_start = memstart;
+        hcd->rsrc_len = memlen;
+        hcd->regs = base;
+        hcd->irq = irq;
+        hcd->state = HC_STATE_HALT;
+
+        oxu = hcd_to_oxu(hcd);
+        oxu->is_otg = otg;
+
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (ret < 0)
+                return ERR_PTR(ret);
+
+        return hcd;
+}
+
+static int oxu_init(struct platform_device *pdev,
+                                unsigned long memstart, unsigned long memlen,
+                                void *base, int irq)
+{
+        struct oxu_info *info = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd;
+        int ret;
+
+        /* First time configuration at start up */
+        oxu_configuration(pdev, base);
+
+        ret = oxu_verify_id(pdev, base);
+        if (ret) {
+                dev_err(&pdev->dev, "no devices found!\n");
+                return -ENODEV;
+        }
+
+        /* Create the OTG controller */
+        hcd = oxu_create(pdev, memstart, memlen, base, irq, 1);
+        if (IS_ERR(hcd)) {
+                dev_err(&pdev->dev, "cannot create OTG controller!\n");
+                ret = PTR_ERR(hcd);
+                goto error_create_otg;
+        }
+        info->hcd[0] = hcd;
+
+        /* Create the SPH host controller */
+        hcd = oxu_create(pdev, memstart, memlen, base, irq, 0);
+        if (IS_ERR(hcd)) {
+                dev_err(&pdev->dev, "cannot create SPH controller!\n");
+                ret = PTR_ERR(hcd);
+                goto error_create_sph;
+        }
+        info->hcd[1] = hcd;
+
+        oxu_writel(base, OXU_CHIPIRQEN_SET,
+                oxu_readl(base, OXU_CHIPIRQEN_SET) | 3);
+
+        return 0;
+
+error_create_sph:
+        usb_remove_hcd(info->hcd[0]);
+        usb_put_hcd(info->hcd[0]);
+
+error_create_otg:
+        return ret;
+}
+
+static int oxu_drv_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        void *base;
+        unsigned long memstart, memlen;
+        int irq, ret;
+        struct oxu_info *info;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        /*
+         * Get the platform resources
+         */
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(&pdev->dev,
+                        "no IRQ! Check %s setup!\n", dev_name(&pdev->dev));
+                return -ENODEV;
+        }
+        irq = res->start;
+        dev_dbg(&pdev->dev, "IRQ resource %d\n", irq);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&pdev->dev, "no registers address! Check %s setup!\n",
+                        dev_name(&pdev->dev));
+                return -ENODEV;
+        }
+        memstart = res->start;
+        memlen = res->end - res->start + 1;
+        dev_dbg(&pdev->dev, "MEM resource %lx-%lx\n", memstart, memlen);
+        if (!request_mem_region(memstart, memlen,
+                                oxu_hc_driver.description)) {
+                dev_dbg(&pdev->dev, "memory area already in use\n");
+                return -EBUSY;
+        }
+
+        ret = set_irq_type(irq, IRQF_TRIGGER_FALLING);
+        if (ret) {
+                dev_err(&pdev->dev, "error setting irq type\n");
+                ret = -EFAULT;
+                goto error_set_irq_type;
+        }
+
+        base = ioremap(memstart, memlen);
+        if (!base) {
+                dev_dbg(&pdev->dev, "error mapping memory\n");
+                ret = -EFAULT;
+                goto error_ioremap;
+        }
+
+        /* Allocate a driver data struct to hold useful info for both
+         * SPH & OTG devices
+         */
+        info = kzalloc(sizeof(struct oxu_info), GFP_KERNEL);
+        if (!info) {
+                dev_dbg(&pdev->dev, "error allocating memory\n");
+                ret = -EFAULT;
+                goto error_alloc;
+        }
+        platform_set_drvdata(pdev, info);
+
+        ret = oxu_init(pdev, memstart, memlen, base, irq);
+        if (ret < 0) {
+                dev_dbg(&pdev->dev, "cannot init USB devices\n");
+                goto error_init;
+        }
+
+        dev_info(&pdev->dev, "devices enabled and running\n");
+        platform_set_drvdata(pdev, info);
+
+        return 0;
+
+error_init:
+        kfree(info);
+        platform_set_drvdata(pdev, NULL);
+
+error_alloc:
+        iounmap(base);
+
+error_set_irq_type:
+error_ioremap:
+        release_mem_region(memstart, memlen);
+
+        dev_err(&pdev->dev, "init %s fail, %d\n", dev_name(&pdev->dev), ret);
+        return ret;
+}
+
+static void oxu_remove(struct platform_device *pdev, struct usb_hcd *hcd)
+{
+        usb_remove_hcd(hcd);
+        usb_put_hcd(hcd);
+}
+
+static int oxu_drv_remove(struct platform_device *pdev)
+{
+        struct oxu_info *info = platform_get_drvdata(pdev);
+        unsigned long memstart = info->hcd[0]->rsrc_start,
+                        memlen = info->hcd[0]->rsrc_len;
+        void *base = info->hcd[0]->regs;
+
+        oxu_remove(pdev, info->hcd[0]);
+        oxu_remove(pdev, info->hcd[1]);
+
+        iounmap(base);
+        release_mem_region(memstart, memlen);
+
+        kfree(info);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+static void oxu_drv_shutdown(struct platform_device *pdev)
+{
+        oxu_drv_remove(pdev);
+}
+
+#if 0
+/* FIXME: TODO */
+static int oxu_drv_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        return 0;
+}
+
+static int oxu_drv_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+
+        return 0;
+}
+#else
+#define oxu_drv_suspend NULL
+#define oxu_drv_resume  NULL
+#endif
+
+static struct platform_driver oxu_driver = {
+        .probe          = oxu_drv_probe,
+        .remove         = oxu_drv_remove,
+        .shutdown       = oxu_drv_shutdown,
+        .suspend        = oxu_drv_suspend,
+        .resume         = oxu_drv_resume,
+        .driver = {
+                .name = "oxu210hp-hcd",
+                .bus = &platform_bus_type
+        }
+};
+
+static int __init oxu_module_init(void)
+{
+        int retval = 0;
+
+        retval = platform_driver_register(&oxu_driver);
+        if (retval < 0)
+                return retval;
+
+        return retval;
+}
+
+static void __exit oxu_module_cleanup(void)
+{
+        platform_driver_unregister(&oxu_driver);
+}
+
+module_init(oxu_module_init);
+module_exit(oxu_module_cleanup);
+
+MODULE_DESCRIPTION("Oxford OXU210HP HCD driver - ver. " DRIVER_VERSION);
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/oxu210hp.h b/drivers/usb/host/oxu210hp.h
new file mode 100644
index 000000000000..8910e271cc7d
--- /dev/null
+++ b/drivers/usb/host/oxu210hp.h
@@ -0,0 +1,447 @@
+/*
+ * Host interface registers
+ */
+
+#define OXU_DEVICEID                    0x00
+        #define OXU_REV_MASK            0xffff0000
+        #define OXU_REV_SHIFT           16
+        #define OXU_REV_2100            0x2100
+        #define OXU_BO_SHIFT            8
+        #define OXU_BO_MASK             (0x3 << OXU_BO_SHIFT)
+        #define OXU_MAJ_REV_SHIFT       4
+        #define OXU_MAJ_REV_MASK        (0xf << OXU_MAJ_REV_SHIFT)
+        #define OXU_MIN_REV_SHIFT       0
+        #define OXU_MIN_REV_MASK        (0xf << OXU_MIN_REV_SHIFT)
+#define OXU_HOSTIFCONFIG                0x04
+#define OXU_SOFTRESET                   0x08
+        #define OXU_SRESET              (1 << 0)
+
+#define OXU_PIOBURSTREADCTRL            0x0C
+
+#define OXU_CHIPIRQSTATUS               0x10
+#define OXU_CHIPIRQEN_SET               0x14
+#define OXU_CHIPIRQEN_CLR               0x18
+        #define OXU_USBSPHLPWUI         0x00000080
+        #define OXU_USBOTGLPWUI         0x00000040
+        #define OXU_USBSPHI             0x00000002
+        #define OXU_USBOTGI             0x00000001
+
+#define OXU_CLKCTRL_SET                 0x1C
+        #define OXU_SYSCLKEN            0x00000008
+        #define OXU_USBSPHCLKEN         0x00000002
+        #define OXU_USBOTGCLKEN         0x00000001
+
+#define OXU_ASO                         0x68
+        #define OXU_SPHPOEN             0x00000100
+        #define OXU_OVRCCURPUPDEN       0x00000800
+        #define OXU_ASO_OP              (1 << 10)
+        #define OXU_COMPARATOR          0x000004000
+
+#define OXU_USBMODE                     0x1A8
+        #define OXU_VBPS                0x00000020
+        #define OXU_ES_LITTLE           0x00000000
+        #define OXU_CM_HOST_ONLY        0x00000003
+
+/*
+ * Proper EHCI structs & defines
+ */
+
+/* Magic numbers that can affect system performance */
+#define EHCI_TUNE_CERR          3       /* 0-3 qtd retries; 0 == don't stop */
+#define EHCI_TUNE_RL_HS         4       /* nak throttle; see 4.9 */
+#define EHCI_TUNE_RL_TT         0
+#define EHCI_TUNE_MULT_HS       1       /* 1-3 transactions/uframe; 4.10.3 */
+#define EHCI_TUNE_MULT_TT       1
+#define EHCI_TUNE_FLS           2       /* (small) 256 frame schedule */
+
+struct oxu_hcd;
+
+/* EHCI register interface, corresponds to EHCI Revision 0.95 specification */
+
+/* Section 2.2 Host Controller Capability Registers */
+struct ehci_caps {
+        /* these fields are specified as 8 and 16 bit registers,
+         * but some hosts can't perform 8 or 16 bit PCI accesses.
+         */
+        u32             hc_capbase;
+#define HC_LENGTH(p)            (((p)>>00)&0x00ff)      /* bits 7:0 */
+#define HC_VERSION(p)           (((p)>>16)&0xffff)      /* bits 31:16 */
+        u32             hcs_params;     /* HCSPARAMS - offset 0x4 */
+#define HCS_DEBUG_PORT(p)       (((p)>>20)&0xf) /* bits 23:20, debug port? */
+#define HCS_INDICATOR(p)        ((p)&(1 << 16)) /* true: has port indicators */
+#define HCS_N_CC(p)             (((p)>>12)&0xf) /* bits 15:12, #companion HCs */
+#define HCS_N_PCC(p)            (((p)>>8)&0xf)  /* bits 11:8, ports per CC */
+#define HCS_PORTROUTED(p)       ((p)&(1 << 7))  /* true: port routing */
+#define HCS_PPC(p)              ((p)&(1 << 4))  /* true: port power control */
+#define HCS_N_PORTS(p)          (((p)>>0)&0xf)  /* bits 3:0, ports on HC */
+
+        u32             hcc_params;      /* HCCPARAMS - offset 0x8 */
+#define HCC_EXT_CAPS(p)         (((p)>>8)&0xff) /* for pci extended caps */
+#define HCC_ISOC_CACHE(p)       ((p)&(1 << 7))  /* true: can cache isoc frame */
+#define HCC_ISOC_THRES(p)       (((p)>>4)&0x7)  /* bits 6:4, uframes cached */
+#define HCC_CANPARK(p)          ((p)&(1 << 2))  /* true: can park on async qh */
+#define HCC_PGM_FRAMELISTLEN(p) ((p)&(1 << 1))  /* true: periodic_size changes*/
+#define HCC_64BIT_ADDR(p)       ((p)&(1))       /* true: can use 64-bit addr */
+        u8              portroute[8];    /* nibbles for routing - offset 0xC */
+} __attribute__ ((packed));
+
+
+/* Section 2.3 Host Controller Operational Registers */
+struct ehci_regs {
+        /* USBCMD: offset 0x00 */
+        u32             command;
+/* 23:16 is r/w intr rate, in microframes; default "8" == 1/msec */
+#define CMD_PARK        (1<<11)         /* enable "park" on async qh */
+#define CMD_PARK_CNT(c) (((c)>>8)&3)    /* how many transfers to park for */
+#define CMD_LRESET      (1<<7)          /* partial reset (no ports, etc) */
+#define CMD_IAAD        (1<<6)          /* "doorbell" interrupt async advance */
+#define CMD_ASE         (1<<5)          /* async schedule enable */
+#define CMD_PSE         (1<<4)          /* periodic schedule enable */
+/* 3:2 is periodic frame list size */
+#define CMD_RESET       (1<<1)          /* reset HC not bus */
+#define CMD_RUN         (1<<0)          /* start/stop HC */
+
+        /* USBSTS: offset 0x04 */
+        u32             status;
+#define STS_ASS         (1<<15)         /* Async Schedule Status */
+#define STS_PSS         (1<<14)         /* Periodic Schedule Status */
+#define STS_RECL        (1<<13)         /* Reclamation */
+#define STS_HALT        (1<<12)         /* Not running (any reason) */
+/* some bits reserved */
+        /* these STS_* flags are also intr_enable bits (USBINTR) */
+#define STS_IAA         (1<<5)          /* Interrupted on async advance */
+#define STS_FATAL       (1<<4)          /* such as some PCI access errors */
+#define STS_FLR         (1<<3)          /* frame list rolled over */
+#define STS_PCD         (1<<2)          /* port change detect */
+#define STS_ERR         (1<<1)          /* "error" completion (overflow, ...) */
+#define STS_INT         (1<<0)          /* "normal" completion (short, ...) */
+
+#define INTR_MASK (STS_IAA | STS_FATAL | STS_PCD | STS_ERR | STS_INT)
+
+        /* USBINTR: offset 0x08 */
+        u32             intr_enable;
+
+        /* FRINDEX: offset 0x0C */
+        u32             frame_index;    /* current microframe number */
+        /* CTRLDSSEGMENT: offset 0x10 */
+        u32             segment;        /* address bits 63:32 if needed */
+        /* PERIODICLISTBASE: offset 0x14 */
+        u32             frame_list;     /* points to periodic list */
+        /* ASYNCLISTADDR: offset 0x18 */
+        u32             async_next;     /* address of next async queue head */
+
+        u32             reserved[9];
+
+        /* CONFIGFLAG: offset 0x40 */
+        u32             configured_flag;
+#define FLAG_CF         (1<<0)          /* true: we'll support "high speed" */
+
+        /* PORTSC: offset 0x44 */
+        u32             port_status[0]; /* up to N_PORTS */
+/* 31:23 reserved */
+#define PORT_WKOC_E     (1<<22)         /* wake on overcurrent (enable) */
+#define PORT_WKDISC_E   (1<<21)         /* wake on disconnect (enable) */
+#define PORT_WKCONN_E   (1<<20)         /* wake on connect (enable) */
+/* 19:16 for port testing */
+#define PORT_LED_OFF    (0<<14)
+#define PORT_LED_AMBER  (1<<14)
+#define PORT_LED_GREEN  (2<<14)
+#define PORT_LED_MASK   (3<<14)
+#define PORT_OWNER      (1<<13)         /* true: companion hc owns this port */
+#define PORT_POWER      (1<<12)         /* true: has power (see PPC) */
+#define PORT_USB11(x) (((x)&(3<<10)) == (1<<10))        /* USB 1.1 device */
+/* 11:10 for detecting lowspeed devices (reset vs release ownership) */
+/* 9 reserved */
+#define PORT_RESET      (1<<8)          /* reset port */
+#define PORT_SUSPEND    (1<<7)          /* suspend port */
+#define PORT_RESUME     (1<<6)          /* resume it */
+#define PORT_OCC        (1<<5)          /* over current change */
+#define PORT_OC         (1<<4)          /* over current active */
+#define PORT_PEC        (1<<3)          /* port enable change */
+#define PORT_PE         (1<<2)          /* port enable */
+#define PORT_CSC        (1<<1)          /* connect status change */
+#define PORT_CONNECT    (1<<0)          /* device connected */
+#define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_OCC)
+} __attribute__ ((packed));
+
+/* Appendix C, Debug port ... intended for use with special "debug devices"
+ * that can help if there's no serial console.  (nonstandard enumeration.)
+ */
+struct ehci_dbg_port {
+        u32     control;
+#define DBGP_OWNER      (1<<30)
+#define DBGP_ENABLED    (1<<28)
+#define DBGP_DONE       (1<<16)
+#define DBGP_INUSE      (1<<10)
+#define DBGP_ERRCODE(x) (((x)>>7)&0x07)
+#       define DBGP_ERR_BAD     1
+#       define DBGP_ERR_SIGNAL  2
+#define DBGP_ERROR      (1<<6)
+#define DBGP_GO         (1<<5)
+#define DBGP_OUT        (1<<4)
+#define DBGP_LEN(x)     (((x)>>0)&0x0f)
+        u32     pids;
+#define DBGP_PID_GET(x)         (((x)>>16)&0xff)
+#define DBGP_PID_SET(data, tok) (((data)<<8)|(tok))
+        u32     data03;
+        u32     data47;
+        u32     address;
+#define DBGP_EPADDR(dev, ep)    (((dev)<<8)|(ep))
+} __attribute__ ((packed));
+
+
+#define QTD_NEXT(dma)   cpu_to_le32((u32)dma)
+
+/*
+ * EHCI Specification 0.95 Section 3.5
+ * QTD: describe data transfer components (buffer, direction, ...)
+ * See Fig 3-6 "Queue Element Transfer Descriptor Block Diagram".
+ *
+ * These are associated only with "QH" (Queue Head) structures,
+ * used with control, bulk, and interrupt transfers.
+ */
+struct ehci_qtd {
+        /* first part defined by EHCI spec */
+        __le32                  hw_next;                /* see EHCI 3.5.1 */
+        __le32                  hw_alt_next;            /* see EHCI 3.5.2 */
+        __le32                  hw_token;               /* see EHCI 3.5.3 */
+#define QTD_TOGGLE      (1 << 31)       /* data toggle */
+#define QTD_LENGTH(tok) (((tok)>>16) & 0x7fff)
+#define QTD_IOC         (1 << 15)       /* interrupt on complete */
+#define QTD_CERR(tok)   (((tok)>>10) & 0x3)
+#define QTD_PID(tok)    (((tok)>>8) & 0x3)
+#define QTD_STS_ACTIVE  (1 << 7)        /* HC may execute this */
+#define QTD_STS_HALT    (1 << 6)        /* halted on error */
+#define QTD_STS_DBE     (1 << 5)        /* data buffer error (in HC) */
+#define QTD_STS_BABBLE  (1 << 4)        /* device was babbling (qtd halted) */
+#define QTD_STS_XACT    (1 << 3)        /* device gave illegal response */
+#define QTD_STS_MMF     (1 << 2)        /* incomplete split transaction */
+#define QTD_STS_STS     (1 << 1)        /* split transaction state */
+#define QTD_STS_PING    (1 << 0)        /* issue PING? */
+        __le32                  hw_buf[5];              /* see EHCI 3.5.4 */
+        __le32                  hw_buf_hi[5];           /* Appendix B */
+
+        /* the rest is HCD-private */
+        dma_addr_t              qtd_dma;                /* qtd address */
+        struct list_head        qtd_list;               /* sw qtd list */
+        struct urb              *urb;                   /* qtd's urb */
+        size_t                  length;                 /* length of buffer */
+
+        u32                     qtd_buffer_len;
+        void                    *buffer;
+        dma_addr_t              buffer_dma;
+        void                    *transfer_buffer;
+        void                    *transfer_dma;
+} __attribute__ ((aligned(32)));
+
+/* mask NakCnt+T in qh->hw_alt_next */
+#define QTD_MASK __constant_cpu_to_le32 (~0x1f)
+
+#define IS_SHORT_READ(token) (QTD_LENGTH(token) != 0 && QTD_PID(token) == 1)
+
+/* Type tag from {qh, itd, sitd, fstn}->hw_next */
+#define Q_NEXT_TYPE(dma) ((dma) & __constant_cpu_to_le32 (3 << 1))
+
+/* values for that type tag */
+#define Q_TYPE_QH       __constant_cpu_to_le32 (1 << 1)
+
+/* next async queue entry, or pointer to interrupt/periodic QH */
+#define QH_NEXT(dma)    (cpu_to_le32(((u32)dma)&~0x01f)|Q_TYPE_QH)
+
+/* for periodic/async schedules and qtd lists, mark end of list */
+#define EHCI_LIST_END   __constant_cpu_to_le32(1) /* "null pointer" to hw */
+
+/*
+ * Entries in periodic shadow table are pointers to one of four kinds
+ * of data structure.  That's dictated by the hardware; a type tag is
+ * encoded in the low bits of the hardware's periodic schedule.  Use
+ * Q_NEXT_TYPE to get the tag.
+ *
+ * For entries in the async schedule, the type tag always says "qh".
+ */
+union ehci_shadow {
+        struct ehci_qh          *qh;            /* Q_TYPE_QH */
+        __le32                  *hw_next;       /* (all types) */
+        void                    *ptr;
+};
+
+/*
+ * EHCI Specification 0.95 Section 3.6
+ * QH: describes control/bulk/interrupt endpoints
+ * See Fig 3-7 "Queue Head Structure Layout".
+ *
+ * These appear in both the async and (for interrupt) periodic schedules.
+ */
+
+struct ehci_qh {
+        /* first part defined by EHCI spec */
+        __le32                  hw_next;         /* see EHCI 3.6.1 */
+        __le32                  hw_info1;       /* see EHCI 3.6.2 */
+#define QH_HEAD         0x00008000
+        __le32                  hw_info2;       /* see EHCI 3.6.2 */
+#define QH_SMASK        0x000000ff
+#define QH_CMASK        0x0000ff00
+#define QH_HUBADDR      0x007f0000
+#define QH_HUBPORT      0x3f800000
+#define QH_MULT         0xc0000000
+        __le32                  hw_current;      /* qtd list - see EHCI 3.6.4 */
+
+        /* qtd overlay (hardware parts of a struct ehci_qtd) */
+        __le32                  hw_qtd_next;
+        __le32                  hw_alt_next;
+        __le32                  hw_token;
+        __le32                  hw_buf[5];
+        __le32                  hw_buf_hi[5];
+
+        /* the rest is HCD-private */
+        dma_addr_t              qh_dma;         /* address of qh */
+        union ehci_shadow       qh_next;        /* ptr to qh; or periodic */
+        struct list_head        qtd_list;       /* sw qtd list */
+        struct ehci_qtd         *dummy;
+        struct ehci_qh          *reclaim;       /* next to reclaim */
+
+        struct oxu_hcd          *oxu;
+        struct kref             kref;
+        unsigned                stamp;
+
+        u8                      qh_state;
+#define QH_STATE_LINKED         1               /* HC sees this */
+#define QH_STATE_UNLINK         2               /* HC may still see this */
+#define QH_STATE_IDLE           3               /* HC doesn't see this */
+#define QH_STATE_UNLINK_WAIT    4               /* LINKED and on reclaim q */
+#define QH_STATE_COMPLETING     5               /* don't touch token.HALT */
+
+        /* periodic schedule info */
+        u8                      usecs;          /* intr bandwidth */
+        u8                      gap_uf;         /* uframes split/csplit gap */
+        u8                      c_usecs;        /* ... split completion bw */
+        u16                     tt_usecs;       /* tt downstream bandwidth */
+        unsigned short          period;         /* polling interval */
+        unsigned short          start;          /* where polling starts */
+#define NO_FRAME ((unsigned short)~0)                   /* pick new start */
+        struct usb_device       *dev;           /* access to TT */
+} __attribute__ ((aligned(32)));
+
+/*
+ * Proper OXU210HP structs
+ */
+
+#define OXU_OTG_CORE_OFFSET     0x00400
+#define OXU_OTG_CAP_OFFSET      (OXU_OTG_CORE_OFFSET + 0x100)
+#define OXU_SPH_CORE_OFFSET     0x00800
+#define OXU_SPH_CAP_OFFSET      (OXU_SPH_CORE_OFFSET + 0x100)
+
+#define OXU_OTG_MEM             0xE000
+#define OXU_SPH_MEM             0x16000
+
+/* Only how many elements & element structure are specifies here. */
+/* 2 host controllers are enabled - total size <= 28 kbytes */
+#define DEFAULT_I_TDPS          1024
+#define QHEAD_NUM               16
+#define QTD_NUM                 32
+#define SITD_NUM                8
+#define MURB_NUM                8
+
+#define BUFFER_NUM              8
+#define BUFFER_SIZE             512
+
+struct oxu_info {
+        struct usb_hcd *hcd[2];
+};
+
+struct oxu_buf {
+        u8                      buffer[BUFFER_SIZE];
+} __attribute__ ((aligned(BUFFER_SIZE)));
+
+struct oxu_onchip_mem {
+        struct oxu_buf          db_pool[BUFFER_NUM];
+
+        u32                     frame_list[DEFAULT_I_TDPS];
+        struct ehci_qh          qh_pool[QHEAD_NUM];
+        struct ehci_qtd         qtd_pool[QTD_NUM];
+} __attribute__ ((aligned(4 << 10)));
+
+#define EHCI_MAX_ROOT_PORTS     15              /* see HCS_N_PORTS */
+
+struct oxu_murb {
+        struct urb              urb;
+        struct urb              *main;
+        u8                      last;
+};
+
+struct oxu_hcd {                                /* one per controller */
+        unsigned int            is_otg:1;
+
+        u8                      qh_used[QHEAD_NUM];
+        u8                      qtd_used[QTD_NUM];
+        u8                      db_used[BUFFER_NUM];
+        u8                      murb_used[MURB_NUM];
+
+        struct oxu_onchip_mem   __iomem *mem;
+        spinlock_t              mem_lock;
+
+        struct timer_list       urb_timer;
+
+        struct ehci_caps __iomem *caps;
+        struct ehci_regs __iomem *regs;
+
+        __u32                   hcs_params;     /* cached register copy */
+        spinlock_t              lock;
+
+        /* async schedule support */
+        struct ehci_qh          *async;
+        struct ehci_qh          *reclaim;
+        unsigned                reclaim_ready:1;
+        unsigned                scanning:1;
+
+        /* periodic schedule support */
+        unsigned                periodic_size;
+        __le32                  *periodic;      /* hw periodic table */
+        dma_addr_t              periodic_dma;
+        unsigned                i_thresh;       /* uframes HC might cache */
+
+        union ehci_shadow       *pshadow;       /* mirror hw periodic table */
+        int                     next_uframe;    /* scan periodic, start here */
+        unsigned                periodic_sched; /* periodic activity count */
+
+        /* per root hub port */
+        unsigned long           reset_done[EHCI_MAX_ROOT_PORTS];
+        /* bit vectors (one bit per port) */
+        unsigned long           bus_suspended;  /* which ports were
+                                                 * already suspended at the
+                                                 * start of a bus suspend
+                                                 */
+        unsigned long           companion_ports;/* which ports are dedicated
+                                                 * to the companion controller
+                                                 */
+
+        struct timer_list       watchdog;
+        unsigned long           actions;
+        unsigned                stamp;
+        unsigned long           next_statechange;
+        u32                     command;
+
+        /* SILICON QUIRKS */
+        struct list_head        urb_list;       /* this is the head to urb
+                                                 * queue that didn't get enough
+                                                 * resources
+                                                 */
+        struct oxu_murb         *murb_pool;     /* murb per split big urb */
+        unsigned urb_len;
+
+        u8                      sbrn;           /* packed release number */
+};
+
+#define EHCI_IAA_JIFFIES        (HZ/100)        /* arbitrary; ~10 msec */
+#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 */
+
+enum ehci_timer_action {
+        TIMER_IO_WATCHDOG,
+        TIMER_IAA_WATCHDOG,
+        TIMER_ASYNC_SHRINK,
+        TIMER_ASYNC_OFF,
+};
+
+#include <linux/oxu210hp.h>
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index ae6e70edd745..75b69847918e 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -172,9 +172,9 @@ static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
         if (!mmio_resource_enabled(pdev, 0))
                 return;
 
-        base = ioremap_nocache(pci_resource_start(pdev, 0),
-                                     pci_resource_len(pdev, 0));
-        if (base == NULL) return;
+        base = pci_ioremap_bar(pdev, 0);
+        if (base == NULL)
+                return;
 
 /* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
 #ifndef __hppa__
@@ -221,9 +221,9 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
         if (!mmio_resource_enabled(pdev, 0))
                 return;
 
-        base = ioremap_nocache(pci_resource_start(pdev, 0),
-                                pci_resource_len(pdev, 0));
-        if (base == NULL) return;
+        base = pci_ioremap_bar(pdev, 0);
+        if (base == NULL)
+                return;
 
         cap_length = readb(base);
         op_reg_base = base + cap_length;
@@ -271,7 +271,7 @@ static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
                         /* if boot firmware now owns EHCI, spin till
                          * it hands it over.
                          */
-                        msec = 5000;
+                        msec = 1000;
                         while ((cap & EHCI_USBLEGSUP_BIOS) && (msec > 0)) {
                                 tried_handoff = 1;
                                 msleep(10);
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index c21f14e0666a..319041205b57 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2275,7 +2275,6 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev)
         return 0;
 }
 
-#define resource_len(r) (((r)->end - (r)->start) + 1)
 static int __init r8a66597_probe(struct platform_device *pdev)
 {
 #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
@@ -2296,11 +2295,10 @@ static int __init r8a66597_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                                           (char *)hcd_name);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 ret = -ENODEV;
-                dev_err(&pdev->dev, "platform_get_resource_byname error.\n");
+                dev_err(&pdev->dev, "platform_get_resource error.\n");
                 goto clean_up;
         }
 
@@ -2315,7 +2313,7 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         irq = ires->start;
         irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
 
-        reg = ioremap(res->start, resource_len(res));
+        reg = ioremap(res->start, resource_size(res));
         if (reg == NULL) {
                 ret = -ENOMEM;
                 dev_err(&pdev->dev, "ioremap error.\n");
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index cf5e4cf7ea42..4e221060f58c 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -942,6 +942,8 @@ static struct pci_driver uhci_pci_driver = {
 
 #ifdef  CONFIG_PM
         .suspend =      usb_hcd_pci_suspend,
+        .suspend_late = usb_hcd_pci_suspend_late,
+        .resume_early = usb_hcd_pci_resume_early,
         .resume =       usb_hcd_pci_resume,
 #endif  /* PM */
 };
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 885867a86de8..4541dfcea88f 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -350,17 +350,16 @@ static int mts_scsi_abort(struct scsi_cmnd *srb)
 static int mts_scsi_host_reset(struct scsi_cmnd *srb)
 {
         struct mts_desc* desc = (struct mts_desc*)(srb->device->host->hostdata[0]);
-        int result, rc;
+        int result;
 
         MTS_DEBUG_GOT_HERE();
         mts_debug_dump(desc);
 
-        rc = usb_lock_device_for_reset(desc->usb_dev, desc->usb_intf);
-        if (rc < 0)
-                return FAILED;
-        result = usb_reset_device(desc->usb_dev);
-        if (rc)
+        result = usb_lock_device_for_reset(desc->usb_dev, desc->usb_intf);
+        if (result == 0) {
+                result = usb_reset_device(desc->usb_dev);
                 usb_unlock_device(desc->usb_dev);
+        }
         return result ? FAILED : SUCCESS;
 }
 
diff --git a/drivers/usb/misc/berry_charge.c b/drivers/usb/misc/berry_charge.c
index 24e2dc3148a4..c05a85bc5925 100644
--- a/drivers/usb/misc/berry_charge.c
+++ b/drivers/usb/misc/berry_charge.c
@@ -123,6 +123,11 @@ static int berry_probe(struct usb_interface *intf,
 {
         struct usb_device *udev = interface_to_usbdev(intf);
 
+        if (udev->bus_mA < 500) {
+                dbg(&udev->dev, "Not enough power to charge available\n");
+                return -ENODEV;
+        }
+
         dbg(&udev->dev, "Power is set to %dmA\n",
             udev->actconfig->desc.bMaxPower * 2);
 
diff --git a/drivers/usb/misc/emi26.c b/drivers/usb/misc/emi26.c
index e762beb5f3c6..879a980ca8c4 100644
--- a/drivers/usb/misc/emi26.c
+++ b/drivers/usb/misc/emi26.c
@@ -160,7 +160,7 @@ static int emi26_load_firmware (struct usb_device *dev)
                         err("%s - error loading firmware: error = %d", __func__, err);
                         goto wraperr;
                 }
-        } while (i > 0);
+        } while (rec);
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi26_set_reset(dev,1);
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 444c69c447be..5f1a19d1497d 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -192,8 +192,6 @@ static struct urb *simple_alloc_urb (
 {
         struct urb              *urb;
 
-        if (bytes < 0)
-                return NULL;
         urb = usb_alloc_urb (0, GFP_KERNEL);
         if (!urb)
                 return urb;
diff --git a/drivers/usb/mon/Kconfig b/drivers/usb/mon/Kconfig
index deb9ddffa402..f28f350cd96a 100644
--- a/drivers/usb/mon/Kconfig
+++ b/drivers/usb/mon/Kconfig
@@ -3,14 +3,13 @@
 #
 
 config USB_MON
-        bool "USB Monitor"
-        depends on USB!=n
-        default y
+        tristate "USB Monitor"
+        depends on USB
+        default y if USB=y
+        default m if USB=m
         help
-          If you say Y here, a component which captures the USB traffic
+          If you select this option, a component which captures the USB traffic
           between peripheral-specific drivers and HC drivers will be built.
           For more information, see <file:Documentation/usb/usbmon.txt>.
 
-          This is somewhat experimental at this time, but it should be safe.
-
-          If unsure, say Y.
+          If unsure, say Y (if allowed), otherwise M.
diff --git a/drivers/usb/mon/Makefile b/drivers/usb/mon/Makefile
index 0f76ed5e1617..c6516b566731 100644
--- a/drivers/usb/mon/Makefile
+++ b/drivers/usb/mon/Makefile
@@ -4,5 +4,4 @@
 
 usbmon-objs     := mon_main.o mon_stat.o mon_text.o mon_bin.o mon_dma.o
 
-# This does not use CONFIG_USB_MON because we want this to use a tristate.
-obj-$(CONFIG_USB)       += usbmon.o
+obj-$(CONFIG_USB_MON)   += usbmon.o
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 4b9542bbb35c..5af7379cd9a3 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -11,7 +11,7 @@ config USB_MUSB_HDRC
         depends on (USB || USB_GADGET) && HAVE_CLK
         depends on !SUPERH
         select TWL4030_USB if MACH_OMAP_3430SDP
-        tristate 'Inventra Highspeed Dual Role Controller (TI, ...)'
+        tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
         help
           Say Y here if your system has a dual role high speed USB
           controller based on the Mentor Graphics silicon IP.  Then
@@ -22,6 +22,9 @@ config USB_MUSB_HDRC
           Texas Instruments parts using this IP include DaVinci 644x,
           OMAP 243x, OMAP 343x, and TUSB 6010.
 
+          Analog Devices parts using this IP include Blackfin BF54x,
+          BF525 and BF527.
+
           If you do not know what this is, please say N.
 
           To compile this driver as a module, choose M here; the
@@ -33,6 +36,8 @@ config USB_MUSB_SOC
         default y if ARCH_DAVINCI
         default y if ARCH_OMAP2430
         default y if ARCH_OMAP34XX
+        default y if (BF54x && !BF544)
+        default y if (BF52x && !BF522 && !BF523)
 
 comment "DaVinci 644x USB support"
         depends on USB_MUSB_HDRC && ARCH_DAVINCI
@@ -43,6 +48,9 @@ comment "OMAP 243x high speed USB support"
 comment "OMAP 343x high speed USB support"
         depends on USB_MUSB_HDRC && ARCH_OMAP34XX
 
+comment "Blackfin high speed USB Support"
+        depends on USB_MUSB_HDRC && (BF54x && !BF544) || (BF52x && !BF522 && !BF523)
+
 config USB_TUSB6010
         boolean "TUSB 6010 support"
         depends on USB_MUSB_HDRC && !USB_MUSB_SOC
@@ -142,7 +150,7 @@ config MUSB_PIO_ONLY
 config USB_INVENTRA_DMA
         bool
         depends on USB_MUSB_HDRC && !MUSB_PIO_ONLY
-        default ARCH_OMAP2430 || ARCH_OMAP34XX
+        default ARCH_OMAP2430 || ARCH_OMAP34XX || BLACKFIN
         help
           Enable DMA transfers using Mentor's engine.
 
diff --git a/drivers/usb/musb/Makefile b/drivers/usb/musb/Makefile
index b6af0d687a73..85710ccc1887 100644
--- a/drivers/usb/musb/Makefile
+++ b/drivers/usb/musb/Makefile
@@ -22,6 +22,14 @@ ifeq ($(CONFIG_ARCH_OMAP3430),y)
         musb_hdrc-objs  += omap2430.o
 endif
 
+ifeq ($(CONFIG_BF54x),y)
+        musb_hdrc-objs  += blackfin.o
+endif
+
+ifeq ($(CONFIG_BF52x),y)
+        musb_hdrc-objs  += blackfin.o
+endif
+
 ifeq ($(CONFIG_USB_GADGET_MUSB_HDRC),y)
         musb_hdrc-objs          += musb_gadget_ep0.o musb_gadget.o
 endif
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
new file mode 100644
index 000000000000..786134852092
--- /dev/null
+++ b/drivers/usb/musb/blackfin.c
@@ -0,0 +1,320 @@
+/*
+ * MUSB OTG controller driver for Blackfin Processors
+ *
+ * Copyright 2006-2008 Analog Devices Inc.
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/list.h>
+#include <linux/clk.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+
+#include <asm/cacheflush.h>
+
+#include "musb_core.h"
+#include "blackfin.h"
+
+/*
+ * Load an endpoint's FIFO
+ */
+void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
+{
+        void __iomem *fifo = hw_ep->fifo;
+        void __iomem *epio = hw_ep->regs;
+
+        prefetch((u8 *)src);
+
+        musb_writew(epio, MUSB_TXCOUNT, len);
+
+        DBG(4, "TX ep%d fifo %p count %d buf %p, epio %p\n",
+                        hw_ep->epnum, fifo, len, src, epio);
+
+        dump_fifo_data(src, len);
+
+        if (unlikely((unsigned long)src & 0x01))
+                outsw_8((unsigned long)fifo, src,
+                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
+        else
+                outsw((unsigned long)fifo, src,
+                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
+}
+
+/*
+ * Unload an endpoint's FIFO
+ */
+void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
+{
+        void __iomem *fifo = hw_ep->fifo;
+        u8 epnum = hw_ep->epnum;
+        u16 dma_reg = 0;
+
+        DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
+                        'R', hw_ep->epnum, fifo, len, dst);
+
+#ifdef CONFIG_BF52x
+        invalidate_dcache_range((unsigned int)dst,
+                (unsigned int)(dst + len));
+
+        /* Setup DMA address register */
+        dma_reg = (u16) ((u32) dst & 0xFFFF);
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_LOW), dma_reg);
+        SSYNC();
+
+        dma_reg = (u16) (((u32) dst >> 16) & 0xFFFF);
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_ADDR_HIGH), dma_reg);
+        SSYNC();
+
+        /* Setup DMA count register */
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_LOW), len);
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_COUNT_HIGH), 0);
+        SSYNC();
+
+        /* Enable the DMA */
+        dma_reg = (epnum << 4) | DMA_ENA | INT_ENA;
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), dma_reg);
+        SSYNC();
+
+        /* Wait for compelete */
+        while (!(bfin_read_USB_DMA_INTERRUPT() & (1 << epnum)))
+                cpu_relax();
+
+        /* acknowledge dma interrupt */
+        bfin_write_USB_DMA_INTERRUPT(1 << epnum);
+        SSYNC();
+
+        /* Reset DMA */
+        bfin_write16(USB_DMA_REG(epnum, USB_DMAx_CTRL), 0);
+        SSYNC();
+#else
+        if (unlikely((unsigned long)dst & 0x01))
+                insw_8((unsigned long)fifo, dst,
+                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
+        else
+                insw((unsigned long)fifo, dst,
+                        len & 0x01 ? (len >> 1) + 1 : len >> 1);
+#endif
+
+        dump_fifo_data(dst, len);
+}
+
+static irqreturn_t blackfin_interrupt(int irq, void *__hci)
+{
+        unsigned long   flags;
+        irqreturn_t     retval = IRQ_NONE;
+        struct musb     *musb = __hci;
+
+        spin_lock_irqsave(&musb->lock, flags);
+
+        musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
+        musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
+        musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
+
+        if (musb->int_usb || musb->int_tx || musb->int_rx) {
+                musb_writeb(musb->mregs, MUSB_INTRUSB, musb->int_usb);
+                musb_writew(musb->mregs, MUSB_INTRTX, musb->int_tx);
+                musb_writew(musb->mregs, MUSB_INTRRX, musb->int_rx);
+                retval = musb_interrupt(musb);
+        }
+
+        spin_unlock_irqrestore(&musb->lock, flags);
+
+        /* REVISIT we sometimes get spurious IRQs on g_ep0
+         * not clear why... fall in BF54x too.
+         */
+        if (retval != IRQ_HANDLED)
+                DBG(5, "spurious?\n");
+
+        return IRQ_HANDLED;
+}
+
+static void musb_conn_timer_handler(unsigned long _musb)
+{
+        struct musb *musb = (void *)_musb;
+        unsigned long flags;
+        u16 val;
+
+        spin_lock_irqsave(&musb->lock, flags);
+        switch (musb->xceiv.state) {
+        case OTG_STATE_A_IDLE:
+        case OTG_STATE_A_WAIT_BCON:
+                /* Start a new session */
+                val = musb_readw(musb->mregs, MUSB_DEVCTL);
+                val |= MUSB_DEVCTL_SESSION;
+                musb_writew(musb->mregs, MUSB_DEVCTL, val);
+
+                val = musb_readw(musb->mregs, MUSB_DEVCTL);
+                if (!(val & MUSB_DEVCTL_BDEVICE)) {
+                        gpio_set_value(musb->config->gpio_vrsel, 1);
+                        musb->xceiv.state = OTG_STATE_A_WAIT_BCON;
+                } else {
+                        gpio_set_value(musb->config->gpio_vrsel, 0);
+
+                        /* Ignore VBUSERROR and SUSPEND IRQ */
+                        val = musb_readb(musb->mregs, MUSB_INTRUSBE);
+                        val &= ~MUSB_INTR_VBUSERROR;
+                        musb_writeb(musb->mregs, MUSB_INTRUSBE, val);
+
+                        val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR;
+                        musb_writeb(musb->mregs, MUSB_INTRUSB, val);
+
+                        val = MUSB_POWER_HSENAB;
+                        musb_writeb(musb->mregs, MUSB_POWER, val);
+                }
+                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
+                break;
+
+        default:
+                DBG(1, "%s state not handled\n", otg_state_string(musb));
+                break;
+        }
+        spin_unlock_irqrestore(&musb->lock, flags);
+
+        DBG(4, "state is %s\n", otg_state_string(musb));
+}
+
+void musb_platform_enable(struct musb *musb)
+{
+        if (is_host_enabled(musb)) {
+                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
+                musb->a_wait_bcon = TIMER_DELAY;
+        }
+}
+
+void musb_platform_disable(struct musb *musb)
+{
+}
+
+static void bfin_vbus_power(struct musb *musb, int is_on, int sleeping)
+{
+}
+
+static void bfin_set_vbus(struct musb *musb, int is_on)
+{
+        if (is_on)
+                gpio_set_value(musb->config->gpio_vrsel, 1);
+        else
+                gpio_set_value(musb->config->gpio_vrsel, 0);
+
+        DBG(1, "VBUS %s, devctl %02x "
+                /* otg %3x conf %08x prcm %08x */ "\n",
+                otg_state_string(musb),
+                musb_readb(musb->mregs, MUSB_DEVCTL));
+}
+
+static int bfin_set_power(struct otg_transceiver *x, unsigned mA)
+{
+        return 0;
+}
+
+void musb_platform_try_idle(struct musb *musb, unsigned long timeout)
+{
+        if (is_host_enabled(musb))
+                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
+}
+
+int musb_platform_get_vbus_status(struct musb *musb)
+{
+        return 0;
+}
+
+void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+{
+}
+
+int __init musb_platform_init(struct musb *musb)
+{
+
+        /*
+         * Rev 1.0 BF549 EZ-KITs require PE7 to be high for both DEVICE
+         * and OTG HOST modes, while rev 1.1 and greater require PE7 to
+         * be low for DEVICE mode and high for HOST mode. We set it high
+         * here because we are in host mode
+         */
+
+        if (gpio_request(musb->config->gpio_vrsel, "USB_VRSEL")) {
+                printk(KERN_ERR "Failed ro request USB_VRSEL GPIO_%d \n",
+                        musb->config->gpio_vrsel);
+                return -ENODEV;
+        }
+        gpio_direction_output(musb->config->gpio_vrsel, 0);
+
+        if (ANOMALY_05000346) {
+                bfin_write_USB_APHY_CALIB(ANOMALY_05000346_value);
+                SSYNC();
+        }
+
+        if (ANOMALY_05000347) {
+                bfin_write_USB_APHY_CNTRL(0x0);
+                SSYNC();
+        }
+
+        /* TODO
+         * Set SIC-IVG register
+         */
+
+        /* Configure PLL oscillator register */
+        bfin_write_USB_PLLOSC_CTRL(0x30a8);
+        SSYNC();
+
+        bfin_write_USB_SRP_CLKDIV((get_sclk()/1000) / 32 - 1);
+        SSYNC();
+
+        bfin_write_USB_EP_NI0_RXMAXP(64);
+        SSYNC();
+
+        bfin_write_USB_EP_NI0_TXMAXP(64);
+        SSYNC();
+
+        /* Route INTRUSB/INTR_RX/INTR_TX to USB_INT0*/
+        bfin_write_USB_GLOBINTR(0x7);
+        SSYNC();
+
+        bfin_write_USB_GLOBAL_CTL(GLOBAL_ENA | EP1_TX_ENA | EP2_TX_ENA |
+                                EP3_TX_ENA | EP4_TX_ENA | EP5_TX_ENA |
+                                EP6_TX_ENA | EP7_TX_ENA | EP1_RX_ENA |
+                                EP2_RX_ENA | EP3_RX_ENA | EP4_RX_ENA |
+                                EP5_RX_ENA | EP6_RX_ENA | EP7_RX_ENA);
+        SSYNC();
+
+        if (is_host_enabled(musb)) {
+                musb->board_set_vbus = bfin_set_vbus;
+                setup_timer(&musb_conn_timer,
+                        musb_conn_timer_handler, (unsigned long) musb);
+        }
+        if (is_peripheral_enabled(musb))
+                musb->xceiv.set_power = bfin_set_power;
+
+        musb->isr = blackfin_interrupt;
+
+        return 0;
+}
+
+int musb_platform_suspend(struct musb *musb)
+{
+        return 0;
+}
+
+int musb_platform_resume(struct musb *musb)
+{
+        return 0;
+}
+
+
+int musb_platform_exit(struct musb *musb)
+{
+
+        bfin_vbus_power(musb, 0 /*off*/, 1);
+        gpio_free(musb->config->gpio_vrsel);
+        musb_platform_suspend(musb);
+
+        return 0;
+}
diff --git a/drivers/usb/musb/blackfin.h b/drivers/usb/musb/blackfin.h
new file mode 100644
index 000000000000..a240c1e53d16
--- /dev/null
+++ b/drivers/usb/musb/blackfin.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2007 by Analog Devices, Inc.
+ *
+ * The Inventra Controller Driver for Linux 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.
+ */
+
+#ifndef __MUSB_BLACKFIN_H__
+#define __MUSB_BLACKFIN_H__
+
+/*
+ * Blackfin specific definitions
+ */
+
+#undef DUMP_FIFO_DATA
+#ifdef DUMP_FIFO_DATA
+static void dump_fifo_data(u8 *buf, u16 len)
+{
+        u8 *tmp = buf;
+        int i;
+
+        for (i = 0; i < len; i++) {
+                if (!(i % 16) && i)
+                        pr_debug("\n");
+                pr_debug("%02x ", *tmp++);
+        }
+        pr_debug("\n");
+}
+#else
+#define dump_fifo_data(buf, len)        do {} while (0)
+#endif
+
+#ifdef CONFIG_BF52x
+
+#define USB_DMA_BASE            USB_DMA_INTERRUPT
+#define USB_DMAx_CTRL           0x04
+#define USB_DMAx_ADDR_LOW       0x08
+#define USB_DMAx_ADDR_HIGH      0x0C
+#define USB_DMAx_COUNT_LOW      0x10
+#define USB_DMAx_COUNT_HIGH     0x14
+
+#define USB_DMA_REG(ep, reg)    (USB_DMA_BASE + 0x20 * ep + reg)
+#endif
+
+/* Almost 1 second */
+#define TIMER_DELAY     (1 * HZ)
+
+static struct timer_list musb_conn_timer;
+
+#endif  /* __MUSB_BLACKFIN_H__ */
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index dfb3bcbe00fc..0d566dc5ce06 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -32,9 +32,9 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 
-#include <asm/arch/hardware.h>
-#include <asm/arch/memory.h>
-#include <asm/arch/gpio.h>
+#include <mach/arch/hardware.h>
+#include <mach/arch/memory.h>
+#include <mach/arch/gpio.h>
 #include <asm/mach-types.h>
 
 #include "musb_core.h"
@@ -364,6 +364,18 @@ static irqreturn_t davinci_interrupt(int irq, void *__hci)
         return IRQ_HANDLED;
 }
 
+int musb_platform_set_mode(struct musb *musb, u8 mode)
+{
+        /* EVM can't do this (right?) */
+        return -EIO;
+}
+
+int musb_platform_set_mode(struct musb *musb, u8 mode)
+{
+       /* EVM can't do this (right?) */
+       return -EIO;
+}
+
 int __init musb_platform_init(struct musb *musb)
 {
         void __iomem    *tibase = musb->ctrl_base;
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 5280dba9b1fb..6c7faacfb535 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -148,7 +148,8 @@ static inline struct musb *dev_to_musb(struct device *dev)
 
 /*-------------------------------------------------------------------------*/
 
-#ifndef CONFIG_USB_TUSB6010
+#if !defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_BLACKFIN)
+
 /*
  * Load an endpoint's FIFO
  */
@@ -1124,25 +1125,25 @@ fifo_setup(struct musb *musb, struct musb_hw_ep  *hw_ep,
 #endif
         switch (cfg->style) {
         case FIFO_TX:
-                musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
-                musb_writew(mbase, MUSB_TXFIFOADD, c_off);
+                musb_write_txfifosz(mbase, c_size);
+                musb_write_txfifoadd(mbase, c_off);
                 hw_ep->tx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
                 hw_ep->max_packet_sz_tx = maxpacket;
                 break;
         case FIFO_RX:
-                musb_writeb(mbase, MUSB_RXFIFOSZ, c_size);
-                musb_writew(mbase, MUSB_RXFIFOADD, c_off);
+                musb_write_rxfifosz(mbase, c_size);
+                musb_write_rxfifoadd(mbase, c_off);
                 hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
                 hw_ep->max_packet_sz_rx = maxpacket;
                 break;
         case FIFO_RXTX:
-                musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
-                musb_writew(mbase, MUSB_TXFIFOADD, c_off);
+                musb_write_txfifosz(mbase, c_size);
+                musb_write_txfifoadd(mbase, c_off);
                 hw_ep->rx_double_buffered = !!(c_size & MUSB_FIFOSZ_DPB);
                 hw_ep->max_packet_sz_rx = maxpacket;
 
-                musb_writeb(mbase, MUSB_RXFIFOSZ, c_size);
-                musb_writew(mbase, MUSB_RXFIFOADD, c_off);
+                musb_write_rxfifosz(mbase, c_size);
+                musb_write_rxfifoadd(mbase, c_off);
                 hw_ep->tx_double_buffered = hw_ep->rx_double_buffered;
                 hw_ep->max_packet_sz_tx = maxpacket;
 
@@ -1212,7 +1213,7 @@ static int __init ep_config_from_table(struct musb *musb)
                 if (epn >= musb->config->num_eps) {
                         pr_debug("%s: invalid ep %d\n",
                                         musb_driver_name, epn);
-                        continue;
+                        return -EINVAL;
                 }
                 offset = fifo_setup(musb, hw_ep + epn, cfg++, offset);
                 if (offset < 0) {
@@ -1246,9 +1247,10 @@ static int __init ep_config_from_table(struct musb *musb)
  */
 static int __init ep_config_from_hw(struct musb *musb)
 {
-        u8 epnum = 0, reg;
+        u8 epnum = 0;
         struct musb_hw_ep *hw_ep;
         void *mbase = musb->mregs;
+        int ret = 0;
 
         DBG(2, "<== static silicon ep config\n");
 
@@ -1258,26 +1260,9 @@ static int __init ep_config_from_hw(struct musb *musb)
                 musb_ep_select(mbase, epnum);
                 hw_ep = musb->endpoints + epnum;
 
-                /* read from core using indexed model */
-                reg = musb_readb(hw_ep->regs, 0x10 + MUSB_FIFOSIZE);
-                if (!reg) {
-                        /* 0's returned when no more endpoints */
+                ret = musb_read_fifosize(musb, hw_ep, epnum);
+                if (ret < 0)
                         break;
-                }
-                musb->nr_endpoints++;
-                musb->epmask |= (1 << epnum);
-
-                hw_ep->max_packet_sz_tx = 1 << (reg & 0x0f);
-
-                /* shared TX/RX FIFO? */
-                if ((reg & 0xf0) == 0xf0) {
-                        hw_ep->max_packet_sz_rx = hw_ep->max_packet_sz_tx;
-                        hw_ep->is_shared_fifo = true;
-                        continue;
-                } else {
-                        hw_ep->max_packet_sz_rx = 1 << ((reg & 0xf0) >> 4);
-                        hw_ep->is_shared_fifo = false;
-                }
 
                 /* FIXME set up hw_ep->{rx,tx}_double_buffered */
 
@@ -1326,7 +1311,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 
         /* log core options (read using indexed model) */
         musb_ep_select(mbase, 0);
-        reg = musb_readb(mbase, 0x10 + MUSB_CONFIGDATA);
+        reg = musb_read_configdata(mbase);
 
         strcpy(aInfo, (reg & MUSB_CONFIGDATA_UTMIDW) ? "UTMI-16" : "UTMI-8");
         if (reg & MUSB_CONFIGDATA_DYNFIFO)
@@ -1391,7 +1376,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
         }
 
         /* log release info */
-        hwvers = musb_readw(mbase, MUSB_HWVERS);
+        hwvers = musb_read_hwvers(mbase);
         rev_major = (hwvers >> 10) & 0x1f;
         rev_minor = hwvers & 0x3ff;
         snprintf(aRevision, 32, "%d.%d%s", rev_major,
@@ -1400,8 +1385,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
                         musb_driver_name, type, aRevision, aDate);
 
         /* configure ep0 */
-        musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
-        musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
+        musb_configure_ep0(musb);
 
         /* discover endpoint configuration */
         musb->nr_endpoints = 1;
@@ -1445,7 +1429,7 @@ static int __init musb_core_init(u16 musb_type, struct musb *musb)
 
                 hw_ep->regs = MUSB_EP_OFFSET(i, 0) + mbase;
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
-                hw_ep->target_regs = MUSB_BUSCTL_OFFSET(i, 0) + mbase;
+                hw_ep->target_regs = musb_read_target_reg_base(i, mbase);
                 hw_ep->rx_reinit = 1;
                 hw_ep->tx_reinit = 1;
 #endif
@@ -1671,17 +1655,20 @@ musb_mode_store(struct device *dev, struct device_attribute *attr,
 {
         struct musb     *musb = dev_to_musb(dev);
         unsigned long   flags;
+        int             status;
 
         spin_lock_irqsave(&musb->lock, flags);
-        if (!strncmp(buf, "host", 4))
-                musb_platform_set_mode(musb, MUSB_HOST);
-        if (!strncmp(buf, "peripheral", 10))
-                musb_platform_set_mode(musb, MUSB_PERIPHERAL);
-        if (!strncmp(buf, "otg", 3))
-                musb_platform_set_mode(musb, MUSB_OTG);
+        if (sysfs_streq(buf, "host"))
+                status = musb_platform_set_mode(musb, MUSB_HOST);
+        else if (sysfs_streq(buf, "peripheral"))
+                status = musb_platform_set_mode(musb, MUSB_PERIPHERAL);
+        else if (sysfs_streq(buf, "otg"))
+                status = musb_platform_set_mode(musb, MUSB_OTG);
+        else
+                status = -EINVAL;
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        return n;
+        return (status == 0) ? n : status;
 }
 static DEVICE_ATTR(mode, 0644, musb_mode_show, musb_mode_store);
 
@@ -1781,7 +1768,7 @@ allocate_instance(struct device *dev,
 #ifdef CONFIG_USB_MUSB_HDRC_HCD
         struct usb_hcd  *hcd;
 
-        hcd = usb_create_hcd(&musb_hc_driver, dev, dev->bus_id);
+        hcd = usb_create_hcd(&musb_hc_driver, dev, dev_name(dev));
         if (!hcd)
                 return NULL;
         /* usbcore sets dev->driver_data to hcd, and sometimes uses that... */
@@ -1810,7 +1797,6 @@ allocate_instance(struct device *dev,
         for (epnum = 0, ep = musb->endpoints;
                         epnum < musb->config->num_eps;
                         epnum++, ep++) {
-
                 ep->musb = musb;
                 ep->epnum = epnum;
         }
@@ -1838,7 +1824,7 @@ static void musb_free(struct musb *musb)
         musb_gadget_cleanup(musb);
 #endif
 
-        if (musb->nIrq >= 0) {
+        if (musb->nIrq >= 0 && musb->irq_wake) {
                 disable_irq_wake(musb->nIrq);
                 free_irq(musb->nIrq, musb);
         }
@@ -1984,15 +1970,19 @@ bad_config:
         INIT_WORK(&musb->irq_work, musb_irq_work);
 
         /* attach to the IRQ */
-        if (request_irq(nIrq, musb->isr, 0, dev->bus_id, musb)) {
+        if (request_irq(nIrq, musb->isr, 0, dev_name(dev), musb)) {
                 dev_err(dev, "request_irq %d failed!\n", nIrq);
                 status = -ENODEV;
                 goto fail2;
         }
         musb->nIrq = nIrq;
 /* FIXME this handles wakeup irqs wrong */
-        if (enable_irq_wake(nIrq) == 0)
+        if (enable_irq_wake(nIrq) == 0) {
+                musb->irq_wake = 1;
                 device_init_wakeup(dev, 1);
+        } else {
+                musb->irq_wake = 0;
+        }
 
         pr_info("%s: USB %s mode controller at %p using %s, IRQ %d\n",
                         musb_driver_name,
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 82227251931b..630946a2d9fc 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -191,7 +191,7 @@ enum musb_g_ep0_state {
  */
 
 #if defined(CONFIG_ARCH_DAVINCI) || defined(CONFIG_ARCH_OMAP2430) \
-                || defined(CONFIG_ARCH_OMAP3430)
+                || defined(CONFIG_ARCH_OMAP3430) || defined(CONFIG_BLACKFIN)
 /* REVISIT indexed access seemed to
  * misbehave (on DaVinci) for at least peripheral IN ...
  */
@@ -359,6 +359,7 @@ struct musb {
         struct otg_transceiver  xceiv;
 
         int nIrq;
+        unsigned                irq_wake:1;
 
         struct musb_hw_ep        endpoints[MUSB_C_NUM_EPS];
 #define control_ep              endpoints
@@ -447,6 +448,70 @@ static inline struct musb *gadget_to_musb(struct usb_gadget *g)
 }
 #endif
 
+#ifdef CONFIG_BLACKFIN
+static inline int musb_read_fifosize(struct musb *musb,
+                struct musb_hw_ep *hw_ep, u8 epnum)
+{
+        musb->nr_endpoints++;
+        musb->epmask |= (1 << epnum);
+
+        if (epnum < 5) {
+                hw_ep->max_packet_sz_tx = 128;
+                hw_ep->max_packet_sz_rx = 128;
+        } else {
+                hw_ep->max_packet_sz_tx = 1024;
+                hw_ep->max_packet_sz_rx = 1024;
+        }
+        hw_ep->is_shared_fifo = false;
+
+        return 0;
+}
+
+static inline void musb_configure_ep0(struct musb *musb)
+{
+        musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
+        musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
+        musb->endpoints[0].is_shared_fifo = true;
+}
+
+#else
+
+static inline int musb_read_fifosize(struct musb *musb,
+                struct musb_hw_ep *hw_ep, u8 epnum)
+{
+        u8 reg = 0;
+
+        /* read from core using indexed model */
+        reg = musb_readb(hw_ep->regs, 0x10 + MUSB_FIFOSIZE);
+        /* 0's returned when no more endpoints */
+        if (!reg)
+                return -ENODEV;
+
+        musb->nr_endpoints++;
+        musb->epmask |= (1 << epnum);
+
+        hw_ep->max_packet_sz_tx = 1 << (reg & 0x0f);
+
+        /* shared TX/RX FIFO? */
+        if ((reg & 0xf0) == 0xf0) {
+                hw_ep->max_packet_sz_rx = hw_ep->max_packet_sz_tx;
+                hw_ep->is_shared_fifo = true;
+                return 0;
+        } else {
+                hw_ep->max_packet_sz_rx = 1 << ((reg & 0xf0) >> 4);
+                hw_ep->is_shared_fifo = false;
+        }
+
+        return 0;
+}
+
+static inline void musb_configure_ep0(struct musb *musb)
+{
+        musb->endpoints[0].max_packet_sz_tx = MUSB_EP0_FIFOSIZE;
+        musb->endpoints[0].max_packet_sz_rx = MUSB_EP0_FIFOSIZE;
+}
+#endif /* CONFIG_BLACKFIN */
+
 
 /***************************** Glue it together *****************************/
 
@@ -467,16 +532,16 @@ extern void musb_platform_disable(struct musb *musb);
 
 extern void musb_hnp_stop(struct musb *musb);
 
-extern void musb_platform_set_mode(struct musb *musb, u8 musb_mode);
+extern int musb_platform_set_mode(struct musb *musb, u8 musb_mode);
 
-#if defined(CONFIG_USB_TUSB6010) || \
+#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN) || \
         defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP34XX)
 extern void musb_platform_try_idle(struct musb *musb, unsigned long timeout);
 #else
 #define musb_platform_try_idle(x, y)            do {} while (0)
 #endif
 
-#ifdef CONFIG_USB_TUSB6010
+#if defined(CONFIG_USB_TUSB6010) || defined(CONFIG_BLACKFIN)
 extern int musb_platform_get_vbus_status(struct musb *musb);
 #else
 #define musb_platform_get_vbus_status(x)        0
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index d6a802c224fa..6197daeab8f9 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1633,7 +1633,7 @@ int __init musb_gadget_setup(struct musb *musb)
         musb->g.speed = USB_SPEED_UNKNOWN;
 
         /* this "gadget" abstracts/virtualizes the controller */
-        strcpy(musb->g.dev.bus_id, "gadget");
+        dev_set_name(&musb->g.dev, "gadget");
         musb->g.dev.parent = musb->controller;
         musb->g.dev.dma_mask = musb->controller->dma_mask;
         musb->g.dev.release = musb_gadget_release;
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index cc64462d4c4e..99fa61234876 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -112,18 +112,21 @@ static void musb_h_tx_flush_fifo(struct musb_hw_ep *ep)
 {
         void __iomem    *epio = ep->regs;
         u16             csr;
+        u16             lastcsr = 0;
         int             retries = 1000;
 
         csr = musb_readw(epio, MUSB_TXCSR);
         while (csr & MUSB_TXCSR_FIFONOTEMPTY) {
-                DBG(5, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
+                if (csr != lastcsr)
+                        DBG(3, "Host TX FIFONOTEMPTY csr: %02x\n", csr);
+                lastcsr = csr;
                 csr |= MUSB_TXCSR_FLUSHFIFO;
                 musb_writew(epio, MUSB_TXCSR, csr);
                 csr = musb_readw(epio, MUSB_TXCSR);
-                if (retries-- < 1) {
-                        ERR("Could not flush host TX fifo: csr: %04x\n", csr);
+                if (WARN(retries-- < 1,
+                                "Could not flush host TX%d fifo: csr: %04x\n",
+                                ep->epnum, csr))
                         return;
-                }
                 mdelay(1);
         }
 }
@@ -268,7 +271,7 @@ __musb_giveback(struct musb *musb, struct urb *urb, int status)
 __releases(musb->lock)
 __acquires(musb->lock)
 {
-        DBG(({ int level; switch (urb->status) {
+        DBG(({ int level; switch (status) {
                                 case 0:
                                         level = 4;
                                         break;
@@ -283,8 +286,8 @@ __acquires(musb->lock)
                                         level = 2;
                                         break;
                                 }; level; }),
-                        "complete %p (%d), dev%d ep%d%s, %d/%d\n",
-                        urb, urb->status,
+                        "complete %p %pF (%d), dev%d ep%d%s, %d/%d\n",
+                        urb, urb->complete, status,
                         usb_pipedevice(urb->pipe),
                         usb_pipeendpoint(urb->pipe),
                         usb_pipein(urb->pipe) ? "in" : "out",
@@ -593,12 +596,10 @@ musb_rx_reinit(struct musb *musb, struct musb_qh *qh, struct musb_hw_ep *ep)
 
         /* target addr and (for multipoint) hub addr/port */
         if (musb->is_multipoint) {
-                musb_writeb(ep->target_regs, MUSB_RXFUNCADDR,
-                        qh->addr_reg);
-                musb_writeb(ep->target_regs, MUSB_RXHUBADDR,
-                        qh->h_addr_reg);
-                musb_writeb(ep->target_regs, MUSB_RXHUBPORT,
-                        qh->h_port_reg);
+                musb_write_rxfunaddr(ep->target_regs, qh->addr_reg);
+                musb_write_rxhubaddr(ep->target_regs, qh->h_addr_reg);
+                musb_write_rxhubport(ep->target_regs, qh->h_port_reg);
+
         } else
                 musb_writeb(musb->mregs, MUSB_FADDR, qh->addr_reg);
 
@@ -712,15 +713,9 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
 
                 /* target addr and (for multipoint) hub addr/port */
                 if (musb->is_multipoint) {
-                        musb_writeb(mbase,
-                                MUSB_BUSCTL_OFFSET(epnum, MUSB_TXFUNCADDR),
-                                qh->addr_reg);
-                        musb_writeb(mbase,
-                                MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBADDR),
-                                qh->h_addr_reg);
-                        musb_writeb(mbase,
-                                MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBPORT),
-                                qh->h_port_reg);
+                        musb_write_txfunaddr(mbase, epnum, qh->addr_reg);
+                        musb_write_txhubaddr(mbase, epnum, qh->h_addr_reg);
+                        musb_write_txhubport(mbase, epnum, qh->h_port_reg);
 /* FIXME if !epnum, do the same for RX ... */
                 } else
                         musb_writeb(mbase, MUSB_FADDR, qh->addr_reg);
@@ -988,8 +983,10 @@ static bool musb_h_ep0_continue(struct musb *musb, u16 len, struct urb *urb)
                 if (fifo_count) {
                         fifo_dest = (u8 *) (urb->transfer_buffer
                                         + urb->actual_length);
-                        DBG(3, "Sending %d bytes to %p\n",
-                                        fifo_count, fifo_dest);
+                        DBG(3, "Sending %d byte%s to ep0 fifo %p\n",
+                                        fifo_count,
+                                        (fifo_count == 1) ? "" : "s",
+                                        fifo_dest);
                         musb_write_fifo(hw_ep, fifo_count, fifo_dest);
 
                         urb->actual_length += fifo_count;
diff --git a/drivers/usb/musb/musb_io.h b/drivers/usb/musb/musb_io.h
index 223f0a514094..b06e9ef00cfc 100644
--- a/drivers/usb/musb/musb_io.h
+++ b/drivers/usb/musb/musb_io.h
@@ -39,7 +39,7 @@
 
 #if !defined(CONFIG_ARM) && !defined(CONFIG_SUPERH) \
         && !defined(CONFIG_AVR32) && !defined(CONFIG_PPC32) \
-        && !defined(CONFIG_PPC64)
+        && !defined(CONFIG_PPC64) && !defined(CONFIG_BLACKFIN)
 static inline void readsl(const void __iomem *addr, void *buf, int len)
         { insl((unsigned long)addr, buf, len); }
 static inline void readsw(const void __iomem *addr, void *buf, int len)
@@ -56,6 +56,8 @@ static inline void writesb(const void __iomem *addr, const void *buf, int len)
 
 #endif
 
+#ifndef CONFIG_BLACKFIN
+
 /* NOTE:  these offsets are all in bytes */
 
 static inline u16 musb_readw(const void __iomem *addr, unsigned offset)
@@ -114,4 +116,26 @@ static inline void musb_writeb(void __iomem *addr, unsigned offset, u8 data)
 
 #endif  /* CONFIG_USB_TUSB6010 */
 
+#else
+
+static inline u8 musb_readb(const void __iomem *addr, unsigned offset)
+        { return (u8) (bfin_read16(addr + offset)); }
+
+static inline u16 musb_readw(const void __iomem *addr, unsigned offset)
+        { return bfin_read16(addr + offset); }
+
+static inline u32 musb_readl(const void __iomem *addr, unsigned offset)
+        { return (u32) (bfin_read16(addr + offset)); }
+
+static inline void musb_writeb(void __iomem *addr, unsigned offset, u8 data)
+        { bfin_write16(addr + offset, (u16) data); }
+
+static inline void musb_writew(void __iomem *addr, unsigned offset, u16 data)
+        { bfin_write16(addr + offset, data); }
+
+static inline void musb_writel(void __iomem *addr, unsigned offset, u32 data)
+        { bfin_write16(addr + offset, (u16) data); }
+
+#endif /* CONFIG_BLACKFIN */
+
 #endif
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index 9c228661aa5a..de3b2f18db44 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -38,97 +38,6 @@
 #define MUSB_EP0_FIFOSIZE       64      /* This is non-configurable */
 
 /*
- * Common USB registers
- */
-
-#define MUSB_FADDR              0x00    /* 8-bit */
-#define MUSB_POWER              0x01    /* 8-bit */
-
-#define MUSB_INTRTX             0x02    /* 16-bit */
-#define MUSB_INTRRX             0x04
-#define MUSB_INTRTXE            0x06
-#define MUSB_INTRRXE            0x08
-#define MUSB_INTRUSB            0x0A    /* 8 bit */
-#define MUSB_INTRUSBE           0x0B    /* 8 bit */
-#define MUSB_FRAME              0x0C
-#define MUSB_INDEX              0x0E    /* 8 bit */
-#define MUSB_TESTMODE           0x0F    /* 8 bit */
-
-/* Get offset for a given FIFO from musb->mregs */
-#ifdef  CONFIG_USB_TUSB6010
-#define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
-#else
-#define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
-#endif
-
-/*
- * Additional Control Registers
- */
-
-#define MUSB_DEVCTL             0x60    /* 8 bit */
-
-/* These are always controlled through the INDEX register */
-#define MUSB_TXFIFOSZ           0x62    /* 8-bit (see masks) */
-#define MUSB_RXFIFOSZ           0x63    /* 8-bit (see masks) */
-#define MUSB_TXFIFOADD          0x64    /* 16-bit offset shifted right 3 */
-#define MUSB_RXFIFOADD          0x66    /* 16-bit offset shifted right 3 */
-
-/* REVISIT: vctrl/vstatus: optional vendor utmi+phy register at 0x68 */
-#define MUSB_HWVERS             0x6C    /* 8 bit */
-
-#define MUSB_EPINFO             0x78    /* 8 bit */
-#define MUSB_RAMINFO            0x79    /* 8 bit */
-#define MUSB_LINKINFO           0x7a    /* 8 bit */
-#define MUSB_VPLEN              0x7b    /* 8 bit */
-#define MUSB_HS_EOF1            0x7c    /* 8 bit */
-#define MUSB_FS_EOF1            0x7d    /* 8 bit */
-#define MUSB_LS_EOF1            0x7e    /* 8 bit */
-
-/* Offsets to endpoint registers */
-#define MUSB_TXMAXP             0x00
-#define MUSB_TXCSR              0x02
-#define MUSB_CSR0               MUSB_TXCSR      /* Re-used for EP0 */
-#define MUSB_RXMAXP             0x04
-#define MUSB_RXCSR              0x06
-#define MUSB_RXCOUNT            0x08
-#define MUSB_COUNT0             MUSB_RXCOUNT    /* Re-used for EP0 */
-#define MUSB_TXTYPE             0x0A
-#define MUSB_TYPE0              MUSB_TXTYPE     /* Re-used for EP0 */
-#define MUSB_TXINTERVAL         0x0B
-#define MUSB_NAKLIMIT0          MUSB_TXINTERVAL /* Re-used for EP0 */
-#define MUSB_RXTYPE             0x0C
-#define MUSB_RXINTERVAL         0x0D
-#define MUSB_FIFOSIZE           0x0F
-#define MUSB_CONFIGDATA         MUSB_FIFOSIZE   /* Re-used for EP0 */
-
-/* Offsets to endpoint registers in indexed model (using INDEX register) */
-#define MUSB_INDEXED_OFFSET(_epnum, _offset)    \
-        (0x10 + (_offset))
-
-/* Offsets to endpoint registers in flat models */
-#define MUSB_FLAT_OFFSET(_epnum, _offset)       \
-        (0x100 + (0x10*(_epnum)) + (_offset))
-
-#ifdef CONFIG_USB_TUSB6010
-/* TUSB6010 EP0 configuration register is special */
-#define MUSB_TUSB_OFFSET(_epnum, _offset)       \
-        (0x10 + _offset)
-#include "tusb6010.h"           /* Needed "only" for TUSB_EP0_CONF */
-#endif
-
-/* "bus control"/target registers, for host side multipoint (external hubs) */
-#define MUSB_TXFUNCADDR         0x00
-#define MUSB_TXHUBADDR          0x02
-#define MUSB_TXHUBPORT          0x03
-
-#define MUSB_RXFUNCADDR         0x04
-#define MUSB_RXHUBADDR          0x06
-#define MUSB_RXHUBPORT          0x07
-
-#define MUSB_BUSCTL_OFFSET(_epnum, _offset) \
-        (0x80 + (8*(_epnum)) + (_offset))
-
-/*
  * MUSB Register bits
  */
 
@@ -228,7 +137,6 @@
 
 /* TXCSR in Peripheral and Host mode */
 #define MUSB_TXCSR_AUTOSET              0x8000
-#define MUSB_TXCSR_MODE                 0x2000
 #define MUSB_TXCSR_DMAENAB              0x1000
 #define MUSB_TXCSR_FRCDATATOG           0x0800
 #define MUSB_TXCSR_DMAMODE              0x0400
@@ -297,4 +205,309 @@
 /* HUBADDR */
 #define MUSB_HUBADDR_MULTI_TT           0x80
 
+
+#ifndef CONFIG_BLACKFIN
+
+/*
+ * Common USB registers
+ */
+
+#define MUSB_FADDR              0x00    /* 8-bit */
+#define MUSB_POWER              0x01    /* 8-bit */
+
+#define MUSB_INTRTX             0x02    /* 16-bit */
+#define MUSB_INTRRX             0x04
+#define MUSB_INTRTXE            0x06
+#define MUSB_INTRRXE            0x08
+#define MUSB_INTRUSB            0x0A    /* 8 bit */
+#define MUSB_INTRUSBE           0x0B    /* 8 bit */
+#define MUSB_FRAME              0x0C
+#define MUSB_INDEX              0x0E    /* 8 bit */
+#define MUSB_TESTMODE           0x0F    /* 8 bit */
+
+/* Get offset for a given FIFO from musb->mregs */
+#ifdef  CONFIG_USB_TUSB6010
+#define MUSB_FIFO_OFFSET(epnum) (0x200 + ((epnum) * 0x20))
+#else
+#define MUSB_FIFO_OFFSET(epnum) (0x20 + ((epnum) * 4))
+#endif
+
+/*
+ * Additional Control Registers
+ */
+
+#define MUSB_DEVCTL             0x60    /* 8 bit */
+
+/* These are always controlled through the INDEX register */
+#define MUSB_TXFIFOSZ           0x62    /* 8-bit (see masks) */
+#define MUSB_RXFIFOSZ           0x63    /* 8-bit (see masks) */
+#define MUSB_TXFIFOADD          0x64    /* 16-bit offset shifted right 3 */
+#define MUSB_RXFIFOADD          0x66    /* 16-bit offset shifted right 3 */
+
+/* REVISIT: vctrl/vstatus: optional vendor utmi+phy register at 0x68 */
+#define MUSB_HWVERS             0x6C    /* 8 bit */
+
+#define MUSB_EPINFO             0x78    /* 8 bit */
+#define MUSB_RAMINFO            0x79    /* 8 bit */
+#define MUSB_LINKINFO           0x7a    /* 8 bit */
+#define MUSB_VPLEN              0x7b    /* 8 bit */
+#define MUSB_HS_EOF1            0x7c    /* 8 bit */
+#define MUSB_FS_EOF1            0x7d    /* 8 bit */
+#define MUSB_LS_EOF1            0x7e    /* 8 bit */
+
+/* Offsets to endpoint registers */
+#define MUSB_TXMAXP             0x00
+#define MUSB_TXCSR              0x02
+#define MUSB_CSR0               MUSB_TXCSR      /* Re-used for EP0 */
+#define MUSB_RXMAXP             0x04
+#define MUSB_RXCSR              0x06
+#define MUSB_RXCOUNT            0x08
+#define MUSB_COUNT0             MUSB_RXCOUNT    /* Re-used for EP0 */
+#define MUSB_TXTYPE             0x0A
+#define MUSB_TYPE0              MUSB_TXTYPE     /* Re-used for EP0 */
+#define MUSB_TXINTERVAL         0x0B
+#define MUSB_NAKLIMIT0          MUSB_TXINTERVAL /* Re-used for EP0 */
+#define MUSB_RXTYPE             0x0C
+#define MUSB_RXINTERVAL         0x0D
+#define MUSB_FIFOSIZE           0x0F
+#define MUSB_CONFIGDATA         MUSB_FIFOSIZE   /* Re-used for EP0 */
+
+/* Offsets to endpoint registers in indexed model (using INDEX register) */
+#define MUSB_INDEXED_OFFSET(_epnum, _offset)    \
+        (0x10 + (_offset))
+
+/* Offsets to endpoint registers in flat models */
+#define MUSB_FLAT_OFFSET(_epnum, _offset)       \
+        (0x100 + (0x10*(_epnum)) + (_offset))
+
+#ifdef CONFIG_USB_TUSB6010
+/* TUSB6010 EP0 configuration register is special */
+#define MUSB_TUSB_OFFSET(_epnum, _offset)       \
+        (0x10 + _offset)
+#include "tusb6010.h"           /* Needed "only" for TUSB_EP0_CONF */
+#endif
+
+#define MUSB_TXCSR_MODE                 0x2000
+
+/* "bus control"/target registers, for host side multipoint (external hubs) */
+#define MUSB_TXFUNCADDR         0x00
+#define MUSB_TXHUBADDR          0x02
+#define MUSB_TXHUBPORT          0x03
+
+#define MUSB_RXFUNCADDR         0x04
+#define MUSB_RXHUBADDR          0x06
+#define MUSB_RXHUBPORT          0x07
+
+#define MUSB_BUSCTL_OFFSET(_epnum, _offset) \
+        (0x80 + (8*(_epnum)) + (_offset))
+
+static inline void musb_write_txfifosz(void __iomem *mbase, u8 c_size)
+{
+        musb_writeb(mbase, MUSB_TXFIFOSZ, c_size);
+}
+
+static inline void musb_write_txfifoadd(void __iomem *mbase, u16 c_off)
+{
+        musb_writew(mbase, MUSB_TXFIFOADD, c_off);
+}
+
+static inline void musb_write_rxfifosz(void __iomem *mbase, u8 c_size)
+{
+        musb_writeb(mbase, MUSB_RXFIFOSZ, c_size);
+}
+
+static inline void  musb_write_rxfifoadd(void __iomem *mbase, u16 c_off)
+{
+        musb_writew(mbase, MUSB_RXFIFOADD, c_off);
+}
+
+static inline u8 musb_read_configdata(void __iomem *mbase)
+{
+        return musb_readb(mbase, 0x10 + MUSB_CONFIGDATA);
+}
+
+static inline u16 musb_read_hwvers(void __iomem *mbase)
+{
+        return musb_readw(mbase, MUSB_HWVERS);
+}
+
+static inline void __iomem *musb_read_target_reg_base(u8 i, void __iomem *mbase)
+{
+        return (MUSB_BUSCTL_OFFSET(i, 0) + mbase);
+}
+
+static inline void musb_write_rxfunaddr(void __iomem *ep_target_regs,
+                u8 qh_addr_reg)
+{
+        musb_writeb(ep_target_regs, MUSB_RXFUNCADDR, qh_addr_reg);
+}
+
+static inline void musb_write_rxhubaddr(void __iomem *ep_target_regs,
+                u8 qh_h_addr_reg)
+{
+        musb_writeb(ep_target_regs, MUSB_RXHUBADDR, qh_h_addr_reg);
+}
+
+static inline void musb_write_rxhubport(void __iomem *ep_target_regs,
+                u8 qh_h_port_reg)
+{
+        musb_writeb(ep_target_regs, MUSB_RXHUBPORT, qh_h_port_reg);
+}
+
+static inline void  musb_write_txfunaddr(void __iomem *mbase, u8 epnum,
+                u8 qh_addr_reg)
+{
+        musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXFUNCADDR),
+                        qh_addr_reg);
+}
+
+static inline void  musb_write_txhubaddr(void __iomem *mbase, u8 epnum,
+                u8 qh_addr_reg)
+{
+        musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBADDR),
+                        qh_addr_reg);
+}
+
+static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
+                u8 qh_h_port_reg)
+{
+        musb_writeb(mbase, MUSB_BUSCTL_OFFSET(epnum, MUSB_TXHUBPORT),
+                        qh_h_port_reg);
+}
+
+#else /* CONFIG_BLACKFIN */
+
+#define USB_BASE                USB_FADDR
+#define USB_OFFSET(reg)         (reg - USB_BASE)
+
+/*
+ * Common USB registers
+ */
+#define MUSB_FADDR              USB_OFFSET(USB_FADDR)   /* 8-bit */
+#define MUSB_POWER              USB_OFFSET(USB_POWER)   /* 8-bit */
+#define MUSB_INTRTX             USB_OFFSET(USB_INTRTX)  /* 16-bit */
+#define MUSB_INTRRX             USB_OFFSET(USB_INTRRX)
+#define MUSB_INTRTXE            USB_OFFSET(USB_INTRTXE)
+#define MUSB_INTRRXE            USB_OFFSET(USB_INTRRXE)
+#define MUSB_INTRUSB            USB_OFFSET(USB_INTRUSB) /* 8 bit */
+#define MUSB_INTRUSBE           USB_OFFSET(USB_INTRUSBE)/* 8 bit */
+#define MUSB_FRAME              USB_OFFSET(USB_FRAME)
+#define MUSB_INDEX              USB_OFFSET(USB_INDEX)   /* 8 bit */
+#define MUSB_TESTMODE           USB_OFFSET(USB_TESTMODE)/* 8 bit */
+
+/* Get offset for a given FIFO from musb->mregs */
+#define MUSB_FIFO_OFFSET(epnum) \
+        (USB_OFFSET(USB_EP0_FIFO) + ((epnum) * 8))
+
+/*
+ * Additional Control Registers
+ */
+
+#define MUSB_DEVCTL             USB_OFFSET(USB_OTG_DEV_CTL)     /* 8 bit */
+
+#define MUSB_LINKINFO           USB_OFFSET(USB_LINKINFO)/* 8 bit */
+#define MUSB_VPLEN              USB_OFFSET(USB_VPLEN)   /* 8 bit */
+#define MUSB_HS_EOF1            USB_OFFSET(USB_HS_EOF1) /* 8 bit */
+#define MUSB_FS_EOF1            USB_OFFSET(USB_FS_EOF1) /* 8 bit */
+#define MUSB_LS_EOF1            USB_OFFSET(USB_LS_EOF1) /* 8 bit */
+
+/* Offsets to endpoint registers */
+#define MUSB_TXMAXP             0x00
+#define MUSB_TXCSR              0x04
+#define MUSB_CSR0               MUSB_TXCSR      /* Re-used for EP0 */
+#define MUSB_RXMAXP             0x08
+#define MUSB_RXCSR              0x0C
+#define MUSB_RXCOUNT            0x10
+#define MUSB_COUNT0             MUSB_RXCOUNT    /* Re-used for EP0 */
+#define MUSB_TXTYPE             0x14
+#define MUSB_TYPE0              MUSB_TXTYPE     /* Re-used for EP0 */
+#define MUSB_TXINTERVAL         0x18
+#define MUSB_NAKLIMIT0          MUSB_TXINTERVAL /* Re-used for EP0 */
+#define MUSB_RXTYPE             0x1C
+#define MUSB_RXINTERVAL         0x20
+#define MUSB_TXCOUNT            0x28
+
+/* Offsets to endpoint registers in indexed model (using INDEX register) */
+#define MUSB_INDEXED_OFFSET(_epnum, _offset)    \
+        (0x40 + (_offset))
+
+/* Offsets to endpoint registers in flat models */
+#define MUSB_FLAT_OFFSET(_epnum, _offset)       \
+        (USB_OFFSET(USB_EP_NI0_TXMAXP) + (0x40 * (_epnum)) + (_offset))
+
+/* Not implemented - HW has seperate Tx/Rx FIFO */
+#define MUSB_TXCSR_MODE                 0x0000
+
+/*
+ * Dummy stub for clk framework, it will be removed
+ * until Blackfin supports clk framework
+ */
+#define clk_get(dev, id)        NULL
+#define clk_put(clock)          do {} while (0)
+#define clk_enable(clock)       do {} while (0)
+#define clk_disable(clock)      do {} while (0)
+
+static inline void musb_write_txfifosz(void __iomem *mbase, u8 c_size)
+{
+}
+
+static inline void musb_write_txfifoadd(void __iomem *mbase, u16 c_off)
+{
+}
+
+static inline void musb_write_rxfifosz(void __iomem *mbase, u8 c_size)
+{
+}
+
+static inline void  musb_write_rxfifoadd(void __iomem *mbase, u16 c_off)
+{
+}
+
+static inline u8 musb_read_configdata(void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline u16 musb_read_hwvers(void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline u16 musb_read_target_reg_base(u8 i, void __iomem *mbase)
+{
+        return 0;
+}
+
+static inline void musb_write_rxfunaddr(void __iomem *ep_target_regs,
+                u8 qh_addr_req)
+{
+}
+
+static inline void musb_write_rxhubaddr(void __iomem *ep_target_regs,
+                u8 qh_h_addr_reg)
+{
+}
+
+static inline void musb_write_rxhubport(void __iomem *ep_target_regs,
+                u8 qh_h_port_reg)
+{
+}
+
+static inline void  musb_write_txfunaddr(void __iomem *mbase, u8 epnum,
+                u8 qh_addr_reg)
+{
+}
+
+static inline void  musb_write_txhubaddr(void __iomem *mbase, u8 epnum,
+                u8 qh_addr_reg)
+{
+}
+
+static inline void  musb_write_txhubport(void __iomem *mbase, u8 epnum,
+                u8 qh_h_port_reg)
+{
+}
+
+#endif /* CONFIG_BLACKFIN */
+
 #endif  /* __MUSB_REGS_H__ */
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index 8c734ef2c1ed..8662e9e159c3 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -34,58 +34,7 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include "musb_core.h"
-
-#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
-#include "omap2430.h"
-#endif
-
-#define MUSB_HSDMA_BASE         0x200
-#define MUSB_HSDMA_INTR         (MUSB_HSDMA_BASE + 0)
-#define MUSB_HSDMA_CONTROL              0x4
-#define MUSB_HSDMA_ADDRESS              0x8
-#define MUSB_HSDMA_COUNT                0xc
-
-#define MUSB_HSDMA_CHANNEL_OFFSET(_bchannel, _offset)           \
-                (MUSB_HSDMA_BASE + (_bchannel << 4) + _offset)
-
-/* control register (16-bit): */
-#define MUSB_HSDMA_ENABLE_SHIFT         0
-#define MUSB_HSDMA_TRANSMIT_SHIFT               1
-#define MUSB_HSDMA_MODE1_SHIFT          2
-#define MUSB_HSDMA_IRQENABLE_SHIFT              3
-#define MUSB_HSDMA_ENDPOINT_SHIFT               4
-#define MUSB_HSDMA_BUSERROR_SHIFT               8
-#define MUSB_HSDMA_BURSTMODE_SHIFT              9
-#define MUSB_HSDMA_BURSTMODE            (3 << MUSB_HSDMA_BURSTMODE_SHIFT)
-#define MUSB_HSDMA_BURSTMODE_UNSPEC     0
-#define MUSB_HSDMA_BURSTMODE_INCR4      1
-#define MUSB_HSDMA_BURSTMODE_INCR8      2
-#define MUSB_HSDMA_BURSTMODE_INCR16     3
-
-#define MUSB_HSDMA_CHANNELS             8
-
-struct musb_dma_controller;
-
-struct musb_dma_channel {
-        struct dma_channel              channel;
-        struct musb_dma_controller      *controller;
-        u32                             start_addr;
-        u32                             len;
-        u16                             max_packet_sz;
-        u8                              idx;
-        u8                              epnum;
-        u8                              transmit;
-};
-
-struct musb_dma_controller {
-        struct dma_controller           controller;
-        struct musb_dma_channel         channel[MUSB_HSDMA_CHANNELS];
-        void                            *private_data;
-        void __iomem                    *base;
-        u8                              channel_count;
-        u8                              used_channels;
-        u8                              irq;
-};
+#include "musbhsdma.h"
 
 static int dma_controller_start(struct dma_controller *c)
 {
@@ -203,12 +152,8 @@ static void configure_channel(struct dma_channel *channel,
                                 : 0);
 
         /* address/count */
-        musb_writel(mbase,
-                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDRESS),
-                dma_addr);
-        musb_writel(mbase,
-                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT),
-                len);
+        musb_write_hsdma_addr(mbase, bchannel, dma_addr);
+        musb_write_hsdma_count(mbase, bchannel, len);
 
         /* control (this should start things) */
         musb_writew(mbase,
@@ -279,13 +224,8 @@ static int dma_channel_abort(struct dma_channel *channel)
                 musb_writew(mbase,
                         MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_CONTROL),
                         0);
-                musb_writel(mbase,
-                        MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDRESS),
-                        0);
-                musb_writel(mbase,
-                        MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT),
-                        0);
-
+                musb_write_hsdma_addr(mbase, bchannel, 0);
+                musb_write_hsdma_count(mbase, bchannel, 0);
                 channel->status = MUSB_DMA_STATUS_FREE;
         }
 
@@ -333,10 +273,8 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                         } else {
                                 u8 devctl;
 
-                                addr = musb_readl(mbase,
-                                                MUSB_HSDMA_CHANNEL_OFFSET(
-                                                        bchannel,
-                                                        MUSB_HSDMA_ADDRESS));
+                                addr = musb_read_hsdma_addr(mbase,
+                                                bchannel);
                                 channel->actual_len = addr
                                         - musb_channel->start_addr;
 
@@ -375,6 +313,12 @@ static irqreturn_t dma_controller_irq(int irq, void *private_data)
                         }
                 }
         }
+
+#ifdef CONFIG_BLACKFIN
+        /* Clear DMA interrup flags */
+        musb_writeb(mbase, MUSB_HSDMA_INTR, int_hsdma);
+#endif
+
         retval = IRQ_HANDLED;
 done:
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -424,7 +368,7 @@ dma_controller_create(struct musb *musb, void __iomem *base)
         controller->controller.channel_abort = dma_channel_abort;
 
         if (request_irq(irq, dma_controller_irq, IRQF_DISABLED,
-                        musb->controller->bus_id, &controller->controller)) {
+                        dev_name(musb->controller), &controller->controller)) {
                 dev_err(dev, "request_irq %d failed!\n", irq);
                 dma_controller_destroy(&controller->controller);
 
diff --git a/drivers/usb/musb/musbhsdma.h b/drivers/usb/musb/musbhsdma.h
new file mode 100644
index 000000000000..1299d92dc83f
--- /dev/null
+++ b/drivers/usb/musb/musbhsdma.h
@@ -0,0 +1,149 @@
+/*
+ * MUSB OTG driver - support for Mentor's DMA controller
+ *
+ * Copyright 2005 Mentor Graphics Corporation
+ * Copyright (C) 2005-2007 by Texas Instruments
+ *
+ * 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.
+ *
+ * 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
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+ * NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
+#include "omap2430.h"
+#endif
+
+#ifndef CONFIG_BLACKFIN
+
+#define MUSB_HSDMA_BASE         0x200
+#define MUSB_HSDMA_INTR         (MUSB_HSDMA_BASE + 0)
+#define MUSB_HSDMA_CONTROL              0x4
+#define MUSB_HSDMA_ADDRESS              0x8
+#define MUSB_HSDMA_COUNT                0xc
+
+#define MUSB_HSDMA_CHANNEL_OFFSET(_bchannel, _offset)           \
+                (MUSB_HSDMA_BASE + (_bchannel << 4) + _offset)
+
+#define musb_read_hsdma_addr(mbase, bchannel)   \
+        musb_readl(mbase,       \
+                   MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDRESS))
+
+#define musb_write_hsdma_addr(mbase, bchannel, addr) \
+        musb_writel(mbase, \
+                    MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDRESS), \
+                    addr)
+
+#define musb_write_hsdma_count(mbase, bchannel, len) \
+        musb_writel(mbase, \
+                    MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT), \
+                    len)
+#else
+
+#define MUSB_HSDMA_BASE         0x400
+#define MUSB_HSDMA_INTR         (MUSB_HSDMA_BASE + 0)
+#define MUSB_HSDMA_CONTROL              0x04
+#define MUSB_HSDMA_ADDR_LOW             0x08
+#define MUSB_HSDMA_ADDR_HIGH            0x0C
+#define MUSB_HSDMA_COUNT_LOW            0x10
+#define MUSB_HSDMA_COUNT_HIGH           0x14
+
+#define MUSB_HSDMA_CHANNEL_OFFSET(_bchannel, _offset)           \
+                (MUSB_HSDMA_BASE + (_bchannel * 0x20) + _offset)
+
+static inline u32 musb_read_hsdma_addr(void __iomem *mbase, u8 bchannel)
+{
+        u32 addr = musb_readw(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_HIGH));
+
+        addr = addr << 16;
+
+        addr |= musb_readw(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_LOW));
+
+        return addr;
+}
+
+static inline void musb_write_hsdma_addr(void __iomem *mbase,
+                                u8 bchannel, dma_addr_t dma_addr)
+{
+        musb_writew(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_LOW),
+                ((u16)((u32) dma_addr & 0xFFFF)));
+        musb_writew(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_ADDR_HIGH),
+                ((u16)(((u32) dma_addr >> 16) & 0xFFFF)));
+}
+
+static inline void musb_write_hsdma_count(void __iomem *mbase,
+                                u8 bchannel, u32 len)
+{
+        musb_writew(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_LOW),
+                ((u16)((u32) len & 0xFFFF)));
+        musb_writew(mbase,
+                MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_COUNT_HIGH),
+                ((u16)(((u32) len >> 16) & 0xFFFF)));
+}
+
+#endif /* CONFIG_BLACKFIN */
+
+/* control register (16-bit): */
+#define MUSB_HSDMA_ENABLE_SHIFT         0
+#define MUSB_HSDMA_TRANSMIT_SHIFT       1
+#define MUSB_HSDMA_MODE1_SHIFT          2
+#define MUSB_HSDMA_IRQENABLE_SHIFT      3
+#define MUSB_HSDMA_ENDPOINT_SHIFT       4
+#define MUSB_HSDMA_BUSERROR_SHIFT       8
+#define MUSB_HSDMA_BURSTMODE_SHIFT      9
+#define MUSB_HSDMA_BURSTMODE            (3 << MUSB_HSDMA_BURSTMODE_SHIFT)
+#define MUSB_HSDMA_BURSTMODE_UNSPEC     0
+#define MUSB_HSDMA_BURSTMODE_INCR4      1
+#define MUSB_HSDMA_BURSTMODE_INCR8      2
+#define MUSB_HSDMA_BURSTMODE_INCR16     3
+
+#define MUSB_HSDMA_CHANNELS             8
+
+struct musb_dma_controller;
+
+struct musb_dma_channel {
+        struct dma_channel              channel;
+        struct musb_dma_controller      *controller;
+        u32                             start_addr;
+        u32                             len;
+        u16                             max_packet_sz;
+        u8                              idx;
+        u8                              epnum;
+        u8                              transmit;
+};
+
+struct musb_dma_controller {
+        struct dma_controller           controller;
+        struct musb_dma_channel         channel[MUSB_HSDMA_CHANNELS];
+        void                            *private_data;
+        void __iomem                    *base;
+        u8                              channel_count;
+        u8                              used_channels;
+        u8                              irq;
+};
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index ce6c162920f7..901dffdf23b1 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -58,10 +58,10 @@ static void musb_do_idle(unsigned long _musb)
 #endif
         u8      devctl;
 
-        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
-
         spin_lock_irqsave(&musb->lock, flags);
 
+        devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
+
         switch (musb->xceiv.state) {
         case OTG_STATE_A_WAIT_BCON:
                 devctl &= ~MUSB_DEVCTL_SESSION;
@@ -196,7 +196,7 @@ static int omap_set_power(struct otg_transceiver *x, unsigned mA)
 
 static int musb_platform_resume(struct musb *musb);
 
-void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
 {
         u8      devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
 
@@ -204,15 +204,24 @@ void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
 
         switch (musb_mode) {
+#ifdef CONFIG_USB_MUSB_HDRC_HCD
         case MUSB_HOST:
                 otg_set_host(&musb->xceiv, musb->xceiv.host);
                 break;
+#endif
+#ifdef CONFIG_USB_GADGET_MUSB_HDRC
         case MUSB_PERIPHERAL:
                 otg_set_peripheral(&musb->xceiv, musb->xceiv.gadget);
                 break;
+#endif
+#ifdef CONFIG_USB_MUSB_OTG
         case MUSB_OTG:
                 break;
+#endif
+        default:
+                return -EINVAL;
         }
+        return 0;
 }
 
 int __init musb_platform_init(struct musb *musb)
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index ee8fca92a4ac..9e20fd070d71 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -598,7 +598,7 @@ static void tusb_source_power(struct musb *musb, int is_on)
  * and peripheral modes in non-OTG configurations by reconfiguring hardware
  * and then setting musb->board_mode. For now, only support OTG mode.
  */
-void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
+int musb_platform_set_mode(struct musb *musb, u8 musb_mode)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, phy_otg_ctrl, phy_otg_ena, dev_conf;
@@ -641,7 +641,8 @@ void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
 #endif
 
         default:
-                DBG(2, "Trying to set unknown mode %i\n", musb_mode);
+                DBG(2, "Trying to set mode %i\n", musb_mode);
+                return -EINVAL;
         }
 
         musb_writel(tbase, TUSB_PHY_OTG_CTRL,
@@ -655,6 +656,8 @@ void musb_platform_set_mode(struct musb *musb, u8 musb_mode)
                 !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS))
                         INFO("Cannot be peripheral with mini-A cable "
                         "otg_stat: %08x\n", otg_stat);
+
+        return 0;
 }
 
 static inline unsigned long
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
new file mode 100644
index 000000000000..8e8dbdb9b39b
--- /dev/null
+++ b/drivers/usb/otg/Kconfig
@@ -0,0 +1,54 @@
+#
+# USB OTG infrastructure may be needed for peripheral-only, host-only,
+# or OTG-capable configurations when OTG transceivers or controllers
+# are used.
+#
+
+comment "OTG and related infrastructure"
+
+if USB || USB_GADGET
+
+config USB_OTG_UTILS
+        bool
+        help
+          Select this to make sure the build includes objects from
+          the OTG infrastructure directory.
+
+#
+# USB Transceiver Drivers
+#
+config USB_GPIO_VBUS
+        tristate "GPIO based peripheral-only VBUS sensing 'transceiver'"
+        depends on GENERIC_GPIO
+        select USB_OTG_UTILS
+        help
+          Provides simple GPIO VBUS sensing for controllers with an
+          internal transceiver via the otg_transceiver interface, and
+          optionally control of a D+ pullup GPIO as well as a VBUS
+          current limit regulator.
+
+config ISP1301_OMAP
+        tristate "Philips ISP1301 with OMAP OTG"
+        depends on I2C && ARCH_OMAP_OTG
+        select USB_OTG_UTILS
+        help
+          If you say yes here you get support for the Philips ISP1301
+          USB-On-The-Go transceiver working with the OMAP OTG controller.
+          The ISP1301 is a full speed USB  transceiver which is used in
+          products including H2, H3, and H4 development boards for Texas
+          Instruments OMAP processors.
+
+          This driver can also be built as a module.  If so, the module
+          will be called isp1301_omap.
+
+config TWL4030_USB
+        tristate "TWL4030 USB Transceiver Driver"
+        depends on TWL4030_CORE
+        select USB_OTG_UTILS
+        help
+          Enable this to support the USB OTG transceiver on TWL4030
+          family chips (including the TWL5030 and TPS659x0 devices).
+          This transceiver supports high and full speed devices plus,
+          in host mode, low speed.
+
+endif # USB || OTG
diff --git a/drivers/usb/otg/Makefile b/drivers/usb/otg/Makefile
new file mode 100644
index 000000000000..d73c7cf5e2f7
--- /dev/null
+++ b/drivers/usb/otg/Makefile
@@ -0,0 +1,15 @@
+#
+# OTG infrastructure and transceiver drivers
+#
+
+# infrastructure
+obj-$(CONFIG_USB_OTG_UTILS)     += otg.o
+
+# transceiver drivers
+obj-$(CONFIG_USB_GPIO_VBUS)     += gpio_vbus.o
+obj-$(CONFIG_ISP1301_OMAP)      += isp1301_omap.o
+obj-$(CONFIG_TWL4030_USB)       += twl4030-usb.o
+
+ccflags-$(CONFIG_USB_DEBUG)     += -DDEBUG
+ccflags-$(CONFIG_USB_GADGET_DEBUG) += -DDEBUG
+
diff --git a/drivers/usb/otg/gpio_vbus.c b/drivers/usb/otg/gpio_vbus.c
new file mode 100644
index 000000000000..63a6036f04be
--- /dev/null
+++ b/drivers/usb/otg/gpio_vbus.c
@@ -0,0 +1,335 @@
+/*
+ * gpio-vbus.c - simple GPIO VBUS sensing driver for B peripheral devices
+ *
+ * Copyright (c) 2008 Philipp Zabel <philipp.zabel@gmail.com>
+ *
+ * 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/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/usb.h>
+
+#include <linux/regulator/consumer.h>
+
+#include <linux/usb/gadget.h>
+#include <linux/usb/gpio_vbus.h>
+#include <linux/usb/otg.h>
+
+
+/*
+ * A simple GPIO VBUS sensing driver for B peripheral only devices
+ * with internal transceivers. It can control a D+ pullup GPIO and
+ * a regulator to limit the current drawn from VBUS.
+ *
+ * Needs to be loaded before the UDC driver that will use it.
+ */
+struct gpio_vbus_data {
+        struct otg_transceiver otg;
+        struct device          *dev;
+        struct regulator       *vbus_draw;
+        int                     vbus_draw_enabled;
+        unsigned                mA;
+};
+
+
+/*
+ * This driver relies on "both edges" triggering.  VBUS has 100 msec to
+ * stabilize, so the peripheral controller driver may need to cope with
+ * some bouncing due to current surges (e.g. charging local capacitance)
+ * and contact chatter.
+ *
+ * REVISIT in desperate straits, toggling between rising and falling
+ * edges might be workable.
+ */
+#define VBUS_IRQ_FLAGS \
+        ( IRQF_SAMPLE_RANDOM | IRQF_SHARED \
+        | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING )
+
+
+/* interface to regulator framework */
+static void set_vbus_draw(struct gpio_vbus_data *gpio_vbus, unsigned mA)
+{
+        struct regulator *vbus_draw = gpio_vbus->vbus_draw;
+        int enabled;
+
+        if (!vbus_draw)
+                return;
+
+        enabled = gpio_vbus->vbus_draw_enabled;
+        if (mA) {
+                regulator_set_current_limit(vbus_draw, 0, 1000 * mA);
+                if (!enabled) {
+                        regulator_enable(vbus_draw);
+                        gpio_vbus->vbus_draw_enabled = 1;
+                }
+        } else {
+                if (enabled) {
+                        regulator_disable(vbus_draw);
+                        gpio_vbus->vbus_draw_enabled = 0;
+                }
+        }
+        gpio_vbus->mA = mA;
+}
+
+/* VBUS change IRQ handler */
+static irqreturn_t gpio_vbus_irq(int irq, void *data)
+{
+        struct platform_device *pdev = data;
+        struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
+        struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
+        int gpio, vbus;
+
+        vbus = gpio_get_value(pdata->gpio_vbus);
+        if (pdata->gpio_vbus_inverted)
+                vbus = !vbus;
+
+        dev_dbg(&pdev->dev, "VBUS %s (gadget: %s)\n",
+                vbus ? "supplied" : "inactive",
+                gpio_vbus->otg.gadget ? gpio_vbus->otg.gadget->name : "none");
+
+        if (!gpio_vbus->otg.gadget)
+                return IRQ_HANDLED;
+
+        /* Peripheral controllers which manage the pullup themselves won't have
+         * gpio_pullup configured here.  If it's configured here, we'll do what
+         * isp1301_omap::b_peripheral() does and enable the pullup here... although
+         * that may complicate usb_gadget_{,dis}connect() support.
+         */
+        gpio = pdata->gpio_pullup;
+        if (vbus) {
+                gpio_vbus->otg.state = OTG_STATE_B_PERIPHERAL;
+                usb_gadget_vbus_connect(gpio_vbus->otg.gadget);
+
+                /* drawing a "unit load" is *always* OK, except for OTG */
+                set_vbus_draw(gpio_vbus, 100);
+
+                /* optionally enable D+ pullup */
+                if (gpio_is_valid(gpio))
+                        gpio_set_value(gpio, !pdata->gpio_pullup_inverted);
+        } else {
+                /* optionally disable D+ pullup */
+                if (gpio_is_valid(gpio))
+                        gpio_set_value(gpio, pdata->gpio_pullup_inverted);
+
+                set_vbus_draw(gpio_vbus, 0);
+
+                usb_gadget_vbus_disconnect(gpio_vbus->otg.gadget);
+                gpio_vbus->otg.state = OTG_STATE_B_IDLE;
+        }
+
+        return IRQ_HANDLED;
+}
+
+/* OTG transceiver interface */
+
+/* bind/unbind the peripheral controller */
+static int gpio_vbus_set_peripheral(struct otg_transceiver *otg,
+                                struct usb_gadget *gadget)
+{
+        struct gpio_vbus_data *gpio_vbus;
+        struct gpio_vbus_mach_info *pdata;
+        struct platform_device *pdev;
+        int gpio, irq;
+
+        gpio_vbus = container_of(otg, struct gpio_vbus_data, otg);
+        pdev = to_platform_device(gpio_vbus->dev);
+        pdata = gpio_vbus->dev->platform_data;
+        irq = gpio_to_irq(pdata->gpio_vbus);
+        gpio = pdata->gpio_pullup;
+
+        if (!gadget) {
+                dev_dbg(&pdev->dev, "unregistering gadget '%s'\n",
+                        otg->gadget->name);
+
+                /* optionally disable D+ pullup */
+                if (gpio_is_valid(gpio))
+                        gpio_set_value(gpio, pdata->gpio_pullup_inverted);
+
+                set_vbus_draw(gpio_vbus, 0);
+
+                usb_gadget_vbus_disconnect(otg->gadget);
+                otg->state = OTG_STATE_UNDEFINED;
+
+                otg->gadget = NULL;
+                return 0;
+        }
+
+        otg->gadget = gadget;
+        dev_dbg(&pdev->dev, "registered gadget '%s'\n", gadget->name);
+
+        /* initialize connection state */
+        gpio_vbus_irq(irq, pdev);
+        return 0;
+}
+
+/* effective for B devices, ignored for A-peripheral */
+static int gpio_vbus_set_power(struct otg_transceiver *otg, unsigned mA)
+{
+        struct gpio_vbus_data *gpio_vbus;
+
+        gpio_vbus = container_of(otg, struct gpio_vbus_data, otg);
+
+        if (otg->state == OTG_STATE_B_PERIPHERAL)
+                set_vbus_draw(gpio_vbus, mA);
+        return 0;
+}
+
+/* for non-OTG B devices: set/clear transceiver suspend mode */
+static int gpio_vbus_set_suspend(struct otg_transceiver *otg, int suspend)
+{
+        struct gpio_vbus_data *gpio_vbus;
+
+        gpio_vbus = container_of(otg, struct gpio_vbus_data, otg);
+
+        /* draw max 0 mA from vbus in suspend mode; or the previously
+         * recorded amount of current if not suspended
+         *
+         * NOTE: high powered configs (mA > 100) may draw up to 2.5 mA
+         * if they're wake-enabled ... we don't handle that yet.
+         */
+        return gpio_vbus_set_power(otg, suspend ? 0 : gpio_vbus->mA);
+}
+
+/* platform driver interface */
+
+static int __init gpio_vbus_probe(struct platform_device *pdev)
+{
+        struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
+        struct gpio_vbus_data *gpio_vbus;
+        struct resource *res;
+        int err, gpio, irq;
+
+        if (!pdata || !gpio_is_valid(pdata->gpio_vbus))
+                return -EINVAL;
+        gpio = pdata->gpio_vbus;
+
+        gpio_vbus = kzalloc(sizeof(struct gpio_vbus_data), GFP_KERNEL);
+        if (!gpio_vbus)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, gpio_vbus);
+        gpio_vbus->dev = &pdev->dev;
+        gpio_vbus->otg.label = "gpio-vbus";
+        gpio_vbus->otg.state = OTG_STATE_UNDEFINED;
+        gpio_vbus->otg.set_peripheral = gpio_vbus_set_peripheral;
+        gpio_vbus->otg.set_power = gpio_vbus_set_power;
+        gpio_vbus->otg.set_suspend = gpio_vbus_set_suspend;
+
+        err = gpio_request(gpio, "vbus_detect");
+        if (err) {
+                dev_err(&pdev->dev, "can't request vbus gpio %d, err: %d\n",
+                        gpio, err);
+                goto err_gpio;
+        }
+        gpio_direction_input(gpio);
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (res) {
+                irq = res->start;
+                res->flags &= IRQF_TRIGGER_MASK;
+                res->flags |= IRQF_SAMPLE_RANDOM | IRQF_SHARED;
+        } else
+                irq = gpio_to_irq(gpio);
+
+        /* if data line pullup is in use, initialize it to "not pulling up" */
+        gpio = pdata->gpio_pullup;
+        if (gpio_is_valid(gpio)) {
+                err = gpio_request(gpio, "udc_pullup");
+                if (err) {
+                        dev_err(&pdev->dev,
+                                "can't request pullup gpio %d, err: %d\n",
+                                gpio, err);
+                        gpio_free(pdata->gpio_vbus);
+                        goto err_gpio;
+                }
+                gpio_direction_output(gpio, pdata->gpio_pullup_inverted);
+        }
+
+        err = request_irq(irq, gpio_vbus_irq, VBUS_IRQ_FLAGS,
+                "vbus_detect", pdev);
+        if (err) {
+                dev_err(&pdev->dev, "can't request irq %i, err: %d\n",
+                        irq, err);
+                goto err_irq;
+        }
+
+        /* only active when a gadget is registered */
+        err = otg_set_transceiver(&gpio_vbus->otg);
+        if (err) {
+                dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
+                        err);
+                goto err_otg;
+        }
+
+        gpio_vbus->vbus_draw = regulator_get(&pdev->dev, "vbus_draw");
+        if (IS_ERR(gpio_vbus->vbus_draw)) {
+                dev_dbg(&pdev->dev, "can't get vbus_draw regulator, err: %ld\n",
+                        PTR_ERR(gpio_vbus->vbus_draw));
+                gpio_vbus->vbus_draw = NULL;
+        }
+
+        return 0;
+err_otg:
+        free_irq(irq, &pdev->dev);
+err_irq:
+        if (gpio_is_valid(pdata->gpio_pullup))
+                gpio_free(pdata->gpio_pullup);
+        gpio_free(pdata->gpio_vbus);
+err_gpio:
+        platform_set_drvdata(pdev, NULL);
+        kfree(gpio_vbus);
+        return err;
+}
+
+static int __exit gpio_vbus_remove(struct platform_device *pdev)
+{
+        struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
+        struct gpio_vbus_mach_info *pdata = pdev->dev.platform_data;
+        int gpio = pdata->gpio_vbus;
+
+        regulator_put(gpio_vbus->vbus_draw);
+
+        otg_set_transceiver(NULL);
+
+        free_irq(gpio_to_irq(gpio), &pdev->dev);
+        if (gpio_is_valid(pdata->gpio_pullup))
+                gpio_free(pdata->gpio_pullup);
+        gpio_free(gpio);
+        platform_set_drvdata(pdev, NULL);
+        kfree(gpio_vbus);
+
+        return 0;
+}
+
+/* NOTE:  the gpio-vbus device may *NOT* be hotplugged */
+
+MODULE_ALIAS("platform:gpio-vbus");
+
+static struct platform_driver gpio_vbus_driver = {
+        .driver = {
+                .name  = "gpio-vbus",
+                .owner = THIS_MODULE,
+        },
+        .remove  = __exit_p(gpio_vbus_remove),
+};
+
+static int __init gpio_vbus_init(void)
+{
+        return platform_driver_probe(&gpio_vbus_driver, gpio_vbus_probe);
+}
+module_init(gpio_vbus_init);
+
+static void __exit gpio_vbus_exit(void)
+{
+        platform_driver_unregister(&gpio_vbus_driver);
+}
+module_exit(gpio_vbus_exit);
+
+MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver");
+MODULE_AUTHOR("Philipp Zabel");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
new file mode 100644
index 000000000000..e0d56ef2bcb0
--- /dev/null
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -0,0 +1,1683 @@
+/*
+ * isp1301_omap - ISP 1301 USB transceiver, talking to OMAP OTG controller
+ *
+ * Copyright (C) 2004 Texas Instruments
+ * Copyright (C) 2004 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb.h>
+#include <linux/usb/otg.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+
+#include <asm/irq.h>
+#include <asm/mach-types.h>
+
+#include <mach/usb.h>
+#include <mach/mux.h>
+
+
+#ifndef DEBUG
+#undef  VERBOSE
+#endif
+
+
+#define DRIVER_VERSION  "24 August 2004"
+#define DRIVER_NAME     (isp1301_driver.driver.name)
+
+MODULE_DESCRIPTION("ISP1301 USB OTG Transceiver Driver");
+MODULE_LICENSE("GPL");
+
+struct isp1301 {
+        struct otg_transceiver  otg;
+        struct i2c_client       *client;
+        void                    (*i2c_release)(struct device *dev);
+
+        int                     irq_type;
+
+        u32                     last_otg_ctrl;
+        unsigned                working:1;
+
+        struct timer_list       timer;
+
+        /* use keventd context to change the state for us */
+        struct work_struct      work;
+
+        unsigned long           todo;
+#               define WORK_UPDATE_ISP  0       /* update ISP from OTG */
+#               define WORK_UPDATE_OTG  1       /* update OTG from ISP */
+#               define WORK_HOST_RESUME 4       /* resume host */
+#               define WORK_TIMER       6       /* timer fired */
+#               define WORK_STOP        7       /* don't resubmit */
+};
+
+
+/* bits in OTG_CTRL */
+
+#define OTG_XCEIV_OUTPUTS \
+        (OTG_ASESSVLD|OTG_BSESSEND|OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
+#define OTG_XCEIV_INPUTS \
+        (OTG_PULLDOWN|OTG_PULLUP|OTG_DRV_VBUS|OTG_PD_VBUS|OTG_PU_VBUS|OTG_PU_ID)
+#define OTG_CTRL_BITS \
+        (OTG_A_BUSREQ|OTG_A_SETB_HNPEN|OTG_B_BUSREQ|OTG_B_HNPEN|OTG_BUSDROP)
+        /* and OTG_PULLUP is sometimes written */
+
+#define OTG_CTRL_MASK   (OTG_DRIVER_SEL| \
+        OTG_XCEIV_OUTPUTS|OTG_XCEIV_INPUTS| \
+        OTG_CTRL_BITS)
+
+
+/*-------------------------------------------------------------------------*/
+
+/* board-specific PM hooks */
+
+#if defined(CONFIG_MACH_OMAP_H2) || defined(CONFIG_MACH_OMAP_H3)
+
+#if     defined(CONFIG_TPS65010) || defined(CONFIG_TPS65010_MODULE)
+
+#include <linux/i2c/tps65010.h>
+
+#else
+
+static inline int tps65010_set_vbus_draw(unsigned mA)
+{
+        pr_debug("tps65010: draw %d mA (STUB)\n", mA);
+        return 0;
+}
+
+#endif
+
+static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
+{
+        int status = tps65010_set_vbus_draw(mA);
+        if (status < 0)
+                pr_debug("  VBUS %d mA error %d\n", mA, status);
+}
+
+static void enable_vbus_source(struct isp1301 *isp)
+{
+        /* this board won't supply more than 8mA vbus power.
+         * some boards can switch a 100ma "unit load" (or more).
+         */
+}
+
+
+/* products will deliver OTG messages with LEDs, GUI, etc */
+static inline void notresponding(struct isp1301 *isp)
+{
+        printk(KERN_NOTICE "OTG device not responding.\n");
+}
+
+
+#endif
+
+#if defined(CONFIG_MACH_OMAP_H4)
+
+static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
+{
+        /* H4 controls this by DIP switch S2.4; no soft control.
+         * ON means the charger is always enabled.  Leave it OFF
+         * unless the OTG port is used only in B-peripheral mode.
+         */
+}
+
+static void enable_vbus_source(struct isp1301 *isp)
+{
+        /* this board won't supply more than 8mA vbus power.
+         * some boards can switch a 100ma "unit load" (or more).
+         */
+}
+
+
+/* products will deliver OTG messages with LEDs, GUI, etc */
+static inline void notresponding(struct isp1301 *isp)
+{
+        printk(KERN_NOTICE "OTG device not responding.\n");
+}
+
+
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+static struct i2c_driver isp1301_driver;
+
+/* smbus apis are used for portability */
+
+static inline u8
+isp1301_get_u8(struct isp1301 *isp, u8 reg)
+{
+        return i2c_smbus_read_byte_data(isp->client, reg + 0);
+}
+
+static inline int
+isp1301_get_u16(struct isp1301 *isp, u8 reg)
+{
+        return i2c_smbus_read_word_data(isp->client, reg);
+}
+
+static inline int
+isp1301_set_bits(struct isp1301 *isp, u8 reg, u8 bits)
+{
+        return i2c_smbus_write_byte_data(isp->client, reg + 0, bits);
+}
+
+static inline int
+isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
+{
+        return i2c_smbus_write_byte_data(isp->client, reg + 1, bits);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* identification */
+#define ISP1301_VENDOR_ID               0x00    /* u16 read */
+#define ISP1301_PRODUCT_ID              0x02    /* u16 read */
+#define ISP1301_BCD_DEVICE              0x14    /* u16 read */
+
+#define I2C_VENDOR_ID_PHILIPS           0x04cc
+#define I2C_PRODUCT_ID_PHILIPS_1301     0x1301
+
+/* operational registers */
+#define ISP1301_MODE_CONTROL_1          0x04    /* u8 read, set, +1 clear */
+#       define  MC1_SPEED               (1 << 0)
+#       define  MC1_SUSPEND             (1 << 1)
+#       define  MC1_DAT_SE0             (1 << 2)
+#       define  MC1_TRANSPARENT         (1 << 3)
+#       define  MC1_BDIS_ACON_EN        (1 << 4)
+#       define  MC1_OE_INT_EN           (1 << 5)
+#       define  MC1_UART_EN             (1 << 6)
+#       define  MC1_MASK                0x7f
+#define ISP1301_MODE_CONTROL_2          0x12    /* u8 read, set, +1 clear */
+#       define  MC2_GLOBAL_PWR_DN       (1 << 0)
+#       define  MC2_SPD_SUSP_CTRL       (1 << 1)
+#       define  MC2_BI_DI               (1 << 2)
+#       define  MC2_TRANSP_BDIR0        (1 << 3)
+#       define  MC2_TRANSP_BDIR1        (1 << 4)
+#       define  MC2_AUDIO_EN            (1 << 5)
+#       define  MC2_PSW_EN              (1 << 6)
+#       define  MC2_EN2V7               (1 << 7)
+#define ISP1301_OTG_CONTROL_1           0x06    /* u8 read, set, +1 clear */
+#       define  OTG1_DP_PULLUP          (1 << 0)
+#       define  OTG1_DM_PULLUP          (1 << 1)
+#       define  OTG1_DP_PULLDOWN        (1 << 2)
+#       define  OTG1_DM_PULLDOWN        (1 << 3)
+#       define  OTG1_ID_PULLDOWN        (1 << 4)
+#       define  OTG1_VBUS_DRV           (1 << 5)
+#       define  OTG1_VBUS_DISCHRG       (1 << 6)
+#       define  OTG1_VBUS_CHRG          (1 << 7)
+#define ISP1301_OTG_STATUS              0x10    /* u8 readonly */
+#       define  OTG_B_SESS_END          (1 << 6)
+#       define  OTG_B_SESS_VLD          (1 << 7)
+
+#define ISP1301_INTERRUPT_SOURCE        0x08    /* u8 read */
+#define ISP1301_INTERRUPT_LATCH         0x0A    /* u8 read, set, +1 clear */
+
+#define ISP1301_INTERRUPT_FALLING       0x0C    /* u8 read, set, +1 clear */
+#define ISP1301_INTERRUPT_RISING        0x0E    /* u8 read, set, +1 clear */
+
+/* same bitfields in all interrupt registers */
+#       define  INTR_VBUS_VLD           (1 << 0)
+#       define  INTR_SESS_VLD           (1 << 1)
+#       define  INTR_DP_HI              (1 << 2)
+#       define  INTR_ID_GND             (1 << 3)
+#       define  INTR_DM_HI              (1 << 4)
+#       define  INTR_ID_FLOAT           (1 << 5)
+#       define  INTR_BDIS_ACON          (1 << 6)
+#       define  INTR_CR_INT             (1 << 7)
+
+/*-------------------------------------------------------------------------*/
+
+static const char *state_string(enum usb_otg_state state)
+{
+        switch (state) {
+        case OTG_STATE_A_IDLE:          return "a_idle";
+        case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
+        case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
+        case OTG_STATE_A_HOST:          return "a_host";
+        case OTG_STATE_A_SUSPEND:       return "a_suspend";
+        case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
+        case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
+        case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
+        case OTG_STATE_B_IDLE:          return "b_idle";
+        case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
+        case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
+        case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
+        case OTG_STATE_B_HOST:          return "b_host";
+        default:                        return "UNDEFINED";
+        }
+}
+
+static inline const char *state_name(struct isp1301 *isp)
+{
+        return state_string(isp->otg.state);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* NOTE:  some of this ISP1301 setup is specific to H2 boards;
+ * not everything is guarded by board-specific checks, or even using
+ * omap_usb_config data to deduce MC1_DAT_SE0 and MC2_BI_DI.
+ *
+ * ALSO:  this currently doesn't use ISP1301 low-power modes
+ * while OTG is running.
+ */
+
+static void power_down(struct isp1301 *isp)
+{
+        isp->otg.state = OTG_STATE_UNDEFINED;
+
+        // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
+        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
+
+        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_ID_PULLDOWN);
+        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
+}
+
+static void power_up(struct isp1301 *isp)
+{
+        // isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
+        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
+
+        /* do this only when cpu is driving transceiver,
+         * so host won't see a low speed device...
+         */
+        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
+}
+
+#define NO_HOST_SUSPEND
+
+static int host_suspend(struct isp1301 *isp)
+{
+#ifdef  NO_HOST_SUSPEND
+        return 0;
+#else
+        struct device   *dev;
+
+        if (!isp->otg.host)
+                return -ENODEV;
+
+        /* Currently ASSUMES only the OTG port matters;
+         * other ports could be active...
+         */
+        dev = isp->otg.host->controller;
+        return dev->driver->suspend(dev, 3, 0);
+#endif
+}
+
+static int host_resume(struct isp1301 *isp)
+{
+#ifdef  NO_HOST_SUSPEND
+        return 0;
+#else
+        struct device   *dev;
+
+        if (!isp->otg.host)
+                return -ENODEV;
+
+        dev = isp->otg.host->controller;
+        return dev->driver->resume(dev, 0);
+#endif
+}
+
+static int gadget_suspend(struct isp1301 *isp)
+{
+        isp->otg.gadget->b_hnp_enable = 0;
+        isp->otg.gadget->a_hnp_support = 0;
+        isp->otg.gadget->a_alt_hnp_support = 0;
+        return usb_gadget_vbus_disconnect(isp->otg.gadget);
+}
+
+/*-------------------------------------------------------------------------*/
+
+#define TIMER_MINUTES   10
+#define TIMER_JIFFIES   (TIMER_MINUTES * 60 * HZ)
+
+/* Almost all our I2C messaging comes from a work queue's task context.
+ * NOTE: guaranteeing certain response times might mean we shouldn't
+ * share keventd's work queue; a realtime task might be safest.
+ */
+static void isp1301_defer_work(struct isp1301 *isp, int work)
+{
+        int status;
+
+        if (isp && !test_and_set_bit(work, &isp->todo)) {
+                (void) get_device(&isp->client->dev);
+                status = schedule_work(&isp->work);
+                if (!status && !isp->working)
+                        dev_vdbg(&isp->client->dev,
+                                "work item %d may be lost\n", work);
+        }
+}
+
+/* called from irq handlers */
+static void a_idle(struct isp1301 *isp, const char *tag)
+{
+        u32 l;
+
+        if (isp->otg.state == OTG_STATE_A_IDLE)
+                return;
+
+        isp->otg.default_a = 1;
+        if (isp->otg.host) {
+                isp->otg.host->is_b_host = 0;
+                host_suspend(isp);
+        }
+        if (isp->otg.gadget) {
+                isp->otg.gadget->is_a_peripheral = 1;
+                gadget_suspend(isp);
+        }
+        isp->otg.state = OTG_STATE_A_IDLE;
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+        isp->last_otg_ctrl = l;
+        pr_debug("  --> %s/%s\n", state_name(isp), tag);
+}
+
+/* called from irq handlers */
+static void b_idle(struct isp1301 *isp, const char *tag)
+{
+        u32 l;
+
+        if (isp->otg.state == OTG_STATE_B_IDLE)
+                return;
+
+        isp->otg.default_a = 0;
+        if (isp->otg.host) {
+                isp->otg.host->is_b_host = 1;
+                host_suspend(isp);
+        }
+        if (isp->otg.gadget) {
+                isp->otg.gadget->is_a_peripheral = 0;
+                gadget_suspend(isp);
+        }
+        isp->otg.state = OTG_STATE_B_IDLE;
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+        isp->last_otg_ctrl = l;
+        pr_debug("  --> %s/%s\n", state_name(isp), tag);
+}
+
+static void
+dump_regs(struct isp1301 *isp, const char *label)
+{
+#ifdef  DEBUG
+        u8      ctrl = isp1301_get_u8(isp, ISP1301_OTG_CONTROL_1);
+        u8      status = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
+        u8      src = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
+
+        pr_debug("otg: %06x, %s %s, otg/%02x stat/%02x.%02x\n",
+                omap_readl(OTG_CTRL), label, state_name(isp),
+                ctrl, status, src);
+        /* mode control and irq enables don't change much */
+#endif
+}
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef  CONFIG_USB_OTG
+
+/*
+ * The OMAP OTG controller handles most of the OTG state transitions.
+ *
+ * We translate isp1301 outputs (mostly voltage comparator status) into
+ * OTG inputs; OTG outputs (mostly pullup/pulldown controls) and HNP state
+ * flags into isp1301 inputs ... and infer state transitions.
+ */
+
+#ifdef  VERBOSE
+
+static void check_state(struct isp1301 *isp, const char *tag)
+{
+        enum usb_otg_state      state = OTG_STATE_UNDEFINED;
+        u8                      fsm = omap_readw(OTG_TEST) & 0x0ff;
+        unsigned                extra = 0;
+
+        switch (fsm) {
+
+        /* default-b */
+        case 0x0:
+                state = OTG_STATE_B_IDLE;
+                break;
+        case 0x3:
+        case 0x7:
+                extra = 1;
+        case 0x1:
+                state = OTG_STATE_B_PERIPHERAL;
+                break;
+        case 0x11:
+                state = OTG_STATE_B_SRP_INIT;
+                break;
+
+        /* extra dual-role default-b states */
+        case 0x12:
+        case 0x13:
+        case 0x16:
+                extra = 1;
+        case 0x17:
+                state = OTG_STATE_B_WAIT_ACON;
+                break;
+        case 0x34:
+                state = OTG_STATE_B_HOST;
+                break;
+
+        /* default-a */
+        case 0x36:
+                state = OTG_STATE_A_IDLE;
+                break;
+        case 0x3c:
+                state = OTG_STATE_A_WAIT_VFALL;
+                break;
+        case 0x7d:
+                state = OTG_STATE_A_VBUS_ERR;
+                break;
+        case 0x9e:
+        case 0x9f:
+                extra = 1;
+        case 0x89:
+                state = OTG_STATE_A_PERIPHERAL;
+                break;
+        case 0xb7:
+                state = OTG_STATE_A_WAIT_VRISE;
+                break;
+        case 0xb8:
+                state = OTG_STATE_A_WAIT_BCON;
+                break;
+        case 0xb9:
+                state = OTG_STATE_A_HOST;
+                break;
+        case 0xba:
+                state = OTG_STATE_A_SUSPEND;
+                break;
+        default:
+                break;
+        }
+        if (isp->otg.state == state && !extra)
+                return;
+        pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
+                state_string(state), fsm, state_name(isp),
+                omap_readl(OTG_CTRL));
+}
+
+#else
+
+static inline void check_state(struct isp1301 *isp, const char *tag) { }
+
+#endif
+
+/* outputs from ISP1301_INTERRUPT_SOURCE */
+static void update_otg1(struct isp1301 *isp, u8 int_src)
+{
+        u32     otg_ctrl;
+
+        otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        otg_ctrl &= ~OTG_XCEIV_INPUTS;
+        otg_ctrl &= ~(OTG_ID|OTG_ASESSVLD|OTG_VBUSVLD);
+
+        if (int_src & INTR_SESS_VLD)
+                otg_ctrl |= OTG_ASESSVLD;
+        else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
+                a_idle(isp, "vfall");
+                otg_ctrl &= ~OTG_CTRL_BITS;
+        }
+        if (int_src & INTR_VBUS_VLD)
+                otg_ctrl |= OTG_VBUSVLD;
+        if (int_src & INTR_ID_GND) {            /* default-A */
+                if (isp->otg.state == OTG_STATE_B_IDLE
+                                || isp->otg.state == OTG_STATE_UNDEFINED) {
+                        a_idle(isp, "init");
+                        return;
+                }
+        } else {                                /* default-B */
+                otg_ctrl |= OTG_ID;
+                if (isp->otg.state == OTG_STATE_A_IDLE
+                                || isp->otg.state == OTG_STATE_UNDEFINED) {
+                        b_idle(isp, "init");
+                        return;
+                }
+        }
+        omap_writel(otg_ctrl, OTG_CTRL);
+}
+
+/* outputs from ISP1301_OTG_STATUS */
+static void update_otg2(struct isp1301 *isp, u8 otg_status)
+{
+        u32     otg_ctrl;
+
+        otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        otg_ctrl &= ~OTG_XCEIV_INPUTS;
+        otg_ctrl &= ~(OTG_BSESSVLD | OTG_BSESSEND);
+        if (otg_status & OTG_B_SESS_VLD)
+                otg_ctrl |= OTG_BSESSVLD;
+        else if (otg_status & OTG_B_SESS_END)
+                otg_ctrl |= OTG_BSESSEND;
+        omap_writel(otg_ctrl, OTG_CTRL);
+}
+
+/* inputs going to ISP1301 */
+static void otg_update_isp(struct isp1301 *isp)
+{
+        u32     otg_ctrl, otg_change;
+        u8      set = OTG1_DM_PULLDOWN, clr = OTG1_DM_PULLUP;
+
+        otg_ctrl = omap_readl(OTG_CTRL);
+        otg_change = otg_ctrl ^ isp->last_otg_ctrl;
+        isp->last_otg_ctrl = otg_ctrl;
+        otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
+
+        switch (isp->otg.state) {
+        case OTG_STATE_B_IDLE:
+        case OTG_STATE_B_PERIPHERAL:
+        case OTG_STATE_B_SRP_INIT:
+                if (!(otg_ctrl & OTG_PULLUP)) {
+                        // if (otg_ctrl & OTG_B_HNPEN) {
+                        if (isp->otg.gadget->b_hnp_enable) {
+                                isp->otg.state = OTG_STATE_B_WAIT_ACON;
+                                pr_debug("  --> b_wait_acon\n");
+                        }
+                        goto pulldown;
+                }
+pullup:
+                set |= OTG1_DP_PULLUP;
+                clr |= OTG1_DP_PULLDOWN;
+                break;
+        case OTG_STATE_A_SUSPEND:
+        case OTG_STATE_A_PERIPHERAL:
+                if (otg_ctrl & OTG_PULLUP)
+                        goto pullup;
+                /* FALLTHROUGH */
+        // case OTG_STATE_B_WAIT_ACON:
+        default:
+pulldown:
+                set |= OTG1_DP_PULLDOWN;
+                clr |= OTG1_DP_PULLUP;
+                break;
+        }
+
+#       define toggle(OTG,ISP) do { \
+                if (otg_ctrl & OTG) set |= ISP; \
+                else clr |= ISP; \
+                } while (0)
+
+        if (!(isp->otg.host))
+                otg_ctrl &= ~OTG_DRV_VBUS;
+
+        switch (isp->otg.state) {
+        case OTG_STATE_A_SUSPEND:
+                if (otg_ctrl & OTG_DRV_VBUS) {
+                        set |= OTG1_VBUS_DRV;
+                        break;
+                }
+                /* HNP failed for some reason (A_AIDL_BDIS timeout) */
+                notresponding(isp);
+
+                /* FALLTHROUGH */
+        case OTG_STATE_A_VBUS_ERR:
+                isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+                pr_debug("  --> a_wait_vfall\n");
+                /* FALLTHROUGH */
+        case OTG_STATE_A_WAIT_VFALL:
+                /* FIXME usbcore thinks port power is still on ... */
+                clr |= OTG1_VBUS_DRV;
+                break;
+        case OTG_STATE_A_IDLE:
+                if (otg_ctrl & OTG_DRV_VBUS) {
+                        isp->otg.state = OTG_STATE_A_WAIT_VRISE;
+                        pr_debug("  --> a_wait_vrise\n");
+                }
+                /* FALLTHROUGH */
+        default:
+                toggle(OTG_DRV_VBUS, OTG1_VBUS_DRV);
+        }
+
+        toggle(OTG_PU_VBUS, OTG1_VBUS_CHRG);
+        toggle(OTG_PD_VBUS, OTG1_VBUS_DISCHRG);
+
+#       undef toggle
+
+        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, set);
+        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, clr);
+
+        /* HNP switch to host or peripheral; and SRP */
+        if (otg_change & OTG_PULLUP) {
+                u32 l;
+
+                switch (isp->otg.state) {
+                case OTG_STATE_B_IDLE:
+                        if (clr & OTG1_DP_PULLUP)
+                                break;
+                        isp->otg.state = OTG_STATE_B_PERIPHERAL;
+                        pr_debug("  --> b_peripheral\n");
+                        break;
+                case OTG_STATE_A_SUSPEND:
+                        if (clr & OTG1_DP_PULLUP)
+                                break;
+                        isp->otg.state = OTG_STATE_A_PERIPHERAL;
+                        pr_debug("  --> a_peripheral\n");
+                        break;
+                default:
+                        break;
+                }
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_PULLUP;
+                omap_writel(l, OTG_CTRL);
+        }
+
+        check_state(isp, __func__);
+        dump_regs(isp, "otg->isp1301");
+}
+
+static irqreturn_t omap_otg_irq(int irq, void *_isp)
+{
+        u16             otg_irq = omap_readw(OTG_IRQ_SRC);
+        u32             otg_ctrl;
+        int             ret = IRQ_NONE;
+        struct isp1301  *isp = _isp;
+
+        /* update ISP1301 transciever from OTG controller */
+        if (otg_irq & OPRT_CHG) {
+                omap_writew(OPRT_CHG, OTG_IRQ_SRC);
+                isp1301_defer_work(isp, WORK_UPDATE_ISP);
+                ret = IRQ_HANDLED;
+
+        /* SRP to become b_peripheral failed */
+        } else if (otg_irq & B_SRP_TMROUT) {
+                pr_debug("otg: B_SRP_TIMEOUT, %06x\n", omap_readl(OTG_CTRL));
+                notresponding(isp);
+
+                /* gadget drivers that care should monitor all kinds of
+                 * remote wakeup (SRP, normal) using their own timer
+                 * to give "check cable and A-device" messages.
+                 */
+                if (isp->otg.state == OTG_STATE_B_SRP_INIT)
+                        b_idle(isp, "srp_timeout");
+
+                omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+        /* HNP to become b_host failed */
+        } else if (otg_irq & B_HNP_FAIL) {
+                pr_debug("otg: %s B_HNP_FAIL, %06x\n",
+                                state_name(isp), omap_readl(OTG_CTRL));
+                notresponding(isp);
+
+                otg_ctrl = omap_readl(OTG_CTRL);
+                otg_ctrl |= OTG_BUSDROP;
+                otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
+                omap_writel(otg_ctrl, OTG_CTRL);
+
+                /* subset of b_peripheral()... */
+                isp->otg.state = OTG_STATE_B_PERIPHERAL;
+                pr_debug("  --> b_peripheral\n");
+
+                omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+        /* detect SRP from B-device ... */
+        } else if (otg_irq & A_SRP_DETECT) {
+                pr_debug("otg: %s SRP_DETECT, %06x\n",
+                                state_name(isp), omap_readl(OTG_CTRL));
+
+                isp1301_defer_work(isp, WORK_UPDATE_OTG);
+                switch (isp->otg.state) {
+                case OTG_STATE_A_IDLE:
+                        if (!isp->otg.host)
+                                break;
+                        isp1301_defer_work(isp, WORK_HOST_RESUME);
+                        otg_ctrl = omap_readl(OTG_CTRL);
+                        otg_ctrl |= OTG_A_BUSREQ;
+                        otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
+                                        & ~OTG_XCEIV_INPUTS
+                                        & OTG_CTRL_MASK;
+                        omap_writel(otg_ctrl, OTG_CTRL);
+                        break;
+                default:
+                        break;
+                }
+
+                omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+        /* timer expired:  T(a_wait_bcon) and maybe T(a_wait_vrise)
+         * we don't track them separately
+         */
+        } else if (otg_irq & A_REQ_TMROUT) {
+                otg_ctrl = omap_readl(OTG_CTRL);
+                pr_info("otg: BCON_TMOUT from %s, %06x\n",
+                                state_name(isp), otg_ctrl);
+                notresponding(isp);
+
+                otg_ctrl |= OTG_BUSDROP;
+                otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
+                omap_writel(otg_ctrl, OTG_CTRL);
+                isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+
+                omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+        /* A-supplied voltage fell too low; overcurrent */
+        } else if (otg_irq & A_VBUS_ERR) {
+                otg_ctrl = omap_readl(OTG_CTRL);
+                printk(KERN_ERR "otg: %s, VBUS_ERR %04x ctrl %06x\n",
+                        state_name(isp), otg_irq, otg_ctrl);
+
+                otg_ctrl |= OTG_BUSDROP;
+                otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
+                omap_writel(otg_ctrl, OTG_CTRL);
+                isp->otg.state = OTG_STATE_A_VBUS_ERR;
+
+                omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+        /* switch driver; the transciever code activates it,
+         * ungating the udc clock or resuming OHCI.
+         */
+        } else if (otg_irq & DRIVER_SWITCH) {
+                int     kick = 0;
+
+                otg_ctrl = omap_readl(OTG_CTRL);
+                printk(KERN_NOTICE "otg: %s, SWITCH to %s, ctrl %06x\n",
+                                state_name(isp),
+                                (otg_ctrl & OTG_DRIVER_SEL)
+                                        ? "gadget" : "host",
+                                otg_ctrl);
+                isp1301_defer_work(isp, WORK_UPDATE_ISP);
+
+                /* role is peripheral */
+                if (otg_ctrl & OTG_DRIVER_SEL) {
+                        switch (isp->otg.state) {
+                        case OTG_STATE_A_IDLE:
+                                b_idle(isp, __func__);
+                                break;
+                        default:
+                                break;
+                        }
+                        isp1301_defer_work(isp, WORK_UPDATE_ISP);
+
+                /* role is host */
+                } else {
+                        if (!(otg_ctrl & OTG_ID)) {
+                                otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
+                                omap_writel(otg_ctrl | OTG_A_BUSREQ, OTG_CTRL);
+                        }
+
+                        if (isp->otg.host) {
+                                switch (isp->otg.state) {
+                                case OTG_STATE_B_WAIT_ACON:
+                                        isp->otg.state = OTG_STATE_B_HOST;
+                                        pr_debug("  --> b_host\n");
+                                        kick = 1;
+                                        break;
+                                case OTG_STATE_A_WAIT_BCON:
+                                        isp->otg.state = OTG_STATE_A_HOST;
+                                        pr_debug("  --> a_host\n");
+                                        break;
+                                case OTG_STATE_A_PERIPHERAL:
+                                        isp->otg.state = OTG_STATE_A_WAIT_BCON;
+                                        pr_debug("  --> a_wait_bcon\n");
+                                        break;
+                                default:
+                                        break;
+                                }
+                                isp1301_defer_work(isp, WORK_HOST_RESUME);
+                        }
+                }
+
+                omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
+                ret = IRQ_HANDLED;
+
+                if (kick)
+                        usb_bus_start_enum(isp->otg.host,
+                                                isp->otg.host->otg_port);
+        }
+
+        check_state(isp, __func__);
+        return ret;
+}
+
+static struct platform_device *otg_dev;
+
+static int otg_init(struct isp1301 *isp)
+{
+        u32 l;
+
+        if (!otg_dev)
+                return -ENODEV;
+
+        dump_regs(isp, __func__);
+        /* some of these values are board-specific... */
+        l = omap_readl(OTG_SYSCON_2);
+        l |= OTG_EN
+                /* for B-device: */
+                | SRP_GPDATA            /* 9msec Bdev D+ pulse */
+                | SRP_GPDVBUS           /* discharge after VBUS pulse */
+                // | (3 << 24)          /* 2msec VBUS pulse */
+                /* for A-device: */
+                | (0 << 20)             /* 200ms nominal A_WAIT_VRISE timer */
+                | SRP_DPW               /* detect 167+ns SRP pulses */
+                | SRP_DATA | SRP_VBUS   /* accept both kinds of SRP pulse */
+                ;
+        omap_writel(l, OTG_SYSCON_2);
+
+        update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
+        update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
+
+        check_state(isp, __func__);
+        pr_debug("otg: %s, %s %06x\n",
+                        state_name(isp), __func__, omap_readl(OTG_CTRL));
+
+        omap_writew(DRIVER_SWITCH | OPRT_CHG
+                        | B_SRP_TMROUT | B_HNP_FAIL
+                        | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT, OTG_IRQ_EN);
+
+        l = omap_readl(OTG_SYSCON_2);
+        l |= OTG_EN;
+        omap_writel(l, OTG_SYSCON_2);
+
+        return 0;
+}
+
+static int otg_probe(struct platform_device *dev)
+{
+        // struct omap_usb_config *config = dev->platform_data;
+
+        otg_dev = dev;
+        return 0;
+}
+
+static int otg_remove(struct platform_device *dev)
+{
+        otg_dev = NULL;
+        return 0;
+}
+
+static struct platform_driver omap_otg_driver = {
+        .probe          = otg_probe,
+        .remove         = otg_remove,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "omap_otg",
+        },
+};
+
+static int otg_bind(struct isp1301 *isp)
+{
+        int     status;
+
+        if (otg_dev)
+                return -EBUSY;
+
+        status = platform_driver_register(&omap_otg_driver);
+        if (status < 0)
+                return status;
+
+        if (otg_dev)
+                status = request_irq(otg_dev->resource[1].start, omap_otg_irq,
+                                IRQF_DISABLED, DRIVER_NAME, isp);
+        else
+                status = -ENODEV;
+
+        if (status < 0)
+                platform_driver_unregister(&omap_otg_driver);
+        return status;
+}
+
+static void otg_unbind(struct isp1301 *isp)
+{
+        if (!otg_dev)
+                return;
+        free_irq(otg_dev->resource[1].start, isp);
+}
+
+#else
+
+/* OTG controller isn't clocked */
+
+#endif  /* CONFIG_USB_OTG */
+
+/*-------------------------------------------------------------------------*/
+
+static void b_peripheral(struct isp1301 *isp)
+{
+        u32 l;
+
+        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+        omap_writel(l, OTG_CTRL);
+
+        usb_gadget_vbus_connect(isp->otg.gadget);
+
+#ifdef  CONFIG_USB_OTG
+        enable_vbus_draw(isp, 8);
+        otg_update_isp(isp);
+#else
+        enable_vbus_draw(isp, 100);
+        /* UDC driver just set OTG_BSESSVLD */
+        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
+        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
+        isp->otg.state = OTG_STATE_B_PERIPHERAL;
+        pr_debug("  --> b_peripheral\n");
+        dump_regs(isp, "2periph");
+#endif
+}
+
+static void isp_update_otg(struct isp1301 *isp, u8 stat)
+{
+        u8                      isp_stat, isp_bstat;
+        enum usb_otg_state      state = isp->otg.state;
+
+        if (stat & INTR_BDIS_ACON)
+                pr_debug("OTG:  BDIS_ACON, %s\n", state_name(isp));
+
+        /* start certain state transitions right away */
+        isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
+        if (isp_stat & INTR_ID_GND) {
+                if (isp->otg.default_a) {
+                        switch (state) {
+                        case OTG_STATE_B_IDLE:
+                                a_idle(isp, "idle");
+                                /* FALLTHROUGH */
+                        case OTG_STATE_A_IDLE:
+                                enable_vbus_source(isp);
+                                /* FALLTHROUGH */
+                        case OTG_STATE_A_WAIT_VRISE:
+                                /* we skip over OTG_STATE_A_WAIT_BCON, since
+                                 * the HC will transition to A_HOST (or
+                                 * A_SUSPEND!) without our noticing except
+                                 * when HNP is used.
+                                 */
+                                if (isp_stat & INTR_VBUS_VLD)
+                                        isp->otg.state = OTG_STATE_A_HOST;
+                                break;
+                        case OTG_STATE_A_WAIT_VFALL:
+                                if (!(isp_stat & INTR_SESS_VLD))
+                                        a_idle(isp, "vfell");
+                                break;
+                        default:
+                                if (!(isp_stat & INTR_VBUS_VLD))
+                                        isp->otg.state = OTG_STATE_A_VBUS_ERR;
+                                break;
+                        }
+                        isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
+                } else {
+                        switch (state) {
+                        case OTG_STATE_B_PERIPHERAL:
+                        case OTG_STATE_B_HOST:
+                        case OTG_STATE_B_WAIT_ACON:
+                                usb_gadget_vbus_disconnect(isp->otg.gadget);
+                                break;
+                        default:
+                                break;
+                        }
+                        if (state != OTG_STATE_A_IDLE)
+                                a_idle(isp, "id");
+                        if (isp->otg.host && state == OTG_STATE_A_IDLE)
+                                isp1301_defer_work(isp, WORK_HOST_RESUME);
+                        isp_bstat = 0;
+                }
+        } else {
+                u32 l;
+
+                /* if user unplugged mini-A end of cable,
+                 * don't bypass A_WAIT_VFALL.
+                 */
+                if (isp->otg.default_a) {
+                        switch (state) {
+                        default:
+                                isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+                                break;
+                        case OTG_STATE_A_WAIT_VFALL:
+                                state = OTG_STATE_A_IDLE;
+                                /* khubd may take a while to notice and
+                                 * handle this disconnect, so don't go
+                                 * to B_IDLE quite yet.
+                                 */
+                                break;
+                        case OTG_STATE_A_IDLE:
+                                host_suspend(isp);
+                                isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
+                                                MC1_BDIS_ACON_EN);
+                                isp->otg.state = OTG_STATE_B_IDLE;
+                                l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+                                l &= ~OTG_CTRL_BITS;
+                                omap_writel(l, OTG_CTRL);
+                                break;
+                        case OTG_STATE_B_IDLE:
+                                break;
+                        }
+                }
+                isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
+
+                switch (isp->otg.state) {
+                case OTG_STATE_B_PERIPHERAL:
+                case OTG_STATE_B_WAIT_ACON:
+                case OTG_STATE_B_HOST:
+                        if (likely(isp_bstat & OTG_B_SESS_VLD))
+                                break;
+                        enable_vbus_draw(isp, 0);
+#ifndef CONFIG_USB_OTG
+                        /* UDC driver will clear OTG_BSESSVLD */
+                        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
+                                                OTG1_DP_PULLDOWN);
+                        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
+                                                OTG1_DP_PULLUP);
+                        dump_regs(isp, __func__);
+#endif
+                        /* FALLTHROUGH */
+                case OTG_STATE_B_SRP_INIT:
+                        b_idle(isp, __func__);
+                        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
+                        omap_writel(l, OTG_CTRL);
+                        /* FALLTHROUGH */
+                case OTG_STATE_B_IDLE:
+                        if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
+#ifdef  CONFIG_USB_OTG
+                                update_otg1(isp, isp_stat);
+                                update_otg2(isp, isp_bstat);
+#endif
+                                b_peripheral(isp);
+                        } else if (!(isp_stat & (INTR_VBUS_VLD|INTR_SESS_VLD)))
+                                isp_bstat |= OTG_B_SESS_END;
+                        break;
+                case OTG_STATE_A_WAIT_VFALL:
+                        break;
+                default:
+                        pr_debug("otg: unsupported b-device %s\n",
+                                state_name(isp));
+                        break;
+                }
+        }
+
+        if (state != isp->otg.state)
+                pr_debug("  isp, %s -> %s\n",
+                                state_string(state), state_name(isp));
+
+#ifdef  CONFIG_USB_OTG
+        /* update the OTG controller state to match the isp1301; may
+         * trigger OPRT_CHG irqs for changes going to the isp1301.
+         */
+        update_otg1(isp, isp_stat);
+        update_otg2(isp, isp_bstat);
+        check_state(isp, __func__);
+#endif
+
+        dump_regs(isp, "isp1301->otg");
+}
+
+/*-------------------------------------------------------------------------*/
+
+static u8 isp1301_clear_latch(struct isp1301 *isp)
+{
+        u8 latch = isp1301_get_u8(isp, ISP1301_INTERRUPT_LATCH);
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, latch);
+        return latch;
+}
+
+static void
+isp1301_work(struct work_struct *work)
+{
+        struct isp1301  *isp = container_of(work, struct isp1301, work);
+        int             stop;
+
+        /* implicit lock:  we're the only task using this device */
+        isp->working = 1;
+        do {
+                stop = test_bit(WORK_STOP, &isp->todo);
+
+#ifdef  CONFIG_USB_OTG
+                /* transfer state from otg engine to isp1301 */
+                if (test_and_clear_bit(WORK_UPDATE_ISP, &isp->todo)) {
+                        otg_update_isp(isp);
+                        put_device(&isp->client->dev);
+                }
+#endif
+                /* transfer state from isp1301 to otg engine */
+                if (test_and_clear_bit(WORK_UPDATE_OTG, &isp->todo)) {
+                        u8              stat = isp1301_clear_latch(isp);
+
+                        isp_update_otg(isp, stat);
+                        put_device(&isp->client->dev);
+                }
+
+                if (test_and_clear_bit(WORK_HOST_RESUME, &isp->todo)) {
+                        u32     otg_ctrl;
+
+                        /*
+                         * skip A_WAIT_VRISE; hc transitions invisibly
+                         * skip A_WAIT_BCON; same.
+                         */
+                        switch (isp->otg.state) {
+                        case OTG_STATE_A_WAIT_BCON:
+                        case OTG_STATE_A_WAIT_VRISE:
+                                isp->otg.state = OTG_STATE_A_HOST;
+                                pr_debug("  --> a_host\n");
+                                otg_ctrl = omap_readl(OTG_CTRL);
+                                otg_ctrl |= OTG_A_BUSREQ;
+                                otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
+                                                & OTG_CTRL_MASK;
+                                omap_writel(otg_ctrl, OTG_CTRL);
+                                break;
+                        case OTG_STATE_B_WAIT_ACON:
+                                isp->otg.state = OTG_STATE_B_HOST;
+                                pr_debug("  --> b_host (acon)\n");
+                                break;
+                        case OTG_STATE_B_HOST:
+                        case OTG_STATE_B_IDLE:
+                        case OTG_STATE_A_IDLE:
+                                break;
+                        default:
+                                pr_debug("  host resume in %s\n",
+                                                state_name(isp));
+                        }
+                        host_resume(isp);
+                        // mdelay(10);
+                        put_device(&isp->client->dev);
+                }
+
+                if (test_and_clear_bit(WORK_TIMER, &isp->todo)) {
+#ifdef  VERBOSE
+                        dump_regs(isp, "timer");
+                        if (!stop)
+                                mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
+#endif
+                        put_device(&isp->client->dev);
+                }
+
+                if (isp->todo)
+                        dev_vdbg(&isp->client->dev,
+                                "work done, todo = 0x%lx\n",
+                                isp->todo);
+                if (stop) {
+                        dev_dbg(&isp->client->dev, "stop\n");
+                        break;
+                }
+        } while (isp->todo);
+        isp->working = 0;
+}
+
+static irqreturn_t isp1301_irq(int irq, void *isp)
+{
+        isp1301_defer_work(isp, WORK_UPDATE_OTG);
+        return IRQ_HANDLED;
+}
+
+static void isp1301_timer(unsigned long _isp)
+{
+        isp1301_defer_work((void *)_isp, WORK_TIMER);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static void isp1301_release(struct device *dev)
+{
+        struct isp1301  *isp;
+
+        isp = dev_get_drvdata(dev);
+
+        /* FIXME -- not with a "new style" driver, it doesn't!! */
+
+        /* ugly -- i2c hijacks our memory hook to wait_for_completion() */
+        if (isp->i2c_release)
+                isp->i2c_release(dev);
+        kfree (isp);
+}
+
+static struct isp1301 *the_transceiver;
+
+static int __exit isp1301_remove(struct i2c_client *i2c)
+{
+        struct isp1301  *isp;
+
+        isp = i2c_get_clientdata(i2c);
+
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
+        free_irq(i2c->irq, isp);
+#ifdef  CONFIG_USB_OTG
+        otg_unbind(isp);
+#endif
+        if (machine_is_omap_h2())
+                gpio_free(2);
+
+        isp->timer.data = 0;
+        set_bit(WORK_STOP, &isp->todo);
+        del_timer_sync(&isp->timer);
+        flush_scheduled_work();
+
+        put_device(&i2c->dev);
+        the_transceiver = NULL;
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* NOTE:  three modes are possible here, only one of which
+ * will be standards-conformant on any given system:
+ *
+ *  - OTG mode (dual-role), required if there's a Mini-AB connector
+ *  - HOST mode, for when there's one or more A (host) connectors
+ *  - DEVICE mode, for when there's a B/Mini-B (device) connector
+ *
+ * As a rule, you won't have an isp1301 chip unless it's there to
+ * support the OTG mode.  Other modes help testing USB controllers
+ * in isolation from (full) OTG support, or maybe so later board
+ * revisions can help to support those feature.
+ */
+
+#ifdef  CONFIG_USB_OTG
+
+static int isp1301_otg_enable(struct isp1301 *isp)
+{
+        power_up(isp);
+        otg_init(isp);
+
+        /* NOTE:  since we don't change this, this provides
+         * a few more interrupts than are strictly needed.
+         */
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
+                INTR_VBUS_VLD | INTR_SESS_VLD | INTR_ID_GND);
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
+                INTR_VBUS_VLD | INTR_SESS_VLD | INTR_ID_GND);
+
+        dev_info(&isp->client->dev, "ready for dual-role USB ...\n");
+
+        return 0;
+}
+
+#endif
+
+/* add or disable the host device+driver */
+static int
+isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
+{
+        struct isp1301  *isp = container_of(otg, struct isp1301, otg);
+
+        if (!otg || isp != the_transceiver)
+                return -ENODEV;
+
+        if (!host) {
+                omap_writew(0, OTG_IRQ_EN);
+                power_down(isp);
+                isp->otg.host = NULL;
+                return 0;
+        }
+
+#ifdef  CONFIG_USB_OTG
+        isp->otg.host = host;
+        dev_dbg(&isp->client->dev, "registered host\n");
+        host_suspend(isp);
+        if (isp->otg.gadget)
+                return isp1301_otg_enable(isp);
+        return 0;
+
+#elif   !defined(CONFIG_USB_GADGET_OMAP)
+        // FIXME update its refcount
+        isp->otg.host = host;
+
+        power_up(isp);
+
+        if (machine_is_omap_h2())
+                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
+
+        dev_info(&isp->client->dev, "A-Host sessions ok\n");
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
+                INTR_ID_GND);
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
+                INTR_ID_GND);
+
+        /* If this has a Mini-AB connector, this mode is highly
+         * nonstandard ... but can be handy for testing, especially with
+         * the Mini-A end of an OTG cable.  (Or something nonstandard
+         * like MiniB-to-StandardB, maybe built with a gender mender.)
+         */
+        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV);
+
+        dump_regs(isp, __func__);
+
+        return 0;
+
+#else
+        dev_dbg(&isp->client->dev, "host sessions not allowed\n");
+        return -EINVAL;
+#endif
+
+}
+
+static int
+isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
+{
+        struct isp1301  *isp = container_of(otg, struct isp1301, otg);
+#ifndef CONFIG_USB_OTG
+        u32 l;
+#endif
+
+        if (!otg || isp != the_transceiver)
+                return -ENODEV;
+
+        if (!gadget) {
+                omap_writew(0, OTG_IRQ_EN);
+                if (!isp->otg.default_a)
+                        enable_vbus_draw(isp, 0);
+                usb_gadget_vbus_disconnect(isp->otg.gadget);
+                isp->otg.gadget = NULL;
+                power_down(isp);
+                return 0;
+        }
+
+#ifdef  CONFIG_USB_OTG
+        isp->otg.gadget = gadget;
+        dev_dbg(&isp->client->dev, "registered gadget\n");
+        /* gadget driver may be suspended until vbus_connect () */
+        if (isp->otg.host)
+                return isp1301_otg_enable(isp);
+        return 0;
+
+#elif   !defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OHCI_HCD_MODULE)
+        isp->otg.gadget = gadget;
+        // FIXME update its refcount
+
+        l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
+        l &= ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS);
+        l |= OTG_ID;
+        omap_writel(l, OTG_CTRL);
+
+        power_up(isp);
+        isp->otg.state = OTG_STATE_B_IDLE;
+
+        if (machine_is_omap_h2() || machine_is_omap_h3())
+                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
+
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
+                INTR_SESS_VLD);
+        isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
+                INTR_VBUS_VLD);
+        dev_info(&isp->client->dev, "B-Peripheral sessions ok\n");
+        dump_regs(isp, __func__);
+
+        /* If this has a Mini-AB connector, this mode is highly
+         * nonstandard ... but can be handy for testing, so long
+         * as you don't plug a Mini-A cable into the jack.
+         */
+        if (isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE) & INTR_VBUS_VLD)
+                b_peripheral(isp);
+
+        return 0;
+
+#else
+        dev_dbg(&isp->client->dev, "peripheral sessions not allowed\n");
+        return -EINVAL;
+#endif
+}
+
+
+/*-------------------------------------------------------------------------*/
+
+static int
+isp1301_set_power(struct otg_transceiver *dev, unsigned mA)
+{
+        if (!the_transceiver)
+                return -ENODEV;
+        if (dev->state == OTG_STATE_B_PERIPHERAL)
+                enable_vbus_draw(the_transceiver, mA);
+        return 0;
+}
+
+static int
+isp1301_start_srp(struct otg_transceiver *dev)
+{
+        struct isp1301  *isp = container_of(dev, struct isp1301, otg);
+        u32             otg_ctrl;
+
+        if (!dev || isp != the_transceiver
+                        || isp->otg.state != OTG_STATE_B_IDLE)
+                return -ENODEV;
+
+        otg_ctrl = omap_readl(OTG_CTRL);
+        if (!(otg_ctrl & OTG_BSESSEND))
+                return -EINVAL;
+
+        otg_ctrl |= OTG_B_BUSREQ;
+        otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK;
+        omap_writel(otg_ctrl, OTG_CTRL);
+        isp->otg.state = OTG_STATE_B_SRP_INIT;
+
+        pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
+                        omap_readl(OTG_CTRL));
+#ifdef  CONFIG_USB_OTG
+        check_state(isp, __func__);
+#endif
+        return 0;
+}
+
+static int
+isp1301_start_hnp(struct otg_transceiver *dev)
+{
+#ifdef  CONFIG_USB_OTG
+        struct isp1301  *isp = container_of(dev, struct isp1301, otg);
+        u32 l;
+
+        if (!dev || isp != the_transceiver)
+                return -ENODEV;
+        if (isp->otg.default_a && (isp->otg.host == NULL
+                        || !isp->otg.host->b_hnp_enable))
+                return -ENOTCONN;
+        if (!isp->otg.default_a && (isp->otg.gadget == NULL
+                        || !isp->otg.gadget->b_hnp_enable))
+                return -ENOTCONN;
+
+        /* We want hardware to manage most HNP protocol timings.
+         * So do this part as early as possible...
+         */
+        switch (isp->otg.state) {
+        case OTG_STATE_B_HOST:
+                isp->otg.state = OTG_STATE_B_PERIPHERAL;
+                /* caller will suspend next */
+                break;
+        case OTG_STATE_A_HOST:
+#if 0
+                /* autoconnect mode avoids irq latency bugs */
+                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
+                                MC1_BDIS_ACON_EN);
+#endif
+                /* caller must suspend then clear A_BUSREQ */
+                usb_gadget_vbus_connect(isp->otg.gadget);
+                l = omap_readl(OTG_CTRL);
+                l |= OTG_A_SETB_HNPEN;
+                omap_writel(l, OTG_CTRL);
+
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                /* initiated by B-Host suspend */
+                break;
+        default:
+                return -EILSEQ;
+        }
+        pr_debug("otg: HNP %s, %06x ...\n",
+                state_name(isp), omap_readl(OTG_CTRL));
+        check_state(isp, __func__);
+        return 0;
+#else
+        /* srp-only */
+        return -EINVAL;
+#endif
+}
+
+/*-------------------------------------------------------------------------*/
+
+static int __init
+isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
+{
+        int                     status;
+        struct isp1301          *isp;
+
+        if (the_transceiver)
+                return 0;
+
+        isp = kzalloc(sizeof *isp, GFP_KERNEL);
+        if (!isp)
+                return 0;
+
+        INIT_WORK(&isp->work, isp1301_work);
+        init_timer(&isp->timer);
+        isp->timer.function = isp1301_timer;
+        isp->timer.data = (unsigned long) isp;
+
+        i2c_set_clientdata(i2c, isp);
+        isp->client = i2c;
+
+        /* verify the chip (shouldn't be necesary) */
+        status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
+        if (status != I2C_VENDOR_ID_PHILIPS) {
+                dev_dbg(&i2c->dev, "not philips id: %d\n", status);
+                goto fail;
+        }
+        status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
+        if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
+                dev_dbg(&i2c->dev, "not isp1301, %d\n", status);
+                goto fail;
+        }
+        isp->i2c_release = i2c->dev.release;
+        i2c->dev.release = isp1301_release;
+
+        /* initial development used chiprev 2.00 */
+        status = i2c_smbus_read_word_data(i2c, ISP1301_BCD_DEVICE);
+        dev_info(&i2c->dev, "chiprev %x.%02x, driver " DRIVER_VERSION "\n",
+                status >> 8, status & 0xff);
+
+        /* make like power-on reset */
+        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
+
+        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
+        isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
+
+        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
+                                OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN);
+        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
+                                ~(OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN));
+
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
+        isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
+
+#ifdef  CONFIG_USB_OTG
+        status = otg_bind(isp);
+        if (status < 0) {
+                dev_dbg(&i2c->dev, "can't bind OTG\n");
+                goto fail;
+        }
+#endif
+
+        if (machine_is_omap_h2()) {
+                /* full speed signaling by default */
+                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
+                        MC1_SPEED);
+                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
+                        MC2_SPD_SUSP_CTRL);
+
+                /* IRQ wired at M14 */
+                omap_cfg_reg(M14_1510_GPIO2);
+                if (gpio_request(2, "isp1301") == 0)
+                        gpio_direction_input(2);
+                isp->irq_type = IRQF_TRIGGER_FALLING;
+        }
+
+        isp->irq_type |= IRQF_SAMPLE_RANDOM;
+        status = request_irq(i2c->irq, isp1301_irq,
+                        isp->irq_type, DRIVER_NAME, isp);
+        if (status < 0) {
+                dev_dbg(&i2c->dev, "can't get IRQ %d, err %d\n",
+                                i2c->irq, status);
+                goto fail;
+        }
+
+        isp->otg.dev = &i2c->dev;
+        isp->otg.label = DRIVER_NAME;
+
+        isp->otg.set_host = isp1301_set_host,
+        isp->otg.set_peripheral = isp1301_set_peripheral,
+        isp->otg.set_power = isp1301_set_power,
+        isp->otg.start_srp = isp1301_start_srp,
+        isp->otg.start_hnp = isp1301_start_hnp,
+
+        enable_vbus_draw(isp, 0);
+        power_down(isp);
+        the_transceiver = isp;
+
+#ifdef  CONFIG_USB_OTG
+        update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
+        update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
+#endif
+
+        dump_regs(isp, __func__);
+
+#ifdef  VERBOSE
+        mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
+        dev_dbg(&i2c->dev, "scheduled timer, %d min\n", TIMER_MINUTES);
+#endif
+
+        status = otg_set_transceiver(&isp->otg);
+        if (status < 0)
+                dev_err(&i2c->dev, "can't register transceiver, %d\n",
+                        status);
+
+        return 0;
+
+fail:
+        kfree(isp);
+        return -ENODEV;
+}
+
+static const struct i2c_device_id isp1301_id[] = {
+        { "isp1301_omap", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, isp1301_id);
+
+static struct i2c_driver isp1301_driver = {
+        .driver = {
+                .name   = "isp1301_omap",
+        },
+        .probe          = isp1301_probe,
+        .remove         = __exit_p(isp1301_remove),
+        .id_table       = isp1301_id,
+};
+
+/*-------------------------------------------------------------------------*/
+
+static int __init isp_init(void)
+{
+        return i2c_add_driver(&isp1301_driver);
+}
+module_init(isp_init);
+
+static void __exit isp_exit(void)
+{
+        if (the_transceiver)
+                otg_set_transceiver(NULL);
+        i2c_del_driver(&isp1301_driver);
+}
+module_exit(isp_exit);
+
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
new file mode 100644
index 000000000000..ff318fae7d4d
--- /dev/null
+++ b/drivers/usb/otg/otg.c
@@ -0,0 +1,65 @@
+/*
+ * otg.c -- USB OTG utility code
+ *
+ * Copyright (C) 2004 Texas Instruments
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+
+#include <linux/usb/otg.h>
+
+static struct otg_transceiver *xceiv;
+
+/**
+ * otg_get_transceiver - find the (single) OTG transceiver
+ *
+ * Returns the transceiver driver, after getting a refcount to it; or
+ * null if there is no such transceiver.  The caller is responsible for
+ * calling otg_put_transceiver() to release that count.
+ *
+ * For use by USB host and peripheral drivers.
+ */
+struct otg_transceiver *otg_get_transceiver(void)
+{
+        if (xceiv)
+                get_device(xceiv->dev);
+        return xceiv;
+}
+EXPORT_SYMBOL(otg_get_transceiver);
+
+/**
+ * otg_put_transceiver - release the (single) OTG transceiver
+ * @x: the transceiver returned by otg_get_transceiver()
+ *
+ * Releases a refcount the caller received from otg_get_transceiver().
+ *
+ * For use by USB host and peripheral drivers.
+ */
+void otg_put_transceiver(struct otg_transceiver *x)
+{
+        put_device(x->dev);
+}
+EXPORT_SYMBOL(otg_put_transceiver);
+
+/**
+ * otg_set_transceiver - declare the (single) OTG transceiver
+ * @x: the USB OTG transceiver to be used; or NULL
+ *
+ * This call is exclusively for use by transceiver drivers, which
+ * coordinate the activities of drivers for host and peripheral
+ * controllers, and in some cases for VBUS current regulation.
+ */
+int otg_set_transceiver(struct otg_transceiver *x)
+{
+        if (xceiv && x)
+                return -EBUSY;
+        xceiv = x;
+        return 0;
+}
+EXPORT_SYMBOL(otg_set_transceiver);
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
new file mode 100644
index 000000000000..416e4410be02
--- /dev/null
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -0,0 +1,721 @@
+/*
+ * twl4030_usb - TWL4030 USB transceiver, talking to OMAP OTG controller
+ *
+ * Copyright (C) 2004-2007 Texas Instruments
+ * Copyright (C) 2008 Nokia Corporation
+ * Contact: Felipe Balbi <felipe.balbi@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Current status:
+ *      - HS USB ULPI mode works.
+ *      - 3-pin mode support may be added in future.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/io.h>
+#include <linux/delay.h>
+#include <linux/usb/otg.h>
+#include <linux/i2c/twl4030.h>
+
+
+/* Register defines */
+
+#define VENDOR_ID_LO                    0x00
+#define VENDOR_ID_HI                    0x01
+#define PRODUCT_ID_LO                   0x02
+#define PRODUCT_ID_HI                   0x03
+
+#define FUNC_CTRL                       0x04
+#define FUNC_CTRL_SET                   0x05
+#define FUNC_CTRL_CLR                   0x06
+#define FUNC_CTRL_SUSPENDM              (1 << 6)
+#define FUNC_CTRL_RESET                 (1 << 5)
+#define FUNC_CTRL_OPMODE_MASK           (3 << 3) /* bits 3 and 4 */
+#define FUNC_CTRL_OPMODE_NORMAL         (0 << 3)
+#define FUNC_CTRL_OPMODE_NONDRIVING     (1 << 3)
+#define FUNC_CTRL_OPMODE_DISABLE_BIT_NRZI       (2 << 3)
+#define FUNC_CTRL_TERMSELECT            (1 << 2)
+#define FUNC_CTRL_XCVRSELECT_MASK       (3 << 0) /* bits 0 and 1 */
+#define FUNC_CTRL_XCVRSELECT_HS         (0 << 0)
+#define FUNC_CTRL_XCVRSELECT_FS         (1 << 0)
+#define FUNC_CTRL_XCVRSELECT_LS         (2 << 0)
+#define FUNC_CTRL_XCVRSELECT_FS4LS      (3 << 0)
+
+#define IFC_CTRL                        0x07
+#define IFC_CTRL_SET                    0x08
+#define IFC_CTRL_CLR                    0x09
+#define IFC_CTRL_INTERFACE_PROTECT_DISABLE      (1 << 7)
+#define IFC_CTRL_AUTORESUME             (1 << 4)
+#define IFC_CTRL_CLOCKSUSPENDM          (1 << 3)
+#define IFC_CTRL_CARKITMODE             (1 << 2)
+#define IFC_CTRL_FSLSSERIALMODE_3PIN    (1 << 1)
+
+#define TWL4030_OTG_CTRL                0x0A
+#define TWL4030_OTG_CTRL_SET            0x0B
+#define TWL4030_OTG_CTRL_CLR            0x0C
+#define TWL4030_OTG_CTRL_DRVVBUS        (1 << 5)
+#define TWL4030_OTG_CTRL_CHRGVBUS       (1 << 4)
+#define TWL4030_OTG_CTRL_DISCHRGVBUS    (1 << 3)
+#define TWL4030_OTG_CTRL_DMPULLDOWN     (1 << 2)
+#define TWL4030_OTG_CTRL_DPPULLDOWN     (1 << 1)
+#define TWL4030_OTG_CTRL_IDPULLUP       (1 << 0)
+
+#define USB_INT_EN_RISE                 0x0D
+#define USB_INT_EN_RISE_SET             0x0E
+#define USB_INT_EN_RISE_CLR             0x0F
+#define USB_INT_EN_FALL                 0x10
+#define USB_INT_EN_FALL_SET             0x11
+#define USB_INT_EN_FALL_CLR             0x12
+#define USB_INT_STS                     0x13
+#define USB_INT_LATCH                   0x14
+#define USB_INT_IDGND                   (1 << 4)
+#define USB_INT_SESSEND                 (1 << 3)
+#define USB_INT_SESSVALID               (1 << 2)
+#define USB_INT_VBUSVALID               (1 << 1)
+#define USB_INT_HOSTDISCONNECT          (1 << 0)
+
+#define CARKIT_CTRL                     0x19
+#define CARKIT_CTRL_SET                 0x1A
+#define CARKIT_CTRL_CLR                 0x1B
+#define CARKIT_CTRL_MICEN               (1 << 6)
+#define CARKIT_CTRL_SPKRIGHTEN          (1 << 5)
+#define CARKIT_CTRL_SPKLEFTEN           (1 << 4)
+#define CARKIT_CTRL_RXDEN               (1 << 3)
+#define CARKIT_CTRL_TXDEN               (1 << 2)
+#define CARKIT_CTRL_IDGNDDRV            (1 << 1)
+#define CARKIT_CTRL_CARKITPWR           (1 << 0)
+#define CARKIT_PLS_CTRL                 0x22
+#define CARKIT_PLS_CTRL_SET             0x23
+#define CARKIT_PLS_CTRL_CLR             0x24
+#define CARKIT_PLS_CTRL_SPKRRIGHT_BIASEN        (1 << 3)
+#define CARKIT_PLS_CTRL_SPKRLEFT_BIASEN (1 << 2)
+#define CARKIT_PLS_CTRL_RXPLSEN         (1 << 1)
+#define CARKIT_PLS_CTRL_TXPLSEN         (1 << 0)
+
+#define MCPC_CTRL                       0x30
+#define MCPC_CTRL_SET                   0x31
+#define MCPC_CTRL_CLR                   0x32
+#define MCPC_CTRL_RTSOL                 (1 << 7)
+#define MCPC_CTRL_EXTSWR                (1 << 6)
+#define MCPC_CTRL_EXTSWC                (1 << 5)
+#define MCPC_CTRL_VOICESW               (1 << 4)
+#define MCPC_CTRL_OUT64K                (1 << 3)
+#define MCPC_CTRL_RTSCTSSW              (1 << 2)
+#define MCPC_CTRL_HS_UART               (1 << 0)
+
+#define MCPC_IO_CTRL                    0x33
+#define MCPC_IO_CTRL_SET                0x34
+#define MCPC_IO_CTRL_CLR                0x35
+#define MCPC_IO_CTRL_MICBIASEN          (1 << 5)
+#define MCPC_IO_CTRL_CTS_NPU            (1 << 4)
+#define MCPC_IO_CTRL_RXD_PU             (1 << 3)
+#define MCPC_IO_CTRL_TXDTYP             (1 << 2)
+#define MCPC_IO_CTRL_CTSTYP             (1 << 1)
+#define MCPC_IO_CTRL_RTSTYP             (1 << 0)
+
+#define MCPC_CTRL2                      0x36
+#define MCPC_CTRL2_SET                  0x37
+#define MCPC_CTRL2_CLR                  0x38
+#define MCPC_CTRL2_MCPC_CK_EN           (1 << 0)
+
+#define OTHER_FUNC_CTRL                 0x80
+#define OTHER_FUNC_CTRL_SET             0x81
+#define OTHER_FUNC_CTRL_CLR             0x82
+#define OTHER_FUNC_CTRL_BDIS_ACON_EN    (1 << 4)
+#define OTHER_FUNC_CTRL_FIVEWIRE_MODE   (1 << 2)
+
+#define OTHER_IFC_CTRL                  0x83
+#define OTHER_IFC_CTRL_SET              0x84
+#define OTHER_IFC_CTRL_CLR              0x85
+#define OTHER_IFC_CTRL_OE_INT_EN        (1 << 6)
+#define OTHER_IFC_CTRL_CEA2011_MODE     (1 << 5)
+#define OTHER_IFC_CTRL_FSLSSERIALMODE_4PIN      (1 << 4)
+#define OTHER_IFC_CTRL_HIZ_ULPI_60MHZ_OUT       (1 << 3)
+#define OTHER_IFC_CTRL_HIZ_ULPI         (1 << 2)
+#define OTHER_IFC_CTRL_ALT_INT_REROUTE  (1 << 0)
+
+#define OTHER_INT_EN_RISE               0x86
+#define OTHER_INT_EN_RISE_SET           0x87
+#define OTHER_INT_EN_RISE_CLR           0x88
+#define OTHER_INT_EN_FALL               0x89
+#define OTHER_INT_EN_FALL_SET           0x8A
+#define OTHER_INT_EN_FALL_CLR           0x8B
+#define OTHER_INT_STS                   0x8C
+#define OTHER_INT_LATCH                 0x8D
+#define OTHER_INT_VB_SESS_VLD           (1 << 7)
+#define OTHER_INT_DM_HI                 (1 << 6) /* not valid for "latch" reg */
+#define OTHER_INT_DP_HI                 (1 << 5) /* not valid for "latch" reg */
+#define OTHER_INT_BDIS_ACON             (1 << 3) /* not valid for "fall" regs */
+#define OTHER_INT_MANU                  (1 << 1)
+#define OTHER_INT_ABNORMAL_STRESS       (1 << 0)
+
+#define ID_STATUS                       0x96
+#define ID_RES_FLOAT                    (1 << 4)
+#define ID_RES_440K                     (1 << 3)
+#define ID_RES_200K                     (1 << 2)
+#define ID_RES_102K                     (1 << 1)
+#define ID_RES_GND                      (1 << 0)
+
+#define POWER_CTRL                      0xAC
+#define POWER_CTRL_SET                  0xAD
+#define POWER_CTRL_CLR                  0xAE
+#define POWER_CTRL_OTG_ENAB             (1 << 5)
+
+#define OTHER_IFC_CTRL2                 0xAF
+#define OTHER_IFC_CTRL2_SET             0xB0
+#define OTHER_IFC_CTRL2_CLR             0xB1
+#define OTHER_IFC_CTRL2_ULPI_STP_LOW    (1 << 4)
+#define OTHER_IFC_CTRL2_ULPI_TXEN_POL   (1 << 3)
+#define OTHER_IFC_CTRL2_ULPI_4PIN_2430  (1 << 2)
+#define OTHER_IFC_CTRL2_USB_INT_OUTSEL_MASK     (3 << 0) /* bits 0 and 1 */
+#define OTHER_IFC_CTRL2_USB_INT_OUTSEL_INT1N    (0 << 0)
+#define OTHER_IFC_CTRL2_USB_INT_OUTSEL_INT2N    (1 << 0)
+
+#define REG_CTRL_EN                     0xB2
+#define REG_CTRL_EN_SET                 0xB3
+#define REG_CTRL_EN_CLR                 0xB4
+#define REG_CTRL_ERROR                  0xB5
+#define ULPI_I2C_CONFLICT_INTEN         (1 << 0)
+
+#define OTHER_FUNC_CTRL2                0xB8
+#define OTHER_FUNC_CTRL2_SET            0xB9
+#define OTHER_FUNC_CTRL2_CLR            0xBA
+#define OTHER_FUNC_CTRL2_VBAT_TIMER_EN  (1 << 0)
+
+/* following registers do not have separate _clr and _set registers */
+#define VBUS_DEBOUNCE                   0xC0
+#define ID_DEBOUNCE                     0xC1
+#define VBAT_TIMER                      0xD3
+#define PHY_PWR_CTRL                    0xFD
+#define PHY_PWR_PHYPWD                  (1 << 0)
+#define PHY_CLK_CTRL                    0xFE
+#define PHY_CLK_CTRL_CLOCKGATING_EN     (1 << 2)
+#define PHY_CLK_CTRL_CLK32K_EN          (1 << 1)
+#define REQ_PHY_DPLL_CLK                (1 << 0)
+#define PHY_CLK_CTRL_STS                0xFF
+#define PHY_DPLL_CLK                    (1 << 0)
+
+/* In module TWL4030_MODULE_PM_MASTER */
+#define PROTECT_KEY                     0x0E
+
+/* In module TWL4030_MODULE_PM_RECEIVER */
+#define VUSB_DEDICATED1                 0x7D
+#define VUSB_DEDICATED2                 0x7E
+#define VUSB1V5_DEV_GRP                 0x71
+#define VUSB1V5_TYPE                    0x72
+#define VUSB1V5_REMAP                   0x73
+#define VUSB1V8_DEV_GRP                 0x74
+#define VUSB1V8_TYPE                    0x75
+#define VUSB1V8_REMAP                   0x76
+#define VUSB3V1_DEV_GRP                 0x77
+#define VUSB3V1_TYPE                    0x78
+#define VUSB3V1_REMAP                   0x79
+
+/* In module TWL4030_MODULE_INTBR */
+#define PMBR1                           0x0D
+#define GPIO_USB_4PIN_ULPI_2430C        (3 << 0)
+
+
+
+enum linkstat {
+        USB_LINK_UNKNOWN = 0,
+        USB_LINK_NONE,
+        USB_LINK_VBUS,
+        USB_LINK_ID,
+};
+
+struct twl4030_usb {
+        struct otg_transceiver  otg;
+        struct device           *dev;
+
+        /* for vbus reporting with irqs disabled */
+        spinlock_t              lock;
+
+        /* pin configuration */
+        enum twl4030_usb_mode   usb_mode;
+
+        int                     irq;
+        u8                      linkstat;
+        u8                      asleep;
+        bool                    irq_enabled;
+};
+
+/* internal define on top of container_of */
+#define xceiv_to_twl(x)         container_of((x), struct twl4030_usb, otg);
+
+/*-------------------------------------------------------------------------*/
+
+static int twl4030_i2c_write_u8_verify(struct twl4030_usb *twl,
+                u8 module, u8 data, u8 address)
+{
+        u8 check;
+
+        if ((twl4030_i2c_write_u8(module, data, address) >= 0) &&
+            (twl4030_i2c_read_u8(module, &check, address) >= 0) &&
+                                                (check == data))
+                return 0;
+        dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
+                        1, module, address, check, data);
+
+        /* Failed once: Try again */
+        if ((twl4030_i2c_write_u8(module, data, address) >= 0) &&
+            (twl4030_i2c_read_u8(module, &check, address) >= 0) &&
+                                                (check == data))
+                return 0;
+        dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
+                        2, module, address, check, data);
+
+        /* Failed again: Return error */
+        return -EBUSY;
+}
+
+#define twl4030_usb_write_verify(twl, address, data)    \
+        twl4030_i2c_write_u8_verify(twl, TWL4030_MODULE_USB, (data), (address))
+
+static inline int twl4030_usb_write(struct twl4030_usb *twl,
+                u8 address, u8 data)
+{
+        int ret = 0;
+
+        ret = twl4030_i2c_write_u8(TWL4030_MODULE_USB, data, address);
+        if (ret < 0)
+                dev_dbg(twl->dev,
+                        "TWL4030:USB:Write[0x%x] Error %d\n", address, ret);
+        return ret;
+}
+
+static inline int twl4030_readb(struct twl4030_usb *twl, u8 module, u8 address)
+{
+        u8 data;
+        int ret = 0;
+
+        ret = twl4030_i2c_read_u8(module, &data, address);
+        if (ret >= 0)
+                ret = data;
+        else
+                dev_dbg(twl->dev,
+                        "TWL4030:readb[0x%x,0x%x] Error %d\n",
+                                        module, address, ret);
+
+        return ret;
+}
+
+static inline int twl4030_usb_read(struct twl4030_usb *twl, u8 address)
+{
+        return twl4030_readb(twl, TWL4030_MODULE_USB, address);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline int
+twl4030_usb_set_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
+{
+        return twl4030_usb_write(twl, reg + 1, bits);
+}
+
+static inline int
+twl4030_usb_clear_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
+{
+        return twl4030_usb_write(twl, reg + 2, bits);
+}
+
+/*-------------------------------------------------------------------------*/
+
+static enum linkstat twl4030_usb_linkstat(struct twl4030_usb *twl)
+{
+        int     status;
+        int     linkstat = USB_LINK_UNKNOWN;
+
+        /* STS_HW_CONDITIONS */
+        status = twl4030_readb(twl, TWL4030_MODULE_PM_MASTER, 0x0f);
+        if (status < 0)
+                dev_err(twl->dev, "USB link status err %d\n", status);
+        else if (status & BIT(7))
+                linkstat = USB_LINK_VBUS;
+        else if (status & BIT(2))
+                linkstat = USB_LINK_ID;
+        else
+                linkstat = USB_LINK_NONE;
+
+        dev_dbg(twl->dev, "HW_CONDITIONS 0x%02x/%d; link %d\n",
+                        status, status, linkstat);
+
+        /* REVISIT this assumes host and peripheral controllers
+         * are registered, and that both are active...
+         */
+
+        spin_lock_irq(&twl->lock);
+        twl->linkstat = linkstat;
+        if (linkstat == USB_LINK_ID) {
+                twl->otg.default_a = true;
+                twl->otg.state = OTG_STATE_A_IDLE;
+        } else {
+                twl->otg.default_a = false;
+                twl->otg.state = OTG_STATE_B_IDLE;
+        }
+        spin_unlock_irq(&twl->lock);
+
+        return linkstat;
+}
+
+static void twl4030_usb_set_mode(struct twl4030_usb *twl, int mode)
+{
+        twl->usb_mode = mode;
+
+        switch (mode) {
+        case T2_USB_MODE_ULPI:
+                twl4030_usb_clear_bits(twl, IFC_CTRL, IFC_CTRL_CARKITMODE);
+                twl4030_usb_set_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
+                twl4030_usb_clear_bits(twl, FUNC_CTRL,
+                                        FUNC_CTRL_XCVRSELECT_MASK |
+                                        FUNC_CTRL_OPMODE_MASK);
+                break;
+        case -1:
+                /* FIXME: power on defaults */
+                break;
+        default:
+                dev_err(twl->dev, "unsupported T2 transceiver mode %d\n",
+                                mode);
+                break;
+        };
+}
+
+static void twl4030_i2c_access(struct twl4030_usb *twl, int on)
+{
+        unsigned long timeout;
+        int val = twl4030_usb_read(twl, PHY_CLK_CTRL);
+
+        if (val >= 0) {
+                if (on) {
+                        /* enable DPLL to access PHY registers over I2C */
+                        val |= REQ_PHY_DPLL_CLK;
+                        WARN_ON(twl4030_usb_write_verify(twl, PHY_CLK_CTRL,
+                                                (u8)val) < 0);
+
+                        timeout = jiffies + HZ;
+                        while (!(twl4030_usb_read(twl, PHY_CLK_CTRL_STS) &
+                                                        PHY_DPLL_CLK)
+                                && time_before(jiffies, timeout))
+                                        udelay(10);
+                        if (!(twl4030_usb_read(twl, PHY_CLK_CTRL_STS) &
+                                                        PHY_DPLL_CLK))
+                                dev_err(twl->dev, "Timeout setting T2 HSUSB "
+                                                "PHY DPLL clock\n");
+                } else {
+                        /* let ULPI control the DPLL clock */
+                        val &= ~REQ_PHY_DPLL_CLK;
+                        WARN_ON(twl4030_usb_write_verify(twl, PHY_CLK_CTRL,
+                                                (u8)val) < 0);
+                }
+        }
+}
+
+static void twl4030_phy_power(struct twl4030_usb *twl, int on)
+{
+        u8 pwr;
+
+        pwr = twl4030_usb_read(twl, PHY_PWR_CTRL);
+        if (on) {
+                pwr &= ~PHY_PWR_PHYPWD;
+                WARN_ON(twl4030_usb_write_verify(twl, PHY_PWR_CTRL, pwr) < 0);
+                twl4030_usb_write(twl, PHY_CLK_CTRL,
+                                  twl4030_usb_read(twl, PHY_CLK_CTRL) |
+                                        (PHY_CLK_CTRL_CLOCKGATING_EN |
+                                                PHY_CLK_CTRL_CLK32K_EN));
+        } else  {
+                pwr |= PHY_PWR_PHYPWD;
+                WARN_ON(twl4030_usb_write_verify(twl, PHY_PWR_CTRL, pwr) < 0);
+        }
+}
+
+static void twl4030_phy_suspend(struct twl4030_usb *twl, int controller_off)
+{
+        if (twl->asleep)
+                return;
+
+        twl4030_phy_power(twl, 0);
+        twl->asleep = 1;
+}
+
+static void twl4030_phy_resume(struct twl4030_usb *twl)
+{
+        if (!twl->asleep)
+                return;
+
+        twl4030_phy_power(twl, 1);
+        twl4030_i2c_access(twl, 1);
+        twl4030_usb_set_mode(twl, twl->usb_mode);
+        if (twl->usb_mode == T2_USB_MODE_ULPI)
+                twl4030_i2c_access(twl, 0);
+        twl->asleep = 0;
+}
+
+static void twl4030_usb_ldo_init(struct twl4030_usb *twl)
+{
+        /* Enable writing to power configuration registers */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY);
+
+        /* put VUSB3V1 LDO in active state */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);
+
+        /* input to VUSB3V1 LDO is from VBAT, not VBUS */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
+
+        /* turn on 3.1V regulator */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB3V1_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
+
+        /* turn on 1.5V regulator */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB1V5_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
+
+        /* turn on 1.8V regulator */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x20, VUSB1V8_DEV_GRP);
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
+
+        /* disable access to power configuration registers */
+        twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
+}
+
+static ssize_t twl4030_usb_vbus_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct twl4030_usb *twl = dev_get_drvdata(dev);
+        unsigned long flags;
+        int ret = -EINVAL;
+
+        spin_lock_irqsave(&twl->lock, flags);
+        ret = sprintf(buf, "%s\n",
+                        (twl->linkstat == USB_LINK_VBUS) ? "on" : "off");
+        spin_unlock_irqrestore(&twl->lock, flags);
+
+        return ret;
+}
+static DEVICE_ATTR(vbus, 0444, twl4030_usb_vbus_show, NULL);
+
+static irqreturn_t twl4030_usb_irq(int irq, void *_twl)
+{
+        struct twl4030_usb *twl = _twl;
+        int status;
+
+#ifdef CONFIG_LOCKDEP
+        /* WORKAROUND for lockdep forcing IRQF_DISABLED on us, which
+         * we don't want and can't tolerate.  Although it might be
+         * friendlier not to borrow this thread context...
+         */
+        local_irq_enable();
+#endif
+
+        status = twl4030_usb_linkstat(twl);
+        if (status != USB_LINK_UNKNOWN) {
+
+                /* FIXME add a set_power() method so that B-devices can
+                 * configure the charger appropriately.  It's not always
+                 * correct to consume VBUS power, and how much current to
+                 * consume is a function of the USB configuration chosen
+                 * by the host.
+                 *
+                 * REVISIT usb_gadget_vbus_connect(...) as needed, ditto
+                 * its disconnect() sibling, when changing to/from the
+                 * USB_LINK_VBUS state.  musb_hdrc won't care until it
+                 * starts to handle softconnect right.
+                 */
+                twl4030charger_usb_en(status == USB_LINK_VBUS);
+
+                if (status == USB_LINK_NONE)
+                        twl4030_phy_suspend(twl, 0);
+                else
+                        twl4030_phy_resume(twl);
+        }
+        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
+
+        return IRQ_HANDLED;
+}
+
+static int twl4030_set_suspend(struct otg_transceiver *x, int suspend)
+{
+        struct twl4030_usb *twl = xceiv_to_twl(x);
+
+        if (suspend)
+                twl4030_phy_suspend(twl, 1);
+        else
+                twl4030_phy_resume(twl);
+
+        return 0;
+}
+
+static int twl4030_set_peripheral(struct otg_transceiver *x,
+                struct usb_gadget *gadget)
+{
+        struct twl4030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.gadget = gadget;
+        if (!gadget)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int twl4030_set_host(struct otg_transceiver *x, struct usb_bus *host)
+{
+        struct twl4030_usb *twl;
+
+        if (!x)
+                return -ENODEV;
+
+        twl = xceiv_to_twl(x);
+        twl->otg.host = host;
+        if (!host)
+                twl->otg.state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int __init twl4030_usb_probe(struct platform_device *pdev)
+{
+        struct twl4030_usb_data *pdata = pdev->dev.platform_data;
+        struct twl4030_usb      *twl;
+        int                     status;
+
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "platform_data not available\n");
+                return -EINVAL;
+        }
+
+        twl = kzalloc(sizeof *twl, GFP_KERNEL);
+        if (!twl)
+                return -ENOMEM;
+
+        twl->dev                = &pdev->dev;
+        twl->irq                = platform_get_irq(pdev, 0);
+        twl->otg.dev            = twl->dev;
+        twl->otg.label          = "twl4030";
+        twl->otg.set_host       = twl4030_set_host;
+        twl->otg.set_peripheral = twl4030_set_peripheral;
+        twl->otg.set_suspend    = twl4030_set_suspend;
+        twl->usb_mode           = pdata->usb_mode;
+        twl->asleep             = 1;
+
+        /* init spinlock for workqueue */
+        spin_lock_init(&twl->lock);
+
+        twl4030_usb_ldo_init(twl);
+        otg_set_transceiver(&twl->otg);
+
+        platform_set_drvdata(pdev, twl);
+        if (device_create_file(&pdev->dev, &dev_attr_vbus))
+                dev_warn(&pdev->dev, "could not create sysfs file\n");
+
+        /* Our job is to use irqs and status from the power module
+         * to keep the transceiver disabled when nothing's connected.
+         *
+         * FIXME we actually shouldn't start enabling it until the
+         * USB controller drivers have said they're ready, by calling
+         * set_host() and/or set_peripheral() ... OTG_capable boards
+         * need both handles, otherwise just one suffices.
+         */
+        twl->irq_enabled = true;
+        status = request_irq(twl->irq, twl4030_usb_irq,
+                        IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
+                        "twl4030_usb", twl);
+        if (status < 0) {
+                dev_dbg(&pdev->dev, "can't get IRQ %d, err %d\n",
+                        twl->irq, status);
+                kfree(twl);
+                return status;
+        }
+
+        /* The IRQ handler just handles changes from the previous states
+         * of the ID and VBUS pins ... in probe() we must initialize that
+         * previous state.  The easy way:  fake an IRQ.
+         *
+         * REVISIT:  a real IRQ might have happened already, if PREEMPT is
+         * enabled.  Else the IRQ may not yet be configured or enabled,
+         * because of scheduling delays.
+         */
+        twl4030_usb_irq(twl->irq, twl);
+
+        dev_info(&pdev->dev, "Initialized TWL4030 USB module\n");
+        return 0;
+}
+
+static int __exit twl4030_usb_remove(struct platform_device *pdev)
+{
+        struct twl4030_usb *twl = platform_get_drvdata(pdev);
+        int val;
+
+        free_irq(twl->irq, twl);
+        device_remove_file(twl->dev, &dev_attr_vbus);
+
+        /* set transceiver mode to power on defaults */
+        twl4030_usb_set_mode(twl, -1);
+
+        /* autogate 60MHz ULPI clock,
+         * clear dpll clock request for i2c access,
+         * disable 32KHz
+         */
+        val = twl4030_usb_read(twl, PHY_CLK_CTRL);
+        if (val >= 0) {
+                val |= PHY_CLK_CTRL_CLOCKGATING_EN;
+                val &= ~(PHY_CLK_CTRL_CLK32K_EN | REQ_PHY_DPLL_CLK);
+                twl4030_usb_write(twl, PHY_CLK_CTRL, (u8)val);
+        }
+
+        /* disable complete OTG block */
+        twl4030_usb_clear_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
+
+        twl4030_phy_power(twl, 0);
+
+        kfree(twl);
+
+        return 0;
+}
+
+static struct platform_driver twl4030_usb_driver = {
+        .probe          = twl4030_usb_probe,
+        .remove         = __exit_p(twl4030_usb_remove),
+        .driver         = {
+                .name   = "twl4030_usb",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init twl4030_usb_init(void)
+{
+        return platform_driver_register(&twl4030_usb_driver);
+}
+subsys_initcall(twl4030_usb_init);
+
+static void __exit twl4030_usb_exit(void)
+{
+        platform_driver_unregister(&twl4030_usb_driver);
+}
+module_exit(twl4030_usb_exit);
+
+MODULE_ALIAS("platform:twl4030_usb");
+MODULE_AUTHOR("Texas Instruments, Inc, Nokia Corporation");
+MODULE_DESCRIPTION("TWL4030 USB transceiver driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 70338f4ec918..b361f05cafac 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -496,6 +496,14 @@ config USB_SERIAL_SAFE_PADDED
         bool "USB Secure Encapsulated Driver - Padded"
         depends on USB_SERIAL_SAFE
 
+config USB_SERIAL_SIEMENS_MPI
+        tristate "USB Siemens MPI driver"
+        help
+          Say M here if you want to use a Siemens USB/MPI adapter.
+
+          To compile this driver as a module, choose M here: the
+          module will be called siemens_mpi.
+
 config USB_SERIAL_SIERRAWIRELESS
         tristate "USB Sierra Wireless Driver"
         help
@@ -565,6 +573,15 @@ config USB_SERIAL_OMNINET
           To compile this driver as a module, choose M here: the
           module will be called omninet.
 
+config USB_SERIAL_OPTICON
+        tristate "USB Opticon Barcode driver (serial mode)"
+        help
+          Say Y here if you want to use a Opticon USB Barcode device
+          in serial emulation mode.
+
+          To compile this driver as a module, choose M here: the
+          module will be called opticon.
+
 config USB_SERIAL_DEBUG
         tristate "USB Debugging Device"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 6047f818adfe..b75be91eb8f1 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -41,10 +41,12 @@ obj-$(CONFIG_USB_SERIAL_MOS7840)		+= mos7840.o
 obj-$(CONFIG_USB_SERIAL_MOTOROLA)               += moto_modem.o
 obj-$(CONFIG_USB_SERIAL_NAVMAN)                 += navman.o
 obj-$(CONFIG_USB_SERIAL_OMNINET)                += omninet.o
+obj-$(CONFIG_USB_SERIAL_OPTICON)                += opticon.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_OTI6858)                += oti6858.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
 obj-$(CONFIG_USB_SERIAL_SAFE)                   += safe_serial.o
+obj-$(CONFIG_USB_SERIAL_SIEMENS_MPI)            += siemens_mpi.o
 obj-$(CONFIG_USB_SERIAL_SIERRAWIRELESS)         += sierra.o
 obj-$(CONFIG_USB_SERIAL_SPCP8X5)                += spcp8x5.o
 obj-$(CONFIG_USB_SERIAL_TI)                     += ti_usb_3410_5052.o
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 69f84f0ea6fe..38ba4ea8b6bf 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -635,8 +635,7 @@ static int digi_write_oob_command(struct usb_serial_port *port,
 
         spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
         while (count > 0) {
-                while (oob_port->write_urb->status == -EINPROGRESS
-                        || oob_priv->dp_write_urb_in_use) {
+                while (oob_priv->dp_write_urb_in_use) {
                         cond_wait_interruptible_timeout_irqrestore(
                                 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
                                 &oob_priv->dp_port_lock, flags);
@@ -699,9 +698,8 @@ static int digi_write_inb_command(struct usb_serial_port *port,
 
         spin_lock_irqsave(&priv->dp_port_lock, flags);
         while (count > 0 && ret == 0) {
-                while ((port->write_urb->status == -EINPROGRESS
-                                || priv->dp_write_urb_in_use)
-                                        && time_before(jiffies, timeout)) {
+                while (priv->dp_write_urb_in_use &&
+                       time_before(jiffies, timeout)) {
                         cond_wait_interruptible_timeout_irqrestore(
                                 &port->write_wait, DIGI_RETRY_TIMEOUT,
                                 &priv->dp_port_lock, flags);
@@ -779,8 +777,7 @@ static int digi_set_modem_signals(struct usb_serial_port *port,
         spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
         spin_lock(&port_priv->dp_port_lock);
 
-        while (oob_port->write_urb->status == -EINPROGRESS ||
-                                        oob_priv->dp_write_urb_in_use) {
+        while (oob_priv->dp_write_urb_in_use) {
                 spin_unlock(&port_priv->dp_port_lock);
                 cond_wait_interruptible_timeout_irqrestore(
                         &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
@@ -1168,12 +1165,10 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         /* be sure only one write proceeds at a time */
         /* there are races on the port private buffer */
-        /* and races to check write_urb->status */
         spin_lock_irqsave(&priv->dp_port_lock, flags);
 
         /* wait for urb status clear to submit another urb */
-        if (port->write_urb->status == -EINPROGRESS ||
-                                        priv->dp_write_urb_in_use) {
+        if (priv->dp_write_urb_in_use) {
                 /* buffer data if count is 1 (probably put_char) if possible */
                 if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) {
                         priv->dp_out_buf[priv->dp_out_buf_len++] = *buf;
@@ -1236,7 +1231,7 @@ static void digi_write_bulk_callback(struct urb *urb)
         int ret = 0;
         int status = urb->status;
 
-        dbg("digi_write_bulk_callback: TOP, urb->status=%d", status);
+        dbg("digi_write_bulk_callback: TOP, status=%d", status);
 
         /* port and serial sanity check */
         if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) {
@@ -1266,8 +1261,7 @@ static void digi_write_bulk_callback(struct urb *urb)
         /* try to send any buffered data on this port, if it is open */
         spin_lock(&priv->dp_port_lock);
         priv->dp_write_urb_in_use = 0;
-        if (port->port.count && port->write_urb->status != -EINPROGRESS
-            && priv->dp_out_buf_len > 0) {
+        if (port->port.count && priv->dp_out_buf_len > 0) {
                 *((unsigned char *)(port->write_urb->transfer_buffer))
                         = (unsigned char)DIGI_CMD_SEND_DATA;
                 *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
@@ -1305,8 +1299,7 @@ static int digi_write_room(struct tty_struct *tty)
 
         spin_lock_irqsave(&priv->dp_port_lock, flags);
 
-        if (port->write_urb->status == -EINPROGRESS ||
-                                        priv->dp_write_urb_in_use)
+        if (priv->dp_write_urb_in_use)
                 room = 0;
         else
                 room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
@@ -1322,8 +1315,7 @@ static int digi_chars_in_buffer(struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         struct digi_port *priv = usb_get_serial_port_data(port);
 
-        if (port->write_urb->status == -EINPROGRESS
-            || priv->dp_write_urb_in_use) {
+        if (priv->dp_write_urb_in_use) {
                 dbg("digi_chars_in_buffer: port=%d, chars=%d",
                         priv->dp_port_num, port->bulk_out_size - 2);
                 /* return(port->bulk_out_size - 2); */
@@ -1702,7 +1694,7 @@ static int digi_read_inb_callback(struct urb *urb)
         /* short/multiple packet check */
         if (urb->actual_length != len + 2) {
                 dev_err(&port->dev, "%s: INCOMPLETE OR MULTIPLE PACKET, "
-                        "urb->status=%d, port=%d, opcode=%d, len=%d, "
+                        "status=%d, port=%d, opcode=%d, len=%d, "
                         "actual_length=%d, status=%d\n", __func__, status,
                         priv->dp_port_num, opcode, len, urb->actual_length,
                         port_status);
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 8e6a66e38db2..a26a0e2cdb4a 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1056,7 +1056,7 @@ static void garmin_write_bulk_callback(struct urb *urb)
 
                 if (status) {
                         dbg("%s - nonzero write bulk status received: %d",
-                            __func__, urb->status);
+                            __func__, status);
                         spin_lock_irqsave(&garmin_data_p->lock, flags);
                         garmin_data_p->flags |= CLEAR_HALT_REQUIRED;
                         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 3ac59a8a980f..f530032ed93d 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -473,7 +473,7 @@ static struct usb_serial_driver ipw_device = {
 
 
 
-static int usb_ipw_init(void)
+static int __init usb_ipw_init(void)
 {
         int retval;
 
@@ -490,7 +490,7 @@ static int usb_ipw_init(void)
         return 0;
 }
 
-static void usb_ipw_exit(void)
+static void __exit usb_ipw_exit(void)
 {
         usb_deregister(&usb_ipw_driver);
         usb_serial_deregister(&ipw_device);
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index e320972cb227..2314c6ae4fc2 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -190,10 +190,12 @@ static void iuu_rxcmd(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         int result;
+        int status = urb->status;
+
         dbg("%s - enter", __func__);
 
-        if (urb->status) {
-                dbg("%s - urb->status = %d", __func__, urb->status);
+        if (status) {
+                dbg("%s - status = %d", __func__, status);
                 /* error stop all */
                 return;
         }
@@ -245,10 +247,12 @@ static void iuu_update_status_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         struct iuu_private *priv = usb_get_serial_port_data(port);
         u8 *st;
+        int status = urb->status;
+
         dbg("%s - enter", __func__);
 
-        if (urb->status) {
-                dbg("%s - urb->status = %d", __func__, urb->status);
+        if (status) {
+                dbg("%s - status = %d", __func__, status);
                 /* error stop all */
                 return;
         }
@@ -274,9 +278,9 @@ static void iuu_status_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         int result;
-        dbg("%s - enter", __func__);
+        int status = urb->status;
 
-        dbg("%s - urb->status = %d", __func__, urb->status);
+        dbg("%s - status = %d", __func__, status);
         usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                           usb_rcvbulkpipe(port->serial->dev,
                                           port->bulk_in_endpointAddress),
@@ -618,11 +622,12 @@ static void read_buf_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         unsigned char *data = urb->transfer_buffer;
         struct tty_struct *tty;
-        dbg("%s - urb->status = %d", __func__, urb->status);
+        int status = urb->status;
 
-        if (urb->status) {
-                dbg("%s - urb->status = %d", __func__, urb->status);
-                if (urb->status == -EPROTO) {
+        dbg("%s - status = %d", __func__, status);
+
+        if (status) {
+                if (status == -EPROTO) {
                         /* reschedule needed */
                 }
                 return;
@@ -695,7 +700,7 @@ static void iuu_uart_read_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         struct iuu_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        int status;
+        int status = urb->status;
         int error = 0;
         int len = 0;
         unsigned char *data = urb->transfer_buffer;
@@ -703,8 +708,8 @@ static void iuu_uart_read_callback(struct urb *urb)
 
         dbg("%s - enter", __func__);
 
-        if (urb->status) {
-                dbg("%s - urb->status = %d", __func__, urb->status);
+        if (status) {
+                dbg("%s - status = %d", __func__, status);
                 /* error stop all */
                 return;
         }
@@ -782,12 +787,11 @@ static void read_rxcmd_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         int result;
-        dbg("%s - enter", __func__);
+        int status = urb->status;
 
-        dbg("%s - urb->status = %d", __func__, urb->status);
+        dbg("%s - status = %d", __func__, status);
 
-        if (urb->status) {
-                dbg("%s - urb->status = %d", __func__, urb->status);
+        if (status) {
                 /* error stop all */
                 return;
         }
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 96a8c7713212..2c20e88a91b3 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -214,6 +214,7 @@ struct moschip_port {
         spinlock_t pool_lock;
         struct urb *write_urb_pool[NUM_URBS];
         char busy[NUM_URBS];
+        bool read_urb_busy;
 };
 
 
@@ -679,26 +680,30 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         struct tty_struct *tty;
         int status = urb->status;
 
-        if (status) {
-                dbg("nonzero read bulk status received: %d", status);
-                return;
-        }
-
         mos7840_port = urb->context;
         if (!mos7840_port) {
                 dbg("%s", "NULL mos7840_port pointer \n");
+                mos7840_port->read_urb_busy = false;
+                return;
+        }
+
+        if (status) {
+                dbg("nonzero read bulk status received: %d", status);
+                mos7840_port->read_urb_busy = false;
                 return;
         }
 
         port = (struct usb_serial_port *)mos7840_port->port;
         if (mos7840_port_paranoia_check(port, __func__)) {
                 dbg("%s", "Port Paranoia failed \n");
+                mos7840_port->read_urb_busy = false;
                 return;
         }
 
         serial = mos7840_get_usb_serial(port, __func__);
         if (!serial) {
                 dbg("%s\n", "Bad serial pointer ");
+                mos7840_port->read_urb_busy = false;
                 return;
         }
 
@@ -725,17 +730,19 @@ static void mos7840_bulk_in_callback(struct urb *urb)
 
         if (!mos7840_port->read_urb) {
                 dbg("%s", "URB KILLED !!!\n");
+                mos7840_port->read_urb_busy = false;
                 return;
         }
 
 
         mos7840_port->read_urb->dev = serial->dev;
 
+        mos7840_port->read_urb_busy = true;
         retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
 
         if (retval) {
-                dbg(" usb_submit_urb(read bulk) failed, retval = %d",
-                 retval);
+                dbg("usb_submit_urb(read bulk) failed, retval = %d", retval);
+                mos7840_port->read_urb_busy = false;
         }
 }
 
@@ -1055,10 +1062,12 @@ static int mos7840_open(struct tty_struct *tty,
 
         dbg("mos7840_open: bulkin endpoint is %d\n",
             port->bulk_in_endpointAddress);
+        mos7840_port->read_urb_busy = true;
         response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
         if (response) {
                 dev_err(&port->dev, "%s - Error %d submitting control urb\n",
                         __func__, response);
+                mos7840_port->read_urb_busy = false;
         }
 
         /* initialize our wait queues */
@@ -1227,6 +1236,7 @@ static void mos7840_close(struct tty_struct *tty,
                 if (mos7840_port->read_urb) {
                         dbg("%s", "Shutdown bulk read\n");
                         usb_kill_urb(mos7840_port->read_urb);
+                        mos7840_port->read_urb_busy = false;
                 }
                 if ((&mos7840_port->control_urb)) {
                         dbg("%s", "Shutdown control read\n");
@@ -2043,14 +2053,14 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
         Data = 0x0c;
         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
 
-        if (mos7840_port->read_urb->status != -EINPROGRESS) {
+        if (mos7840_port->read_urb_busy == false) {
                 mos7840_port->read_urb->dev = serial->dev;
-
+                mos7840_port->read_urb_busy = true;
                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
-
                 if (status) {
-                        dbg(" usb_submit_urb(read bulk) failed, status = %d",
+                        dbg("usb_submit_urb(read bulk) failed, status = %d",
                             status);
+                        mos7840_port->read_urb_busy = false;
                 }
         }
         wake_up(&mos7840_port->delta_msr_wait);
@@ -2117,12 +2127,14 @@ static void mos7840_set_termios(struct tty_struct *tty,
                 return;
         }
 
-        if (mos7840_port->read_urb->status != -EINPROGRESS) {
+        if (mos7840_port->read_urb_busy == false) {
                 mos7840_port->read_urb->dev = serial->dev;
+                mos7840_port->read_urb_busy = true;
                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
                 if (status) {
-                        dbg(" usb_submit_urb(read bulk) failed, status = %d",
+                        dbg("usb_submit_urb(read bulk) failed, status = %d",
                             status);
+                        mos7840_port->read_urb_busy = false;
                 }
         }
         return;
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
new file mode 100644
index 000000000000..cea326f1f105
--- /dev/null
+++ b/drivers/usb/serial/opticon.c
@@ -0,0 +1,358 @@
+/*
+ * Opticon USB barcode to serial driver
+ *
+ * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
+ * Copyright (C) 2008 Novell Inc.
+ *
+ *      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_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+#include <linux/uaccess.h>
+
+static int debug;
+
+static struct usb_device_id id_table[] = {
+        { USB_DEVICE(0x065a, 0x0009) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+/* This structure holds all of the individual device information */
+struct opticon_private {
+        struct usb_device *udev;
+        struct usb_serial *serial;
+        struct usb_serial_port *port;
+        unsigned char *bulk_in_buffer;
+        struct urb *bulk_read_urb;
+        int buffer_size;
+        u8 bulk_address;
+        spinlock_t lock;        /* protects the following flags */
+        bool throttled;
+        bool actually_throttled;
+        bool rts;
+};
+
+static void opticon_bulk_callback(struct urb *urb)
+{
+        struct opticon_private *priv = urb->context;
+        unsigned char *data = urb->transfer_buffer;
+        struct usb_serial_port *port = priv->port;
+        int status = urb->status;
+        struct tty_struct *tty;
+        int result;
+        int available_room = 0;
+        int data_length;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        switch (status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __func__, status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __func__, status);
+                goto exit;
+        }
+
+        usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
+                              data);
+
+        if (urb->actual_length > 2) {
+                data_length = urb->actual_length - 2;
+
+                /*
+                 * Data from the device comes with a 2 byte header:
+                 *
+                 * <0x00><0x00>data...
+                 *      This is real data to be sent to the tty layer
+                 * <0x00><0x01)level
+                 *      This is a RTS level change, the third byte is the RTS
+                 *      value (0 for low, 1 for high).
+                 */
+                if ((data[0] == 0x00) && (data[1] == 0x00)) {
+                        /* real data, send it to the tty layer */
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                available_room = tty_buffer_request_room(tty,
+                                                                data_length);
+                                if (available_room) {
+                                        tty_insert_flip_string(tty, data,
+                                                               available_room);
+                                        tty_flip_buffer_push(tty);
+                                }
+                                tty_kref_put(tty);
+                        }
+                } else {
+                        if ((data[0] == 0x00) && (data[1] == 0x01)) {
+                                if (data[2] == 0x00)
+                                        priv->rts = false;
+                                else
+                                        priv->rts = true;
+                                /* FIXME change the RTS level */
+                        } else {
+                        dev_dbg(&priv->udev->dev,
+                                "Unknown data packet received from the device:"
+                                " %2x %2x\n",
+                                data[0], data[1]);
+                        }
+                }
+        } else {
+                dev_dbg(&priv->udev->dev,
+                        "Improper ammount of data received from the device, "
+                        "%d bytes", urb->actual_length);
+        }
+
+exit:
+        spin_lock(&priv->lock);
+
+        /* Continue trying to always read if we should */
+        if (!priv->throttled) {
+                usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
+                                  usb_rcvbulkpipe(priv->udev,
+                                                  priv->bulk_address),
+                                  priv->bulk_in_buffer, priv->buffer_size,
+                                  opticon_bulk_callback, priv);
+                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);
+        } else
+                priv->actually_throttled = true;
+        spin_unlock(&priv->lock);
+}
+
+static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port,
+                        struct file *filp)
+{
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        int result = 0;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = false;
+        priv->actually_throttled = false;
+        priv->port = port;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        /*
+         * Force low_latency on so that our tty_push actually forces the data
+         * through, otherwise it is scheduled, and with high data rates (like
+         * with OHCI) data can get lost.
+         */
+        if (tty)
+                tty->low_latency = 1;
+
+        /* Start reading from the device */
+        usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
+                          usb_rcvbulkpipe(priv->udev,
+                                          priv->bulk_address),
+                          priv->bulk_in_buffer, priv->buffer_size,
+                          opticon_bulk_callback, priv);
+        result = usb_submit_urb(priv->bulk_read_urb, GFP_KERNEL);
+        if (result)
+                dev_err(&port->dev,
+                        "%s - failed resubmitting read urb, error %d\n",
+                        __func__, result);
+        return result;
+}
+
+static void opticon_close(struct tty_struct *tty, struct usb_serial_port *port,
+                          struct file *filp)
+{
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+
+        dbg("%s - port %d", __func__, port->number);
+
+        /* shutdown our urbs */
+        usb_kill_urb(priv->bulk_read_urb);
+}
+
+static void opticon_throttle(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+
+        dbg("%s - port %d", __func__, port->number);
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = true;
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+
+static void opticon_unthrottle(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct opticon_private *priv = usb_get_serial_data(port->serial);
+        unsigned long flags;
+        int result;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        priv->throttled = false;
+        priv->actually_throttled = false;
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        priv->bulk_read_urb->dev = port->serial->dev;
+        result = usb_submit_urb(priv->bulk_read_urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&port->dev,
+                        "%s - failed submitting read urb, error %d\n",
+                                                        __func__, result);
+}
+
+static int opticon_startup(struct usb_serial *serial)
+{
+        struct opticon_private *priv;
+        struct usb_host_interface *intf;
+        int i;
+        int retval = -ENOMEM;
+        bool bulk_in_found = false;
+
+        /* create our private serial structure */
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (priv == NULL) {
+                dev_err(&serial->dev->dev, "%s - Out of memory\n", __func__);
+                return -ENOMEM;
+        }
+        spin_lock_init(&priv->lock);
+        priv->serial = serial;
+        priv->port = serial->port[0];
+        priv->udev = serial->dev;
+
+        /* find our bulk endpoint */
+        intf = serial->interface->altsetting;
+        for (i = 0; i < intf->desc.bNumEndpoints; ++i) {
+                struct usb_endpoint_descriptor *endpoint;
+
+                endpoint = &intf->endpoint[i].desc;
+                if (!usb_endpoint_is_bulk_in(endpoint))
+                        continue;
+
+                priv->bulk_read_urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (!priv->bulk_read_urb) {
+                        dev_err(&priv->udev->dev, "out of memory\n");
+                        goto error;
+                }
+
+                priv->buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
+                priv->bulk_in_buffer = kmalloc(priv->buffer_size, GFP_KERNEL);
+                if (!priv->bulk_in_buffer) {
+                        dev_err(&priv->udev->dev, "out of memory\n");
+                        goto error;
+                }
+
+                priv->bulk_address = endpoint->bEndpointAddress;
+
+                /* set up our bulk urb */
+                usb_fill_bulk_urb(priv->bulk_read_urb, priv->udev,
+                                  usb_rcvbulkpipe(priv->udev,
+                                                  endpoint->bEndpointAddress),
+                                  priv->bulk_in_buffer, priv->buffer_size,
+                                  opticon_bulk_callback, priv);
+
+                bulk_in_found = true;
+                break;
+                }
+
+        if (!bulk_in_found) {
+                dev_err(&priv->udev->dev,
+                        "Error - the proper endpoints were not found!\n");
+                goto error;
+        }
+
+        usb_set_serial_data(serial, priv);
+        return 0;
+
+error:
+        usb_free_urb(priv->bulk_read_urb);
+        kfree(priv->bulk_in_buffer);
+        kfree(priv);
+        return retval;
+}
+
+static void opticon_shutdown(struct usb_serial *serial)
+{
+        struct opticon_private *priv = usb_get_serial_data(serial);
+
+        dbg("%s", __func__);
+
+        usb_kill_urb(priv->bulk_read_urb);
+        usb_free_urb(priv->bulk_read_urb);
+        kfree(priv->bulk_in_buffer);
+        kfree(priv);
+        usb_set_serial_data(serial, NULL);
+}
+
+
+static struct usb_driver opticon_driver = {
+        .name =         "opticon",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+        .no_dynamic_id =        1,
+};
+
+static struct usb_serial_driver opticon_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "opticon",
+        },
+        .id_table =             id_table,
+        .usb_driver =           &opticon_driver,
+        .num_ports =            1,
+        .attach =               opticon_startup,
+        .open =                 opticon_open,
+        .close =                opticon_close,
+        .shutdown =             opticon_shutdown,
+        .throttle =             opticon_throttle,
+        .unthrottle =           opticon_unthrottle,
+};
+
+static int __init opticon_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&opticon_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&opticon_driver);
+        if (retval)
+                usb_serial_deregister(&opticon_device);
+        return retval;
+}
+
+static void __exit opticon_exit(void)
+{
+        usb_deregister(&opticon_driver);
+        usb_serial_deregister(&opticon_device);
+}
+
+module_init(opticon_init);
+module_exit(opticon_exit);
+MODULE_LICENSE("GPL");
+
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 809697b3c7fc..5ed183477aaf 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -522,9 +522,9 @@ static int debug;
 /* per port private data */
 
 #define N_IN_URB 4
-#define N_OUT_URB 1
+#define N_OUT_URB 4
 #define IN_BUFLEN 4096
-#define OUT_BUFLEN 128
+#define OUT_BUFLEN 4096
 
 struct option_port_private {
         /* Input endpoints and buffer for this port */
@@ -654,10 +654,6 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                         usb_unlink_urb(this_urb);
                         continue;
                 }
-                if (this_urb->status != 0)
-                        dbg("usb_write %p failed (err=%d)",
-                                this_urb, this_urb->status);
-
                 dbg("%s: endpoint %d buf %d", __func__,
                         usb_pipeendpoint(this_urb->pipe), i);
 
@@ -669,8 +665,7 @@ static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
                 if (err) {
                         dbg("usb_submit_urb %p (write bulk) failed "
-                                "(%d, has %d)", this_urb,
-                                err, this_urb->status);
+                                "(%d)", this_urb, err);
                         clear_bit(i, &portdata->out_busy);
                         continue;
                 }
diff --git a/drivers/usb/serial/siemens_mpi.c b/drivers/usb/serial/siemens_mpi.c
new file mode 100644
index 000000000000..951ea0c6ba77
--- /dev/null
+++ b/drivers/usb/serial/siemens_mpi.c
@@ -0,0 +1,77 @@
+/*
+ * Siemens USB-MPI Serial USB driver
+ *
+ * Copyright (C) 2005 Thomas Hergenhahn <thomas.hergenhahn@suse.de>
+ * Copyright (C) 2005,2008 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/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+
+/* Version Information */
+#define DRIVER_VERSION "Version 0.1 09/26/2005"
+#define DRIVER_AUTHOR "Thomas Hergenhahn@web.de http://libnodave.sf.net"
+#define DRIVER_DESC "Driver for Siemens USB/MPI adapter"
+
+
+static struct usb_device_id id_table[] = {
+        /* Vendor and product id for 6ES7-972-0CB20-0XA0 */
+        { USB_DEVICE(0x908, 0x0004) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_driver siemens_usb_mpi_driver = {
+        .name =         "siemens_mpi",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+};
+
+static struct usb_serial_driver siemens_usb_mpi_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "siemens_mpi",
+        },
+        .id_table =             id_table,
+        .num_ports =            1,
+};
+
+static int __init siemens_usb_mpi_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&siemens_usb_mpi_device);
+        if (retval)
+                goto failed_usb_serial_register;
+        retval = usb_register(&siemens_usb_mpi_driver);
+        if (retval)
+                goto failed_usb_register;
+        printk(KERN_INFO DRIVER_DESC "\n");
+        printk(KERN_INFO DRIVER_VERSION " " DRIVER_AUTHOR "\n");
+        return retval;
+failed_usb_register:
+        usb_serial_deregister(&siemens_usb_mpi_device);
+failed_usb_serial_register:
+        return retval;
+}
+
+static void __exit siemens_usb_mpi_exit(void)
+{
+        usb_deregister(&siemens_usb_mpi_driver);
+        usb_serial_deregister(&siemens_usb_mpi_device);
+}
+
+module_init(siemens_usb_mpi_init);
+module_exit(siemens_usb_mpi_exit);
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index a65bc2bd8e71..5e7528cc81a8 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -709,21 +709,20 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
         int i;
-        int result;
-        u8 status = 0;
+        int result = urb->status;
+        u8 status;
         char tty_flag;
 
-        dev_dbg(&port->dev, "start, urb->status = %d, "
-                "urb->actual_length = %d\n,", urb->status, urb->actual_length);
+        dev_dbg(&port->dev, "start, result = %d, urb->actual_length = %d\n,",
+                result, urb->actual_length);
 
         /* check the urb status */
-        if (urb->status) {
+        if (result) {
                 if (!port->port.count)
                         return;
-                if (urb->status == -EPROTO) {
+                if (result == -EPROTO) {
                         /* spcp8x5 mysteriously fails with -EPROTO */
                         /* reschedule the read */
-                        urb->status = 0;
                         urb->dev = port->serial->dev;
                         result = usb_submit_urb(urb , GFP_ATOMIC);
                         if (result)
@@ -833,8 +832,9 @@ static void spcp8x5_write_bulk_callback(struct urb *urb)
         struct usb_serial_port *port = urb->context;
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         int result;
+        int status = urb->status;
 
-        switch (urb->status) {
+        switch (status) {
         case 0:
                 /* success */
                 break;
@@ -843,14 +843,14 @@ static void spcp8x5_write_bulk_callback(struct urb *urb)
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
                 dev_dbg(&port->dev, "urb shutting down with status: %d\n",
-                        urb->status);
+                        status);
                 priv->write_urb_in_use = 0;
                 return;
         default:
                 /* error in the urb, so we have to resubmit it */
                 dbg("%s - Overflow in write", __func__);
                 dbg("%s - nonzero write bulk status received: %d",
-                        __func__, urb->status);
+                        __func__, status);
                 port->write_urb->transfer_buffer_length = 1;
                 port->write_urb->dev = port->serial->dev;
                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index fc5d9952b03b..6c9cbb59552a 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -31,7 +31,7 @@ static struct usb_driver debug_driver = {
         .no_dynamic_id =        1,
 };
 
-int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port,
+static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port,
                                                         struct file *filp)
 {
         port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index c68b738900bd..9df6887b91f6 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -61,13 +61,6 @@ config USB_STORAGE_ISD200
           - CyQ've CQ8060A CDRW drive
           - Planex eXtreme Drive RX-25HU USB-IDE cable (not model RX-25U)
 
-config USB_STORAGE_DPCM
-        bool "Microtech/ZiO! CompactFlash/SmartMedia support"
-        depends on USB_STORAGE
-        help
-          Say Y here to support the Microtech/ZiO! CompactFlash reader.
-          There is a web page at <http://www.ziocorp.com/products/>.
-
 config USB_STORAGE_USBAT
         bool "USBAT/USBAT02-based storage support"
         depends on USB_STORAGE
@@ -90,12 +83,12 @@ config USB_STORAGE_USBAT
           - Sandisk ImageMate SDDR-05b
 
 config USB_STORAGE_SDDR09
-        bool "SanDisk SDDR-09 (and other SmartMedia) support"
+        bool "SanDisk SDDR-09 (and other SmartMedia, including DPCM) support"
         depends on USB_STORAGE
         help
           Say Y here to include additional code to support the Sandisk SDDR-09
           SmartMedia reader in the USB Mass Storage driver.
-          Also works for the Microtech Zio! SmartMedia reader.
+          Also works for the Microtech Zio! CompactFlash/SmartMedia reader.
 
 config USB_STORAGE_SDDR55
         bool "SanDisk SDDR-55 SmartMedia support"
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index 7f8beb5366ae..b32069313390 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -14,7 +14,6 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_USBAT)	+= shuttle_usbat.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR09)    += sddr09.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_SDDR55)    += sddr55.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_FREECOM)   += freecom.o
-usb-storage-obj-$(CONFIG_USB_STORAGE_DPCM)      += dpcm.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_ISD200)    += isd200.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_DATAFAB)   += datafab.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_JUMPSHOT)  += jumpshot.o
@@ -24,7 +23,7 @@ usb-storage-obj-$(CONFIG_USB_STORAGE_KARMA)	+= karma.o
 usb-storage-obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += cypress_atacb.o
 
 usb-storage-objs :=     scsiglue.o protocol.o transport.o usb.o \
-                        initializers.o sierra_ms.o $(usb-storage-obj-y)
+                        initializers.o sierra_ms.o option_ms.o $(usb-storage-obj-y)
 
 ifneq ($(CONFIG_USB_LIBUSUAL),)
         obj-$(CONFIG_USB)       += libusual.o
diff --git a/drivers/usb/storage/dpcm.c b/drivers/usb/storage/dpcm.c
deleted file mode 100644
index 939923471af4..000000000000
--- a/drivers/usb/storage/dpcm.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/* Driver for Microtech DPCM-USB CompactFlash/SmartMedia reader
- *
- * DPCM driver v0.1:
- *
- * First release
- *
- * Current development and maintenance by:
- *   (c) 2000 Brian Webb (webbb@earthlink.net)
- *
- * This device contains both a CompactFlash card reader, which
- * uses the Control/Bulk w/o Interrupt protocol and
- * a SmartMedia card reader that uses the same protocol
- * as the SDDR09.
- *
- * 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, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <scsi/scsi.h>
-#include <scsi/scsi_cmnd.h>
-#include <scsi/scsi_device.h>
-
-#include "usb.h"
-#include "transport.h"
-#include "protocol.h"
-#include "debug.h"
-#include "dpcm.h"
-#include "sddr09.h"
-
-/*
- * Transport for the Microtech DPCM-USB
- *
- */
-int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
-{
-        int ret;
-
-        if (srb == NULL)
-                return USB_STOR_TRANSPORT_ERROR;
-
-        US_DEBUGP("dpcm_transport: LUN=%d\n", srb->device->lun);
-
-        switch (srb->device->lun) {
-                case 0:
-
-                        /*
-                         * LUN 0 corresponds to the CompactFlash card reader.
-                         */
-                        ret = usb_stor_CB_transport(srb, us);
-                        break;
-
-#ifdef CONFIG_USB_STORAGE_SDDR09
-                case 1:
-
-                        /*
-                         * LUN 1 corresponds to the SmartMedia card reader.
-                         */
-
-                        /*
-                         * Set the LUN to 0 (just in case).
-                         */
-                        srb->device->lun = 0; us->srb->device->lun = 0;
-                        ret = sddr09_transport(srb, us);
-                        srb->device->lun = 1; us->srb->device->lun = 1;
-                        break;
-
-#endif
-
-                default:
-                        US_DEBUGP("dpcm_transport: Invalid LUN %d\n", srb->device->lun);
-                        ret = USB_STOR_TRANSPORT_ERROR;
-                        break;
-        }
-        return ret;
-}
diff --git a/drivers/usb/storage/dpcm.h b/drivers/usb/storage/dpcm.h
deleted file mode 100644
index e7b7b0f120d7..000000000000
--- a/drivers/usb/storage/dpcm.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Driver for Microtech DPCM-USB CompactFlash/SmartMedia reader
- *
- * DPCM driver v0.1:
- *
- * First release
- *
- * Current development and maintenance by:
- *   (c) 2000 Brian Webb (webbb@earthlink.net)
- *
- * See dpcm.c for more explanation
- *
- * 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, or (at your option) any
- * later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef _MICROTECH_DPCM_USB_H
-#define _MICROTECH_DPCM_USB_H
-
-extern int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us);
-
-#endif
diff --git a/drivers/usb/storage/libusual.c b/drivers/usb/storage/libusual.c
index d617e8ae6b00..f970b27ba308 100644
--- a/drivers/usb/storage/libusual.c
+++ b/drivers/usb/storage/libusual.c
@@ -46,6 +46,12 @@ static int usu_probe_thread(void *arg);
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
   .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
 
+#define COMPLIANT_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
+                    vendorName, productName, useProtocol, useTransport, \
+                    initFunction, flags) \
+{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
+  .driver_info = (flags) }
+
 #define USUAL_DEV(useProto, useTrans, useType) \
 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
   .driver_info = ((useType)<<24) }
@@ -57,6 +63,7 @@ struct usb_device_id storage_usb_ids [] = {
 
 #undef USUAL_DEV
 #undef UNUSUAL_DEV
+#undef COMPLIANT_DEV
 
 MODULE_DEVICE_TABLE(usb, storage_usb_ids);
 EXPORT_SYMBOL_GPL(storage_usb_ids);
diff --git a/drivers/usb/storage/option_ms.c b/drivers/usb/storage/option_ms.c
new file mode 100644
index 000000000000..353f922939a4
--- /dev/null
+++ b/drivers/usb/storage/option_ms.c
@@ -0,0 +1,147 @@
+/*
+ * Driver for Option High Speed Mobile Devices.
+ *
+ *   (c) 2008 Dan Williams <dcbw@redhat.com>
+ *
+ * Inspiration taken from sierra_ms.c by Kevin Lloyd <klloyd@sierrawireless.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/usb.h>
+
+#include "usb.h"
+#include "transport.h"
+#include "option_ms.h"
+#include "debug.h"
+
+#define ZCD_FORCE_MODEM                 0x01
+#define ZCD_ALLOW_MS                    0x02
+
+static unsigned int option_zero_cd = ZCD_FORCE_MODEM;
+module_param(option_zero_cd, uint, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(option_zero_cd, "ZeroCD mode (1=Force Modem (default),"
+                 " 2=Allow CD-Rom");
+
+#define RESPONSE_LEN 1024
+
+static int option_rezero(struct us_data *us, int ep_in, int ep_out)
+{
+        const unsigned char rezero_msg[] = {
+          0x55, 0x53, 0x42, 0x43, 0x78, 0x56, 0x34, 0x12,
+          0x01, 0x00, 0x00, 0x00, 0x80, 0x00, 0x06, 0x01,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+        };
+        char *buffer;
+        int result;
+
+        US_DEBUGP("Option MS: %s", "DEVICE MODE SWITCH\n");
+
+        buffer = kzalloc(RESPONSE_LEN, GFP_KERNEL);
+        if (buffer == NULL)
+                return USB_STOR_TRANSPORT_ERROR;
+
+        memcpy(buffer, rezero_msg, sizeof (rezero_msg));
+        result = usb_stor_bulk_transfer_buf(us,
+                        usb_sndbulkpipe(us->pusb_dev, ep_out),
+                        buffer, sizeof (rezero_msg), NULL);
+        if (result != USB_STOR_XFER_GOOD) {
+                result = USB_STOR_XFER_ERROR;
+                goto out;
+        }
+
+        /* Some of the devices need to be asked for a response, but we don't
+         * care what that response is.
+         */
+        result = usb_stor_bulk_transfer_buf(us,
+                        usb_sndbulkpipe(us->pusb_dev, ep_out),
+                        buffer, RESPONSE_LEN, NULL);
+        result = USB_STOR_XFER_GOOD;
+
+out:
+        kfree(buffer);
+        return result;
+}
+
+int option_ms_init(struct us_data *us)
+{
+        struct usb_device *udev;
+        struct usb_interface *intf;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint = NULL;
+        u8 ep_in = 0, ep_out = 0;
+        int ep_in_size = 0, ep_out_size = 0;
+        int i, result;
+
+        udev = us->pusb_dev;
+        intf = us->pusb_intf;
+
+        /* Ensure it's really a ZeroCD device; devices that are already
+         * in modem mode return 0xFF for class, subclass, and protocol.
+         */
+        if (udev->descriptor.bDeviceClass != 0 ||
+            udev->descriptor.bDeviceSubClass != 0 ||
+            udev->descriptor.bDeviceProtocol != 0)
+                return USB_STOR_TRANSPORT_GOOD;
+
+        US_DEBUGP("Option MS: option_ms_init called\n");
+
+        /* Find the right mass storage interface */
+        iface_desc = intf->cur_altsetting;
+        if (iface_desc->desc.bInterfaceClass != 0x8 ||
+            iface_desc->desc.bInterfaceSubClass != 0x6 ||
+            iface_desc->desc.bInterfaceProtocol != 0x50) {
+                US_DEBUGP("Option MS: mass storage interface not found, no action "
+                          "required\n");
+                return USB_STOR_TRANSPORT_GOOD;
+        }
+
+        /* Find the mass storage bulk endpoints */
+        for (i = 0; i < iface_desc->desc.bNumEndpoints && (!ep_in_size || !ep_out_size); ++i) {
+                endpoint = &iface_desc->endpoint[i].desc;
+
+                if (usb_endpoint_is_bulk_in(endpoint)) {
+                        ep_in = usb_endpoint_num(endpoint);
+                        ep_in_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                } else if (usb_endpoint_is_bulk_out(endpoint)) {
+                        ep_out = usb_endpoint_num(endpoint);
+                        ep_out_size = le16_to_cpu(endpoint->wMaxPacketSize);
+                }
+        }
+
+        /* Can't find the mass storage endpoints */
+        if (!ep_in_size || !ep_out_size) {
+                US_DEBUGP("Option MS: mass storage endpoints not found, no action "
+                          "required\n");
+                return USB_STOR_TRANSPORT_GOOD;
+        }
+
+        /* Force Modem mode */
+        if (option_zero_cd == ZCD_FORCE_MODEM) {
+                US_DEBUGP("Option MS: %s", "Forcing Modem Mode\n");
+                result = option_rezero(us, ep_in, ep_out);
+                if (result != USB_STOR_XFER_GOOD)
+                        US_DEBUGP("Option MS: Failed to switch to modem mode.\n");
+                return -EIO;
+        } else if (option_zero_cd == ZCD_ALLOW_MS) {
+                /* Allow Mass Storage mode (keep CD-Rom) */
+                US_DEBUGP("Option MS: %s", "Allowing Mass Storage Mode if device"
+                          " requests it\n");
+        }
+
+        return USB_STOR_TRANSPORT_GOOD;
+}
+
diff --git a/drivers/usb/storage/option_ms.h b/drivers/usb/storage/option_ms.h
new file mode 100644
index 000000000000..b6e448cab039
--- /dev/null
+++ b/drivers/usb/storage/option_ms.h
@@ -0,0 +1,4 @@
+#ifndef _OPTION_MS_H_
+#define _OPTION_MS_H_
+extern int option_ms_init(struct us_data *us);
+#endif
diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
index 3b3357e20ea7..be441d84bc64 100644
--- a/drivers/usb/storage/protocol.c
+++ b/drivers/usb/storage/protocol.c
@@ -56,9 +56,9 @@
  * Protocol routines
  ***********************************************************************/
 
-void usb_stor_qic157_command(struct scsi_cmnd *srb, struct us_data *us)
+void usb_stor_pad12_command(struct scsi_cmnd *srb, struct us_data *us)
 {
-        /* Pad the ATAPI command with zeros 
+        /* Pad the SCSI command with zeros out to 12 bytes
          *
          * NOTE: This only works because a scsi_cmnd struct field contains
          * a unsigned char cmnd[16], so we know we have storage available
@@ -73,26 +73,6 @@ void usb_stor_qic157_command(struct scsi_cmnd *srb, struct us_data *us)
         usb_stor_invoke_transport(srb, us);
 }
 
-void usb_stor_ATAPI_command(struct scsi_cmnd *srb, struct us_data *us)
-{
-        /* Pad the ATAPI command with zeros 
-         *
-         * NOTE: This only works because a scsi_cmnd struct field contains
-         * a unsigned char cmnd[16], so we know we have storage available
-         */
-
-        /* Pad the ATAPI command with zeros */
-        for (; srb->cmd_len<12; srb->cmd_len++)
-                srb->cmnd[srb->cmd_len] = 0;
-
-        /* set command length to 12 bytes */
-        srb->cmd_len = 12;
-
-        /* send the command to the transport layer */
-        usb_stor_invoke_transport(srb, us);
-}
-
-
 void usb_stor_ufi_command(struct scsi_cmnd *srb, struct us_data *us)
 {
         /* fix some commands -- this is a form of mode translation
diff --git a/drivers/usb/storage/protocol.h b/drivers/usb/storage/protocol.h
index 487056ffb516..ffc3e2af0156 100644
--- a/drivers/usb/storage/protocol.h
+++ b/drivers/usb/storage/protocol.h
@@ -40,8 +40,7 @@
 #define _PROTOCOL_H_
 
 /* Protocol handling routines */
-extern void usb_stor_ATAPI_command(struct scsi_cmnd*, struct us_data*);
-extern void usb_stor_qic157_command(struct scsi_cmnd*, struct us_data*);
+extern void usb_stor_pad12_command(struct scsi_cmnd*, struct us_data*);
 extern void usb_stor_ufi_command(struct scsi_cmnd*, struct us_data*);
 extern void usb_stor_transparent_scsi_command(struct scsi_cmnd*,
                 struct us_data*);
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 09779f6a8179..2a42b862aa9f 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -59,6 +59,13 @@
 #include "transport.h"
 #include "protocol.h"
 
+/* Vendor IDs for companies that seem to include the READ CAPACITY bug
+ * in all their devices
+ */
+#define VENDOR_ID_NOKIA         0x0421
+#define VENDOR_ID_NIKON         0x04b0
+#define VENDOR_ID_MOTOROLA      0x22b8
+
 /***********************************************************************
  * Host functions 
  ***********************************************************************/
@@ -129,11 +136,35 @@ static int slave_configure(struct scsi_device *sdev)
                                               max_sectors);
         }
 
+        /* Some USB host controllers can't do DMA; they have to use PIO.
+         * They indicate this by setting their dma_mask to NULL.  For
+         * such controllers we need to make sure the block layer sets
+         * up bounce buffers in addressable memory.
+         */
+        if (!us->pusb_dev->bus->controller->dma_mask)
+                blk_queue_bounce_limit(sdev->request_queue, BLK_BOUNCE_HIGH);
+
         /* We can't put these settings in slave_alloc() because that gets
          * called before the device type is known.  Consequently these
          * settings can't be overridden via the scsi devinfo mechanism. */
         if (sdev->type == TYPE_DISK) {
 
+                /* Some vendors seem to put the READ CAPACITY bug into
+                 * all their devices -- primarily makers of cell phones
+                 * and digital cameras.  Since these devices always use
+                 * flash media and can be expected to have an even number
+                 * of sectors, we will always enable the CAPACITY_HEURISTICS
+                 * flag unless told otherwise. */
+                switch (le16_to_cpu(us->pusb_dev->descriptor.idVendor)) {
+                case VENDOR_ID_NOKIA:
+                case VENDOR_ID_NIKON:
+                case VENDOR_ID_MOTOROLA:
+                        if (!(us->fflags & (US_FL_FIX_CAPACITY |
+                                        US_FL_CAPACITY_OK)))
+                                us->fflags |= US_FL_CAPACITY_HEURISTICS;
+                        break;
+                }
+
                 /* Disk-type devices use MODE SENSE(6) if the protocol
                  * (SubClass) is Transparent SCSI, otherwise they use
                  * MODE SENSE(10). */
@@ -170,6 +201,10 @@ static int slave_configure(struct scsi_device *sdev)
                 if (us->fflags & US_FL_CAPACITY_HEURISTICS)
                         sdev->guess_capacity = 1;
 
+                /* assume SPC3 or latter devices support sense size > 18 */
+                if (sdev->scsi_level > SCSI_SPC_2)
+                        us->fflags |= US_FL_SANE_SENSE;
+
                 /* Some devices report a SCSI revision level above 2 but are
                  * unable to handle the REPORT LUNS command (for which
                  * support is mandatory at level 3).  Since we already have
@@ -196,6 +231,14 @@ static int slave_configure(struct scsi_device *sdev)
                  * sector in a larger then 1 sector read, since the performance
                  * impact is negible we set this flag for all USB disks */
                 sdev->last_sector_bug = 1;
+
+                /* Enable last-sector hacks for single-target devices using
+                 * the Bulk-only transport, unless we already know the
+                 * capacity will be decremented or is correct. */
+                if (!(us->fflags & (US_FL_FIX_CAPACITY | US_FL_CAPACITY_OK |
+                                        US_FL_SCM_MULT_TARG)) &&
+                                us->protocol == US_PR_BULK)
+                        us->use_last_sector_hacks = 1;
         } else {
 
                 /* Non-disk-type devices don't need to blacklist any pages
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index c5a54b872c24..531ae5c5abf3 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -45,6 +45,7 @@
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
 
 #include "usb.h"
 #include "transport.h"
@@ -1446,6 +1447,48 @@ usb_stor_sddr09_dpcm_init(struct us_data *us) {
 }
 
 /*
+ * Transport for the Microtech DPCM-USB
+ */
+int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us)
+{
+        int ret;
+
+        US_DEBUGP("dpcm_transport: LUN=%d\n", srb->device->lun);
+
+        switch (srb->device->lun) {
+        case 0:
+
+                /*
+                 * LUN 0 corresponds to the CompactFlash card reader.
+                 */
+                ret = usb_stor_CB_transport(srb, us);
+                break;
+
+        case 1:
+
+                /*
+                 * LUN 1 corresponds to the SmartMedia card reader.
+                 */
+
+                /*
+                 * Set the LUN to 0 (just in case).
+                 */
+                srb->device->lun = 0;
+                ret = sddr09_transport(srb, us);
+                srb->device->lun = 1;
+                break;
+
+        default:
+                US_DEBUGP("dpcm_transport: Invalid LUN %d\n",
+                                srb->device->lun);
+                ret = USB_STOR_TRANSPORT_ERROR;
+                break;
+        }
+        return ret;
+}
+
+
+/*
  * Transport for the Sandisk SDDR-09
  */
 int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us)
diff --git a/drivers/usb/storage/sddr09.h b/drivers/usb/storage/sddr09.h
index e50033ad7b19..b701172e12e3 100644
--- a/drivers/usb/storage/sddr09.h
+++ b/drivers/usb/storage/sddr09.h
@@ -28,8 +28,11 @@
 /* Sandisk SDDR-09 stuff */
 
 extern int sddr09_transport(struct scsi_cmnd *srb, struct us_data *us);
+extern int usb_stor_sddr09_init(struct us_data *us);
+
+/* Microtech DPCM-USB stuff */
 
+extern int dpcm_transport(struct scsi_cmnd *srb, struct us_data *us);
 extern int usb_stor_sddr09_dpcm_init(struct us_data *us);
-extern int usb_stor_sddr09_init(struct us_data *us);
 
 #endif
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index 79108d5d3171..1d5438e6363b 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -57,6 +57,9 @@
 #include "scsiglue.h"
 #include "debug.h"
 
+#include <linux/blkdev.h>
+#include "../../scsi/sd.h"
+
 
 /***********************************************************************
  * Data transfer routines
@@ -511,6 +514,110 @@ int usb_stor_bulk_transfer_sg(struct us_data* us, unsigned int pipe,
  * Transport routines
  ***********************************************************************/
 
+/* There are so many devices that report the capacity incorrectly,
+ * this routine was written to counteract some of the resulting
+ * problems.
+ */
+static void last_sector_hacks(struct us_data *us, struct scsi_cmnd *srb)
+{
+        struct gendisk *disk;
+        struct scsi_disk *sdkp;
+        u32 sector;
+
+        /* To Report "Medium Error: Record Not Found */
+        static unsigned char record_not_found[18] = {
+                [0]     = 0x70,                 /* current error */
+                [2]     = MEDIUM_ERROR,         /* = 0x03 */
+                [7]     = 0x0a,                 /* additional length */
+                [12]    = 0x14                  /* Record Not Found */
+        };
+
+        /* If last-sector problems can't occur, whether because the
+         * capacity was already decremented or because the device is
+         * known to report the correct capacity, then we don't need
+         * to do anything.
+         */
+        if (!us->use_last_sector_hacks)
+                return;
+
+        /* Was this command a READ(10) or a WRITE(10)? */
+        if (srb->cmnd[0] != READ_10 && srb->cmnd[0] != WRITE_10)
+                goto done;
+
+        /* Did this command access the last sector? */
+        sector = (srb->cmnd[2] << 24) | (srb->cmnd[3] << 16) |
+                        (srb->cmnd[4] << 8) | (srb->cmnd[5]);
+        disk = srb->request->rq_disk;
+        if (!disk)
+                goto done;
+        sdkp = scsi_disk(disk);
+        if (!sdkp)
+                goto done;
+        if (sector + 1 != sdkp->capacity)
+                goto done;
+
+        if (srb->result == SAM_STAT_GOOD && scsi_get_resid(srb) == 0) {
+
+                /* The command succeeded.  If the capacity is odd
+                 * (i.e., if the sector number is even) then the
+                 * "always-even" heuristic would be wrong for this
+                 * device.  Issue a WARN() so that the kerneloops.org
+                 * project will be notified and we will then know to
+                 * mark the device with a CAPACITY_OK flag.  Hopefully
+                 * this will occur for only a few devices.
+                 *
+                 * Use the sign of us->last_sector_hacks to tell whether
+                 * the warning has already been issued; we don't need
+                 * more than one warning per device.
+                 */
+                if (!(sector & 1) && us->use_last_sector_hacks > 0) {
+                        unsigned vid = le16_to_cpu(
+                                        us->pusb_dev->descriptor.idVendor);
+                        unsigned pid = le16_to_cpu(
+                                        us->pusb_dev->descriptor.idProduct);
+                        unsigned rev = le16_to_cpu(
+                                        us->pusb_dev->descriptor.bcdDevice);
+
+                        WARN(1, "%s: Successful last sector success at %u, "
+                                        "device %04x:%04x:%04x\n",
+                                        sdkp->disk->disk_name, sector,
+                                        vid, pid, rev);
+                        us->use_last_sector_hacks = -1;
+                }
+
+        } else {
+                /* The command failed.  Allow up to 3 retries in case this
+                 * is some normal sort of failure.  After that, assume the
+                 * capacity is wrong and we're trying to access the sector
+                 * beyond the end.  Replace the result code and sense data
+                 * with values that will cause the SCSI core to fail the
+                 * command immediately, instead of going into an infinite
+                 * (or even just a very long) retry loop.
+                 */
+                if (++us->last_sector_retries < 3)
+                        return;
+                srb->result = SAM_STAT_CHECK_CONDITION;
+                memcpy(srb->sense_buffer, record_not_found,
+                                sizeof(record_not_found));
+
+                /* In theory we might want to issue a WARN() here if the
+                 * capacity is even, since it could indicate the device
+                 * has the READ CAPACITY bug _and_ the real capacity is
+                 * odd.  But it could also indicate that the device
+                 * simply can't access its last sector, a failure mode
+                 * which is surprisingly common.  So no warning.
+                 */
+        }
+
+ done:
+        /* Don't reset the retry counter for TEST UNIT READY commands,
+         * because they get issued after device resets which might be
+         * caused by a failed last-sector access.
+         */
+        if (srb->cmnd[0] != TEST_UNIT_READY)
+                us->last_sector_retries = 0;
+}
+
 /* Invoke the transport and basic error-handling/recovery methods
  *
  * This is used by the protocol layers to actually send the message to
@@ -544,6 +651,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         /* if the transport provided its own sense data, don't auto-sense */
         if (result == USB_STOR_TRANSPORT_NO_SENSE) {
                 srb->result = SAM_STAT_CHECK_CONDITION;
+                last_sector_hacks(us, srb);
                 return;
         }
 
@@ -579,6 +687,20 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         }
 
         /*
+         * Determine if this device is SAT by seeing if the
+         * command executed successfully.  Otherwise we'll have
+         * to wait for at least one CHECK_CONDITION to determine
+         * SANE_SENSE support
+         */
+        if ((srb->cmnd[0] == ATA_16 || srb->cmnd[0] == ATA_12) &&
+            result == USB_STOR_TRANSPORT_GOOD &&
+            !(us->fflags & US_FL_SANE_SENSE) &&
+            !(srb->cmnd[2] & 0x20)) {
+                US_DEBUGP("-- SAT supported, increasing auto-sense\n");
+                us->fflags |= US_FL_SANE_SENSE;
+        }
+
+        /*
          * A short transfer on a command where we don't expect it
          * is unusual, but it doesn't mean we need to auto-sense.
          */
@@ -595,10 +717,15 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
         if (need_auto_sense) {
                 int temp_result;
                 struct scsi_eh_save ses;
+                int sense_size = US_SENSE_SIZE;
+
+                /* device supports and needs bigger sense buffer */
+                if (us->fflags & US_FL_SANE_SENSE)
+                        sense_size = ~0;
 
                 US_DEBUGP("Issuing auto-REQUEST_SENSE\n");
 
-                scsi_eh_prep_cmnd(srb, &ses, NULL, 0, US_SENSE_SIZE);
+                scsi_eh_prep_cmnd(srb, &ses, NULL, 0, sense_size);
 
                 /* FIXME: we must do the protocol translation here */
                 if (us->subclass == US_SC_RBC || us->subclass == US_SC_SCSI ||
@@ -632,6 +759,25 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                         return;
                 }
 
+                /* If the sense data returned is larger than 18-bytes then we
+                 * assume this device supports requesting more in the future.
+                 * The response code must be 70h through 73h inclusive.
+                 */
+                if (srb->sense_buffer[7] > (US_SENSE_SIZE - 8) &&
+                    !(us->fflags & US_FL_SANE_SENSE) &&
+                    (srb->sense_buffer[0] & 0x7C) == 0x70) {
+                        US_DEBUGP("-- SANE_SENSE support enabled\n");
+                        us->fflags |= US_FL_SANE_SENSE;
+
+                        /* Indicate to the user that we truncated their sense
+                         * because we didn't know it supported larger sense.
+                         */
+                        US_DEBUGP("-- Sense data truncated to %i from %i\n",
+                                  US_SENSE_SIZE,
+                                  srb->sense_buffer[7] + 8);
+                        srb->sense_buffer[7] = (US_SENSE_SIZE - 8);
+                }
+
                 US_DEBUGP("-- Result from auto-sense is %d\n", temp_result);
                 US_DEBUGP("-- code: 0x%x, key: 0x%x, ASC: 0x%x, ASCQ: 0x%x\n",
                           srb->sense_buffer[0],
@@ -667,6 +813,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                         scsi_bufflen(srb) - scsi_get_resid(srb) < srb->underflow)
                 srb->result = (DID_ERROR << 16) | (SUGGEST_RETRY << 24);
 
+        last_sector_hacks(us, srb);
         return;
 
         /* Error and abort processing: try to resynchronize with the device
@@ -694,6 +841,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 us->transport_reset(us);
         }
         clear_bit(US_FLIDX_RESETTING, &us->dflags);
+        last_sector_hacks(us, srb);
 }
 
 /* Stop the current URB transfer */
@@ -718,10 +866,10 @@ void usb_stor_stop_transport(struct us_data *us)
 }
 
 /*
- * Control/Bulk/Interrupt transport
+ * Control/Bulk and Control/Bulk/Interrupt transport
  */
 
-int usb_stor_CBI_transport(struct scsi_cmnd *srb, struct us_data *us)
+int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
 {
         unsigned int transfer_length = scsi_bufflen(srb);
         unsigned int pipe = 0;
@@ -763,6 +911,13 @@ int usb_stor_CBI_transport(struct scsi_cmnd *srb, struct us_data *us)
         }
 
         /* STATUS STAGE */
+
+        /* NOTE: CB does not have a status stage.  Silly, I know.  So
+         * we have to catch this at a higher level.
+         */
+        if (us->protocol != US_PR_CBI)
+                return USB_STOR_TRANSPORT_GOOD;
+
         result = usb_stor_intr_transfer(us, us->iobuf, 2);
         US_DEBUGP("Got interrupt data (0x%x, 0x%x)\n", 
                         us->iobuf[0], us->iobuf[1]);
@@ -817,56 +972,6 @@ int usb_stor_CBI_transport(struct scsi_cmnd *srb, struct us_data *us)
 }
 
 /*
- * Control/Bulk transport
- */
-int usb_stor_CB_transport(struct scsi_cmnd *srb, struct us_data *us)
-{
-        unsigned int transfer_length = scsi_bufflen(srb);
-        int result;
-
-        /* COMMAND STAGE */
-        /* let's send the command via the control pipe */
-        result = usb_stor_ctrl_transfer(us, us->send_ctrl_pipe,
-                                      US_CBI_ADSC, 
-                                      USB_TYPE_CLASS | USB_RECIP_INTERFACE, 0, 
-                                      us->ifnum, srb->cmnd, srb->cmd_len);
-
-        /* check the return code for the command */
-        US_DEBUGP("Call to usb_stor_ctrl_transfer() returned %d\n", result);
-
-        /* if we stalled the command, it means command failed */
-        if (result == USB_STOR_XFER_STALLED) {
-                return USB_STOR_TRANSPORT_FAILED;
-        }
-
-        /* Uh oh... serious problem here */
-        if (result != USB_STOR_XFER_GOOD) {
-                return USB_STOR_TRANSPORT_ERROR;
-        }
-
-        /* DATA STAGE */
-        /* transfer the data payload for this command, if one exists*/
-        if (transfer_length) {
-                unsigned int pipe = srb->sc_data_direction == DMA_FROM_DEVICE ? 
-                                us->recv_bulk_pipe : us->send_bulk_pipe;
-                result = usb_stor_bulk_srb(us, pipe, srb);
-                US_DEBUGP("CB data stage result is 0x%x\n", result);
-
-                /* if we stalled the data transfer it means command failed */
-                if (result == USB_STOR_XFER_STALLED)
-                        return USB_STOR_TRANSPORT_FAILED;
-                if (result > USB_STOR_XFER_STALLED)
-                        return USB_STOR_TRANSPORT_ERROR;
-        }
-
-        /* STATUS STAGE */
-        /* NOTE: CB does not have a status stage.  Silly, I know.  So
-         * we have to catch this at a higher level.
-         */
-        return USB_STOR_TRANSPORT_GOOD;
-}
-
-/*
  * Bulk only transport
  */
 
@@ -1173,10 +1278,9 @@ int usb_stor_Bulk_reset(struct us_data *us)
  */
 int usb_stor_port_reset(struct us_data *us)
 {
-        int result, rc_lock;
+        int result;
 
-        result = rc_lock =
-                usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
+        result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
         if (result < 0)
                 US_DEBUGP("unable to lock device for reset: %d\n", result);
         else {
@@ -1189,8 +1293,7 @@ int usb_stor_port_reset(struct us_data *us)
                         US_DEBUGP("usb_reset_device returns %d\n",
                                         result);
                 }
-                if (rc_lock)
-                        usb_unlock_device(us->pusb_dev);
+                usb_unlock_device(us->pusb_dev);
         }
         return result;
 }
diff --git a/drivers/usb/storage/transport.h b/drivers/usb/storage/transport.h
index e70b88182f0e..242ff5e791a5 100644
--- a/drivers/usb/storage/transport.h
+++ b/drivers/usb/storage/transport.h
@@ -113,8 +113,6 @@ struct bulk_cs_wrap {
 
 #define US_CBI_ADSC             0
 
-extern int usb_stor_CBI_transport(struct scsi_cmnd *, struct us_data*);
-
 extern int usb_stor_CB_transport(struct scsi_cmnd *, struct us_data*);
 extern int usb_stor_CB_reset(struct us_data*);
 
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index bfcc1fe82518..a7f9513fa19d 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -27,7 +27,8 @@
 
 /* IMPORTANT NOTE: This file must be included in another file which does
  * the following thing for it to work:
- * The macro UNUSUAL_DEV() must be defined before this file is included
+ * The UNUSUAL_DEV, COMPLIANT_DEV, and USUAL_DEV macros must be defined
+ * before this file is included.
  */
 
 /* If you edit this file, please try to keep it sorted first by VendorID,
@@ -46,6 +47,12 @@
  * <usb-storage@lists.one-eyed-alien.net>
  */
 
+/* Note: If you add an entry only in order to set the CAPACITY_OK flag,
+ * use the COMPLIANT_DEV macro instead of UNUSUAL_DEV.  This is
+ * because such entries mark devices which actually work correctly,
+ * as opposed to devices that do something strangely or wrongly.
+ */
+
 /* patch submitted by Vivian Bregier <Vivian.Bregier@imag.fr>
  */
 UNUSUAL_DEV(  0x03eb, 0x2002, 0x0100, 0x0100,
@@ -85,6 +92,13 @@ UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001,
                 US_SC_8070, US_PR_USBAT, init_usbat_cd, 0),
 #endif
 
+/* Reported by Ben Efros <ben@pc-doctor.com> */
+UNUSUAL_DEV(  0x03f0, 0x070c, 0x0000, 0x0000,
+                "HP",
+                "Personal Media Drive",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SANE_SENSE ),
+
 /* Reported by Grant Grundler <grundler@parisc-linux.org>
  * HP r707 camera in "Disk" mode with 2.00.23 or 2.00.24 firmware.
  */
@@ -160,34 +174,6 @@ UNUSUAL_DEV(  0x0421, 0x0019, 0x0592, 0x0592,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
-/* Reported by Filip Joelsson <filip@blueturtle.nu> */
-UNUSUAL_DEV(  0x0421, 0x005d, 0x0001, 0x0600,
-                "Nokia",
-                "Nokia 3110c",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
-/* Reported by Ozan Sener <themgzzy@gmail.com> */
-UNUSUAL_DEV(  0x0421, 0x0060, 0x0551, 0x0551,
-                "Nokia",
-                "3500c",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
-/* Reported by CSECSY Laszlo <boobaa@frugalware.org> */
-UNUSUAL_DEV(  0x0421, 0x0063, 0x0001, 0x0601,
-                "Nokia",
-                "Nokia 3109c",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
-/* Patch for Nokia 5310 capacity */
-UNUSUAL_DEV(  0x0421, 0x006a, 0x0000, 0x0701,
-                "Nokia",
-                "5310",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
 /* Reported by Mario Rettig <mariorettig@web.de> */
 UNUSUAL_DEV(  0x0421, 0x042e, 0x0100, 0x0100,
                 "Nokia",
@@ -253,35 +239,6 @@ UNUSUAL_DEV(  0x0421, 0x0495, 0x0370, 0x0370,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_MAX_SECTORS_64 ),
 
-/* Reported by Cedric Godin <cedric@belbone.be> */
-UNUSUAL_DEV(  0x0421, 0x04b9, 0x0500, 0x0551,
-                "Nokia",
-                "5300",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
-/* Reported by Richard Nauber <RichardNauber@web.de> */
-UNUSUAL_DEV(  0x0421, 0x04fa, 0x0550, 0x0660,
-                "Nokia",
-                "6300",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY ),
-
-/* Patch for Nokia 5310 capacity */
-UNUSUAL_DEV(  0x0421, 0x006a, 0x0000, 0x0591,
-        "Nokia",
-        "5310",
-        US_SC_DEVICE, US_PR_DEVICE, NULL,
-        US_FL_FIX_CAPACITY ),
-
-/* Submitted by Ricky Wong Yung Fei <evilbladewarrior@gmail.com> */
-/* Nokia 7610 Supernova - Too many sectors reported in usb storage mode */
-UNUSUAL_DEV(  0x0421, 0x00f5, 0x0000, 0x0470,
-        "Nokia",
-        "7610 Supernova",
-        US_SC_DEVICE, US_PR_DEVICE, NULL,
-        US_FL_FIX_CAPACITY ),
-
 /* Reported by Olaf Hering <olh@suse.de> from novell bug #105878 */
 UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
                 "SMSC",
@@ -289,11 +246,17 @@ UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_SINGLE_LUN ),
 
-#ifdef CONFIG_USB_STORAGE_DPCM
+#ifdef CONFIG_USB_STORAGE_SDDR09
 UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate (DPCM_USB)",
                 US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ),
+#else
+UNUSUAL_DEV(  0x0436, 0x0005, 0x0100, 0x0100,
+                "Microtech",
+                "CameraMate",
+                US_SC_SCSI, US_PR_CB, NULL,
+                US_FL_SINGLE_LUN ),
 #endif
 
 /* Patch submitted by Daniel Drake <dsd@gentoo.org>
@@ -388,6 +351,15 @@ UNUSUAL_DEV(  0x04a4, 0x0004, 0x0001, 0x0001,
                 "DVD-CAM DZ-MV100A Camcorder",
                 US_SC_SCSI, US_PR_CB, NULL, US_FL_SINGLE_LUN),
 
+/* BENQ DC5330
+ * Reported by Manuel Fombuena <mfombuena@ya.com> and
+ * Frank Copeland <fjc@thingy.apana.org.au> */
+UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
+                "Tekom Technologies, Inc",
+                "300_CAMERA",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE ),
+
 /* Patch for Nikon coolpix 2000
  * Submitted by Fabien Cosse <fabien.cosse@wanadoo.fr>*/
 UNUSUAL_DEV(  0x04b0, 0x0301, 0x0010, 0x0010,
@@ -396,83 +368,6 @@ UNUSUAL_DEV(  0x04b0, 0x0301, 0x0010, 0x0010,
                 US_SC_DEVICE, US_PR_DEVICE,NULL,
                 US_FL_NOT_LOCKABLE ),
 
-/* Reported by Stefan de Konink <skinkie@xs4all.nl> */
-UNUSUAL_DEV(  0x04b0, 0x0401, 0x0200, 0x0200,
-                "NIKON",
-                "NIKON DSC D100",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Tobias Kunze Briseno <t-linux@fictive.com> */
-UNUSUAL_DEV(  0x04b0, 0x0403, 0x0200, 0x0200,
-                "NIKON",
-                "NIKON DSC D2H",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Milinevsky Dmitry <niam.niam@gmail.com> */
-UNUSUAL_DEV(  0x04b0, 0x0409, 0x0100, 0x0100,
-                "NIKON",
-                "NIKON DSC D50",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Andreas Bockhold <andreas@bockionline.de> */
-UNUSUAL_DEV(  0x04b0, 0x0405, 0x0100, 0x0100,
-                "NIKON",
-                "NIKON DSC D70",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Jamie Kitson <jamie@staberinde.fsnet.co.uk> */
-UNUSUAL_DEV(  0x04b0, 0x040d, 0x0100, 0x0100,
-                "NIKON",
-                "NIKON DSC D70s",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Graber and Mike Pagano <mpagano-kernel@mpagano.com> */
-UNUSUAL_DEV(  0x04b0, 0x040f, 0x0100, 0x0200,
-                "NIKON",
-                "NIKON DSC D200",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Emil Larsson <emil@swip.net> */
-UNUSUAL_DEV(  0x04b0, 0x0411, 0x0100, 0x0111,
-                "NIKON",
-                "NIKON DSC D80",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Ortwin Glueck <odi@odi.ch> */
-UNUSUAL_DEV(  0x04b0, 0x0413, 0x0110, 0x0111,
-                "NIKON",
-                "NIKON DSC D40",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Paul Check <paul@openstreet.com> */
-UNUSUAL_DEV(  0x04b0, 0x0415, 0x0100, 0x0100,
-                "NIKON",
-                "NIKON DSC D2Xs",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by Shan Destromp (shansan@gmail.com) */
-UNUSUAL_DEV(  0x04b0, 0x0417, 0x0100, 0x0100,
-                "NIKON",
-                "NIKON DSC D40X",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/* Reported by paul ready <lxtwin@homecall.co.uk> */
-UNUSUAL_DEV(  0x04b0, 0x0419, 0x0100, 0x0200,
-                "NIKON",
-                "NIKON DSC D300",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
 /* Reported by Doug Maxey (dwm@austin.ibm.com) */
 UNUSUAL_DEV(  0x04b3, 0x4001, 0x0110, 0x0110,
                 "IBM",
@@ -480,15 +375,6 @@ UNUSUAL_DEV(  0x04b3, 0x4001, 0x0110, 0x0110,
                 US_SC_DEVICE, US_PR_CB, NULL,
                 US_FL_MAX_SECTORS_MIN),
 
-/* BENQ DC5330
- * Reported by Manuel Fombuena <mfombuena@ya.com> and
- * Frank Copeland <fjc@thingy.apana.org.au> */
-UNUSUAL_DEV(  0x04a5, 0x3010, 0x0100, 0x0100,
-                "Tekom Technologies, Inc",
-                "300_CAMERA",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_IGNORE_RESIDUE ),
-
 #ifdef CONFIG_USB_STORAGE_CYPRESS_ATACB
 /* CY7C68300 : support atacb */
 UNUSUAL_DEV(  0x04b4, 0x6830, 0x0000, 0x9999,
@@ -594,6 +480,12 @@ UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
                 "eUSB SmartMedia / CompactFlash Adapter",
                 US_SC_SCSI, US_PR_DPCM_USB, usb_stor_sddr09_dpcm_init,
                 0),
+#else
+UNUSUAL_DEV(  0x04e6, 0x0005, 0x0100, 0x0208,
+                "SCM Microsystems",
+                "eUSB CompactFlash Adapter",
+                US_SC_SCSI, US_PR_CB, NULL,
+                US_FL_SINGLE_LUN),
 #endif
 
 /* Reported by Markus Demleitner <msdemlei@cl.uni-heidelberg.de> */
@@ -685,6 +577,13 @@ UNUSUAL_DEV(  0x0525, 0xa140, 0x0100, 0x0100,
                 US_SC_8070, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* Added by Alan Stern <stern@rowland.harvard.edu> */
+COMPLIANT_DEV(0x0525, 0xa4a5, 0x0000, 0x9999,
+                "Linux",
+                "File-backed Storage Gadget",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_CAPACITY_OK ),
+
 /* Yakumo Mega Image 37
  * Submitted by Stephan Fuhrmann <atomenergie@t-online.de> */
 UNUSUAL_DEV(  0x052b, 0x1801, 0x0100, 0x0100,
@@ -807,15 +706,15 @@ UNUSUAL_DEV(  0x054c, 0x006d, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
-/* Submitted by Mike Alborn <malborn@deandra.homeip.net> */
-UNUSUAL_DEV(  0x054c, 0x016a, 0x0000, 0x9999,
+/* Submitted by Frank Engel <frankie@cse.unsw.edu.au> */
+UNUSUAL_DEV(  0x054c, 0x0099, 0x0000, 0x9999,
                 "Sony",
                 "PEG Mass Storage",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
-                
-/* Submitted by Frank Engel <frankie@cse.unsw.edu.au> */
-UNUSUAL_DEV(  0x054c, 0x0099, 0x0000, 0x9999,
+
+/* Submitted by Mike Alborn <malborn@deandra.homeip.net> */
+UNUSUAL_DEV(  0x054c, 0x016a, 0x0000, 0x9999,
                 "Sony",
                 "PEG Mass Storage",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
@@ -966,6 +865,18 @@ UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
+/* Reported by Dan Williams <dcbw@redhat.com>
+ * Option N.V. mobile broadband modems
+ * Ignore driver CD mode and force into modem mode by default.
+ */
+
+/* Globetrotter HSDPA; mass storage shows up as Qualcomm for vendor */
+UNUSUAL_DEV(  0x05c6, 0x1000, 0x0000, 0x9999,
+                "Option N.V.",
+                "Mass Storage",
+                US_SC_DEVICE, US_PR_DEVICE, option_ms_init,
+                0),
+
 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
 UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
                 "Lexar",
@@ -1004,6 +915,13 @@ UNUSUAL_DEV(  0x05e3, 0x0702, 0x0000, 0xffff,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_GO_SLOW | US_FL_MAX_SECTORS_64 ),
 
+/* Reported by Ben Efros <ben@pc-doctor.com> */
+UNUSUAL_DEV(  0x05e3, 0x0723, 0x9451, 0x9451,
+                "Genesys Logic",
+                "USB to SATA",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SANE_SENSE ),
+
 /* Reported by Hanno Boeck <hanno@gmx.de>
  * Taken from the Lycoris Kernel */
 UNUSUAL_DEV(  0x0636, 0x0003, 0x0000, 0x9999,
@@ -1040,7 +958,7 @@ UNUSUAL_DEV( 0x067b, 0x2507, 0x0100, 0x0100,
                 US_FL_FIX_CAPACITY | US_FL_GO_SLOW ),
 
 /* Reported by Alex Butcher <alex.butcher@assursys.co.uk> */
-UNUSUAL_DEV( 0x067b, 0x3507, 0x0001, 0x0001,
+UNUSUAL_DEV( 0x067b, 0x3507, 0x0001, 0x0101,
                 "Prolific Technology Inc.",
                 "ATAPI-6 Bridge Controller",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
@@ -1161,11 +1079,17 @@ UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100,
                 US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
-#ifdef CONFIG_USB_STORAGE_DPCM
+#ifdef CONFIG_USB_STORAGE_SDDR09
 UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
                 "Microtech",
                 "CameraMate (DPCM_USB)",
                 US_SC_SCSI, US_PR_DPCM_USB, NULL, 0 ),
+#else
+UNUSUAL_DEV(  0x07af, 0x0006, 0x0100, 0x0100,
+                "Microtech",
+                "CameraMate",
+                US_SC_SCSI, US_PR_CB, NULL,
+                US_FL_SINGLE_LUN ),
 #endif
 
 #ifdef CONFIG_USB_STORAGE_ALAUDA
@@ -1320,6 +1244,13 @@ UNUSUAL_DEV( 0x0840, 0x0082, 0x0001, 0x0001,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
+/* Reported and patched by Nguyen Anh Quynh <aquynh@gmail.com> */
+UNUSUAL_DEV( 0x0840, 0x0084, 0x0001, 0x0001,
+                "Argosy",
+                "Storage",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
 /* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
  * Flag will support Bulk devices which use a standards-violating 32-byte
  * Command Block Wrapper. Here, the "DC2MEGA" cameras (several brands) with
@@ -1343,17 +1274,6 @@ 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",
@@ -1425,6 +1345,13 @@ UNUSUAL_DEV( 0x0a17, 0x006, 0x0000, 0xffff,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* Reported by Jaak Ristioja <Ristioja@gmail.com> */
+UNUSUAL_DEV( 0x0a17, 0x006e, 0x0100, 0x0100,
+                "Pentax",
+                "K10D",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
+
 /* These are virtual windows driver CDs, which the zd1211rw driver
  * automatically converts into WLAN devices. */
 UNUSUAL_DEV( 0x0ace, 0x2011, 0x0101, 0x0101,
@@ -1439,6 +1366,18 @@ UNUSUAL_DEV( 0x0ace, 0x20ff, 0x0101, 0x0101,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_DEVICE ),
 
+/* Reported by Dan Williams <dcbw@redhat.com>
+ * Option N.V. mobile broadband modems
+ * Ignore driver CD mode and force into modem mode by default.
+ */
+
+/* iCON 225 */
+UNUSUAL_DEV(  0x0af0, 0x6971, 0x0000, 0x9999,
+                "Option N.V.",
+                "Mass Storage",
+                US_SC_DEVICE, US_PR_DEVICE, option_ms_init,
+                0),
+
 /* Reported by F. Aben <f.aben@option.com>
  * This device (wrongly) has a vendor-specific device descriptor.
  * The entry is needed so usb-storage can bind to it's mass-storage
@@ -1449,6 +1388,13 @@ UNUSUAL_DEV( 0x0af0, 0x7401, 0x0000, 0x0000,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 0 ),
 
+/* Reported by Ben Efros <ben@pc-doctor.com> */
+UNUSUAL_DEV( 0x0bc2, 0x3010, 0x0000, 0x0000,
+                "Seagate",
+                "FreeAgent Pro",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SANE_SENSE ),
+
 #ifdef CONFIG_USB_STORAGE_ISD200
 UNUSUAL_DEV(  0x0bf6, 0xa001, 0x0100, 0x0110,
                 "ATI",
@@ -1472,6 +1418,22 @@ UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
                 US_FL_SINGLE_LUN ),
 #endif
 
+UNUSUAL_DEV(  0x0d49, 0x7310, 0x0000, 0x9999,
+                "Maxtor",
+                "USB to SATA",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SANE_SENSE),
+
+/*
+ * Pete Zaitcev <zaitcev@yahoo.com>, bz#164688.
+ * The device blatantly ignores LUN and returns 1 in GetMaxLUN.
+ */
+UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100,
+                "Unknown",
+                "Unknown",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SINGLE_LUN ),
+
 /* Submitted by: Nick Sillik <n.sillik@temple.edu>
  * Needed for OneTouch extension to usb-storage
  *
@@ -1489,16 +1451,6 @@ UNUSUAL_DEV( 0x0c0b, 0xa109, 0x0000, 0xffff,
                         0),
 #endif
 
-/*
- * Pete Zaitcev <zaitcev@yahoo.com>, bz#164688.
- * The device blatantly ignores LUN and returns 1 in GetMaxLUN.
- */
-UNUSUAL_DEV( 0x0c45, 0x1060, 0x0100, 0x0100,
-                "Unknown",
-                "Unknown",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_SINGLE_LUN ),
-
 /* Submitted by Joris Struyve <joris@struyve.be> */
 UNUSUAL_DEV( 0x0d96, 0x410a, 0x0001, 0xffff,
                 "Medion",
@@ -1516,6 +1468,13 @@ UNUSUAL_DEV(  0x0d96, 0x5200, 0x0001, 0x0200,
                 "JD 5200 z3",
                 US_SC_DEVICE, US_PR_DEVICE, NULL, US_FL_FIX_INQUIRY),
 
+/* Reported by  Jason Johnston <killean@shaw.ca> */
+UNUSUAL_DEV(  0x0dc4, 0x0073, 0x0000, 0x0000,
+                "Macpower Technology Co.LTD.",
+                "USB 2.0 3.5\" DEVICE",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY),
+
 /* Reported by Lubomir Blaha <tritol@trilogic.cz>
  * I _REALLY_ don't know what 3rd, 4th number and all defines mean, but this
  * works for me. Can anybody correct these values? (I able to test corrected
@@ -1638,13 +1597,6 @@ UNUSUAL_DEV(  0x0fce, 0xe030, 0x0000, 0x0000,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
 
-/* Reported by Ricardo Barberis <ricardo@dattatec.com> */
-UNUSUAL_DEV(  0x0fce, 0xe092, 0x0000, 0x0000,
-                "Sony Ericsson",
-                "P1i",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_IGNORE_RESIDUE ),
-
 /* Reported by Emmanuel Vasilakis <evas@forthnet.gr> */
 UNUSUAL_DEV(  0x0fce, 0xe031, 0x0000, 0x0000,
                 "Sony Ericsson",
@@ -1652,6 +1604,13 @@ UNUSUAL_DEV(  0x0fce, 0xe031, 0x0000, 0x0000,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE | US_FL_FIX_CAPACITY ),
 
+/* Reported by Ricardo Barberis <ricardo@dattatec.com> */
+UNUSUAL_DEV(  0x0fce, 0xe092, 0x0000, 0x0000,
+                "Sony Ericsson",
+                "P1i",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE ),
+
 /* Reported by Kevin Cernekee <kpc-usbdev@gelato.uiuc.edu>
  * Tested on hardware version 1.10.
  * Entry is needed only for the initializer function override.
@@ -1664,6 +1623,12 @@ UNUSUAL_DEV(  0x1019, 0x0c55, 0x0000, 0x0110,
                 US_SC_DEVICE, US_PR_DEVICE, usb_stor_ucr61s2b_init,
                 0 ),
 
+UNUSUAL_DEV(  0x1058, 0x0704, 0x0000, 0x9999,
+                "Western Digital",
+                "External HDD",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_SANE_SENSE),
+
 /* Reported by Fabio Venturi <f.venturi@tdnet.it>
  * The device reports a vendor-specific bDeviceClass.
  */
@@ -2053,10 +2018,10 @@ UNUSUAL_DEV(  0x14cd, 0x6600, 0x0201, 0x0201,
  * JMicron responds to USN and several other SCSI ioctls with a
  * residue that causes subsequent I/O requests to fail.  */
 UNUSUAL_DEV(  0x152d, 0x2329, 0x0100, 0x0100,
-                "JMicron",
-                "USB to ATA/ATAPI Bridge",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_IGNORE_RESIDUE ),
+                "JMicron",
+                "USB to ATA/ATAPI Bridge",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE | US_FL_SANE_SENSE ),
 
 /* Reported by Robert Schedel <r.schedel@yahoo.de>
  * Note: this is a 'super top' device like the above 14cd/6600 device */
@@ -2086,27 +2051,6 @@ UNUSUAL_DEV(  0x22b8, 0x3010, 0x0001, 0x0001,
                 US_FL_FIX_CAPACITY | US_FL_IGNORE_RESIDUE ),
 
 /*
- * Patch by Pete Zaitcev <zaitcev@redhat.com>
- * Report by Mark Patton. Red Hat bz#208928.
- * Added support for rev 0x0002 (Motorola ROKR W5)
- * by Javier Smaldone <javier@smaldone.com.ar>
- */
-UNUSUAL_DEV(  0x22b8, 0x4810, 0x0001, 0x0002,
-                "Motorola",
-                "RAZR V3i/ROKR W5",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/*
- * Patch by Jost Diederichs <jost@qdusa.com>
- */
-UNUSUAL_DEV(0x22b8, 0x6410, 0x0001, 0x9999,
-                "Motorola Inc.",
-                "Motorola Phone (RAZRV3xx)",
-                US_SC_DEVICE, US_PR_DEVICE, NULL,
-                US_FL_FIX_CAPACITY),
-
-/*
  * Patch by Constantin Baranov <const@tltsu.ru>
  * Report by Andreas Koenecke.
  * Motorola ROKR Z6.
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 27016fd2cad1..4becf495ca2d 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -75,9 +75,6 @@
 #ifdef CONFIG_USB_STORAGE_SDDR55
 #include "sddr55.h"
 #endif
-#ifdef CONFIG_USB_STORAGE_DPCM
-#include "dpcm.h"
-#endif
 #ifdef CONFIG_USB_STORAGE_FREECOM
 #include "freecom.h"
 #endif
@@ -103,6 +100,7 @@
 #include "cypress_atacb.h"
 #endif
 #include "sierra_ms.h"
+#include "option_ms.h"
 
 /* Some informational data */
 MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
@@ -113,6 +111,10 @@ static unsigned int delay_use = 5;
 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
 
+static char quirks[128];
+module_param_string(quirks, quirks, sizeof(quirks), S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
+
 
 /*
  * The entries in this table correspond, line for line,
@@ -126,6 +128,8 @@ MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin,bcdDeviceMax), \
   .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
 
+#define COMPLIANT_DEV   UNUSUAL_DEV
+
 #define USUAL_DEV(useProto, useTrans, useType) \
 { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
   .driver_info = (USB_US_TYPE_STOR<<24) }
@@ -134,6 +138,7 @@ static struct usb_device_id storage_usb_ids [] = {
 
 #       include "unusual_devs.h"
 #undef UNUSUAL_DEV
+#undef COMPLIANT_DEV
 #undef USUAL_DEV
         /* Terminating entry */
         { }
@@ -164,6 +169,8 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids);
         .initFunction = init_function,  \
 }
 
+#define COMPLIANT_DEV   UNUSUAL_DEV
+
 #define USUAL_DEV(use_protocol, use_transport, use_type) \
 { \
         .useProtocol = use_protocol,    \
@@ -173,6 +180,7 @@ MODULE_DEVICE_TABLE (usb, storage_usb_ids);
 static struct us_unusual_dev us_unusual_dev_list[] = {
 #       include "unusual_devs.h" 
 #       undef UNUSUAL_DEV
+#       undef COMPLIANT_DEV
 #       undef USUAL_DEV
 
         /* Terminating entry */
@@ -464,13 +472,83 @@ static int associate_dev(struct us_data *us, struct usb_interface *intf)
                 US_DEBUGP("I/O buffer allocation failed\n");
                 return -ENOMEM;
         }
+        return 0;
+}
 
-        us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
-        if (!us->sensebuf) {
-                US_DEBUGP("Sense buffer allocation failed\n");
-                return -ENOMEM;
+/* Works only for digits and letters, but small and fast */
+#define TOLOWER(x) ((x) | 0x20)
+
+/* Adjust device flags based on the "quirks=" module parameter */
+static void adjust_quirks(struct us_data *us)
+{
+        char *p;
+        u16 vid = le16_to_cpu(us->pusb_dev->descriptor.idVendor);
+        u16 pid = le16_to_cpu(us->pusb_dev->descriptor.idProduct);
+        unsigned f = 0;
+        unsigned int mask = (US_FL_SANE_SENSE | US_FL_FIX_CAPACITY |
+                        US_FL_CAPACITY_HEURISTICS | US_FL_IGNORE_DEVICE |
+                        US_FL_NOT_LOCKABLE | US_FL_MAX_SECTORS_64 |
+                        US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
+                        US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT);
+
+        p = quirks;
+        while (*p) {
+                /* Each entry consists of VID:PID:flags */
+                if (vid == simple_strtoul(p, &p, 16) &&
+                                *p == ':' &&
+                                pid == simple_strtoul(p+1, &p, 16) &&
+                                *p == ':')
+                        break;
+
+                /* Move forward to the next entry */
+                while (*p) {
+                        if (*p++ == ',')
+                                break;
+                }
         }
-        return 0;
+        if (!*p)        /* No match */
+                return;
+
+        /* Collect the flags */
+        while (*++p && *p != ',') {
+                switch (TOLOWER(*p)) {
+                case 'a':
+                        f |= US_FL_SANE_SENSE;
+                        break;
+                case 'c':
+                        f |= US_FL_FIX_CAPACITY;
+                        break;
+                case 'h':
+                        f |= US_FL_CAPACITY_HEURISTICS;
+                        break;
+                case 'i':
+                        f |= US_FL_IGNORE_DEVICE;
+                        break;
+                case 'l':
+                        f |= US_FL_NOT_LOCKABLE;
+                        break;
+                case 'm':
+                        f |= US_FL_MAX_SECTORS_64;
+                        break;
+                case 'o':
+                        f |= US_FL_CAPACITY_OK;
+                        break;
+                case 'r':
+                        f |= US_FL_IGNORE_RESIDUE;
+                        break;
+                case 's':
+                        f |= US_FL_SINGLE_LUN;
+                        break;
+                case 'w':
+                        f |= US_FL_NO_WP_DETECT;
+                        break;
+                /* Ignore unrecognized flag characters */
+                }
+        }
+        us->fflags = (us->fflags & ~mask) | f;
+        dev_info(&us->pusb_intf->dev, "Quirks match for "
+                        "vid %04x pid %04x: %x\n",
+                        vid, pid, f);
 }
 
 /* Find an unusual_dev descriptor (always succeeds in the current code) */
@@ -497,6 +575,7 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id)
                         idesc->bInterfaceProtocol :
                         unusual_dev->useTransport;
         us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
+        adjust_quirks(us);
 
         if (us->fflags & US_FL_IGNORE_DEVICE) {
                 printk(KERN_INFO USB_STORAGE "device ignored\n");
@@ -562,7 +641,7 @@ static int get_transport(struct us_data *us)
 
         case US_PR_CBI:
                 us->transport_name = "Control/Bulk/Interrupt";
-                us->transport = usb_stor_CBI_transport;
+                us->transport = usb_stor_CB_transport;
                 us->transport_reset = usb_stor_CB_reset;
                 us->max_lun = 7;
                 break;
@@ -675,19 +754,19 @@ static int get_protocol(struct us_data *us)
 
         case US_SC_8020:
                 us->protocol_name = "8020i";
-                us->proto_handler = usb_stor_ATAPI_command;
+                us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
         case US_SC_QIC:
                 us->protocol_name = "QIC-157";
-                us->proto_handler = usb_stor_qic157_command;
+                us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
         case US_SC_8070:
                 us->protocol_name = "8070i";
-                us->proto_handler = usb_stor_ATAPI_command;
+                us->proto_handler = usb_stor_pad12_command;
                 us->max_lun = 0;
                 break;
 
@@ -840,8 +919,6 @@ static void dissociate_dev(struct us_data *us)
 {
         US_DEBUGP("-- %s\n", __func__);
 
-        kfree(us->sensebuf);
-
         /* Free the device-related DMA-mapped buffers */
         if (us->cr)
                 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
@@ -1064,6 +1141,7 @@ static struct usb_driver usb_storage_driver = {
 static int __init usb_stor_init(void)
 {
         int retval;
+
         printk(KERN_INFO "Initializing USB Mass Storage driver...\n");
 
         /* register the driver, return usb_register return code if error */
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index a4ad73bd832d..65e674e4be99 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -138,7 +138,6 @@ struct us_data {
         struct usb_ctrlrequest  *cr;             /* control requests     */
         struct usb_sg_request   current_sg;      /* scatter-gather req.  */
         unsigned char           *iobuf;          /* I/O buffer           */
-        unsigned char           *sensebuf;       /* sense data buffer    */
         dma_addr_t              cr_dma;          /* buffer DMA addresses */
         dma_addr_t              iobuf_dma;
         struct task_struct      *ctl_thread;     /* the control thread   */
@@ -155,6 +154,10 @@ struct us_data {
 #ifdef CONFIG_PM
         pm_hook                 suspend_resume_hook;
 #endif
+
+        /* hacks for READ CAPACITY bug handling */
+        int                     use_last_sector_hacks;
+        int                     last_sector_retries;
 };
 
 /* Convert between us_data and the corresponding Scsi_Host */
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index 95c6fa3bf6b2..3937bf6f8cef 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -326,7 +326,7 @@ static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
 static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
                                      u32 *_buf, u16 wLength)
 {
-        u16 *buf = (u16 *) _buf;
+        __le16 *buf = (__le16 *)_buf;
 
         if (port_idx > wusbhc->ports_max)
                 return -EINVAL;