187 files changed, 7613 insertions, 5782 deletions

diff --git a/drivers/usb/atm/usbatm.h b/drivers/usb/atm/usbatm.h
index 5651231a7437..f3eecd967a8a 100644
--- a/drivers/usb/atm/usbatm.h
+++ b/drivers/usb/atm/usbatm.h
@@ -34,6 +34,7 @@
 #include <linux/stringify.h>
 #include <linux/usb.h>
 #include <linux/mutex.h>
+#include <linux/ratelimit.h>
 
 /*
 #define VERBOSE_DEBUG
@@ -59,13 +60,12 @@
         atm_printk(KERN_INFO, instance , format , ## arg)
 #define atm_warn(instance, format, arg...)      \
         atm_printk(KERN_WARNING, instance , format , ## arg)
-#define atm_dbg(instance, format, arg...)               \
-        dynamic_pr_debug("ATM dev %d: " format ,        \
-        (instance)->atm_dev->number , ## arg)
-#define atm_rldbg(instance, format, arg...)             \
-        if (printk_ratelimit())                         \
-                atm_dbg(instance , format , ## arg)
-
+#define atm_dbg(instance, format, ...)                                  \
+        pr_debug("ATM dev %d: " format,                                 \
+                 (instance)->atm_dev->number, ##__VA_ARGS__)
+#define atm_rldbg(instance, format, ...)                                \
+        pr_debug_ratelimited("ATM dev %d: " format,                     \
+                             (instance)->atm_dev->number, ##__VA_ARGS__)
 
 /* flags, set by mini-driver in bind() */
 
diff --git a/drivers/usb/c67x00/c67x00-sched.c b/drivers/usb/c67x00/c67x00-sched.c
index aa491627a45b..892cc96466eb 100644
--- a/drivers/usb/c67x00/c67x00-sched.c
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -344,7 +344,7 @@ void c67x00_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
                 /* it could happen that we reinitialize this completion, while
                  * somebody was waiting for that completion.  The timeout and
                  * while loop handle such cases, but this might be improved */
-                INIT_COMPLETION(c67x00->endpoint_disable);
+                reinit_completion(&c67x00->endpoint_disable);
                 c67x00_sched_kick(c67x00);
                 wait_for_completion_timeout(&c67x00->endpoint_disable, 1 * HZ);
 
diff --git a/drivers/usb/chipidea/Kconfig b/drivers/usb/chipidea/Kconfig
index 4a851e15e58c..77b47d82c9a6 100644
--- a/drivers/usb/chipidea/Kconfig
+++ b/drivers/usb/chipidea/Kconfig
@@ -1,6 +1,6 @@
 config USB_CHIPIDEA
         tristate "ChipIdea Highspeed Dual Role Controller"
-        depends on (USB_EHCI_HCD && USB_GADGET) || (USB_EHCI_HCD && !USB_GADGET) || (!USB_EHCI_HCD && USB_GADGET)
+        depends on ((USB_EHCI_HCD && USB_GADGET) || (USB_EHCI_HCD && !USB_GADGET) || (!USB_EHCI_HCD && USB_GADGET)) && HAS_DMA
         help
           Say Y here if your system has a dual role high speed USB
           controller based on ChipIdea silicon IP. Currently, only the
diff --git a/drivers/usb/chipidea/bits.h b/drivers/usb/chipidea/bits.h
index 464584c6ccae..a85713165688 100644
--- a/drivers/usb/chipidea/bits.h
+++ b/drivers/usb/chipidea/bits.h
@@ -48,6 +48,7 @@
 #define PORTSC_SUSP           BIT(7)
 #define PORTSC_HSP            BIT(9)
 #define PORTSC_PTC            (0x0FUL << 16)
+#define PORTSC_PHCD(d)        ((d) ? BIT(22) : BIT(23))
 /* PTS and PTW for non lpm version only */
 #define PORTSC_PTS(d)                                           \
         (u32)((((d) & 0x3) << 30) | (((d) & 0x4) ? BIT(25) : 0))
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_hdrc_imx.c
index 74d998d9b45b..bb5d976e5b81 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.c
+++ b/drivers/usb/chipidea/ci_hdrc_imx.c
@@ -108,23 +108,16 @@ static int ci_hdrc_imx_probe(struct platform_device *pdev)
         }
 
         data->phy = devm_usb_get_phy_by_phandle(&pdev->dev, "fsl,usbphy", 0);
-        if (!IS_ERR(data->phy)) {
-                ret = usb_phy_init(data->phy);
-                if (ret) {
-                        dev_err(&pdev->dev, "unable to init phy: %d\n", ret);
-                        goto err_clk;
-                }
-        } else if (PTR_ERR(data->phy) == -EPROBE_DEFER) {
-                ret = -EPROBE_DEFER;
+        if (IS_ERR(data->phy)) {
+                ret = PTR_ERR(data->phy);
                 goto err_clk;
         }
 
         pdata.phy = data->phy;
 
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err_clk;
 
         if (data->usbmisc_data) {
                 ret = imx_usbmisc_init(data->usbmisc_data);
@@ -175,10 +168,6 @@ static int ci_hdrc_imx_remove(struct platform_device *pdev)
 
         pm_runtime_disable(&pdev->dev);
         ci_hdrc_remove_device(data->ci_pdev);
-
-        if (data->phy)
-                usb_phy_shutdown(data->phy);
-
         clk_disable_unprepare(data->clk);
 
         return 0;
diff --git a/drivers/usb/chipidea/ci_hdrc_pci.c b/drivers/usb/chipidea/ci_hdrc_pci.c
index 042320a6c6c7..d514332ac081 100644
--- a/drivers/usb/chipidea/ci_hdrc_pci.c
+++ b/drivers/usb/chipidea/ci_hdrc_pci.c
@@ -129,7 +129,12 @@ static DEFINE_PCI_DEVICE_TABLE(ci_hdrc_pci_id_table) = {
                 PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0829),
                 .driver_data = (kernel_ulong_t)&penwell_pci_platdata,
         },
-        { 0, 0, 0, 0, 0, 0, 0 /* end: all zeroes */ }
+        {
+                /* Intel Clovertrail */
+                PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe006),
+                .driver_data = (kernel_ulong_t)&penwell_pci_platdata,
+        },
+        { 0 } /* end: all zeroes */
 };
 MODULE_DEVICE_TABLE(pci, ci_hdrc_pci_id_table);
 
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 94626409559a..5d8981c5235e 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -172,6 +172,27 @@ u8 hw_port_test_get(struct ci_hdrc *ci)
         return hw_read(ci, OP_PORTSC, PORTSC_PTC) >> __ffs(PORTSC_PTC);
 }
 
+/* The PHY enters/leaves low power mode */
+static void ci_hdrc_enter_lpm(struct ci_hdrc *ci, bool enable)
+{
+        enum ci_hw_regs reg = ci->hw_bank.lpm ? OP_DEVLC : OP_PORTSC;
+        bool lpm = !!(hw_read(ci, reg, PORTSC_PHCD(ci->hw_bank.lpm)));
+
+        if (enable && !lpm) {
+                hw_write(ci, reg, PORTSC_PHCD(ci->hw_bank.lpm),
+                                PORTSC_PHCD(ci->hw_bank.lpm));
+        } else  if (!enable && lpm) {
+                hw_write(ci, reg, PORTSC_PHCD(ci->hw_bank.lpm),
+                                0);
+                /* 
+                 * The controller needs at least 1ms to reflect
+                 * PHY's status, the PHY also needs some time (less
+                 * than 1ms) to leave low power mode.
+                 */
+                usleep_range(1500, 2000);
+        }
+}
+
 static int hw_device_init(struct ci_hdrc *ci, void __iomem *base)
 {
         u32 reg;
@@ -199,6 +220,8 @@ static int hw_device_init(struct ci_hdrc *ci, void __iomem *base)
         if (ci->hw_ep_max > ENDPT_MAX)
                 return -ENODEV;
 
+        ci_hdrc_enter_lpm(ci, false);
+
         /* Disable all interrupts bits */
         hw_write(ci, OP_USBINTR, 0xffffffff, 0);
 
@@ -369,16 +392,28 @@ static irqreturn_t ci_irq(int irq, void *data)
 static int ci_get_platdata(struct device *dev,
                 struct ci_hdrc_platform_data *platdata)
 {
-        /* Get the vbus regulator */
-        platdata->reg_vbus = devm_regulator_get(dev, "vbus");
-        if (PTR_ERR(platdata->reg_vbus) == -EPROBE_DEFER) {
-                return -EPROBE_DEFER;
-        } else if (PTR_ERR(platdata->reg_vbus) == -ENODEV) {
-                platdata->reg_vbus = NULL; /* no vbus regualator is needed */
-        } else if (IS_ERR(platdata->reg_vbus)) {
-                dev_err(dev, "Getting regulator error: %ld\n",
-                        PTR_ERR(platdata->reg_vbus));
-                return PTR_ERR(platdata->reg_vbus);
+        if (!platdata->phy_mode)
+                platdata->phy_mode = of_usb_get_phy_mode(dev->of_node);
+
+        if (!platdata->dr_mode)
+                platdata->dr_mode = of_usb_get_dr_mode(dev->of_node);
+
+        if (platdata->dr_mode == USB_DR_MODE_UNKNOWN)
+                platdata->dr_mode = USB_DR_MODE_OTG;
+
+        if (platdata->dr_mode != USB_DR_MODE_PERIPHERAL) {
+                /* Get the vbus regulator */
+                platdata->reg_vbus = devm_regulator_get(dev, "vbus");
+                if (PTR_ERR(platdata->reg_vbus) == -EPROBE_DEFER) {
+                        return -EPROBE_DEFER;
+                } else if (PTR_ERR(platdata->reg_vbus) == -ENODEV) {
+                        /* no vbus regualator is needed */
+                        platdata->reg_vbus = NULL;
+                } else if (IS_ERR(platdata->reg_vbus)) {
+                        dev_err(dev, "Getting regulator error: %ld\n",
+                                PTR_ERR(platdata->reg_vbus));
+                        return PTR_ERR(platdata->reg_vbus);
+                }
         }
 
         return 0;
@@ -465,6 +500,33 @@ static void ci_get_otg_capable(struct ci_hdrc *ci)
         }
 }
 
+static int ci_usb_phy_init(struct ci_hdrc *ci)
+{
+        if (ci->platdata->phy) {
+                ci->transceiver = ci->platdata->phy;
+                return usb_phy_init(ci->transceiver);
+        } else {
+                ci->global_phy = true;
+                ci->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
+                if (IS_ERR(ci->transceiver))
+                        ci->transceiver = NULL;
+
+                return 0;
+        }
+}
+
+static void ci_usb_phy_destroy(struct ci_hdrc *ci)
+{
+        if (!ci->transceiver)
+                return;
+
+        otg_set_peripheral(ci->transceiver->otg, NULL);
+        if (ci->global_phy)
+                usb_put_phy(ci->transceiver);
+        else
+                usb_phy_shutdown(ci->transceiver);
+}
+
 static int ci_hdrc_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
@@ -473,7 +535,6 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         void __iomem    *base;
         int             ret;
         enum usb_dr_mode dr_mode;
-        struct device_node *of_node = dev->of_node ?: dev->parent->of_node;
 
         if (!dev->platform_data) {
                 dev_err(dev, "platform data missing\n");
@@ -493,10 +554,6 @@ static int ci_hdrc_probe(struct platform_device *pdev)
 
         ci->dev = dev;
         ci->platdata = dev->platform_data;
-        if (ci->platdata->phy)
-                ci->transceiver = ci->platdata->phy;
-        else
-                ci->global_phy = true;
 
         ret = hw_device_init(ci, base);
         if (ret < 0) {
@@ -504,27 +561,25 @@ static int ci_hdrc_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
+        ret = ci_usb_phy_init(ci);
+        if (ret) {
+                dev_err(dev, "unable to init phy: %d\n", ret);
+                return ret;
+        }
+
         ci->hw_bank.phys = res->start;
 
         ci->irq = platform_get_irq(pdev, 0);
         if (ci->irq < 0) {
                 dev_err(dev, "missing IRQ\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto destroy_phy;
         }
 
         ci_get_otg_capable(ci);
 
-        if (!ci->platdata->phy_mode)
-                ci->platdata->phy_mode = of_usb_get_phy_mode(of_node);
-
         hw_phymode_configure(ci);
 
-        if (!ci->platdata->dr_mode)
-                ci->platdata->dr_mode = of_usb_get_dr_mode(of_node);
-
-        if (ci->platdata->dr_mode == USB_DR_MODE_UNKNOWN)
-                ci->platdata->dr_mode = USB_DR_MODE_OTG;
-
         dr_mode = ci->platdata->dr_mode;
         /* initialize role(s) before the interrupt is requested */
         if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) {
@@ -537,11 +592,23 @@ static int ci_hdrc_probe(struct platform_device *pdev)
                 ret = ci_hdrc_gadget_init(ci);
                 if (ret)
                         dev_info(dev, "doesn't support gadget\n");
+                if (!ret && ci->transceiver) {
+                        ret = otg_set_peripheral(ci->transceiver->otg,
+                                                        &ci->gadget);
+                        /*
+                         * If we implement all USB functions using chipidea drivers,
+                         * it doesn't need to call above API, meanwhile, if we only
+                         * use gadget function, calling above API is useless.
+                         */
+                        if (ret && ret != -ENOTSUPP)
+                                goto destroy_phy;
+                }
         }
 
         if (!ci->roles[CI_ROLE_HOST] && !ci->roles[CI_ROLE_GADGET]) {
                 dev_err(dev, "no supported roles\n");
-                return -ENODEV;
+                ret = -ENODEV;
+                goto destroy_phy;
         }
 
         if (ci->is_otg) {
@@ -594,6 +661,8 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         free_irq(ci->irq, ci);
 stop:
         ci_role_destroy(ci);
+destroy_phy:
+        ci_usb_phy_destroy(ci);
 
         return ret;
 }
@@ -605,6 +674,9 @@ static int ci_hdrc_remove(struct platform_device *pdev)
         dbg_remove_files(ci);
         free_irq(ci->irq, ci);
         ci_role_destroy(ci);
+        ci_hdrc_enter_lpm(ci, true);
+        ci_usb_phy_destroy(ci);
+        kfree(ci->hw_bank.regmap);
 
         return 0;
 }
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index 6f96795dd20c..59e6020ea753 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -100,16 +100,18 @@ static void host_stop(struct ci_hdrc *ci)
 {
         struct usb_hcd *hcd = ci->hcd;
 
-        usb_remove_hcd(hcd);
-        usb_put_hcd(hcd);
-        if (ci->platdata->reg_vbus)
-                regulator_disable(ci->platdata->reg_vbus);
+        if (hcd) {
+                usb_remove_hcd(hcd);
+                usb_put_hcd(hcd);
+                if (ci->platdata->reg_vbus)
+                        regulator_disable(ci->platdata->reg_vbus);
+        }
 }
 
 
 void ci_hdrc_host_destroy(struct ci_hdrc *ci)
 {
-        if (ci->role == CI_ROLE_HOST)
+        if (ci->role == CI_ROLE_HOST && ci->hcd)
                 host_stop(ci);
 }
 
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index 6b4c2f2eb946..b34c81969cba 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -20,7 +20,6 @@
 #include <linux/pm_runtime.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
-#include <linux/usb/otg.h>
 #include <linux/usb/chipidea.h>
 
 #include "ci.h"
@@ -686,9 +685,6 @@ static int _gadget_stop_activity(struct usb_gadget *gadget)
         usb_ep_fifo_flush(&ci->ep0out->ep);
         usb_ep_fifo_flush(&ci->ep0in->ep);
 
-        if (ci->driver)
-                ci->driver->disconnect(gadget);
-
         /* make sure to disable all endpoints */
         gadget_for_each_ep(ep, gadget) {
                 usb_ep_disable(ep);
@@ -718,6 +714,11 @@ __acquires(ci->lock)
         int retval;
 
         spin_unlock(&ci->lock);
+        if (ci->gadget.speed != USB_SPEED_UNKNOWN) {
+                if (ci->driver)
+                        ci->driver->disconnect(&ci->gadget);
+        }
+
         retval = _gadget_stop_activity(&ci->gadget);
         if (retval)
                 goto done;
@@ -1461,6 +1462,8 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                         hw_device_state(ci, ci->ep0out->qh.dma);
                         dev_dbg(ci->dev, "Connected to host\n");
                 } else {
+                        if (ci->driver)
+                                ci->driver->disconnect(&ci->gadget);
                         hw_device_state(ci, 0);
                         if (ci->platdata->notify_event)
                                 ci->platdata->notify_event(ci,
@@ -1600,6 +1603,8 @@ static void destroy_eps(struct ci_hdrc *ci)
         for (i = 0; i < ci->hw_ep_max; i++) {
                 struct ci_hw_ep *hwep = &ci->ci_hw_ep[i];
 
+                if (hwep->pending_td)
+                        free_pending_td(hwep);
                 dma_pool_free(ci->qh_pool, hwep->qh.ptr, hwep->qh.dma);
         }
 }
@@ -1631,23 +1636,22 @@ static int ci_udc_start(struct usb_gadget *gadget,
         retval = usb_ep_enable(&ci->ep0in->ep);
         if (retval)
                 return retval;
-        spin_lock_irqsave(&ci->lock, flags);
 
         ci->driver = driver;
         pm_runtime_get_sync(&ci->gadget.dev);
         if (ci->vbus_active) {
+                spin_lock_irqsave(&ci->lock, flags);
                 hw_device_reset(ci, USBMODE_CM_DC);
         } else {
                 pm_runtime_put_sync(&ci->gadget.dev);
-                goto done;
+                return retval;
         }
 
         retval = hw_device_state(ci, ci->ep0out->qh.dma);
+        spin_unlock_irqrestore(&ci->lock, flags);
         if (retval)
                 pm_runtime_put_sync(&ci->gadget.dev);
 
- done:
-        spin_unlock_irqrestore(&ci->lock, flags);
         return retval;
 }
 
@@ -1667,13 +1671,13 @@ static int ci_udc_stop(struct usb_gadget *gadget,
                 if (ci->platdata->notify_event)
                         ci->platdata->notify_event(ci,
                         CI_HDRC_CONTROLLER_STOPPED_EVENT);
-                ci->driver = NULL;
                 spin_unlock_irqrestore(&ci->lock, flags);
                 _gadget_stop_activity(&ci->gadget);
                 spin_lock_irqsave(&ci->lock, flags);
                 pm_runtime_put(&ci->gadget.dev);
         }
 
+        ci->driver = NULL;
         spin_unlock_irqrestore(&ci->lock, flags);
 
         return 0;
@@ -1784,34 +1788,9 @@ static int udc_start(struct ci_hdrc *ci)
 
         ci->gadget.ep0 = &ci->ep0in->ep;
 
-        if (ci->global_phy) {
-                ci->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
-                if (IS_ERR(ci->transceiver))
-                        ci->transceiver = NULL;
-        }
-
-        if (ci->platdata->flags & CI_HDRC_REQUIRE_TRANSCEIVER) {
-                if (ci->transceiver == NULL) {
-                        retval = -ENODEV;
-                        goto destroy_eps;
-                }
-        }
-
-        if (ci->transceiver) {
-                retval = otg_set_peripheral(ci->transceiver->otg,
-                                                &ci->gadget);
-                /*
-                 * If we implement all USB functions using chipidea drivers,
-                 * it doesn't need to call above API, meanwhile, if we only
-                 * use gadget function, calling above API is useless.
-                 */
-                if (retval && retval != -ENOTSUPP)
-                        goto put_transceiver;
-        }
-
         retval = usb_add_gadget_udc(dev, &ci->gadget);
         if (retval)
-                goto remove_trans;
+                goto destroy_eps;
 
         pm_runtime_no_callbacks(&ci->gadget.dev);
         pm_runtime_enable(&ci->gadget.dev);
@@ -1821,17 +1800,6 @@ static int udc_start(struct ci_hdrc *ci)
 
         return retval;
 
-remove_trans:
-        if (ci->transceiver) {
-                otg_set_peripheral(ci->transceiver->otg, NULL);
-                if (ci->global_phy)
-                        usb_put_phy(ci->transceiver);
-        }
-
-        dev_err(dev, "error = %i\n", retval);
-put_transceiver:
-        if (ci->transceiver && ci->global_phy)
-                usb_put_phy(ci->transceiver);
 destroy_eps:
         destroy_eps(ci);
 free_pools:
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index d3318a0df8ee..4d387596f3f0 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -101,6 +101,7 @@ struct wdm_device {
         struct work_struct      rxwork;
         int                     werr;
         int                     rerr;
+        int                     resp_count;
 
         struct list_head        device_list;
         int                     (*manage_power)(struct usb_interface *, int);
@@ -253,6 +254,10 @@ static void wdm_int_callback(struct urb *urb)
                         "NOTIFY_NETWORK_CONNECTION %s network",
                         dr->wValue ? "connected to" : "disconnected from");
                 goto exit;
+        case USB_CDC_NOTIFY_SPEED_CHANGE:
+                dev_dbg(&desc->intf->dev, "SPEED_CHANGE received (len %u)",
+                        urb->actual_length);
+                goto exit;
         default:
                 clear_bit(WDM_POLL_RUNNING, &desc->flags);
                 dev_err(&desc->intf->dev,
@@ -262,9 +267,9 @@ static void wdm_int_callback(struct urb *urb)
         }
 
         spin_lock(&desc->iuspin);
-        clear_bit(WDM_READ, &desc->flags);
         responding = test_and_set_bit(WDM_RESPONDING, &desc->flags);
-        if (!responding && !test_bit(WDM_DISCONNECTING, &desc->flags)
+        if (!desc->resp_count++ && !responding
+                && !test_bit(WDM_DISCONNECTING, &desc->flags)
                 && !test_bit(WDM_SUSPENDING, &desc->flags)) {
                 rv = usb_submit_urb(desc->response, GFP_ATOMIC);
                 dev_dbg(&desc->intf->dev, "%s: usb_submit_urb %d",
@@ -521,10 +526,36 @@ retry:
 
         desc->length -= cntr;
         /* in case we had outstanding data */
-        if (!desc->length)
+        if (!desc->length) {
                 clear_bit(WDM_READ, &desc->flags);
 
-        spin_unlock_irq(&desc->iuspin);
+                if (--desc->resp_count) {
+                        set_bit(WDM_RESPONDING, &desc->flags);
+                        spin_unlock_irq(&desc->iuspin);
+
+                        rv = usb_submit_urb(desc->response, GFP_KERNEL);
+                        if (rv) {
+                                dev_err(&desc->intf->dev,
+                                        "%s: usb_submit_urb failed with result %d\n",
+                                        __func__, rv);
+                                spin_lock_irq(&desc->iuspin);
+                                clear_bit(WDM_RESPONDING, &desc->flags);
+                                spin_unlock_irq(&desc->iuspin);
+
+                                if (rv == -ENOMEM) {
+                                        rv = schedule_work(&desc->rxwork);
+                                        if (rv)
+                                                dev_err(&desc->intf->dev, "Cannot schedule work\n");
+                                } else {
+                                        spin_lock_irq(&desc->iuspin);
+                                        desc->resp_count = 0;
+                                        spin_unlock_irq(&desc->iuspin);
+                                }
+                        }
+                } else
+                        spin_unlock_irq(&desc->iuspin);
+        } else
+                spin_unlock_irq(&desc->iuspin);
 
         rv = cntr;
 
@@ -635,6 +666,9 @@ static int wdm_release(struct inode *inode, struct file *file)
                 if (!test_bit(WDM_DISCONNECTING, &desc->flags)) {
                         dev_dbg(&desc->intf->dev, "wdm_release: cleanup");
                         kill_urbs(desc);
+                        spin_lock_irq(&desc->iuspin);
+                        desc->resp_count = 0;
+                        spin_unlock_irq(&desc->iuspin);
                         desc->manage_power(desc->intf, 0);
                 } else {
                         /* must avoid dev_printk here as desc->intf is invalid */
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 737e3c19967b..967152a63bd3 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -742,6 +742,22 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype,
                 if ((index & ~USB_DIR_IN) == 0)
                         return 0;
                 ret = findintfep(ps->dev, index);
+                if (ret < 0) {
+                        /*
+                         * Some not fully compliant Win apps seem to get
+                         * index wrong and have the endpoint number here
+                         * rather than the endpoint address (with the
+                         * correct direction). Win does let this through,
+                         * so we'll not reject it here but leave it to
+                         * the device to not break KVM. But we warn.
+                         */
+                        ret = findintfep(ps->dev, index ^ 0x80);
+                        if (ret >= 0)
+                                dev_info(&ps->dev->dev,
+                                        "%s: process %i (%s) requesting ep %02x but needs %02x\n",
+                                        __func__, task_pid_nr(current),
+                                        current->comm, index, index ^ 0x80);
+                }
                 if (ret >= 0)
                         ret = checkintf(ps, ret);
                 break;
@@ -898,10 +914,8 @@ static int proc_control(struct dev_state *ps, void __user *arg)
         snoop(&dev->dev, "control urb: bRequestType=%02x "
                 "bRequest=%02x wValue=%04x "
                 "wIndex=%04x wLength=%04x\n",
-                ctrl.bRequestType, ctrl.bRequest,
-                __le16_to_cpup(&ctrl.wValue),
-                __le16_to_cpup(&ctrl.wIndex),
-                __le16_to_cpup(&ctrl.wLength));
+                ctrl.bRequestType, ctrl.bRequest, ctrl.wValue,
+                ctrl.wIndex, ctrl.wLength);
         if (ctrl.bRequestType & 0x80) {
                 if (ctrl.wLength && !access_ok(VERIFY_WRITE, ctrl.data,
                                                ctrl.wLength)) {
@@ -1620,32 +1634,32 @@ static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
 static int proc_control_compat(struct dev_state *ps,
                                 struct usbdevfs_ctrltransfer32 __user *p32)
 {
-        struct usbdevfs_ctrltransfer __user *p;
-        __u32 udata;
-        p = compat_alloc_user_space(sizeof(*p));
-        if (copy_in_user(p, p32, (sizeof(*p32) - sizeof(compat_caddr_t))) ||
-            get_user(udata, &p32->data) ||
+        struct usbdevfs_ctrltransfer __user *p;
+        __u32 udata;
+        p = compat_alloc_user_space(sizeof(*p));
+        if (copy_in_user(p, p32, (sizeof(*p32) - sizeof(compat_caddr_t))) ||
+            get_user(udata, &p32->data) ||
             put_user(compat_ptr(udata), &p->data))
                 return -EFAULT;
-        return proc_control(ps, p);
+        return proc_control(ps, p);
 }
 
 static int proc_bulk_compat(struct dev_state *ps,
                         struct usbdevfs_bulktransfer32 __user *p32)
 {
-        struct usbdevfs_bulktransfer __user *p;
-        compat_uint_t n;
-        compat_caddr_t addr;
+        struct usbdevfs_bulktransfer __user *p;
+        compat_uint_t n;
+        compat_caddr_t addr;
 
-        p = compat_alloc_user_space(sizeof(*p));
+        p = compat_alloc_user_space(sizeof(*p));
 
-        if (get_user(n, &p32->ep) || put_user(n, &p->ep) ||
-            get_user(n, &p32->len) || put_user(n, &p->len) ||
-            get_user(n, &p32->timeout) || put_user(n, &p->timeout) ||
-            get_user(addr, &p32->data) || put_user(compat_ptr(addr), &p->data))
-                return -EFAULT;
+        if (get_user(n, &p32->ep) || put_user(n, &p->ep) ||
+            get_user(n, &p32->len) || put_user(n, &p->len) ||
+            get_user(n, &p32->timeout) || put_user(n, &p->timeout) ||
+            get_user(addr, &p32->data) || put_user(compat_ptr(addr), &p->data))
+                return -EFAULT;
 
-        return proc_bulk(ps, p);
+        return proc_bulk(ps, p);
 }
 static int proc_disconnectsignal_compat(struct dev_state *ps, void __user *arg)
 {
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index f7841d44feda..47aade2a5e74 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -1179,8 +1179,8 @@ static int usb_resume_interface(struct usb_device *udev,
                                                 "reset_resume", status);
                 } else {
                         intf->needs_binding = 1;
-                        dev_warn(&intf->dev, "no %s for driver %s?\n",
-                                        "reset_resume", driver->name);
+                        dev_dbg(&intf->dev, "no reset_resume for driver %s?\n",
+                                        driver->name);
                 }
         } else {
                 status = driver->resume(intf);
@@ -1790,6 +1790,9 @@ int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
         int ret = -EPERM;
 
+        if (enable && !udev->usb2_hw_lpm_allowed)
+                return 0;
+
         if (hcd->driver->set_usb2_hw_lpm) {
                 ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
                 if (!ret)
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 7421888087a3..ea337a718cc1 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -8,7 +8,7 @@
  * (C) Copyright Deti Fliegl 1999 (new USB architecture)
  * (C) Copyright Randy Dunlap 2000
  * (C) Copyright David Brownell 2000-2001 (kernel hotplug, usb_device_id,
-        more docs, etc)
+ *      more docs, etc)
  * (C) Copyright Yggdrasil Computing, Inc. 2000
  *     (usb_device_id matching changes by Adam J. Richter)
  * (C) Copyright Greg Kroah-Hartman 2002-2003
@@ -27,29 +27,21 @@
 static const struct file_operations *usb_minors[MAX_USB_MINORS];
 static DECLARE_RWSEM(minor_rwsem);
 
-static int usb_open(struct inode * inode, struct file * file)
+static int usb_open(struct inode *inode, struct file *file)
 {
-        int minor = iminor(inode);
-        const struct file_operations *c;
         int err = -ENODEV;
-        const struct file_operations *old_fops, *new_fops = NULL;
+        const struct file_operations *new_fops;
 
         down_read(&minor_rwsem);
-        c = usb_minors[minor];
+        new_fops = fops_get(usb_minors[iminor(inode)]);
 
-        if (!c || !(new_fops = fops_get(c)))
+        if (!new_fops)
                 goto done;
 
-        old_fops = file->f_op;
-        file->f_op = new_fops;
+        replace_fops(file, new_fops);
         /* Curiouser and curiouser... NULL ->open() as "no device" ? */
         if (file->f_op->open)
-                err = file->f_op->open(inode,file);
-        if (err) {
-                fops_put(file->f_op);
-                file->f_op = fops_get(old_fops);
-        }
-        fops_put(old_fops);
+                err = file->f_op->open(inode, file);
  done:
         up_read(&minor_rwsem);
         return err;
@@ -166,7 +158,7 @@ int usb_register_dev(struct usb_interface *intf,
         char *temp;
 
 #ifdef CONFIG_USB_DYNAMIC_MINORS
-        /* 
+        /*
          * We don't care what the device tries to start at, we want to start
          * at zero to pack the devices into the smallest available space with
          * no holes in the minor range.
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index b9d3c43e3859..dfe9d0f22978 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -215,6 +215,9 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 goto disable_pci;
         }
 
+        hcd->amd_resume_bug = (usb_hcd_amd_remote_wakeup_quirk(dev) &&
+                        driver->flags & (HCD_USB11 | HCD_USB3)) ? 1 : 0;
+
         if (driver->flags & HCD_MEMORY) {
                 /* EHCI, OHCI */
                 hcd->rsrc_start = pci_resource_start(dev, 0);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index d6a8d23f047b..6bffb8c87bc9 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -6,7 +6,7 @@
  * (C) Copyright Deti Fliegl 1999
  * (C) Copyright Randy Dunlap 2000
  * (C) Copyright David Brownell 2000-2002
- * 
+ *
  * 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
@@ -40,6 +40,7 @@
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
 #include <linux/pm_runtime.h>
+#include <linux/types.h>
 
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -92,10 +93,7 @@ EXPORT_SYMBOL_GPL (usb_bus_list);
 
 /* used when allocating bus numbers */
 #define USB_MAXBUS              64
-struct usb_busmap {
-        unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
-};
-static struct usb_busmap busmap;
+static DECLARE_BITMAP(busmap, USB_MAXBUS);
 
 /* used when updating list of hcds */
 DEFINE_MUTEX(usb_bus_list_lock);        /* exported only for usbfs */
@@ -171,7 +169,7 @@ static const u8 usb25_rh_dev_descriptor[18] = {
 };
 
 /* usb 2.0 root hub device descriptor */
-static const u8 usb2_rh_dev_descriptor [18] = {
+static const u8 usb2_rh_dev_descriptor[18] = {
         0x12,       /*  __u8  bLength; */
         0x01,       /*  __u8  bDescriptorType; Device */
         0x00, 0x02, /*  __le16 bcdUSB; v2.0 */
@@ -194,7 +192,7 @@ static const u8 usb2_rh_dev_descriptor [18] = {
 /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
 
 /* usb 1.1 root hub device descriptor */
-static const u8 usb11_rh_dev_descriptor [18] = {
+static const u8 usb11_rh_dev_descriptor[18] = {
         0x12,       /*  __u8  bLength; */
         0x01,       /*  __u8  bDescriptorType; Device */
         0x10, 0x01, /*  __le16 bcdUSB; v1.1 */
@@ -219,7 +217,7 @@ static const u8 usb11_rh_dev_descriptor [18] = {
 
 /* Configuration descriptors for our root hubs */
 
-static const u8 fs_rh_config_descriptor [] = {
+static const u8 fs_rh_config_descriptor[] = {
 
         /* one configuration */
         0x09,       /*  __u8  bLength; */
@@ -228,13 +226,13 @@ static const u8 fs_rh_config_descriptor [] = {
         0x01,       /*  __u8  bNumInterfaces; (1) */
         0x01,       /*  __u8  bConfigurationValue; */
         0x00,       /*  __u8  iConfiguration; */
-        0xc0,       /*  __u8  bmAttributes; 
+        0xc0,       /*  __u8  bmAttributes;
                                  Bit 7: must be set,
                                      6: Self-powered,
                                      5: Remote wakeup,
                                      4..0: resvd */
         0x00,       /*  __u8  MaxPower; */
-      
+
         /* USB 1.1:
          * USB 2.0, single TT organization (mandatory):
          *      one interface, protocol 0
@@ -256,17 +254,17 @@ static const u8 fs_rh_config_descriptor [] = {
         0x00,       /*  __u8  if_bInterfaceSubClass; */
         0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
         0x00,       /*  __u8  if_iInterface; */
-     
+
         /* one endpoint (status change endpoint) */
         0x07,       /*  __u8  ep_bLength; */
         0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
         0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
-        0x03,       /*  __u8  ep_bmAttributes; Interrupt */
-        0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
+        0x03,       /*  __u8  ep_bmAttributes; Interrupt */
+        0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
         0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
 };
 
-static const u8 hs_rh_config_descriptor [] = {
+static const u8 hs_rh_config_descriptor[] = {
 
         /* one configuration */
         0x09,       /*  __u8  bLength; */
@@ -275,13 +273,13 @@ static const u8 hs_rh_config_descriptor [] = {
         0x01,       /*  __u8  bNumInterfaces; (1) */
         0x01,       /*  __u8  bConfigurationValue; */
         0x00,       /*  __u8  iConfiguration; */
-        0xc0,       /*  __u8  bmAttributes; 
+        0xc0,       /*  __u8  bmAttributes;
                                  Bit 7: must be set,
                                      6: Self-powered,
                                      5: Remote wakeup,
                                      4..0: resvd */
         0x00,       /*  __u8  MaxPower; */
-      
+
         /* USB 1.1:
          * USB 2.0, single TT organization (mandatory):
          *      one interface, protocol 0
@@ -303,12 +301,12 @@ static const u8 hs_rh_config_descriptor [] = {
         0x00,       /*  __u8  if_bInterfaceSubClass; */
         0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
         0x00,       /*  __u8  if_iInterface; */
-     
+
         /* one endpoint (status change endpoint) */
         0x07,       /*  __u8  ep_bLength; */
         0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
         0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
-        0x03,       /*  __u8  ep_bmAttributes; Interrupt */
+        0x03,       /*  __u8  ep_bmAttributes; Interrupt */
                     /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
                      * see hub.c:hub_configure() for details. */
         (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
@@ -428,7 +426,7 @@ rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
         char const *s;
         static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
 
-        // language ids
+        /* language ids */
         switch (id) {
         case 0:
                 /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
@@ -464,7 +462,7 @@ rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
 static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
 {
         struct usb_ctrlrequest *cmd;
-        u16             typeReq, wValue, wIndex, wLength;
+        u16             typeReq, wValue, wIndex, wLength;
         u8              *ubuf = urb->transfer_buffer;
         unsigned        len = 0;
         int             status;
@@ -526,10 +524,10 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
          */
 
         case DeviceRequest | USB_REQ_GET_STATUS:
-                tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
+                tbuf[0] = (device_may_wakeup(&hcd->self.root_hub->dev)
                                         << USB_DEVICE_REMOTE_WAKEUP)
                                 | (1 << USB_DEVICE_SELF_POWERED);
-                tbuf [1] = 0;
+                tbuf[1] = 0;
                 len = 2;
                 break;
         case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
@@ -546,7 +544,7 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
                         goto error;
                 break;
         case DeviceRequest | USB_REQ_GET_CONFIGURATION:
-                tbuf [0] = 1;
+                tbuf[0] = 1;
                 len = 1;
                         /* FALLTHROUGH */
         case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
@@ -609,13 +607,13 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
                 }
                 break;
         case DeviceRequest | USB_REQ_GET_INTERFACE:
-                tbuf [0] = 0;
+                tbuf[0] = 0;
                 len = 1;
                         /* FALLTHROUGH */
         case DeviceOutRequest | USB_REQ_SET_INTERFACE:
                 break;
         case DeviceOutRequest | USB_REQ_SET_ADDRESS:
-                // wValue == urb->dev->devaddr
+                /* wValue == urb->dev->devaddr */
                 dev_dbg (hcd->self.controller, "root hub device address %d\n",
                         wValue);
                 break;
@@ -625,9 +623,9 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
         /* ENDPOINT REQUESTS */
 
         case EndpointRequest | USB_REQ_GET_STATUS:
-                // ENDPOINT_HALT flag
-                tbuf [0] = 0;
-                tbuf [1] = 0;
+                /* ENDPOINT_HALT flag */
+                tbuf[0] = 0;
+                tbuf[1] = 0;
                 len = 2;
                         /* FALLTHROUGH */
         case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
@@ -683,7 +681,7 @@ error:
                 if (urb->transfer_buffer_length < len)
                         len = urb->transfer_buffer_length;
                 urb->actual_length = len;
-                // always USB_DIR_IN, toward host
+                /* always USB_DIR_IN, toward host */
                 memcpy (ubuf, bufp, len);
 
                 /* report whether RH hardware supports remote wakeup */
@@ -877,11 +875,11 @@ static ssize_t authorized_default_store(struct device *dev,
         usb_hcd = bus_to_hcd(usb_bus);
         result = sscanf(buf, "%u\n", &val);
         if (result == 1) {
-                usb_hcd->authorized_default = val? 1 : 0;
+                usb_hcd->authorized_default = val ? 1 : 0;
                 result = size;
-        }
-        else
+        } else {
                 result = -EINVAL;
+        }
         return result;
 }
 static DEVICE_ATTR_RW(authorized_default);
@@ -941,12 +939,12 @@ static int usb_register_bus(struct usb_bus *bus)
         int busnum;
 
         mutex_lock(&usb_bus_list_lock);
-        busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
+        busnum = find_next_zero_bit(busmap, USB_MAXBUS, 1);
         if (busnum >= USB_MAXBUS) {
                 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
                 goto error_find_busnum;
         }
-        set_bit (busnum, busmap.busmap);
+        set_bit(busnum, busmap);
         bus->busnum = busnum;
 
         /* Add it to the local list of buses */
@@ -987,7 +985,7 @@ static void usb_deregister_bus (struct usb_bus *bus)
 
         usb_notify_remove_bus(bus);
 
-        clear_bit (bus->busnum, busmap.busmap);
+        clear_bit(bus->busnum, busmap);
 }
 
 /**
@@ -1033,6 +1031,7 @@ static int register_root_hub(struct usb_hcd *hcd)
                                         dev_name(&usb_dev->dev), retval);
                         return retval;
                 }
+                usb_dev->lpm_capable = usb_device_supports_lpm(usb_dev);
         }
 
         retval = usb_new_device (usb_dev);
@@ -1120,21 +1119,21 @@ long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
         case USB_SPEED_LOW:     /* INTR only */
                 if (is_input) {
                         tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
-                        return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
+                        return 64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp;
                 } else {
                         tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
-                        return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
+                        return 64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp;
                 }
         case USB_SPEED_FULL:    /* ISOC or INTR */
                 if (isoc) {
                         tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
-                        return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
+                        return ((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp;
                 } else {
                         tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
-                        return (9107L + BW_HOST_DELAY + tmp);
+                        return 9107L + BW_HOST_DELAY + tmp;
                 }
         case USB_SPEED_HIGH:    /* ISOC or INTR */
-                // FIXME adjust for input vs output
+                /* FIXME adjust for input vs output */
                 if (isoc)
                         tmp = HS_NSECS_ISO (bytecount);
                 else
@@ -1651,6 +1650,7 @@ int usb_hcd_unlink_urb (struct urb *urb, int status)
 static void __usb_hcd_giveback_urb(struct urb *urb)
 {
         struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
+        struct usb_anchor *anchor = urb->anchor;
         int status = urb->unlinked;
         unsigned long flags;
 
@@ -1662,6 +1662,7 @@ static void __usb_hcd_giveback_urb(struct urb *urb)
 
         unmap_urb_for_dma(hcd, urb);
         usbmon_urb_complete(&hcd->self, urb, status);
+        usb_anchor_suspend_wakeups(anchor);
         usb_unanchor_urb(urb);
 
         /* pass ownership to the completion handler */
@@ -1681,6 +1682,7 @@ static void __usb_hcd_giveback_urb(struct urb *urb)
         urb->complete(urb);
         local_irq_restore(flags);
 
+        usb_anchor_resume_wakeups(anchor);
         atomic_dec(&urb->use_count);
         if (unlikely(atomic_read(&urb->reject)))
                 wake_up(&usb_kill_urb_queue);
@@ -1703,7 +1705,9 @@ static void usb_giveback_urb_bh(unsigned long param)
 
                 urb = list_entry(local_list.next, struct urb, urb_list);
                 list_del_init(&urb->urb_list);
+                bh->completing_ep = urb->ep;
                 __usb_hcd_giveback_urb(urb);
+                bh->completing_ep = NULL;
         }
 
         /* check if there are new URBs to giveback */
@@ -1812,7 +1816,7 @@ rescan:
                                  case USB_ENDPOINT_XFER_INT:
                                         s = "-intr"; break;
                                  default:
-                                        s = "-iso"; break;
+                                        s = "-iso"; break;
                                 };
                                 s;
                         }));
@@ -2073,8 +2077,11 @@ EXPORT_SYMBOL_GPL(usb_alloc_streams);
  *
  * Reverts a group of bulk endpoints back to not using stream IDs.
  * Can fail if we are given bad arguments, or HCD is broken.
+ *
+ * Return: On success, the number of allocated streams. On failure, a negative
+ * error code.
  */
-void usb_free_streams(struct usb_interface *interface,
+int usb_free_streams(struct usb_interface *interface,
                 struct usb_host_endpoint **eps, unsigned int num_eps,
                 gfp_t mem_flags)
 {
@@ -2085,14 +2092,14 @@ void usb_free_streams(struct usb_interface *interface,
         dev = interface_to_usbdev(interface);
         hcd = bus_to_hcd(dev->bus);
         if (dev->speed != USB_SPEED_SUPER)
-                return;
+                return -EINVAL;
 
         /* Streams only apply to bulk endpoints. */
         for (i = 0; i < num_eps; i++)
                 if (!eps[i] || !usb_endpoint_xfer_bulk(&eps[i]->desc))
-                        return;
+                        return -EINVAL;
 
-        hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
+        return hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
 }
 EXPORT_SYMBOL_GPL(usb_free_streams);
 
@@ -2245,7 +2252,7 @@ static void hcd_resume_work(struct work_struct *work)
 }
 
 /**
- * usb_hcd_resume_root_hub - called by HCD to resume its root hub 
+ * usb_hcd_resume_root_hub - called by HCD to resume its root hub
  * @hcd: host controller for this root hub
  *
  * The USB host controller calls this function when its root hub is
@@ -2324,15 +2331,8 @@ EXPORT_SYMBOL_GPL(usb_bus_start_enum);
 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
 {
         struct usb_hcd          *hcd = __hcd;
-        unsigned long           flags;
         irqreturn_t             rc;
 
-        /* IRQF_DISABLED doesn't work correctly with shared IRQs
-         * when the first handler doesn't use it.  So let's just
-         * assume it's never used.
-         */
-        local_irq_save(flags);
-
         if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd)))
                 rc = IRQ_NONE;
         else if (hcd->driver->irq(hcd) == IRQ_NONE)
@@ -2340,7 +2340,6 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd)
         else
                 rc = IRQ_HANDLED;
 
-        local_irq_restore(flags);
         return rc;
 }
 EXPORT_SYMBOL_GPL(usb_hcd_irq);
@@ -2547,13 +2546,6 @@ static int usb_hcd_request_irqs(struct usb_hcd *hcd,
 
         if (hcd->driver->irq) {
 
-                /* IRQF_DISABLED doesn't work as advertised when used together
-                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
-                 * interrupts we can remove it here.
-                 */
-                if (irqflags & IRQF_SHARED)
-                        irqflags &= ~IRQF_DISABLED;
-
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
@@ -2600,7 +2592,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
 
         /* Keep old behaviour if authorized_default is not in [0, 1]. */
         if (authorized_default < 0 || authorized_default > 1)
-                hcd->authorized_default = hcd->wireless? 0 : 1;
+                hcd->authorized_default = hcd->wireless ? 0 : 1;
         else
                 hcd->authorized_default = authorized_default;
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
@@ -2743,7 +2735,7 @@ err_allocate_root_hub:
 err_register_bus:
         hcd_buffer_destroy(hcd);
         return retval;
-} 
+}
 EXPORT_SYMBOL_GPL(usb_add_hcd);
 
 /**
@@ -2818,7 +2810,7 @@ void usb_remove_hcd(struct usb_hcd *hcd)
 EXPORT_SYMBOL_GPL(usb_remove_hcd);
 
 void
-usb_hcd_platform_shutdown(struct platform_device* dev)
+usb_hcd_platform_shutdown(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
 
@@ -2840,7 +2832,7 @@ struct usb_mon_operations *mon_ops;
  * Notice that the code is minimally error-proof. Because usbmon needs
  * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
  */
- 
+
 int usb_mon_register (struct usb_mon_operations *ops)
 {
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index dde4c83516a1..06cec635e703 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -120,7 +120,7 @@ static inline char *portspeed(struct usb_hub *hub, int portstatus)
         if (hub_is_superspeed(hub->hdev))
                 return "5.0 Gb/s";
         if (portstatus & USB_PORT_STAT_HIGH_SPEED)
-                return "480 Mb/s";
+                return "480 Mb/s";
         else if (portstatus & USB_PORT_STAT_LOW_SPEED)
                 return "1.5 Mb/s";
         else
@@ -135,7 +135,7 @@ struct usb_hub *usb_hub_to_struct_hub(struct usb_device *hdev)
         return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
 
-static int usb_device_supports_lpm(struct usb_device *udev)
+int usb_device_supports_lpm(struct usb_device *udev)
 {
         /* USB 2.1 (and greater) devices indicate LPM support through
          * their USB 2.0 Extended Capabilities BOS descriptor.
@@ -156,6 +156,11 @@ static int usb_device_supports_lpm(struct usb_device *udev)
                                 "Power management will be impacted.\n");
                 return 0;
         }
+
+        /* udev is root hub */
+        if (!udev->parent)
+                return 1;
+
         if (udev->parent->lpm_capable)
                 return 1;
 
@@ -310,9 +315,9 @@ static void usb_set_lpm_parameters(struct usb_device *udev)
                 return;
 
         udev_u1_del = udev->bos->ss_cap->bU1devExitLat;
-        udev_u2_del = udev->bos->ss_cap->bU2DevExitLat;
+        udev_u2_del = le16_to_cpu(udev->bos->ss_cap->bU2DevExitLat);
         hub_u1_del = udev->parent->bos->ss_cap->bU1devExitLat;
-        hub_u2_del = udev->parent->bos->ss_cap->bU2DevExitLat;
+        hub_u2_del = le16_to_cpu(udev->parent->bos->ss_cap->bU2DevExitLat);
 
         usb_set_lpm_mel(udev, &udev->u1_params, udev_u1_del,
                         hub, &udev->parent->u1_params, hub_u1_del);
@@ -433,7 +438,7 @@ static void set_port_led(
                         case HUB_LED_OFF: s = "off"; break;
                         case HUB_LED_AUTO: s = "auto"; break;
                         default: s = "??"; break;
-                        }; s; }),
+                        } s; }),
                         status);
 }
 
@@ -857,7 +862,7 @@ static int hub_hub_status(struct usb_hub *hub,
                                 "%s failed (err = %d)\n", __func__, ret);
         } else {
                 *status = le16_to_cpu(hub->status->hub.wHubStatus);
-                *change = le16_to_cpu(hub->status->hub.wHubChange); 
+                *change = le16_to_cpu(hub->status->hub.wHubChange);
                 ret = 0;
         }
         mutex_unlock(&hub->status_mutex);
@@ -956,7 +961,7 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
          */
 
         set_bit(port1, hub->change_bits);
-        kick_khubd(hub);
+        kick_khubd(hub);
 }
 
 /**
@@ -1107,16 +1112,13 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                         /*
                          * USB3 protocol ports will automatically transition
                          * to Enabled state when detect an USB3.0 device attach.
-                         * Do not disable USB3 protocol ports.
+                         * Do not disable USB3 protocol ports, just pretend
+                         * power was lost
                          */
-                        if (!hub_is_superspeed(hdev)) {
+                        portstatus &= ~USB_PORT_STAT_ENABLE;
+                        if (!hub_is_superspeed(hdev))
                                 usb_clear_port_feature(hdev, port1,
                                                    USB_PORT_FEAT_ENABLE);
-                                portstatus &= ~USB_PORT_STAT_ENABLE;
-                        } else {
-                                /* Pretend that power was lost for USB3 devs */
-                                portstatus &= ~USB_PORT_STAT_ENABLE;
-                        }
                 }
 
                 /* Clear status-change flags; we'll debounce later */
@@ -1130,6 +1132,11 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                         usb_clear_port_feature(hub->hdev, port1,
                                         USB_PORT_FEAT_C_ENABLE);
                 }
+                if (portchange & USB_PORT_STAT_C_RESET) {
+                        need_debounce_delay = true;
+                        usb_clear_port_feature(hub->hdev, port1,
+                                        USB_PORT_FEAT_C_RESET);
+                }
                 if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
                                 hub_is_superspeed(hub->hdev)) {
                         need_debounce_delay = true;
@@ -1361,7 +1368,7 @@ static int hub_configure(struct usb_hub *hub,
         if ((wHubCharacteristics & HUB_CHAR_COMPOUND) &&
                         !(hub_is_superspeed(hdev))) {
                 int     i;
-                char    portstr [USB_MAXCHILDREN + 1];
+                char    portstr[USB_MAXCHILDREN + 1];
 
                 for (i = 0; i < hdev->maxchild; i++)
                         portstr[i] = hub->descriptor->u.hs.DeviceRemovable
@@ -1429,32 +1436,32 @@ static int hub_configure(struct usb_hub *hub,
 
         /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
         switch (wHubCharacteristics & HUB_CHAR_TTTT) {
-                case HUB_TTTT_8_BITS:
-                        if (hdev->descriptor.bDeviceProtocol != 0) {
-                                hub->tt.think_time = 666;
-                                dev_dbg(hub_dev, "TT requires at most %d "
-                                                "FS bit times (%d ns)\n",
-                                        8, hub->tt.think_time);
-                        }
-                        break;
-                case HUB_TTTT_16_BITS:
-                        hub->tt.think_time = 666 * 2;
+        case HUB_TTTT_8_BITS:
+                if (hdev->descriptor.bDeviceProtocol != 0) {
+                        hub->tt.think_time = 666;
                         dev_dbg(hub_dev, "TT requires at most %d "
                                         "FS bit times (%d ns)\n",
-                                16, hub->tt.think_time);
-                        break;
-                case HUB_TTTT_24_BITS:
-                        hub->tt.think_time = 666 * 3;
-                        dev_dbg(hub_dev, "TT requires at most %d "
-                                        "FS bit times (%d ns)\n",
-                                24, hub->tt.think_time);
-                        break;
-                case HUB_TTTT_32_BITS:
-                        hub->tt.think_time = 666 * 4;
-                        dev_dbg(hub_dev, "TT requires at most %d "
-                                        "FS bit times (%d ns)\n",
-                                32, hub->tt.think_time);
-                        break;
+                                8, hub->tt.think_time);
+                }
+                break;
+        case HUB_TTTT_16_BITS:
+                hub->tt.think_time = 666 * 2;
+                dev_dbg(hub_dev, "TT requires at most %d "
+                                "FS bit times (%d ns)\n",
+                        16, hub->tt.think_time);
+                break;
+        case HUB_TTTT_24_BITS:
+                hub->tt.think_time = 666 * 3;
+                dev_dbg(hub_dev, "TT requires at most %d "
+                                "FS bit times (%d ns)\n",
+                        24, hub->tt.think_time);
+                break;
+        case HUB_TTTT_32_BITS:
+                hub->tt.think_time = 666 * 4;
+                dev_dbg(hub_dev, "TT requires at most %d "
+                                "FS bit times (%d ns)\n",
+                        32, hub->tt.think_time);
+                break;
         }
 
         /* probe() zeroes hub->indicator[] */
@@ -1560,7 +1567,7 @@ static int hub_configure(struct usb_hub *hub,
 
         /* maybe cycle the hub leds */
         if (hub->has_indicators && blinkenlights)
-                hub->indicator [0] = INDICATOR_CYCLE;
+                hub->indicator[0] = INDICATOR_CYCLE;
 
         for (i = 0; i < hdev->maxchild; i++) {
                 ret = usb_hub_create_port_device(hub, i + 1);
@@ -1978,7 +1985,7 @@ static void choose_devnum(struct usb_device *udev)
                 if (devnum >= 128)
                         devnum = find_next_zero_bit(bus->devmap.devicemap,
                                                     128, 1);
-                bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1);
+                bus->devnum_next = (devnum >= 127 ? 1 : devnum + 1);
         }
         if (devnum < 128) {
                 set_bit(devnum, bus->devmap.devicemap);
@@ -2018,8 +2025,8 @@ static void hub_free_dev(struct usb_device *udev)
  * Something got disconnected. Get rid of it and all of its children.
  *
  * If *pdev is a normal device then the parent hub must already be locked.
- * If *pdev is a root hub then this routine will acquire the
- * usb_bus_list_lock on behalf of the caller.
+ * If *pdev is a root hub then the caller must hold the usb_bus_list_lock,
+ * which protects the set of root hubs as well as the list of buses.
  *
  * Only hub drivers (including virtual root hub drivers for host
  * controllers) should ever call this.
@@ -2232,8 +2239,7 @@ static int usb_enumerate_device(struct usb_device *udev)
                 udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
                 udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
                 udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        }
-        else {
+        } else {
                 /* read the standard strings and cache them if present */
                 udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
                 udev->manufacturer = usb_cache_string(udev,
@@ -2489,7 +2495,7 @@ error_device_descriptor:
         usb_autosuspend_device(usb_dev);
 error_autoresume:
 out_authorized:
-        usb_unlock_device(usb_dev);     // complements locktree
+        usb_unlock_device(usb_dev);     /* complements locktree */
         return result;
 }
 
@@ -3108,8 +3114,8 @@ static int finish_port_resume(struct usb_device *udev)
  retry_reset_resume:
                 status = usb_reset_and_verify_device(udev);
 
-        /* 10.5.4.5 says be sure devices in the tree are still there.
-         * For now let's assume the device didn't go crazy on resume,
+        /* 10.5.4.5 says be sure devices in the tree are still there.
+         * For now let's assume the device didn't go crazy on resume,
          * and device drivers will know about any resume quirks.
          */
         if (status == 0) {
@@ -3211,7 +3217,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
-        // dev_dbg(hub->intfdev, "resume port %d\n", port1);
+        /* dev_dbg(hub->intfdev, "resume port %d\n", port1); */
 
         set_bit(port1, hub->busy_bits);
 
@@ -3426,6 +3432,9 @@ static int usb_req_set_sel(struct usb_device *udev, enum usb3_link_state state)
         unsigned long long u2_pel;
         int ret;
 
+        if (udev->state != USB_STATE_CONFIGURED)
+                return 0;
+
         /* Convert SEL and PEL stored in ns to us */
         u1_sel = DIV_ROUND_UP(udev->u1_params.sel, 1000);
         u1_pel = DIV_ROUND_UP(udev->u1_params.pel, 1000);
@@ -3852,7 +3861,7 @@ EXPORT_SYMBOL_GPL(usb_enable_ltm);
  * Between connect detection and reset signaling there must be a delay
  * of 100ms at least for debounce and power-settling.  The corresponding
  * timer shall restart whenever the downstream port detects a disconnect.
- * 
+ *
  * Apparently there are some bluetooth and irda-dongles and a number of
  * low-speed devices for which this debounce period may last over a second.
  * Not covered by the spec - but easy to deal with.
@@ -3946,6 +3955,32 @@ static int hub_set_address(struct usb_device *udev, int devnum)
         return retval;
 }
 
+/*
+ * There are reports of USB 3.0 devices that say they support USB 2.0 Link PM
+ * when they're plugged into a USB 2.0 port, but they don't work when LPM is
+ * enabled.
+ *
+ * Only enable USB 2.0 Link PM if the port is internal (hardwired), or the
+ * device says it supports the new USB 2.0 Link PM errata by setting the BESL
+ * support bit in the BOS descriptor.
+ */
+static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
+{
+        int connect_type;
+
+        if (!udev->usb2_hw_lpm_capable)
+                return;
+
+        connect_type = usb_get_hub_port_connect_type(udev->parent,
+                        udev->portnum);
+
+        if ((udev->bos->ext_cap->bmAttributes & USB_BESL_SUPPORT) ||
+                        connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
+                udev->usb2_hw_lpm_allowed = 1;
+                usb_set_usb2_hardware_lpm(udev, 1);
+        }
+}
+
 /* Reset device, (re)assign address, get device descriptor.
  * Device connection must be stable, no more debouncing needed.
  * Returns device in USB_STATE_ADDRESS, except on error.
@@ -4052,7 +4087,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 udev->tt = &hub->tt;
                 udev->ttport = port1;
         }
- 
+
         /* Why interleave GET_DESCRIPTOR and SET_ADDRESS this way?
          * Because device hardware and firmware is sometimes buggy in
          * this area, and this is how Linux has done it for ages.
@@ -4127,11 +4162,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
 #undef GET_DESCRIPTOR_BUFSIZE
                 }
 
-                /*
-                 * If device is WUSB, we already assigned an
-                 * unauthorized address in the Connect Ack sequence;
-                 * authorization will assign the final address.
-                 */
+                /*
+                 * If device is WUSB, we already assigned an
+                 * unauthorized address in the Connect Ack sequence;
+                 * authorization will assign the final address.
+                 */
                 if (udev->wusb == 0) {
                         for (j = 0; j < SET_ADDRESS_TRIES; ++j) {
                                 retval = hub_set_address(udev, devnum);
@@ -4160,7 +4195,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                         msleep(10);
                         if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
                                 break;
-                }
+                }
 
                 retval = usb_get_device_descriptor(udev, 8);
                 if (retval < 8) {
@@ -4216,7 +4251,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 udev->ep0.desc.wMaxPacketSize = cpu_to_le16(i);
                 usb_ep0_reinit(udev);
         }
-  
+
         retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);
         if (retval < (signed)sizeof(udev->descriptor)) {
                 if (retval != -ENODEV)
@@ -4239,6 +4274,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         /* notify HCD that we have a device connected and addressed */
         if (hcd->driver->update_device)
                 hcd->driver->update_device(hcd, udev);
+        hub_set_initial_usb2_lpm_policy(udev);
 fail:
         if (retval) {
                 hub_port_disable(hub, port1, 0);
@@ -4313,7 +4349,7 @@ hub_power_remaining (struct usb_hub *hub)
         }
         if (remaining < 0) {
                 dev_warn(hub->intfdev, "%dmA over power budget!\n",
-                        - remaining);
+                        -remaining);
                 remaining = 0;
         }
         return remaining;
@@ -4424,7 +4460,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
                 if (portstatus & USB_PORT_STAT_ENABLE)
-                        goto done;
+                        goto done;
                 return;
         }
         if (hub_is_superspeed(hub->hdev))
@@ -4447,7 +4483,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 }
 
                 usb_set_device_state(udev, USB_STATE_POWERED);
-                udev->bus_mA = hub->mA_per_port;
+                udev->bus_mA = hub->mA_per_port;
                 udev->level = hdev->level + 1;
                 udev->wusb = hub_is_wusb(hub);
 
@@ -4501,7 +4537,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                                 goto loop_disable;
                         }
                 }
- 
+
                 /* check for devices running slower than they could */
                 if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0200
                                 && udev->speed == USB_SPEED_FULL
@@ -4561,7 +4597,7 @@ loop:
                         dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
                                         port1);
         }
- 
+
 done:
         hub_port_disable(hub, port1, 1);
         if (hcd->driver->relinquish_port && !hub->hdev->parent)
@@ -4726,7 +4762,7 @@ static void hub_events(void)
                                  * EM interference sometimes causes badly
                                  * shielded USB devices to be shutdown by
                                  * the hub, this hack enables them again.
-                                 * Works at least with mouse driver. 
+                                 * Works at least with mouse driver.
                                  */
                                 if (!(portstatus & USB_PORT_STAT_ENABLE)
                                     && !connect_change
@@ -4838,7 +4874,7 @@ static void hub_events(void)
                                 dev_dbg(hub_dev, "over-current change\n");
                                 clear_hub_feature(hdev, C_HUB_OVER_CURRENT);
                                 msleep(500);    /* Cool down */
-                                hub_power_on(hub, true);
+                                hub_power_on(hub, true);
                                 hub_hub_status(hub, &status, &unused);
                                 if (status & HUB_STATUS_OVERCURRENT)
                                         dev_err(hub_dev, "over-current "
@@ -4858,7 +4894,7 @@ static void hub_events(void)
                 usb_unlock_device(hdev);
                 kref_put(&hub->kref, hub_release);
 
-        } /* end while (1) */
+        } /* end while (1) */
 }
 
 static int hub_thread(void *__unused)
@@ -4883,7 +4919,7 @@ static int hub_thread(void *__unused)
 
 static const struct usb_device_id hub_id_table[] = {
     { .match_flags = USB_DEVICE_ID_MATCH_VENDOR
-                   | USB_DEVICE_ID_MATCH_INT_CLASS,
+                        | USB_DEVICE_ID_MATCH_INT_CLASS,
       .idVendor = USB_VENDOR_GENESYS_LOGIC,
       .bInterfaceClass = USB_CLASS_HUB,
       .driver_info = HUB_QUIRK_CHECK_PORT_AUTOSUSPEND},
@@ -5083,6 +5119,12 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
         }
         parent_hub = usb_hub_to_struct_hub(parent_hdev);
 
+        /* Disable USB2 hardware LPM.
+         * It will be re-enabled by the enumeration process.
+         */
+        if (udev->usb2_hw_lpm_enabled == 1)
+                usb_set_usb2_hardware_lpm(udev, 0);
+
         bos = udev->bos;
         udev->bos = NULL;
 
@@ -5117,13 +5159,13 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
 
         if (ret < 0)
                 goto re_enumerate;
- 
+
         /* Device might have changed firmware (DFU or similar) */
         if (descriptors_changed(udev, &descriptor, bos)) {
                 dev_info(&udev->dev, "device firmware changed\n");
                 udev->descriptor = descriptor;  /* for disconnect() calls */
                 goto re_enumerate;
-        }
+        }
 
         /* Restore the device's previous configuration */
         if (!udev->actconfig)
@@ -5148,7 +5190,7 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                         udev->actconfig->desc.bConfigurationValue, ret);
                 mutex_unlock(hcd->bandwidth_mutex);
                 goto re_enumerate;
-        }
+        }
         mutex_unlock(hcd->bandwidth_mutex);
         usb_set_device_state(udev, USB_STATE_CONFIGURED);
 
@@ -5190,12 +5232,13 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
 
 done:
         /* Now that the alt settings are re-installed, enable LTM and LPM. */
+        usb_set_usb2_hardware_lpm(udev, 1);
         usb_unlocked_enable_lpm(udev);
         usb_enable_ltm(udev);
         usb_release_bos_descriptor(udev);
         udev->bos = bos;
         return 0;
- 
+
 re_enumerate:
         /* LPM state doesn't matter when we're about to destroy the device. */
         hub_port_logical_disconnect(parent_hub, port1);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 82927e1ed27d..bb315970e475 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1182,8 +1182,12 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                         put_device(&dev->actconfig->interface[i]->dev);
                         dev->actconfig->interface[i] = NULL;
                 }
+
+                if (dev->usb2_hw_lpm_enabled == 1)
+                        usb_set_usb2_hardware_lpm(dev, 0);
                 usb_unlocked_disable_lpm(dev);
                 usb_disable_ltm(dev);
+
                 dev->actconfig = NULL;
                 if (dev->state == USB_STATE_CONFIGURED)
                         usb_set_device_state(dev, USB_STATE_ADDRESS);
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 5b44cd47da5b..12924dbfdc2c 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -13,6 +13,7 @@
 
 #include <linux/usb.h>
 #include <linux/usb/quirks.h>
+#include <linux/usb/hcd.h>
 #include "usb.h"
 
 /* Lists of quirky USB devices, split in device quirks and interface quirks.
@@ -97,6 +98,9 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Alcor Micro Corp. Hub */
         { USB_DEVICE(0x058f, 0x9254), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* MicroTouch Systems touchscreen */
+        { USB_DEVICE(0x0596, 0x051e), .driver_info = USB_QUIRK_RESET_RESUME },
+
         /* appletouch */
         { USB_DEVICE(0x05ac, 0x021a), .driver_info = USB_QUIRK_RESET_RESUME },
 
@@ -130,6 +134,9 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Broadcom BCM92035DGROM BT dongle */
         { USB_DEVICE(0x0a5c, 0x2021), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* MAYA44USB sound device */
+        { USB_DEVICE(0x0a92, 0x0091), .driver_info = USB_QUIRK_RESET_RESUME },
+
         /* Action Semiconductor flash disk */
         { USB_DEVICE(0x10d6, 0x2200), .driver_info =
                         USB_QUIRK_STRING_FETCH_255 },
@@ -155,6 +162,21 @@ static const struct usb_device_id usb_interface_quirk_list[] = {
         { }  /* terminating entry must be last */
 };
 
+static const struct usb_device_id usb_amd_resume_quirk_list[] = {
+        /* Lenovo Mouse with Pixart controller */
+        { USB_DEVICE(0x17ef, 0x602e), .driver_info = USB_QUIRK_RESET_RESUME },
+
+        /* Pixart Mouse */
+        { USB_DEVICE(0x093a, 0x2500), .driver_info = USB_QUIRK_RESET_RESUME },
+        { USB_DEVICE(0x093a, 0x2510), .driver_info = USB_QUIRK_RESET_RESUME },
+        { USB_DEVICE(0x093a, 0x2521), .driver_info = USB_QUIRK_RESET_RESUME },
+
+        /* Logitech Optical Mouse M90/M100 */
+        { USB_DEVICE(0x046d, 0xc05a), .driver_info = USB_QUIRK_RESET_RESUME },
+
+        { }  /* terminating entry must be last */
+};
+
 static bool usb_match_any_interface(struct usb_device *udev,
                                     const struct usb_device_id *id)
 {
@@ -181,6 +203,18 @@ static bool usb_match_any_interface(struct usb_device *udev,
         return false;
 }
 
+static int usb_amd_resume_quirk(struct usb_device *udev)
+{
+        struct usb_hcd *hcd;
+
+        hcd = bus_to_hcd(udev->bus);
+        /* The device should be attached directly to root hub */
+        if (udev->level == 1 && hcd->amd_resume_bug == 1)
+                return 1;
+
+        return 0;
+}
+
 static u32 __usb_detect_quirks(struct usb_device *udev,
                                const struct usb_device_id *id)
 {
@@ -206,6 +240,15 @@ static u32 __usb_detect_quirks(struct usb_device *udev,
 void usb_detect_quirks(struct usb_device *udev)
 {
         udev->quirks = __usb_detect_quirks(udev, usb_quirk_list);
+
+        /*
+         * Pixart-based mice would trigger remote wakeup issue on AMD
+         * Yangtze chipset, so set them as RESET_RESUME flag.
+         */
+        if (usb_amd_resume_quirk(udev))
+                udev->quirks |= __usb_detect_quirks(udev,
+                                usb_amd_resume_quirk_list);
+
         if (udev->quirks)
                 dev_dbg(&udev->dev, "USB quirks for this device: %x\n",
                         udev->quirks);
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 6d2c8edb1ffe..52a97adf02a0 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -23,14 +23,16 @@ static ssize_t field##_show(struct device *dev,				\
 {                                                                       \
         struct usb_device *udev;                                        \
         struct usb_host_config *actconfig;                              \
+        ssize_t rc = 0;                                                 \
                                                                         \
         udev = to_usb_device(dev);                                      \
+        usb_lock_device(udev);                                          \
         actconfig = udev->actconfig;                                    \
         if (actconfig)                                                  \
-                return sprintf(buf, format_string,                      \
+                rc = sprintf(buf, format_string,                        \
                                 actconfig->desc.field);                 \
-        else                                                            \
-                return 0;                                               \
+        usb_unlock_device(udev);                                        \
+        return rc;                                                      \
 }                                                                       \
 
 #define usb_actconfig_attr(field, format_string)                \
@@ -45,12 +47,15 @@ static ssize_t bMaxPower_show(struct device *dev,
 {
         struct usb_device *udev;
         struct usb_host_config *actconfig;
+        ssize_t rc = 0;
 
         udev = to_usb_device(dev);
+        usb_lock_device(udev);
         actconfig = udev->actconfig;
-        if (!actconfig)
-                return 0;
-        return sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
+        if (actconfig)
+                rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
+        usb_unlock_device(udev);
+        return rc;
 }
 static DEVICE_ATTR_RO(bMaxPower);
 
@@ -59,12 +64,15 @@ static ssize_t configuration_show(struct device *dev,
 {
         struct usb_device *udev;
         struct usb_host_config *actconfig;
+        ssize_t rc = 0;
 
         udev = to_usb_device(dev);
+        usb_lock_device(udev);
         actconfig = udev->actconfig;
-        if ((!actconfig) || (!actconfig->string))
-                return 0;
-        return sprintf(buf, "%s\n", actconfig->string);
+        if (actconfig && actconfig->string)
+                rc = sprintf(buf, "%s\n", actconfig->string);
+        usb_unlock_device(udev);
+        return rc;
 }
 static DEVICE_ATTR_RO(configuration);
 
@@ -390,7 +398,8 @@ static DEVICE_ATTR_RW(autosuspend);
 static const char on_string[] = "on";
 static const char auto_string[] = "auto";
 
-static void warn_level(void) {
+static void warn_level(void)
+{
         static int level_warned;
 
         if (!level_warned) {
@@ -449,7 +458,7 @@ static ssize_t usb2_hardware_lpm_show(struct device *dev,
         struct usb_device *udev = to_usb_device(dev);
         const char *p;
 
-        if (udev->usb2_hw_lpm_enabled == 1)
+        if (udev->usb2_hw_lpm_allowed == 1)
                 p = "enabled";
         else
                 p = "disabled";
@@ -469,8 +478,10 @@ static ssize_t usb2_hardware_lpm_store(struct device *dev,
 
         ret = strtobool(buf, &value);
 
-        if (!ret)
+        if (!ret) {
+                udev->usb2_hw_lpm_allowed = value;
                 ret = usb_set_usb2_hardware_lpm(udev, value);
+        }
 
         usb_unlock_device(udev);
 
@@ -644,7 +655,7 @@ static ssize_t authorized_store(struct device *dev,
                 result = usb_deauthorize_device(usb_dev);
         else
                 result = usb_authorize_device(usb_dev);
-        return result < 0? result : size;
+        return result < 0 ? result : size;
 }
 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
                                   authorized_show, authorized_store);
@@ -764,6 +775,7 @@ read_descriptors(struct file *filp, struct kobject *kobj,
          * Following that are the raw descriptor entries for all the
          * configurations (config plus subsidiary descriptors).
          */
+        usb_lock_device(udev);
         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
                         nleft > 0; ++cfgno) {
                 if (cfgno < 0) {
@@ -784,6 +796,7 @@ read_descriptors(struct file *filp, struct kobject *kobj,
                         off -= srclen;
                 }
         }
+        usb_unlock_device(udev);
         return count - nleft;
 }
 
@@ -870,9 +883,7 @@ static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
         char *string;
 
         intf = to_usb_interface(dev);
-        string = intf->cur_altsetting->string;
-        barrier();              /* The altsetting might change! */
-
+        string = ACCESS_ONCE(intf->cur_altsetting->string);
         if (!string)
                 return 0;
         return sprintf(buf, "%s\n", string);
@@ -888,7 +899,7 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 
         intf = to_usb_interface(dev);
         udev = interface_to_usbdev(intf);
-        alt = intf->cur_altsetting;
+        alt = ACCESS_ONCE(intf->cur_altsetting);
 
         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
                         "ic%02Xisc%02Xip%02Xin%02X\n",
@@ -909,23 +920,14 @@ static ssize_t supports_autosuspend_show(struct device *dev,
                                          struct device_attribute *attr,
                                          char *buf)
 {
-        struct usb_interface *intf;
-        struct usb_device *udev;
-        int ret;
+        int s;
 
-        intf = to_usb_interface(dev);
-        udev = interface_to_usbdev(intf);
-
-        usb_lock_device(udev);
+        device_lock(dev);
         /* Devices will be autosuspended even when an interface isn't claimed */
-        if (!intf->dev.driver ||
-                        to_usb_driver(intf->dev.driver)->supports_autosuspend)
-                ret = sprintf(buf, "%u\n", 1);
-        else
-                ret = sprintf(buf, "%u\n", 0);
-        usb_unlock_device(udev);
+        s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
+        device_unlock(dev);
 
-        return ret;
+        return sprintf(buf, "%u\n", s);
 }
 static DEVICE_ATTR_RO(supports_autosuspend);
 
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index c12bc790a6a7..e62208356c89 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -138,13 +138,19 @@ void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
 }
 EXPORT_SYMBOL_GPL(usb_anchor_urb);
 
+static int usb_anchor_check_wakeup(struct usb_anchor *anchor)
+{
+        return atomic_read(&anchor->suspend_wakeups) == 0 &&
+                list_empty(&anchor->urb_list);
+}
+
 /* Callers must hold anchor->lock */
 static void __usb_unanchor_urb(struct urb *urb, struct usb_anchor *anchor)
 {
         urb->anchor = NULL;
         list_del(&urb->anchor_list);
         usb_put_urb(urb);
-        if (list_empty(&anchor->urb_list))
+        if (usb_anchor_check_wakeup(anchor))
                 wake_up(&anchor->wait);
 }
 
@@ -846,6 +852,39 @@ void usb_unlink_anchored_urbs(struct usb_anchor *anchor)
 EXPORT_SYMBOL_GPL(usb_unlink_anchored_urbs);
 
 /**
+ * usb_anchor_suspend_wakeups
+ * @anchor: the anchor you want to suspend wakeups on
+ *
+ * Call this to stop the last urb being unanchored from waking up any
+ * usb_wait_anchor_empty_timeout waiters. This is used in the hcd urb give-
+ * back path to delay waking up until after the completion handler has run.
+ */
+void usb_anchor_suspend_wakeups(struct usb_anchor *anchor)
+{
+        if (anchor)
+                atomic_inc(&anchor->suspend_wakeups);
+}
+EXPORT_SYMBOL_GPL(usb_anchor_suspend_wakeups);
+
+/**
+ * usb_anchor_resume_wakeups
+ * @anchor: the anchor you want to resume wakeups on
+ *
+ * Allow usb_wait_anchor_empty_timeout waiters to be woken up again, and
+ * wake up any current waiters if the anchor is empty.
+ */
+void usb_anchor_resume_wakeups(struct usb_anchor *anchor)
+{
+        if (!anchor)
+                return;
+
+        atomic_dec(&anchor->suspend_wakeups);
+        if (usb_anchor_check_wakeup(anchor))
+                wake_up(&anchor->wait);
+}
+EXPORT_SYMBOL_GPL(usb_anchor_resume_wakeups);
+
+/**
  * usb_wait_anchor_empty_timeout - wait for an anchor to be unused
  * @anchor: the anchor you want to become unused
  * @timeout: how long you are willing to wait in milliseconds
@@ -858,7 +897,8 @@ EXPORT_SYMBOL_GPL(usb_unlink_anchored_urbs);
 int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,
                                   unsigned int timeout)
 {
-        return wait_event_timeout(anchor->wait, list_empty(&anchor->urb_list),
+        return wait_event_timeout(anchor->wait,
+                                  usb_anchor_check_wakeup(anchor),
                                   msecs_to_jiffies(timeout));
 }
 EXPORT_SYMBOL_GPL(usb_wait_anchor_empty_timeout);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 0a6ee2e70b25..4d1144990d4c 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -497,7 +497,7 @@ struct usb_device *usb_alloc_dev(struct usb_device *parent,
                 dev->authorized = 1;
         else {
                 dev->authorized = usb_hcd->authorized_default;
-                dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
+                dev->wusb = usb_bus_is_wusb(bus) ? 1 : 0;
         }
         return dev;
 }
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 823857767a16..c49383669cd8 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -35,6 +35,7 @@ extern int usb_get_device_descriptor(struct usb_device *dev,
                 unsigned int size);
 extern int usb_get_bos_descriptor(struct usb_device *dev);
 extern void usb_release_bos_descriptor(struct usb_device *dev);
+extern int usb_device_supports_lpm(struct usb_device *udev);
 extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 extern int usb_choose_configuration(struct usb_device *udev);
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index f969ea266acb..70fc43027a5c 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -1,7 +1,6 @@
 config USB_DWC3
         tristate "DesignWare USB3 DRD Core Support"
-        depends on (USB || USB_GADGET) && GENERIC_HARDIRQS && HAS_DMA
-        depends on EXTCON
+        depends on (USB || USB_GADGET) && HAS_DMA
         select USB_XHCI_PLATFORM if USB_SUPPORT && USB_XHCI_HCD
         help
           Say Y or M here if your system has a Dual Role SuperSpeed
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 474162e9d01d..74f9cf02da07 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -584,7 +584,7 @@ static int dwc3_remove(struct platform_device *pdev)
         usb_phy_set_suspend(dwc->usb2_phy, 1);
         usb_phy_set_suspend(dwc->usb3_phy, 1);
 
-        pm_runtime_put(&pdev->dev);
+        pm_runtime_put_sync(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
 
         dwc3_debugfs_exit(dwc);
@@ -691,7 +691,6 @@ static int dwc3_resume(struct device *dev)
 
         usb_phy_init(dwc->usb3_phy);
         usb_phy_init(dwc->usb2_phy);
-        msleep(100);
 
         spin_lock_irqsave(&dwc->lock, flags);
 
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index 2f2e88a3a11a..8b20c70d91e7 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -119,10 +119,9 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err1;
 
         platform_set_drvdata(pdev, exynos);
 
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index 9b138129e856..31443aeedcdb 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -28,6 +28,8 @@
 /* FIXME define these in <linux/pci_ids.h> */
 #define PCI_VENDOR_ID_SYNOPSYS          0x16c3
 #define PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3 0xabcd
+#define PCI_DEVICE_ID_INTEL_BYT         0x0f37
+#define PCI_DEVICE_ID_INTEL_MRFLD       0x119e
 
 struct dwc3_pci {
         struct device           *dev;
@@ -163,7 +165,6 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         return 0;
 
 err3:
-        pci_set_drvdata(pci, NULL);
         platform_device_put(dwc3);
 err1:
         pci_disable_device(pci);
@@ -178,7 +179,6 @@ static void dwc3_pci_remove(struct pci_dev *pci)
         platform_device_unregister(glue->dwc3);
         platform_device_unregister(glue->usb2_phy);
         platform_device_unregister(glue->usb3_phy);
-        pci_set_drvdata(pci, NULL);
         pci_disable_device(pci);
 }
 
@@ -187,6 +187,8 @@ static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = {
                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
         },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT), },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_MRFLD), },
         {  }    /* Terminating Entry */
 };
 MODULE_DEVICE_TABLE(pci, dwc3_pci_id_table);
diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c
index 7fa93f4bc507..95f7649c71a7 100644
--- a/drivers/usb/dwc3/ep0.c
+++ b/drivers/usb/dwc3/ep0.c
@@ -352,7 +352,7 @@ static int dwc3_ep0_handle_status(struct dwc3 *dwc,
                 break;
         default:
                 return -EINVAL;
-        };
+        }
 
         response_pkt = (__le16 *) dwc->setup_buf;
         *response_pkt = cpu_to_le16(usb_status);
@@ -470,7 +470,7 @@ static int dwc3_ep0_handle_feature(struct dwc3 *dwc,
 
         default:
                 return -EINVAL;
-        };
+        }
 
         return 0;
 }
@@ -709,7 +709,7 @@ static int dwc3_ep0_std_request(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
                 dev_vdbg(dwc->dev, "Forwarding to gadget driver\n");
                 ret = dwc3_ep0_delegate_req(dwc, ctrl);
                 break;
-        };
+        }
 
         return ret;
 }
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index f168eaebdef8..5452c0fce360 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -2611,15 +2611,13 @@ int dwc3_gadget_init(struct dwc3 *dwc)
         ret = usb_add_gadget_udc(dwc->dev, &dwc->gadget);
         if (ret) {
                 dev_err(dwc->dev, "failed to register udc\n");
-                goto err5;
+                goto err4;
         }
 
         return 0;
 
-err5:
-        dwc3_gadget_free_endpoints(dwc);
-
 err4:
+        dwc3_gadget_free_endpoints(dwc);
         dma_free_coherent(dwc->dev, DWC3_EP0_BOUNCE_SIZE,
                         dwc->ep0_bounce, dwc->ep0_bounce_addr);
 
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index 5e29ddeb4d33..8cfc3191be50 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -568,10 +568,6 @@ try_again:
                 dbgp_printk("Could not find attached debug device\n");
                 goto err;
         }
-        if (ret < 0) {
-                dbgp_printk("Attached device is not a debug device\n");
-                goto err;
-        }
         dbgp_endpoint_out = dbgp_desc.bDebugOutEndpoint;
         dbgp_endpoint_in = dbgp_desc.bDebugInEndpoint;
 
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 30e2dd8a1f2c..a91e6422f930 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -58,6 +58,20 @@ config USB_GADGET_DEBUG
            trying to track down.  Never enable these messages for a
            production build.
 
+config USB_GADGET_VERBOSE
+        bool "Verbose debugging Messages (DEVELOPMENT)"
+        depends on USB_GADGET_DEBUG
+        help
+           Many controller and gadget drivers will print verbose debugging
+           messages if you use this option to ask for those messages.
+
+           Avoid enabling these messages, even if you're actively
+           debugging such a driver.  Many drivers will emit so many
+           messages that the driver timings are affected, which will
+           either create new failure modes or remove the one you're
+           trying to track down.  Never enable these messages for a
+           production build.
+
 config USB_GADGET_DEBUG_FILES
         boolean "Debugging information files (DEVELOPMENT)"
         depends on PROC_FS
@@ -313,7 +327,7 @@ config USB_S3C_HSUDC
 
 config USB_MV_UDC
         tristate "Marvell USB2.0 Device Controller"
-        depends on GENERIC_HARDIRQS && HAS_DMA
+        depends on HAS_DMA
         help
           Marvell Socs (including PXA and MMP series) include a high speed
           USB2.0 OTG controller, which can be configured as high speed or
@@ -425,7 +439,7 @@ config USB_GOKU
 
 config USB_EG20T
         tristate "Intel EG20T PCH/LAPIS Semiconductor IOH(ML7213/ML7831) UDC"
-        depends on PCI && GENERIC_HARDIRQS
+        depends on PCI
         help
           This is a USB device driver for EG20T PCH.
           EG20T PCH is the platform controller hub that is used in Intel's
@@ -525,6 +539,9 @@ config USB_F_SUBSET
 config USB_F_RNDIS
         tristate
 
+config USB_F_MASS_STORAGE
+        tristate
+
 choice
         tristate "USB Gadget Drivers"
         default USB_ETH
@@ -662,6 +679,16 @@ config USB_CONFIGFS_PHONET
         help
           The Phonet protocol implementation for USB device.
 
+config USB_CONFIGFS_MASS_STORAGE
+        boolean "Mass storage"
+        depends on USB_CONFIGFS
+        select USB_F_MASS_STORAGE
+        help
+          The Mass Storage Gadget acts as a USB Mass Storage disk drive.
+          As its storage repository it can use a regular file or a block
+          device (in much the same way as the "loop" device driver),
+          specified as a module parameter or sysfs option.
+
 config USB_ZERO
         tristate "Gadget Zero (DEVELOPMENT)"
         select USB_LIBCOMPOSITE
@@ -878,6 +905,7 @@ config USB_MASS_STORAGE
         tristate "Mass Storage Gadget"
         depends on BLOCK
         select USB_LIBCOMPOSITE
+        select USB_F_MASS_STORAGE
         help
           The Mass Storage Gadget acts as a USB Mass Storage disk drive.
           As its storage repository it can use a regular file or a block
@@ -1001,6 +1029,7 @@ config USB_G_ACM_MS
         select USB_LIBCOMPOSITE
         select USB_U_SERIAL
         select USB_F_ACM
+        select USB_F_MASS_STORAGE
         help
           This driver provides two functions in one configuration:
           a mass storage, and a CDC ACM (serial port) link.
@@ -1015,8 +1044,8 @@ config USB_G_MULTI
         select USB_LIBCOMPOSITE
         select USB_U_SERIAL
         select USB_U_ETHER
-        select USB_U_RNDIS
         select USB_F_ACM
+        select USB_F_MASS_STORAGE
         help
           The Multifunction Composite Gadget provides Ethernet (RNDIS
           and/or CDC Ethernet), mass storage and ACM serial link
@@ -1035,6 +1064,8 @@ config USB_G_MULTI
 config USB_G_MULTI_RNDIS
         bool "RNDIS + CDC Serial + Storage configuration"
         depends on USB_G_MULTI
+        select USB_U_RNDIS
+        select USB_F_RNDIS
         default y
         help
           This option enables a configuration with RNDIS, CDC Serial and
@@ -1048,6 +1079,7 @@ config USB_G_MULTI_CDC
         bool "CDC Ethernet + CDC Serial + Storage configuration"
         depends on USB_G_MULTI
         default n
+        select USB_F_ECM
         help
           This option enables a configuration with CDC Ethernet (ECM), CDC
           Serial and Mass Storage functions available in the Multifunction
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 386db9daf1d9..f1af39603d4d 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -1,7 +1,8 @@
 #
 # USB peripheral controller drivers
 #
-ccflags-$(CONFIG_USB_GADGET_DEBUG) := -DDEBUG
+ccflags-$(CONFIG_USB_GADGET_DEBUG)      := -DDEBUG
+ccflags-$(CONFIG_USB_GADGET_VERBOSE)    += -DVERBOSE_DEBUG
 
 obj-$(CONFIG_USB_GADGET)        += udc-core.o
 obj-$(CONFIG_USB_LIBCOMPOSITE)  += libcomposite.o
@@ -60,6 +61,8 @@ usb_f_ecm_subset-y		:= f_subset.o
 obj-$(CONFIG_USB_F_SUBSET)      += usb_f_ecm_subset.o
 usb_f_rndis-y                   := f_rndis.o
 obj-$(CONFIG_USB_F_RNDIS)       += usb_f_rndis.o
+usb_f_mass_storage-y            := f_mass_storage.o storage_common.o
+obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
 
 #
 # USB gadget drivers
diff --git a/drivers/usb/gadget/acm_ms.c b/drivers/usb/gadget/acm_ms.c
index 4b947bb50f62..7bfa134fe0e3 100644
--- a/drivers/usb/gadget/acm_ms.c
+++ b/drivers/usb/gadget/acm_ms.c
@@ -31,16 +31,7 @@
 #define ACM_MS_VENDOR_NUM       0x1d6b  /* Linux Foundation */
 #define ACM_MS_PRODUCT_NUM      0x0106  /* Composite Gadget: ACM + MS*/
 
-/*-------------------------------------------------------------------------*/
-
-/*
- * Kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
- */
-#include "f_mass_storage.c"
+#include "f_mass_storage.h"
 
 /*-------------------------------------------------------------------------*/
 USB_GADGET_COMPOSITE_OPTIONS();
@@ -104,18 +95,35 @@ static struct usb_gadget_strings *dev_strings[] = {
 /****************************** Configurations ******************************/
 
 static struct fsg_module_parameters fsg_mod_data = { .stall = 1 };
-FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
 
-static struct fsg_common fsg_common;
+static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
+
+#else
+
+/*
+ * Number of buffers we will use.
+ * 2 is usually enough for good buffering pipeline
+ */
+#define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
+
+#endif /* CONFIG_USB_DEBUG */
+
+FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
 
 /*-------------------------------------------------------------------------*/
 static struct usb_function *f_acm;
 static struct usb_function_instance *f_acm_inst;
+
+static struct usb_function_instance *fi_msg;
+static struct usb_function *f_msg;
+
 /*
  * We _always_ have both ACM and mass storage functions.
  */
 static int __init acm_ms_do_config(struct usb_configuration *c)
 {
+        struct fsg_opts *opts;
         int     status;
 
         if (gadget_is_otg(c->cdev->gadget)) {
@@ -123,31 +131,37 @@ static int __init acm_ms_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        f_acm_inst = usb_get_function_instance("acm");
-        if (IS_ERR(f_acm_inst))
-                return PTR_ERR(f_acm_inst);
+        opts = fsg_opts_from_func_inst(fi_msg);
 
         f_acm = usb_get_function(f_acm_inst);
-        if (IS_ERR(f_acm)) {
-                status = PTR_ERR(f_acm);
-                goto err_func;
+        if (IS_ERR(f_acm))
+                return PTR_ERR(f_acm);
+
+        f_msg = usb_get_function(fi_msg);
+        if (IS_ERR(f_msg)) {
+                status = PTR_ERR(f_msg);
+                goto put_acm;
         }
 
         status = usb_add_function(c, f_acm);
         if (status < 0)
-                goto err_conf;
+                goto put_msg;
 
-        status = fsg_bind_config(c->cdev, c, &fsg_common);
-        if (status < 0)
-                goto err_fsg;
+        status = fsg_common_run_thread(opts->common);
+        if (status)
+                goto remove_acm;
+
+        status = usb_add_function(c, f_msg);
+        if (status)
+                goto remove_acm;
 
         return 0;
-err_fsg:
+remove_acm:
         usb_remove_function(c, f_acm);
-err_conf:
+put_msg:
+        usb_put_function(f_msg);
+put_acm:
         usb_put_function(f_acm);
-err_func:
-        usb_put_function_instance(f_acm_inst);
         return status;
 }
 
@@ -163,45 +177,82 @@ static struct usb_configuration acm_ms_config_driver = {
 static int __init acm_ms_bind(struct usb_composite_dev *cdev)
 {
         struct usb_gadget       *gadget = cdev->gadget;
+        struct fsg_opts         *opts;
+        struct fsg_config       config;
         int                     status;
-        void                    *retp;
 
-        /* set up mass storage function */
-        retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
-        if (IS_ERR(retp)) {
-                status = PTR_ERR(retp);
-                return PTR_ERR(retp);
+        f_acm_inst = usb_get_function_instance("acm");
+        if (IS_ERR(f_acm_inst))
+                return PTR_ERR(f_acm_inst);
+
+        fi_msg = usb_get_function_instance("mass_storage");
+        if (IS_ERR(fi_msg)) {
+                status = PTR_ERR(fi_msg);
+                goto fail_get_msg;
         }
 
+        /* set up mass storage function */
+        fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers);
+        opts = fsg_opts_from_func_inst(fi_msg);
+
+        opts->no_configfs = true;
+        status = fsg_common_set_num_buffers(opts->common, fsg_num_buffers);
+        if (status)
+                goto fail;
+
+        status = fsg_common_set_nluns(opts->common, config.nluns);
+        if (status)
+                goto fail_set_nluns;
+
+        status = fsg_common_set_cdev(opts->common, cdev, config.can_stall);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_sysfs(opts->common, true);
+        status = fsg_common_create_luns(opts->common, &config);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_inquiry_string(opts->common, config.vendor_name,
+                                      config.product_name);
         /*
          * Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
         status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
-                goto fail1;
+                goto fail_string_ids;
         device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
         device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register our configuration */
         status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config);
         if (status < 0)
-                goto fail1;
+                goto fail_string_ids;
 
         usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
                         DRIVER_DESC);
-        fsg_common_put(&fsg_common);
         return 0;
 
         /* error recovery */
-fail1:
-        fsg_common_put(&fsg_common);
+fail_string_ids:
+        fsg_common_remove_luns(opts->common);
+fail_set_cdev:
+        fsg_common_free_luns(opts->common);
+fail_set_nluns:
+        fsg_common_free_buffers(opts->common);
+fail:
+        usb_put_function_instance(fi_msg);
+fail_get_msg:
+        usb_put_function_instance(f_acm_inst);
         return status;
 }
 
 static int __exit acm_ms_unbind(struct usb_composite_dev *cdev)
 {
+        usb_put_function(f_msg);
+        usb_put_function_instance(fi_msg);
         usb_put_function(f_acm);
         usb_put_function_instance(f_acm_inst);
         return 0;
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index a9a4346c83aa..54a1e2954cea 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -3078,8 +3078,6 @@ static void udc_pci_remove(struct pci_dev *pdev)
         if (dev->active)
                 pci_disable_device(pdev);
 
-        pci_set_drvdata(pdev, NULL);
-
         udc_remove(dev);
 }
 
diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
index 5a5acf22c694..e126b6b248e6 100644
--- a/drivers/usb/gadget/cdc2.c
+++ b/drivers/usb/gadget/cdc2.c
@@ -113,12 +113,6 @@ static int __init cdc_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        fi_ecm = usb_get_function_instance("ecm");
-        if (IS_ERR(fi_ecm)) {
-                status = PTR_ERR(fi_ecm);
-                goto err_func_ecm;
-        }
-
         f_ecm = usb_get_function(fi_ecm);
         if (IS_ERR(f_ecm)) {
                 status = PTR_ERR(f_ecm);
@@ -129,35 +123,24 @@ static int __init cdc_do_config(struct usb_configuration *c)
         if (status)
                 goto err_add_ecm;
 
-        fi_serial = usb_get_function_instance("acm");
-        if (IS_ERR(fi_serial)) {
-                status = PTR_ERR(fi_serial);
-                goto err_get_acm;
-        }
-
         f_acm = usb_get_function(fi_serial);
         if (IS_ERR(f_acm)) {
                 status = PTR_ERR(f_acm);
-                goto err_func_acm;
+                goto err_get_acm;
         }
 
         status = usb_add_function(c, f_acm);
         if (status)
                 goto err_add_acm;
-
         return 0;
 
 err_add_acm:
         usb_put_function(f_acm);
-err_func_acm:
-        usb_put_function_instance(fi_serial);
 err_get_acm:
         usb_remove_function(c, f_ecm);
 err_add_ecm:
         usb_put_function(f_ecm);
 err_get_ecm:
-        usb_put_function_instance(fi_ecm);
-err_func_ecm:
         return status;
 }
 
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index d4f0f3305759..3e7ae707f691 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -354,7 +354,7 @@ static u8 encode_bMaxPower(enum usb_device_speed speed,
                 return DIV_ROUND_UP(val, 8);
         default:
                 return DIV_ROUND_UP(val, 2);
-        };
+        }
 }
 
 static int config_buf(struct usb_configuration *config,
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
index 8f0d6141e5e6..25885112fa35 100644
--- a/drivers/usb/gadget/configfs.c
+++ b/drivers/usb/gadget/configfs.c
@@ -557,7 +557,7 @@ static struct config_group *function_make(
 
         fi = usb_get_function_instance(func_name);
         if (IS_ERR(fi))
-                return ERR_PTR(PTR_ERR(fi));
+                return ERR_CAST(fi);
 
         ret = config_item_set_name(&fi->group.cg_item, name);
         if (ret) {
@@ -991,6 +991,14 @@ static struct configfs_subsystem gadget_subsys = {
         .su_mutex = __MUTEX_INITIALIZER(gadget_subsys.su_mutex),
 };
 
+void unregister_gadget_item(struct config_item *item)
+{
+        struct gadget_info *gi = to_gadget_info(item);
+
+        unregister_gadget(gi);
+}
+EXPORT_SYMBOL(unregister_gadget_item);
+
 static int __init gadget_cfs_init(void)
 {
         int ret;
diff --git a/drivers/usb/gadget/configfs.h b/drivers/usb/gadget/configfs.h
new file mode 100644
index 000000000000..a7b564a913d1
--- /dev/null
+++ b/drivers/usb/gadget/configfs.h
@@ -0,0 +1,6 @@
+#ifndef USB__GADGET__CONFIGFS__H
+#define USB__GADGET__CONFIGFS__H
+
+void unregister_gadget_item(struct config_item *item);
+
+#endif /*  USB__GADGET__CONFIGFS__H */
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 06ecd08fd57a..8f4dae310923 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -544,7 +544,7 @@ static int dummy_enable(struct usb_ep *_ep,
                  default:
                          val = "ctrl";
                          break;
-                 }; val; }),
+                 } val; }),
                 max, ep->stream_en ? "enabled" : "disabled");
 
         /* at this point real hardware should be NAKing transfers
@@ -923,8 +923,9 @@ static int dummy_udc_stop(struct usb_gadget *g,
         struct dummy_hcd        *dum_hcd = gadget_to_dummy_hcd(g);
         struct dummy            *dum = dum_hcd->dum;
 
-        dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
-                        driver->driver.name);
+        if (driver)
+                dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
+                                driver->driver.name);
 
         dum->driver = NULL;
 
@@ -1000,8 +1001,8 @@ static int dummy_udc_remove(struct platform_device *pdev)
 {
         struct dummy    *dum = platform_get_drvdata(pdev);
 
-        usb_del_gadget_udc(&dum->gadget);
         device_remove_file(&dum->gadget.dev, &dev_attr_function);
+        usb_del_gadget_udc(&dum->gadget);
         return 0;
 }
 
@@ -2270,7 +2271,7 @@ static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
                 default:
                         s = "?";
                         break;
-                 }; s; }),
+                 } s; }),
                 ep, ep ? (usb_pipein(urb->pipe) ? "in" : "out") : "",
                 ({ char *s; \
                 switch (usb_pipetype(urb->pipe)) { \
@@ -2286,7 +2287,7 @@ static inline ssize_t show_urb(char *buf, size_t size, struct urb *urb)
                 default: \
                         s = "-iso"; \
                         break; \
-                }; s; }),
+                } s; }),
                 urb->actual_length, urb->transfer_buffer_length);
 }
 
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index edab45da3741..8d9e6f7e8f1a 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -995,7 +995,7 @@ static void ecm_unbind(struct usb_configuration *c, struct usb_function *f)
         usb_ep_free_request(ecm->notify, ecm->notify_req);
 }
 
-struct usb_function *ecm_alloc(struct usb_function_instance *fi)
+static struct usb_function *ecm_alloc(struct usb_function_instance *fi)
 {
         struct f_ecm    *ecm;
         struct f_ecm_opts *opts;
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
index d00392d879db..d61c11d765d0 100644
--- a/drivers/usb/gadget/f_eem.c
+++ b/drivers/usb/gadget/f_eem.c
@@ -624,7 +624,7 @@ static void eem_unbind(struct usb_configuration *c, struct usb_function *f)
         usb_free_all_descriptors(f);
 }
 
-struct usb_function *eem_alloc(struct usb_function_instance *fi)
+static struct usb_function *eem_alloc(struct usb_function_instance *fi)
 {
         struct f_eem    *eem;
         struct f_eem_opts *opts;
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 1a66c5baa0d1..774e8b89cdb5 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -373,7 +373,7 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
         if (req->buf == NULL)
                 req->buf = (void *)0xDEADBABE;
 
-        INIT_COMPLETION(ffs->ep0req_completion);
+        reinit_completion(&ffs->ep0req_completion);
 
         ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
         if (unlikely(ret < 0))
@@ -1034,37 +1034,19 @@ struct ffs_sb_fill_data {
         struct ffs_file_perms perms;
         umode_t root_mode;
         const char *dev_name;
-        union {
-                /* set by ffs_fs_mount(), read by ffs_sb_fill() */
-                void *private_data;
-                /* set by ffs_sb_fill(), read by ffs_fs_mount */
-                struct ffs_data *ffs_data;
-        };
+        struct ffs_data *ffs_data;
 };
 
 static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
 {
         struct ffs_sb_fill_data *data = _data;
         struct inode    *inode;
-        struct ffs_data *ffs;
+        struct ffs_data *ffs = data->ffs_data;
 
         ENTER();
 
-        /* Initialise data */
-        ffs = ffs_data_new();
-        if (unlikely(!ffs))
-                goto Enomem;
-
         ffs->sb              = sb;
-        ffs->dev_name        = kstrdup(data->dev_name, GFP_KERNEL);
-        if (unlikely(!ffs->dev_name))
-                goto Enomem;
-        ffs->file_perms      = data->perms;
-        ffs->private_data    = data->private_data;
-
-        /* used by the caller of this function */
-        data->ffs_data       = ffs;
-
+        data->ffs_data       = NULL;
         sb->s_fs_info        = ffs;
         sb->s_blocksize      = PAGE_CACHE_SIZE;
         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
@@ -1080,17 +1062,14 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
                                   &data->perms);
         sb->s_root = d_make_root(inode);
         if (unlikely(!sb->s_root))
-                goto Enomem;
+                return -ENOMEM;
 
         /* EP0 file */
         if (unlikely(!ffs_sb_create_file(sb, "ep0", ffs,
                                          &ffs_ep0_operations, NULL)))
-                goto Enomem;
+                return -ENOMEM;
 
         return 0;
-
-Enomem:
-        return -ENOMEM;
 }
 
 static int ffs_fs_parse_opts(struct ffs_sb_fill_data *data, char *opts)
@@ -1193,6 +1172,7 @@ ffs_fs_mount(struct file_system_type *t, int flags,
         struct dentry *rv;
         int ret;
         void *ffs_dev;
+        struct ffs_data *ffs;
 
         ENTER();
 
@@ -1200,18 +1180,30 @@ ffs_fs_mount(struct file_system_type *t, int flags,
         if (unlikely(ret < 0))
                 return ERR_PTR(ret);
 
+        ffs = ffs_data_new();
+        if (unlikely(!ffs))
+                return ERR_PTR(-ENOMEM);
+        ffs->file_perms = data.perms;
+
+        ffs->dev_name = kstrdup(dev_name, GFP_KERNEL);
+        if (unlikely(!ffs->dev_name)) {
+                ffs_data_put(ffs);
+                return ERR_PTR(-ENOMEM);
+        }
+
         ffs_dev = functionfs_acquire_dev_callback(dev_name);
-        if (IS_ERR(ffs_dev))
-                return ffs_dev;
+        if (IS_ERR(ffs_dev)) {
+                ffs_data_put(ffs);
+                return ERR_CAST(ffs_dev);
+        }
+        ffs->private_data = ffs_dev;
+        data.ffs_data = ffs;
 
-        data.dev_name = dev_name;
-        data.private_data = ffs_dev;
         rv = mount_nodev(t, flags, &data, ffs_sb_fill);
-
-        /* data.ffs_data is set by ffs_sb_fill */
-        if (IS_ERR(rv))
+        if (IS_ERR(rv) && data.ffs_data) {
                 functionfs_release_dev_callback(data.ffs_data);
-
+                ffs_data_put(data.ffs_data);
+        }
         return rv;
 }
 
@@ -2264,6 +2256,8 @@ static int ffs_func_bind(struct usb_configuration *c,
                                    data->raw_descs + ret,
                                    (sizeof data->raw_descs) - ret,
                                    __ffs_func_bind_do_descs, func);
+                if (unlikely(ret < 0))
+                        goto error;
         }
 
         /*
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 313b835eedfd..a03ba2c83589 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -213,12 +213,14 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/freezer.h>
+#include <linux/module.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/composite.h>
 
 #include "gadget_chips.h"
+#include "configfs.h"
 
 
 /*------------------------------------------------------------------------*/
@@ -228,26 +230,30 @@
 
 static const char fsg_string_interface[] = "Mass Storage";
 
-#include "storage_common.c"
+#include "storage_common.h"
+#include "f_mass_storage.h"
 
+/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
+static struct usb_string                fsg_strings[] = {
+        {FSG_STRING_INTERFACE,          fsg_string_interface},
+        {}
+};
+
+static struct usb_gadget_strings        fsg_stringtab = {
+        .language       = 0x0409,               /* en-us */
+        .strings        = fsg_strings,
+};
+
+static struct usb_gadget_strings *fsg_strings_array[] = {
+        &fsg_stringtab,
+        NULL,
+};
 
 /*-------------------------------------------------------------------------*/
 
 struct fsg_dev;
 struct fsg_common;
 
-/* FSF callback functions */
-struct fsg_operations {
-        /*
-         * Callback function to call when thread exits.  If no
-         * callback is set or it returns value lower then zero MSF
-         * will force eject all LUNs it operates on (including those
-         * marked as non-removable or with prevent_medium_removal flag
-         * set).
-         */
-        int (*thread_exits)(struct fsg_common *common);
-};
-
 /* Data shared by all the FSG instances. */
 struct fsg_common {
         struct usb_gadget       *gadget;
@@ -268,13 +274,14 @@ struct fsg_common {
         struct fsg_buffhd       *next_buffhd_to_fill;
         struct fsg_buffhd       *next_buffhd_to_drain;
         struct fsg_buffhd       *buffhds;
+        unsigned int            fsg_num_buffers;
 
         int                     cmnd_size;
         u8                      cmnd[MAX_COMMAND_SIZE];
 
         unsigned int            nluns;
         unsigned int            lun;
-        struct fsg_lun          *luns;
+        struct fsg_lun          **luns;
         struct fsg_lun          *curlun;
 
         unsigned int            bulk_out_maxpacket;
@@ -294,6 +301,7 @@ struct fsg_common {
         unsigned int            short_packet_received:1;
         unsigned int            bad_lun_okay:1;
         unsigned int            running:1;
+        unsigned int            sysfs:1;
 
         int                     thread_wakeup_needed;
         struct completion       thread_notifier;
@@ -313,27 +321,6 @@ struct fsg_common {
         struct kref             ref;
 };
 
-struct fsg_config {
-        unsigned nluns;
-        struct fsg_lun_config {
-                const char *filename;
-                char ro;
-                char removable;
-                char cdrom;
-                char nofua;
-        } luns[FSG_MAX_LUNS];
-
-        /* Callback functions. */
-        const struct fsg_operations     *ops;
-        /* Gadget's private data. */
-        void                    *private_data;
-
-        const char *vendor_name;                /*  8 characters or less */
-        const char *product_name;               /* 16 characters or less */
-
-        char                    can_stall;
-};
-
 struct fsg_dev {
         struct usb_function     function;
         struct usb_gadget       *gadget;        /* Copy of cdev->gadget */
@@ -2172,7 +2159,7 @@ static int received_cbw(struct fsg_dev *fsg, struct fsg_buffhd *bh)
                 common->data_dir = DATA_DIR_NONE;
         common->lun = cbw->Lun;
         if (common->lun < common->nluns)
-                common->curlun = &common->luns[common->lun];
+                common->curlun = common->luns[common->lun];
         else
                 common->curlun = NULL;
         common->tag = cbw->Tag;
@@ -2244,7 +2231,7 @@ reset:
         if (common->fsg) {
                 fsg = common->fsg;
 
-                for (i = 0; i < fsg_num_buffers; ++i) {
+                for (i = 0; i < common->fsg_num_buffers; ++i) {
                         struct fsg_buffhd *bh = &common->buffhds[i];
 
                         if (bh->inreq) {
@@ -2260,10 +2247,12 @@ reset:
                 /* Disable the endpoints */
                 if (fsg->bulk_in_enabled) {
                         usb_ep_disable(fsg->bulk_in);
+                        fsg->bulk_in->driver_data = NULL;
                         fsg->bulk_in_enabled = 0;
                 }
                 if (fsg->bulk_out_enabled) {
                         usb_ep_disable(fsg->bulk_out);
+                        fsg->bulk_out->driver_data = NULL;
                         fsg->bulk_out_enabled = 0;
                 }
 
@@ -2301,7 +2290,7 @@ reset:
         clear_bit(IGNORE_BULK_OUT, &fsg->atomic_bitflags);
 
         /* Allocate the requests */
-        for (i = 0; i < fsg_num_buffers; ++i) {
+        for (i = 0; i < common->fsg_num_buffers; ++i) {
                 struct fsg_buffhd       *bh = &common->buffhds[i];
 
                 rc = alloc_request(common, fsg->bulk_in, &bh->inreq);
@@ -2318,7 +2307,9 @@ reset:
 
         common->running = 1;
         for (i = 0; i < common->nluns; ++i)
-                common->luns[i].unit_attention_data = SS_RESET_OCCURRED;
+                if (common->luns[i])
+                        common->luns[i]->unit_attention_data =
+                                SS_RESET_OCCURRED;
         return rc;
 }
 
@@ -2370,7 +2361,7 @@ static void handle_exception(struct fsg_common *common)
 
         /* Cancel all the pending transfers */
         if (likely(common->fsg)) {
-                for (i = 0; i < fsg_num_buffers; ++i) {
+                for (i = 0; i < common->fsg_num_buffers; ++i) {
                         bh = &common->buffhds[i];
                         if (bh->inreq_busy)
                                 usb_ep_dequeue(common->fsg->bulk_in, bh->inreq);
@@ -2382,7 +2373,7 @@ static void handle_exception(struct fsg_common *common)
                 /* Wait until everything is idle */
                 for (;;) {
                         int num_active = 0;
-                        for (i = 0; i < fsg_num_buffers; ++i) {
+                        for (i = 0; i < common->fsg_num_buffers; ++i) {
                                 bh = &common->buffhds[i];
                                 num_active += bh->inreq_busy + bh->outreq_busy;
                         }
@@ -2405,7 +2396,7 @@ static void handle_exception(struct fsg_common *common)
          */
         spin_lock_irq(&common->lock);
 
-        for (i = 0; i < fsg_num_buffers; ++i) {
+        for (i = 0; i < common->fsg_num_buffers; ++i) {
                 bh = &common->buffhds[i];
                 bh->state = BUF_STATE_EMPTY;
         }
@@ -2418,7 +2409,9 @@ static void handle_exception(struct fsg_common *common)
                 common->state = FSG_STATE_STATUS_PHASE;
         else {
                 for (i = 0; i < common->nluns; ++i) {
-                        curlun = &common->luns[i];
+                        curlun = common->luns[i];
+                        if (!curlun)
+                                continue;
                         curlun->prevent_medium_removal = 0;
                         curlun->sense_data = SS_NO_SENSE;
                         curlun->unit_attention_data = SS_NO_SENSE;
@@ -2460,8 +2453,9 @@ static void handle_exception(struct fsg_common *common)
                  * CONFIG_CHANGE cases.
                  */
                 /* for (i = 0; i < common->nluns; ++i) */
-                /*      common->luns[i].unit_attention_data = */
-                /*              SS_RESET_OCCURRED;  */
+                /*      if (common->luns[i]) */
+                /*              common->luns[i]->unit_attention_data = */
+                /*                      SS_RESET_OCCURRED;  */
                 break;
 
         case FSG_STATE_CONFIG_CHANGE:
@@ -2557,12 +2551,13 @@ static int fsg_main_thread(void *common_)
 
         if (!common->ops || !common->ops->thread_exits
          || common->ops->thread_exits(common) < 0) {
-                struct fsg_lun *curlun = common->luns;
+                struct fsg_lun **curlun_it = common->luns;
                 unsigned i = common->nluns;
 
                 down_write(&common->filesem);
-                for (; i--; ++curlun) {
-                        if (!fsg_lun_is_open(curlun))
+                for (; i--; ++curlun_it) {
+                        struct fsg_lun *curlun = *curlun_it;
+                        if (!curlun || !fsg_lun_is_open(curlun))
                                 continue;
 
                         fsg_lun_close(curlun);
@@ -2578,6 +2573,56 @@ static int fsg_main_thread(void *common_)
 
 /*************************** DEVICE ATTRIBUTES ***************************/
 
+static ssize_t ro_show(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+
+        return fsg_show_ro(curlun, buf);
+}
+
+static ssize_t nofua_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+
+        return fsg_show_nofua(curlun, buf);
+}
+
+static ssize_t file_show(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+
+        return fsg_show_file(curlun, filesem, buf);
+}
+
+static ssize_t ro_store(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+
+        return fsg_store_ro(curlun, filesem, buf, count);
+}
+
+static ssize_t nofua_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+
+        return fsg_store_nofua(curlun, buf, count);
+}
+
+static ssize_t file_store(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
+{
+        struct fsg_lun          *curlun = fsg_lun_from_dev(dev);
+        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
+
+        return fsg_store_file(curlun, filesem, buf, count);
+}
+
 static DEVICE_ATTR_RW(ro);
 static DEVICE_ATTR_RW(nofua);
 static DEVICE_ATTR_RW(file);
@@ -2595,221 +2640,422 @@ static void fsg_lun_release(struct device *dev)
         /* Nothing needs to be done */
 }
 
-static inline void fsg_common_get(struct fsg_common *common)
+void fsg_common_get(struct fsg_common *common)
 {
         kref_get(&common->ref);
 }
+EXPORT_SYMBOL_GPL(fsg_common_get);
 
-static inline void fsg_common_put(struct fsg_common *common)
+void fsg_common_put(struct fsg_common *common)
 {
         kref_put(&common->ref, fsg_common_release);
 }
+EXPORT_SYMBOL_GPL(fsg_common_put);
 
-static struct fsg_common *fsg_common_init(struct fsg_common *common,
-                                          struct usb_composite_dev *cdev,
-                                          struct fsg_config *cfg)
+/* check if fsg_num_buffers is within a valid range */
+static inline int fsg_num_buffers_validate(unsigned int fsg_num_buffers)
 {
-        struct usb_gadget *gadget = cdev->gadget;
-        struct fsg_buffhd *bh;
-        struct fsg_lun *curlun;
-        struct fsg_lun_config *lcfg;
-        int nluns, i, rc;
-        char *pathbuf;
-
-        rc = fsg_num_buffers_validate();
-        if (rc != 0)
-                return ERR_PTR(rc);
-
-        /* Find out how many LUNs there should be */
-        nluns = cfg->nluns;
-        if (nluns < 1 || nluns > FSG_MAX_LUNS) {
-                dev_err(&gadget->dev, "invalid number of LUNs: %u\n", nluns);
-                return ERR_PTR(-EINVAL);
-        }
+        if (fsg_num_buffers >= 2 && fsg_num_buffers <= 4)
+                return 0;
+        pr_err("fsg_num_buffers %u is out of range (%d to %d)\n",
+               fsg_num_buffers, 2, 4);
+        return -EINVAL;
+}
 
-        /* Allocate? */
+static struct fsg_common *fsg_common_setup(struct fsg_common *common)
+{
         if (!common) {
-                common = kzalloc(sizeof *common, GFP_KERNEL);
+                common = kzalloc(sizeof(*common), GFP_KERNEL);
                 if (!common)
                         return ERR_PTR(-ENOMEM);
                 common->free_storage_on_release = 1;
         } else {
-                memset(common, 0, sizeof *common);
                 common->free_storage_on_release = 0;
         }
+        init_rwsem(&common->filesem);
+        spin_lock_init(&common->lock);
+        kref_init(&common->ref);
+        init_completion(&common->thread_notifier);
+        init_waitqueue_head(&common->fsg_wait);
+        common->state = FSG_STATE_TERMINATED;
 
-        common->buffhds = kcalloc(fsg_num_buffers,
-                                  sizeof *(common->buffhds), GFP_KERNEL);
-        if (!common->buffhds) {
-                if (common->free_storage_on_release)
-                        kfree(common);
-                return ERR_PTR(-ENOMEM);
+        return common;
+}
+
+void fsg_common_set_sysfs(struct fsg_common *common, bool sysfs)
+{
+        common->sysfs = sysfs;
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_sysfs);
+
+static void _fsg_common_free_buffers(struct fsg_buffhd *buffhds, unsigned n)
+{
+        if (buffhds) {
+                struct fsg_buffhd *bh = buffhds;
+                while (n--) {
+                        kfree(bh->buf);
+                        ++bh;
+                }
+                kfree(buffhds);
         }
+}
 
-        common->ops = cfg->ops;
-        common->private_data = cfg->private_data;
+int fsg_common_set_num_buffers(struct fsg_common *common, unsigned int n)
+{
+        struct fsg_buffhd *bh, *buffhds;
+        int i, rc;
 
-        common->gadget = gadget;
-        common->ep0 = gadget->ep0;
-        common->ep0req = cdev->req;
-        common->cdev = cdev;
+        rc = fsg_num_buffers_validate(n);
+        if (rc != 0)
+                return rc;
+
+        buffhds = kcalloc(n, sizeof(*buffhds), GFP_KERNEL);
+        if (!buffhds)
+                return -ENOMEM;
 
-        /* Maybe allocate device-global string IDs, and patch descriptors */
-        if (fsg_strings[FSG_STRING_INTERFACE].id == 0) {
-                rc = usb_string_id(cdev);
-                if (unlikely(rc < 0))
+        /* Data buffers cyclic list */
+        bh = buffhds;
+        i = n;
+        goto buffhds_first_it;
+        do {
+                bh->next = bh + 1;
+                ++bh;
+buffhds_first_it:
+                bh->buf = kmalloc(FSG_BUFLEN, GFP_KERNEL);
+                if (unlikely(!bh->buf))
                         goto error_release;
-                fsg_strings[FSG_STRING_INTERFACE].id = rc;
-                fsg_intf_desc.iInterface = rc;
-        }
+        } while (--i);
+        bh->next = buffhds;
 
+        _fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
+        common->fsg_num_buffers = n;
+        common->buffhds = buffhds;
+
+        return 0;
+
+error_release:
         /*
-         * Create the LUNs, open their backing files, and register the
-         * LUN devices in sysfs.
+         * "buf"s pointed to by heads after n - i are NULL
+         * so releasing them won't hurt
          */
-        curlun = kcalloc(nluns, sizeof(*curlun), GFP_KERNEL);
-        if (unlikely(!curlun)) {
-                rc = -ENOMEM;
-                goto error_release;
+        _fsg_common_free_buffers(buffhds, n);
+
+        return -ENOMEM;
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_num_buffers);
+
+static inline void fsg_common_remove_sysfs(struct fsg_lun *lun)
+{
+        device_remove_file(&lun->dev, &dev_attr_nofua);
+        /*
+         * device_remove_file() =>
+         *
+         * here the attr (e.g. dev_attr_ro) is only used to be passed to:
+         *
+         *      sysfs_remove_file() =>
+         *
+         *      here e.g. both dev_attr_ro_cdrom and dev_attr_ro are in
+         *      the same namespace and
+         *      from here only attr->name is passed to:
+         *
+         *              sysfs_hash_and_remove()
+         *
+         *              attr->name is the same for dev_attr_ro_cdrom and
+         *              dev_attr_ro
+         *              attr->name is the same for dev_attr_file and
+         *              dev_attr_file_nonremovable
+         *
+         * so we don't differentiate between removing e.g. dev_attr_ro_cdrom
+         * and dev_attr_ro
+         */
+        device_remove_file(&lun->dev, &dev_attr_ro);
+        device_remove_file(&lun->dev, &dev_attr_file);
+}
+
+void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs)
+{
+        if (sysfs) {
+                fsg_common_remove_sysfs(lun);
+                device_unregister(&lun->dev);
         }
-        common->luns = curlun;
+        fsg_lun_close(lun);
+        kfree(lun);
+}
+EXPORT_SYMBOL_GPL(fsg_common_remove_lun);
 
-        init_rwsem(&common->filesem);
+static void _fsg_common_remove_luns(struct fsg_common *common, int n)
+{
+        int i;
 
-        for (i = 0, lcfg = cfg->luns; i < nluns; ++i, ++curlun, ++lcfg) {
-                curlun->cdrom = !!lcfg->cdrom;
-                curlun->ro = lcfg->cdrom || lcfg->ro;
-                curlun->initially_ro = curlun->ro;
-                curlun->removable = lcfg->removable;
-                curlun->dev.release = fsg_lun_release;
-                curlun->dev.parent = &gadget->dev;
-                /* curlun->dev.driver = &fsg_driver.driver; XXX */
-                dev_set_drvdata(&curlun->dev, &common->filesem);
-                dev_set_name(&curlun->dev, "lun%d", i);
-
-                rc = device_register(&curlun->dev);
-                if (rc) {
-                        INFO(common, "failed to register LUN%d: %d\n", i, rc);
-                        common->nluns = i;
-                        put_device(&curlun->dev);
-                        goto error_release;
+        for (i = 0; i < n; ++i)
+                if (common->luns[i]) {
+                        fsg_common_remove_lun(common->luns[i], common->sysfs);
+                        common->luns[i] = NULL;
                 }
+}
+EXPORT_SYMBOL_GPL(fsg_common_remove_luns);
 
-                rc = device_create_file(&curlun->dev,
-                                        curlun->cdrom
-                                      ? &dev_attr_ro_cdrom
-                                      : &dev_attr_ro);
-                if (rc)
-                        goto error_luns;
-                rc = device_create_file(&curlun->dev,
-                                        curlun->removable
-                                      ? &dev_attr_file
-                                      : &dev_attr_file_nonremovable);
-                if (rc)
-                        goto error_luns;
-                rc = device_create_file(&curlun->dev, &dev_attr_nofua);
-                if (rc)
-                        goto error_luns;
+void fsg_common_remove_luns(struct fsg_common *common)
+{
+        _fsg_common_remove_luns(common, common->nluns);
+}
 
-                if (lcfg->filename) {
-                        rc = fsg_lun_open(curlun, lcfg->filename);
-                        if (rc)
-                                goto error_luns;
-                } else if (!curlun->removable) {
-                        ERROR(common, "no file given for LUN%d\n", i);
-                        rc = -EINVAL;
-                        goto error_luns;
-                }
+void fsg_common_free_luns(struct fsg_common *common)
+{
+        fsg_common_remove_luns(common);
+        kfree(common->luns);
+        common->luns = NULL;
+}
+EXPORT_SYMBOL_GPL(fsg_common_free_luns);
+
+int fsg_common_set_nluns(struct fsg_common *common, int nluns)
+{
+        struct fsg_lun **curlun;
+
+        /* Find out how many LUNs there should be */
+        if (nluns < 1 || nluns > FSG_MAX_LUNS) {
+                pr_err("invalid number of LUNs: %u\n", nluns);
+                return -EINVAL;
         }
+
+        curlun = kcalloc(nluns, sizeof(*curlun), GFP_KERNEL);
+        if (unlikely(!curlun))
+                return -ENOMEM;
+
+        if (common->luns)
+                fsg_common_free_luns(common);
+
+        common->luns = curlun;
         common->nluns = nluns;
 
-        /* Data buffers cyclic list */
-        bh = common->buffhds;
-        i = fsg_num_buffers;
-        goto buffhds_first_it;
-        do {
-                bh->next = bh + 1;
-                ++bh;
-buffhds_first_it:
-                bh->buf = kmalloc(FSG_BUFLEN, GFP_KERNEL);
-                if (unlikely(!bh->buf)) {
-                        rc = -ENOMEM;
-                        goto error_release;
-                }
-        } while (--i);
-        bh->next = common->buffhds;
+        pr_info("Number of LUNs=%d\n", common->nluns);
 
-        /* Prepare inquiryString */
-        i = get_default_bcdDevice();
-        snprintf(common->inquiry_string, sizeof common->inquiry_string,
-                 "%-8s%-16s%04x", cfg->vendor_name ?: "Linux",
-                 /* Assume product name dependent on the first LUN */
-                 cfg->product_name ?: (common->luns->cdrom
-                                     ? "File-CD Gadget"
-                                     : "File-Stor Gadget"),
-                 i);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_nluns);
+
+void fsg_common_set_ops(struct fsg_common *common,
+                        const struct fsg_operations *ops)
+{
+        common->ops = ops;
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_ops);
+
+void fsg_common_free_buffers(struct fsg_common *common)
+{
+        _fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
+        common->buffhds = NULL;
+}
+EXPORT_SYMBOL_GPL(fsg_common_free_buffers);
+
+int fsg_common_set_cdev(struct fsg_common *common,
+                         struct usb_composite_dev *cdev, bool can_stall)
+{
+        struct usb_string *us;
+
+        common->gadget = cdev->gadget;
+        common->ep0 = cdev->gadget->ep0;
+        common->ep0req = cdev->req;
+        common->cdev = cdev;
+
+        us = usb_gstrings_attach(cdev, fsg_strings_array,
+                                 ARRAY_SIZE(fsg_strings));
+        if (IS_ERR(us))
+                return PTR_ERR(us);
+
+        fsg_intf_desc.iInterface = us[FSG_STRING_INTERFACE].id;
 
         /*
          * Some peripheral controllers are known not to be able to
          * halt bulk endpoints correctly.  If one of them is present,
          * disable stalls.
          */
-        common->can_stall = cfg->can_stall &&
-                !(gadget_is_at91(common->gadget));
+        common->can_stall = can_stall && !(gadget_is_at91(common->gadget));
 
-        spin_lock_init(&common->lock);
-        kref_init(&common->ref);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_cdev);
 
-        /* Tell the thread to start working */
-        common->thread_task =
-                kthread_create(fsg_main_thread, common, "file-storage");
-        if (IS_ERR(common->thread_task)) {
-                rc = PTR_ERR(common->thread_task);
-                goto error_release;
+static inline int fsg_common_add_sysfs(struct fsg_common *common,
+                                       struct fsg_lun *lun)
+{
+        int rc;
+
+        rc = device_register(&lun->dev);
+        if (rc) {
+                put_device(&lun->dev);
+                return rc;
         }
-        init_completion(&common->thread_notifier);
-        init_waitqueue_head(&common->fsg_wait);
 
-        /* Information */
-        INFO(common, FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
-        INFO(common, "Number of LUNs=%d\n", common->nluns);
+        rc = device_create_file(&lun->dev,
+                                lun->cdrom
+                              ? &dev_attr_ro_cdrom
+                              : &dev_attr_ro);
+        if (rc)
+                goto error;
+        rc = device_create_file(&lun->dev,
+                                lun->removable
+                              ? &dev_attr_file
+                              : &dev_attr_file_nonremovable);
+        if (rc)
+                goto error;
+        rc = device_create_file(&lun->dev, &dev_attr_nofua);
+        if (rc)
+                goto error;
+
+        return 0;
+
+error:
+        /* removing nonexistent files is a no-op */
+        fsg_common_remove_sysfs(lun);
+        device_unregister(&lun->dev);
+        return rc;
+}
+
+int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
+                          unsigned int id, const char *name,
+                          const char **name_pfx)
+{
+        struct fsg_lun *lun;
+        char *pathbuf, *p;
+        int rc = -ENOMEM;
+
+        if (!common->nluns || !common->luns)
+                return -ENODEV;
+
+        if (common->luns[id])
+                return -EBUSY;
+
+        if (!cfg->filename && !cfg->removable) {
+                pr_err("no file given for LUN%d\n", id);
+                return -EINVAL;
+        }
+
+        lun = kzalloc(sizeof(*lun), GFP_KERNEL);
+        if (!lun)
+                return -ENOMEM;
+
+        lun->name_pfx = name_pfx;
+
+        lun->cdrom = !!cfg->cdrom;
+        lun->ro = cfg->cdrom || cfg->ro;
+        lun->initially_ro = lun->ro;
+        lun->removable = !!cfg->removable;
+
+        if (!common->sysfs) {
+                /* we DON'T own the name!*/
+                lun->name = name;
+        } else {
+                lun->dev.release = fsg_lun_release;
+                lun->dev.parent = &common->gadget->dev;
+                dev_set_drvdata(&lun->dev, &common->filesem);
+                dev_set_name(&lun->dev, "%s", name);
+                lun->name = dev_name(&lun->dev);
+
+                rc = fsg_common_add_sysfs(common, lun);
+                if (rc) {
+                        pr_info("failed to register LUN%d: %d\n", id, rc);
+                        goto error_sysfs;
+                }
+        }
+
+        common->luns[id] = lun;
+
+        if (cfg->filename) {
+                rc = fsg_lun_open(lun, cfg->filename);
+                if (rc)
+                        goto error_lun;
+        }
 
         pathbuf = kmalloc(PATH_MAX, GFP_KERNEL);
-        for (i = 0, nluns = common->nluns, curlun = common->luns;
-             i < nluns;
-             ++curlun, ++i) {
-                char *p = "(no medium)";
-                if (fsg_lun_is_open(curlun)) {
-                        p = "(error)";
-                        if (pathbuf) {
-                                p = d_path(&curlun->filp->f_path,
-                                           pathbuf, PATH_MAX);
-                                if (IS_ERR(p))
-                                        p = "(error)";
-                        }
+        p = "(no medium)";
+        if (fsg_lun_is_open(lun)) {
+                p = "(error)";
+                if (pathbuf) {
+                        p = d_path(&lun->filp->f_path, pathbuf, PATH_MAX);
+                        if (IS_ERR(p))
+                                p = "(error)";
                 }
-                LINFO(curlun, "LUN: %s%s%sfile: %s\n",
-                      curlun->removable ? "removable " : "",
-                      curlun->ro ? "read only " : "",
-                      curlun->cdrom ? "CD-ROM " : "",
-                      p);
         }
+        pr_info("LUN: %s%s%sfile: %s\n",
+              lun->removable ? "removable " : "",
+              lun->ro ? "read only " : "",
+              lun->cdrom ? "CD-ROM " : "",
+              p);
         kfree(pathbuf);
 
+        return 0;
+
+error_lun:
+        if (common->sysfs) {
+                fsg_common_remove_sysfs(lun);
+                device_unregister(&lun->dev);
+        }
+        fsg_lun_close(lun);
+        common->luns[id] = NULL;
+error_sysfs:
+        kfree(lun);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(fsg_common_create_lun);
+
+int fsg_common_create_luns(struct fsg_common *common, struct fsg_config *cfg)
+{
+        char buf[8]; /* enough for 100000000 different numbers, decimal */
+        int i, rc;
+
+        for (i = 0; i < common->nluns; ++i) {
+                snprintf(buf, sizeof(buf), "lun%d", i);
+                rc = fsg_common_create_lun(common, &cfg->luns[i], i, buf, NULL);
+                if (rc)
+                        goto fail;
+        }
+
+        pr_info("Number of LUNs=%d\n", common->nluns);
+
+        return 0;
+
+fail:
+        _fsg_common_remove_luns(common, i);
+        return rc;
+}
+EXPORT_SYMBOL_GPL(fsg_common_create_luns);
+
+void fsg_common_set_inquiry_string(struct fsg_common *common, const char *vn,
+                                   const char *pn)
+{
+        int i;
+
+        /* Prepare inquiryString */
+        i = get_default_bcdDevice();
+        snprintf(common->inquiry_string, sizeof(common->inquiry_string),
+                 "%-8s%-16s%04x", vn ?: "Linux",
+                 /* Assume product name dependent on the first LUN */
+                 pn ?: ((*common->luns)->cdrom
+                     ? "File-CD Gadget"
+                     : "File-Stor Gadget"),
+                 i);
+}
+EXPORT_SYMBOL_GPL(fsg_common_set_inquiry_string);
+
+int fsg_common_run_thread(struct fsg_common *common)
+{
+        common->state = FSG_STATE_IDLE;
+        /* Tell the thread to start working */
+        common->thread_task =
+                kthread_create(fsg_main_thread, common, "file-storage");
+        if (IS_ERR(common->thread_task)) {
+                common->state = FSG_STATE_TERMINATED;
+                return PTR_ERR(common->thread_task);
+        }
+
         DBG(common, "I/O thread pid: %d\n", task_pid_nr(common->thread_task));
 
         wake_up_process(common->thread_task);
 
-        return common;
-
-error_luns:
-        common->nluns = i + 1;
-error_release:
-        common->state = FSG_STATE_TERMINATED;   /* The thread is dead */
-        /* Call fsg_common_release() directly, ref might be not initialised. */
-        fsg_common_release(&common->ref);
-        return ERR_PTR(rc);
+        return 0;
 }
+EXPORT_SYMBOL_GPL(fsg_common_run_thread);
 
 static void fsg_common_release(struct kref *ref)
 {
@@ -2822,36 +3068,26 @@ static void fsg_common_release(struct kref *ref)
         }
 
         if (likely(common->luns)) {
-                struct fsg_lun *lun = common->luns;
+                struct fsg_lun **lun_it = common->luns;
                 unsigned i = common->nluns;
 
                 /* In error recovery common->nluns may be zero. */
-                for (; i; --i, ++lun) {
-                        device_remove_file(&lun->dev, &dev_attr_nofua);
-                        device_remove_file(&lun->dev,
-                                           lun->cdrom
-                                         ? &dev_attr_ro_cdrom
-                                         : &dev_attr_ro);
-                        device_remove_file(&lun->dev,
-                                           lun->removable
-                                         ? &dev_attr_file
-                                         : &dev_attr_file_nonremovable);
+                for (; i; --i, ++lun_it) {
+                        struct fsg_lun *lun = *lun_it;
+                        if (!lun)
+                                continue;
+                        if (common->sysfs)
+                                fsg_common_remove_sysfs(lun);
                         fsg_lun_close(lun);
-                        device_unregister(&lun->dev);
+                        if (common->sysfs)
+                                device_unregister(&lun->dev);
+                        kfree(lun);
                 }
 
                 kfree(common->luns);
         }
 
-        {
-                struct fsg_buffhd *bh = common->buffhds;
-                unsigned i = fsg_num_buffers;
-                do {
-                        kfree(bh->buf);
-                } while (++bh, --i);
-        }
-
-        kfree(common->buffhds);
+        _fsg_common_free_buffers(common->buffhds, common->fsg_num_buffers);
         if (common->free_storage_on_release)
                 kfree(common);
 }
@@ -2859,24 +3095,6 @@ static void fsg_common_release(struct kref *ref)
 
 /*-------------------------------------------------------------------------*/
 
-static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
-{
-        struct fsg_dev          *fsg = fsg_from_func(f);
-        struct fsg_common       *common = fsg->common;
-
-        DBG(fsg, "unbind\n");
-        if (fsg->common->fsg == fsg) {
-                fsg->common->new_fsg = NULL;
-                raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
-                /* FIXME: make interruptible or killable somehow? */
-                wait_event(common->fsg_wait, common->fsg != fsg);
-        }
-
-        fsg_common_put(common);
-        usb_free_all_descriptors(&fsg->function);
-        kfree(fsg);
-}
-
 static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct fsg_dev          *fsg = fsg_from_func(f);
@@ -2885,6 +3103,19 @@ static int fsg_bind(struct usb_configuration *c, struct usb_function *f)
         struct usb_ep           *ep;
         unsigned                max_burst;
         int                     ret;
+        struct fsg_opts         *opts;
+
+        opts = fsg_opts_from_func_inst(f->fi);
+        if (!opts->no_configfs) {
+                ret = fsg_common_set_cdev(fsg->common, c->cdev,
+                                          fsg->common->can_stall);
+                if (ret)
+                        return ret;
+                fsg_common_set_inquiry_string(fsg->common, 0, 0);
+                ret = fsg_common_run_thread(fsg->common);
+                if (ret)
+                        return ret;
+        }
 
         fsg->gadget = gadget;
 
@@ -2937,95 +3168,472 @@ autoconf_fail:
         return -ENOTSUPP;
 }
 
-/****************************** ADD FUNCTION ******************************/
+/****************************** ALLOCATE FUNCTION *************************/
 
-static struct usb_gadget_strings *fsg_strings_array[] = {
-        &fsg_stringtab,
+static void fsg_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct fsg_dev          *fsg = fsg_from_func(f);
+        struct fsg_common       *common = fsg->common;
+
+        DBG(fsg, "unbind\n");
+        if (fsg->common->fsg == fsg) {
+                fsg->common->new_fsg = NULL;
+                raise_exception(fsg->common, FSG_STATE_CONFIG_CHANGE);
+                /* FIXME: make interruptible or killable somehow? */
+                wait_event(common->fsg_wait, common->fsg != fsg);
+        }
+
+        usb_free_all_descriptors(&fsg->function);
+}
+
+static inline struct fsg_lun_opts *to_fsg_lun_opts(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct fsg_lun_opts, group);
+}
+
+static inline struct fsg_opts *to_fsg_opts(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct fsg_opts,
+                            func_inst.group);
+}
+
+CONFIGFS_ATTR_STRUCT(fsg_lun_opts);
+CONFIGFS_ATTR_OPS(fsg_lun_opts);
+
+static void fsg_lun_attr_release(struct config_item *item)
+{
+        struct fsg_lun_opts *lun_opts;
+
+        lun_opts = to_fsg_lun_opts(item);
+        kfree(lun_opts);
+}
+
+static struct configfs_item_operations fsg_lun_item_ops = {
+        .release                = fsg_lun_attr_release,
+        .show_attribute         = fsg_lun_opts_attr_show,
+        .store_attribute        = fsg_lun_opts_attr_store,
+};
+
+static ssize_t fsg_lun_opts_file_show(struct fsg_lun_opts *opts, char *page)
+{
+        struct fsg_opts *fsg_opts;
+
+        fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
+
+        return fsg_show_file(opts->lun, &fsg_opts->common->filesem, page);
+}
+
+static ssize_t fsg_lun_opts_file_store(struct fsg_lun_opts *opts,
+                                       const char *page, size_t len)
+{
+        struct fsg_opts *fsg_opts;
+
+        fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
+
+        return fsg_store_file(opts->lun, &fsg_opts->common->filesem, page, len);
+}
+
+static struct fsg_lun_opts_attribute fsg_lun_opts_file =
+        __CONFIGFS_ATTR(file, S_IRUGO | S_IWUSR, fsg_lun_opts_file_show,
+                        fsg_lun_opts_file_store);
+
+static ssize_t fsg_lun_opts_ro_show(struct fsg_lun_opts *opts, char *page)
+{
+        return fsg_show_ro(opts->lun, page);
+}
+
+static ssize_t fsg_lun_opts_ro_store(struct fsg_lun_opts *opts,
+                                       const char *page, size_t len)
+{
+        struct fsg_opts *fsg_opts;
+
+        fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
+
+        return fsg_store_ro(opts->lun, &fsg_opts->common->filesem, page, len);
+}
+
+static struct fsg_lun_opts_attribute fsg_lun_opts_ro =
+        __CONFIGFS_ATTR(ro, S_IRUGO | S_IWUSR, fsg_lun_opts_ro_show,
+                        fsg_lun_opts_ro_store);
+
+static ssize_t fsg_lun_opts_removable_show(struct fsg_lun_opts *opts,
+                                           char *page)
+{
+        return fsg_show_removable(opts->lun, page);
+}
+
+static ssize_t fsg_lun_opts_removable_store(struct fsg_lun_opts *opts,
+                                       const char *page, size_t len)
+{
+        return fsg_store_removable(opts->lun, page, len);
+}
+
+static struct fsg_lun_opts_attribute fsg_lun_opts_removable =
+        __CONFIGFS_ATTR(removable, S_IRUGO | S_IWUSR,
+                        fsg_lun_opts_removable_show,
+                        fsg_lun_opts_removable_store);
+
+static ssize_t fsg_lun_opts_cdrom_show(struct fsg_lun_opts *opts, char *page)
+{
+        return fsg_show_cdrom(opts->lun, page);
+}
+
+static ssize_t fsg_lun_opts_cdrom_store(struct fsg_lun_opts *opts,
+                                       const char *page, size_t len)
+{
+        struct fsg_opts *fsg_opts;
+
+        fsg_opts = to_fsg_opts(opts->group.cg_item.ci_parent);
+
+        return fsg_store_cdrom(opts->lun, &fsg_opts->common->filesem, page,
+                               len);
+}
+
+static struct fsg_lun_opts_attribute fsg_lun_opts_cdrom =
+        __CONFIGFS_ATTR(cdrom, S_IRUGO | S_IWUSR, fsg_lun_opts_cdrom_show,
+                        fsg_lun_opts_cdrom_store);
+
+static ssize_t fsg_lun_opts_nofua_show(struct fsg_lun_opts *opts, char *page)
+{
+        return fsg_show_nofua(opts->lun, page);
+}
+
+static ssize_t fsg_lun_opts_nofua_store(struct fsg_lun_opts *opts,
+                                       const char *page, size_t len)
+{
+        return fsg_store_nofua(opts->lun, page, len);
+}
+
+static struct fsg_lun_opts_attribute fsg_lun_opts_nofua =
+        __CONFIGFS_ATTR(nofua, S_IRUGO | S_IWUSR, fsg_lun_opts_nofua_show,
+                        fsg_lun_opts_nofua_store);
+
+static struct configfs_attribute *fsg_lun_attrs[] = {
+        &fsg_lun_opts_file.attr,
+        &fsg_lun_opts_ro.attr,
+        &fsg_lun_opts_removable.attr,
+        &fsg_lun_opts_cdrom.attr,
+        &fsg_lun_opts_nofua.attr,
         NULL,
 };
 
-static int fsg_bind_config(struct usb_composite_dev *cdev,
-                           struct usb_configuration *c,
-                           struct fsg_common *common)
+static struct config_item_type fsg_lun_type = {
+        .ct_item_ops    = &fsg_lun_item_ops,
+        .ct_attrs       = fsg_lun_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static struct config_group *fsg_lun_make(struct config_group *group,
+                                         const char *name)
 {
-        struct fsg_dev *fsg;
+        struct fsg_lun_opts *opts;
+        struct fsg_opts *fsg_opts;
+        struct fsg_lun_config config;
+        char *num_str;
+        u8 num;
+        int ret;
+
+        num_str = strchr(name, '.');
+        if (!num_str) {
+                pr_err("Unable to locate . in LUN.NUMBER\n");
+                return ERR_PTR(-EINVAL);
+        }
+        num_str++;
+
+        ret = kstrtou8(num_str, 0, &num);
+        if (ret)
+                return ERR_PTR(ret);
+
+        fsg_opts = to_fsg_opts(&group->cg_item);
+        if (num >= FSG_MAX_LUNS)
+                return ERR_PTR(-ERANGE);
+
+        mutex_lock(&fsg_opts->lock);
+        if (fsg_opts->refcnt || fsg_opts->common->luns[num]) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        memset(&config, 0, sizeof(config));
+        config.removable = true;
+
+        ret = fsg_common_create_lun(fsg_opts->common, &config, num, name,
+                                    (const char **)&group->cg_item.ci_name);
+        if (ret) {
+                kfree(opts);
+                goto out;
+        }
+        opts->lun = fsg_opts->common->luns[num];
+        opts->lun_id = num;
+        mutex_unlock(&fsg_opts->lock);
+
+        config_group_init_type_name(&opts->group, name, &fsg_lun_type);
+
+        return &opts->group;
+out:
+        mutex_unlock(&fsg_opts->lock);
+        return ERR_PTR(ret);
+}
+
+static void fsg_lun_drop(struct config_group *group, struct config_item *item)
+{
+        struct fsg_lun_opts *lun_opts;
+        struct fsg_opts *fsg_opts;
+
+        lun_opts = to_fsg_lun_opts(item);
+        fsg_opts = to_fsg_opts(&group->cg_item);
+
+        mutex_lock(&fsg_opts->lock);
+        if (fsg_opts->refcnt) {
+                struct config_item *gadget;
+
+                gadget = group->cg_item.ci_parent->ci_parent;
+                unregister_gadget_item(gadget);
+        }
+
+        fsg_common_remove_lun(lun_opts->lun, fsg_opts->common->sysfs);
+        fsg_opts->common->luns[lun_opts->lun_id] = NULL;
+        lun_opts->lun_id = 0;
+        mutex_unlock(&fsg_opts->lock);
+
+        config_item_put(item);
+}
+
+CONFIGFS_ATTR_STRUCT(fsg_opts);
+CONFIGFS_ATTR_OPS(fsg_opts);
+
+static void fsg_attr_release(struct config_item *item)
+{
+        struct fsg_opts *opts = to_fsg_opts(item);
+
+        usb_put_function_instance(&opts->func_inst);
+}
+
+static struct configfs_item_operations fsg_item_ops = {
+        .release                = fsg_attr_release,
+        .show_attribute         = fsg_opts_attr_show,
+        .store_attribute        = fsg_opts_attr_store,
+};
+
+static ssize_t fsg_opts_stall_show(struct fsg_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->common->can_stall);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t fsg_opts_stall_store(struct fsg_opts *opts, const char *page,
+                                    size_t len)
+{
+        int ret;
+        bool stall;
+
+        mutex_lock(&opts->lock);
+
+        if (opts->refcnt) {
+                mutex_unlock(&opts->lock);
+                return -EBUSY;
+        }
+
+        ret = strtobool(page, &stall);
+        if (!ret) {
+                opts->common->can_stall = stall;
+                ret = len;
+        }
+
+        mutex_unlock(&opts->lock);
+
+        return ret;
+}
+
+static struct fsg_opts_attribute fsg_opts_stall =
+        __CONFIGFS_ATTR(stall, S_IRUGO | S_IWUSR, fsg_opts_stall_show,
+                        fsg_opts_stall_store);
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+static ssize_t fsg_opts_num_buffers_show(struct fsg_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->common->fsg_num_buffers);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t fsg_opts_num_buffers_store(struct fsg_opts *opts,
+                                          const char *page, size_t len)
+{
+        int ret;
+        u8 num;
+
+        mutex_lock(&opts->lock);
+        if (opts->refcnt) {
+                ret = -EBUSY;
+                goto end;
+        }
+        ret = kstrtou8(page, 0, &num);
+        if (ret)
+                goto end;
+
+        ret = fsg_num_buffers_validate(num);
+        if (ret)
+                goto end;
+
+        fsg_common_set_num_buffers(opts->common, num);
+        ret = len;
+
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct fsg_opts_attribute fsg_opts_num_buffers =
+        __CONFIGFS_ATTR(num_buffers, S_IRUGO | S_IWUSR,
+                        fsg_opts_num_buffers_show,
+                        fsg_opts_num_buffers_store);
+
+#endif
+
+static struct configfs_attribute *fsg_attrs[] = {
+        &fsg_opts_stall.attr,
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+        &fsg_opts_num_buffers.attr,
+#endif
+        NULL,
+};
+
+static struct configfs_group_operations fsg_group_ops = {
+        .make_group     = fsg_lun_make,
+        .drop_item      = fsg_lun_drop,
+};
+
+static struct config_item_type fsg_func_type = {
+        .ct_item_ops    = &fsg_item_ops,
+        .ct_group_ops   = &fsg_group_ops,
+        .ct_attrs       = fsg_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static void fsg_free_inst(struct usb_function_instance *fi)
+{
+        struct fsg_opts *opts;
+
+        opts = fsg_opts_from_func_inst(fi);
+        fsg_common_put(opts->common);
+        kfree(opts);
+}
+
+static struct usb_function_instance *fsg_alloc_inst(void)
+{
+        struct fsg_opts *opts;
+        struct fsg_lun_config config;
         int rc;
 
-        fsg = kzalloc(sizeof *fsg, GFP_KERNEL);
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+        mutex_init(&opts->lock);
+        opts->func_inst.free_func_inst = fsg_free_inst;
+        opts->common = fsg_common_setup(opts->common);
+        if (IS_ERR(opts->common)) {
+                rc = PTR_ERR(opts->common);
+                goto release_opts;
+        }
+        rc = fsg_common_set_nluns(opts->common, FSG_MAX_LUNS);
+        if (rc)
+                goto release_opts;
+
+        rc = fsg_common_set_num_buffers(opts->common,
+                                        CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS);
+        if (rc)
+                goto release_luns;
+
+        pr_info(FSG_DRIVER_DESC ", version: " FSG_DRIVER_VERSION "\n");
+
+        memset(&config, 0, sizeof(config));
+        config.removable = true;
+        rc = fsg_common_create_lun(opts->common, &config, 0, "lun.0",
+                        (const char **)&opts->func_inst.group.cg_item.ci_name);
+        opts->lun0.lun = opts->common->luns[0];
+        opts->lun0.lun_id = 0;
+        config_group_init_type_name(&opts->lun0.group, "lun.0", &fsg_lun_type);
+        opts->default_groups[0] = &opts->lun0.group;
+        opts->func_inst.group.default_groups = opts->default_groups;
+
+        config_group_init_type_name(&opts->func_inst.group, "", &fsg_func_type);
+
+        return &opts->func_inst;
+
+release_luns:
+        kfree(opts->common->luns);
+release_opts:
+        kfree(opts);
+        return ERR_PTR(rc);
+}
+
+static void fsg_free(struct usb_function *f)
+{
+        struct fsg_dev *fsg;
+        struct fsg_opts *opts;
+
+        fsg = container_of(f, struct fsg_dev, function);
+        opts = container_of(f->fi, struct fsg_opts, func_inst);
+
+        mutex_lock(&opts->lock);
+        opts->refcnt--;
+        mutex_unlock(&opts->lock);
+
+        kfree(fsg);
+}
+
+static struct usb_function *fsg_alloc(struct usb_function_instance *fi)
+{
+        struct fsg_opts *opts = fsg_opts_from_func_inst(fi);
+        struct fsg_common *common = opts->common;
+        struct fsg_dev *fsg;
+
+        fsg = kzalloc(sizeof(*fsg), GFP_KERNEL);
         if (unlikely(!fsg))
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
-        fsg->function.name        = FSG_DRIVER_DESC;
-        fsg->function.strings     = fsg_strings_array;
-        fsg->function.bind        = fsg_bind;
-        fsg->function.unbind      = fsg_unbind;
-        fsg->function.setup       = fsg_setup;
-        fsg->function.set_alt     = fsg_set_alt;
-        fsg->function.disable     = fsg_disable;
+        mutex_lock(&opts->lock);
+        opts->refcnt++;
+        mutex_unlock(&opts->lock);
+        fsg->function.name      = FSG_DRIVER_DESC;
+        fsg->function.bind      = fsg_bind;
+        fsg->function.unbind    = fsg_unbind;
+        fsg->function.setup     = fsg_setup;
+        fsg->function.set_alt   = fsg_set_alt;
+        fsg->function.disable   = fsg_disable;
+        fsg->function.free_func = fsg_free;
 
         fsg->common               = common;
-        /*
-         * Our caller holds a reference to common structure so we
-         * don't have to be worry about it being freed until we return
-         * from this function.  So instead of incrementing counter now
-         * and decrement in error recovery we increment it only when
-         * call to usb_add_function() was successful.
-         */
 
-        rc = usb_add_function(c, &fsg->function);
-        if (unlikely(rc))
-                kfree(fsg);
-        else
-                fsg_common_get(fsg->common);
-        return rc;
+        return &fsg->function;
 }
 
+DECLARE_USB_FUNCTION_INIT(mass_storage, fsg_alloc_inst, fsg_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Michal Nazarewicz");
 
 /************************* Module parameters *************************/
 
-struct fsg_module_parameters {
-        char            *file[FSG_MAX_LUNS];
-        bool            ro[FSG_MAX_LUNS];
-        bool            removable[FSG_MAX_LUNS];
-        bool            cdrom[FSG_MAX_LUNS];
-        bool            nofua[FSG_MAX_LUNS];
-
-        unsigned int    file_count, ro_count, removable_count, cdrom_count;
-        unsigned int    nofua_count;
-        unsigned int    luns;   /* nluns */
-        bool            stall;  /* can_stall */
-};
 
-#define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc)       \
-        module_param_array_named(prefix ## name, params.name, type,     \
-                                 &prefix ## params.name ## _count,      \
-                                 S_IRUGO);                              \
-        MODULE_PARM_DESC(prefix ## name, desc)
-
-#define _FSG_MODULE_PARAM(prefix, params, name, type, desc)             \
-        module_param_named(prefix ## name, params.name, type,           \
-                           S_IRUGO);                                    \
-        MODULE_PARM_DESC(prefix ## name, desc)
-
-#define FSG_MODULE_PARAMETERS(prefix, params)                           \
-        _FSG_MODULE_PARAM_ARRAY(prefix, params, file, charp,            \
-                                "names of backing files or devices");   \
-        _FSG_MODULE_PARAM_ARRAY(prefix, params, ro, bool,               \
-                                "true to force read-only");             \
-        _FSG_MODULE_PARAM_ARRAY(prefix, params, removable, bool,        \
-                                "true to simulate removable media");    \
-        _FSG_MODULE_PARAM_ARRAY(prefix, params, cdrom, bool,            \
-                                "true to simulate CD-ROM instead of disk"); \
-        _FSG_MODULE_PARAM_ARRAY(prefix, params, nofua, bool,            \
-                                "true to ignore SCSI WRITE(10,12) FUA bit"); \
-        _FSG_MODULE_PARAM(prefix, params, luns, uint,                   \
-                          "number of LUNs");                            \
-        _FSG_MODULE_PARAM(prefix, params, stall, bool,                  \
-                          "false to prevent bulk stalls")
-
-static void
-fsg_config_from_params(struct fsg_config *cfg,
-                       const struct fsg_module_parameters *params)
+void fsg_config_from_params(struct fsg_config *cfg,
+                       const struct fsg_module_parameters *params,
+                       unsigned int fsg_num_buffers)
 {
         struct fsg_lun_config *lun;
         unsigned i;
@@ -3053,19 +3661,7 @@ fsg_config_from_params(struct fsg_config *cfg,
 
         /* Finalise */
         cfg->can_stall = params->stall;
+        cfg->fsg_num_buffers = fsg_num_buffers;
 }
+EXPORT_SYMBOL_GPL(fsg_config_from_params);
 
-static inline struct fsg_common *
-fsg_common_from_params(struct fsg_common *common,
-                       struct usb_composite_dev *cdev,
-                       const struct fsg_module_parameters *params)
-        __attribute__((unused));
-static inline struct fsg_common *
-fsg_common_from_params(struct fsg_common *common,
-                       struct usb_composite_dev *cdev,
-                       const struct fsg_module_parameters *params)
-{
-        struct fsg_config cfg;
-        fsg_config_from_params(&cfg, params);
-        return fsg_common_init(common, cdev, &cfg);
-}
diff --git a/drivers/usb/gadget/f_mass_storage.h b/drivers/usb/gadget/f_mass_storage.h
new file mode 100644
index 000000000000..b4866fcef30b
--- /dev/null
+++ b/drivers/usb/gadget/f_mass_storage.h
@@ -0,0 +1,166 @@
+#ifndef USB_F_MASS_STORAGE_H
+#define USB_F_MASS_STORAGE_H
+
+#include <linux/usb/composite.h>
+#include "storage_common.h"
+
+struct fsg_module_parameters {
+        char            *file[FSG_MAX_LUNS];
+        bool            ro[FSG_MAX_LUNS];
+        bool            removable[FSG_MAX_LUNS];
+        bool            cdrom[FSG_MAX_LUNS];
+        bool            nofua[FSG_MAX_LUNS];
+
+        unsigned int    file_count, ro_count, removable_count, cdrom_count;
+        unsigned int    nofua_count;
+        unsigned int    luns;   /* nluns */
+        bool            stall;  /* can_stall */
+};
+
+#define _FSG_MODULE_PARAM_ARRAY(prefix, params, name, type, desc)       \
+        module_param_array_named(prefix ## name, params.name, type,     \
+                                 &prefix ## params.name ## _count,      \
+                                 S_IRUGO);                              \
+        MODULE_PARM_DESC(prefix ## name, desc)
+
+#define _FSG_MODULE_PARAM(prefix, params, name, type, desc)             \
+        module_param_named(prefix ## name, params.name, type,           \
+                           S_IRUGO);                                    \
+        MODULE_PARM_DESC(prefix ## name, desc)
+
+#define __FSG_MODULE_PARAMETERS(prefix, params)                         \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, file, charp,            \
+                                "names of backing files or devices");   \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, ro, bool,               \
+                                "true to force read-only");             \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, removable, bool,        \
+                                "true to simulate removable media");    \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, cdrom, bool,            \
+                                "true to simulate CD-ROM instead of disk"); \
+        _FSG_MODULE_PARAM_ARRAY(prefix, params, nofua, bool,            \
+                                "true to ignore SCSI WRITE(10,12) FUA bit"); \
+        _FSG_MODULE_PARAM(prefix, params, luns, uint,                   \
+                          "number of LUNs");                            \
+        _FSG_MODULE_PARAM(prefix, params, stall, bool,                  \
+                          "false to prevent bulk stalls")
+
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+
+#define FSG_MODULE_PARAMETERS(prefix, params)                           \
+        __FSG_MODULE_PARAMETERS(prefix, params);                        \
+        module_param_named(num_buffers, fsg_num_buffers, uint, S_IRUGO);\
+        MODULE_PARM_DESC(num_buffers, "Number of pipeline buffers")
+#else
+
+#define FSG_MODULE_PARAMETERS(prefix, params)                           \
+        __FSG_MODULE_PARAMETERS(prefix, params)
+
+#endif
+
+struct fsg_common;
+
+/* FSF callback functions */
+struct fsg_operations {
+        /*
+         * Callback function to call when thread exits.  If no
+         * callback is set or it returns value lower then zero MSF
+         * will force eject all LUNs it operates on (including those
+         * marked as non-removable or with prevent_medium_removal flag
+         * set).
+         */
+        int (*thread_exits)(struct fsg_common *common);
+};
+
+struct fsg_lun_opts {
+        struct config_group group;
+        struct fsg_lun *lun;
+        int lun_id;
+};
+
+struct fsg_opts {
+        struct fsg_common *common;
+        struct usb_function_instance func_inst;
+        struct fsg_lun_opts lun0;
+        struct config_group *default_groups[2];
+        bool no_configfs; /* for legacy gadgets */
+
+        /*
+         * Read/write access to configfs attributes is handled by configfs.
+         *
+         * This is to protect the data from concurrent access by read/write
+         * and create symlink/remove symlink.
+         */
+        struct mutex                    lock;
+        int                             refcnt;
+};
+
+struct fsg_lun_config {
+        const char *filename;
+        char ro;
+        char removable;
+        char cdrom;
+        char nofua;
+};
+
+struct fsg_config {
+        unsigned nluns;
+        struct fsg_lun_config luns[FSG_MAX_LUNS];
+
+        /* Callback functions. */
+        const struct fsg_operations     *ops;
+        /* Gadget's private data. */
+        void                    *private_data;
+
+        const char *vendor_name;                /*  8 characters or less */
+        const char *product_name;               /* 16 characters or less */
+
+        char                    can_stall;
+        unsigned int            fsg_num_buffers;
+};
+
+static inline struct fsg_opts *
+fsg_opts_from_func_inst(const struct usb_function_instance *fi)
+{
+        return container_of(fi, struct fsg_opts, func_inst);
+}
+
+void fsg_common_get(struct fsg_common *common);
+
+void fsg_common_put(struct fsg_common *common);
+
+void fsg_common_set_sysfs(struct fsg_common *common, bool sysfs);
+
+int fsg_common_set_num_buffers(struct fsg_common *common, unsigned int n);
+
+void fsg_common_free_buffers(struct fsg_common *common);
+
+int fsg_common_set_cdev(struct fsg_common *common,
+                        struct usb_composite_dev *cdev, bool can_stall);
+
+void fsg_common_remove_lun(struct fsg_lun *lun, bool sysfs);
+
+void fsg_common_remove_luns(struct fsg_common *common);
+
+void fsg_common_free_luns(struct fsg_common *common);
+
+int fsg_common_set_nluns(struct fsg_common *common, int nluns);
+
+void fsg_common_set_ops(struct fsg_common *common,
+                        const struct fsg_operations *ops);
+
+int fsg_common_create_lun(struct fsg_common *common, struct fsg_lun_config *cfg,
+                          unsigned int id, const char *name,
+                          const char **name_pfx);
+
+int fsg_common_create_luns(struct fsg_common *common, struct fsg_config *cfg);
+
+void fsg_common_set_inquiry_string(struct fsg_common *common, const char *vn,
+                                   const char *pn);
+
+int fsg_common_run_thread(struct fsg_common *common);
+
+void fsg_config_from_params(struct fsg_config *cfg,
+                            const struct fsg_module_parameters *params,
+                            unsigned int fsg_num_buffers);
+
+#endif /* USB_F_MASS_STORAGE_H */
diff --git a/drivers/usb/gadget/fotg210-udc.c b/drivers/usb/gadget/fotg210-udc.c
index 32db2eee2d87..bbbfd1948778 100644
--- a/drivers/usb/gadget/fotg210-udc.c
+++ b/drivers/usb/gadget/fotg210-udc.c
@@ -1214,6 +1214,6 @@ static struct platform_driver fotg210_driver = {
 
 module_platform_driver(fotg210_driver);
 
-MODULE_AUTHOR("Yuan-Hsin Chen <yhchen@faraday-tech.com>");
+MODULE_AUTHOR("Yuan-Hsin Chen, Feng-Hsin Chiang <john453@faraday-tech.com>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index f3bb363f1d4a..807127d56fa3 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -33,6 +33,7 @@
 #include <linux/io.h>
 #include <linux/moduleparam.h>
 #include <linux/of_address.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/ch9.h>
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index f1dd6daabe21..b278abe52453 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -22,7 +22,7 @@
 
 MODULE_DESCRIPTION("FUSB300  USB gadget driver");
 MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Yuan Hsin Chen <yhchen@faraday-tech.com>");
+MODULE_AUTHOR("Yuan-Hsin Chen, Feng-Hsin Chiang <john453@faraday-tech.com>");
 MODULE_ALIAS("platform:fusb300_udc");
 
 #define DRIVER_VERSION  "20 October 2010"
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
index 5327c82472ed..2344efe4f4ce 100644
--- a/drivers/usb/gadget/g_ffs.c
+++ b/drivers/usb/gadget/g_ffs.c
@@ -76,7 +76,9 @@ struct gfs_ffs_obj {
 
 USB_GADGET_COMPOSITE_OPTIONS();
 
+#if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
 USB_ETHERNET_MODULE_PARAMETERS();
+#endif
 
 static struct usb_device_descriptor gfs_dev_desc = {
         .bLength                = sizeof gfs_dev_desc,
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index c64deb9e3d62..f82768015715 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1165,7 +1165,7 @@ static int udc_proc_read(struct seq_file *m, void *v)
                                 s = "invalid"; break;
                         default:
                                 s = "?"; break;
-                        }; s; }),
+                        } s; }),
                         (tmp & EPxSTATUS_TOGGLE) ? "data1" : "data0",
                         (tmp & EPxSTATUS_SUSPEND) ? " suspend" : "",
                         (tmp & EPxSTATUS_FIFO_DISABLE) ? " disable" : "",
@@ -1701,7 +1701,6 @@ static void goku_remove(struct pci_dev *pdev)
         if (dev->enabled)
                 pci_disable_device(pdev);
 
-        pci_set_drvdata(pdev, NULL);
         dev->regs = NULL;
 
         INFO(dev, "unbind\n");
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index 465ef8e2cc91..b94c049ab0d0 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -524,7 +524,7 @@ struct kiocb_priv {
         unsigned                actual;
 };
 
-static int ep_aio_cancel(struct kiocb *iocb, struct io_event *e)
+static int ep_aio_cancel(struct kiocb *iocb)
 {
         struct kiocb_priv       *priv = iocb->private;
         struct ep_data          *epdata;
@@ -540,7 +540,6 @@ static int ep_aio_cancel(struct kiocb *iocb, struct io_event *e)
         // spin_unlock(&epdata->dev->lock);
         local_irq_enable();
 
-        aio_put_req(iocb);
         return value;
 }
 
@@ -709,11 +708,11 @@ ep_aio_read(struct kiocb *iocb, const struct iovec *iov,
         if (unlikely(usb_endpoint_dir_in(&epdata->desc)))
                 return -EINVAL;
 
-        buf = kmalloc(iocb->ki_left, GFP_KERNEL);
+        buf = kmalloc(iocb->ki_nbytes, GFP_KERNEL);
         if (unlikely(!buf))
                 return -ENOMEM;
 
-        return ep_aio_rwtail(iocb, buf, iocb->ki_left, epdata, iov, nr_segs);
+        return ep_aio_rwtail(iocb, buf, iocb->ki_nbytes, epdata, iov, nr_segs);
 }
 
 static ssize_t
@@ -728,7 +727,7 @@ ep_aio_write(struct kiocb *iocb, const struct iovec *iov,
         if (unlikely(!usb_endpoint_dir_in(&epdata->desc)))
                 return -EINVAL;
 
-        buf = kmalloc(iocb->ki_left, GFP_KERNEL);
+        buf = kmalloc(iocb->ki_nbytes, GFP_KERNEL);
         if (unlikely(!buf))
                 return -ENOMEM;
 
diff --git a/drivers/usb/gadget/lpc32xx_udc.c b/drivers/usb/gadget/lpc32xx_udc.c
index 67128be1e1b7..6a2a65aa0057 100644
--- a/drivers/usb/gadget/lpc32xx_udc.c
+++ b/drivers/usb/gadget/lpc32xx_udc.c
@@ -3078,7 +3078,9 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
                  udc->isp1301_i2c_client->addr);
 
         pdev->dev.dma_mask = &lpc32xx_usbd_dmamask;
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto resource_fail;
 
         udc->board = &lpc32xx_usbddata;
 
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index 080e577773d5..8e27a8c96444 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -37,16 +37,16 @@
 #define DRIVER_DESC             "Mass Storage Gadget"
 #define DRIVER_VERSION          "2009/09/11"
 
-/*-------------------------------------------------------------------------*/
-
 /*
- * kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
+ * Thanks to NetChip Technologies for donating this product ID.
+ *
+ * DO NOT REUSE THESE IDs with any other driver!!  Ever!!
+ * Instead:  allocate your own, using normal USB-IF procedures.
  */
-#include "f_mass_storage.c"
+#define FSG_VENDOR_ID   0x0525  /* NetChip */
+#define FSG_PRODUCT_ID  0xa4a5  /* Linux-USB File-backed Storage Gadget */
+
+#include "f_mass_storage.h"
 
 /*-------------------------------------------------------------------------*/
 USB_GADGET_COMPOSITE_OPTIONS();
@@ -97,11 +97,28 @@ static struct usb_gadget_strings *dev_strings[] = {
         NULL,
 };
 
+static struct usb_function_instance *fi_msg;
+static struct usb_function *f_msg;
+
 /****************************** Configurations ******************************/
 
 static struct fsg_module_parameters mod_data = {
         .stall = 1
 };
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+
+static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
+
+#else
+
+/*
+ * Number of buffers we will use.
+ * 2 is usually enough for good buffering pipeline
+ */
+#define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
+
+#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
+
 FSG_MODULE_PARAMETERS(/* no prefix */, mod_data);
 
 static unsigned long msg_registered;
@@ -115,13 +132,7 @@ static int msg_thread_exits(struct fsg_common *common)
 
 static int __init msg_do_config(struct usb_configuration *c)
 {
-        static const struct fsg_operations ops = {
-                .thread_exits = msg_thread_exits,
-        };
-        static struct fsg_common common;
-
-        struct fsg_common *retp;
-        struct fsg_config config;
+        struct fsg_opts *opts;
         int ret;
 
         if (gadget_is_otg(c->cdev->gadget)) {
@@ -129,15 +140,24 @@ static int __init msg_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        fsg_config_from_params(&config, &mod_data);
-        config.ops = &ops;
+        opts = fsg_opts_from_func_inst(fi_msg);
+
+        f_msg = usb_get_function(fi_msg);
+        if (IS_ERR(f_msg))
+                return PTR_ERR(f_msg);
+
+        ret = fsg_common_run_thread(opts->common);
+        if (ret)
+                goto put_func;
+
+        ret = usb_add_function(c, f_msg);
+        if (ret)
+                goto put_func;
 
-        retp = fsg_common_init(&common, c->cdev, &config);
-        if (IS_ERR(retp))
-                return PTR_ERR(retp);
+        return 0;
 
-        ret = fsg_bind_config(c->cdev, c, &common);
-        fsg_common_put(&common);
+put_func:
+        usb_put_function(f_msg);
         return ret;
 }
 
@@ -152,23 +172,79 @@ static struct usb_configuration msg_config_driver = {
 
 static int __init msg_bind(struct usb_composite_dev *cdev)
 {
+        static const struct fsg_operations ops = {
+                .thread_exits = msg_thread_exits,
+        };
+        struct fsg_opts *opts;
+        struct fsg_config config;
         int status;
 
+        fi_msg = usb_get_function_instance("mass_storage");
+        if (IS_ERR(fi_msg))
+                return PTR_ERR(fi_msg);
+
+        fsg_config_from_params(&config, &mod_data, fsg_num_buffers);
+        opts = fsg_opts_from_func_inst(fi_msg);
+
+        opts->no_configfs = true;
+        status = fsg_common_set_num_buffers(opts->common, fsg_num_buffers);
+        if (status)
+                goto fail;
+
+        status = fsg_common_set_nluns(opts->common, config.nluns);
+        if (status)
+                goto fail_set_nluns;
+
+        fsg_common_set_ops(opts->common, &ops);
+
+        status = fsg_common_set_cdev(opts->common, cdev, config.can_stall);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_sysfs(opts->common, true);
+        status = fsg_common_create_luns(opts->common, &config);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_inquiry_string(opts->common, config.vendor_name,
+                                      config.product_name);
+
         status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
-                return status;
+                goto fail_string_ids;
         msg_device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         status = usb_add_config(cdev, &msg_config_driver, msg_do_config);
         if (status < 0)
-                return status;
+                goto fail_string_ids;
+
         usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&cdev->gadget->dev,
                  DRIVER_DESC ", version: " DRIVER_VERSION "\n");
         set_bit(0, &msg_registered);
         return 0;
+
+fail_string_ids:
+        fsg_common_remove_luns(opts->common);
+fail_set_cdev:
+        fsg_common_free_luns(opts->common);
+fail_set_nluns:
+        fsg_common_free_buffers(opts->common);
+fail:
+        usb_put_function_instance(fi_msg);
+        return status;
 }
 
+static int msg_unbind(struct usb_composite_dev *cdev)
+{
+        if (!IS_ERR(f_msg))
+                usb_put_function(f_msg);
+
+        if (!IS_ERR(fi_msg))
+                usb_put_function_instance(fi_msg);
+
+        return 0;
+}
 
 /****************************** Some noise ******************************/
 
@@ -179,6 +255,7 @@ static __refdata struct usb_composite_driver msg_driver = {
         .needs_serial   = 1,
         .strings        = dev_strings,
         .bind           = msg_bind,
+        .unbind         = msg_unbind,
 };
 
 MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
index 2a1ebefd8f9e..4fdaa54a2a2a 100644
--- a/drivers/usb/gadget/multi.c
+++ b/drivers/usb/gadget/multi.c
@@ -15,6 +15,7 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/netdevice.h>
 
 #include "u_serial.h"
 #if defined USB_ETH_RNDIS
@@ -32,22 +33,11 @@ MODULE_AUTHOR("Michal Nazarewicz");
 MODULE_LICENSE("GPL");
 
 
-/***************************** All the files... *****************************/
+#include "f_mass_storage.h"
 
-/*
- * kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
- */
-#include "f_mass_storage.c"
-
-#define USBF_ECM_INCLUDED
-#include "f_ecm.c"
+#include "u_ecm.h"
 #ifdef USB_ETH_RNDIS
-#  define USB_FRNDIS_INCLUDED
-#  include "f_rndis.c"
+#  include "u_rndis.h"
 #  include "rndis.h"
 #endif
 #include "u_ether.h"
@@ -132,22 +122,36 @@ static struct usb_gadget_strings *dev_strings[] = {
 /****************************** Configurations ******************************/
 
 static struct fsg_module_parameters fsg_mod_data = { .stall = 1 };
-FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
+#ifdef CONFIG_USB_GADGET_DEBUG_FILES
+
+static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
 
-static struct fsg_common fsg_common;
+#else
+
+/*
+ * Number of buffers we will use.
+ * 2 is usually enough for good buffering pipeline
+ */
+#define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
 
-static u8 host_mac[ETH_ALEN];
+#endif /* CONFIG_USB_DEBUG */
+
+FSG_MODULE_PARAMETERS(/* no prefix */, fsg_mod_data);
 
 static struct usb_function_instance *fi_acm;
-static struct eth_dev *the_dev;
+static struct usb_function_instance *fi_msg;
 
 /********** RNDIS **********/
 
 #ifdef USB_ETH_RNDIS
+static struct usb_function_instance *fi_rndis;
 static struct usb_function *f_acm_rndis;
+static struct usb_function *f_rndis;
+static struct usb_function *f_msg_rndis;
 
 static __init int rndis_do_config(struct usb_configuration *c)
 {
+        struct fsg_opts *fsg_opts;
         int ret;
 
         if (gadget_is_otg(c->cdev->gadget)) {
@@ -155,31 +159,54 @@ static __init int rndis_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        ret = rndis_bind_config(c, host_mac, the_dev);
+        f_rndis = usb_get_function(fi_rndis);
+        if (IS_ERR(f_rndis))
+                return PTR_ERR(f_rndis);
+
+        ret = usb_add_function(c, f_rndis);
         if (ret < 0)
-                return ret;
+                goto err_func_rndis;
 
         f_acm_rndis = usb_get_function(fi_acm);
-        if (IS_ERR(f_acm_rndis))
-                return PTR_ERR(f_acm_rndis);
+        if (IS_ERR(f_acm_rndis)) {
+                ret = PTR_ERR(f_acm_rndis);
+                goto err_func_acm;
+        }
 
         ret = usb_add_function(c, f_acm_rndis);
         if (ret)
                 goto err_conf;
 
-        ret = fsg_bind_config(c->cdev, c, &fsg_common);
-        if (ret < 0)
+        f_msg_rndis = usb_get_function(fi_msg);
+        if (IS_ERR(f_msg_rndis)) {
+                ret = PTR_ERR(f_msg_rndis);
                 goto err_fsg;
+        }
+
+        fsg_opts = fsg_opts_from_func_inst(fi_msg);
+        ret = fsg_common_run_thread(fsg_opts->common);
+        if (ret)
+                goto err_run;
+
+        ret = usb_add_function(c, f_msg_rndis);
+        if (ret)
+                goto err_run;
 
         return 0;
+err_run:
+        usb_put_function(f_msg_rndis);
 err_fsg:
         usb_remove_function(c, f_acm_rndis);
 err_conf:
         usb_put_function(f_acm_rndis);
+err_func_acm:
+        usb_remove_function(c, f_rndis);
+err_func_rndis:
+        usb_put_function(f_rndis);
         return ret;
 }
 
-static int rndis_config_register(struct usb_composite_dev *cdev)
+static __ref int rndis_config_register(struct usb_composite_dev *cdev)
 {
         static struct usb_configuration config = {
                 .bConfigurationValue    = MULTI_RNDIS_CONFIG_NUM,
@@ -194,7 +221,7 @@ static int rndis_config_register(struct usb_composite_dev *cdev)
 
 #else
 
-static int rndis_config_register(struct usb_composite_dev *cdev)
+static __ref int rndis_config_register(struct usb_composite_dev *cdev)
 {
         return 0;
 }
@@ -205,10 +232,14 @@ static int rndis_config_register(struct usb_composite_dev *cdev)
 /********** CDC ECM **********/
 
 #ifdef CONFIG_USB_G_MULTI_CDC
+static struct usb_function_instance *fi_ecm;
 static struct usb_function *f_acm_multi;
+static struct usb_function *f_ecm;
+static struct usb_function *f_msg_multi;
 
 static __init int cdc_do_config(struct usb_configuration *c)
 {
+        struct fsg_opts *fsg_opts;
         int ret;
 
         if (gadget_is_otg(c->cdev->gadget)) {
@@ -216,32 +247,55 @@ static __init int cdc_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        ret = ecm_bind_config(c, host_mac, the_dev);
+        f_ecm = usb_get_function(fi_ecm);
+        if (IS_ERR(f_ecm))
+                return PTR_ERR(f_ecm);
+
+        ret = usb_add_function(c, f_ecm);
         if (ret < 0)
-                return ret;
+                goto err_func_ecm;
 
         /* implicit port_num is zero */
         f_acm_multi = usb_get_function(fi_acm);
-        if (IS_ERR(f_acm_multi))
-                return PTR_ERR(f_acm_multi);
+        if (IS_ERR(f_acm_multi)) {
+                ret = PTR_ERR(f_acm_multi);
+                goto err_func_acm;
+        }
 
         ret = usb_add_function(c, f_acm_multi);
         if (ret)
                 goto err_conf;
 
-        ret = fsg_bind_config(c->cdev, c, &fsg_common);
-        if (ret < 0)
+        f_msg_multi = usb_get_function(fi_msg);
+        if (IS_ERR(f_msg_multi)) {
+                ret = PTR_ERR(f_msg_multi);
                 goto err_fsg;
+        }
+
+        fsg_opts = fsg_opts_from_func_inst(fi_msg);
+        ret = fsg_common_run_thread(fsg_opts->common);
+        if (ret)
+                goto err_run;
+
+        ret = usb_add_function(c, f_msg_multi);
+        if (ret)
+                goto err_run;
 
         return 0;
+err_run:
+        usb_put_function(f_msg_multi);
 err_fsg:
         usb_remove_function(c, f_acm_multi);
 err_conf:
         usb_put_function(f_acm_multi);
+err_func_acm:
+        usb_remove_function(c, f_ecm);
+err_func_ecm:
+        usb_put_function(f_ecm);
         return ret;
 }
 
-static int cdc_config_register(struct usb_composite_dev *cdev)
+static __ref int cdc_config_register(struct usb_composite_dev *cdev)
 {
         static struct usb_configuration config = {
                 .bConfigurationValue    = MULTI_CDC_CONFIG_NUM,
@@ -256,7 +310,7 @@ static int cdc_config_register(struct usb_composite_dev *cdev)
 
 #else
 
-static int cdc_config_register(struct usb_composite_dev *cdev)
+static __ref int cdc_config_register(struct usb_composite_dev *cdev)
 {
         return 0;
 }
@@ -270,19 +324,67 @@ static int cdc_config_register(struct usb_composite_dev *cdev)
 static int __ref multi_bind(struct usb_composite_dev *cdev)
 {
         struct usb_gadget *gadget = cdev->gadget;
+#ifdef CONFIG_USB_G_MULTI_CDC
+        struct f_ecm_opts *ecm_opts;
+#endif
+#ifdef USB_ETH_RNDIS
+        struct f_rndis_opts *rndis_opts;
+#endif
+        struct fsg_opts *fsg_opts;
+        struct fsg_config config;
         int status;
 
         if (!can_support_ecm(cdev->gadget)) {
                 dev_err(&gadget->dev, "controller '%s' not usable\n",
-                        gadget->name);
+                        gadget->name);
                 return -EINVAL;
         }
 
-        /* set up network link layer */
-        the_dev = gether_setup(cdev->gadget, dev_addr, host_addr, host_mac,
-                               qmult);
-        if (IS_ERR(the_dev))
-                return PTR_ERR(the_dev);
+#ifdef CONFIG_USB_G_MULTI_CDC
+        fi_ecm = usb_get_function_instance("ecm");
+        if (IS_ERR(fi_ecm))
+                return PTR_ERR(fi_ecm);
+
+        ecm_opts = container_of(fi_ecm, struct f_ecm_opts, func_inst);
+
+        gether_set_qmult(ecm_opts->net, qmult);
+        if (!gether_set_host_addr(ecm_opts->net, host_addr))
+                pr_info("using host ethernet address: %s", host_addr);
+        if (!gether_set_dev_addr(ecm_opts->net, dev_addr))
+                pr_info("using self ethernet address: %s", dev_addr);
+#endif
+
+#ifdef USB_ETH_RNDIS
+        fi_rndis = usb_get_function_instance("rndis");
+        if (IS_ERR(fi_rndis)) {
+                status = PTR_ERR(fi_rndis);
+                goto fail;
+        }
+
+        rndis_opts = container_of(fi_rndis, struct f_rndis_opts, func_inst);
+
+        gether_set_qmult(rndis_opts->net, qmult);
+        if (!gether_set_host_addr(rndis_opts->net, host_addr))
+                pr_info("using host ethernet address: %s", host_addr);
+        if (!gether_set_dev_addr(rndis_opts->net, dev_addr))
+                pr_info("using self ethernet address: %s", dev_addr);
+#endif
+
+#if (defined CONFIG_USB_G_MULTI_CDC && defined USB_ETH_RNDIS)
+        /*
+         * If both ecm and rndis are selected then:
+         *      1) rndis borrows the net interface from ecm
+         *      2) since the interface is shared it must not be bound
+         *      twice - in ecm's _and_ rndis' binds, so do it here.
+         */
+        gether_set_gadget(ecm_opts->net, cdev->gadget);
+        status = gether_register_netdev(ecm_opts->net);
+        if (status)
+                goto fail0;
+
+        rndis_borrow_net(fi_rndis, ecm_opts->net);
+        ecm_opts->bound = true;
+#endif
 
         /* set up serial link layer */
         fi_acm = usb_get_function_instance("acm");
@@ -292,57 +394,102 @@ static int __ref multi_bind(struct usb_composite_dev *cdev)
         }
 
         /* set up mass storage function */
-        {
-                void *retp;
-                retp = fsg_common_from_params(&fsg_common, cdev, &fsg_mod_data);
-                if (IS_ERR(retp)) {
-                        status = PTR_ERR(retp);
-                        goto fail1;
-                }
+        fi_msg = usb_get_function_instance("mass_storage");
+        if (IS_ERR(fi_msg)) {
+                status = PTR_ERR(fi_msg);
+                goto fail1;
         }
+        fsg_config_from_params(&config, &fsg_mod_data, fsg_num_buffers);
+        fsg_opts = fsg_opts_from_func_inst(fi_msg);
+
+        fsg_opts->no_configfs = true;
+        status = fsg_common_set_num_buffers(fsg_opts->common, fsg_num_buffers);
+        if (status)
+                goto fail2;
+
+        status = fsg_common_set_nluns(fsg_opts->common, config.nluns);
+        if (status)
+                goto fail_set_nluns;
+
+        status = fsg_common_set_cdev(fsg_opts->common, cdev, config.can_stall);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_sysfs(fsg_opts->common, true);
+        status = fsg_common_create_luns(fsg_opts->common, &config);
+        if (status)
+                goto fail_set_cdev;
+
+        fsg_common_set_inquiry_string(fsg_opts->common, config.vendor_name,
+                                      config.product_name);
 
         /* allocate string IDs */
         status = usb_string_ids_tab(cdev, strings_dev);
         if (unlikely(status < 0))
-                goto fail2;
+                goto fail_string_ids;
         device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register configurations */
         status = rndis_config_register(cdev);
         if (unlikely(status < 0))
-                goto fail2;
+                goto fail_string_ids;
 
         status = cdc_config_register(cdev);
         if (unlikely(status < 0))
-                goto fail2;
+                goto fail_string_ids;
         usb_composite_overwrite_options(cdev, &coverwrite);
 
         /* we're done */
         dev_info(&gadget->dev, DRIVER_DESC "\n");
-        fsg_common_put(&fsg_common);
         return 0;
 
 
         /* error recovery */
+fail_string_ids:
+        fsg_common_remove_luns(fsg_opts->common);
+fail_set_cdev:
+        fsg_common_free_luns(fsg_opts->common);
+fail_set_nluns:
+        fsg_common_free_buffers(fsg_opts->common);
 fail2:
-        fsg_common_put(&fsg_common);
+        usb_put_function_instance(fi_msg);
 fail1:
         usb_put_function_instance(fi_acm);
 fail0:
-        gether_cleanup(the_dev);
+#ifdef USB_ETH_RNDIS
+        usb_put_function_instance(fi_rndis);
+fail:
+#endif
+#ifdef CONFIG_USB_G_MULTI_CDC
+        usb_put_function_instance(fi_ecm);
+#endif
         return status;
 }
 
 static int __exit multi_unbind(struct usb_composite_dev *cdev)
 {
 #ifdef CONFIG_USB_G_MULTI_CDC
+        usb_put_function(f_msg_multi);
+#endif
+#ifdef USB_ETH_RNDIS
+        usb_put_function(f_msg_rndis);
+#endif
+        usb_put_function_instance(fi_msg);
+#ifdef CONFIG_USB_G_MULTI_CDC
         usb_put_function(f_acm_multi);
 #endif
 #ifdef USB_ETH_RNDIS
         usb_put_function(f_acm_rndis);
 #endif
         usb_put_function_instance(fi_acm);
-        gether_cleanup(the_dev);
+#ifdef USB_ETH_RNDIS
+        usb_put_function(f_rndis);
+        usb_put_function_instance(fi_rndis);
+#endif
+#ifdef CONFIG_USB_G_MULTI_CDC
+        usb_put_function(f_ecm);
+        usb_put_function_instance(fi_ecm);
+#endif
         return 0;
 }
 
diff --git a/drivers/usb/gadget/mv_u3d_core.c b/drivers/usb/gadget/mv_u3d_core.c
index bbb6e98c4384..234711eabea1 100644
--- a/drivers/usb/gadget/mv_u3d_core.c
+++ b/drivers/usb/gadget/mv_u3d_core.c
@@ -310,6 +310,7 @@ static struct mv_u3d_trb *mv_u3d_build_trb_one(struct mv_u3d_req *req,
          */
         trb_hw = dma_pool_alloc(u3d->trb_pool, GFP_ATOMIC, dma);
         if (!trb_hw) {
+                kfree(trb);
                 dev_err(u3d->dev,
                         "%s, dma_pool_alloc fail\n", __func__);
                 return NULL;
@@ -454,6 +455,7 @@ static int mv_u3d_req_to_trb(struct mv_u3d_req *req)
 
                 trb_hw = kcalloc(trb_num, sizeof(*trb_hw), GFP_ATOMIC);
                 if (!trb_hw) {
+                        kfree(trb);
                         dev_err(u3d->dev,
                                         "%s, trb_hw alloc fail\n", __func__);
                         return -ENOMEM;
@@ -645,6 +647,7 @@ static int  mv_u3d_ep_disable(struct usb_ep *_ep)
         struct mv_u3d_ep *ep;
         struct mv_u3d_ep_context *ep_context;
         u32 epxcr, direction;
+        unsigned long flags;
 
         if (!_ep)
                 return -EINVAL;
@@ -661,7 +664,9 @@ static int  mv_u3d_ep_disable(struct usb_ep *_ep)
         direction = mv_u3d_ep_dir(ep);
 
         /* nuke all pending requests (does flush) */
+        spin_lock_irqsave(&u3d->lock, flags);
         mv_u3d_nuke(ep, -ESHUTDOWN);
+        spin_unlock_irqrestore(&u3d->lock, flags);
 
         /* Disable the endpoint for Rx or Tx and reset the endpoint type */
         if (direction == MV_U3D_EP_DIR_OUT) {
@@ -1933,7 +1938,7 @@ static int mv_u3d_probe(struct platform_device *dev)
         }
         u3d->irq = r->start;
         if (request_irq(u3d->irq, mv_u3d_irq,
-                IRQF_DISABLED | IRQF_SHARED, driver_name, u3d)) {
+                IRQF_SHARED, driver_name, u3d)) {
                 u3d->irq = 0;
                 dev_err(&dev->dev, "Request irq %d for u3d failed\n",
                         u3d->irq);
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 0781bff70015..fc852177c087 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -129,7 +129,7 @@ static char *type_string (u8 bmAttributes)
         case USB_ENDPOINT_XFER_BULK:    return "bulk";
         case USB_ENDPOINT_XFER_ISOC:    return "iso";
         case USB_ENDPOINT_XFER_INT:     return "intr";
-        };
+        }
         return "control";
 }
 #endif
@@ -1630,7 +1630,7 @@ static ssize_t queues_show(struct device *_dev, struct device_attribute *attr,
                                         val = "intr"; break;
                                  default:
                                         val = "iso"; break;
-                                 }; val; }),
+                                 } val; }),
                                 usb_endpoint_maxp (d) & 0x1fff,
                                 ep->dma ? "dma" : "pio", ep->fifo_size
                                 );
@@ -2680,7 +2680,6 @@ static void net2280_remove (struct pci_dev *pdev)
         if (dev->enabled)
                 pci_disable_device (pdev);
         device_remove_file (&pdev->dev, &dev_attr_registers);
-        pci_set_drvdata (pdev, NULL);
 
         INFO (dev, "unbind\n");
 }
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
index 24174e1d1564..32d5e923750b 100644
--- a/drivers/usb/gadget/pch_udc.c
+++ b/drivers/usb/gadget/pch_udc.c
@@ -3080,7 +3080,6 @@ static void pch_udc_remove(struct pci_dev *pdev)
         if (dev->active)
                 pci_disable_device(pdev);
         kfree(dev);
-        pci_set_drvdata(pdev, NULL);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index cc9207473dbc..0ac6064aa3b8 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -2054,7 +2054,7 @@ static struct pxa25x_udc memory = {
 /*
  *      probe - binds to the platform device
  */
-static int __init pxa25x_udc_probe(struct platform_device *pdev)
+static int pxa25x_udc_probe(struct platform_device *pdev)
 {
         struct pxa25x_udc *dev = &memory;
         int retval, irq;
@@ -2203,7 +2203,7 @@ static void pxa25x_udc_shutdown(struct platform_device *_dev)
         pullup_off();
 }
 
-static int __exit pxa25x_udc_remove(struct platform_device *pdev)
+static int pxa25x_udc_remove(struct platform_device *pdev)
 {
         struct pxa25x_udc *dev = platform_get_drvdata(pdev);
 
@@ -2294,7 +2294,8 @@ static int pxa25x_udc_resume(struct platform_device *dev)
 
 static struct platform_driver udc_driver = {
         .shutdown       = pxa25x_udc_shutdown,
-        .remove         = __exit_p(pxa25x_udc_remove),
+        .probe          = pxa25x_udc_probe,
+        .remove         = pxa25x_udc_remove,
         .suspend        = pxa25x_udc_suspend,
         .resume         = pxa25x_udc_resume,
         .driver         = {
@@ -2303,7 +2304,7 @@ static struct platform_driver udc_driver = {
         },
 };
 
-module_platform_driver_probe(udc_driver, pxa25x_udc_probe);
+module_platform_driver(udc_driver);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR("Frank Becker, Robert Schwebel, David Brownell");
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 9575085ded81..a3ad732bc812 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -1068,7 +1068,7 @@ static int rndis_proc_show(struct seq_file *m, void *v)
                                 s = "RNDIS_INITIALIZED"; break;
                          case RNDIS_DATA_INITIALIZED:
                                 s = "RNDIS_DATA_INITIALIZED"; break;
-                        }; s; }),
+                        } s; }),
                          param->medium,
                          (param->media_state) ? 0 : param->speed*100,
                          (param->media_state) ? "disconnected" : "connected",
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index d69b36a99dbc..9875d9c0823f 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -83,9 +83,12 @@ struct s3c_hsotg_req;
  * @dir_in: Set to true if this endpoint is of the IN direction, which
  *          means that it is sending data to the Host.
  * @index: The index for the endpoint registers.
+ * @mc: Multi Count - number of transactions per microframe
+ * @interval - Interval for periodic endpoints
  * @name: The name array passed to the USB core.
  * @halted: Set if the endpoint has been halted.
  * @periodic: Set if this is a periodic ep, such as Interrupt
+ * @isochronous: Set if this is a isochronous ep
  * @sent_zlp: Set if we've sent a zero-length packet.
  * @total_data: The total number of data bytes done.
  * @fifo_size: The size of the FIFO (for periodic IN endpoints)
@@ -121,9 +124,12 @@ struct s3c_hsotg_ep {
 
         unsigned char           dir_in;
         unsigned char           index;
+        unsigned char           mc;
+        unsigned char           interval;
 
         unsigned int            halted:1;
         unsigned int            periodic:1;
+        unsigned int            isochronous:1;
         unsigned int            sent_zlp:1;
 
         char                    name[10];
@@ -468,6 +474,7 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
         void *data;
         int can_write;
         int pkt_round;
+        int max_transfer;
 
         to_write -= (buf_pos - hs_ep->last_load);
 
@@ -535,15 +542,17 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 can_write *= 4; /* fifo size is in 32bit quantities. */
         }
 
-        dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, mps %d\n",
-                 __func__, gnptxsts, can_write, to_write, hs_ep->ep.maxpacket);
+        max_transfer = hs_ep->ep.maxpacket * hs_ep->mc;
+
+        dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, max_transfer %d\n",
+                 __func__, gnptxsts, can_write, to_write, max_transfer);
 
         /*
          * limit to 512 bytes of data, it seems at least on the non-periodic
          * FIFO, requests of >512 cause the endpoint to get stuck with a
          * fragment of the end of the transfer in it.
          */
-        if (can_write > 512)
+        if (can_write > 512 && !periodic)
                 can_write = 512;
 
         /*
@@ -551,19 +560,21 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
          * the transfer to return that it did not run out of fifo space
          * doing it.
          */
-        if (to_write > hs_ep->ep.maxpacket) {
-                to_write = hs_ep->ep.maxpacket;
+        if (to_write > max_transfer) {
+                to_write = max_transfer;
 
-                s3c_hsotg_en_gsint(hsotg,
-                                   periodic ? GINTSTS_PTxFEmp :
-                                   GINTSTS_NPTxFEmp);
+                /* it's needed only when we do not use dedicated fifos */
+                if (!hsotg->dedicated_fifos)
+                        s3c_hsotg_en_gsint(hsotg,
+                                           periodic ? GINTSTS_PTxFEmp :
+                                           GINTSTS_NPTxFEmp);
         }
 
         /* see if we can write data */
 
         if (to_write > can_write) {
                 to_write = can_write;
-                pkt_round = to_write % hs_ep->ep.maxpacket;
+                pkt_round = to_write % max_transfer;
 
                 /*
                  * Round the write down to an
@@ -581,9 +592,11 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                  * is more room left.
                  */
 
-                s3c_hsotg_en_gsint(hsotg,
-                                   periodic ? GINTSTS_PTxFEmp :
-                                   GINTSTS_NPTxFEmp);
+                /* it's needed only when we do not use dedicated fifos */
+                if (!hsotg->dedicated_fifos)
+                        s3c_hsotg_en_gsint(hsotg,
+                                           periodic ? GINTSTS_PTxFEmp :
+                                           GINTSTS_NPTxFEmp);
         }
 
         dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
@@ -727,8 +740,16 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         else
                 packets = 1;    /* send one packet if length is zero. */
 
+        if (hs_ep->isochronous && length > (hs_ep->mc * hs_ep->ep.maxpacket)) {
+                dev_err(hsotg->dev, "req length > maxpacket*mc\n");
+                return;
+        }
+
         if (dir_in && index != 0)
-                epsize = DxEPTSIZ_MC(1);
+                if (hs_ep->isochronous)
+                        epsize = DxEPTSIZ_MC(packets);
+                else
+                        epsize = DxEPTSIZ_MC(1);
         else
                 epsize = 0;
 
@@ -820,6 +841,9 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
 
         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n",
                 __func__, readl(hsotg->regs + epctrl_reg));
+
+        /* enable ep interrupts */
+        s3c_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 1);
 }
 
 /**
@@ -1091,6 +1115,7 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
         bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
         struct s3c_hsotg_ep *ep;
         int ret;
+        bool halted;
 
         dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
                 __func__, set ? "SET" : "CLEAR");
@@ -1105,6 +1130,8 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
 
                 switch (le16_to_cpu(ctrl->wValue)) {
                 case USB_ENDPOINT_HALT:
+                        halted = ep->halted;
+
                         s3c_hsotg_ep_sethalt(&ep->ep, set);
 
                         ret = s3c_hsotg_send_reply(hsotg, ep0, NULL, 0);
@@ -1114,7 +1141,12 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                                 return ret;
                         }
 
-                        if (!set) {
+                        /*
+                         * we have to complete all requests for ep if it was
+                         * halted, and the halt was cleared by CLEAR_FEATURE
+                         */
+
+                        if (!set && halted) {
                                 /*
                                  * If we have request in progress,
                                  * then complete it
@@ -1147,6 +1179,8 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
         return 1;
 }
 
+static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg);
+
 /**
  * s3c_hsotg_process_control - process a control request
  * @hsotg: The device state
@@ -1246,11 +1280,15 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                  * don't believe we need to anything more to get the EP
                  * to reply with a STALL packet
                  */
+
+                 /*
+                  * complete won't be called, so we enqueue
+                  * setup request here
+                  */
+                 s3c_hsotg_enqueue_setup(hsotg);
         }
 }
 
-static void s3c_hsotg_enqueue_setup(struct s3c_hsotg *hsotg);
-
 /**
  * s3c_hsotg_complete_setup - completion of a setup transfer
  * @ep: The endpoint the request was on.
@@ -1698,6 +1736,7 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
         struct s3c_hsotg_ep *hs_ep = &hsotg->eps[ep];
         void __iomem *regs = hsotg->regs;
         u32 mpsval;
+        u32 mcval;
         u32 reg;
 
         if (ep == 0) {
@@ -1705,15 +1744,19 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
                 mpsval = s3c_hsotg_ep0_mps(mps);
                 if (mpsval > 3)
                         goto bad_mps;
+                hs_ep->ep.maxpacket = mps;
+                hs_ep->mc = 1;
         } else {
-                if (mps >= DxEPCTL_MPS_LIMIT+1)
+                mpsval = mps & DxEPCTL_MPS_MASK;
+                if (mpsval > 1024)
                         goto bad_mps;
-
-                mpsval = mps;
+                mcval = ((mps >> 11) & 0x3) + 1;
+                hs_ep->mc = mcval;
+                if (mcval > 3)
+                        goto bad_mps;
+                hs_ep->ep.maxpacket = mpsval;
         }
 
-        hs_ep->ep.maxpacket = mps;
-
         /*
          * update both the in and out endpoint controldir_ registers, even
          * if one of the directions may not be in use.
@@ -1782,8 +1825,16 @@ static int s3c_hsotg_trytx(struct s3c_hsotg *hsotg,
 {
         struct s3c_hsotg_req *hs_req = hs_ep->req;
 
-        if (!hs_ep->dir_in || !hs_req)
+        if (!hs_ep->dir_in || !hs_req) {
+                /**
+                 * if request is not enqueued, we disable interrupts
+                 * for endpoints, excepting ep0
+                 */
+                if (hs_ep->index != 0)
+                        s3c_hsotg_ctrl_epint(hsotg, hs_ep->index,
+                                             hs_ep->dir_in, 0);
                 return 0;
+        }
 
         if (hs_req->req.actual < hs_req->req.length) {
                 dev_dbg(hsotg->dev, "trying to write more for ep%d\n",
@@ -1887,8 +1938,10 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
         u32 epsiz_reg = dir_in ? DIEPTSIZ(idx) : DOEPTSIZ(idx);
         u32 ints;
+        u32 ctrl;
 
         ints = readl(hsotg->regs + epint_reg);
+        ctrl = readl(hsotg->regs + epctl_reg);
 
         /* Clear endpoint interrupts */
         writel(ints, hsotg->regs + epint_reg);
@@ -1897,6 +1950,14 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 __func__, idx, dir_in ? "in" : "out", ints);
 
         if (ints & DxEPINT_XferCompl) {
+                if (hs_ep->isochronous && hs_ep->interval == 1) {
+                        if (ctrl & DxEPCTL_EOFrNum)
+                                ctrl |= DxEPCTL_SetEvenFr;
+                        else
+                                ctrl |= DxEPCTL_SetOddFr;
+                        writel(ctrl, hsotg->regs + epctl_reg);
+                }
+
                 dev_dbg(hsotg->dev,
                         "%s: XferCompl: DxEPCTL=0x%08x, DxEPTSIZ=%08x\n",
                         __func__, readl(hsotg->regs + epctl_reg),
@@ -1963,7 +2024,7 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         if (ints & DxEPINT_Back2BackSetup)
                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
 
-        if (dir_in) {
+        if (dir_in && !hs_ep->isochronous) {
                 /* not sure if this is important, but we'll clear it anyway */
                 if (ints & DIEPMSK_INTknTXFEmpMsk) {
                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
@@ -2092,12 +2153,14 @@ static void kill_all_requests(struct s3c_hsotg *hsotg,
 }
 
 #define call_gadget(_hs, _entry) \
+do { \
         if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
             (_hs)->driver && (_hs)->driver->_entry) { \
                 spin_unlock(&_hs->lock); \
                 (_hs)->driver->_entry(&(_hs)->gadget); \
                 spin_lock(&_hs->lock); \
-                }
+        } \
+} while (0)
 
 /**
  * s3c_hsotg_disconnect - disconnect service
@@ -2241,15 +2304,19 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
                        GAHBCFG_HBstLen_Incr4,
                        hsotg->regs + GAHBCFG);
         else
-                writel(GAHBCFG_GlblIntrEn, hsotg->regs + GAHBCFG);
+                writel(((hsotg->dedicated_fifos) ? (GAHBCFG_NPTxFEmpLvl |
+                                                    GAHBCFG_PTxFEmpLvl) : 0) |
+                       GAHBCFG_GlblIntrEn,
+                       hsotg->regs + GAHBCFG);
 
         /*
-         * Enabling INTknTXFEmpMsk here seems to be a big mistake, we end
-         * up being flooded with interrupts if the host is polling the
-         * endpoint to try and read data.
+         * If INTknTXFEmpMsk is enabled, it's important to disable ep interrupts
+         * when we have no data to transfer. Otherwise we get being flooded by
+         * interrupts.
          */
 
-        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TxFIFOEmpty : 0) |
+        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TxFIFOEmpty |
+               DIEPMSK_INTknTXFEmpMsk : 0) |
                DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk |
                DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
                DIEPMSK_INTknEPMisMsk,
@@ -2378,10 +2445,14 @@ irq_retry:
 
         if (gintsts & (GINTSTS_OEPInt | GINTSTS_IEPInt)) {
                 u32 daint = readl(hsotg->regs + DAINT);
-                u32 daint_out = daint >> DAINT_OutEP_SHIFT;
-                u32 daint_in = daint & ~(daint_out << DAINT_OutEP_SHIFT);
+                u32 daintmsk = readl(hsotg->regs + DAINTMSK);
+                u32 daint_out, daint_in;
                 int ep;
 
+                daint &= daintmsk;
+                daint_out = daint >> DAINT_OutEP_SHIFT;
+                daint_in = daint & ~(daint_out << DAINT_OutEP_SHIFT);
+
                 dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
 
                 for (ep = 0; ep < 15 && daint_out; ep++, daint_out >>= 1) {
@@ -2475,8 +2546,6 @@ irq_retry:
         if (gintsts & GINTSTS_ErlySusp) {
                 dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
                 writel(GINTSTS_ErlySusp, hsotg->regs + GINTSTS);
-
-                s3c_hsotg_disconnect(hsotg);
         }
 
         /*
@@ -2579,16 +2648,25 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         epctrl |= DxEPCTL_SNAK;
 
         /* update the endpoint state */
-        hs_ep->ep.maxpacket = mps;
+        s3c_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps);
 
         /* default, set to non-periodic */
+        hs_ep->isochronous = 0;
         hs_ep->periodic = 0;
+        hs_ep->halted = 0;
+        hs_ep->interval = desc->bInterval;
+
+        if (hs_ep->interval > 1 && hs_ep->mc > 1)
+                dev_err(hsotg->dev, "MC > 1 when interval is not 1\n");
 
         switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
         case USB_ENDPOINT_XFER_ISOC:
-                dev_err(hsotg->dev, "no current ISOC support\n");
-                ret = -EINVAL;
-                goto out;
+                epctrl |= DxEPCTL_EPType_Iso;
+                epctrl |= DxEPCTL_SetEvenFr;
+                hs_ep->isochronous = 1;
+                if (dir_in)
+                        hs_ep->periodic = 1;
+                break;
 
         case USB_ENDPOINT_XFER_BULK:
                 epctrl |= DxEPCTL_EPType_Bulk;
@@ -2636,7 +2714,6 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         /* enable the endpoint interrupt */
         s3c_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
 
-out:
         spin_unlock_irqrestore(&hsotg->lock, flags);
         return ret;
 }
@@ -2778,6 +2855,8 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
 
         writel(epctl, hs->regs + epreg);
 
+        hs_ep->halted = value;
+
         return 0;
 }
 
@@ -2905,7 +2984,7 @@ static int s3c_hsotg_udc_start(struct usb_gadget *gadget,
         int ret;
 
         if (!hsotg) {
-                printk(KERN_ERR "%s: called with no device\n", __func__);
+                pr_err("%s: called with no device\n", __func__);
                 return -ENODEV;
         }
 
@@ -2962,9 +3041,6 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget,
         if (!hsotg)
                 return -ENODEV;
 
-        if (!driver || driver != hsotg->driver || !driver->unbind)
-                return -EINVAL;
-
         /* all endpoints should be shutdown */
         for (ep = 0; ep < hsotg->num_of_eps; ep++)
                 s3c_hsotg_ep_disable(&hsotg->eps[ep].ep);
@@ -2972,15 +3048,15 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget,
         spin_lock_irqsave(&hsotg->lock, flags);
 
         s3c_hsotg_phy_disable(hsotg);
-        regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
 
-        hsotg->driver = NULL;
+        if (!driver)
+                hsotg->driver = NULL;
+
         hsotg->gadget.speed = USB_SPEED_UNKNOWN;
 
         spin_unlock_irqrestore(&hsotg->lock, flags);
 
-        dev_info(hsotg->dev, "unregistered gadget driver '%s'\n",
-                 driver->driver.name);
+        regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
 
         return 0;
 }
@@ -3071,7 +3147,7 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
 
         hs_ep->parent = hsotg;
         hs_ep->ep.name = hs_ep->name;
-        hs_ep->ep.maxpacket = epnum ? 512 : EP0_MPS_LIMIT;
+        hs_ep->ep.maxpacket = epnum ? 1024 : EP0_MPS_LIMIT;
         hs_ep->ep.ops = &s3c_hsotg_ep_ops;
 
         /*
@@ -3205,7 +3281,7 @@ static int state_show(struct seq_file *seq, void *v)
                    readl(regs + GNPTXSTS),
                    readl(regs + GRXSTSR));
 
-        seq_printf(seq, "\nEndpoint status:\n");
+        seq_puts(seq, "\nEndpoint status:\n");
 
         for (idx = 0; idx < 15; idx++) {
                 u32 in, out;
@@ -3222,7 +3298,7 @@ static int state_show(struct seq_file *seq, void *v)
                 seq_printf(seq, ", DIEPTSIZ=0x%08x, DOEPTSIZ=0x%08x",
                            in, out);
 
-                seq_printf(seq, "\n");
+                seq_puts(seq, "\n");
         }
 
         return 0;
@@ -3256,7 +3332,7 @@ static int fifo_show(struct seq_file *seq, void *v)
         u32 val;
         int idx;
 
-        seq_printf(seq, "Non-periodic FIFOs:\n");
+        seq_puts(seq, "Non-periodic FIFOs:\n");
         seq_printf(seq, "RXFIFO: Size %d\n", readl(regs + GRXFSIZ));
 
         val = readl(regs + GNPTXFSIZ);
@@ -3264,7 +3340,7 @@ static int fifo_show(struct seq_file *seq, void *v)
                    val >> GNPTXFSIZ_NPTxFDep_SHIFT,
                    val & GNPTXFSIZ_NPTxFStAddr_MASK);
 
-        seq_printf(seq, "\nPeriodic TXFIFOs:\n");
+        seq_puts(seq, "\nPeriodic TXFIFOs:\n");
 
         for (idx = 1; idx <= 15; idx++) {
                 val = readl(regs + DPTXFSIZn(idx));
@@ -3335,7 +3411,7 @@ static int ep_show(struct seq_file *seq, void *v)
                    readl(regs + DIEPTSIZ(index)),
                    readl(regs + DOEPTSIZ(index)));
 
-        seq_printf(seq, "\n");
+        seq_puts(seq, "\n");
         seq_printf(seq, "mps %d\n", ep->ep.maxpacket);
         seq_printf(seq, "total_data=%ld\n", ep->total_data);
 
@@ -3346,7 +3422,7 @@ static int ep_show(struct seq_file *seq, void *v)
 
         list_for_each_entry(req, &ep->queue, queue) {
                 if (--show_limit < 0) {
-                        seq_printf(seq, "not showing more requests...\n");
+                        seq_puts(seq, "not showing more requests...\n");
                         break;
                 }
 
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 08a1a3210a21..ec20a1f50c2d 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -23,242 +23,17 @@
  * The valid range of num_buffers is: num >= 2 && num <= 4.
  */
 
+#include <linux/module.h>
+#include <linux/blkdev.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include <linux/usb/composite.h>
 
-#include <linux/usb/storage.h>
-#include <scsi/scsi.h>
-#include <asm/unaligned.h>
-
-
-/*
- * Thanks to NetChip Technologies for donating this product ID.
- *
- * DO NOT REUSE THESE IDs with any other driver!!  Ever!!
- * Instead:  allocate your own, using normal USB-IF procedures.
- */
-#define FSG_VENDOR_ID   0x0525  /* NetChip */
-#define FSG_PRODUCT_ID  0xa4a5  /* Linux-USB File-backed Storage Gadget */
-
-
-/*-------------------------------------------------------------------------*/
-
-
-#ifndef DEBUG
-#undef VERBOSE_DEBUG
-#undef DUMP_MSGS
-#endif /* !DEBUG */
-
-#ifdef VERBOSE_DEBUG
-#define VLDBG   LDBG
-#else
-#define VLDBG(lun, fmt, args...) do { } while (0)
-#endif /* VERBOSE_DEBUG */
-
-#define LDBG(lun, fmt, args...)   dev_dbg (&(lun)->dev, fmt, ## args)
-#define LERROR(lun, fmt, args...) dev_err (&(lun)->dev, fmt, ## args)
-#define LWARN(lun, fmt, args...)  dev_warn(&(lun)->dev, fmt, ## args)
-#define LINFO(lun, fmt, args...)  dev_info(&(lun)->dev, fmt, ## args)
-
-
-#ifdef DUMP_MSGS
-
-#  define dump_msg(fsg, /* const char * */ label,                       \
-                   /* const u8 * */ buf, /* unsigned */ length) do {    \
-        if (length < 512) {                                             \
-                DBG(fsg, "%s, length %u:\n", label, length);            \
-                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,      \
-                               16, 1, buf, length, 0);                  \
-        }                                                               \
-} while (0)
-
-#  define dump_cdb(fsg) do { } while (0)
-
-#else
-
-#  define dump_msg(fsg, /* const char * */ label, \
-                   /* const u8 * */ buf, /* unsigned */ length) do { } while (0)
-
-#  ifdef VERBOSE_DEBUG
-
-#    define dump_cdb(fsg)                                               \
-        print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,      \
-                       16, 1, (fsg)->cmnd, (fsg)->cmnd_size, 0)         \
-
-#  else
-
-#    define dump_cdb(fsg) do { } while (0)
-
-#  endif /* VERBOSE_DEBUG */
-
-#endif /* DUMP_MSGS */
-
-/*-------------------------------------------------------------------------*/
-
-/* Length of a SCSI Command Data Block */
-#define MAX_COMMAND_SIZE        16
-
-/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
-#define SS_NO_SENSE                             0
-#define SS_COMMUNICATION_FAILURE                0x040800
-#define SS_INVALID_COMMAND                      0x052000
-#define SS_INVALID_FIELD_IN_CDB                 0x052400
-#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE   0x052100
-#define SS_LOGICAL_UNIT_NOT_SUPPORTED           0x052500
-#define SS_MEDIUM_NOT_PRESENT                   0x023a00
-#define SS_MEDIUM_REMOVAL_PREVENTED             0x055302
-#define SS_NOT_READY_TO_READY_TRANSITION        0x062800
-#define SS_RESET_OCCURRED                       0x062900
-#define SS_SAVING_PARAMETERS_NOT_SUPPORTED      0x053900
-#define SS_UNRECOVERED_READ_ERROR               0x031100
-#define SS_WRITE_ERROR                          0x030c02
-#define SS_WRITE_PROTECTED                      0x072700
-
-#define SK(x)           ((u8) ((x) >> 16))      /* Sense Key byte, etc. */
-#define ASC(x)          ((u8) ((x) >> 8))
-#define ASCQ(x)         ((u8) (x))
-
-
-/*-------------------------------------------------------------------------*/
-
-
-struct fsg_lun {
-        struct file     *filp;
-        loff_t          file_length;
-        loff_t          num_sectors;
-
-        unsigned int    initially_ro:1;
-        unsigned int    ro:1;
-        unsigned int    removable:1;
-        unsigned int    cdrom:1;
-        unsigned int    prevent_medium_removal:1;
-        unsigned int    registered:1;
-        unsigned int    info_valid:1;
-        unsigned int    nofua:1;
-
-        u32             sense_data;
-        u32             sense_data_info;
-        u32             unit_attention_data;
-
-        unsigned int    blkbits;        /* Bits of logical block size of bound block device */
-        unsigned int    blksize;        /* logical block size of bound block device */
-        struct device   dev;
-};
-
-static inline bool fsg_lun_is_open(struct fsg_lun *curlun)
-{
-        return curlun->filp != NULL;
-}
-
-static inline struct fsg_lun *fsg_lun_from_dev(struct device *dev)
-{
-        return container_of(dev, struct fsg_lun, dev);
-}
-
-
-/* Big enough to hold our biggest descriptor */
-#define EP0_BUFSIZE     256
-#define DELAYED_STATUS  (EP0_BUFSIZE + 999)     /* An impossibly large value */
-
-#ifdef CONFIG_USB_GADGET_DEBUG_FILES
-
-static unsigned int fsg_num_buffers = CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS;
-module_param_named(num_buffers, fsg_num_buffers, uint, S_IRUGO);
-MODULE_PARM_DESC(num_buffers, "Number of pipeline buffers");
-
-#else
-
-/*
- * Number of buffers we will use.
- * 2 is usually enough for good buffering pipeline
- */
-#define fsg_num_buffers CONFIG_USB_GADGET_STORAGE_NUM_BUFFERS
-
-#endif /* CONFIG_USB_GADGET_DEBUG_FILES */
-
-/* check if fsg_num_buffers is within a valid range */
-static inline int fsg_num_buffers_validate(void)
-{
-        if (fsg_num_buffers >= 2 && fsg_num_buffers <= 4)
-                return 0;
-        pr_err("fsg_num_buffers %u is out of range (%d to %d)\n",
-               fsg_num_buffers, 2 ,4);
-        return -EINVAL;
-}
-
-/* Default size of buffer length. */
-#define FSG_BUFLEN      ((u32)16384)
-
-/* Maximal number of LUNs supported in mass storage function */
-#define FSG_MAX_LUNS    8
-
-enum fsg_buffer_state {
-        BUF_STATE_EMPTY = 0,
-        BUF_STATE_FULL,
-        BUF_STATE_BUSY
-};
-
-struct fsg_buffhd {
-        void                            *buf;
-        enum fsg_buffer_state           state;
-        struct fsg_buffhd               *next;
-
-        /*
-         * The NetChip 2280 is faster, and handles some protocol faults
-         * better, if we don't submit any short bulk-out read requests.
-         * So we will record the intended request length here.
-         */
-        unsigned int                    bulk_out_intended_length;
-
-        struct usb_request              *inreq;
-        int                             inreq_busy;
-        struct usb_request              *outreq;
-        int                             outreq_busy;
-};
-
-enum fsg_state {
-        /* This one isn't used anywhere */
-        FSG_STATE_COMMAND_PHASE = -10,
-        FSG_STATE_DATA_PHASE,
-        FSG_STATE_STATUS_PHASE,
-
-        FSG_STATE_IDLE = 0,
-        FSG_STATE_ABORT_BULK_OUT,
-        FSG_STATE_RESET,
-        FSG_STATE_INTERFACE_CHANGE,
-        FSG_STATE_CONFIG_CHANGE,
-        FSG_STATE_DISCONNECT,
-        FSG_STATE_EXIT,
-        FSG_STATE_TERMINATED
-};
-
-enum data_direction {
-        DATA_DIR_UNKNOWN = 0,
-        DATA_DIR_FROM_HOST,
-        DATA_DIR_TO_HOST,
-        DATA_DIR_NONE
-};
-
-
-/*-------------------------------------------------------------------------*/
-
-
-static inline u32 get_unaligned_be24(u8 *buf)
-{
-        return 0xffffff & (u32) get_unaligned_be32(buf - 1);
-}
-
-
-/*-------------------------------------------------------------------------*/
-
-
-enum {
-        FSG_STRING_INTERFACE
-};
-
+#include "storage_common.h"
 
 /* There is only one interface. */
 
-static struct usb_interface_descriptor
-fsg_intf_desc = {
+struct usb_interface_descriptor fsg_intf_desc = {
         .bLength =              sizeof fsg_intf_desc,
         .bDescriptorType =      USB_DT_INTERFACE,
 
@@ -268,14 +43,14 @@ fsg_intf_desc = {
         .bInterfaceProtocol =   USB_PR_BULK,    /* Adjusted during fsg_bind() */
         .iInterface =           FSG_STRING_INTERFACE,
 };
+EXPORT_SYMBOL(fsg_intf_desc);
 
 /*
  * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
  * interrupt-in.
  */
 
-static struct usb_endpoint_descriptor
-fsg_fs_bulk_in_desc = {
+struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -283,9 +58,9 @@ fsg_fs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
+EXPORT_SYMBOL(fsg_fs_bulk_in_desc);
 
-static struct usb_endpoint_descriptor
-fsg_fs_bulk_out_desc = {
+struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -293,13 +68,15 @@ fsg_fs_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
+EXPORT_SYMBOL(fsg_fs_bulk_out_desc);
 
-static struct usb_descriptor_header *fsg_fs_function[] = {
+struct usb_descriptor_header *fsg_fs_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
         (struct usb_descriptor_header *) &fsg_fs_bulk_in_desc,
         (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
         NULL,
 };
+EXPORT_SYMBOL(fsg_fs_function);
 
 
 /*
@@ -310,8 +87,7 @@ static struct usb_descriptor_header *fsg_fs_function[] = {
  * and a "device qualifier" ... plus more construction options
  * for the configuration descriptor.
  */
-static struct usb_endpoint_descriptor
-fsg_hs_bulk_in_desc = {
+struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -319,9 +95,9 @@ fsg_hs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(512),
 };
+EXPORT_SYMBOL(fsg_hs_bulk_in_desc);
 
-static struct usb_endpoint_descriptor
-fsg_hs_bulk_out_desc = {
+struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -330,17 +106,18 @@ fsg_hs_bulk_out_desc = {
         .wMaxPacketSize =       cpu_to_le16(512),
         .bInterval =            1,      /* NAK every 1 uframe */
 };
+EXPORT_SYMBOL(fsg_hs_bulk_out_desc);
 
 
-static struct usb_descriptor_header *fsg_hs_function[] = {
+struct usb_descriptor_header *fsg_hs_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
         (struct usb_descriptor_header *) &fsg_hs_bulk_in_desc,
         (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
         NULL,
 };
+EXPORT_SYMBOL(fsg_hs_function);
 
-static struct usb_endpoint_descriptor
-fsg_ss_bulk_in_desc = {
+struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -348,16 +125,17 @@ fsg_ss_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
+EXPORT_SYMBOL(fsg_ss_bulk_in_desc);
 
-static struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
+struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 
         /*.bMaxBurst =          DYNAMIC, */
 };
+EXPORT_SYMBOL(fsg_ss_bulk_in_comp_desc);
 
-static struct usb_endpoint_descriptor
-fsg_ss_bulk_out_desc = {
+struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
         .bDescriptorType =      USB_DT_ENDPOINT,
 
@@ -365,15 +143,17 @@ fsg_ss_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
+EXPORT_SYMBOL(fsg_ss_bulk_out_desc);
 
-static struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
+struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
         .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
 
         /*.bMaxBurst =          DYNAMIC, */
 };
+EXPORT_SYMBOL(fsg_ss_bulk_out_comp_desc);
 
-static struct usb_descriptor_header *fsg_ss_function[] = {
+struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
         (struct usb_descriptor_header *) &fsg_ss_bulk_in_desc,
         (struct usb_descriptor_header *) &fsg_ss_bulk_in_comp_desc,
@@ -381,17 +161,7 @@ static struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
         NULL,
 };
-
-/* Static strings, in UTF-8 (for simplicity we use only ASCII characters) */
-static struct usb_string                fsg_strings[] = {
-        {FSG_STRING_INTERFACE,          fsg_string_interface},
-        {}
-};
-
-static struct usb_gadget_strings        fsg_stringtab = {
-        .language       = 0x0409,               /* en-us */
-        .strings        = fsg_strings,
-};
+EXPORT_SYMBOL(fsg_ss_function);
 
 
  /*-------------------------------------------------------------------------*/
@@ -401,7 +171,7 @@ static struct usb_gadget_strings	fsg_stringtab = {
  * the caller must own fsg->filesem for writing.
  */
 
-static void fsg_lun_close(struct fsg_lun *curlun)
+void fsg_lun_close(struct fsg_lun *curlun)
 {
         if (curlun->filp) {
                 LDBG(curlun, "close backing file\n");
@@ -409,9 +179,9 @@ static void fsg_lun_close(struct fsg_lun *curlun)
                 curlun->filp = NULL;
         }
 }
+EXPORT_SYMBOL(fsg_lun_close);
 
-
-static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
+int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 {
         int                             ro;
         struct file                     *filp = NULL;
@@ -508,6 +278,7 @@ out:
         fput(filp);
         return rc;
 }
+EXPORT_SYMBOL(fsg_lun_open);
 
 
 /*-------------------------------------------------------------------------*/
@@ -516,7 +287,7 @@ out:
  * Sync the file data, don't bother with the metadata.
  * This code was copied from fs/buffer.c:sys_fdatasync().
  */
-static int fsg_lun_fsync_sub(struct fsg_lun *curlun)
+int fsg_lun_fsync_sub(struct fsg_lun *curlun)
 {
         struct file     *filp = curlun->filp;
 
@@ -524,8 +295,9 @@ static int fsg_lun_fsync_sub(struct fsg_lun *curlun)
                 return 0;
         return vfs_fsync(filp, 1);
 }
+EXPORT_SYMBOL(fsg_lun_fsync_sub);
 
-static void store_cdrom_address(u8 *dest, int msf, u32 addr)
+void store_cdrom_address(u8 *dest, int msf, u32 addr)
 {
         if (msf) {
                 /* Convert to Minutes-Seconds-Frames */
@@ -542,34 +314,28 @@ static void store_cdrom_address(u8 *dest, int msf, u32 addr)
                 put_unaligned_be32(addr, dest);
         }
 }
-
+EXPORT_SYMBOL(store_cdrom_address);
 
 /*-------------------------------------------------------------------------*/
 
 
-static ssize_t ro_show(struct device *dev, struct device_attribute *attr,
-                       char *buf)
+ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
 {
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-
         return sprintf(buf, "%d\n", fsg_lun_is_open(curlun)
                                   ? curlun->ro
                                   : curlun->initially_ro);
 }
+EXPORT_SYMBOL(fsg_show_ro);
 
-static ssize_t nofua_show(struct device *dev, struct device_attribute *attr,
-                          char *buf)
+ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
 {
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-
         return sprintf(buf, "%u\n", curlun->nofua);
 }
+EXPORT_SYMBOL(fsg_show_nofua);
 
-static ssize_t file_show(struct device *dev, struct device_attribute *attr,
-                         char *buf)
+ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                      char *buf)
 {
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
         char            *p;
         ssize_t         rc;
 
@@ -591,17 +357,44 @@ static ssize_t file_show(struct device *dev, struct device_attribute *attr,
         up_read(filesem);
         return rc;
 }
+EXPORT_SYMBOL(fsg_show_file);
 
+ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
+{
+        return sprintf(buf, "%u\n", curlun->cdrom);
+}
+EXPORT_SYMBOL(fsg_show_cdrom);
 
-static ssize_t ro_store(struct device *dev, struct device_attribute *attr,
-                        const char *buf, size_t count)
+ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
+{
+        return sprintf(buf, "%u\n", curlun->removable);
+}
+EXPORT_SYMBOL(fsg_show_removable);
+
+/*
+ * The caller must hold fsg->filesem for reading when calling this function.
+ */
+static ssize_t _fsg_store_ro(struct fsg_lun *curlun, bool ro)
+{
+        if (fsg_lun_is_open(curlun)) {
+                LDBG(curlun, "read-only status change prevented\n");
+                return -EBUSY;
+        }
+
+        curlun->ro = ro;
+        curlun->initially_ro = ro;
+        LDBG(curlun, "read-only status set to %d\n", curlun->ro);
+
+        return 0;
+}
+
+ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                     const char *buf, size_t count)
 {
         ssize_t         rc;
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
-        unsigned        ro;
+        bool            ro;
 
-        rc = kstrtouint(buf, 2, &ro);
+        rc = strtobool(buf, &ro);
         if (rc)
                 return rc;
 
@@ -610,27 +403,21 @@ static ssize_t ro_store(struct device *dev, struct device_attribute *attr,
          * backing file is closed.
          */
         down_read(filesem);
-        if (fsg_lun_is_open(curlun)) {
-                LDBG(curlun, "read-only status change prevented\n");
-                rc = -EBUSY;
-        } else {
-                curlun->ro = ro;
-                curlun->initially_ro = ro;
-                LDBG(curlun, "read-only status set to %d\n", curlun->ro);
+        rc = _fsg_store_ro(curlun, ro);
+        if (!rc)
                 rc = count;
-        }
         up_read(filesem);
+
         return rc;
 }
+EXPORT_SYMBOL(fsg_store_ro);
 
-static ssize_t nofua_store(struct device *dev, struct device_attribute *attr,
-                           const char *buf, size_t count)
+ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 {
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        unsigned        nofua;
+        bool            nofua;
         int             ret;
 
-        ret = kstrtouint(buf, 2, &nofua);
+        ret = strtobool(buf, &nofua);
         if (ret)
                 return ret;
 
@@ -642,12 +429,11 @@ static ssize_t nofua_store(struct device *dev, struct device_attribute *attr,
 
         return count;
 }
+EXPORT_SYMBOL(fsg_store_nofua);
 
-static ssize_t file_store(struct device *dev, struct device_attribute *attr,
-                          const char *buf, size_t count)
+ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                       const char *buf, size_t count)
 {
-        struct fsg_lun  *curlun = fsg_lun_from_dev(dev);
-        struct rw_semaphore     *filesem = dev_get_drvdata(dev);
         int             rc = 0;
 
         if (curlun->prevent_medium_removal && fsg_lun_is_open(curlun)) {
@@ -674,3 +460,45 @@ static ssize_t file_store(struct device *dev, struct device_attribute *attr,
         up_write(filesem);
         return (rc < 0 ? rc : count);
 }
+EXPORT_SYMBOL(fsg_store_file);
+
+ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                        const char *buf, size_t count)
+{
+        bool            cdrom;
+        int             ret;
+
+        ret = strtobool(buf, &cdrom);
+        if (ret)
+                return ret;
+
+        down_read(filesem);
+        ret = cdrom ? _fsg_store_ro(curlun, true) : 0;
+
+        if (!ret) {
+                curlun->cdrom = cdrom;
+                ret = count;
+        }
+        up_read(filesem);
+
+        return ret;
+}
+EXPORT_SYMBOL(fsg_store_cdrom);
+
+ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
+                            size_t count)
+{
+        bool            removable;
+        int             ret;
+
+        ret = strtobool(buf, &removable);
+        if (ret)
+                return ret;
+
+        curlun->removable = removable;
+
+        return count;
+}
+EXPORT_SYMBOL(fsg_store_removable);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/storage_common.h b/drivers/usb/gadget/storage_common.h
new file mode 100644
index 000000000000..c74c2fdbd56e
--- /dev/null
+++ b/drivers/usb/gadget/storage_common.h
@@ -0,0 +1,229 @@
+#ifndef USB_STORAGE_COMMON_H
+#define USB_STORAGE_COMMON_H
+
+#include <linux/device.h>
+#include <linux/usb/storage.h>
+#include <scsi/scsi.h>
+#include <asm/unaligned.h>
+
+#ifndef DEBUG
+#undef VERBOSE_DEBUG
+#undef DUMP_MSGS
+#endif /* !DEBUG */
+
+#ifdef VERBOSE_DEBUG
+#define VLDBG   LDBG
+#else
+#define VLDBG(lun, fmt, args...) do { } while (0)
+#endif /* VERBOSE_DEBUG */
+
+#define _LMSG(func, lun, fmt, args...)                                  \
+        do {                                                            \
+                if ((lun)->name_pfx && *(lun)->name_pfx)                \
+                        func("%s/%s: " fmt, *(lun)->name_pfx,           \
+                                 (lun)->name, ## args);                 \
+                else                                                    \
+                        func("%s: " fmt, (lun)->name, ## args);         \
+        } while (0)
+
+#define LDBG(lun, fmt, args...)         _LMSG(pr_debug, lun, fmt, ## args)
+#define LERROR(lun, fmt, args...)       _LMSG(pr_err, lun, fmt, ## args)
+#define LWARN(lun, fmt, args...)        _LMSG(pr_warn, lun, fmt, ## args)
+#define LINFO(lun, fmt, args...)        _LMSG(pr_info, lun, fmt, ## args)
+
+
+#ifdef DUMP_MSGS
+
+#  define dump_msg(fsg, /* const char * */ label,                       \
+                   /* const u8 * */ buf, /* unsigned */ length)         \
+do {                                                                    \
+        if (length < 512) {                                             \
+                DBG(fsg, "%s, length %u:\n", label, length);            \
+                print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET,      \
+                               16, 1, buf, length, 0);                  \
+        }                                                               \
+} while (0)
+
+#  define dump_cdb(fsg) do { } while (0)
+
+#else
+
+#  define dump_msg(fsg, /* const char * */ label, \
+                   /* const u8 * */ buf, /* unsigned */ length) do { } while (0)
+
+#  ifdef VERBOSE_DEBUG
+
+#    define dump_cdb(fsg)                                               \
+        print_hex_dump(KERN_DEBUG, "SCSI CDB: ", DUMP_PREFIX_NONE,      \
+                       16, 1, (fsg)->cmnd, (fsg)->cmnd_size, 0)         \
+
+#  else
+
+#    define dump_cdb(fsg) do { } while (0)
+
+#  endif /* VERBOSE_DEBUG */
+
+#endif /* DUMP_MSGS */
+
+/* Length of a SCSI Command Data Block */
+#define MAX_COMMAND_SIZE        16
+
+/* SCSI Sense Key/Additional Sense Code/ASC Qualifier values */
+#define SS_NO_SENSE                             0
+#define SS_COMMUNICATION_FAILURE                0x040800
+#define SS_INVALID_COMMAND                      0x052000
+#define SS_INVALID_FIELD_IN_CDB                 0x052400
+#define SS_LOGICAL_BLOCK_ADDRESS_OUT_OF_RANGE   0x052100
+#define SS_LOGICAL_UNIT_NOT_SUPPORTED           0x052500
+#define SS_MEDIUM_NOT_PRESENT                   0x023a00
+#define SS_MEDIUM_REMOVAL_PREVENTED             0x055302
+#define SS_NOT_READY_TO_READY_TRANSITION        0x062800
+#define SS_RESET_OCCURRED                       0x062900
+#define SS_SAVING_PARAMETERS_NOT_SUPPORTED      0x053900
+#define SS_UNRECOVERED_READ_ERROR               0x031100
+#define SS_WRITE_ERROR                          0x030c02
+#define SS_WRITE_PROTECTED                      0x072700
+
+#define SK(x)           ((u8) ((x) >> 16))      /* Sense Key byte, etc. */
+#define ASC(x)          ((u8) ((x) >> 8))
+#define ASCQ(x)         ((u8) (x))
+
+struct fsg_lun {
+        struct file     *filp;
+        loff_t          file_length;
+        loff_t          num_sectors;
+
+        unsigned int    initially_ro:1;
+        unsigned int    ro:1;
+        unsigned int    removable:1;
+        unsigned int    cdrom:1;
+        unsigned int    prevent_medium_removal:1;
+        unsigned int    registered:1;
+        unsigned int    info_valid:1;
+        unsigned int    nofua:1;
+
+        u32             sense_data;
+        u32             sense_data_info;
+        u32             unit_attention_data;
+
+        unsigned int    blkbits; /* Bits of logical block size
+                                                       of bound block device */
+        unsigned int    blksize; /* logical block size of bound block device */
+        struct device   dev;
+        const char      *name;          /* "lun.name" */
+        const char      **name_pfx;     /* "function.name" */
+};
+
+static inline bool fsg_lun_is_open(struct fsg_lun *curlun)
+{
+        return curlun->filp != NULL;
+}
+
+/* Big enough to hold our biggest descriptor */
+#define EP0_BUFSIZE     256
+#define DELAYED_STATUS  (EP0_BUFSIZE + 999)     /* An impossibly large value */
+
+/* Default size of buffer length. */
+#define FSG_BUFLEN      ((u32)16384)
+
+/* Maximal number of LUNs supported in mass storage function */
+#define FSG_MAX_LUNS    8
+
+enum fsg_buffer_state {
+        BUF_STATE_EMPTY = 0,
+        BUF_STATE_FULL,
+        BUF_STATE_BUSY
+};
+
+struct fsg_buffhd {
+        void                            *buf;
+        enum fsg_buffer_state           state;
+        struct fsg_buffhd               *next;
+
+        /*
+         * The NetChip 2280 is faster, and handles some protocol faults
+         * better, if we don't submit any short bulk-out read requests.
+         * So we will record the intended request length here.
+         */
+        unsigned int                    bulk_out_intended_length;
+
+        struct usb_request              *inreq;
+        int                             inreq_busy;
+        struct usb_request              *outreq;
+        int                             outreq_busy;
+};
+
+enum fsg_state {
+        /* This one isn't used anywhere */
+        FSG_STATE_COMMAND_PHASE = -10,
+        FSG_STATE_DATA_PHASE,
+        FSG_STATE_STATUS_PHASE,
+
+        FSG_STATE_IDLE = 0,
+        FSG_STATE_ABORT_BULK_OUT,
+        FSG_STATE_RESET,
+        FSG_STATE_INTERFACE_CHANGE,
+        FSG_STATE_CONFIG_CHANGE,
+        FSG_STATE_DISCONNECT,
+        FSG_STATE_EXIT,
+        FSG_STATE_TERMINATED
+};
+
+enum data_direction {
+        DATA_DIR_UNKNOWN = 0,
+        DATA_DIR_FROM_HOST,
+        DATA_DIR_TO_HOST,
+        DATA_DIR_NONE
+};
+
+static inline u32 get_unaligned_be24(u8 *buf)
+{
+        return 0xffffff & (u32) get_unaligned_be32(buf - 1);
+}
+
+static inline struct fsg_lun *fsg_lun_from_dev(struct device *dev)
+{
+        return container_of(dev, struct fsg_lun, dev);
+}
+
+enum {
+        FSG_STRING_INTERFACE
+};
+
+extern struct usb_interface_descriptor fsg_intf_desc;
+
+extern struct usb_endpoint_descriptor fsg_fs_bulk_in_desc;
+extern struct usb_endpoint_descriptor fsg_fs_bulk_out_desc;
+extern struct usb_descriptor_header *fsg_fs_function[];
+
+extern struct usb_endpoint_descriptor fsg_hs_bulk_in_desc;
+extern struct usb_endpoint_descriptor fsg_hs_bulk_out_desc;
+extern struct usb_descriptor_header *fsg_hs_function[];
+
+extern struct usb_endpoint_descriptor fsg_ss_bulk_in_desc;
+extern struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc;
+extern struct usb_endpoint_descriptor fsg_ss_bulk_out_desc;
+extern struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc;
+extern struct usb_descriptor_header *fsg_ss_function[];
+
+void fsg_lun_close(struct fsg_lun *curlun);
+int fsg_lun_open(struct fsg_lun *curlun, const char *filename);
+int fsg_lun_fsync_sub(struct fsg_lun *curlun);
+void store_cdrom_address(u8 *dest, int msf, u32 addr);
+ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf);
+ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf);
+ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                      char *buf);
+ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf);
+ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf);
+ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                     const char *buf, size_t count);
+ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count);
+ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                       const char *buf, size_t count);
+ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
+                        const char *buf, size_t count);
+ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
+                            size_t count);
+
+#endif /* USB_STORAGE_COMMON_H */
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index 0ff33396eef3..eccea1df702d 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -472,7 +472,7 @@ static int usbg_bot_setup(struct usb_function *f,
                 bot_enqueue_cmd_cbw(fu);
                 return 0;
                 break;
-        };
+        }
         return -ENOTSUPP;
 }
 
@@ -617,7 +617,7 @@ static void uasp_status_data_cmpl(struct usb_ep *ep, struct usb_request *req)
 
         default:
                 BUG();
-        };
+        }
         return;
 
 cleanup:
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 59891b1c48fc..27768a7d986a 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -356,7 +356,8 @@ static int udc_bind_to_driver(struct usb_udc *udc, struct usb_gadget_driver *dri
         kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
         return 0;
 err1:
-        dev_err(&udc->dev, "failed to start %s: %d\n",
+        if (ret != -EISNAM)
+                dev_err(&udc->dev, "failed to start %s: %d\n",
                         udc->driver->function, ret);
         udc->driver = NULL;
         udc->dev.driver = NULL;
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 0deb9d6cde26..0dd07ae1555d 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -95,6 +95,18 @@ unsigned autoresume = DEFAULT_AUTORESUME;
 module_param(autoresume, uint, S_IRUGO);
 MODULE_PARM_DESC(autoresume, "zero, or seconds before remote wakeup");
 
+/* Maximum Autoresume time */
+unsigned max_autoresume;
+module_param(max_autoresume, uint, S_IRUGO);
+MODULE_PARM_DESC(max_autoresume, "maximum seconds before remote wakeup");
+
+/* Interval between two remote wakeups */
+unsigned autoresume_interval_ms;
+module_param(autoresume_interval_ms, uint, S_IRUGO);
+MODULE_PARM_DESC(autoresume_interval_ms,
+                "milliseconds to increase successive wakeup delays");
+
+static unsigned autoresume_step_ms;
 /*-------------------------------------------------------------------------*/
 
 static struct usb_device_descriptor device_desc = {
@@ -183,8 +195,16 @@ static void zero_suspend(struct usb_composite_dev *cdev)
                 return;
 
         if (autoresume) {
-                mod_timer(&autoresume_timer, jiffies + (HZ * autoresume));
-                DBG(cdev, "suspend, wakeup in %d seconds\n", autoresume);
+                if (max_autoresume &&
+                        (autoresume_step_ms > max_autoresume * 1000))
+                                autoresume_step_ms = autoresume * 1000;
+
+                mod_timer(&autoresume_timer, jiffies +
+                        msecs_to_jiffies(autoresume_step_ms));
+                DBG(cdev, "suspend, wakeup in %d milliseconds\n",
+                        autoresume_step_ms);
+
+                autoresume_step_ms += autoresume_interval_ms;
         } else
                 DBG(cdev, "%s\n", __func__);
 }
@@ -316,6 +336,7 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
         if (autoresume) {
                 sourcesink_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
                 loopback_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
+                autoresume_step_ms = autoresume * 1000;
         }
 
         /* support OTG systems */
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 5be0326aae38..a9707da7da0b 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -54,7 +54,7 @@ config USB_EHCI_HCD
 
 config USB_EHCI_ROOT_HUB_TT
         bool "Root Hub Transaction Translators"
-        depends on USB_EHCI_HCD || USB_CHIPIDEA_HOST
+        depends on USB_EHCI_HCD
         ---help---
           Some EHCI chips have vendor-specific extensions to integrate
           transaction translators, so that no OHCI or UHCI companion
@@ -66,7 +66,7 @@ config USB_EHCI_ROOT_HUB_TT
 
 config USB_EHCI_TT_NEWSCHED
         bool "Improved Transaction Translator scheduling"
-        depends on USB_EHCI_HCD || USB_CHIPIDEA_HOST
+        depends on USB_EHCI_HCD
         default y
         ---help---
           This changes the periodic scheduling code to fill more of the low
@@ -203,12 +203,11 @@ config USB_EHCI_SH
           Enables support for the on-chip EHCI controller on the SuperH.
           If you use the PCI EHCI controller, this option is not necessary.
 
-config USB_EHCI_S5P
+config USB_EHCI_EXYNOS
        tristate "EHCI support for Samsung S5P/EXYNOS SoC Series"
        depends on PLAT_S5P || ARCH_EXYNOS
        help
-        Enable support for the Samsung S5Pxxxx and Exynos3/4/5 SOC's
-        on-chip EHCI controller.
+        Enable support for the Samsung Exynos SOC's on-chip EHCI controller.
 
 config USB_EHCI_MV
         bool "EHCI support for Marvell PXA/MMP USB controller"
@@ -224,7 +223,7 @@ config USB_EHCI_MV
           on-chip EHCI USB controller" for those.
 
 config USB_W90X900_EHCI
-        bool "W90X900(W90P910) EHCI support"
+        tristate "W90X900(W90P910) EHCI support"
         depends on ARCH_W90X900
         ---help---
                 Enables support for the W90X900 USB controller
@@ -278,7 +277,6 @@ endif # USB_EHCI_HCD
 
 config USB_OXU210HP_HCD
         tristate "OXU210HP HCD support"
-        depends on GENERIC_HARDIRQS
         ---help---
           The OXU210HP is an USB host/OTG/device controller. Enable this
           option if your board has this chip. If unsure, say N.
@@ -368,14 +366,54 @@ config USB_OHCI_HCD
 if USB_OHCI_HCD
 
 config USB_OHCI_HCD_OMAP1
-        bool "OHCI support for OMAP1/2 chips"
+        tristate "OHCI support for OMAP1/2 chips"
         depends on ARCH_OMAP1
         default y
         ---help---
           Enables support for the OHCI controller on OMAP1/2 chips.
 
+config USB_OHCI_HCD_SPEAR
+        tristate "Support for ST SPEAr on-chip OHCI USB controller"
+        depends on USB_OHCI_HCD && PLAT_SPEAR
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          ST SPEAr chips.
+
+config USB_OHCI_HCD_S3C2410
+        tristate "OHCI support for Samsung S3C24xx/S3C64xx SoC series"
+        depends on USB_OHCI_HCD && (ARCH_S3C24XX || ARCH_S3C64XX)
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          S3C24xx/S3C64xx chips.
+
+config USB_OHCI_HCD_LPC32XX
+        tristate "Support for LPC on-chip OHCI USB controller"
+        depends on USB_OHCI_HCD && ARCH_LPC32XX
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          NXP chips.
+
+config USB_OHCI_HCD_PXA27X
+        tristate "Support for PXA27X/PXA3XX on-chip OHCI USB controller"
+        depends on USB_OHCI_HCD && (PXA27x || PXA3xx)
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          PXA27x/PXA3xx chips.
+
+config USB_OHCI_HCD_AT91
+        tristate "Support for Atmel on-chip OHCI USB controller"
+        depends on USB_OHCI_HCD && ARCH_AT91
+        default y
+        ---help---
+          Enables support for the on-chip OHCI controller on
+          Atmel chips.
+
 config USB_OHCI_HCD_OMAP3
-        bool "OHCI support for OMAP3 and later chips"
+        tristate "OHCI support for OMAP3 and later chips"
         depends on (ARCH_OMAP3 || ARCH_OMAP4)
         default y
         ---help---
@@ -455,8 +493,8 @@ config USB_OHCI_SH
           If you use the PCI OHCI controller, this option is not necessary.
 
 config USB_OHCI_EXYNOS
-        boolean "OHCI support for Samsung EXYNOS SoC Series"
-        depends on ARCH_EXYNOS
+        tristate "OHCI support for Samsung S5P/EXYNOS SoC Series"
+        depends on PLAT_S5P || ARCH_EXYNOS
         help
          Enable support for the Samsung Exynos SOC's on-chip OHCI controller.
 
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 50b0041c09a9..01e879ef3654 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -34,10 +34,11 @@ obj-$(CONFIG_USB_EHCI_MXC)	+= ehci-mxc.o
 obj-$(CONFIG_USB_EHCI_HCD_OMAP) += ehci-omap.o
 obj-$(CONFIG_USB_EHCI_HCD_ORION)        += ehci-orion.o
 obj-$(CONFIG_USB_EHCI_HCD_SPEAR)        += ehci-spear.o
-obj-$(CONFIG_USB_EHCI_S5P)      += ehci-s5p.o
+obj-$(CONFIG_USB_EHCI_EXYNOS)   += ehci-exynos.o
 obj-$(CONFIG_USB_EHCI_HCD_AT91) += ehci-atmel.o
 obj-$(CONFIG_USB_EHCI_MSM)      += ehci-msm.o
 obj-$(CONFIG_USB_EHCI_TEGRA)    += ehci-tegra.o
+obj-$(CONFIG_USB_W90X900_EHCI)  += ehci-w90x900.o
 
 obj-$(CONFIG_USB_OXU210HP_HCD)  += oxu210hp-hcd.o
 obj-$(CONFIG_USB_ISP116X_HCD)   += isp116x-hcd.o
@@ -46,6 +47,14 @@ obj-$(CONFIG_USB_ISP1362_HCD)	+= isp1362-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD_PCI)  += ohci-pci.o
 obj-$(CONFIG_USB_OHCI_HCD_PLATFORM)     += ohci-platform.o
+obj-$(CONFIG_USB_OHCI_EXYNOS)   += ohci-exynos.o
+obj-$(CONFIG_USB_OHCI_HCD_OMAP1)        += ohci-omap.o
+obj-$(CONFIG_USB_OHCI_HCD_OMAP3)        += ohci-omap3.o
+obj-$(CONFIG_USB_OHCI_HCD_SPEAR)        += ohci-spear.o
+obj-$(CONFIG_USB_OHCI_HCD_AT91) += ohci-at91.o
+obj-$(CONFIG_USB_OHCI_HCD_S3C2410)      += ohci-s3c2410.o
+obj-$(CONFIG_USB_OHCI_HCD_LPC32XX)      += ohci-nxp.o
+obj-$(CONFIG_USB_OHCI_HCD_PXA27X)       += ohci-pxa27x.o
 
 obj-$(CONFIG_USB_UHCI_HCD)      += uhci-hcd.o
 obj-$(CONFIG_USB_FHCI_HCD)      += fhci.o
diff --git a/drivers/usb/host/bcma-hcd.c b/drivers/usb/host/bcma-hcd.c
index df13d425e9c5..205f4a336583 100644
--- a/drivers/usb/host/bcma-hcd.c
+++ b/drivers/usb/host/bcma-hcd.c
@@ -227,8 +227,7 @@ static int bcma_hcd_probe(struct bcma_device *dev)
 
         /* TODO: Probably need checks here; is the core connected? */
 
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+        if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))
                 return -EOPNOTSUPP;
 
         usb_dev = kzalloc(sizeof(struct bcma_hcd_device), GFP_KERNEL);
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 3b645ff46f7b..284f8417eae5 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -30,13 +30,17 @@ static const char hcd_name[] = "ehci-atmel";
 static struct hc_driver __read_mostly ehci_atmel_hc_driver;
 
 /* interface and function clocks */
-static struct clk *iclk, *fclk;
+static struct clk *iclk, *fclk, *uclk;
 static int clocked;
 
 /*-------------------------------------------------------------------------*/
 
 static void atmel_start_clock(void)
 {
+        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
+                clk_set_rate(uclk, 48000000);
+                clk_prepare_enable(uclk);
+        }
         clk_prepare_enable(iclk);
         clk_prepare_enable(fclk);
         clocked = 1;
@@ -46,6 +50,8 @@ static void atmel_stop_clock(void)
 {
         clk_disable_unprepare(fclk);
         clk_disable_unprepare(iclk);
+        if (IS_ENABLED(CONFIG_COMMON_CLK))
+                clk_disable_unprepare(uclk);
         clocked = 0;
 }
 
@@ -90,10 +96,9 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail_create_hcd;
 
         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
@@ -130,6 +135,14 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
                 retval = -ENOENT;
                 goto fail_request_resource;
         }
+        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
+                uclk = devm_clk_get(&pdev->dev, "usb_clk");
+                if (IS_ERR(uclk)) {
+                        dev_err(&pdev->dev, "failed to get uclk\n");
+                        retval = PTR_ERR(uclk);
+                        goto fail_request_resource;
+                }
+        }
 
         ehci = hcd_to_ehci(hcd);
         /* registers start at offset 0x0 */
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index aa5b603f3933..4a9c2edbcb2b 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -334,6 +334,7 @@ static inline void remove_debug_files (struct ehci_hcd *bus) { }
 /* troubleshooting help: expose state in debugfs */
 
 static int debug_async_open(struct inode *, struct file *);
+static int debug_bandwidth_open(struct inode *, struct file *);
 static int debug_periodic_open(struct inode *, struct file *);
 static int debug_registers_open(struct inode *, struct file *);
 
@@ -347,6 +348,13 @@ static const struct file_operations debug_async_fops = {
         .release        = debug_close,
         .llseek         = default_llseek,
 };
+static const struct file_operations debug_bandwidth_fops = {
+        .owner          = THIS_MODULE,
+        .open           = debug_bandwidth_open,
+        .read           = debug_output,
+        .release        = debug_close,
+        .llseek         = default_llseek,
+};
 static const struct file_operations debug_periodic_fops = {
         .owner          = THIS_MODULE,
         .open           = debug_periodic_open,
@@ -379,7 +387,7 @@ struct debug_buffer {
                 case QH_LOW_SPEED:  tmp = 'l'; break; \
                 case QH_HIGH_SPEED: tmp = 'h'; break; \
                 default: tmp = '?'; break; \
-                }; tmp; })
+                } tmp; })
 
 static inline char token_mark(struct ehci_hcd *ehci, __hc32 token)
 {
@@ -525,6 +533,89 @@ static ssize_t fill_async_buffer(struct debug_buffer *buf)
         return strlen(buf->output_buf);
 }
 
+static ssize_t fill_bandwidth_buffer(struct debug_buffer *buf)
+{
+        struct ehci_hcd         *ehci;
+        struct ehci_tt          *tt;
+        struct ehci_per_sched   *ps;
+        unsigned                temp, size;
+        char                    *next;
+        unsigned                i;
+        u8                      *bw;
+        u16                     *bf;
+        u8                      budget[EHCI_BANDWIDTH_SIZE];
+
+        ehci = hcd_to_ehci(bus_to_hcd(buf->bus));
+        next = buf->output_buf;
+        size = buf->alloc_size;
+
+        *next = 0;
+
+        spin_lock_irq(&ehci->lock);
+
+        /* Dump the HS bandwidth table */
+        temp = scnprintf(next, size,
+                        "HS bandwidth allocation (us per microframe)\n");
+        size -= temp;
+        next += temp;
+        for (i = 0; i < EHCI_BANDWIDTH_SIZE; i += 8) {
+                bw = &ehci->bandwidth[i];
+                temp = scnprintf(next, size,
+                                "%2u: %4u%4u%4u%4u%4u%4u%4u%4u\n",
+                                i, bw[0], bw[1], bw[2], bw[3],
+                                        bw[4], bw[5], bw[6], bw[7]);
+                size -= temp;
+                next += temp;
+        }
+
+        /* Dump all the FS/LS tables */
+        list_for_each_entry(tt, &ehci->tt_list, tt_list) {
+                temp = scnprintf(next, size,
+                                "\nTT %s port %d  FS/LS bandwidth allocation (us per frame)\n",
+                                dev_name(&tt->usb_tt->hub->dev),
+                                tt->tt_port + !!tt->usb_tt->multi);
+                size -= temp;
+                next += temp;
+
+                bf = tt->bandwidth;
+                temp = scnprintf(next, size,
+                                "  %5u%5u%5u%5u%5u%5u%5u%5u\n",
+                                bf[0], bf[1], bf[2], bf[3],
+                                        bf[4], bf[5], bf[6], bf[7]);
+                size -= temp;
+                next += temp;
+
+                temp = scnprintf(next, size,
+                                "FS/LS budget (us per microframe)\n");
+                size -= temp;
+                next += temp;
+                compute_tt_budget(budget, tt);
+                for (i = 0; i < EHCI_BANDWIDTH_SIZE; i += 8) {
+                        bw = &budget[i];
+                        temp = scnprintf(next, size,
+                                        "%2u: %4u%4u%4u%4u%4u%4u%4u%4u\n",
+                                        i, bw[0], bw[1], bw[2], bw[3],
+                                                bw[4], bw[5], bw[6], bw[7]);
+                        size -= temp;
+                        next += temp;
+                }
+                list_for_each_entry(ps, &tt->ps_list, ps_list) {
+                        temp = scnprintf(next, size,
+                                        "%s ep %02x:  %4u @ %2u.%u+%u mask %04x\n",
+                                        dev_name(&ps->udev->dev),
+                                        ps->ep->desc.bEndpointAddress,
+                                        ps->tt_usecs,
+                                        ps->bw_phase, ps->phase_uf,
+                                        ps->bw_period, ps->cs_mask);
+                        size -= temp;
+                        next += temp;
+                }
+        }
+        spin_unlock_irq(&ehci->lock);
+
+        return next - buf->output_buf;
+}
+
 #define DBG_SCHED_LIMIT 64
 static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
 {
@@ -571,7 +662,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                         case Q_TYPE_QH:
                                 hw = p.qh->hw;
                                 temp = scnprintf (next, size, " qh%d-%04x/%p",
-                                                p.qh->period,
+                                                p.qh->ps.period,
                                                 hc32_to_cpup(ehci,
                                                         &hw->hw_info2)
                                                         /* uframe masks */
@@ -618,7 +709,8 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                                                 speed_char (scratch),
                                                 scratch & 0x007f,
                                                 (scratch >> 8) & 0x000f, type,
-                                                p.qh->usecs, p.qh->c_usecs,
+                                                p.qh->ps.usecs,
+                                                p.qh->ps.c_usecs,
                                                 temp,
                                                 0x7ff & (scratch >> 16));
 
@@ -645,7 +737,7 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                         case Q_TYPE_SITD:
                                 temp = scnprintf (next, size,
                                         " sitd%d-%04x/%p",
-                                        p.sitd->stream->interval,
+                                        p.sitd->stream->ps.period,
                                         hc32_to_cpup(ehci, &p.sitd->hw_uframe)
                                                 & 0x0000ffff,
                                         p.sitd);
@@ -918,6 +1010,7 @@ static int debug_close(struct inode *inode, struct file *file)
 
         return 0;
 }
+
 static int debug_async_open(struct inode *inode, struct file *file)
 {
         file->private_data = alloc_buffer(inode->i_private, fill_async_buffer);
@@ -925,6 +1018,14 @@ static int debug_async_open(struct inode *inode, struct file *file)
         return file->private_data ? 0 : -ENOMEM;
 }
 
+static int debug_bandwidth_open(struct inode *inode, struct file *file)
+{
+        file->private_data = alloc_buffer(inode->i_private,
+                        fill_bandwidth_buffer);
+
+        return file->private_data ? 0 : -ENOMEM;
+}
+
 static int debug_periodic_open(struct inode *inode, struct file *file)
 {
         struct debug_buffer *buf;
@@ -957,6 +1058,10 @@ static inline void create_debug_files (struct ehci_hcd *ehci)
                                                 &debug_async_fops))
                 goto file_error;
 
+        if (!debugfs_create_file("bandwidth", S_IRUGO, ehci->debug_dir, bus,
+                                                &debug_bandwidth_fops))
+                goto file_error;
+
         if (!debugfs_create_file("periodic", S_IRUGO, ehci->debug_dir, bus,
                                                 &debug_periodic_fops))
                 goto file_error;
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-exynos.c
index 7c3de95c7054..e97c198e052f 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -1,5 +1,5 @@
 /*
- * SAMSUNG S5P USB HOST EHCI Controller
+ * SAMSUNG EXYNOS USB HOST EHCI Controller
  *
  * Copyright (C) 2011 Samsung Electronics Co.Ltd
  * Author: Jingoo Han <jg1.han@samsung.com>
@@ -20,7 +20,6 @@
 #include <linux/of.h>
 #include <linux/of_gpio.h>
 #include <linux/platform_device.h>
-#include <linux/platform_data/usb-ehci-s5p.h>
 #include <linux/usb/phy.h>
 #include <linux/usb/samsung_usb_phy.h>
 #include <linux/usb.h>
@@ -29,7 +28,7 @@
 
 #include "ehci.h"
 
-#define DRIVER_DESC "EHCI s5p driver"
+#define DRIVER_DESC "EHCI EXYNOS driver"
 
 #define EHCI_INSNREG00(base)                    (base + 0x90)
 #define EHCI_INSNREG00_ENA_INCR16               (0x1 << 25)
@@ -40,21 +39,18 @@
         (EHCI_INSNREG00_ENA_INCR16 | EHCI_INSNREG00_ENA_INCR8 | \
          EHCI_INSNREG00_ENA_INCR4 | EHCI_INSNREG00_ENA_INCRX_ALIGN)
 
-static const char hcd_name[] = "ehci-s5p";
-static struct hc_driver __read_mostly s5p_ehci_hc_driver;
+static const char hcd_name[] = "ehci-exynos";
+static struct hc_driver __read_mostly exynos_ehci_hc_driver;
 
-struct s5p_ehci_hcd {
+struct exynos_ehci_hcd {
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
-        struct s5p_ehci_platdata *pdata;
 };
 
-static struct s5p_ehci_platdata empty_platdata;
+#define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
 
-#define to_s5p_ehci(hcd)      (struct s5p_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
-
-static void s5p_setup_vbus_gpio(struct platform_device *pdev)
+static void exynos_setup_vbus_gpio(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         int err;
@@ -73,10 +69,9 @@ static void s5p_setup_vbus_gpio(struct platform_device *pdev)
                 dev_err(dev, "can't request ehci vbus gpio %d", gpio);
 }
 
-static int s5p_ehci_probe(struct platform_device *pdev)
+static int exynos_ehci_probe(struct platform_device *pdev)
 {
-        struct s5p_ehci_platdata *pdata = dev_get_platdata(&pdev->dev);
-        struct s5p_ehci_hcd *s5p_ehci;
+        struct exynos_ehci_hcd *exynos_ehci;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
         struct resource *res;
@@ -89,53 +84,45 @@ static int s5p_ehci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
-        s5p_setup_vbus_gpio(pdev);
+        exynos_setup_vbus_gpio(pdev);
 
-        hcd = usb_create_hcd(&s5p_ehci_hc_driver,
+        hcd = usb_create_hcd(&exynos_ehci_hc_driver,
                              &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 dev_err(&pdev->dev, "Unable to create HCD\n");
                 return -ENOMEM;
         }
-        s5p_ehci = to_s5p_ehci(hcd);
+        exynos_ehci = to_exynos_ehci(hcd);
 
         if (of_device_is_compatible(pdev->dev.of_node,
-                                        "samsung,exynos5440-ehci")) {
-                s5p_ehci->pdata = &empty_platdata;
+                                        "samsung,exynos5440-ehci"))
                 goto skip_phy;
-        }
 
         phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
         if (IS_ERR(phy)) {
-                /* Fallback to pdata */
-                if (!pdata) {
-                        usb_put_hcd(hcd);
-                        dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                        return -EPROBE_DEFER;
-                } else {
-                        s5p_ehci->pdata = pdata;
-                }
+                usb_put_hcd(hcd);
+                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
+                return -EPROBE_DEFER;
         } else {
-                s5p_ehci->phy = phy;
-                s5p_ehci->otg = phy->otg;
+                exynos_ehci->phy = phy;
+                exynos_ehci->otg = phy->otg;
         }
 
 skip_phy:
 
-        s5p_ehci->clk = devm_clk_get(&pdev->dev, "usbhost");
+        exynos_ehci->clk = devm_clk_get(&pdev->dev, "usbhost");
 
-        if (IS_ERR(s5p_ehci->clk)) {
+        if (IS_ERR(exynos_ehci->clk)) {
                 dev_err(&pdev->dev, "Failed to get usbhost clock\n");
-                err = PTR_ERR(s5p_ehci->clk);
+                err = PTR_ERR(exynos_ehci->clk);
                 goto fail_clk;
         }
 
-        err = clk_prepare_enable(s5p_ehci->clk);
+        err = clk_prepare_enable(exynos_ehci->clk);
         if (err)
                 goto fail_clk;
 
@@ -162,13 +149,11 @@ skip_phy:
                 goto fail_io;
         }
 
-        if (s5p_ehci->otg)
-                s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);
+        if (exynos_ehci->otg)
+                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (s5p_ehci->phy)
-                usb_phy_init(s5p_ehci->phy);
-        else if (s5p_ehci->pdata->phy_init)
-                s5p_ehci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
+        if (exynos_ehci->phy)
+                usb_phy_init(exynos_ehci->phy);
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
@@ -187,33 +172,29 @@ skip_phy:
         return 0;
 
 fail_add_hcd:
-        if (s5p_ehci->phy)
-                usb_phy_shutdown(s5p_ehci->phy);
-        else if (s5p_ehci->pdata->phy_exit)
-                s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
+        if (exynos_ehci->phy)
+                usb_phy_shutdown(exynos_ehci->phy);
 fail_io:
-        clk_disable_unprepare(s5p_ehci->clk);
+        clk_disable_unprepare(exynos_ehci->clk);
 fail_clk:
         usb_put_hcd(hcd);
         return err;
 }
 
-static int s5p_ehci_remove(struct platform_device *pdev)
+static int exynos_ehci_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
 
         usb_remove_hcd(hcd);
 
-        if (s5p_ehci->otg)
-                s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);
+        if (exynos_ehci->otg)
+                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (s5p_ehci->phy)
-                usb_phy_shutdown(s5p_ehci->phy);
-        else if (s5p_ehci->pdata->phy_exit)
-                s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
+        if (exynos_ehci->phy)
+                usb_phy_shutdown(exynos_ehci->phy);
 
-        clk_disable_unprepare(s5p_ehci->clk);
+        clk_disable_unprepare(exynos_ehci->clk);
 
         usb_put_hcd(hcd);
 
@@ -221,45 +202,39 @@ static int s5p_ehci_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int s5p_ehci_suspend(struct device *dev)
+static int exynos_ehci_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
-        struct s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);
-        struct platform_device *pdev = to_platform_device(dev);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
 
         bool do_wakeup = device_may_wakeup(dev);
         int rc;
 
         rc = ehci_suspend(hcd, do_wakeup);
 
-        if (s5p_ehci->otg)
-                s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);
+        if (exynos_ehci->otg)
+                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (s5p_ehci->phy)
-                usb_phy_shutdown(s5p_ehci->phy);
-        else if (s5p_ehci->pdata->phy_exit)
-                s5p_ehci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
+        if (exynos_ehci->phy)
+                usb_phy_shutdown(exynos_ehci->phy);
 
-        clk_disable_unprepare(s5p_ehci->clk);
+        clk_disable_unprepare(exynos_ehci->clk);
 
         return rc;
 }
 
-static int s5p_ehci_resume(struct device *dev)
+static int exynos_ehci_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
-        struct  s5p_ehci_hcd *s5p_ehci = to_s5p_ehci(hcd);
-        struct platform_device *pdev = to_platform_device(dev);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
 
-        clk_prepare_enable(s5p_ehci->clk);
+        clk_prepare_enable(exynos_ehci->clk);
 
-        if (s5p_ehci->otg)
-                s5p_ehci->otg->set_host(s5p_ehci->otg, &hcd->self);
+        if (exynos_ehci->otg)
+                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (s5p_ehci->phy)
-                usb_phy_init(s5p_ehci->phy);
-        else if (s5p_ehci->pdata->phy_init)
-                s5p_ehci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
+        if (exynos_ehci->phy)
+                usb_phy_init(exynos_ehci->phy);
 
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
@@ -268,13 +243,13 @@ static int s5p_ehci_resume(struct device *dev)
         return 0;
 }
 #else
-#define s5p_ehci_suspend        NULL
-#define s5p_ehci_resume         NULL
+#define exynos_ehci_suspend     NULL
+#define exynos_ehci_resume      NULL
 #endif
 
-static const struct dev_pm_ops s5p_ehci_pm_ops = {
-        .suspend        = s5p_ehci_suspend,
-        .resume         = s5p_ehci_resume,
+static const struct dev_pm_ops exynos_ehci_pm_ops = {
+        .suspend        = exynos_ehci_suspend,
+        .resume         = exynos_ehci_resume,
 };
 
 #ifdef CONFIG_OF
@@ -286,40 +261,40 @@ static const struct of_device_id exynos_ehci_match[] = {
 MODULE_DEVICE_TABLE(of, exynos_ehci_match);
 #endif
 
-static struct platform_driver s5p_ehci_driver = {
-        .probe          = s5p_ehci_probe,
-        .remove         = s5p_ehci_remove,
+static struct platform_driver exynos_ehci_driver = {
+        .probe          = exynos_ehci_probe,
+        .remove         = exynos_ehci_remove,
         .shutdown       = usb_hcd_platform_shutdown,
         .driver = {
-                .name   = "s5p-ehci",
+                .name   = "exynos-ehci",
                 .owner  = THIS_MODULE,
-                .pm     = &s5p_ehci_pm_ops,
+                .pm     = &exynos_ehci_pm_ops,
                 .of_match_table = of_match_ptr(exynos_ehci_match),
         }
 };
-static const struct ehci_driver_overrides s5p_overrides __initdata = {
-        .extra_priv_size = sizeof(struct s5p_ehci_hcd),
+static const struct ehci_driver_overrides exynos_overrides __initdata = {
+        .extra_priv_size = sizeof(struct exynos_ehci_hcd),
 };
 
-static int __init ehci_s5p_init(void)
+static int __init ehci_exynos_init(void)
 {
         if (usb_disabled())
                 return -ENODEV;
 
         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
-        ehci_init_driver(&s5p_ehci_hc_driver, &s5p_overrides);
-        return platform_driver_register(&s5p_ehci_driver);
+        ehci_init_driver(&exynos_ehci_hc_driver, &exynos_overrides);
+        return platform_driver_register(&exynos_ehci_driver);
 }
-module_init(ehci_s5p_init);
+module_init(ehci_exynos_init);
 
-static void __exit ehci_s5p_cleanup(void)
+static void __exit ehci_exynos_cleanup(void)
 {
-        platform_driver_unregister(&s5p_ehci_driver);
+        platform_driver_unregister(&exynos_ehci_driver);
 }
-module_exit(ehci_s5p_cleanup);
+module_exit(ehci_exynos_cleanup);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_ALIAS("platform:s5p-ehci");
+MODULE_ALIAS("platform:exynos-ehci");
 MODULE_AUTHOR("Jingoo Han");
 MODULE_AUTHOR("Joonyoung Shim");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index 947b009009f1..a06d5012201f 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -57,7 +57,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         pr_debug("initializing FSL-SOC USB Controller\n");
 
         /* Need platform data for setup */
-        pdata = (struct fsl_usb2_platform_data *)dev_get_platdata(&pdev->dev);
+        pdata = dev_get_platdata(&pdev->dev);
         if (!pdata) {
                 dev_err(&pdev->dev,
                         "No platform data for %s.\n", dev_name(&pdev->dev));
@@ -130,7 +130,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         }
 
         /* Enable USB controller, 83xx or 8536 */
-        if (pdata->have_sysif_regs)
+        if (pdata->have_sysif_regs && pdata->controller_ver < FSL_USB_VER_1_6)
                 setbits32(hcd->regs + FSL_SOC_USB_CTRL, 0x4);
 
         /* Don't need to set host mode here. It will be done by tdi_reset() */
@@ -232,15 +232,9 @@ static int ehci_fsl_setup_phy(struct usb_hcd *hcd,
         case FSL_USB2_PHY_ULPI:
                 if (pdata->have_sysif_regs && pdata->controller_ver) {
                         /* controller version 1.6 or above */
+                        clrbits32(non_ehci + FSL_SOC_USB_CTRL, UTMI_PHY_EN);
                         setbits32(non_ehci + FSL_SOC_USB_CTRL,
-                                        ULPI_PHY_CLK_SEL);
-                        /*
-                         * Due to controller issue of PHY_CLK_VALID in ULPI
-                         * mode, we set USB_CTRL_USB_EN before checking
-                         * PHY_CLK_VALID, otherwise PHY_CLK_VALID doesn't work.
-                         */
-                        clrsetbits_be32(non_ehci + FSL_SOC_USB_CTRL,
-                                        UTMI_PHY_EN, USB_CTRL_USB_EN);
+                                ULPI_PHY_CLK_SEL | USB_CTRL_USB_EN);
                 }
                 portsc |= PORT_PTS_ULPI;
                 break;
@@ -270,8 +264,9 @@ static int ehci_fsl_setup_phy(struct usb_hcd *hcd,
         if (pdata->have_sysif_regs && pdata->controller_ver &&
             (phy_mode == FSL_USB2_PHY_ULPI)) {
                 /* check PHY_CLK_VALID to get phy clk valid */
-                if (!spin_event_timeout(in_be32(non_ehci + FSL_SOC_USB_CTRL) &
-                                PHY_CLK_VALID, FSL_USB_PHY_CLK_TIMEOUT, 0)) {
+                if (!(spin_event_timeout(in_be32(non_ehci + FSL_SOC_USB_CTRL) &
+                                PHY_CLK_VALID, FSL_USB_PHY_CLK_TIMEOUT, 0) ||
+                                in_be32(non_ehci + FSL_SOC_USB_PRICTRL))) {
                         printk(KERN_WARNING "fsl-ehci: USB PHY clock invalid\n");
                         return -EINVAL;
                 }
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 5d6022f30ebe..e8ba4c44223a 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -110,6 +110,9 @@ MODULE_PARM_DESC (ignore_oc, "ignore bogus hardware overcurrent indications");
 #include "ehci.h"
 #include "pci-quirks.h"
 
+static void compute_tt_budget(u8 budget_table[EHCI_BANDWIDTH_SIZE],
+                struct ehci_tt *tt);
+
 /*
  * The MosChip MCS9990 controller updates its microframe counter
  * a little before the frame counter, and occasionally we will read
@@ -484,6 +487,7 @@ static int ehci_init(struct usb_hcd *hcd)
         INIT_LIST_HEAD(&ehci->intr_qh_list);
         INIT_LIST_HEAD(&ehci->cached_itd_list);
         INIT_LIST_HEAD(&ehci->cached_sitd_list);
+        INIT_LIST_HEAD(&ehci->tt_list);
 
         if (HCC_PGM_FRAMELISTLEN(hcc_params)) {
                 /* periodic schedule size can be smaller than default */
@@ -956,6 +960,7 @@ rescan:
                         goto idle_timeout;
 
                 /* BUG_ON(!list_empty(&stream->free_list)); */
+                reserve_release_iso_bandwidth(ehci, stream, -1);
                 kfree(stream);
                 goto done;
         }
@@ -982,6 +987,8 @@ idle_timeout:
                 if (qh->clearing_tt)
                         goto idle_timeout;
                 if (list_empty (&qh->qtd_list)) {
+                        if (qh->ps.bw_uperiod)
+                                reserve_release_intr_bandwidth(ehci, qh, -1);
                         qh_destroy(ehci, qh);
                         break;
                 }
@@ -1022,7 +1029,6 @@ ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
          * the toggle bit in the QH.
          */
         if (qh) {
-                usb_settoggle(qh->dev, epnum, is_out, 0);
                 if (!list_empty(&qh->qtd_list)) {
                         WARN_ONCE(1, "clear_halt for a busy endpoint\n");
                 } else {
@@ -1030,6 +1036,7 @@ ehci_endpoint_reset(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
                          * while the QH is active.  Unlink it now;
                          * re-linking will call qh_refresh().
                          */
+                        usb_settoggle(qh->ps.udev, epnum, is_out, 0);
                         qh->exception = 1;
                         if (eptype == USB_ENDPOINT_XFER_BULK)
                                 start_unlink_async(ehci, qh);
@@ -1048,6 +1055,19 @@ static int ehci_get_frame (struct usb_hcd *hcd)
 
 /*-------------------------------------------------------------------------*/
 
+/* Device addition and removal */
+
+static void ehci_remove_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
+
+        spin_lock_irq(&ehci->lock);
+        drop_tt(udev);
+        spin_unlock_irq(&ehci->lock);
+}
+
+/*-------------------------------------------------------------------------*/
+
 #ifdef  CONFIG_PM
 
 /* suspend/resume, section 4.3 */
@@ -1075,6 +1095,14 @@ int ehci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
         spin_unlock_irq(&ehci->lock);
 
+        synchronize_irq(hcd->irq);
+
+        /* Check for race with a wakeup request */
+        if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
+                ehci_resume(hcd, false);
+                return -EBUSY;
+        }
+
         return 0;
 }
 EXPORT_SYMBOL_GPL(ehci_suspend);
@@ -1191,6 +1219,11 @@ static const struct hc_driver ehci_hc_driver = {
         .bus_resume =           ehci_bus_resume,
         .relinquish_port =      ehci_relinquish_port,
         .port_handed_over =     ehci_port_handed_over,
+
+        /*
+         * device support
+         */
+        .free_dev =             ehci_remove_device,
 };
 
 void ehci_init_driver(struct hc_driver *drv,
@@ -1238,11 +1271,6 @@ MODULE_LICENSE ("GPL");
 #define XILINX_OF_PLATFORM_DRIVER       ehci_hcd_xilinx_of_driver
 #endif
 
-#ifdef CONFIG_USB_W90X900_EHCI
-#include "ehci-w90x900.c"
-#define PLATFORM_DRIVER         ehci_hcd_w90x900_driver
-#endif
-
 #ifdef CONFIG_USB_OCTEON_EHCI
 #include "ehci-octeon.c"
 #define PLATFORM_DRIVER         ehci_octeon_driver
diff --git a/drivers/usb/host/ehci-mem.c b/drivers/usb/host/ehci-mem.c
index 52a77734a225..c0fb6a8ae6a3 100644
--- a/drivers/usb/host/ehci-mem.c
+++ b/drivers/usb/host/ehci-mem.c
@@ -224,11 +224,11 @@ static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags)
                 hw->hw_next = EHCI_LIST_END(ehci);
                 hw->hw_qtd_next = EHCI_LIST_END(ehci);
                 hw->hw_alt_next = EHCI_LIST_END(ehci);
-                hw->hw_token &= ~QTD_STS_ACTIVE;
                 ehci->dummy->hw = hw;
 
                 for (i = 0; i < ehci->periodic_size; i++)
-                        ehci->periodic[i] = ehci->dummy->qh_dma;
+                        ehci->periodic[i] = cpu_to_hc32(ehci,
+                                        ehci->dummy->qh_dma);
         } else {
                 for (i = 0; i < ehci->periodic_size; i++)
                         ehci->periodic[i] = EHCI_LIST_END(ehci);
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index 0f717dc688b7..f341651d6f6c 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -42,7 +42,6 @@
 
 static const char hcd_name[] = "ehci-msm";
 static struct hc_driver __read_mostly msm_hc_driver;
-static struct usb_phy *phy;
 
 static int ehci_msm_reset(struct usb_hcd *hcd)
 {
@@ -70,6 +69,7 @@ static int ehci_msm_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct resource *res;
+        struct usb_phy *phy;
         int ret;
 
         dev_dbg(&pdev->dev, "ehci_msm proble\n");
@@ -108,10 +108,14 @@ static int ehci_msm_probe(struct platform_device *pdev)
          * powering up VBUS, mapping of registers address space and power
          * management.
          */
-        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
+        if (pdev->dev.of_node)
+                phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
+        else
+                phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
+
         if (IS_ERR(phy)) {
                 dev_err(&pdev->dev, "unable to find transceiver\n");
-                ret = -ENODEV;
+                ret = -EPROBE_DEFER;
                 goto put_hcd;
         }
 
@@ -121,6 +125,7 @@ static int ehci_msm_probe(struct platform_device *pdev)
                 goto put_hcd;
         }
 
+        hcd->phy = phy;
         device_init_wakeup(&pdev->dev, 1);
         /*
          * OTG device parent of HCD takes care of putting
@@ -147,7 +152,7 @@ static int ehci_msm_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
         pm_runtime_set_suspended(&pdev->dev);
 
-        otg_set_host(phy->otg, NULL);
+        otg_set_host(hcd->phy->otg, NULL);
 
         /* FIXME: need to call usb_remove_hcd() here? */
 
@@ -186,12 +191,19 @@ static const struct dev_pm_ops ehci_msm_dev_pm_ops = {
         .resume          = ehci_msm_pm_resume,
 };
 
+static struct of_device_id msm_ehci_dt_match[] = {
+        { .compatible = "qcom,ehci-host", },
+        {}
+};
+MODULE_DEVICE_TABLE(of, msm_ehci_dt_match);
+
 static struct platform_driver ehci_msm_driver = {
         .probe  = ehci_msm_probe,
         .remove = ehci_msm_remove,
         .driver = {
                    .name = "msm_hsusb_host",
                    .pm = &ehci_msm_dev_pm_ops,
+                   .of_match_table = msm_ehci_dt_match,
         },
 };
 
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index ab0397e4d8f3..4c528b2c033a 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -116,8 +116,10 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
          * We can DMA from anywhere. But the descriptors must be in
          * the lower 4GB.
          */
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
         pdev->dev.dma_mask = &ehci_octeon_dma_mask;
+        ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&ehci_octeon_hc_driver, &pdev->dev, "octeon");
         if (!hcd)
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 78b01fa475bb..6fa82d6b7661 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -104,7 +104,7 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         struct resource *res;
         struct usb_hcd  *hcd;
         void __iomem *regs;
-        int ret = -ENODEV;
+        int ret;
         int irq;
         int i;
         struct omap_hcd *omap;
@@ -144,11 +144,11 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
+        ret = -ENODEV;
         hcd = usb_create_hcd(&ehci_omap_hc_driver, dev,
                         dev_name(dev));
         if (!hcd) {
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index d1dfb9db5b42..2ba76730e650 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -180,10 +180,9 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
          * set. Since shared usb code relies on it, set it here for
          * now. Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                goto err1;
 
         if (!request_mem_region(res->start, resource_size(res),
                                 ehci_orion_hc_driver.description)) {
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 6bd299e61f58..3e86bf4371b3 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -58,8 +58,6 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
-        struct pci_dev          *p_smbus;
-        u8                      rev;
         u32                     temp;
         int                     retval;
 
@@ -175,22 +173,12 @@ static int ehci_pci_setup(struct usb_hcd *hcd)
                 /* SB600 and old version of SB700 have a bug in EHCI controller,
                  * which causes usb devices lose response in some cases.
                  */
-                if ((pdev->device == 0x4386) || (pdev->device == 0x4396)) {
-                        p_smbus = pci_get_device(PCI_VENDOR_ID_ATI,
-                                                 PCI_DEVICE_ID_ATI_SBX00_SMBUS,
-                                                 NULL);
-                        if (!p_smbus)
-                                break;
-                        rev = p_smbus->revision;
-                        if ((pdev->device == 0x4386) || (rev == 0x3a)
-                            || (rev == 0x3b)) {
-                                u8 tmp;
-                                ehci_info(ehci, "applying AMD SB600/SB700 USB "
-                                        "freeze workaround\n");
-                                pci_read_config_byte(pdev, 0x53, &tmp);
-                                pci_write_config_byte(pdev, 0x53, tmp | (1<<3));
-                        }
-                        pci_dev_put(p_smbus);
+                if ((pdev->device == 0x4386 || pdev->device == 0x4396) &&
+                                usb_amd_hang_symptom_quirk()) {
+                        u8 tmp;
+                        ehci_info(ehci, "applying AMD SB600/SB700 USB freeze workaround\n");
+                        pci_read_config_byte(pdev, 0x53, &tmp);
+                        pci_write_config_byte(pdev, 0x53, tmp | (1<<3));
                 }
                 break;
         case PCI_VENDOR_ID_NETMOS:
@@ -361,7 +349,7 @@ static struct pci_driver ehci_pci_driver = {
         .remove =       usb_hcd_pci_remove,
         .shutdown =     usb_hcd_pci_shutdown,
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
         .driver =       {
                 .pm =   &usb_hcd_pci_pm_ops
         },
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index f6b790ca8cf2..7f30b7168d5a 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -78,7 +78,7 @@ static int ehci_platform_probe(struct platform_device *dev)
         struct resource *res_mem;
         struct usb_ehci_pdata *pdata;
         int irq;
-        int err = -ENOMEM;
+        int err;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -89,10 +89,10 @@ static int ehci_platform_probe(struct platform_device *dev)
          */
         if (!dev_get_platdata(&dev->dev))
                 dev->dev.platform_data = &ehci_platform_defaults;
-        if (!dev->dev.dma_mask)
-                dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
-        if (!dev->dev.coherent_dma_mask)
-                dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+
+        err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         pdata = dev_get_platdata(&dev->dev);
 
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 6cc5567bf9c8..875d2fcc9e0e 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -16,6 +16,8 @@
 #include <linux/signal.h>
 
 #include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
 
 
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index e321804c3475..db05bd8ee9d5 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -105,9 +105,9 @@ qh_update (struct ehci_hcd *ehci, struct ehci_qh *qh, struct ehci_qtd *qtd)
 
                 is_out = qh->is_out;
                 epnum = (hc32_to_cpup(ehci, &hw->hw_info1) >> 8) & 0x0f;
-                if (unlikely (!usb_gettoggle (qh->dev, epnum, is_out))) {
+                if (unlikely(!usb_gettoggle(qh->ps.udev, epnum, is_out))) {
                         hw->hw_token &= ~cpu_to_hc32(ehci, QTD_TOGGLE);
-                        usb_settoggle (qh->dev, epnum, is_out, 1);
+                        usb_settoggle(qh->ps.udev, epnum, is_out, 1);
                 }
         }
 
@@ -797,26 +797,35 @@ qh_make (
          * 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,
+                unsigned        tmp;
+
+                qh->ps.usecs = NS_TO_US(usb_calc_bus_time(USB_SPEED_HIGH,
                                 is_input, 0,
                                 hb_mult(maxp) * max_packet(maxp)));
-                qh->start = NO_FRAME;
+                qh->ps.phase = NO_FRAME;
 
                 if (urb->dev->speed == USB_SPEED_HIGH) {
-                        qh->c_usecs = 0;
+                        qh->ps.c_usecs = 0;
                         qh->gap_uf = 0;
 
-                        qh->period = urb->interval >> 3;
-                        if (qh->period == 0 && urb->interval != 1) {
+                        if (urb->interval > 1 && urb->interval < 8) {
                                 /* NOTE interval 2 or 4 uframes could work.
                                  * But interval 1 scheduling is simpler, and
                                  * includes high bandwidth.
                                  */
                                 urb->interval = 1;
-                        } else if (qh->period > ehci->periodic_size) {
-                                qh->period = ehci->periodic_size;
-                                urb->interval = qh->period << 3;
+                        } else if (urb->interval > ehci->periodic_size << 3) {
+                                urb->interval = ehci->periodic_size << 3;
                         }
+                        qh->ps.period = urb->interval >> 3;
+
+                        /* period for bandwidth allocation */
+                        tmp = min_t(unsigned, EHCI_BANDWIDTH_SIZE,
+                                        1 << (urb->ep->desc.bInterval - 1));
+
+                        /* Allow urb->interval to override */
+                        qh->ps.bw_uperiod = min_t(unsigned, tmp, urb->interval);
+                        qh->ps.bw_period = qh->ps.bw_uperiod >> 3;
                 } else {
                         int             think_time;
 
@@ -826,27 +835,35 @@ qh_make (
 
                         /* 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);
+                                qh->ps.c_usecs = qh->ps.usecs + HS_USECS(0);
+                                qh->ps.usecs = HS_USECS(1);
                         } else {                // SPLIT+DATA, gap, CSPLIT
-                                qh->usecs += HS_USECS (1);
-                                qh->c_usecs = HS_USECS (0);
+                                qh->ps.usecs += HS_USECS(1);
+                                qh->ps.c_usecs = HS_USECS(0);
                         }
 
                         think_time = tt ? tt->think_time : 0;
-                        qh->tt_usecs = NS_TO_US (think_time +
+                        qh->ps.tt_usecs = NS_TO_US(think_time +
                                         usb_calc_bus_time (urb->dev->speed,
                                         is_input, 0, max_packet (maxp)));
-                        qh->period = urb->interval;
-                        if (qh->period > ehci->periodic_size) {
-                                qh->period = ehci->periodic_size;
-                                urb->interval = qh->period;
-                        }
+                        if (urb->interval > ehci->periodic_size)
+                                urb->interval = ehci->periodic_size;
+                        qh->ps.period = urb->interval;
+
+                        /* period for bandwidth allocation */
+                        tmp = min_t(unsigned, EHCI_BANDWIDTH_FRAMES,
+                                        urb->ep->desc.bInterval);
+                        tmp = rounddown_pow_of_two(tmp);
+
+                        /* Allow urb->interval to override */
+                        qh->ps.bw_period = min_t(unsigned, tmp, urb->interval);
+                        qh->ps.bw_uperiod = qh->ps.bw_period << 3;
                 }
         }
 
         /* support for tt scheduling, and access to toggles */
-        qh->dev = urb->dev;
+        qh->ps.udev = urb->dev;
+        qh->ps.ep = urb->ep;
 
         /* using TT? */
         switch (urb->dev->speed) {
diff --git a/drivers/usb/host/ehci-sched.c b/drivers/usb/host/ehci-sched.c
index 85dd24ed97a6..e113fd73aeae 100644
--- a/drivers/usb/host/ehci-sched.c
+++ b/drivers/usb/host/ehci-sched.c
@@ -103,83 +103,210 @@ static void periodic_unlink (struct ehci_hcd *ehci, unsigned frame, void *ptr)
                 *hw_p = *shadow_next_periodic(ehci, &here,
                                 Q_NEXT_TYPE(ehci, *hw_p));
         else
-                *hw_p = ehci->dummy->qh_dma;
+                *hw_p = cpu_to_hc32(ehci, ehci->dummy->qh_dma);
 }
 
-/* how many of the uframe's 125 usecs are allocated? */
-static unsigned short
-periodic_usecs (struct ehci_hcd *ehci, unsigned frame, unsigned uframe)
+/*-------------------------------------------------------------------------*/
+
+/* Bandwidth and TT management */
+
+/* Find the TT data structure for this device; create it if necessary */
+static struct ehci_tt *find_tt(struct usb_device *udev)
 {
-        __hc32                  *hw_p = &ehci->periodic [frame];
-        union ehci_shadow       *q = &ehci->pshadow [frame];
-        unsigned                usecs = 0;
-        struct ehci_qh_hw       *hw;
-
-        while (q->ptr) {
-                switch (hc32_to_cpu(ehci, Q_NEXT_TYPE(ehci, *hw_p))) {
-                case Q_TYPE_QH:
-                        hw = q->qh->hw;
-                        /* is it in the S-mask? */
-                        if (hw->hw_info2 & cpu_to_hc32(ehci, 1 << uframe))
-                                usecs += q->qh->usecs;
-                        /* ... or C-mask? */
-                        if (hw->hw_info2 & cpu_to_hc32(ehci,
-                                        1 << (8 + uframe)))
-                                usecs += q->qh->c_usecs;
-                        hw_p = &hw->hw_next;
-                        q = &q->qh->qh_next;
-                        break;
-                // case Q_TYPE_FSTN:
-                default:
-                        /* for "save place" FSTNs, count the relevant INTR
-                         * bandwidth from the previous frame
-                         */
-                        if (q->fstn->hw_prev != EHCI_LIST_END(ehci)) {
-                                ehci_dbg (ehci, "ignoring FSTN cost ...\n");
-                        }
-                        hw_p = &q->fstn->hw_next;
-                        q = &q->fstn->fstn_next;
-                        break;
-                case Q_TYPE_ITD:
-                        if (q->itd->hw_transaction[uframe])
-                                usecs += q->itd->stream->usecs;
-                        hw_p = &q->itd->hw_next;
-                        q = &q->itd->itd_next;
-                        break;
-                case Q_TYPE_SITD:
-                        /* is it in the S-mask?  (count SPLIT, DATA) */
-                        if (q->sitd->hw_uframe & cpu_to_hc32(ehci,
-                                        1 << uframe)) {
-                                if (q->sitd->hw_fullspeed_ep &
-                                                cpu_to_hc32(ehci, 1<<31))
-                                        usecs += q->sitd->stream->usecs;
-                                else    /* worst case for OUT start-split */
-                                        usecs += HS_USECS_ISO (188);
-                        }
+        struct usb_tt           *utt = udev->tt;
+        struct ehci_tt          *tt, **tt_index, **ptt;
+        unsigned                port;
+        bool                    allocated_index = false;
+
+        if (!utt)
+                return NULL;            /* Not below a TT */
+
+        /*
+         * Find/create our data structure.
+         * For hubs with a single TT, we get it directly.
+         * For hubs with multiple TTs, there's an extra level of pointers.
+         */
+        tt_index = NULL;
+        if (utt->multi) {
+                tt_index = utt->hcpriv;
+                if (!tt_index) {                /* Create the index array */
+                        tt_index = kzalloc(utt->hub->maxchild *
+                                        sizeof(*tt_index), GFP_ATOMIC);
+                        if (!tt_index)
+                                return ERR_PTR(-ENOMEM);
+                        utt->hcpriv = tt_index;
+                        allocated_index = true;
+                }
+                port = udev->ttport - 1;
+                ptt = &tt_index[port];
+        } else {
+                port = 0;
+                ptt = (struct ehci_tt **) &utt->hcpriv;
+        }
+
+        tt = *ptt;
+        if (!tt) {                              /* Create the ehci_tt */
+                struct ehci_hcd         *ehci =
+                                hcd_to_ehci(bus_to_hcd(udev->bus));
 
-                        /* ... C-mask?  (count CSPLIT, DATA) */
-                        if (q->sitd->hw_uframe &
-                                        cpu_to_hc32(ehci, 1 << (8 + uframe))) {
-                                /* worst case for IN complete-split */
-                                usecs += q->sitd->stream->c_usecs;
+                tt = kzalloc(sizeof(*tt), GFP_ATOMIC);
+                if (!tt) {
+                        if (allocated_index) {
+                                utt->hcpriv = NULL;
+                                kfree(tt_index);
                         }
+                        return ERR_PTR(-ENOMEM);
+                }
+                list_add_tail(&tt->tt_list, &ehci->tt_list);
+                INIT_LIST_HEAD(&tt->ps_list);
+                tt->usb_tt = utt;
+                tt->tt_port = port;
+                *ptt = tt;
+        }
 
-                        hw_p = &q->sitd->hw_next;
-                        q = &q->sitd->sitd_next;
-                        break;
+        return tt;
+}
+
+/* Release the TT above udev, if it's not in use */
+static void drop_tt(struct usb_device *udev)
+{
+        struct usb_tt           *utt = udev->tt;
+        struct ehci_tt          *tt, **tt_index, **ptt;
+        int                     cnt, i;
+
+        if (!utt || !utt->hcpriv)
+                return;         /* Not below a TT, or never allocated */
+
+        cnt = 0;
+        if (utt->multi) {
+                tt_index = utt->hcpriv;
+                ptt = &tt_index[udev->ttport - 1];
+
+                /* How many entries are left in tt_index? */
+                for (i = 0; i < utt->hub->maxchild; ++i)
+                        cnt += !!tt_index[i];
+        } else {
+                tt_index = NULL;
+                ptt = (struct ehci_tt **) &utt->hcpriv;
+        }
+
+        tt = *ptt;
+        if (!tt || !list_empty(&tt->ps_list))
+                return;         /* never allocated, or still in use */
+
+        list_del(&tt->tt_list);
+        *ptt = NULL;
+        kfree(tt);
+        if (cnt == 1) {
+                utt->hcpriv = NULL;
+                kfree(tt_index);
+        }
+}
+
+static void bandwidth_dbg(struct ehci_hcd *ehci, int sign, char *type,
+                struct ehci_per_sched *ps)
+{
+        dev_dbg(&ps->udev->dev,
+                        "ep %02x: %s %s @ %u+%u (%u.%u+%u) [%u/%u us] mask %04x\n",
+                        ps->ep->desc.bEndpointAddress,
+                        (sign >= 0 ? "reserve" : "release"), type,
+                        (ps->bw_phase << 3) + ps->phase_uf, ps->bw_uperiod,
+                        ps->phase, ps->phase_uf, ps->period,
+                        ps->usecs, ps->c_usecs, ps->cs_mask);
+}
+
+static void reserve_release_intr_bandwidth(struct ehci_hcd *ehci,
+                struct ehci_qh *qh, int sign)
+{
+        unsigned                start_uf;
+        unsigned                i, j, m;
+        int                     usecs = qh->ps.usecs;
+        int                     c_usecs = qh->ps.c_usecs;
+        int                     tt_usecs = qh->ps.tt_usecs;
+        struct ehci_tt          *tt;
+
+        if (qh->ps.phase == NO_FRAME)   /* Bandwidth wasn't reserved */
+                return;
+        start_uf = qh->ps.bw_phase << 3;
+
+        bandwidth_dbg(ehci, sign, "intr", &qh->ps);
+
+        if (sign < 0) {         /* Release bandwidth */
+                usecs = -usecs;
+                c_usecs = -c_usecs;
+                tt_usecs = -tt_usecs;
+        }
+
+        /* Entire transaction (high speed) or start-split (full/low speed) */
+        for (i = start_uf + qh->ps.phase_uf; i < EHCI_BANDWIDTH_SIZE;
+                        i += qh->ps.bw_uperiod)
+                ehci->bandwidth[i] += usecs;
+
+        /* Complete-split (full/low speed) */
+        if (qh->ps.c_usecs) {
+                /* NOTE: adjustments needed for FSTN */
+                for (i = start_uf; i < EHCI_BANDWIDTH_SIZE;
+                                i += qh->ps.bw_uperiod) {
+                        for ((j = 2, m = 1 << (j+8)); j < 8; (++j, m <<= 1)) {
+                                if (qh->ps.cs_mask & m)
+                                        ehci->bandwidth[i+j] += c_usecs;
+                        }
                 }
         }
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
-        if (usecs > ehci->uframe_periodic_max)
-                ehci_err (ehci, "uframe %d sched overrun: %d usecs\n",
-                        frame * 8 + uframe, usecs);
-#endif
-        return usecs;
+
+        /* FS/LS bus bandwidth */
+        if (tt_usecs) {
+                tt = find_tt(qh->ps.udev);
+                if (sign > 0)
+                        list_add_tail(&qh->ps.ps_list, &tt->ps_list);
+                else
+                        list_del(&qh->ps.ps_list);
+
+                for (i = start_uf >> 3; i < EHCI_BANDWIDTH_FRAMES;
+                                i += qh->ps.bw_period)
+                        tt->bandwidth[i] += tt_usecs;
+        }
 }
 
 /*-------------------------------------------------------------------------*/
 
-static int same_tt (struct usb_device *dev1, struct usb_device *dev2)
+static void compute_tt_budget(u8 budget_table[EHCI_BANDWIDTH_SIZE],
+                struct ehci_tt *tt)
+{
+        struct ehci_per_sched   *ps;
+        unsigned                uframe, uf, x;
+        u8                      *budget_line;
+
+        if (!tt)
+                return;
+        memset(budget_table, 0, EHCI_BANDWIDTH_SIZE);
+
+        /* Add up the contributions from all the endpoints using this TT */
+        list_for_each_entry(ps, &tt->ps_list, ps_list) {
+                for (uframe = ps->bw_phase << 3; uframe < EHCI_BANDWIDTH_SIZE;
+                                uframe += ps->bw_uperiod) {
+                        budget_line = &budget_table[uframe];
+                        x = ps->tt_usecs;
+
+                        /* propagate the time forward */
+                        for (uf = ps->phase_uf; uf < 8; ++uf) {
+                                x += budget_line[uf];
+
+                                /* Each microframe lasts 125 us */
+                                if (x <= 125) {
+                                        budget_line[uf] = x;
+                                        break;
+                                } else {
+                                        budget_line[uf] = 125;
+                                        x -= 125;
+                                }
+                        }
+                }
+        }
+}
+
+static int __maybe_unused same_tt(struct usb_device *dev1,
+                struct usb_device *dev2)
 {
         if (!dev1->tt || !dev2->tt)
                 return 0;
@@ -227,68 +354,6 @@ static inline void carryover_tt_bandwidth(unsigned short tt_usecs[8])
         }
 }
 
-/* How many of the tt's periodic downstream 1000 usecs are allocated?
- *
- * While this measures the bandwidth in terms of usecs/uframe,
- * the low/fullspeed bus has no notion of uframes, so any particular
- * low/fullspeed transfer can "carry over" from one uframe to the next,
- * since the TT just performs downstream transfers in sequence.
- *
- * For example two separate 100 usec transfers can start in the same uframe,
- * and the second one would "carry over" 75 usecs into the next uframe.
- */
-static void
-periodic_tt_usecs (
-        struct ehci_hcd *ehci,
-        struct usb_device *dev,
-        unsigned frame,
-        unsigned short tt_usecs[8]
-)
-{
-        __hc32                  *hw_p = &ehci->periodic [frame];
-        union ehci_shadow       *q = &ehci->pshadow [frame];
-        unsigned char           uf;
-
-        memset(tt_usecs, 0, 16);
-
-        while (q->ptr) {
-                switch (hc32_to_cpu(ehci, Q_NEXT_TYPE(ehci, *hw_p))) {
-                case Q_TYPE_ITD:
-                        hw_p = &q->itd->hw_next;
-                        q = &q->itd->itd_next;
-                        continue;
-                case Q_TYPE_QH:
-                        if (same_tt(dev, q->qh->dev)) {
-                                uf = tt_start_uframe(ehci, q->qh->hw->hw_info2);
-                                tt_usecs[uf] += q->qh->tt_usecs;
-                        }
-                        hw_p = &q->qh->hw->hw_next;
-                        q = &q->qh->qh_next;
-                        continue;
-                case Q_TYPE_SITD:
-                        if (same_tt(dev, q->sitd->urb->dev)) {
-                                uf = tt_start_uframe(ehci, q->sitd->hw_uframe);
-                                tt_usecs[uf] += q->sitd->stream->tt_usecs;
-                        }
-                        hw_p = &q->sitd->hw_next;
-                        q = &q->sitd->sitd_next;
-                        continue;
-                // case Q_TYPE_FSTN:
-                default:
-                        ehci_dbg(ehci, "ignoring periodic frame %d FSTN\n",
-                                        frame);
-                        hw_p = &q->fstn->hw_next;
-                        q = &q->fstn->fstn_next;
-                }
-        }
-
-        carryover_tt_bandwidth(tt_usecs);
-
-        if (max_tt_usecs[7] < tt_usecs[7])
-                ehci_err(ehci, "frame %d tt sched overrun: %d usecs\n",
-                        frame, tt_usecs[7] - max_tt_usecs[7]);
-}
-
 /*
  * Return true if the device's tt's downstream bus is available for a
  * periodic transfer of the specified length (usecs), starting at the
@@ -312,20 +377,29 @@ periodic_tt_usecs (
  */
 static int tt_available (
         struct ehci_hcd         *ehci,
-        unsigned                period,
-        struct usb_device       *dev,
+        struct ehci_per_sched   *ps,
+        struct ehci_tt          *tt,
         unsigned                frame,
-        unsigned                uframe,
-        u16                     usecs
+        unsigned                uframe
 )
 {
+        unsigned                period = ps->bw_period;
+        unsigned                usecs = ps->tt_usecs;
+
         if ((period == 0) || (uframe >= 7))     /* error */
                 return 0;
 
-        for (; frame < ehci->periodic_size; frame += period) {
-                unsigned short tt_usecs[8];
+        for (frame &= period - 1; frame < EHCI_BANDWIDTH_FRAMES;
+                        frame += period) {
+                unsigned        i, uf;
+                unsigned short  tt_usecs[8];
 
-                periodic_tt_usecs (ehci, dev, frame, tt_usecs);
+                if (tt->bandwidth[frame] + usecs > 900)
+                        return 0;
+
+                uf = frame << 3;
+                for (i = 0; i < 8; (++i, ++uf))
+                        tt_usecs[i] = ehci->tt_budget[uf];
 
                 if (max_tt_usecs[uframe] <= tt_usecs[uframe])
                         return 0;
@@ -337,7 +411,7 @@ static int tt_available (
                  */
                 if (125 < usecs) {
                         int ufs = (usecs / 125);
-                        int i;
+
                         for (i = uframe; i < (uframe + ufs) && i < 8; i++)
                                 if (0 < tt_usecs[i])
                                         return 0;
@@ -391,7 +465,7 @@ static int tt_no_collision (
                                 continue;
                         case Q_TYPE_QH:
                                 hw = here.qh->hw;
-                                if (same_tt (dev, here.qh->dev)) {
+                                if (same_tt(dev, here.qh->ps.udev)) {
                                         u32             mask;
 
                                         mask = hc32_to_cpu(ehci,
@@ -471,19 +545,19 @@ static void disable_periodic(struct ehci_hcd *ehci)
 static void qh_link_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
         unsigned        i;
-        unsigned        period = qh->period;
+        unsigned        period = qh->ps.period;
 
-        dev_dbg (&qh->dev->dev,
+        dev_dbg(&qh->ps.udev->dev,
                 "link qh%d-%04x/%p start %d [%d/%d us]\n",
                 period, hc32_to_cpup(ehci, &qh->hw->hw_info2)
                         & (QH_CMASK | QH_SMASK),
-                qh, qh->start, qh->usecs, qh->c_usecs);
+                qh, qh->ps.phase, qh->ps.usecs, qh->ps.c_usecs);
 
         /* high bandwidth, or otherwise every microframe */
         if (period == 0)
                 period = 1;
 
-        for (i = qh->start; i < ehci->periodic_size; i += period) {
+        for (i = qh->ps.phase; i < ehci->periodic_size; i += period) {
                 union ehci_shadow       *prev = &ehci->pshadow[i];
                 __hc32                  *hw_p = &ehci->periodic[i];
                 union ehci_shadow       here = *prev;
@@ -503,7 +577,7 @@ static void qh_link_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
                  * enables sharing interior tree nodes
                  */
                 while (here.ptr && qh != here.qh) {
-                        if (qh->period > here.qh->period)
+                        if (qh->ps.period > here.qh->ps.period)
                                 break;
                         prev = &here.qh->qh_next;
                         hw_p = &here.qh->hw->hw_next;
@@ -523,10 +597,10 @@ static void qh_link_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
         qh->xacterrs = 0;
         qh->exception = 0;
 
-        /* update per-qh bandwidth for usbfs */
-        ehci_to_hcd(ehci)->self.bandwidth_allocated += qh->period
-                ? ((qh->usecs + qh->c_usecs) / qh->period)
-                : (qh->usecs * 8);
+        /* update per-qh bandwidth for debugfs */
+        ehci_to_hcd(ehci)->self.bandwidth_allocated += qh->ps.bw_period
+                ? ((qh->ps.usecs + qh->ps.c_usecs) / qh->ps.bw_period)
+                : (qh->ps.usecs * 8);
 
         list_add(&qh->intr_node, &ehci->intr_qh_list);
 
@@ -556,22 +630,21 @@ static void qh_unlink_periodic(struct ehci_hcd *ehci, struct ehci_qh *qh)
          */
 
         /* high bandwidth, or otherwise part of every microframe */
-        if ((period = qh->period) == 0)
-                period = 1;
+        period = qh->ps.period ? : 1;
 
-        for (i = qh->start; i < ehci->periodic_size; i += period)
+        for (i = qh->ps.phase; i < ehci->periodic_size; i += period)
                 periodic_unlink (ehci, i, qh);
 
-        /* update per-qh bandwidth for usbfs */
-        ehci_to_hcd(ehci)->self.bandwidth_allocated -= qh->period
-                ? ((qh->usecs + qh->c_usecs) / qh->period)
-                : (qh->usecs * 8);
+        /* update per-qh bandwidth for debugfs */
+        ehci_to_hcd(ehci)->self.bandwidth_allocated -= qh->ps.bw_period
+                ? ((qh->ps.usecs + qh->ps.c_usecs) / qh->ps.bw_period)
+                : (qh->ps.usecs * 8);
 
-        dev_dbg (&qh->dev->dev,
+        dev_dbg(&qh->ps.udev->dev,
                 "unlink qh%d-%04x/%p start %d [%d/%d us]\n",
-                qh->period,
+                qh->ps.period,
                 hc32_to_cpup(ehci, &qh->hw->hw_info2) & (QH_CMASK | QH_SMASK),
-                qh, qh->start, qh->usecs, qh->c_usecs);
+                qh, qh->ps.phase, qh->ps.usecs, qh->ps.c_usecs);
 
         /* qh->qh_next still "live" to HC */
         qh->qh_state = QH_STATE_UNLINK;
@@ -694,11 +767,9 @@ static int check_period (
         struct ehci_hcd *ehci,
         unsigned        frame,
         unsigned        uframe,
-        unsigned        period,
+        unsigned        uperiod,
         unsigned        usecs
 ) {
-        int             claimed;
-
         /* complete split running into next frame?
          * given FSTN support, we could sometimes check...
          */
@@ -708,25 +779,10 @@ static int check_period (
         /* convert "usecs we need" to "max already claimed" */
         usecs = ehci->uframe_periodic_max - 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 (ehci, frame, uframe);
-                                if (claimed > usecs)
-                                        return 0;
-                        }
-                } while ((frame += 1) < ehci->periodic_size);
-
-        /* just check the specified uframe, at that period */
-        } else {
-                do {
-                        claimed = periodic_usecs (ehci, frame, uframe);
-                        if (claimed > usecs)
-                                return 0;
-                } while ((frame += period) < ehci->periodic_size);
+        for (uframe += frame << 3; uframe < EHCI_BANDWIDTH_SIZE;
+                        uframe += uperiod) {
+                if (ehci->bandwidth[uframe] > usecs)
+                        return 0;
         }
 
         // success!
@@ -737,40 +793,40 @@ static int check_intr_schedule (
         struct ehci_hcd         *ehci,
         unsigned                frame,
         unsigned                uframe,
-        const struct ehci_qh    *qh,
-        __hc32                  *c_maskp
+        struct ehci_qh          *qh,
+        unsigned                *c_maskp,
+        struct ehci_tt          *tt
 )
 {
         int             retval = -ENOSPC;
         u8              mask = 0;
 
-        if (qh->c_usecs && uframe >= 6)         /* FSTN territory? */
+        if (qh->ps.c_usecs && uframe >= 6)      /* FSTN territory? */
                 goto done;
 
-        if (!check_period (ehci, frame, uframe, qh->period, qh->usecs))
+        if (!check_period(ehci, frame, uframe, qh->ps.bw_uperiod, qh->ps.usecs))
                 goto done;
-        if (!qh->c_usecs) {
+        if (!qh->ps.c_usecs) {
                 retval = 0;
                 *c_maskp = 0;
                 goto done;
         }
 
 #ifdef CONFIG_USB_EHCI_TT_NEWSCHED
-        if (tt_available (ehci, qh->period, qh->dev, frame, uframe,
-                                qh->tt_usecs)) {
+        if (tt_available(ehci, &qh->ps, tt, frame, uframe)) {
                 unsigned i;
 
                 /* TODO : this may need FSTN for SSPLIT in uframe 5. */
-                for (i=uframe+1; i<8 && i<uframe+4; i++)
-                        if (!check_period (ehci, frame, i,
-                                                qh->period, qh->c_usecs))
+                for (i = uframe+2; i < 8 && i <= uframe+4; i++)
+                        if (!check_period(ehci, frame, i,
+                                        qh->ps.bw_uperiod, qh->ps.c_usecs))
                                 goto done;
                         else
                                 mask |= 1 << i;
 
                 retval = 0;
 
-                *c_maskp = cpu_to_hc32(ehci, mask << 8);
+                *c_maskp = mask;
         }
 #else
         /* Make sure this tt's buffer is also available for CSPLITs.
@@ -781,15 +837,15 @@ static int check_intr_schedule (
          * one smart pass...
          */
         mask = 0x03 << (uframe + qh->gap_uf);
-        *c_maskp = cpu_to_hc32(ehci, mask << 8);
+        *c_maskp = mask;
 
         mask |= 1 << uframe;
-        if (tt_no_collision (ehci, qh->period, qh->dev, frame, mask)) {
-                if (!check_period (ehci, frame, uframe + qh->gap_uf + 1,
-                                        qh->period, qh->c_usecs))
+        if (tt_no_collision(ehci, qh->ps.bw_period, qh->ps.udev, frame, mask)) {
+                if (!check_period(ehci, frame, uframe + qh->gap_uf + 1,
+                                qh->ps.bw_uperiod, qh->ps.c_usecs))
                         goto done;
-                if (!check_period (ehci, frame, uframe + qh->gap_uf,
-                                        qh->period, qh->c_usecs))
+                if (!check_period(ehci, frame, uframe + qh->gap_uf,
+                                qh->ps.bw_uperiod, qh->ps.c_usecs))
                         goto done;
                 retval = 0;
         }
@@ -803,62 +859,67 @@ done:
  */
 static int qh_schedule(struct ehci_hcd *ehci, struct ehci_qh *qh)
 {
-        int             status;
+        int             status = 0;
         unsigned        uframe;
-        __hc32          c_mask;
-        unsigned        frame;          /* 0..(qh->period - 1), or NO_FRAME */
+        unsigned        c_mask;
         struct ehci_qh_hw       *hw = qh->hw;
+        struct ehci_tt          *tt;
 
         hw->hw_next = EHCI_LIST_END(ehci);
-        frame = qh->start;
 
         /* reuse the previous schedule slots, if we can */
-        if (frame < qh->period) {
-                uframe = ffs(hc32_to_cpup(ehci, &hw->hw_info2) & QH_SMASK);
-                status = check_intr_schedule (ehci, frame, --uframe,
-                                qh, &c_mask);
-        } else {
-                uframe = 0;
-                c_mask = 0;
-                status = -ENOSPC;
+        if (qh->ps.phase != NO_FRAME) {
+                ehci_dbg(ehci, "reused qh %p schedule\n", qh);
+                return 0;
+        }
+
+        uframe = 0;
+        c_mask = 0;
+        tt = find_tt(qh->ps.udev);
+        if (IS_ERR(tt)) {
+                status = PTR_ERR(tt);
+                goto done;
         }
+        compute_tt_budget(ehci->tt_budget, tt);
 
         /* 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) {
-                        int             i;
-
-                        for (i = qh->period; status && i > 0; --i) {
-                                frame = ++ehci->random_frame % qh->period;
-                                for (uframe = 0; uframe < 8; uframe++) {
-                                        status = check_intr_schedule (ehci,
-                                                        frame, uframe, qh,
-                                                        &c_mask);
-                                        if (status == 0)
-                                                break;
-                                }
+        /* "normal" case, uframing flexible except with splits */
+        if (qh->ps.bw_period) {
+                int             i;
+                unsigned        frame;
+
+                for (i = qh->ps.bw_period; i > 0; --i) {
+                        frame = ++ehci->random_frame & (qh->ps.bw_period - 1);
+                        for (uframe = 0; uframe < 8; uframe++) {
+                                status = check_intr_schedule(ehci,
+                                                frame, uframe, qh, &c_mask, tt);
+                                if (status == 0)
+                                        goto got_it;
                         }
-
-                /* qh->period == 0 means every uframe */
-                } else {
-                        frame = 0;
-                        status = check_intr_schedule (ehci, 0, 0, qh, &c_mask);
                 }
-                if (status)
-                        goto done;
-                qh->start = frame;
 
-                /* reset S-frame and (maybe) C-frame masks */
-                hw->hw_info2 &= cpu_to_hc32(ehci, ~(QH_CMASK | QH_SMASK));
-                hw->hw_info2 |= qh->period
-                        ? cpu_to_hc32(ehci, 1 << uframe)
-                        : cpu_to_hc32(ehci, QH_SMASK);
-                hw->hw_info2 |= c_mask;
-        } else
-                ehci_dbg (ehci, "reused qh %p schedule\n", qh);
+        /* qh->ps.bw_period == 0 means every uframe */
+        } else {
+                status = check_intr_schedule(ehci, 0, 0, qh, &c_mask, tt);
+        }
+        if (status)
+                goto done;
+
+ got_it:
+        qh->ps.phase = (qh->ps.period ? ehci->random_frame &
+                        (qh->ps.period - 1) : 0);
+        qh->ps.bw_phase = qh->ps.phase & (qh->ps.bw_period - 1);
+        qh->ps.phase_uf = uframe;
+        qh->ps.cs_mask = qh->ps.period ?
+                        (c_mask << 8) | (1 << uframe) :
+                        QH_SMASK;
+
+        /* reset S-frame and (maybe) C-frame masks */
+        hw->hw_info2 &= cpu_to_hc32(ehci, ~(QH_CMASK | QH_SMASK));
+        hw->hw_info2 |= cpu_to_hc32(ehci, qh->ps.cs_mask);
+        reserve_release_intr_bandwidth(ehci, qh, 1);
 
 done:
         return status;
@@ -969,7 +1030,8 @@ iso_stream_alloc (gfp_t mem_flags)
         if (likely (stream != NULL)) {
                 INIT_LIST_HEAD(&stream->td_list);
                 INIT_LIST_HEAD(&stream->free_list);
-                stream->next_uframe = -1;
+                stream->next_uframe = NO_FRAME;
+                stream->ps.phase = NO_FRAME;
         }
         return stream;
 }
@@ -978,25 +1040,24 @@ static void
 iso_stream_init (
         struct ehci_hcd         *ehci,
         struct ehci_iso_stream  *stream,
-        struct usb_device       *dev,
-        int                     pipe,
-        unsigned                interval
+        struct urb              *urb
 )
 {
         static const u8 smask_out [] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f };
 
+        struct usb_device       *dev = urb->dev;
         u32                     buf1;
         unsigned                epnum, maxp;
         int                     is_input;
-        long                    bandwidth;
+        unsigned                tmp;
 
         /*
          * this might be a "high bandwidth" highspeed endpoint,
          * as encoded in the ep descriptor's wMaxPacket field
          */
-        epnum = usb_pipeendpoint (pipe);
-        is_input = usb_pipein (pipe) ? USB_DIR_IN : 0;
-        maxp = usb_maxpacket(dev, pipe, !is_input);
+        epnum = usb_pipeendpoint(urb->pipe);
+        is_input = usb_pipein(urb->pipe) ? USB_DIR_IN : 0;
+        maxp = usb_endpoint_maxp(&urb->ep->desc);
         if (is_input) {
                 buf1 = (1 << 11);
         } else {
@@ -1020,9 +1081,19 @@ iso_stream_init (
                 /* usbfs wants to report the average usecs per frame tied up
                  * when transfers on this endpoint are scheduled ...
                  */
-                stream->usecs = HS_USECS_ISO (maxp);
-                bandwidth = stream->usecs * 8;
-                bandwidth /= interval;
+                stream->ps.usecs = HS_USECS_ISO(maxp);
+
+                /* period for bandwidth allocation */
+                tmp = min_t(unsigned, EHCI_BANDWIDTH_SIZE,
+                                1 << (urb->ep->desc.bInterval - 1));
+
+                /* Allow urb->interval to override */
+                stream->ps.bw_uperiod = min_t(unsigned, tmp, urb->interval);
+
+                stream->uperiod = urb->interval;
+                stream->ps.period = urb->interval >> 3;
+                stream->bandwidth = stream->ps.usecs * 8 /
+                                stream->ps.bw_uperiod;
 
         } else {
                 u32             addr;
@@ -1036,36 +1107,46 @@ iso_stream_init (
                         addr |= dev->tt->hub->devnum << 16;
                 addr |= epnum << 8;
                 addr |= dev->devnum;
-                stream->usecs = HS_USECS_ISO (maxp);
+                stream->ps.usecs = HS_USECS_ISO(maxp);
                 think_time = dev->tt ? dev->tt->think_time : 0;
-                stream->tt_usecs = NS_TO_US (think_time + usb_calc_bus_time (
+                stream->ps.tt_usecs = NS_TO_US(think_time + usb_calc_bus_time(
                                 dev->speed, is_input, 1, maxp));
                 hs_transfers = max (1u, (maxp + 187) / 188);
                 if (is_input) {
                         u32     tmp;
 
                         addr |= 1 << 31;
-                        stream->c_usecs = stream->usecs;
-                        stream->usecs = HS_USECS_ISO (1);
-                        stream->raw_mask = 1;
+                        stream->ps.c_usecs = stream->ps.usecs;
+                        stream->ps.usecs = HS_USECS_ISO(1);
+                        stream->ps.cs_mask = 1;
 
                         /* c-mask as specified in USB 2.0 11.18.4 3.c */
                         tmp = (1 << (hs_transfers + 2)) - 1;
-                        stream->raw_mask |= tmp << (8 + 2);
+                        stream->ps.cs_mask |= tmp << (8 + 2);
                 } else
-                        stream->raw_mask = smask_out [hs_transfers - 1];
-                bandwidth = stream->usecs + stream->c_usecs;
-                bandwidth /= interval << 3;
+                        stream->ps.cs_mask = smask_out[hs_transfers - 1];
+
+                /* period for bandwidth allocation */
+                tmp = min_t(unsigned, EHCI_BANDWIDTH_FRAMES,
+                                1 << (urb->ep->desc.bInterval - 1));
+
+                /* Allow urb->interval to override */
+                stream->ps.bw_period = min_t(unsigned, tmp, urb->interval);
+                stream->ps.bw_uperiod = stream->ps.bw_period << 3;
 
-                /* stream->splits gets created from raw_mask later */
+                stream->ps.period = urb->interval;
+                stream->uperiod = urb->interval << 3;
+                stream->bandwidth = (stream->ps.usecs + stream->ps.c_usecs) /
+                                stream->ps.bw_period;
+
+                /* stream->splits gets created from cs_mask later */
                 stream->address = cpu_to_hc32(ehci, addr);
         }
-        stream->bandwidth = bandwidth;
 
-        stream->udev = dev;
+        stream->ps.udev = dev;
+        stream->ps.ep = urb->ep;
 
         stream->bEndpointAddress = is_input | epnum;
-        stream->interval = interval;
         stream->maxp = maxp;
 }
 
@@ -1090,9 +1171,7 @@ iso_stream_find (struct ehci_hcd *ehci, struct urb *urb)
                 stream = iso_stream_alloc(GFP_ATOMIC);
                 if (likely (stream != NULL)) {
                         ep->hcpriv = stream;
-                        stream->ep = ep;
-                        iso_stream_init(ehci, stream, urb->dev, urb->pipe,
-                                        urb->interval);
+                        iso_stream_init(ehci, stream, urb);
                 }
 
         /* if dev->ep [epnum] is a QH, hw is set */
@@ -1137,7 +1216,7 @@ itd_sched_init(
         dma_addr_t      dma = urb->transfer_dma;
 
         /* how many uframes are needed for these transfers */
-        iso_sched->span = urb->number_of_packets * stream->interval;
+        iso_sched->span = urb->number_of_packets * stream->uperiod;
 
         /* figure out per-uframe itd fields that we'll need later
          * when we fit new itds into the schedule.
@@ -1236,7 +1315,7 @@ itd_urb_transaction (
 
                 memset (itd, 0, sizeof *itd);
                 itd->itd_dma = itd_dma;
-                itd->frame = 9999;              /* an invalid value */
+                itd->frame = NO_FRAME;
                 list_add (&itd->itd_list, &sched->td_list);
         }
         spin_unlock_irqrestore (&ehci->lock, flags);
@@ -1249,49 +1328,106 @@ itd_urb_transaction (
 
 /*-------------------------------------------------------------------------*/
 
+static void reserve_release_iso_bandwidth(struct ehci_hcd *ehci,
+                struct ehci_iso_stream *stream, int sign)
+{
+        unsigned                uframe;
+        unsigned                i, j;
+        unsigned                s_mask, c_mask, m;
+        int                     usecs = stream->ps.usecs;
+        int                     c_usecs = stream->ps.c_usecs;
+        int                     tt_usecs = stream->ps.tt_usecs;
+        struct ehci_tt          *tt;
+
+        if (stream->ps.phase == NO_FRAME)       /* Bandwidth wasn't reserved */
+                return;
+        uframe = stream->ps.bw_phase << 3;
+
+        bandwidth_dbg(ehci, sign, "iso", &stream->ps);
+
+        if (sign < 0) {         /* Release bandwidth */
+                usecs = -usecs;
+                c_usecs = -c_usecs;
+                tt_usecs = -tt_usecs;
+        }
+
+        if (!stream->splits) {          /* High speed */
+                for (i = uframe + stream->ps.phase_uf; i < EHCI_BANDWIDTH_SIZE;
+                                i += stream->ps.bw_uperiod)
+                        ehci->bandwidth[i] += usecs;
+
+        } else {                        /* Full speed */
+                s_mask = stream->ps.cs_mask;
+                c_mask = s_mask >> 8;
+
+                /* NOTE: adjustment needed for frame overflow */
+                for (i = uframe; i < EHCI_BANDWIDTH_SIZE;
+                                i += stream->ps.bw_uperiod) {
+                        for ((j = stream->ps.phase_uf, m = 1 << j); j < 8;
+                                        (++j, m <<= 1)) {
+                                if (s_mask & m)
+                                        ehci->bandwidth[i+j] += usecs;
+                                else if (c_mask & m)
+                                        ehci->bandwidth[i+j] += c_usecs;
+                        }
+                }
+
+                tt = find_tt(stream->ps.udev);
+                if (sign > 0)
+                        list_add_tail(&stream->ps.ps_list, &tt->ps_list);
+                else
+                        list_del(&stream->ps.ps_list);
+
+                for (i = uframe >> 3; i < EHCI_BANDWIDTH_FRAMES;
+                                i += stream->ps.bw_period)
+                        tt->bandwidth[i] += tt_usecs;
+        }
+}
+
 static inline int
 itd_slot_ok (
         struct ehci_hcd         *ehci,
-        u32                     mod,
-        u32                     uframe,
-        u8                      usecs,
-        u32                     period
+        struct ehci_iso_stream  *stream,
+        unsigned                uframe
 )
 {
-        uframe %= period;
-        do {
-                /* can't commit more than uframe_periodic_max usec */
-                if (periodic_usecs (ehci, uframe >> 3, uframe & 0x7)
-                                > (ehci->uframe_periodic_max - usecs))
-                        return 0;
+        unsigned                usecs;
+
+        /* convert "usecs we need" to "max already claimed" */
+        usecs = ehci->uframe_periodic_max - stream->ps.usecs;
 
-                /* we know urb->interval is 2^N uframes */
-                uframe += period;
-        } while (uframe < mod);
+        for (uframe &= stream->ps.bw_uperiod - 1; uframe < EHCI_BANDWIDTH_SIZE;
+                        uframe += stream->ps.bw_uperiod) {
+                if (ehci->bandwidth[uframe] > usecs)
+                        return 0;
+        }
         return 1;
 }
 
 static inline int
 sitd_slot_ok (
         struct ehci_hcd         *ehci,
-        u32                     mod,
         struct ehci_iso_stream  *stream,
-        u32                     uframe,
+        unsigned                uframe,
         struct ehci_iso_sched   *sched,
-        u32                     period_uframes
+        struct ehci_tt          *tt
 )
 {
-        u32                     mask, tmp;
-        u32                     frame, uf;
+        unsigned                mask, tmp;
+        unsigned                frame, uf;
+
+        mask = stream->ps.cs_mask << (uframe & 7);
 
-        mask = stream->raw_mask << (uframe & 7);
+        /* for OUT, don't wrap SSPLIT into H-microframe 7 */
+        if (((stream->ps.cs_mask & 0xff) << (uframe & 7)) >= (1 << 7))
+                return 0;
 
         /* for IN, don't wrap CSPLIT into the next frame */
         if (mask & ~0xffff)
                 return 0;
 
         /* check bandwidth */
-        uframe %= period_uframes;
+        uframe &= stream->ps.bw_uperiod - 1;
         frame = uframe >> 3;
 
 #ifdef CONFIG_USB_EHCI_TT_NEWSCHED
@@ -1299,54 +1435,48 @@ sitd_slot_ok (
          * tt_available scheduling guarantees 10+% for control/bulk.
          */
         uf = uframe & 7;
-        if (!tt_available(ehci, period_uframes >> 3,
-                        stream->udev, frame, uf, stream->tt_usecs))
+        if (!tt_available(ehci, &stream->ps, tt, frame, uf))
                 return 0;
 #else
         /* tt must be idle for start(s), any gap, and csplit.
          * assume scheduling slop leaves 10+% for control/bulk.
          */
-        if (!tt_no_collision(ehci, period_uframes >> 3,
-                        stream->udev, frame, mask))
+        if (!tt_no_collision(ehci, stream->ps.bw_period,
+                        stream->ps.udev, frame, mask))
                 return 0;
 #endif
 
-        /* this multi-pass logic is simple, but performance may
-         * suffer when the schedule data isn't cached.
-         */
         do {
-                u32             max_used;
-
-                frame = uframe >> 3;
-                uf = uframe & 7;
+                unsigned        max_used;
+                unsigned        i;
 
                 /* check starts (OUT uses more than one) */
-                max_used = ehci->uframe_periodic_max - stream->usecs;
-                for (tmp = stream->raw_mask & 0xff; tmp; tmp >>= 1, uf++) {
-                        if (periodic_usecs (ehci, frame, uf) > max_used)
+                uf = uframe;
+                max_used = ehci->uframe_periodic_max - stream->ps.usecs;
+                for (tmp = stream->ps.cs_mask & 0xff; tmp; tmp >>= 1, uf++) {
+                        if (ehci->bandwidth[uf] > max_used)
                                 return 0;
                 }
 
                 /* for IN, check CSPLIT */
-                if (stream->c_usecs) {
-                        uf = uframe & 7;
-                        max_used = ehci->uframe_periodic_max - stream->c_usecs;
-                        do {
-                                tmp = 1 << uf;
-                                tmp <<= 8;
-                                if ((stream->raw_mask & tmp) == 0)
+                if (stream->ps.c_usecs) {
+                        max_used = ehci->uframe_periodic_max -
+                                        stream->ps.c_usecs;
+                        uf = uframe & ~7;
+                        tmp = 1 << (2+8);
+                        for (i = (uframe & 7) + 2; i < 8; (++i, tmp <<= 1)) {
+                                if ((stream->ps.cs_mask & tmp) == 0)
                                         continue;
-                                if (periodic_usecs (ehci, frame, uf)
-                                                > max_used)
+                                if (ehci->bandwidth[uf+i] > max_used)
                                         return 0;
-                        } while (++uf < 8);
+                        }
                 }
 
-                /* we know urb->interval is 2^N uframes */
-                uframe += period_uframes;
-        } while (uframe < mod);
+                uframe += stream->ps.bw_uperiod;
+        } while (uframe < EHCI_BANDWIDTH_SIZE);
 
-        stream->splits = cpu_to_hc32(ehci, stream->raw_mask << (uframe & 7));
+        stream->ps.cs_mask <<= uframe & 7;
+        stream->splits = cpu_to_hc32(ehci, stream->ps.cs_mask);
         return 1;
 }
 
@@ -1361,8 +1491,6 @@ sitd_slot_ok (
  * given EHCI_TUNE_FLS and the slop).  Or, write a smarter scheduler!
  */
 
-#define SCHEDULING_DELAY        40      /* microframes */
-
 static int
 iso_stream_schedule (
         struct ehci_hcd         *ehci,
@@ -1370,134 +1498,184 @@ iso_stream_schedule (
         struct ehci_iso_stream  *stream
 )
 {
-        u32                     now, base, next, start, period, span;
-        int                     status;
+        u32                     now, base, next, start, period, span, now2;
+        u32                     wrap = 0, skip = 0;
+        int                     status = 0;
         unsigned                mod = ehci->periodic_size << 3;
         struct ehci_iso_sched   *sched = urb->hcpriv;
+        bool                    empty = list_empty(&stream->td_list);
+        bool                    new_stream = false;
 
-        period = urb->interval;
+        period = stream->uperiod;
         span = sched->span;
-        if (!stream->highspeed) {
-                period <<= 3;
+        if (!stream->highspeed)
                 span <<= 3;
-        }
 
-        now = ehci_read_frame_index(ehci) & (mod - 1);
+        /* Start a new isochronous stream? */
+        if (unlikely(empty && !hcd_periodic_completion_in_progress(
+                        ehci_to_hcd(ehci), urb->ep))) {
 
-        /* Typical case: reuse current schedule, stream is still active.
-         * Hopefully there are no gaps from the host falling behind
-         * (irq delays etc).  If there are, the behavior depends on
-         * whether URB_ISO_ASAP is set.
-         */
-        if (likely (!list_empty (&stream->td_list))) {
+                /* Schedule the endpoint */
+                if (stream->ps.phase == NO_FRAME) {
+                        int             done = 0;
+                        struct ehci_tt  *tt = find_tt(stream->ps.udev);
 
-                /* Take the isochronous scheduling threshold into account */
-                if (ehci->i_thresh)
-                        next = now + ehci->i_thresh;    /* uframe cache */
-                else
-                        next = (now + 2 + 7) & ~0x07;   /* full frame cache */
-
-                /*
-                 * Use ehci->last_iso_frame as the base.  There can't be any
-                 * TDs scheduled for earlier than that.
-                 */
-                base = ehci->last_iso_frame << 3;
-                next = (next - base) & (mod - 1);
-                start = (stream->next_uframe - base) & (mod - 1);
-
-                /* Is the schedule already full? */
-                if (unlikely(start < period)) {
-                        ehci_dbg(ehci, "iso sched full %p (%u-%u < %u mod %u)\n",
-                                        urb, stream->next_uframe, base,
-                                        period, mod);
-                        status = -ENOSPC;
-                        goto fail;
-                }
-
-                /* Behind the scheduling threshold? */
-                if (unlikely(start < next)) {
-                        unsigned now2 = (now - base) & (mod - 1);
+                        if (IS_ERR(tt)) {
+                                status = PTR_ERR(tt);
+                                goto fail;
+                        }
+                        compute_tt_budget(ehci->tt_budget, tt);
 
-                        /* USB_ISO_ASAP: Round up to the first available slot */
-                        if (urb->transfer_flags & URB_ISO_ASAP)
-                                start += (next - start + period - 1) & -period;
+                        start = ((-(++ehci->random_frame)) << 3) & (period - 1);
 
-                        /*
-                         * Not ASAP: Use the next slot in the stream,
-                         * no matter what.
+                        /* find a uframe slot with enough bandwidth.
+                         * Early uframes are more precious because full-speed
+                         * iso IN transfers can't use late uframes,
+                         * and therefore they should be allocated last.
                          */
-                        else if (start + span - period < now2) {
-                                ehci_dbg(ehci, "iso underrun %p (%u+%u < %u)\n",
-                                                urb, start + base,
-                                                span - period, now2 + base);
+                        next = start;
+                        start += period;
+                        do {
+                                start--;
+                                /* check schedule: enough space? */
+                                if (stream->highspeed) {
+                                        if (itd_slot_ok(ehci, stream, start))
+                                                done = 1;
+                                } else {
+                                        if ((start % 8) >= 6)
+                                                continue;
+                                        if (sitd_slot_ok(ehci, stream, start,
+                                                        sched, tt))
+                                                done = 1;
+                                }
+                        } while (start > next && !done);
+
+                        /* no room in the schedule */
+                        if (!done) {
+                                ehci_dbg(ehci, "iso sched full %p", urb);
+                                status = -ENOSPC;
+                                goto fail;
                         }
+                        stream->ps.phase = (start >> 3) &
+                                        (stream->ps.period - 1);
+                        stream->ps.bw_phase = stream->ps.phase &
+                                        (stream->ps.bw_period - 1);
+                        stream->ps.phase_uf = start & 7;
+                        reserve_release_iso_bandwidth(ehci, stream, 1);
+                }
+
+                /* New stream is already scheduled; use the upcoming slot */
+                else {
+                        start = (stream->ps.phase << 3) + stream->ps.phase_uf;
                 }
 
-                start += base;
+                stream->next_uframe = start;
+                new_stream = true;
         }
 
-        /* need to schedule; when's the next (u)frame we could start?
-         * this is bigger than ehci->i_thresh allows; scheduling itself
-         * isn't free, the delay should handle reasonably slow cpus.  it
-         * can also help high bandwidth if the dma and irq loads don't
-         * jump until after the queue is primed.
+        now = ehci_read_frame_index(ehci) & (mod - 1);
+
+        /* Take the isochronous scheduling threshold into account */
+        if (ehci->i_thresh)
+                next = now + ehci->i_thresh;    /* uframe cache */
+        else
+                next = (now + 2 + 7) & ~0x07;   /* full frame cache */
+
+        /*
+         * Use ehci->last_iso_frame as the base.  There can't be any
+         * TDs scheduled for earlier than that.
          */
-        else {
-                int done = 0;
+        base = ehci->last_iso_frame << 3;
+        next = (next - base) & (mod - 1);
+        start = (stream->next_uframe - base) & (mod - 1);
 
-                base = now & ~0x07;
-                start = base + SCHEDULING_DELAY;
+        if (unlikely(new_stream))
+                goto do_ASAP;
 
-                /* find a uframe slot with enough bandwidth.
-                 * Early uframes are more precious because full-speed
-                 * iso IN transfers can't use late uframes,
-                 * and therefore they should be allocated last.
-                 */
-                next = start;
-                start += period;
-                do {
-                        start--;
-                        /* check schedule: enough space? */
-                        if (stream->highspeed) {
-                                if (itd_slot_ok(ehci, mod, start,
-                                                stream->usecs, period))
-                                        done = 1;
-                        } else {
-                                if ((start % 8) >= 6)
-                                        continue;
-                                if (sitd_slot_ok(ehci, mod, stream,
-                                                start, sched, period))
-                                        done = 1;
-                        }
-                } while (start > next && !done);
+        /*
+         * Typical case: reuse current schedule, stream may still be active.
+         * Hopefully there are no gaps from the host falling behind
+         * (irq delays etc).  If there are, the behavior depends on
+         * whether URB_ISO_ASAP is set.
+         */
+        now2 = (now - base) & (mod - 1);
+
+        /* Is the schedule already full? */
+        if (unlikely(!empty && start < period)) {
+                ehci_dbg(ehci, "iso sched full %p (%u-%u < %u mod %u)\n",
+                                urb, stream->next_uframe, base, period, mod);
+                status = -ENOSPC;
+                goto fail;
+        }
+
+        /* Is the next packet scheduled after the base time? */
+        if (likely(!empty || start <= now2 + period)) {
+
+                /* URB_ISO_ASAP: make sure that start >= next */
+                if (unlikely(start < next &&
+                                (urb->transfer_flags & URB_ISO_ASAP)))
+                        goto do_ASAP;
+
+                /* Otherwise use start, if it's not in the past */
+                if (likely(start >= now2))
+                        goto use_start;
 
-                /* no room in the schedule */
-                if (!done) {
-                        ehci_dbg(ehci, "iso sched full %p", urb);
-                        status = -ENOSPC;
-                        goto fail;
+        /* Otherwise we got an underrun while the queue was empty */
+        } else {
+                if (urb->transfer_flags & URB_ISO_ASAP)
+                        goto do_ASAP;
+                wrap = mod;
+                now2 += mod;
+        }
+
+        /* How many uframes and packets do we need to skip? */
+        skip = (now2 - start + period - 1) & -period;
+        if (skip >= span) {             /* Entirely in the past? */
+                ehci_dbg(ehci, "iso underrun %p (%u+%u < %u) [%u]\n",
+                                urb, start + base, span - period, now2 + base,
+                                base);
+
+                /* Try to keep the last TD intact for scanning later */
+                skip = span - period;
+
+                /* Will it come before the current scan position? */
+                if (empty) {
+                        skip = span;    /* Skip the entire URB */
+                        status = 1;     /* and give it back immediately */
+                        iso_sched_free(stream, sched);
+                        sched = NULL;
                 }
         }
+        urb->error_count = skip / period;
+        if (sched)
+                sched->first_packet = urb->error_count;
+        goto use_start;
 
+ do_ASAP:
+        /* Use the first slot after "next" */
+        start = next + ((start - next) & (period - 1));
+
+ use_start:
         /* Tried to schedule too far into the future? */
-        if (unlikely(start - base + span - period >= mod)) {
+        if (unlikely(start + span - period >= mod + wrap)) {
                 ehci_dbg(ehci, "request %p would overflow (%u+%u >= %u)\n",
-                                urb, start - base, span - period, mod);
+                                urb, start, span - period, mod + wrap);
                 status = -EFBIG;
                 goto fail;
         }
 
-        stream->next_uframe = start & (mod - 1);
+        start += base;
+        stream->next_uframe = (start + skip) & (mod - 1);
 
         /* report high speed start in uframes; full speed, in frames */
-        urb->start_frame = stream->next_uframe;
+        urb->start_frame = start & (mod - 1);
         if (!stream->highspeed)
                 urb->start_frame >>= 3;
 
         /* Make sure scan_isoc() sees these */
         if (ehci->isoc_count == 0)
                 ehci->last_iso_frame = now >> 3;
-        return 0;
+        return status;
 
  fail:
         iso_sched_free(stream, sched);
@@ -1610,7 +1788,8 @@ static void itd_link_urb(
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill iTDs uframe by uframe */
-        for (packet = 0, itd = NULL; packet < urb->number_of_packets; ) {
+        for (packet = iso_sched->first_packet, itd = NULL;
+                        packet < urb->number_of_packets;) {
                 if (itd == NULL) {
                         /* ASSERT:  we have all necessary itds */
                         // BUG_ON (list_empty (&iso_sched->td_list));
@@ -1630,7 +1809,7 @@ static void itd_link_urb(
 
                 itd_patch(ehci, itd, iso_sched, packet, uframe);
 
-                next_uframe += stream->interval;
+                next_uframe += stream->uperiod;
                 next_uframe &= mod - 1;
                 packet++;
 
@@ -1770,9 +1949,9 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
                 ehci_dbg (ehci, "can't get iso stream\n");
                 return -ENOMEM;
         }
-        if (unlikely (urb->interval != stream->interval)) {
+        if (unlikely(urb->interval != stream->uperiod)) {
                 ehci_dbg (ehci, "can't change iso interval %d --> %d\n",
-                        stream->interval, urb->interval);
+                        stream->uperiod, urb->interval);
                 goto done;
         }
 
@@ -1804,10 +1983,14 @@ static int itd_submit (struct ehci_hcd *ehci, struct urb *urb,
         if (unlikely(status))
                 goto done_not_linked;
         status = iso_stream_schedule(ehci, urb, stream);
-        if (likely (status == 0))
+        if (likely(status == 0)) {
                 itd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
-        else
+        } else if (status > 0) {
+                status = 0;
+                ehci_urb_done(ehci, urb, 0);
+        } else {
                 usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+        }
  done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
  done:
@@ -1833,7 +2016,7 @@ sitd_sched_init(
         dma_addr_t      dma = urb->transfer_dma;
 
         /* how many frames are needed for these transfers */
-        iso_sched->span = urb->number_of_packets * stream->interval;
+        iso_sched->span = urb->number_of_packets * stream->ps.period;
 
         /* figure out per-frame sitd fields that we'll need later
          * when we fit new sitds into the schedule.
@@ -1925,7 +2108,7 @@ sitd_urb_transaction (
 
                 memset (sitd, 0, sizeof *sitd);
                 sitd->sitd_dma = sitd_dma;
-                sitd->frame = 9999;             /* an invalid value */
+                sitd->frame = NO_FRAME;
                 list_add (&sitd->sitd_list, &iso_sched->td_list);
         }
 
@@ -2008,7 +2191,7 @@ static void sitd_link_urb(
         ehci_to_hcd(ehci)->self.bandwidth_isoc_reqs++;
 
         /* fill sITDs frame by frame */
-        for (packet = 0, sitd = NULL;
+        for (packet = sched->first_packet, sitd = NULL;
                         packet < urb->number_of_packets;
                         packet++) {
 
@@ -2027,7 +2210,7 @@ static void sitd_link_urb(
                 sitd_link(ehci, (next_uframe >> 3) & (ehci->periodic_size - 1),
                                 sitd);
 
-                next_uframe += stream->interval << 3;
+                next_uframe += stream->uperiod;
         }
         stream->next_uframe = next_uframe & (mod - 1);
 
@@ -2146,9 +2329,9 @@ static int sitd_submit (struct ehci_hcd *ehci, struct urb *urb,
                 ehci_dbg (ehci, "can't get iso stream\n");
                 return -ENOMEM;
         }
-        if (urb->interval != stream->interval) {
+        if (urb->interval != stream->ps.period) {
                 ehci_dbg (ehci, "can't change iso interval %d --> %d\n",
-                        stream->interval, urb->interval);
+                        stream->ps.period, urb->interval);
                 goto done;
         }
 
@@ -2178,10 +2361,14 @@ static int sitd_submit (struct ehci_hcd *ehci, struct urb *urb,
         if (unlikely(status))
                 goto done_not_linked;
         status = iso_stream_schedule(ehci, urb, stream);
-        if (status == 0)
+        if (likely(status == 0)) {
                 sitd_link_urb (ehci, urb, ehci->periodic_size << 3, stream);
-        else
+        } else if (status > 0) {
+                status = 0;
+                ehci_urb_done(ehci, urb, 0);
+        } else {
                 usb_hcd_unlink_urb_from_ep(ehci_to_hcd(ehci), urb);
+        }
  done_not_linked:
         spin_unlock_irqrestore (&ehci->lock, flags);
  done:
@@ -2259,7 +2446,8 @@ restart:
                                     q.itd->hw_next != EHCI_LIST_END(ehci))
                                         *hw_p = q.itd->hw_next;
                                 else
-                                        *hw_p = ehci->dummy->qh_dma;
+                                        *hw_p = cpu_to_hc32(ehci,
+                                                        ehci->dummy->qh_dma);
                                 type = Q_NEXT_TYPE(ehci, q.itd->hw_next);
                                 wmb();
                                 modified = itd_complete (ehci, q.itd);
@@ -2294,7 +2482,8 @@ restart:
                                     q.sitd->hw_next != EHCI_LIST_END(ehci))
                                         *hw_p = q.sitd->hw_next;
                                 else
-                                        *hw_p = ehci->dummy->qh_dma;
+                                        *hw_p = cpu_to_hc32(ehci,
+                                                        ehci->dummy->qh_dma);
                                 type = Q_NEXT_TYPE(ehci, q.sitd->hw_next);
                                 wmb();
                                 modified = sitd_complete (ehci, q.sitd);
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 1cf0adba3fc8..ee6f9ffaa0e7 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -81,10 +81,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail;
 
         usbh_clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(usbh_clk)) {
diff --git a/drivers/usb/host/ehci-sysfs.c b/drivers/usb/host/ehci-sysfs.c
index 14ced00ba220..f6459dfb6f54 100644
--- a/drivers/usb/host/ehci-sysfs.c
+++ b/drivers/usb/host/ehci-sysfs.c
@@ -97,8 +97,7 @@ static ssize_t store_uframe_periodic_max(struct device *dev,
 {
         struct ehci_hcd         *ehci;
         unsigned                uframe_periodic_max;
-        unsigned                frame, uframe;
-        unsigned short          allocated_max;
+        unsigned                uframe;
         unsigned long           flags;
         ssize_t                 ret;
 
@@ -122,16 +121,14 @@ static ssize_t store_uframe_periodic_max(struct device *dev,
 
         /*
          * for request to decrease max periodic bandwidth, we have to check
-         * every microframe in the schedule to see whether the decrease is
-         * possible.
+         * to see whether the decrease is possible.
          */
         if (uframe_periodic_max < ehci->uframe_periodic_max) {
-                allocated_max = 0;
+                u8              allocated_max = 0;
 
-                for (frame = 0; frame < ehci->periodic_size; ++frame)
-                        for (uframe = 0; uframe < 7; ++uframe)
-                                allocated_max = max(allocated_max,
-                                                    periodic_usecs (ehci, frame, uframe));
+                for (uframe = 0; uframe < EHCI_BANDWIDTH_SIZE; ++uframe)
+                        allocated_max = max(allocated_max,
+                                        ehci->bandwidth[uframe]);
 
                 if (allocated_max > uframe_periodic_max) {
                         ehci_info(ehci,
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 78fa76da3324..b9fd0396011e 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -362,10 +362,9 @@ static int tegra_ehci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         hcd = usb_create_hcd(&tegra_ehci_hc_driver, &pdev->dev,
                                         dev_name(&pdev->dev));
@@ -388,7 +387,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 
         err = clk_prepare_enable(tegra->clk);
         if (err)
-                goto cleanup_clk_get;
+                goto cleanup_hcd_create;
 
         tegra_periph_reset_assert(tegra->clk);
         udelay(1);
@@ -465,8 +464,6 @@ cleanup_phy:
         usb_phy_shutdown(hcd->phy);
 cleanup_clk_en:
         clk_disable_unprepare(tegra->clk);
-cleanup_clk_get:
-        clk_put(tegra->clk);
 cleanup_hcd_create:
         usb_put_hcd(hcd);
         return err;
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index 1c370dfbee0d..cdad8438c02b 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -11,13 +11,28 @@
  *
  */
 
+#include <linux/dma-mapping.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ehci.h"
 
 /* enable phy0 and phy1 for w90p910 */
 #define ENPHY           (0x01<<8)
 #define PHY0_CTR        (0xA4)
 #define PHY1_CTR        (0xA8)
 
+#define DRIVER_DESC "EHCI w90x900 driver"
+
+static const char hcd_name[] = "ehci-w90x900 ";
+
+static struct hc_driver __read_mostly ehci_w90x900_hc_driver;
+
 static int usb_w90x900_probe(const struct hc_driver *driver,
                       struct platform_device *pdev)
 {
@@ -90,8 +105,8 @@ err1:
         return retval;
 }
 
-static
-void usb_w90x900_remove(struct usb_hcd *hcd, struct platform_device *pdev)
+static void usb_w90x900_remove(struct usb_hcd *hcd,
+                        struct platform_device *pdev)
 {
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
@@ -99,54 +114,6 @@ void usb_w90x900_remove(struct usb_hcd *hcd, struct platform_device *pdev)
         usb_put_hcd(hcd);
 }
 
-static const struct hc_driver ehci_w90x900_hc_driver = {
-        .description = hcd_name,
-        .product_desc = "Nuvoton w90x900 EHCI Host Controller",
-        .hcd_priv_size = sizeof(struct ehci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq = ehci_irq,
-        .flags = HCD_USB2|HCD_MEMORY|HCD_BH,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset = ehci_setup,
-        .start = ehci_run,
-
-        .stop = ehci_stop,
-        .shutdown = ehci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue = ehci_urb_enqueue,
-        .urb_dequeue = ehci_urb_dequeue,
-        .endpoint_disable = ehci_endpoint_disable,
-        .endpoint_reset = ehci_endpoint_reset,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number = ehci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data = ehci_hub_status_data,
-        .hub_control = ehci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend = ehci_bus_suspend,
-        .bus_resume = ehci_bus_resume,
-#endif
-        .relinquish_port        = ehci_relinquish_port,
-        .port_handed_over       = ehci_port_handed_over,
-
-        .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
-};
-
 static int ehci_w90x900_probe(struct platform_device *pdev)
 {
         if (usb_disabled())
@@ -173,7 +140,25 @@ static struct platform_driver ehci_hcd_w90x900_driver = {
         },
 };
 
+static int __init ehci_w90X900_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ehci_init_driver(&ehci_w90x900_hc_driver, NULL);
+        return platform_driver_register(&ehci_hcd_w90x900_driver);
+}
+module_init(ehci_w90X900_init);
+
+static void __exit ehci_w90X900_cleanup(void)
+{
+        platform_driver_unregister(&ehci_hcd_w90x900_driver);
+}
+module_exit(ehci_w90X900_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
-MODULE_DESCRIPTION("w90p910 usb ehci driver!");
-MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:w90p910-ehci");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 291db7d09f22..e8f41c5e771b 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -54,6 +54,28 @@ struct ehci_stats {
         unsigned long           unlink;
 };
 
+/*
+ * Scheduling and budgeting information for periodic transfers, for both
+ * high-speed devices and full/low-speed devices lying behind a TT.
+ */
+struct ehci_per_sched {
+        struct usb_device       *udev;          /* access to the TT */
+        struct usb_host_endpoint *ep;
+        struct list_head        ps_list;        /* node on ehci_tt's ps_list */
+        u16                     tt_usecs;       /* time on the FS/LS bus */
+        u16                     cs_mask;        /* C-mask and S-mask bytes */
+        u16                     period;         /* actual period in frames */
+        u16                     phase;          /* actual phase, frame part */
+        u8                      bw_phase;       /* same, for bandwidth
+                                                   reservation */
+        u8                      phase_uf;       /* uframe part of the phase */
+        u8                      usecs, c_usecs; /* times on the HS bus */
+        u8                      bw_uperiod;     /* period in microframes, for
+                                                   bandwidth reservation */
+        u8                      bw_period;      /* same, in frames */
+};
+#define NO_FRAME        29999                   /* frame not assigned yet */
+
 /* ehci_hcd->lock guards shared data against other CPUs:
  *   ehci_hcd:  async, unlink, periodic (and shadow), ...
  *   usb_host_endpoint: hcpriv
@@ -230,6 +252,15 @@ struct ehci_hcd {			/* one per controller */
         struct dentry           *debug_dir;
 #endif
 
+        /* bandwidth usage */
+#define EHCI_BANDWIDTH_SIZE     64
+#define EHCI_BANDWIDTH_FRAMES   (EHCI_BANDWIDTH_SIZE >> 3)
+        u8                      bandwidth[EHCI_BANDWIDTH_SIZE];
+                                                /* us allocated per uframe */
+        u8                      tt_budget[EHCI_BANDWIDTH_SIZE];
+                                                /* us budgeted per uframe */
+        struct list_head        tt_list;
+
         /* platform-specific data -- must come last */
         unsigned long           priv[0] __aligned(sizeof(s64));
 };
@@ -385,6 +416,7 @@ struct ehci_qh {
         struct list_head        intr_node;      /* list of intr QHs */
         struct ehci_qtd         *dummy;
         struct list_head        unlink_node;
+        struct ehci_per_sched   ps;             /* scheduling info */
 
         unsigned                unlink_cycle;
 
@@ -398,16 +430,8 @@ struct ehci_qh {
         u8                      xacterrs;       /* XactErr retry counter */
 #define QH_XACTERR_MAX          32              /* XactErr retry limit */
 
-        /* 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 */
         unsigned                is_out:1;       /* bulk or intr OUT */
         unsigned                clearing_tt:1;  /* Clear-TT-Buf in progress */
         unsigned                dequeue_during_giveback:1;
@@ -434,6 +458,7 @@ struct ehci_iso_packet {
 struct ehci_iso_sched {
         struct list_head        td_list;
         unsigned                span;
+        unsigned                first_packet;
         struct ehci_iso_packet  packet [0];
 };
 
@@ -449,22 +474,17 @@ struct ehci_iso_stream {
         u8                      highspeed;
         struct list_head        td_list;        /* queued itds/sitds */
         struct list_head        free_list;      /* list of unused itds/sitds */
-        struct usb_device       *udev;
-        struct usb_host_endpoint *ep;
 
         /* output of (re)scheduling */
-        int                     next_uframe;
+        struct ehci_per_sched   ps;             /* scheduling info */
+        unsigned                next_uframe;
         __hc32                  splits;
 
         /* the rest is derived from the endpoint descriptor,
-         * trusting urb->interval == f(epdesc->bInterval) and
          * including the extra info for hw_bufp[0..2]
          */
-        u8                      usecs, c_usecs;
-        u16                     interval;
-        u16                     tt_usecs;
+        u16                     uperiod;        /* period in uframes */
         u16                     maxp;
-        u16                     raw_mask;
         unsigned                bandwidth;
 
         /* This is used to initialize iTD's hw_bufp fields */
@@ -579,6 +599,35 @@ struct ehci_fstn {
 
 /*-------------------------------------------------------------------------*/
 
+/*
+ * USB-2.0 Specification Sections 11.14 and 11.18
+ * Scheduling and budgeting split transactions using TTs
+ *
+ * A hub can have a single TT for all its ports, or multiple TTs (one for each
+ * port).  The bandwidth and budgeting information for the full/low-speed bus
+ * below each TT is self-contained and independent of the other TTs or the
+ * high-speed bus.
+ *
+ * "Bandwidth" refers to the number of microseconds on the FS/LS bus allocated
+ * to an interrupt or isochronous endpoint for each frame.  "Budget" refers to
+ * the best-case estimate of the number of full-speed bytes allocated to an
+ * endpoint for each microframe within an allocated frame.
+ *
+ * Removal of an endpoint invalidates a TT's budget.  Instead of trying to
+ * keep an up-to-date record, we recompute the budget when it is needed.
+ */
+
+struct ehci_tt {
+        u16                     bandwidth[EHCI_BANDWIDTH_FRAMES];
+
+        struct list_head        tt_list;        /* List of all ehci_tt's */
+        struct list_head        ps_list;        /* Items using this TT */
+        struct usb_tt           *usb_tt;
+        int                     tt_port;        /* TT port number */
+};
+
+/*-------------------------------------------------------------------------*/
+
 /* Prepare the PORTSC wakeup flags during controller suspend/resume */
 
 #define ehci_prepare_ports_for_controller_suspend(ehci, do_wakeup)      \
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 0b46542591ff..0551c0af0fd1 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -26,6 +26,8 @@
 #include <linux/io.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
 #include <linux/slab.h>
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index fce13bcc4a3e..55486bd23cf1 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -412,7 +412,7 @@ struct debug_buffer {
                         tmp = 'h'; break; \
                 default:                \
                         tmp = '?'; break; \
-                }; tmp; })
+                } tmp; })
 
 static inline char token_mark(struct fotg210_hcd *fotg210, __hc32 token)
 {
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index cfbff7161828..abd5050a4899 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -24,7 +24,7 @@ struct fsl_usb2_dev_data {
         enum fsl_usb2_operating_modes op_mode;  /* operating mode */
 };
 
-struct fsl_usb2_dev_data dr_mode_data[] = {
+static struct fsl_usb2_dev_data dr_mode_data[] = {
         {
                 .dr_mode = "host",
                 .drivers = { "fsl-ehci", NULL, NULL, },
@@ -42,7 +42,7 @@ struct fsl_usb2_dev_data dr_mode_data[] = {
         },
 };
 
-struct fsl_usb2_dev_data *get_dr_mode_data(struct device_node *np)
+static struct fsl_usb2_dev_data *get_dr_mode_data(struct device_node *np)
 {
         const unsigned char *prop;
         int i;
@@ -75,7 +75,7 @@ static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
         return FSL_USB2_PHY_NONE;
 }
 
-struct platform_device *fsl_usb2_device_register(
+static struct platform_device *fsl_usb2_device_register(
                                         struct platform_device *ofdev,
                                         struct fsl_usb2_platform_data *pdata,
                                         const char *name, int id)
@@ -260,6 +260,7 @@ int fsl_usb2_mpc5121_init(struct platform_device *pdev)
 {
         struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
         struct clk *clk;
+        int err;
         char clk_name[10];
         int base, clk_num;
 
@@ -272,13 +273,16 @@ int fsl_usb2_mpc5121_init(struct platform_device *pdev)
                 return -ENODEV;
 
         snprintf(clk_name, sizeof(clk_name), "usb%d_clk", clk_num);
-        clk = clk_get(&pdev->dev, clk_name);
+        clk = devm_clk_get(pdev->dev.parent, clk_name);
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clk\n");
                 return PTR_ERR(clk);
         }
-
-        clk_enable(clk);
+        err = clk_prepare_enable(clk);
+        if (err) {
+                dev_err(&pdev->dev, "failed to enable clk\n");
+                return err;
+        }
         pdata->clk = clk;
 
         if (pdata->phy_mode == FSL_USB2_PHY_UTMI_WIDE) {
@@ -302,10 +306,8 @@ static void fsl_usb2_mpc5121_exit(struct platform_device *pdev)
 
         pdata->regs = NULL;
 
-        if (pdata->clk) {
-                clk_disable(pdata->clk);
-                clk_put(pdata->clk);
-        }
+        if (pdata->clk)
+                clk_disable_unprepare(pdata->clk);
 }
 
 static struct fsl_usb2_platform_data fsl_usb2_mpc5121_pd = {
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index 299253c826c7..e1c6d850a7e1 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -402,7 +402,7 @@ struct debug_buffer {
                 case QH_LOW_SPEED:  tmp = 'l'; break; \
                 case QH_HIGH_SPEED: tmp = 'h'; break; \
                 default: tmp = '?'; break; \
-                }; tmp; })
+                } tmp; })
 
 static inline char token_mark(struct fusbh200_hcd *fusbh200, __hc32 token)
 {
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index 5b86ffb88f1c..ada0a52797b1 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -199,10 +199,14 @@ static int hwahc_op_get_frame_number(struct usb_hcd *usb_hcd)
 {
         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
+        struct wahc *wa = &hwahc->wa;
 
-        dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
-                usb_hcd, hwahc);
-        return -ENOSYS;
+        /*
+         * We cannot query the HWA for the WUSB time since that requires sending
+         * a synchronous URB and this function can be called in_interrupt.
+         * Instead, query the USB frame number for our parent and use that.
+         */
+        return usb_get_current_frame_number(wa->usb_dev);
 }
 
 static int hwahc_op_urb_enqueue(struct usb_hcd *usb_hcd, struct urb *urb,
@@ -566,14 +570,10 @@ found:
                 goto error;
         }
         wa->wa_descr = wa_descr = (struct usb_wa_descriptor *) hdr;
-        /* Make LE fields CPU order */
-        wa_descr->bcdWAVersion = le16_to_cpu(wa_descr->bcdWAVersion);
-        wa_descr->wNumRPipes = le16_to_cpu(wa_descr->wNumRPipes);
-        wa_descr->wRPipeMaxBlock = le16_to_cpu(wa_descr->wRPipeMaxBlock);
-        if (wa_descr->bcdWAVersion > 0x0100)
+        if (le16_to_cpu(wa_descr->bcdWAVersion) > 0x0100)
                 dev_warn(dev, "Wire Adapter v%d.%d newer than groked v1.0\n",
-                         wa_descr->bcdWAVersion & 0xff00 >> 8,
-                         wa_descr->bcdWAVersion & 0x00ff);
+                         le16_to_cpu(wa_descr->bcdWAVersion) & 0xff00 >> 8,
+                         le16_to_cpu(wa_descr->bcdWAVersion) & 0x00ff);
         result = 0;
 error:
         return result;
@@ -679,7 +679,8 @@ static void hwahc_security_release(struct hwahc *hwahc)
         /* nothing to do here so far... */
 }
 
-static int hwahc_create(struct hwahc *hwahc, struct usb_interface *iface)
+static int hwahc_create(struct hwahc *hwahc, struct usb_interface *iface,
+        kernel_ulong_t quirks)
 {
         int result;
         struct device *dev = &iface->dev;
@@ -724,7 +725,7 @@ static int hwahc_create(struct hwahc *hwahc, struct usb_interface *iface)
                 dev_err(dev, "Can't create WUSB HC structures: %d\n", result);
                 goto error_wusbhc_create;
         }
-        result = wa_create(&hwahc->wa, iface);
+        result = wa_create(&hwahc->wa, iface, quirks);
         if (result < 0)
                 goto error_wa_create;
         return 0;
@@ -780,7 +781,7 @@ static int hwahc_probe(struct usb_interface *usb_iface,
         wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         hwahc = container_of(wusbhc, struct hwahc, wusbhc);
         hwahc_init(hwahc);
-        result = hwahc_create(hwahc, usb_iface);
+        result = hwahc_create(hwahc, usb_iface, id->driver_info);
         if (result < 0) {
                 dev_err(dev, "Cannot initialize internals: %d\n", result);
                 goto error_hwahc_create;
@@ -824,6 +825,12 @@ static void hwahc_disconnect(struct usb_interface *usb_iface)
 }
 
 static struct usb_device_id hwahc_id_table[] = {
+        /* Alereon 5310 */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5310, 0xe0, 0x02, 0x01),
+          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC },
+        /* Alereon 5611 */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x13dc, 0x5611, 0xe0, 0x02, 0x01),
+          .driver_info = WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC },
         /* FIXME: use class labels for this */
         { USB_INTERFACE_INFO(0xe0, 0x02, 0x01), },
         {},
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index 60a5de505ca1..adb01d950a16 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -824,13 +824,13 @@ static int imx21_hc_urb_enqueue_isoc(struct usb_hcd *hcd,
                         i = DIV_ROUND_UP(wrap_frame(
                                         cur_frame - urb->start_frame),
                                         urb->interval);
-                        if (urb->transfer_flags & URB_ISO_ASAP) {
+
+                        /* Treat underruns as if URB_ISO_ASAP was set */
+                        if ((urb->transfer_flags & URB_ISO_ASAP) ||
+                                        i >= urb->number_of_packets) {
                                 urb->start_frame = wrap_frame(urb->start_frame
                                                 + i * urb->interval);
                                 i = 0;
-                        } else if (i >= urb->number_of_packets) {
-                                ret = -EXDEV;
-                                goto alloc_dmem_failed;
                         }
                 }
         }
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 6f29abad6815..935a2dd367a8 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -2108,7 +2108,7 @@ static int isp1362_show(struct seq_file *s, void *unused)
                                    default:
                                            s = "?";
                                            break;
-                                   };
+                                   }
                                    s;}), ep->maxpacket) ;
                 list_for_each_entry(urb, &ep->hep->urb_list, urb_list) {
                         seq_printf(s, "  urb%p, %d/%d\n", urb,
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index caa3764a3407..418444ebb1b8 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -13,19 +13,24 @@
  */
 
 #include <linux/clk.h>
-#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
+#include <linux/platform_device.h>
 #include <linux/platform_data/atmel.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
 
 #include <mach/hardware.h>
 #include <asm/gpio.h>
 
 #include <mach/cpu.h>
 
-#ifndef CONFIG_ARCH_AT91
-#error "CONFIG_ARCH_AT91 must be defined."
-#endif
+
+#include "ohci.h"
 
 #define valid_port(index)       ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
 #define at91_for_each_port(index)       \
@@ -33,7 +38,17 @@
 
 /* interface, function and usb clocks; sometimes also an AHB clock */
 static struct clk *iclk, *fclk, *uclk, *hclk;
+/* interface and function clocks; sometimes also an AHB clock */
+
+#define DRIVER_DESC "OHCI Atmel driver"
+
+static const char hcd_name[] = "ohci-atmel";
+
+static struct hc_driver __read_mostly ohci_at91_hc_driver;
 static int clocked;
+static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
+                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
+static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
 
 extern int usb_disabled(void);
 
@@ -117,6 +132,8 @@ static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
 static int usb_hcd_at91_probe(const struct hc_driver *driver,
                         struct platform_device *pdev)
 {
+        struct at91_usbh_data *board;
+        struct ohci_hcd *ohci;
         int retval;
         struct usb_hcd *hcd = NULL;
 
@@ -177,8 +194,10 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
                 }
         }
 
+        board = hcd->self.controller->platform_data;
+        ohci = hcd_to_ohci(hcd);
+        ohci->num_ports = board->ports;
         at91_start_hc(pdev);
-        ohci_hcd_init(hcd_to_ohci(hcd));
 
         retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
         if (retval == 0)
@@ -238,36 +257,6 @@ static void usb_hcd_at91_remove(struct usb_hcd *hcd,
 }
 
 /*-------------------------------------------------------------------------*/
-
-static int
-ohci_at91_reset (struct usb_hcd *hcd)
-{
-        struct at91_usbh_data   *board = dev_get_platdata(hcd->self.controller);
-        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
-        int                     ret;
-
-        if ((ret = ohci_init(ohci)) < 0)
-                return ret;
-
-        ohci->num_ports = board->ports;
-        return 0;
-}
-
-static int
-ohci_at91_start (struct usb_hcd *hcd)
-{
-        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
-        int                     ret;
-
-        if ((ret = ohci_run(ohci)) < 0) {
-                dev_err(hcd->self.controller, "can't start %s\n",
-                        hcd->self.bus_name);
-                ohci_stop(hcd);
-                return ret;
-        }
-        return 0;
-}
-
 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
 {
         if (!valid_port(port))
@@ -297,8 +286,8 @@ static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
  */
 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
-        struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller);
-        int length = ohci_hub_status_data(hcd, buf);
+        struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
+        int length = orig_ohci_hub_status_data(hcd, buf);
         int port;
 
         at91_for_each_port(port) {
@@ -376,7 +365,8 @@ static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 break;
         }
 
-        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
+        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex + 1,
+                                buf, wLength);
         if (ret)
                 goto out;
 
@@ -430,51 +420,6 @@ static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
 /*-------------------------------------------------------------------------*/
 
-static const struct hc_driver ohci_at91_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "AT91 OHCI",
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                ohci_at91_reset,
-        .start =                ohci_at91_start,
-        .stop =                 ohci_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_at91_hub_status_data,
-        .hub_control =          ohci_at91_hub_control,
-#ifdef CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
-
-/*-------------------------------------------------------------------------*/
-
 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
 {
         struct platform_device *pdev = data;
@@ -524,7 +469,7 @@ MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
 static int ohci_at91_of_init(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
-        int i, gpio;
+        int i, gpio, ret;
         enum of_gpio_flags flags;
         struct at91_usbh_data   *pdata;
         u32 ports;
@@ -536,10 +481,9 @@ static int ohci_at91_of_init(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
@@ -703,7 +647,11 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
          * REVISIT: some boards will be able to turn VBUS off...
          */
         if (at91_suspend_entering_slow_clock()) {
-                ohci_usb_reset (ohci);
+                ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
+                ohci->hc_control &= OHCI_CTRL_RWC;
+                ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
+                ohci->rh_state = OHCI_RH_HALTED;
+
                 /* flush the writes */
                 (void) ohci_readl (ohci, &ohci->regs->control);
                 at91_stop_clock();
@@ -730,8 +678,6 @@ static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
 #define ohci_hcd_at91_drv_resume  NULL
 #endif
 
-MODULE_ALIAS("platform:at91_ohci");
-
 static struct platform_driver ohci_hcd_at91_driver = {
         .probe          = ohci_hcd_at91_drv_probe,
         .remove         = ohci_hcd_at91_drv_remove,
@@ -744,3 +690,40 @@ static struct platform_driver ohci_hcd_at91_driver = {
                 .of_match_table = of_match_ptr(at91_ohci_dt_ids),
         },
 };
+
+static int __init ohci_at91_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+        ohci_init_driver(&ohci_at91_hc_driver, NULL);
+
+        /*
+         * The Atmel HW has some unusual quirks, which require Atmel-specific
+         * workarounds. We override certain hc_driver functions here to
+         * achieve that. We explicitly do not enhance ohci_driver_overrides to
+         * allow this more easily, since this is an unusual case, and we don't
+         * want to encourage others to override these functions by making it
+         * too easy.
+         */
+
+        orig_ohci_hub_control = ohci_at91_hc_driver.hub_control;
+        orig_ohci_hub_status_data = ohci_at91_hc_driver.hub_status_data;
+
+        ohci_at91_hc_driver.hub_status_data     = ohci_at91_hub_status_data;
+        ohci_at91_hc_driver.hub_control         = ohci_at91_hub_control;
+
+        return platform_driver_register(&ohci_hcd_at91_driver);
+}
+module_init(ohci_at91_init);
+
+static void __exit ohci_at91_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_at91_driver);
+}
+module_exit(ohci_at91_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:at91_ohci");
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 31b81f9eacdc..3fca52ec02ac 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -17,7 +17,7 @@
         case PIPE_BULK:         temp = "bulk"; break; \
         case PIPE_INTERRUPT:    temp = "intr"; break; \
         default:                temp = "isoc"; break; \
-        }; temp;})
+        } temp;})
 #define pipestring(pipe) edstring(usb_pipetype(pipe))
 
 /* debug| print the main components of an URB
diff --git a/drivers/usb/host/ohci-ep93xx.c b/drivers/usb/host/ohci-ep93xx.c
deleted file mode 100644
index 84a20d5223b9..000000000000
--- a/drivers/usb/host/ohci-ep93xx.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
- * OHCI HCD (Host Controller Driver) for USB.
- *
- * (C) Copyright 1999 Roman Weissgaerber <weissg@vienna.at>
- * (C) Copyright 2000-2002 David Brownell <dbrownell@users.sourceforge.net>
- * (C) Copyright 2002 Hewlett-Packard Company
- *
- * Bus Glue for ep93xx.
- *
- * Written by Christopher Hoover <ch@hpl.hp.com>
- * Based on fragments of previous driver by Russell King et al.
- *
- * Modified for LH7A404 from ohci-sa1111.c
- *  by Durgesh Pattamatta <pattamattad@sharpsec.com>
- *
- * Modified for pxa27x from ohci-lh7a404.c
- *  by Nick Bane <nick@cecomputing.co.uk> 26-8-2004
- *
- * Modified for ep93xx from ohci-pxa27x.c
- *  by Lennert Buytenhek <buytenh@wantstofly.org> 28-2-2006
- *  Based on an earlier driver by Ray Lehtiniemi
- *
- * This file is licenced under the GPL.
- */
-
-#include <linux/clk.h>
-#include <linux/device.h>
-#include <linux/signal.h>
-#include <linux/platform_device.h>
-
-static struct clk *usb_host_clock;
-
-static int ohci_ep93xx_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        if ((ret = ohci_init(ohci)) < 0)
-                return ret;
-
-        if ((ret = ohci_run(ohci)) < 0) {
-                dev_err(hcd->self.controller, "can't start %s\n",
-                        hcd->self.bus_name);
-                ohci_stop(hcd);
-                return ret;
-        }
-
-        return 0;
-}
-
-static struct hc_driver ohci_ep93xx_hc_driver = {
-        .description            = hcd_name,
-        .product_desc           = "EP93xx OHCI",
-        .hcd_priv_size          = sizeof(struct ohci_hcd),
-        .irq                    = ohci_irq,
-        .flags                  = HCD_USB11 | HCD_MEMORY,
-        .start                  = ohci_ep93xx_start,
-        .stop                   = ohci_stop,
-        .shutdown               = ohci_shutdown,
-        .urb_enqueue            = ohci_urb_enqueue,
-        .urb_dequeue            = ohci_urb_dequeue,
-        .endpoint_disable       = ohci_endpoint_disable,
-        .get_frame_number       = ohci_get_frame,
-        .hub_status_data        = ohci_hub_status_data,
-        .hub_control            = ohci_hub_control,
-#ifdef CONFIG_PM
-        .bus_suspend            = ohci_bus_suspend,
-        .bus_resume             = ohci_bus_resume,
-#endif
-        .start_port_reset       = ohci_start_port_reset,
-};
-
-static int ohci_hcd_ep93xx_drv_probe(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd;
-        struct resource *res;
-        int irq;
-        int ret;
-
-        if (usb_disabled())
-                return -ENODEV;
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0)
-                return irq;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -ENXIO;
-
-        hcd = usb_create_hcd(&ohci_ep93xx_hc_driver, &pdev->dev, "ep93xx");
-        if (!hcd)
-                return -ENOMEM;
-
-        hcd->rsrc_start = res->start;
-        hcd->rsrc_len = resource_size(res);
-
-        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(hcd->regs)) {
-                ret = PTR_ERR(hcd->regs);
-                goto err_put_hcd;
-        }
-
-        usb_host_clock = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(usb_host_clock)) {
-                ret = PTR_ERR(usb_host_clock);
-                goto err_put_hcd;
-        }
-
-        clk_enable(usb_host_clock);
-
-        ohci_hcd_init(hcd_to_ohci(hcd));
-
-        ret = usb_add_hcd(hcd, irq, 0);
-        if (ret)
-                goto err_clk_disable;
-
-        return 0;
-
-err_clk_disable:
-        clk_disable(usb_host_clock);
-err_put_hcd:
-        usb_put_hcd(hcd);
-
-        return ret;
-}
-
-static int ohci_hcd_ep93xx_drv_remove(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
-
-        usb_remove_hcd(hcd);
-        clk_disable(usb_host_clock);
-        usb_put_hcd(hcd);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int ohci_hcd_ep93xx_drv_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-
-        if (time_before(jiffies, ohci->next_statechange))
-                msleep(5);
-        ohci->next_statechange = jiffies;
-
-        clk_disable(usb_host_clock);
-        return 0;
-}
-
-static int ohci_hcd_ep93xx_drv_resume(struct platform_device *pdev)
-{
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-
-        if (time_before(jiffies, ohci->next_statechange))
-                msleep(5);
-        ohci->next_statechange = jiffies;
-
-        clk_enable(usb_host_clock);
-
-        ohci_resume(hcd, false);
-        return 0;
-}
-#endif
-
-
-static struct platform_driver ohci_hcd_ep93xx_driver = {
-        .probe          = ohci_hcd_ep93xx_drv_probe,
-        .remove         = ohci_hcd_ep93xx_drv_remove,
-        .shutdown       = usb_hcd_platform_shutdown,
-#ifdef CONFIG_PM
-        .suspend        = ohci_hcd_ep93xx_drv_suspend,
-        .resume         = ohci_hcd_ep93xx_drv_resume,
-#endif
-        .driver         = {
-                .name   = "ep93xx-ohci",
-                .owner  = THIS_MODULE,
-        },
-};
-
-MODULE_ALIAS("platform:ep93xx-ohci");
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index dc6ee9adacf5..91ec9b2cd378 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -12,98 +12,55 @@
  */
 
 #include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
-#include <linux/platform_data/usb-ohci-exynos.h>
 #include <linux/usb/phy.h>
 #include <linux/usb/samsung_usb_phy.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/otg.h>
+
+#include "ohci.h"
+
+#define DRIVER_DESC "OHCI EXYNOS driver"
+
+static const char hcd_name[] = "ohci-exynos";
+static struct hc_driver __read_mostly exynos_ohci_hc_driver;
+
+#define to_exynos_ohci(hcd) (struct exynos_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
 
 struct exynos_ohci_hcd {
-        struct device *dev;
-        struct usb_hcd *hcd;
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
-        struct exynos4_ohci_platdata *pdata;
 };
 
-static void exynos_ohci_phy_enable(struct exynos_ohci_hcd *exynos_ohci)
+static void exynos_ohci_phy_enable(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
 
         if (exynos_ohci->phy)
                 usb_phy_init(exynos_ohci->phy);
-        else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_init)
-                exynos_ohci->pdata->phy_init(pdev, USB_PHY_TYPE_HOST);
 }
 
-static void exynos_ohci_phy_disable(struct exynos_ohci_hcd *exynos_ohci)
+static void exynos_ohci_phy_disable(struct platform_device *pdev)
 {
-        struct platform_device *pdev = to_platform_device(exynos_ohci->dev);
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
 
         if (exynos_ohci->phy)
                 usb_phy_shutdown(exynos_ohci->phy);
-        else if (exynos_ohci->pdata && exynos_ohci->pdata->phy_exit)
-                exynos_ohci->pdata->phy_exit(pdev, USB_PHY_TYPE_HOST);
-}
-
-static int ohci_exynos_reset(struct usb_hcd *hcd)
-{
-        return ohci_init(hcd_to_ohci(hcd));
-}
-
-static int ohci_exynos_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        ohci_dbg(ohci, "ohci_exynos_start, ohci:%p", ohci);
-
-        ret = ohci_run(ohci);
-        if (ret < 0) {
-                dev_err(hcd->self.controller, "can't start %s\n",
-                        hcd->self.bus_name);
-                ohci_stop(hcd);
-                return ret;
-        }
-
-        return 0;
 }
 
-static const struct hc_driver exynos_ohci_hc_driver = {
-        .description            = hcd_name,
-        .product_desc           = "EXYNOS OHCI Host Controller",
-        .hcd_priv_size          = sizeof(struct ohci_hcd),
-
-        .irq                    = ohci_irq,
-        .flags                  = HCD_MEMORY|HCD_USB11,
-
-        .reset                  = ohci_exynos_reset,
-        .start                  = ohci_exynos_start,
-        .stop                   = ohci_stop,
-        .shutdown               = ohci_shutdown,
-
-        .get_frame_number       = ohci_get_frame,
-
-        .urb_enqueue            = ohci_urb_enqueue,
-        .urb_dequeue            = ohci_urb_dequeue,
-        .endpoint_disable       = ohci_endpoint_disable,
-
-        .hub_status_data        = ohci_hub_status_data,
-        .hub_control            = ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend            = ohci_bus_suspend,
-        .bus_resume             = ohci_bus_resume,
-#endif
-        .start_port_reset       = ohci_start_port_reset,
-};
-
 static int exynos_ohci_probe(struct platform_device *pdev)
 {
-        struct exynos4_ohci_platdata *pdata = dev_get_platdata(&pdev->dev);
         struct exynos_ohci_hcd *exynos_ohci;
         struct usb_hcd *hcd;
-        struct ohci_hcd *ohci;
         struct resource *res;
         struct usb_phy *phy;
         int irq;
@@ -114,15 +71,18 @@ static int exynos_ohci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-
-        exynos_ohci = devm_kzalloc(&pdev->dev, sizeof(struct exynos_ohci_hcd),
-                                        GFP_KERNEL);
-        if (!exynos_ohci)
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
+
+        hcd = usb_create_hcd(&exynos_ohci_hc_driver,
+                                &pdev->dev, dev_name(&pdev->dev));
+        if (!hcd) {
+                dev_err(&pdev->dev, "Unable to create HCD\n");
                 return -ENOMEM;
+        }
+
+        exynos_ohci = to_exynos_ohci(hcd);
 
         if (of_device_is_compatible(pdev->dev.of_node,
                                         "samsung,exynos5440-ohci"))
@@ -130,30 +90,15 @@ static int exynos_ohci_probe(struct platform_device *pdev)
 
         phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
         if (IS_ERR(phy)) {
-                /* Fallback to pdata */
-                if (!pdata) {
-                        dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                        return -EPROBE_DEFER;
-                } else {
-                        exynos_ohci->pdata = pdata;
-                }
+                usb_put_hcd(hcd);
+                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
+                return -EPROBE_DEFER;
         } else {
                 exynos_ohci->phy = phy;
                 exynos_ohci->otg = phy->otg;
         }
 
 skip_phy:
-
-        exynos_ohci->dev = &pdev->dev;
-
-        hcd = usb_create_hcd(&exynos_ohci_hc_driver, &pdev->dev,
-                                        dev_name(&pdev->dev));
-        if (!hcd) {
-                dev_err(&pdev->dev, "Unable to create HCD\n");
-                return -ENOMEM;
-        }
-
-        exynos_ohci->hcd = hcd;
         exynos_ohci->clk = devm_clk_get(&pdev->dev, "usbhost");
 
         if (IS_ERR(exynos_ohci->clk)) {
@@ -190,26 +135,21 @@ skip_phy:
         }
 
         if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg,
-                                        &exynos_ohci->hcd->self);
+                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_enable(exynos_ohci);
+        platform_set_drvdata(pdev, hcd);
 
-        ohci = hcd_to_ohci(hcd);
-        ohci_hcd_init(ohci);
+        exynos_ohci_phy_enable(pdev);
 
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto fail_add_hcd;
         }
-
-        platform_set_drvdata(pdev, exynos_ohci);
-
         return 0;
 
 fail_add_hcd:
-        exynos_ohci_phy_disable(exynos_ohci);
+        exynos_ohci_phy_disable(pdev);
 fail_io:
         clk_disable_unprepare(exynos_ohci->clk);
 fail_clk:
@@ -219,16 +159,15 @@ fail_clk:
 
 static int exynos_ohci_remove(struct platform_device *pdev)
 {
-        struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = exynos_ohci->hcd;
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
 
         usb_remove_hcd(hcd);
 
         if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg,
-                                        &exynos_ohci->hcd->self);
+                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(exynos_ohci);
+        exynos_ohci_phy_disable(pdev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -239,8 +178,7 @@ static int exynos_ohci_remove(struct platform_device *pdev)
 
 static void exynos_ohci_shutdown(struct platform_device *pdev)
 {
-        struct exynos_ohci_hcd *exynos_ohci = platform_get_drvdata(pdev);
-        struct usb_hcd *hcd = exynos_ohci->hcd;
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         if (hcd->driver->shutdown)
                 hcd->driver->shutdown(hcd);
@@ -249,9 +187,10 @@ static void exynos_ohci_shutdown(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int exynos_ohci_suspend(struct device *dev)
 {
-        struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
-        struct usb_hcd *hcd = exynos_ohci->hcd;
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        struct platform_device *pdev = to_platform_device(dev);
         unsigned long flags;
         int rc = 0;
 
@@ -271,10 +210,9 @@ static int exynos_ohci_suspend(struct device *dev)
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg,
-                                        &exynos_ohci->hcd->self);
+                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(exynos_ohci);
+        exynos_ohci_phy_disable(pdev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -286,16 +224,16 @@ fail:
 
 static int exynos_ohci_resume(struct device *dev)
 {
-        struct exynos_ohci_hcd *exynos_ohci = dev_get_drvdata(dev);
-        struct usb_hcd *hcd = exynos_ohci->hcd;
+        struct usb_hcd *hcd                     = dev_get_drvdata(dev);
+        struct exynos_ohci_hcd *exynos_ohci     = to_exynos_ohci(hcd);
+        struct platform_device *pdev            = to_platform_device(dev);
 
         clk_prepare_enable(exynos_ohci->clk);
 
         if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg,
-                                        &exynos_ohci->hcd->self);
+                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_enable(exynos_ohci);
+        exynos_ohci_phy_enable(pdev);
 
         ohci_resume(hcd, false);
 
@@ -306,6 +244,10 @@ static int exynos_ohci_resume(struct device *dev)
 #define exynos_ohci_resume      NULL
 #endif
 
+static const struct ohci_driver_overrides exynos_overrides __initconst = {
+        .extra_priv_size =      sizeof(struct exynos_ohci_hcd),
+};
+
 static const struct dev_pm_ops exynos_ohci_pm_ops = {
         .suspend        = exynos_ohci_suspend,
         .resume         = exynos_ohci_resume,
@@ -331,6 +273,23 @@ static struct platform_driver exynos_ohci_driver = {
                 .of_match_table = of_match_ptr(exynos_ohci_match),
         }
 };
+static int __init ohci_exynos_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+        ohci_init_driver(&exynos_ohci_hc_driver, &exynos_overrides);
+        return platform_driver_register(&exynos_ohci_driver);
+}
+module_init(ohci_exynos_init);
+
+static void __exit ohci_exynos_cleanup(void)
+{
+        platform_driver_unregister(&exynos_ohci_driver);
+}
+module_exit(ohci_exynos_cleanup);
 
 MODULE_ALIAS("platform:exynos-ohci");
 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 8f6b695af6a4..8ada13f8dde2 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -216,31 +216,26 @@ static int ohci_urb_enqueue (
                         frame &= ~(ed->interval - 1);
                         frame |= ed->branch;
                         urb->start_frame = frame;
+                        ed->last_iso = frame + ed->interval * (size - 1);
                 }
         } else if (ed->type == PIPE_ISOCHRONOUS) {
                 u16     next = ohci_frame_no(ohci) + 1;
                 u16     frame = ed->last_iso + ed->interval;
+                u16     length = ed->interval * (size - 1);
 
                 /* Behind the scheduling threshold? */
                 if (unlikely(tick_before(frame, next))) {
 
-                        /* USB_ISO_ASAP: Round up to the first available slot */
+                        /* URB_ISO_ASAP: Round up to the first available slot */
                         if (urb->transfer_flags & URB_ISO_ASAP) {
                                 frame += (next - frame + ed->interval - 1) &
                                                 -ed->interval;
 
                         /*
-                         * Not ASAP: Use the next slot in the stream.  If
-                         * the entire URB falls before the threshold, fail.
+                         * Not ASAP: Use the next slot in the stream,
+                         * no matter what.
                          */
                         } else {
-                                if (tick_before(frame + ed->interval *
-                                        (urb->number_of_packets - 1), next)) {
-                                        retval = -EXDEV;
-                                        usb_hcd_unlink_urb_from_ep(hcd, urb);
-                                        goto fail;
-                                }
-
                                 /*
                                  * Some OHCI hardware doesn't handle late TDs
                                  * correctly.  After retiring them it proceeds
@@ -251,9 +246,16 @@ static int ohci_urb_enqueue (
                                 urb_priv->td_cnt = DIV_ROUND_UP(
                                                 (u16) (next - frame),
                                                 ed->interval);
+                                if (urb_priv->td_cnt >= urb_priv->length) {
+                                        ++urb_priv->td_cnt;     /* Mark it */
+                                        ohci_dbg(ohci, "iso underrun %p (%u+%u < %u)\n",
+                                                        urb, frame, length,
+                                                        next);
+                                }
                         }
                 }
                 urb->start_frame = frame;
+                ed->last_iso = frame + length;
         }
 
         /* fill the TDs and link them to the ed; and
@@ -1159,10 +1161,12 @@ void ohci_init_driver(struct hc_driver *drv,
         /* Copy the generic table to drv and then apply the overrides */
         *drv = ohci_hc_driver;
 
-        drv->product_desc = over->product_desc;
-        drv->hcd_priv_size += over->extra_priv_size;
-        if (over->reset)
-                drv->reset = over->reset;
+        if (over) {
+                drv->product_desc = over->product_desc;
+                drv->hcd_priv_size += over->extra_priv_size;
+                if (over->reset)
+                        drv->reset = over->reset;
+        }
 }
 EXPORT_SYMBOL_GPL(ohci_init_driver);
 
@@ -1177,46 +1181,6 @@ MODULE_LICENSE ("GPL");
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
 
-#if defined(CONFIG_ARCH_S3C24XX) || defined(CONFIG_ARCH_S3C64XX)
-#include "ohci-s3c2410.c"
-#define S3C2410_PLATFORM_DRIVER ohci_hcd_s3c2410_driver
-#endif
-
-#ifdef CONFIG_USB_OHCI_EXYNOS
-#include "ohci-exynos.c"
-#define EXYNOS_PLATFORM_DRIVER  exynos_ohci_driver
-#endif
-
-#ifdef CONFIG_USB_OHCI_HCD_OMAP1
-#include "ohci-omap.c"
-#define OMAP1_PLATFORM_DRIVER   ohci_hcd_omap_driver
-#endif
-
-#ifdef CONFIG_USB_OHCI_HCD_OMAP3
-#include "ohci-omap3.c"
-#define OMAP3_PLATFORM_DRIVER   ohci_hcd_omap3_driver
-#endif
-
-#if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
-#include "ohci-pxa27x.c"
-#define PLATFORM_DRIVER         ohci_hcd_pxa27x_driver
-#endif
-
-#ifdef CONFIG_ARCH_EP93XX
-#include "ohci-ep93xx.c"
-#define EP93XX_PLATFORM_DRIVER  ohci_hcd_ep93xx_driver
-#endif
-
-#ifdef CONFIG_ARCH_AT91
-#include "ohci-at91.c"
-#define AT91_PLATFORM_DRIVER    ohci_hcd_at91_driver
-#endif
-
-#ifdef CONFIG_ARCH_LPC32XX
-#include "ohci-nxp.c"
-#define NXP_PLATFORM_DRIVER     usb_hcd_nxp_driver
-#endif
-
 #ifdef CONFIG_ARCH_DAVINCI_DA8XX
 #include "ohci-da8xx.c"
 #define DAVINCI_PLATFORM_DRIVER ohci_hcd_da8xx_driver
@@ -1227,11 +1191,6 @@ MODULE_LICENSE ("GPL");
 #define OF_PLATFORM_DRIVER      ohci_hcd_ppc_of_driver
 #endif
 
-#ifdef CONFIG_PLAT_SPEAR
-#include "ohci-spear.c"
-#define SPEAR_PLATFORM_DRIVER   spear_ohci_hcd_driver
-#endif
-
 #ifdef CONFIG_PPC_PS3
 #include "ohci-ps3.c"
 #define PS3_SYSTEM_BUS_DRIVER   ps3_ohci_driver
@@ -1294,18 +1253,6 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_platform;
 #endif
 
-#ifdef OMAP1_PLATFORM_DRIVER
-        retval = platform_driver_register(&OMAP1_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_omap1_platform;
-#endif
-
-#ifdef OMAP3_PLATFORM_DRIVER
-        retval = platform_driver_register(&OMAP3_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_omap3_platform;
-#endif
-
 #ifdef OF_PLATFORM_DRIVER
         retval = platform_driver_register(&OF_PLATFORM_DRIVER);
         if (retval < 0)
@@ -1330,79 +1277,19 @@ static int __init ohci_hcd_mod_init(void)
                 goto error_tmio;
 #endif
 
-#ifdef S3C2410_PLATFORM_DRIVER
-        retval = platform_driver_register(&S3C2410_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_s3c2410;
-#endif
-
-#ifdef EXYNOS_PLATFORM_DRIVER
-        retval = platform_driver_register(&EXYNOS_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_exynos;
-#endif
-
-#ifdef EP93XX_PLATFORM_DRIVER
-        retval = platform_driver_register(&EP93XX_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_ep93xx;
-#endif
-
-#ifdef AT91_PLATFORM_DRIVER
-        retval = platform_driver_register(&AT91_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_at91;
-#endif
-
-#ifdef NXP_PLATFORM_DRIVER
-        retval = platform_driver_register(&NXP_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_nxp;
-#endif
-
 #ifdef DAVINCI_PLATFORM_DRIVER
         retval = platform_driver_register(&DAVINCI_PLATFORM_DRIVER);
         if (retval < 0)
                 goto error_davinci;
 #endif
 
-#ifdef SPEAR_PLATFORM_DRIVER
-        retval = platform_driver_register(&SPEAR_PLATFORM_DRIVER);
-        if (retval < 0)
-                goto error_spear;
-#endif
-
         return retval;
 
         /* Error path */
-#ifdef SPEAR_PLATFORM_DRIVER
-        platform_driver_unregister(&SPEAR_PLATFORM_DRIVER);
- error_spear:
-#endif
 #ifdef DAVINCI_PLATFORM_DRIVER
         platform_driver_unregister(&DAVINCI_PLATFORM_DRIVER);
  error_davinci:
 #endif
-#ifdef NXP_PLATFORM_DRIVER
-        platform_driver_unregister(&NXP_PLATFORM_DRIVER);
- error_nxp:
-#endif
-#ifdef AT91_PLATFORM_DRIVER
-        platform_driver_unregister(&AT91_PLATFORM_DRIVER);
- error_at91:
-#endif
-#ifdef EP93XX_PLATFORM_DRIVER
-        platform_driver_unregister(&EP93XX_PLATFORM_DRIVER);
- error_ep93xx:
-#endif
-#ifdef EXYNOS_PLATFORM_DRIVER
-        platform_driver_unregister(&EXYNOS_PLATFORM_DRIVER);
- error_exynos:
-#endif
-#ifdef S3C2410_PLATFORM_DRIVER
-        platform_driver_unregister(&S3C2410_PLATFORM_DRIVER);
- error_s3c2410:
-#endif
 #ifdef TMIO_OHCI_DRIVER
         platform_driver_unregister(&TMIO_OHCI_DRIVER);
  error_tmio:
@@ -1419,14 +1306,6 @@ static int __init ohci_hcd_mod_init(void)
         platform_driver_unregister(&OF_PLATFORM_DRIVER);
  error_of_platform:
 #endif
-#ifdef OMAP3_PLATFORM_DRIVER
-        platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
- error_omap3_platform:
-#endif
-#ifdef OMAP1_PLATFORM_DRIVER
-        platform_driver_unregister(&OMAP1_PLATFORM_DRIVER);
- error_omap1_platform:
-#endif
 #ifdef PLATFORM_DRIVER
         platform_driver_unregister(&PLATFORM_DRIVER);
  error_platform:
@@ -1448,27 +1327,9 @@ module_init(ohci_hcd_mod_init);
 
 static void __exit ohci_hcd_mod_exit(void)
 {
-#ifdef SPEAR_PLATFORM_DRIVER
-        platform_driver_unregister(&SPEAR_PLATFORM_DRIVER);
-#endif
 #ifdef DAVINCI_PLATFORM_DRIVER
         platform_driver_unregister(&DAVINCI_PLATFORM_DRIVER);
 #endif
-#ifdef NXP_PLATFORM_DRIVER
-        platform_driver_unregister(&NXP_PLATFORM_DRIVER);
-#endif
-#ifdef AT91_PLATFORM_DRIVER
-        platform_driver_unregister(&AT91_PLATFORM_DRIVER);
-#endif
-#ifdef EP93XX_PLATFORM_DRIVER
-        platform_driver_unregister(&EP93XX_PLATFORM_DRIVER);
-#endif
-#ifdef EXYNOS_PLATFORM_DRIVER
-        platform_driver_unregister(&EXYNOS_PLATFORM_DRIVER);
-#endif
-#ifdef S3C2410_PLATFORM_DRIVER
-        platform_driver_unregister(&S3C2410_PLATFORM_DRIVER);
-#endif
 #ifdef TMIO_OHCI_DRIVER
         platform_driver_unregister(&TMIO_OHCI_DRIVER);
 #endif
@@ -1481,12 +1342,6 @@ static void __exit ohci_hcd_mod_exit(void)
 #ifdef OF_PLATFORM_DRIVER
         platform_driver_unregister(&OF_PLATFORM_DRIVER);
 #endif
-#ifdef OMAP3_PLATFORM_DRIVER
-        platform_driver_unregister(&OMAP3_PLATFORM_DRIVER);
-#endif
-#ifdef OMAP1_PLATFORM_DRIVER
-        platform_driver_unregister(&OMAP1_PLATFORM_DRIVER);
-#endif
 #ifdef PLATFORM_DRIVER
         platform_driver_unregister(&PLATFORM_DRIVER);
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 2347ab83f046..61705a760e7d 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -212,10 +212,11 @@ __acquires(ohci->lock)
         /* Sometimes PCI D3 suspend trashes frame timings ... */
         periodic_reinit (ohci);
 
-        /* the following code is executed with ohci->lock held and
-         * irqs disabled if and only if autostopped is true
+        /*
+         * The following code is executed with ohci->lock held and
+         * irqs disabled if and only if autostopped is true.  This
+         * will cause sparse to warn about a "context imbalance".
          */
-
 skip_resume:
         /* interrupts might have been disabled */
         ohci_writel (ohci, OHCI_INTR_INIT, &ohci->regs->intrenable);
@@ -531,7 +532,7 @@ ohci_hub_descriptor (
             temp |= 0x0010;
         else if (rh & RH_A_OCPM)        /* per-port overcurrent reporting? */
             temp |= 0x0008;
-        desc->wHubCharacteristics = (__force __u16)cpu_to_hc16(ohci, temp);
+        desc->wHubCharacteristics = cpu_to_le16(temp);
 
         /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
         rh = roothub_b (ohci);
diff --git a/drivers/usb/host/ohci-nxp.c b/drivers/usb/host/ohci-nxp.c
index 7d7d507d54e8..e99db8a6d55f 100644
--- a/drivers/usb/host/ohci-nxp.c
+++ b/drivers/usb/host/ohci-nxp.c
@@ -19,10 +19,19 @@
  * or implied.
  */
 #include <linux/clk.h>
-#include <linux/platform_device.h>
+#include <linux/dma-mapping.h>
+#include <linux/io.h>
 #include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of.h>
+#include <linux/platform_device.h>
 #include <linux/usb/isp1301.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ohci.h"
+
 
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
@@ -57,6 +66,11 @@
 #define start_int_umask(irq)
 #endif
 
+#define DRIVER_DESC "OHCI NXP driver"
+
+static const char hcd_name[] = "ohci-nxp";
+static struct hc_driver __read_mostly ohci_nxp_hc_driver;
+
 static struct i2c_client *isp1301_i2c_client;
 
 extern int usb_disabled(void);
@@ -132,14 +146,14 @@ static inline void isp1301_vbus_off(void)
                 OTG1_VBUS_DRV);
 }
 
-static void nxp_start_hc(void)
+static void ohci_nxp_start_hc(void)
 {
         unsigned long tmp = __raw_readl(USB_OTG_STAT_CONTROL) | HOST_EN;
         __raw_writel(tmp, USB_OTG_STAT_CONTROL);
         isp1301_vbus_on();
 }
 
-static void nxp_stop_hc(void)
+static void ohci_nxp_stop_hc(void)
 {
         unsigned long tmp;
         isp1301_vbus_off();
@@ -147,68 +161,9 @@ static void nxp_stop_hc(void)
         __raw_writel(tmp, USB_OTG_STAT_CONTROL);
 }
 
-static int ohci_nxp_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        if ((ret = ohci_init(ohci)) < 0)
-                return ret;
-
-        if ((ret = ohci_run(ohci)) < 0) {
-                dev_err(hcd->self.controller, "can't start\n");
-                ohci_stop(hcd);
-                return ret;
-        }
-        return 0;
-}
-
-static const struct hc_driver ohci_nxp_hc_driver = {
-        .description = hcd_name,
-        .product_desc =         "nxp OHCI",
-
-        /*
-         * generic hardware linkage
-         */
-        .irq = ohci_irq,
-        .flags = HCD_USB11 | HCD_MEMORY,
-
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-        /*
-         * basic lifecycle operations
-         */
-        .start = ohci_nxp_start,
-        .stop = ohci_stop,
-        .shutdown = ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue = ohci_urb_enqueue,
-        .urb_dequeue = ohci_urb_dequeue,
-        .endpoint_disable = ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number = ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data = ohci_hub_status_data,
-        .hub_control = ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend = ohci_bus_suspend,
-        .bus_resume = ohci_bus_resume,
-#endif
-        .start_port_reset = ohci_start_port_reset,
-};
-
-static int usb_hcd_nxp_probe(struct platform_device *pdev)
+static int ohci_hcd_nxp_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = 0;
-        struct ohci_hcd *ohci;
         const struct hc_driver *driver = &ohci_nxp_hc_driver;
         struct resource *res;
         int ret = 0, irq;
@@ -226,8 +181,9 @@ static int usb_hcd_nxp_probe(struct platform_device *pdev)
                 return -EPROBE_DEFER;
         }
 
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto fail_disable;
 
         dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (nxp)\n", hcd_name);
         if (usb_disabled()) {
@@ -313,17 +269,15 @@ static int usb_hcd_nxp_probe(struct platform_device *pdev)
                 goto fail_resource;
         }
 
-        nxp_start_hc();
+        ohci_nxp_start_hc();
         platform_set_drvdata(pdev, hcd);
-        ohci = hcd_to_ohci(hcd);
-        ohci_hcd_init(ohci);
 
         dev_info(&pdev->dev, "at 0x%p, irq %d\n", hcd->regs, hcd->irq);
         ret = usb_add_hcd(hcd, irq, 0);
         if (ret == 0)
                 return ret;
 
-        nxp_stop_hc();
+        ohci_nxp_stop_hc();
 fail_resource:
         usb_put_hcd(hcd);
 fail_hcd:
@@ -345,12 +299,12 @@ fail_disable:
         return ret;
 }
 
-static int usb_hcd_nxp_remove(struct platform_device *pdev)
+static int ohci_hcd_nxp_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        nxp_stop_hc();
+        ohci_nxp_stop_hc();
         usb_put_hcd(hcd);
         clk_disable(usb_pll_clk);
         clk_put(usb_pll_clk);
@@ -366,20 +320,40 @@ static int usb_hcd_nxp_remove(struct platform_device *pdev)
 MODULE_ALIAS("platform:usb-ohci");
 
 #ifdef CONFIG_OF
-static const struct of_device_id usb_hcd_nxp_match[] = {
+static const struct of_device_id ohci_hcd_nxp_match[] = {
         { .compatible = "nxp,ohci-nxp" },
         {},
 };
-MODULE_DEVICE_TABLE(of, usb_hcd_nxp_match);
+MODULE_DEVICE_TABLE(of, ohci_hcd_nxp_match);
 #endif
 
-static struct platform_driver usb_hcd_nxp_driver = {
+static struct platform_driver ohci_hcd_nxp_driver = {
         .driver = {
                 .name = "usb-ohci",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(usb_hcd_nxp_match),
+                .of_match_table = of_match_ptr(ohci_hcd_nxp_match),
         },
-        .probe = usb_hcd_nxp_probe,
-        .remove = usb_hcd_nxp_remove,
+        .probe = ohci_hcd_nxp_probe,
+        .remove = ohci_hcd_nxp_remove,
 };
 
+static int __init ohci_nxp_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ohci_init_driver(&ohci_nxp_hc_driver, NULL);
+        return platform_driver_register(&ohci_hcd_nxp_driver);
+}
+module_init(ohci_nxp_init);
+
+static void __exit ohci_nxp_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_nxp_driver);
+}
+module_exit(ohci_nxp_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
index 342dc7e543b8..6c16dcef15c6 100644
--- a/drivers/usb/host/ohci-octeon.c
+++ b/drivers/usb/host/ohci-octeon.c
@@ -127,8 +127,9 @@ static int ohci_octeon_drv_probe(struct platform_device *pdev)
         }
 
         /* Ohci is a 32-bit device. */
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&ohci_octeon_hc_driver, &pdev->dev, "octeon");
         if (!hcd)
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index 31d3a12eb486..f253214741ba 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -14,12 +14,21 @@
  * This file is licenced under the GPL.
  */
 
-#include <linux/signal.h>
-#include <linux/jiffies.h>
-#include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/dma-mapping.h>
 #include <linux/err.h>
 #include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb/otg.h>
+#include <linux/platform_device.h>
+#include <linux/signal.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ohci.h"
 
 #include <asm/io.h>
 #include <asm/mach-types.h>
@@ -42,10 +51,7 @@
 #define OMAP1510_LB_MMU_RAM_H   0xfffec234
 #define OMAP1510_LB_MMU_RAM_L   0xfffec238
 
-
-#ifndef CONFIG_ARCH_OMAP
-#error "This file is OMAP bus glue.  CONFIG_OMAP must be defined."
-#endif
+#define DRIVER_DESC "OHCI OMAP driver"
 
 #ifdef CONFIG_TPS65010
 #include <linux/i2c/tps65010.h>
@@ -68,8 +74,9 @@ extern int ocpi_enable(void);
 
 static struct clk *usb_host_ck;
 static struct clk *usb_dc_ck;
-static int host_enabled;
-static int host_initialized;
+
+static const char hcd_name[] = "ohci-omap";
+static struct hc_driver __read_mostly ohci_omap_hc_driver;
 
 static void omap_ohci_clock_power(int on)
 {
@@ -188,7 +195,7 @@ static void start_hnp(struct ohci_hcd *ohci)
 
 /*-------------------------------------------------------------------------*/
 
-static int ohci_omap_init(struct usb_hcd *hcd)
+static int ohci_omap_reset(struct usb_hcd *hcd)
 {
         struct ohci_hcd         *ohci = hcd_to_ohci(hcd);
         struct omap_usb_config  *config = dev_get_platdata(hcd->self.controller);
@@ -198,9 +205,9 @@ static int ohci_omap_init(struct usb_hcd *hcd)
         dev_dbg(hcd->self.controller, "starting USB Controller\n");
 
         if (config->otg) {
-                ohci_to_hcd(ohci)->self.otg_port = config->otg;
+                hcd->self.otg_port = config->otg;
                 /* default/minimum OTG power budget:  8 mA */
-                ohci_to_hcd(ohci)->power_budget = 8;
+                hcd->power_budget = 8;
         }
 
         /* boards can use OTG transceivers in non-OTG modes */
@@ -238,9 +245,15 @@ static int ohci_omap_init(struct usb_hcd *hcd)
                 omap_1510_local_bus_init();
         }
 
-        if ((ret = ohci_init(ohci)) < 0)
+        ret = ohci_setup(hcd);
+        if (ret < 0)
                 return ret;
 
+        if (config->otg || config->rwc) {
+                ohci->hc_control = OHCI_CTRL_RWC;
+                writel(OHCI_CTRL_RWC, &ohci->regs->control);
+        }
+
         /* board-specific power switching and overcurrent support */
         if (machine_is_omap_osk() || machine_is_omap_innovator()) {
                 u32     rh = roothub_a (ohci);
@@ -281,14 +294,6 @@ static int ohci_omap_init(struct usb_hcd *hcd)
         return 0;
 }
 
-static void ohci_omap_stop(struct usb_hcd *hcd)
-{
-        dev_dbg(hcd->self.controller, "stopping USB Controller\n");
-        ohci_stop(hcd);
-        omap_ohci_clock_power(0);
-}
-
-
 /*-------------------------------------------------------------------------*/
 
 /**
@@ -304,7 +309,6 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
 {
         int retval, irq;
         struct usb_hcd *hcd = 0;
-        struct ohci_hcd *ohci;
 
         if (pdev->num_resources != 2) {
                 printk(KERN_ERR "hcd probe: invalid num_resources: %i\n",
@@ -354,12 +358,6 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
                 goto err2;
         }
 
-        ohci = hcd_to_ohci(hcd);
-        ohci_hcd_init(ohci);
-
-        host_initialized = 0;
-        host_enabled = 1;
-
         irq = platform_get_irq(pdev, 0);
         if (irq < 0) {
                 retval = -ENXIO;
@@ -369,11 +367,6 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
         if (retval)
                 goto err3;
 
-        host_initialized = 1;
-
-        if (!host_enabled)
-                omap_ohci_clock_power(0);
-
         return 0;
 err3:
         iounmap(hcd->regs);
@@ -402,7 +395,9 @@ err0:
 static inline void
 usb_hcd_omap_remove (struct usb_hcd *hcd, struct platform_device *pdev)
 {
+        dev_dbg(hcd->self.controller, "stopping USB Controller\n");
         usb_remove_hcd(hcd);
+        omap_ohci_clock_power(0);
         if (!IS_ERR_OR_NULL(hcd->phy)) {
                 (void) otg_set_host(hcd->phy->otg, 0);
                 usb_put_phy(hcd->phy);
@@ -418,76 +413,6 @@ usb_hcd_omap_remove (struct usb_hcd *hcd, struct platform_device *pdev)
 
 /*-------------------------------------------------------------------------*/
 
-static int
-ohci_omap_start (struct usb_hcd *hcd)
-{
-        struct omap_usb_config *config;
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ret;
-
-        if (!host_enabled)
-                return 0;
-        config = dev_get_platdata(hcd->self.controller);
-        if (config->otg || config->rwc) {
-                ohci->hc_control = OHCI_CTRL_RWC;
-                writel(OHCI_CTRL_RWC, &ohci->regs->control);
-        }
-
-        if ((ret = ohci_run (ohci)) < 0) {
-                dev_err(hcd->self.controller, "can't start\n");
-                ohci_stop (hcd);
-                return ret;
-        }
-        return 0;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ohci_omap_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "OMAP OHCI",
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                ohci_omap_init,
-        .start =                ohci_omap_start,
-        .stop =                 ohci_omap_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_hub_status_data,
-        .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
-
-/*-------------------------------------------------------------------------*/
-
 static int ohci_hcd_omap_drv_probe(struct platform_device *dev)
 {
         return usb_hcd_omap_probe(&ohci_omap_hc_driver, dev);
@@ -506,16 +431,23 @@ static int ohci_hcd_omap_drv_remove(struct platform_device *dev)
 
 #ifdef  CONFIG_PM
 
-static int ohci_omap_suspend(struct platform_device *dev, pm_message_t message)
+static int ohci_omap_suspend(struct platform_device *pdev, pm_message_t message)
 {
-        struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(dev));
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        bool do_wakeup = device_may_wakeup(&pdev->dev);
+        int ret;
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
         omap_ohci_clock_power(0);
-        return 0;
+        return ret;
 }
 
 static int ohci_omap_resume(struct platform_device *dev)
@@ -553,4 +485,29 @@ static struct platform_driver ohci_hcd_omap_driver = {
         },
 };
 
+static const struct ohci_driver_overrides omap_overrides __initconst = {
+        .product_desc   = "OMAP OHCI",
+        .reset          = ohci_omap_reset
+};
+
+static int __init ohci_omap_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ohci_init_driver(&ohci_omap_hc_driver, &omap_overrides);
+        return platform_driver_register(&ohci_hcd_omap_driver);
+}
+module_init(ohci_omap_init);
+
+static void __exit ohci_omap_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_omap_driver);
+}
+module_exit(ohci_omap_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_ALIAS("platform:ohci");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index a09af26f69ed..21457417a856 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -29,90 +29,22 @@
  *      - add kernel-doc
  */
 
+#include <linux/dma-mapping.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/usb/otg.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
-#include <linux/of.h>
-#include <linux/dma-mapping.h>
-
-/*-------------------------------------------------------------------------*/
-
-static int ohci_omap3_init(struct usb_hcd *hcd)
-{
-        dev_dbg(hcd->self.controller, "starting OHCI controller\n");
-
-        return ohci_init(hcd_to_ohci(hcd));
-}
-
-/*-------------------------------------------------------------------------*/
-
-static int ohci_omap3_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        /*
-         * RemoteWakeupConnected has to be set explicitly before
-         * calling ohci_run. The reset value of RWC is 0.
-         */
-        ohci->hc_control = OHCI_CTRL_RWC;
-        writel(OHCI_CTRL_RWC, &ohci->regs->control);
-
-        ret = ohci_run(ohci);
-
-        if (ret < 0) {
-                dev_err(hcd->self.controller, "can't start\n");
-                ohci_stop(hcd);
-        }
-
-        return ret;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ohci_omap3_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "OMAP3 OHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                ohci_omap3_init,
-        .start =                ohci_omap3_start,
-        .stop =                 ohci_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
 
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
+#include "ohci.h"
 
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_hub_status_data,
-        .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
+#define DRIVER_DESC "OHCI OMAP3 driver"
 
-/*-------------------------------------------------------------------------*/
+static const char hcd_name[] = "ohci-omap3";
+static struct hc_driver __read_mostly ohci_omap3_hc_driver;
 
 /*
  * configure so an HC device and id are always provided
@@ -129,10 +61,11 @@ static const struct hc_driver ohci_omap3_hc_driver = {
 static int ohci_hcd_omap3_probe(struct platform_device *pdev)
 {
         struct device           *dev = &pdev->dev;
+        struct ohci_hcd         *ohci;
         struct usb_hcd          *hcd = NULL;
         void __iomem            *regs = NULL;
         struct resource         *res;
-        int                     ret = -ENODEV;
+        int                     ret;
         int                     irq;
 
         if (usb_disabled())
@@ -166,11 +99,11 @@ static int ohci_hcd_omap3_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err_io;
 
+        ret = -ENODEV;
         hcd = usb_create_hcd(&ohci_omap3_hc_driver, dev,
                         dev_name(dev));
         if (!hcd) {
@@ -185,7 +118,12 @@ static int ohci_hcd_omap3_probe(struct platform_device *pdev)
         pm_runtime_enable(dev);
         pm_runtime_get_sync(dev);
 
-        ohci_hcd_init(hcd_to_ohci(hcd));
+        ohci = hcd_to_ohci(hcd);
+        /*
+         * RemoteWakeupConnected has to be set explicitly before
+         * calling ohci_run. The reset value of RWC is 0.
+         */
+        ohci->hc_control = OHCI_CTRL_RWC;
 
         ret = usb_add_hcd(hcd, irq, 0);
         if (ret) {
@@ -248,5 +186,25 @@ static struct platform_driver ohci_hcd_omap3_driver = {
         },
 };
 
+static int __init ohci_omap3_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ohci_init_driver(&ohci_omap3_hc_driver, NULL);
+        return platform_driver_register(&ohci_hcd_omap3_driver);
+}
+module_init(ohci_omap3_init);
+
+static void __exit ohci_omap3_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_omap3_driver);
+}
+module_exit(ohci_omap3_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_ALIAS("platform:ohci-omap3");
 MODULE_AUTHOR("Anand Gadiyar <gadiyar@ti.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index ec337c2bd5e0..90879e9ccbec 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -150,28 +150,16 @@ static int ohci_quirk_nec(struct usb_hcd *hcd)
 static int ohci_quirk_amd700(struct usb_hcd *hcd)
 {
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct pci_dev *amd_smbus_dev;
-        u8 rev;
 
         if (usb_amd_find_chipset_info())
                 ohci->flags |= OHCI_QUIRK_AMD_PLL;
 
-        amd_smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
-                        PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
-        if (!amd_smbus_dev)
-                return 0;
-
-        rev = amd_smbus_dev->revision;
-
         /* SB800 needs pre-fetch fix */
-        if ((rev >= 0x40) && (rev <= 0x4f)) {
+        if (usb_amd_prefetch_quirk()) {
                 ohci->flags |= OHCI_QUIRK_AMD_PREFETCH;
                 ohci_dbg(ohci, "enabled AMD prefetch quirk\n");
         }
 
-        pci_dev_put(amd_smbus_dev);
-        amd_smbus_dev = NULL;
-
         return 0;
 }
 
@@ -323,3 +311,4 @@ module_exit(ohci_pci_cleanup);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
+MODULE_SOFTDEP("pre: ehci_pci");
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index a4c6410f0ed4..f351ff5b171f 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -139,14 +139,21 @@ static int ohci_platform_remove(struct platform_device *dev)
 
 static int ohci_platform_suspend(struct device *dev)
 {
-        struct usb_ohci_pdata *pdata = dev_get_platdata(dev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ohci_pdata *pdata = dev->platform_data;
         struct platform_device *pdev =
                 container_of(dev, struct platform_device, dev);
+        bool do_wakeup = device_may_wakeup(dev);
+        int ret;
+
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
 
         if (pdata->power_suspend)
                 pdata->power_suspend(pdev);
 
-        return 0;
+        return ret;
 }
 
 static int ohci_platform_resume(struct device *dev)
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 75f5a1e2f01e..81f3eba215c1 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -14,6 +14,8 @@
  */
 
 #include <linux/signal.h>
+#include <linux/of_address.h>
+#include <linux/of_irq.h>
 #include <linux/of_platform.h>
 
 #include <asm/prom.h>
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 93371a235e82..e89ac4d4b87e 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -19,15 +19,26 @@
  * This file is licenced under the GPL.
  */
 
-#include <linux/device.h>
-#include <linux/signal.h>
-#include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of_platform.h>
 #include <linux/of_gpio.h>
-#include <mach/hardware.h>
 #include <linux/platform_data/usb-ohci-pxa27x.h>
 #include <linux/platform_data/usb-pxa3xx-ulpi.h>
+#include <linux/platform_device.h>
+#include <linux/signal.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/otg.h>
+
+#include <mach/hardware.h>
+
+#include "ohci.h"
+
+#define DRIVER_DESC "OHCI PXA27x/PXA3x driver"
 
 /*
  * UHC: USB Host Controller (OHCI-like) register definitions
@@ -101,16 +112,16 @@
 
 #define PXA_UHC_MAX_PORTNUM    3
 
-struct pxa27x_ohci {
-        /* must be 1st member here for hcd_to_ohci() to work */
-        struct ohci_hcd ohci;
+static const char hcd_name[] = "ohci-pxa27x";
 
-        struct device   *dev;
+static struct hc_driver __read_mostly ohci_pxa27x_hc_driver;
+
+struct pxa27x_ohci {
         struct clk      *clk;
         void __iomem    *mmio_base;
 };
 
-#define to_pxa27x_ohci(hcd)     (struct pxa27x_ohci *)hcd_to_ohci(hcd)
+#define to_pxa27x_ohci(hcd)     (struct pxa27x_ohci *)(hcd_to_ohci(hcd)->priv)
 
 /*
   PMM_NPS_MODE -- PMM Non-power switching mode
@@ -122,10 +133,10 @@ struct pxa27x_ohci {
   PMM_PERPORT_MODE -- PMM per port switching mode
       Ports are powered individually.
  */
-static int pxa27x_ohci_select_pmm(struct pxa27x_ohci *ohci, int mode)
+static int pxa27x_ohci_select_pmm(struct pxa27x_ohci *pxa_ohci, int mode)
 {
-        uint32_t uhcrhda = __raw_readl(ohci->mmio_base + UHCRHDA);
-        uint32_t uhcrhdb = __raw_readl(ohci->mmio_base + UHCRHDB);
+        uint32_t uhcrhda = __raw_readl(pxa_ohci->mmio_base + UHCRHDA);
+        uint32_t uhcrhdb = __raw_readl(pxa_ohci->mmio_base + UHCRHDB);
 
         switch (mode) {
         case PMM_NPS_MODE:
@@ -149,20 +160,18 @@ static int pxa27x_ohci_select_pmm(struct pxa27x_ohci *ohci, int mode)
                 uhcrhda |= RH_A_NPS;
         }
 
-        __raw_writel(uhcrhda, ohci->mmio_base + UHCRHDA);
-        __raw_writel(uhcrhdb, ohci->mmio_base + UHCRHDB);
+        __raw_writel(uhcrhda, pxa_ohci->mmio_base + UHCRHDA);
+        __raw_writel(uhcrhdb, pxa_ohci->mmio_base + UHCRHDB);
         return 0;
 }
 
-extern int usb_disabled(void);
-
 /*-------------------------------------------------------------------------*/
 
-static inline void pxa27x_setup_hc(struct pxa27x_ohci *ohci,
+static inline void pxa27x_setup_hc(struct pxa27x_ohci *pxa_ohci,
                                    struct pxaohci_platform_data *inf)
 {
-        uint32_t uhchr = __raw_readl(ohci->mmio_base + UHCHR);
-        uint32_t uhcrhda = __raw_readl(ohci->mmio_base + UHCRHDA);
+        uint32_t uhchr = __raw_readl(pxa_ohci->mmio_base + UHCHR);
+        uint32_t uhcrhda = __raw_readl(pxa_ohci->mmio_base + UHCRHDA);
 
         if (inf->flags & ENABLE_PORT1)
                 uhchr &= ~UHCHR_SSEP1;
@@ -194,17 +203,17 @@ static inline void pxa27x_setup_hc(struct pxa27x_ohci *ohci,
                 uhcrhda |= UHCRHDA_POTPGT(inf->power_on_delay / 2);
         }
 
-        __raw_writel(uhchr, ohci->mmio_base + UHCHR);
-        __raw_writel(uhcrhda, ohci->mmio_base + UHCRHDA);
+        __raw_writel(uhchr, pxa_ohci->mmio_base + UHCHR);
+        __raw_writel(uhcrhda, pxa_ohci->mmio_base + UHCRHDA);
 }
 
-static inline void pxa27x_reset_hc(struct pxa27x_ohci *ohci)
+static inline void pxa27x_reset_hc(struct pxa27x_ohci *pxa_ohci)
 {
-        uint32_t uhchr = __raw_readl(ohci->mmio_base + UHCHR);
+        uint32_t uhchr = __raw_readl(pxa_ohci->mmio_base + UHCHR);
 
-        __raw_writel(uhchr | UHCHR_FHR, ohci->mmio_base + UHCHR);
+        __raw_writel(uhchr | UHCHR_FHR, pxa_ohci->mmio_base + UHCHR);
         udelay(11);
-        __raw_writel(uhchr & ~UHCHR_FHR, ohci->mmio_base + UHCHR);
+        __raw_writel(uhchr & ~UHCHR_FHR, pxa_ohci->mmio_base + UHCHR);
 }
 
 #ifdef CONFIG_PXA27x
@@ -213,25 +222,26 @@ extern void pxa27x_clear_otgph(void);
 #define pxa27x_clear_otgph()    do {} while (0)
 #endif
 
-static int pxa27x_start_hc(struct pxa27x_ohci *ohci, struct device *dev)
+static int pxa27x_start_hc(struct pxa27x_ohci *pxa_ohci, struct device *dev)
 {
         int retval = 0;
         struct pxaohci_platform_data *inf;
         uint32_t uhchr;
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
 
         inf = dev_get_platdata(dev);
 
-        clk_prepare_enable(ohci->clk);
+        clk_prepare_enable(pxa_ohci->clk);
 
-        pxa27x_reset_hc(ohci);
+        pxa27x_reset_hc(pxa_ohci);
 
-        uhchr = __raw_readl(ohci->mmio_base + UHCHR) | UHCHR_FSBIR;
-        __raw_writel(uhchr, ohci->mmio_base + UHCHR);
+        uhchr = __raw_readl(pxa_ohci->mmio_base + UHCHR) | UHCHR_FSBIR;
+        __raw_writel(uhchr, pxa_ohci->mmio_base + UHCHR);
 
-        while (__raw_readl(ohci->mmio_base + UHCHR) & UHCHR_FSBIR)
+        while (__raw_readl(pxa_ohci->mmio_base + UHCHR) & UHCHR_FSBIR)
                 cpu_relax();
 
-        pxa27x_setup_hc(ohci, inf);
+        pxa27x_setup_hc(pxa_ohci, inf);
 
         if (inf->init)
                 retval = inf->init(dev);
@@ -240,38 +250,39 @@ static int pxa27x_start_hc(struct pxa27x_ohci *ohci, struct device *dev)
                 return retval;
 
         if (cpu_is_pxa3xx())
-                pxa3xx_u2d_start_hc(&ohci_to_hcd(&ohci->ohci)->self);
+                pxa3xx_u2d_start_hc(&hcd->self);
 
-        uhchr = __raw_readl(ohci->mmio_base + UHCHR) & ~UHCHR_SSE;
-        __raw_writel(uhchr, ohci->mmio_base + UHCHR);
-        __raw_writel(UHCHIE_UPRIE | UHCHIE_RWIE, ohci->mmio_base + UHCHIE);
+        uhchr = __raw_readl(pxa_ohci->mmio_base + UHCHR) & ~UHCHR_SSE;
+        __raw_writel(uhchr, pxa_ohci->mmio_base + UHCHR);
+        __raw_writel(UHCHIE_UPRIE | UHCHIE_RWIE, pxa_ohci->mmio_base + UHCHIE);
 
         /* Clear any OTG Pin Hold */
         pxa27x_clear_otgph();
         return 0;
 }
 
-static void pxa27x_stop_hc(struct pxa27x_ohci *ohci, struct device *dev)
+static void pxa27x_stop_hc(struct pxa27x_ohci *pxa_ohci, struct device *dev)
 {
         struct pxaohci_platform_data *inf;
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         uint32_t uhccoms;
 
         inf = dev_get_platdata(dev);
 
         if (cpu_is_pxa3xx())
-                pxa3xx_u2d_stop_hc(&ohci_to_hcd(&ohci->ohci)->self);
+                pxa3xx_u2d_stop_hc(&hcd->self);
 
         if (inf->exit)
                 inf->exit(dev);
 
-        pxa27x_reset_hc(ohci);
+        pxa27x_reset_hc(pxa_ohci);
 
         /* Host Controller Reset */
-        uhccoms = __raw_readl(ohci->mmio_base + UHCCOMS) | 0x01;
-        __raw_writel(uhccoms, ohci->mmio_base + UHCCOMS);
+        uhccoms = __raw_readl(pxa_ohci->mmio_base + UHCCOMS) | 0x01;
+        __raw_writel(uhccoms, pxa_ohci->mmio_base + UHCCOMS);
         udelay(10);
 
-        clk_disable_unprepare(ohci->clk);
+        clk_disable_unprepare(pxa_ohci->clk);
 }
 
 #ifdef CONFIG_OF
@@ -287,6 +298,7 @@ static int ohci_pxa_of_init(struct platform_device *pdev)
         struct device_node *np = pdev->dev.of_node;
         struct pxaohci_platform_data *pdata;
         u32 tmp;
+        int ret;
 
         if (!np)
                 return 0;
@@ -295,10 +307,9 @@ static int ohci_pxa_of_init(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
@@ -356,7 +367,8 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         int retval, irq;
         struct usb_hcd *hcd;
         struct pxaohci_platform_data *inf;
-        struct pxa27x_ohci *ohci;
+        struct pxa27x_ohci *pxa_ohci;
+        struct ohci_hcd *ohci;
         struct resource *r;
         struct clk *usb_clk;
 
@@ -409,29 +421,31 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         }
 
         /* initialize "struct pxa27x_ohci" */
-        ohci = (struct pxa27x_ohci *)hcd_to_ohci(hcd);
-        ohci->dev = &pdev->dev;
-        ohci->clk = usb_clk;
-        ohci->mmio_base = (void __iomem *)hcd->regs;
+        pxa_ohci = to_pxa27x_ohci(hcd);
+        pxa_ohci->clk = usb_clk;
+        pxa_ohci->mmio_base = (void __iomem *)hcd->regs;
 
-        if ((retval = pxa27x_start_hc(ohci, &pdev->dev)) < 0) {
+        retval = pxa27x_start_hc(pxa_ohci, &pdev->dev);
+        if (retval < 0) {
                 pr_debug("pxa27x_start_hc failed");
                 goto err3;
         }
 
         /* Select Power Management Mode */
-        pxa27x_ohci_select_pmm(ohci, inf->port_mode);
+        pxa27x_ohci_select_pmm(pxa_ohci, inf->port_mode);
 
         if (inf->power_budget)
                 hcd->power_budget = inf->power_budget;
 
-        ohci_hcd_init(hcd_to_ohci(hcd));
+        /* The value of NDP in roothub_a is incorrect on this hardware */
+        ohci = hcd_to_ohci(hcd);
+        ohci->num_ports = 3;
 
         retval = usb_add_hcd(hcd, irq, 0);
         if (retval == 0)
                 return retval;
 
-        pxa27x_stop_hc(ohci, &pdev->dev);
+        pxa27x_stop_hc(pxa_ohci, &pdev->dev);
  err3:
         iounmap(hcd->regs);
  err2:
@@ -459,88 +473,18 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
  */
 void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *pdev)
 {
-        struct pxa27x_ohci *ohci = to_pxa27x_ohci(hcd);
+        struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
 
         usb_remove_hcd(hcd);
-        pxa27x_stop_hc(ohci, &pdev->dev);
+        pxa27x_stop_hc(pxa_ohci, &pdev->dev);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        clk_put(pxa_ohci->clk);
         usb_put_hcd(hcd);
-        clk_put(ohci->clk);
 }
 
 /*-------------------------------------------------------------------------*/
 
-static int
-ohci_pxa27x_start (struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci (hcd);
-        int             ret;
-
-        ohci_dbg (ohci, "ohci_pxa27x_start, ohci:%p", ohci);
-
-        /* The value of NDP in roothub_a is incorrect on this hardware */
-        ohci->num_ports = 3;
-
-        if ((ret = ohci_init(ohci)) < 0)
-                return ret;
-
-        if ((ret = ohci_run (ohci)) < 0) {
-                dev_err(hcd->self.controller, "can't start %s",
-                        hcd->self.bus_name);
-                ohci_stop (hcd);
-                return ret;
-        }
-
-        return 0;
-}
-
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ohci_pxa27x_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "PXA27x OHCI",
-        .hcd_priv_size =        sizeof(struct pxa27x_ohci),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .start =                ohci_pxa27x_start,
-        .stop =                 ohci_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_hub_status_data,
-        .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
-
-/*-------------------------------------------------------------------------*/
-
 static int ohci_hcd_pxa27x_drv_probe(struct platform_device *pdev)
 {
         pr_debug ("In ohci_hcd_pxa27x_drv_probe");
@@ -563,32 +507,42 @@ static int ohci_hcd_pxa27x_drv_remove(struct platform_device *pdev)
 static int ohci_hcd_pxa27x_drv_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
-        struct pxa27x_ohci *ohci = to_pxa27x_ohci(hcd);
+        struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        bool do_wakeup = device_may_wakeup(dev);
+        int ret;
+
 
-        if (time_before(jiffies, ohci->ohci.next_statechange))
+        if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
-        ohci->ohci.next_statechange = jiffies;
+        ohci->next_statechange = jiffies;
 
-        pxa27x_stop_hc(ohci, dev);
-        return 0;
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
+        pxa27x_stop_hc(pxa_ohci, dev);
+        return ret;
 }
 
 static int ohci_hcd_pxa27x_drv_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
-        struct pxa27x_ohci *ohci = to_pxa27x_ohci(hcd);
+        struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
         struct pxaohci_platform_data *inf = dev_get_platdata(dev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         int status;
 
-        if (time_before(jiffies, ohci->ohci.next_statechange))
+        if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
-        ohci->ohci.next_statechange = jiffies;
+        ohci->next_statechange = jiffies;
 
-        if ((status = pxa27x_start_hc(ohci, dev)) < 0)
+        status = pxa27x_start_hc(pxa_ohci, dev);
+        if (status < 0)
                 return status;
 
         /* Select Power Management Mode */
-        pxa27x_ohci_select_pmm(ohci, inf->port_mode);
+        pxa27x_ohci_select_pmm(pxa_ohci, inf->port_mode);
 
         ohci_resume(hcd, false);
         return 0;
@@ -600,9 +554,6 @@ static const struct dev_pm_ops ohci_hcd_pxa27x_pm_ops = {
 };
 #endif
 
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:pxa27x-ohci");
-
 static struct platform_driver ohci_hcd_pxa27x_driver = {
         .probe          = ohci_hcd_pxa27x_drv_probe,
         .remove         = ohci_hcd_pxa27x_drv_remove,
@@ -617,3 +568,27 @@ static struct platform_driver ohci_hcd_pxa27x_driver = {
         },
 };
 
+static const struct ohci_driver_overrides pxa27x_overrides __initconst = {
+        .extra_priv_size =      sizeof(struct pxa27x_ohci),
+};
+
+static int __init ohci_pxa27x_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+        ohci_init_driver(&ohci_pxa27x_hc_driver, &pxa27x_overrides);
+        return platform_driver_register(&ohci_hcd_pxa27x_driver);
+}
+module_init(ohci_pxa27x_init);
+
+static void __exit ohci_pxa27x_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_pxa27x_driver);
+}
+module_exit(ohci_pxa27x_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pxa27x-ohci");
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index df4a6707322d..e7f577e63624 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -41,9 +41,13 @@ finish_urb(struct ohci_hcd *ohci, struct urb *urb, int status)
 __releases(ohci->lock)
 __acquires(ohci->lock)
 {
-         struct device *dev = ohci_to_hcd(ohci)->self.controller;
+        struct device *dev = ohci_to_hcd(ohci)->self.controller;
+        struct usb_host_endpoint *ep = urb->ep;
+        struct urb_priv *urb_priv;
+
         // ASSERT (urb->hcpriv != 0);
 
+ restart:
         urb_free_priv (ohci, urb->hcpriv);
         urb->hcpriv = NULL;
         if (likely(status == -EINPROGRESS))
@@ -80,6 +84,21 @@ __acquires(ohci->lock)
                 ohci->hc_control &= ~(OHCI_CTRL_PLE|OHCI_CTRL_IE);
                 ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
         }
+
+        /*
+         * An isochronous URB that is sumitted too late won't have any TDs
+         * (marked by the fact that the td_cnt value is larger than the
+         * actual number of TDs).  If the next URB on this endpoint is like
+         * that, give it back now.
+         */
+        if (!list_empty(&ep->urb_list)) {
+                urb = list_first_entry(&ep->urb_list, struct urb, urb_list);
+                urb_priv = urb->hcpriv;
+                if (urb_priv->td_cnt > urb_priv->length) {
+                        status = 0;
+                        goto restart;
+                }
+        }
 }
 
 
@@ -546,7 +565,6 @@ td_fill (struct ohci_hcd *ohci, u32 info,
                 td->hwCBP = cpu_to_hc32 (ohci, data & 0xFFFFF000);
                 *ohci_hwPSWp(ohci, td, 0) = cpu_to_hc16 (ohci,
                                                 (data & 0x0FFF) | 0xE000);
-                td->ed->last_iso = info & 0xffff;
         } else {
                 td->hwCBP = cpu_to_hc32 (ohci, data);
         }
@@ -996,7 +1014,7 @@ rescan_this:
                         urb_priv->td_cnt++;
 
                         /* if URB is done, clean up */
-                        if (urb_priv->td_cnt == urb_priv->length) {
+                        if (urb_priv->td_cnt >= urb_priv->length) {
                                 modified = completed = 1;
                                 finish_urb(ohci, urb, 0);
                         }
@@ -1086,7 +1104,7 @@ static void takeback_td(struct ohci_hcd *ohci, struct td *td)
         urb_priv->td_cnt++;
 
         /* If all this urb's TDs are done, call complete() */
-        if (urb_priv->td_cnt == urb_priv->length)
+        if (urb_priv->td_cnt >= urb_priv->length)
                 finish_urb(ohci, urb, status);
 
         /* clean schedule:  unlink EDs that are no longer busy */
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index 4919afa4125e..f90101b9cdb9 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -19,19 +19,36 @@
  * This file is licenced under the GPL.
 */
 
-#include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
 #include <linux/platform_data/usb-ohci-s3c2410.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ohci.h"
+
 
 #define valid_port(idx) ((idx) == 1 || (idx) == 2)
 
 /* clock device associated with the hcd */
 
+
+#define DRIVER_DESC "OHCI S3C2410 driver"
+
+static const char hcd_name[] = "ohci-s3c2410";
+
 static struct clk *clk;
 static struct clk *usb_clk;
 
 /* forward definitions */
 
+static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
+                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
+static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
+
 static void s3c2410_hcd_oc(struct s3c2410_hcd_info *info, int port_oc);
 
 /* conversion functions */
@@ -47,10 +64,10 @@ static void s3c2410_start_hc(struct platform_device *dev, struct usb_hcd *hcd)
 
         dev_dbg(&dev->dev, "s3c2410_start_hc:\n");
 
-        clk_enable(usb_clk);
+        clk_prepare_enable(usb_clk);
         mdelay(2);                      /* let the bus clock stabilise */
 
-        clk_enable(clk);
+        clk_prepare_enable(clk);
 
         if (info != NULL) {
                 info->hcd       = hcd;
@@ -75,8 +92,8 @@ static void s3c2410_stop_hc(struct platform_device *dev)
                         (info->enable_oc)(info, 0);
         }
 
-        clk_disable(clk);
-        clk_disable(usb_clk);
+        clk_disable_unprepare(clk);
+        clk_disable_unprepare(usb_clk);
 }
 
 /* ohci_s3c2410_hub_status_data
@@ -93,7 +110,7 @@ ohci_s3c2410_hub_status_data(struct usb_hcd *hcd, char *buf)
         int orig;
         int portno;
 
-        orig  = ohci_hub_status_data(hcd, buf);
+        orig = orig_ohci_hub_status_data(hcd, buf);
 
         if (info == NULL)
                 return orig;
@@ -164,7 +181,7 @@ static int ohci_s3c2410_hub_control(
          * process the request straight away and exit */
 
         if (info == NULL) {
-                ret = ohci_hub_control(hcd, typeReq, wValue,
+                ret = orig_ohci_hub_control(hcd, typeReq, wValue,
                                        wIndex, buf, wLength);
                 goto out;
         }
@@ -214,7 +231,7 @@ static int ohci_s3c2410_hub_control(
                 break;
         }
 
-        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
         if (ret)
                 goto out;
 
@@ -374,8 +391,6 @@ static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
 
         s3c2410_start_hc(dev, hcd);
 
-        ohci_hcd_init(hcd_to_ohci(hcd));
-
         retval = usb_add_hcd(hcd, dev->resource[1].start, 0);
         if (retval != 0)
                 goto err_ioremap;
@@ -392,71 +407,7 @@ static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
 
 /*-------------------------------------------------------------------------*/
 
-static int
-ohci_s3c2410_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        ret = ohci_init(ohci);
-        if (ret < 0)
-                return ret;
-
-        ret = ohci_run(ohci);
-        if (ret < 0) {
-                dev_err(hcd->self.controller, "can't start %s\n",
-                        hcd->self.bus_name);
-                ohci_stop(hcd);
-                return ret;
-        }
-
-        return 0;
-}
-
-
-static const struct hc_driver ohci_s3c2410_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "S3C24XX OHCI",
-        .hcd_priv_size =        sizeof(struct ohci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ohci_irq,
-        .flags =                HCD_USB11 | HCD_MEMORY,
-
-        /*
-         * basic lifecycle operations
-         */
-        .start =                ohci_s3c2410_start,
-        .stop =                 ohci_stop,
-        .shutdown =             ohci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ohci_urb_enqueue,
-        .urb_dequeue =          ohci_urb_dequeue,
-        .endpoint_disable =     ohci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ohci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ohci_s3c2410_hub_status_data,
-        .hub_control =          ohci_s3c2410_hub_control,
-#ifdef  CONFIG_PM
-        .bus_suspend =          ohci_bus_suspend,
-        .bus_resume =           ohci_bus_resume,
-#endif
-        .start_port_reset =     ohci_start_port_reset,
-};
-
-/* device driver */
+static struct hc_driver __read_mostly ohci_s3c2410_hc_driver;
 
 static int ohci_hcd_s3c2410_drv_probe(struct platform_device *pdev)
 {
@@ -533,4 +484,39 @@ static struct platform_driver ohci_hcd_s3c2410_driver = {
         },
 };
 
+static int __init ohci_s3c2410_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+        ohci_init_driver(&ohci_s3c2410_hc_driver, NULL);
+
+        /*
+         * The Samsung HW has some unusual quirks, which require
+         * Sumsung-specific workarounds. We override certain hc_driver
+         * functions here to achieve that. We explicitly do not enhance
+         * ohci_driver_overrides to allow this more easily, since this
+         * is an unusual case, and we don't want to encourage others to
+         * override these functions by making it too easy.
+         */
+
+        orig_ohci_hub_control = ohci_s3c2410_hc_driver.hub_control;
+        orig_ohci_hub_status_data = ohci_s3c2410_hc_driver.hub_status_data;
+
+        ohci_s3c2410_hc_driver.hub_status_data  = ohci_s3c2410_hub_status_data;
+        ohci_s3c2410_hc_driver.hub_control      = ohci_s3c2410_hub_control;
+
+        return platform_driver_register(&ohci_hcd_s3c2410_driver);
+}
+module_init(ohci_s3c2410_init);
+
+static void __exit ohci_s3c2410_cleanup(void)
+{
+        platform_driver_unregister(&ohci_hcd_s3c2410_driver);
+}
+module_exit(ohci_s3c2410_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:s3c2410-ohci");
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index 17b2a7dad77b..aa9e127bbe71 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -185,6 +185,12 @@ static int ohci_hcd_sa1111_probe(struct sa1111_dev *dev)
         if (usb_disabled())
                 return -ENODEV;
 
+        /*
+         * We don't call dma_set_mask_and_coherent() here because the
+         * DMA mask has already been appropraitely setup by the core
+         * SA-1111 bus code (which includes bug workarounds.)
+         */
+
         hcd = usb_create_hcd(&ohci_sa1111_hc_driver, &dev->dev, "sa1111");
         if (!hcd)
                 return -ENOMEM;
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index d479d5ddab88..2a5de5fecd8f 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -216,14 +216,21 @@ static int ohci_hcd_sm501_drv_remove(struct platform_device *pdev)
 static int ohci_sm501_suspend(struct platform_device *pdev, pm_message_t msg)
 {
         struct device *dev = &pdev->dev;
-        struct ohci_hcd *ohci = hcd_to_ohci(platform_get_drvdata(pdev));
+        struct usb_hcd  *hcd = platform_get_drvdata(pdev);
+        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        bool do_wakeup = device_may_wakeup(dev);
+        int ret;
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
         sm501_unit_power(dev->parent, SM501_GATE_USB_HOST, 0);
-        return 0;
+        return ret;
 }
 
 static int ohci_sm501_resume(struct platform_device *pdev)
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index cc9dd9e4f05e..6b02107d281d 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -11,92 +11,37 @@
 * warranty of any kind, whether express or implied.
 */
 
-#include <linux/signal.h>
-#include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of.h>
+#include <linux/platform_device.h>
+#include <linux/signal.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ohci.h"
 
+#define DRIVER_DESC "OHCI SPEAr driver"
+
+static const char hcd_name[] = "SPEAr-ohci";
 struct spear_ohci {
-        struct ohci_hcd ohci;
         struct clk *clk;
 };
 
-#define to_spear_ohci(hcd)      (struct spear_ohci *)hcd_to_ohci(hcd)
-
-static void spear_start_ohci(struct spear_ohci *ohci)
-{
-        clk_prepare_enable(ohci->clk);
-}
-
-static void spear_stop_ohci(struct spear_ohci *ohci)
-{
-        clk_disable_unprepare(ohci->clk);
-}
-
-static int ohci_spear_start(struct usb_hcd *hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        int ret;
-
-        ret = ohci_init(ohci);
-        if (ret < 0)
-                return ret;
-        ohci->regs = hcd->regs;
-
-        ret = ohci_run(ohci);
-        if (ret < 0) {
-                dev_err(hcd->self.controller, "can't start\n");
-                ohci_stop(hcd);
-                return ret;
-        }
+#define to_spear_ohci(hcd)     (struct spear_ohci *)(hcd_to_ohci(hcd)->priv)
 
-        create_debug_files(ohci);
-
-#ifdef DEBUG
-        ohci_dump(ohci, 1);
-#endif
-        return 0;
-}
-
-static const struct hc_driver ohci_spear_hc_driver = {
-        .description            = hcd_name,
-        .product_desc           = "SPEAr OHCI",
-        .hcd_priv_size          = sizeof(struct spear_ohci),
-
-        /* generic hardware linkage */
-        .irq                    = ohci_irq,
-        .flags                  = HCD_USB11 | HCD_MEMORY,
-
-        /* basic lifecycle operations */
-        .start                  = ohci_spear_start,
-        .stop                   = ohci_stop,
-        .shutdown               = ohci_shutdown,
-#ifdef  CONFIG_PM
-        .bus_suspend            = ohci_bus_suspend,
-        .bus_resume             = ohci_bus_resume,
-#endif
-
-        /* managing i/o requests and associated device resources */
-        .urb_enqueue            = ohci_urb_enqueue,
-        .urb_dequeue            = ohci_urb_dequeue,
-        .endpoint_disable       = ohci_endpoint_disable,
-
-        /* scheduling support */
-        .get_frame_number       = ohci_get_frame,
-
-        /* root hub support */
-        .hub_status_data        = ohci_hub_status_data,
-        .hub_control            = ohci_hub_control,
-
-        .start_port_reset       = ohci_start_port_reset,
-};
+static struct hc_driver __read_mostly ohci_spear_hc_driver;
 
 static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
 {
         const struct hc_driver *driver = &ohci_spear_hc_driver;
+        struct ohci_hcd *ohci;
         struct usb_hcd *hcd = NULL;
         struct clk *usbh_clk;
-        struct spear_ohci *ohci_p;
+        struct spear_ohci *sohci_p;
         struct resource *res;
         int retval, irq;
 
@@ -111,10 +56,9 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail;
 
         usbh_clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(usbh_clk)) {
@@ -151,16 +95,18 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ohci_p = (struct spear_ohci *)hcd_to_ohci(hcd);
-        ohci_p->clk = usbh_clk;
-        spear_start_ohci(ohci_p);
-        ohci_hcd_init(hcd_to_ohci(hcd));
+        sohci_p = to_spear_ohci(hcd);
+        sohci_p->clk = usbh_clk;
+
+        clk_prepare_enable(sohci_p->clk);
+
+        ohci = hcd_to_ohci(hcd);
 
         retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0);
         if (retval == 0)
                 return retval;
 
-        spear_stop_ohci(ohci_p);
+        clk_disable_unprepare(sohci_p->clk);
 err_put_hcd:
         usb_put_hcd(hcd);
 fail:
@@ -172,11 +118,11 @@ fail:
 static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+        struct spear_ohci *sohci_p = to_spear_ohci(hcd);
 
         usb_remove_hcd(hcd);
-        if (ohci_p->clk)
-                spear_stop_ohci(ohci_p);
+        if (sohci_p->clk)
+                clk_disable_unprepare(sohci_p->clk);
 
         usb_put_hcd(hcd);
         return 0;
@@ -188,13 +134,14 @@ static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+        struct spear_ohci *sohci_p = to_spear_ohci(hcd);
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
-        spear_stop_ohci(ohci_p);
+        clk_disable_unprepare(sohci_p->clk);
+
         return 0;
 }
 
@@ -202,13 +149,13 @@ static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct spear_ohci *ohci_p = to_spear_ohci(hcd);
+        struct spear_ohci *sohci_p = to_spear_ohci(hcd);
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
-        spear_start_ohci(ohci_p);
+        clk_prepare_enable(sohci_p->clk);
         ohci_resume(hcd, false);
         return 0;
 }
@@ -234,4 +181,28 @@ static struct platform_driver spear_ohci_hcd_driver = {
         },
 };
 
+static const struct ohci_driver_overrides spear_overrides __initconst = {
+        .extra_priv_size = sizeof(struct spear_ohci),
+};
+static int __init ohci_spear_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ohci_init_driver(&ohci_spear_hc_driver, &spear_overrides);
+        return platform_driver_register(&spear_ohci_hcd_driver);
+}
+module_init(ohci_spear_init);
+
+static void __exit ohci_spear_cleanup(void)
+{
+        platform_driver_unregister(&spear_ohci_hcd_driver);
+}
+module_exit(ohci_spear_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Deepak Sikri");
+MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("platform:spear-ohci");
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index 2c76ef1320ea..dfbdd3aefe98 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -79,11 +79,30 @@
 #define USB_INTEL_USB3_PSSEN   0xD8
 #define USB_INTEL_USB3PRM      0xDC
 
+/*
+ * amd_chipset_gen values represent AMD different chipset generations
+ */
+enum amd_chipset_gen {
+        NOT_AMD_CHIPSET = 0,
+        AMD_CHIPSET_SB600,
+        AMD_CHIPSET_SB700,
+        AMD_CHIPSET_SB800,
+        AMD_CHIPSET_HUDSON2,
+        AMD_CHIPSET_BOLTON,
+        AMD_CHIPSET_YANGTZE,
+        AMD_CHIPSET_UNKNOWN,
+};
+
+struct amd_chipset_type {
+        enum amd_chipset_gen gen;
+        u8 rev;
+};
+
 static struct amd_chipset_info {
         struct pci_dev  *nb_dev;
         struct pci_dev  *smbus_dev;
         int nb_type;
-        int sb_type;
+        struct amd_chipset_type sb_type;
         int isoc_reqs;
         int probe_count;
         int probe_result;
@@ -91,6 +110,51 @@ static struct amd_chipset_info {
 
 static DEFINE_SPINLOCK(amd_lock);
 
+/*
+ * amd_chipset_sb_type_init - initialize amd chipset southbridge type
+ *
+ * AMD FCH/SB generation and revision is identified by SMBus controller
+ * vendor, device and revision IDs.
+ *
+ * Returns: 1 if it is an AMD chipset, 0 otherwise.
+ */
+static int amd_chipset_sb_type_init(struct amd_chipset_info *pinfo)
+{
+        u8 rev = 0;
+        pinfo->sb_type.gen = AMD_CHIPSET_UNKNOWN;
+
+        pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI,
+                        PCI_DEVICE_ID_ATI_SBX00_SMBUS, NULL);
+        if (pinfo->smbus_dev) {
+                rev = pinfo->smbus_dev->revision;
+                if (rev >= 0x10 && rev <= 0x1f)
+                        pinfo->sb_type.gen = AMD_CHIPSET_SB600;
+                else if (rev >= 0x30 && rev <= 0x3f)
+                        pinfo->sb_type.gen = AMD_CHIPSET_SB700;
+                else if (rev >= 0x40 && rev <= 0x4f)
+                        pinfo->sb_type.gen = AMD_CHIPSET_SB800;
+        } else {
+                pinfo->smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
+                                PCI_DEVICE_ID_AMD_HUDSON2_SMBUS, NULL);
+
+                if (!pinfo->smbus_dev) {
+                        pinfo->sb_type.gen = NOT_AMD_CHIPSET;
+                        return 0;
+                }
+
+                rev = pinfo->smbus_dev->revision;
+                if (rev >= 0x11 && rev <= 0x14)
+                        pinfo->sb_type.gen = AMD_CHIPSET_HUDSON2;
+                else if (rev >= 0x15 && rev <= 0x18)
+                        pinfo->sb_type.gen = AMD_CHIPSET_BOLTON;
+                else if (rev >= 0x39 && rev <= 0x3a)
+                        pinfo->sb_type.gen = AMD_CHIPSET_YANGTZE;
+        }
+
+        pinfo->sb_type.rev = rev;
+        return 1;
+}
+
 void sb800_prefetch(struct device *dev, int on)
 {
         u16 misc;
@@ -106,7 +170,6 @@ EXPORT_SYMBOL_GPL(sb800_prefetch);
 
 int usb_amd_find_chipset_info(void)
 {
-        u8 rev = 0;
         unsigned long flags;
         struct amd_chipset_info info;
         int ret;
@@ -122,27 +185,17 @@ int usb_amd_find_chipset_info(void)
         memset(&info, 0, sizeof(info));
         spin_unlock_irqrestore(&amd_lock, flags);
 
-        info.smbus_dev = pci_get_device(PCI_VENDOR_ID_ATI, 0x4385, NULL);
-        if (info.smbus_dev) {
-                rev = info.smbus_dev->revision;
-                if (rev >= 0x40)
-                        info.sb_type = 1;
-                else if (rev >= 0x30 && rev <= 0x3b)
-                        info.sb_type = 3;
-        } else {
-                info.smbus_dev = pci_get_device(PCI_VENDOR_ID_AMD,
-                                                0x780b, NULL);
-                if (!info.smbus_dev) {
-                        ret = 0;
-                        goto commit;
-                }
-
-                rev = info.smbus_dev->revision;
-                if (rev >= 0x11 && rev <= 0x18)
-                        info.sb_type = 2;
+        if (!amd_chipset_sb_type_init(&info)) {
+                ret = 0;
+                goto commit;
         }
 
-        if (info.sb_type == 0) {
+        /* Below chipset generations needn't enable AMD PLL quirk */
+        if (info.sb_type.gen == AMD_CHIPSET_UNKNOWN ||
+                        info.sb_type.gen == AMD_CHIPSET_SB600 ||
+                        info.sb_type.gen == AMD_CHIPSET_YANGTZE ||
+                        (info.sb_type.gen == AMD_CHIPSET_SB700 &&
+                        info.sb_type.rev > 0x3b)) {
                 if (info.smbus_dev) {
                         pci_dev_put(info.smbus_dev);
                         info.smbus_dev = NULL;
@@ -197,6 +250,39 @@ commit:
 }
 EXPORT_SYMBOL_GPL(usb_amd_find_chipset_info);
 
+int usb_hcd_amd_remote_wakeup_quirk(struct pci_dev *pdev)
+{
+        /* Make sure amd chipset type has already been initialized */
+        usb_amd_find_chipset_info();
+        if (amd_chipset.sb_type.gen != AMD_CHIPSET_YANGTZE)
+                return 0;
+
+        dev_dbg(&pdev->dev, "QUIRK: Enable AMD remote wakeup fix\n");
+        return 1;
+}
+EXPORT_SYMBOL_GPL(usb_hcd_amd_remote_wakeup_quirk);
+
+bool usb_amd_hang_symptom_quirk(void)
+{
+        u8 rev;
+
+        usb_amd_find_chipset_info();
+        rev = amd_chipset.sb_type.rev;
+        /* SB600 and old version of SB700 have hang symptom bug */
+        return amd_chipset.sb_type.gen == AMD_CHIPSET_SB600 ||
+                        (amd_chipset.sb_type.gen == AMD_CHIPSET_SB700 &&
+                         rev >= 0x3a && rev <= 0x3b);
+}
+EXPORT_SYMBOL_GPL(usb_amd_hang_symptom_quirk);
+
+bool usb_amd_prefetch_quirk(void)
+{
+        usb_amd_find_chipset_info();
+        /* SB800 needs pre-fetch fix */
+        return amd_chipset.sb_type.gen == AMD_CHIPSET_SB800;
+}
+EXPORT_SYMBOL_GPL(usb_amd_prefetch_quirk);
+
 /*
  * The hardware normally enables the A-link power management feature, which
  * lets the system lower the power consumption in idle states.
@@ -229,7 +315,9 @@ static void usb_amd_quirk_pll(int disable)
                 }
         }
 
-        if (amd_chipset.sb_type == 1 || amd_chipset.sb_type == 2) {
+        if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB800 ||
+                        amd_chipset.sb_type.gen == AMD_CHIPSET_HUDSON2 ||
+                        amd_chipset.sb_type.gen == AMD_CHIPSET_BOLTON) {
                 outb_p(AB_REG_BAR_LOW, 0xcd6);
                 addr_low = inb_p(0xcd7);
                 outb_p(AB_REG_BAR_HIGH, 0xcd6);
@@ -240,7 +328,8 @@ static void usb_amd_quirk_pll(int disable)
                 outl_p(0x40, AB_DATA(addr));
                 outl_p(0x34, AB_INDX(addr));
                 val = inl_p(AB_DATA(addr));
-        } else if (amd_chipset.sb_type == 3) {
+        } else if (amd_chipset.sb_type.gen == AMD_CHIPSET_SB700 &&
+                        amd_chipset.sb_type.rev <= 0x3b) {
                 pci_read_config_dword(amd_chipset.smbus_dev,
                                         AB_REG_BAR_SB700, &addr);
                 outl(AX_INDXC, AB_INDX(addr));
@@ -353,7 +442,7 @@ void usb_amd_dev_put(void)
         amd_chipset.nb_dev = NULL;
         amd_chipset.smbus_dev = NULL;
         amd_chipset.nb_type = 0;
-        amd_chipset.sb_type = 0;
+        memset(&amd_chipset.sb_type, 0, sizeof(amd_chipset.sb_type));
         amd_chipset.isoc_reqs = 0;
         amd_chipset.probe_result = 0;
 
@@ -799,7 +888,7 @@ void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
          * switchable ports.
          */
         pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
-                        cpu_to_le32(ports_available));
+                        ports_available);
 
         pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
                         &ports_available);
@@ -821,7 +910,7 @@ void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
          * host.
          */
         pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
-                        cpu_to_le32(ports_available));
+                        ports_available);
 
         pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
                         &ports_available);
diff --git a/drivers/usb/host/pci-quirks.h b/drivers/usb/host/pci-quirks.h
index ed6700d00fe6..638e88f7a28b 100644
--- a/drivers/usb/host/pci-quirks.h
+++ b/drivers/usb/host/pci-quirks.h
@@ -5,6 +5,8 @@
 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
 int usb_amd_find_chipset_info(void);
+bool usb_amd_hang_symptom_quirk(void);
+bool usb_amd_prefetch_quirk(void);
 void usb_amd_dev_put(void);
 void usb_amd_quirk_pll_disable(void);
 void usb_amd_quirk_pll_enable(void);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 5477bf5df218..79620c39217e 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1413,7 +1413,7 @@ static int sl811h_show(struct seq_file *s, void *unused)
                         case SL11H_CTL1MASK_SE0: s = " se0/reset"; break;
                         case SL11H_CTL1MASK_K: s = " k/resume"; break;
                         default: s = "j"; break;
-                        }; s; }),
+                        } s; }),
                         (t & SL11H_CTL1MASK_LSPD) ? " lowspeed" : "",
                         (t & SL11H_CTL1MASK_SUSPEND) ? " suspend" : "");
 
@@ -1446,7 +1446,7 @@ static int sl811h_show(struct seq_file *s, void *unused)
                         case USB_PID_SETUP: s = "setup"; break;
                         case USB_PID_ACK: s = "status"; break;
                         default: s = "?"; break;
-                        }; s;}),
+                        } s;}),
                         ep->maxpacket,
                         ep->nak_count, ep->error_count);
                 list_for_each_entry (urb, &ep->hep->urb_list, urb_list) {
diff --git a/drivers/usb/host/ssb-hcd.c b/drivers/usb/host/ssb-hcd.c
index 74af2c6287d2..0196f766df73 100644
--- a/drivers/usb/host/ssb-hcd.c
+++ b/drivers/usb/host/ssb-hcd.c
@@ -163,8 +163,7 @@ static int ssb_hcd_probe(struct ssb_device *dev,
 
         /* TODO: Probably need checks here; is the core connected? */
 
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+        if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))
                 return -EOPNOTSUPP;
 
         usb_dev = kzalloc(sizeof(struct ssb_hcd_device), GFP_KERNEL);
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 455737546525..8e239cdd95d5 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -310,14 +310,14 @@ static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
         unsigned short portsc1, portsc2;
 
 
-        usbcmd    = uhci_readw(uhci, 0);
-        usbstat   = uhci_readw(uhci, 2);
-        usbint    = uhci_readw(uhci, 4);
-        usbfrnum  = uhci_readw(uhci, 6);
-        flbaseadd = uhci_readl(uhci, 8);
-        sof       = uhci_readb(uhci, 12);
-        portsc1   = uhci_readw(uhci, 16);
-        portsc2   = uhci_readw(uhci, 18);
+        usbcmd    = uhci_readw(uhci, USBCMD);
+        usbstat   = uhci_readw(uhci, USBSTS);
+        usbint    = uhci_readw(uhci, USBINTR);
+        usbfrnum  = uhci_readw(uhci, USBFRNUM);
+        flbaseadd = uhci_readl(uhci, USBFLBASEADD);
+        sof       = uhci_readb(uhci, USBSOF);
+        portsc1   = uhci_readw(uhci, USBPORTSC1);
+        portsc2   = uhci_readw(uhci, USBPORTSC2);
 
         out += sprintf(out, "  usbcmd    =     %04x   %s%s%s%s%s%s%s%s\n",
                 usbcmd,
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index 9189bc984c98..93e17b12fb33 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -75,8 +75,6 @@ static inline int get_hub_status_data(struct uhci_hcd *uhci, char *buf)
         return !!*buf;
 }
 
-#define OK(x)                   len = (x); break
-
 #define CLR_RH_PORTSTAT(x) \
         status = uhci_readw(uhci, port_addr);   \
         status &= ~(RWC_BITS|WZ_BITS); \
@@ -244,7 +242,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         u16 wIndex, char *buf, u16 wLength)
 {
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
-        int status, lstatus, retval = 0, len = 0;
+        int status, lstatus, retval = 0;
         unsigned int port = wIndex - 1;
         unsigned long port_addr = USBPORTSC1 + 2 * port;
         u16 wPortChange, wPortStatus;
@@ -258,7 +256,8 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
         case GetHubStatus:
                 *(__le32 *)buf = cpu_to_le32(0);
-                OK(4);          /* hub power */
+                retval = 4; /* hub power */
+                break;
         case GetPortStatus:
                 if (port >= uhci->rh_numports)
                         goto err;
@@ -311,13 +310,14 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                 *(__le16 *)buf = cpu_to_le16(wPortStatus);
                 *(__le16 *)(buf + 2) = cpu_to_le16(wPortChange);
-                OK(4);
+                retval = 4;
+                break;
         case SetHubFeature:             /* We don't implement these */
         case ClearHubFeature:
                 switch (wValue) {
                 case C_HUB_OVER_CURRENT:
                 case C_HUB_LOCAL_POWER:
-                        OK(0);
+                        break;
                 default:
                         goto err;
                 }
@@ -329,7 +329,7 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
                         SET_RH_PORTSTAT(USBPORTSC_SUSP);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_RESET:
                         SET_RH_PORTSTAT(USBPORTSC_PR);
 
@@ -338,10 +338,10 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                         /* USB v2.0 7.1.7.5 */
                         uhci->ports_timeout = jiffies + msecs_to_jiffies(50);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_POWER:
                         /* UHCI has no power switching */
-                        OK(0);
+                        break;
                 default:
                         goto err;
                 }
@@ -356,10 +356,10 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                         /* Disable terminates Resume signalling */
                         uhci_finish_suspend(uhci, port, port_addr);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_C_ENABLE:
                         CLR_RH_PORTSTAT(USBPORTSC_PEC);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_SUSPEND:
                         if (!(uhci_readw(uhci, port_addr) & USBPORTSC_SUSP)) {
 
@@ -382,32 +382,32 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                         uhci->ports_timeout = jiffies +
                                                 msecs_to_jiffies(20);
                         }
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(port, &uhci->port_c_suspend);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_POWER:
                         /* UHCI has no power switching */
                         goto err;
                 case USB_PORT_FEAT_C_CONNECTION:
                         CLR_RH_PORTSTAT(USBPORTSC_CSC);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_C_OVER_CURRENT:
                         CLR_RH_PORTSTAT(USBPORTSC_OCC);
-                        OK(0);
+                        break;
                 case USB_PORT_FEAT_C_RESET:
                         /* this driver won't report these */
-                        OK(0);
+                        break;
                 default:
                         goto err;
                 }
                 break;
         case GetHubDescriptor:
-                len = min_t(unsigned int, sizeof(root_hub_hub_des), wLength);
-                memcpy(buf, root_hub_hub_des, len);
-                if (len > 2)
+                retval = min_t(unsigned int, sizeof(root_hub_hub_des), wLength);
+                memcpy(buf, root_hub_hub_des, retval);
+                if (retval > 2)
                         buf[2] = uhci->rh_numports;
-                OK(len);
+                break;
         default:
 err:
                 retval = -EPIPE;
diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
index c300bd2f7d1c..4cd79888804b 100644
--- a/drivers/usb/host/uhci-pci.c
+++ b/drivers/usb/host/uhci-pci.c
@@ -162,6 +162,8 @@ static void uhci_shutdown(struct pci_dev *pdev)
 
 #ifdef CONFIG_PM
 
+static int uhci_pci_resume(struct usb_hcd *hcd, bool hibernated);
+
 static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 {
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
@@ -174,12 +176,6 @@ static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         if (!HCD_HW_ACCESSIBLE(hcd) || uhci->dead)
                 goto done_okay;         /* Already suspended or dead */
 
-        if (uhci->rh_state > UHCI_RH_SUSPENDED) {
-                dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
-                rc = -EBUSY;
-                goto done;
-        };
-
         /* All PCI host controllers are required to disable IRQ generation
          * at the source, so we must turn off PIRQ.
          */
@@ -195,8 +191,15 @@ static int uhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 
 done_okay:
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
-done:
         spin_unlock_irq(&uhci->lock);
+
+        synchronize_irq(hcd->irq);
+
+        /* Check for race with a wakeup request */
+        if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
+                uhci_pci_resume(hcd, false);
+                rc = -EBUSY;
+        }
         return rc;
 }
 
@@ -293,9 +296,11 @@ static struct pci_driver uhci_pci_driver = {
         .remove =       usb_hcd_pci_remove,
         .shutdown =     uhci_shutdown,
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
         .driver =       {
                 .pm =   &usb_hcd_pci_pm_ops
         },
 #endif
 };
+
+MODULE_SOFTDEP("pre: ehci_pci");
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
index d033a0ec7f0d..3003fefaa964 100644
--- a/drivers/usb/host/uhci-platform.c
+++ b/drivers/usb/host/uhci-platform.c
@@ -75,10 +75,9 @@ static int uhci_hcd_platform_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&uhci_platform_hc_driver, &pdev->dev,
                         pdev->name);
@@ -105,8 +104,7 @@ static int uhci_hcd_platform_probe(struct platform_device *pdev)
 
         uhci->regs = hcd->regs;
 
-        ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED |
-                                                                IRQF_SHARED);
+        ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
         if (ret)
                 goto err_uhci;
 
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 041c6ddb695c..da6f56d996ce 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -1303,7 +1303,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
                 }
 
                 /* Fell behind? */
-                if (uhci_frame_before_eq(frame, next)) {
+                if (!uhci_frame_before_eq(next, frame)) {
 
                         /* USB_ISO_ASAP: Round up to the first available slot */
                         if (urb->transfer_flags & URB_ISO_ASAP)
@@ -1311,13 +1311,17 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb,
                                                 -qh->period;
 
                         /*
-                         * Not ASAP: Use the next slot in the stream.  If
-                         * the entire URB falls before the threshold, fail.
+                         * Not ASAP: Use the next slot in the stream,
+                         * no matter what.
                          */
                         else if (!uhci_frame_before_eq(next,
                                         frame + (urb->number_of_packets - 1) *
                                                 qh->period))
-                                return -EXDEV;
+                                dev_dbg(uhci_dev(uhci), "iso underrun %p (%u+%u < %u)\n",
+                                                urb, frame,
+                                                (urb->number_of_packets - 1) *
+                                                        qh->period,
+                                                next);
                 }
         }
 
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index ecc88db804e0..1b0888f8da9a 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -134,7 +134,7 @@ static int whc_urb_enqueue(struct usb_hcd *usb_hcd, struct urb *urb,
         default:
                 ret = asl_urb_enqueue(whc, urb, mem_flags);
                 break;
-        };
+        }
 
         return ret;
 }
@@ -160,7 +160,7 @@ static int whc_urb_dequeue(struct usb_hcd *usb_hcd, struct urb *urb, int status)
         default:
                 ret = asl_urb_dequeue(whc, urb, status);
                 break;
-        };
+        }
 
         return ret;
 }
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index fae697ed0b70..805f2348eeba 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -287,7 +287,7 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
                 if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
                         xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
         }
-        cmd->command_trb = xhci->cmd_ring->enqueue;
+        cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
         xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
         xhci_ring_cmd_db(xhci);
@@ -296,7 +296,7 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
         /* Wait for last stop endpoint command to finish */
         timeleft = wait_for_completion_interruptible_timeout(
                         cmd->completion,
-                        USB_CTRL_SET_TIMEOUT);
+                        XHCI_CMD_DEFAULT_TIMEOUT);
         if (timeleft <= 0) {
                 xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
                                 timeleft == 0 ? "Timeout" : "Signal");
@@ -524,7 +524,8 @@ static void xhci_hub_report_usb3_link_state(u32 *status, u32 status_reg)
  * the compliance mode timer is deleted. A port won't enter
  * compliance mode if it has previously entered U0.
  */
-void xhci_del_comp_mod_timer(struct xhci_hcd *xhci, u32 status, u16 wIndex)
+static void xhci_del_comp_mod_timer(struct xhci_hcd *xhci, u32 status,
+                                    u16 wIndex)
 {
         u32 all_ports_seen_u0 = ((1 << xhci->num_usb3_ports)-1);
         bool port_in_u0 = ((status & PORT_PLS_MASK) == XDEV_U0);
@@ -552,11 +553,15 @@ void xhci_del_comp_mod_timer(struct xhci_hcd *xhci, u32 status, u16 wIndex)
  *  - Mark a port as being done with device resume,
  *    and ring the endpoint doorbells.
  *  - Stop the Synopsys redriver Compliance Mode polling.
+ *  - Drop and reacquire the xHCI lock, in order to wait for port resume.
  */
 static u32 xhci_get_port_status(struct usb_hcd *hcd,
                 struct xhci_bus_state *bus_state,
                 __le32 __iomem **port_array,
-                u16 wIndex, u32 raw_port_status)
+                u16 wIndex, u32 raw_port_status,
+                unsigned long flags)
+        __releases(&xhci->lock)
+        __acquires(&xhci->lock)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         u32 status = 0;
@@ -591,21 +596,42 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd,
                         return 0xffffffff;
                 if (time_after_eq(jiffies,
                                         bus_state->resume_done[wIndex])) {
+                        int time_left;
+
                         xhci_dbg(xhci, "Resume USB2 port %d\n",
                                         wIndex + 1);
                         bus_state->resume_done[wIndex] = 0;
                         clear_bit(wIndex, &bus_state->resuming_ports);
+
+                        set_bit(wIndex, &bus_state->rexit_ports);
                         xhci_set_link_state(xhci, port_array, wIndex,
                                         XDEV_U0);
-                        xhci_dbg(xhci, "set port %d resume\n",
-                                        wIndex + 1);
-                        slot_id = xhci_find_slot_id_by_port(hcd, xhci,
-                                        wIndex + 1);
-                        if (!slot_id) {
-                                xhci_dbg(xhci, "slot_id is zero\n");
-                                return 0xffffffff;
+
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        time_left = wait_for_completion_timeout(
+                                        &bus_state->rexit_done[wIndex],
+                                        msecs_to_jiffies(
+                                                XHCI_MAX_REXIT_TIMEOUT));
+                        spin_lock_irqsave(&xhci->lock, flags);
+
+                        if (time_left) {
+                                slot_id = xhci_find_slot_id_by_port(hcd,
+                                                xhci, wIndex + 1);
+                                if (!slot_id) {
+                                        xhci_dbg(xhci, "slot_id is zero\n");
+                                        return 0xffffffff;
+                                }
+                                xhci_ring_device(xhci, slot_id);
+                        } else {
+                                int port_status = xhci_readl(xhci,
+                                                port_array[wIndex]);
+                                xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",
+                                                XHCI_MAX_REXIT_TIMEOUT,
+                                                port_status);
+                                status |= USB_PORT_STAT_SUSPEND;
+                                clear_bit(wIndex, &bus_state->rexit_ports);
                         }
-                        xhci_ring_device(xhci, slot_id);
+
                         bus_state->port_c_suspend |= 1 << wIndex;
                         bus_state->suspended_ports &= ~(1 << wIndex);
                 } else {
@@ -728,7 +754,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         break;
                 }
                 status = xhci_get_port_status(hcd, bus_state, port_array,
-                                wIndex, temp);
+                                wIndex, temp, flags);
                 if (status == 0xffffffff)
                         goto error;
 
@@ -1132,18 +1158,6 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
                 t1 = xhci_port_state_to_neutral(t1);
                 if (t1 != t2)
                         xhci_writel(xhci, t2, port_array[port_index]);
-
-                if (hcd->speed != HCD_USB3) {
-                        /* enable remote wake up for USB 2.0 */
-                        __le32 __iomem *addr;
-                        u32 tmp;
-
-                        /* Get the port power control register address. */
-                        addr = port_array[port_index] + PORTPMSC;
-                        tmp = xhci_readl(xhci, addr);
-                        tmp |= PORT_RWE;
-                        xhci_writel(xhci, tmp, addr);
-                }
         }
         hcd->state = HC_STATE_SUSPENDED;
         bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
@@ -1222,20 +1236,6 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                                 xhci_ring_device(xhci, slot_id);
                 } else
                         xhci_writel(xhci, temp, port_array[port_index]);
-
-                if (hcd->speed != HCD_USB3) {
-                        /* disable remote wake up for USB 2.0 */
-                        __le32 __iomem *addr;
-                        u32 tmp;
-
-                        /* Add one to the port status register address to get
-                         * the port power control register address.
-                         */
-                        addr = port_array[port_index] + PORTPMSC;
-                        tmp = xhci_readl(xhci, addr);
-                        tmp &= ~PORT_RWE;
-                        xhci_writel(xhci, tmp, addr);
-                }
         }
 
         (void) xhci_readl(xhci, &xhci->op_regs->command);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 53b972c2a09f..49b8bd063fab 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1693,9 +1693,7 @@ void xhci_free_command(struct xhci_hcd *xhci,
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
-        struct dev_info *dev_info, *next;
         struct xhci_cd  *cur_cd, *next_cd;
-        unsigned long   flags;
         int size;
         int i, j, num_ports;
 
@@ -1756,13 +1754,6 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
 
         scratchpad_free(xhci);
 
-        spin_lock_irqsave(&xhci->lock, flags);
-        list_for_each_entry_safe(dev_info, next, &xhci->lpm_failed_devs, list) {
-                list_del(&dev_info->list);
-                kfree(dev_info);
-        }
-        spin_unlock_irqrestore(&xhci->lock, flags);
-
         if (!xhci->rh_bw)
                 goto no_bw;
 
@@ -2231,7 +2222,6 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         u32 page_size, temp;
         int i;
 
-        INIT_LIST_HEAD(&xhci->lpm_failed_devs);
         INIT_LIST_HEAD(&xhci->cancel_cmd_list);
 
         page_size = xhci_readl(xhci, &xhci->op_regs->page_size);
@@ -2428,6 +2418,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         for (i = 0; i < USB_MAXCHILDREN; ++i) {
                 xhci->bus_state[0].resume_done[i] = 0;
                 xhci->bus_state[1].resume_done[i] = 0;
+                /* Only the USB 2.0 completions will ever be used. */
+                init_completion(&xhci->bus_state[1].rexit_done[i]);
         }
 
         if (scratchpad_alloc(xhci, flags))
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index c2d495057eb5..b8dffd59eb25 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -35,6 +35,9 @@
 #define PCI_VENDOR_ID_ETRON             0x1b6f
 #define PCI_DEVICE_ID_ASROCK_P67        0x7023
 
+#define PCI_DEVICE_ID_INTEL_LYNXPOINT_XHCI      0x8c31
+#define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI   0x9c31
+
 static const char hcd_name[] = "xhci_hcd";
 
 /* called after powerup, by probe or system-pm "wakeup" */
@@ -69,6 +72,14 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                                 "QUIRK: Fresco Logic xHC needs configure"
                                 " endpoint cmd after reset endpoint");
                 }
+                if (pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK &&
+                                pdev->revision == 0x4) {
+                        xhci->quirks |= XHCI_SLOW_SUSPEND;
+                        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
+                                "QUIRK: Fresco Logic xHC revision %u"
+                                "must be suspended extra slowly",
+                                pdev->revision);
+                }
                 /* Fresco Logic confirms: all revisions of this chip do not
                  * support MSI, even though some of them claim to in their PCI
                  * capabilities.
@@ -110,6 +121,15 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 xhci->quirks |= XHCI_SPURIOUS_REBOOT;
                 xhci->quirks |= XHCI_AVOID_BEI;
         }
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+            (pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_XHCI ||
+             pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI)) {
+                /* Workaround for occasional spurious wakeups from S5 (or
+                 * any other sleep) on Haswell machines with LPT and LPT-LP
+                 * with the new Intel BIOS
+                 */
+                xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
+        }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
@@ -217,6 +237,11 @@ static void xhci_pci_remove(struct pci_dev *dev)
                 usb_put_hcd(xhci->shared_hcd);
         }
         usb_hcd_pci_remove(dev);
+
+        /* Workaround for spurious wakeups at shutdown with HSW */
+        if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
+                pci_set_power_state(dev, PCI_D3hot);
+
         kfree(xhci);
 }
 
@@ -351,7 +376,7 @@ static struct pci_driver xhci_pci_driver = {
         /* suspend and resume implemented later */
 
         .shutdown =     usb_hcd_pci_shutdown,
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM
         .driver = {
                 .pm = &usb_hcd_pci_pm_ops
         },
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 411da1fc7ae8..1e2f3f495843 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -123,6 +123,16 @@ static int enqueue_is_link_trb(struct xhci_ring *ring)
         return TRB_TYPE_LINK_LE32(link->control);
 }
 
+union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring)
+{
+        /* Enqueue pointer can be left pointing to the link TRB,
+         * we must handle that
+         */
+        if (TRB_TYPE_LINK_LE32(ring->enqueue->link.control))
+                return ring->enq_seg->next->trbs;
+        return ring->enqueue;
+}
+
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
  * TRB is in a new segment.  This does not skip over link TRBs, and it does not
  * effect the ring dequeue or enqueue pointers.
@@ -168,7 +178,7 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring)
                         if (ring->type == TYPE_EVENT &&
                                         last_trb_on_last_seg(xhci, ring,
                                                 ring->deq_seg, ring->dequeue)) {
-                                ring->cycle_state = (ring->cycle_state ? 0 : 1);
+                                ring->cycle_state ^= 1;
                         }
                         ring->deq_seg = ring->deq_seg->next;
                         ring->dequeue = ring->deq_seg->trbs;
@@ -716,7 +726,7 @@ static void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
 
 /* Must be called with xhci->lock held in interrupt context */
 static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
-                struct xhci_td *cur_td, int status, char *adjective)
+                struct xhci_td *cur_td, int status)
 {
         struct usb_hcd *hcd;
         struct urb      *urb;
@@ -755,10 +765,9 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
  *  2. Otherwise, we turn all the TRBs in the TD into No-op TRBs (with the chain
  *     bit cleared) so that the HW will skip over them.
  */
-static void handle_stopped_endpoint(struct xhci_hcd *xhci,
+static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
                 union xhci_trb *trb, struct xhci_event_cmd *event)
 {
-        unsigned int slot_id;
         unsigned int ep_index;
         struct xhci_virt_device *virt_dev;
         struct xhci_ring *ep_ring;
@@ -769,10 +778,7 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
 
         struct xhci_dequeue_state deq_state;
 
-        if (unlikely(TRB_TO_SUSPEND_PORT(
-                             le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])))) {
-                slot_id = TRB_TO_SLOT_ID(
-                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
+        if (unlikely(TRB_TO_SUSPEND_PORT(le32_to_cpu(trb->generic.field[3])))) {
                 virt_dev = xhci->devs[slot_id];
                 if (virt_dev)
                         handle_cmd_in_cmd_wait_list(xhci, virt_dev,
@@ -785,7 +791,6 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
         }
 
         memset(&deq_state, 0, sizeof(deq_state));
-        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
         ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         ep = &xhci->devs[slot_id]->eps[ep_index];
 
@@ -859,8 +864,12 @@ remove_finished_td:
                 /* Otherwise ring the doorbell(s) to restart queued transfers */
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
         }
-        ep->stopped_td = NULL;
-        ep->stopped_trb = NULL;
+
+        /* Clear stopped_td and stopped_trb if endpoint is not halted */
+        if (!(ep->ep_state & EP_HALTED)) {
+                ep->stopped_td = NULL;
+                ep->stopped_trb = NULL;
+        }
 
         /*
          * Drop the lock and complete the URBs in the cancelled TD list.
@@ -877,7 +886,7 @@ remove_finished_td:
                 /* Doesn't matter what we pass for status, since the core will
                  * just overwrite it (because the URB has been unlinked).
                  */
-                xhci_giveback_urb_in_irq(xhci, cur_td, 0, "cancelled");
+                xhci_giveback_urb_in_irq(xhci, cur_td, 0);
 
                 /* Stop processing the cancelled list if the watchdog timer is
                  * running.
@@ -987,7 +996,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                 if (!list_empty(&cur_td->cancelled_td_list))
                                         list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
-                                                -ESHUTDOWN, "killed");
+                                                -ESHUTDOWN);
                         }
                         while (!list_empty(&temp_ep->cancelled_td_list)) {
                                 cur_td = list_first_entry(
@@ -996,7 +1005,7 @@ void xhci_stop_endpoint_command_watchdog(unsigned long arg)
                                                 cancelled_td_list);
                                 list_del_init(&cur_td->cancelled_td_list);
                                 xhci_giveback_urb_in_irq(xhci, cur_td,
-                                                -ESHUTDOWN, "killed");
+                                                -ESHUTDOWN);
                         }
                 }
         }
@@ -1063,11 +1072,9 @@ static void update_ring_for_set_deq_completion(struct xhci_hcd *xhci,
  * endpoint doorbell to restart the ring, but only if there aren't more
  * cancellations pending.
  */
-static void handle_set_deq_completion(struct xhci_hcd *xhci,
-                struct xhci_event_cmd *event,
-                union xhci_trb *trb)
+static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
+                union xhci_trb *trb, u32 cmd_comp_code)
 {
-        unsigned int slot_id;
         unsigned int ep_index;
         unsigned int stream_id;
         struct xhci_ring *ep_ring;
@@ -1075,7 +1082,6 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         struct xhci_ep_ctx *ep_ctx;
         struct xhci_slot_ctx *slot_ctx;
 
-        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
         ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         stream_id = TRB_TO_STREAM_ID(le32_to_cpu(trb->generic.field[2]));
         dev = xhci->devs[slot_id];
@@ -1093,11 +1099,11 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
         slot_ctx = xhci_get_slot_ctx(xhci, dev->out_ctx);
 
-        if (GET_COMP_CODE(le32_to_cpu(event->status)) != COMP_SUCCESS) {
+        if (cmd_comp_code != COMP_SUCCESS) {
                 unsigned int ep_state;
                 unsigned int slot_state;
 
-                switch (GET_COMP_CODE(le32_to_cpu(event->status))) {
+                switch (cmd_comp_code) {
                 case COMP_TRB_ERR:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd invalid because "
                                         "of stream ID configuration\n");
@@ -1120,7 +1126,7 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
                 default:
                         xhci_warn(xhci, "WARN Set TR Deq Ptr cmd with unknown "
                                         "completion code of %u.\n",
-                                  GET_COMP_CODE(le32_to_cpu(event->status)));
+                                  cmd_comp_code);
                         break;
                 }
                 /* OK what do we do now?  The endpoint state is hosed, and we
@@ -1157,21 +1163,17 @@ static void handle_set_deq_completion(struct xhci_hcd *xhci,
         ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
 }
 
-static void handle_reset_ep_completion(struct xhci_hcd *xhci,
-                struct xhci_event_cmd *event,
-                union xhci_trb *trb)
+static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
+                union xhci_trb *trb, u32 cmd_comp_code)
 {
-        int slot_id;
         unsigned int ep_index;
 
-        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(trb->generic.field[3]));
         ep_index = TRB_TO_EP_INDEX(le32_to_cpu(trb->generic.field[3]));
         /* This command will only fail if the endpoint wasn't halted,
          * but we don't care.
          */
         xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
-                "Ignoring reset ep completion code of %u",
-                 GET_COMP_CODE(le32_to_cpu(event->status)));
+                "Ignoring reset ep completion code of %u", cmd_comp_code);
 
         /* HW with the reset endpoint quirk needs to have a configure endpoint
          * command complete before the endpoint can be used.  Queue that here
@@ -1372,21 +1374,149 @@ static int handle_stopped_cmd_ring(struct xhci_hcd *xhci,
         return cur_trb_is_good;
 }
 
+static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
+                u32 cmd_comp_code)
+{
+        if (cmd_comp_code == COMP_SUCCESS)
+                xhci->slot_id = slot_id;
+        else
+                xhci->slot_id = 0;
+        complete(&xhci->addr_dev);
+}
+
+static void xhci_handle_cmd_disable_slot(struct xhci_hcd *xhci, int slot_id)
+{
+        struct xhci_virt_device *virt_dev;
+
+        virt_dev = xhci->devs[slot_id];
+        if (!virt_dev)
+                return;
+        if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
+                /* Delete default control endpoint resources */
+                xhci_free_device_endpoint_resources(xhci, virt_dev, true);
+        xhci_free_virt_device(xhci, slot_id);
+}
+
+static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
+                struct xhci_event_cmd *event, u32 cmd_comp_code)
+{
+        struct xhci_virt_device *virt_dev;
+        struct xhci_input_control_ctx *ctrl_ctx;
+        unsigned int ep_index;
+        unsigned int ep_state;
+        u32 add_flags, drop_flags;
+
+        virt_dev = xhci->devs[slot_id];
+        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
+                return;
+        /*
+         * Configure endpoint commands can come from the USB core
+         * configuration or alt setting changes, or because the HW
+         * needed an extra configure endpoint command after a reset
+         * endpoint command or streams were being configured.
+         * If the command was for a halted endpoint, the xHCI driver
+         * is not waiting on the configure endpoint command.
+         */
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        if (!ctrl_ctx) {
+                xhci_warn(xhci, "Could not get input context, bad type.\n");
+                return;
+        }
+
+        add_flags = le32_to_cpu(ctrl_ctx->add_flags);
+        drop_flags = le32_to_cpu(ctrl_ctx->drop_flags);
+        /* Input ctx add_flags are the endpoint index plus one */
+        ep_index = xhci_last_valid_endpoint(add_flags) - 1;
+
+        /* A usb_set_interface() call directly after clearing a halted
+         * condition may race on this quirky hardware.  Not worth
+         * worrying about, since this is prototype hardware.  Not sure
+         * if this will work for streams, but streams support was
+         * untested on this prototype.
+         */
+        if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
+                        ep_index != (unsigned int) -1 &&
+                        add_flags - SLOT_FLAG == drop_flags) {
+                ep_state = virt_dev->eps[ep_index].ep_state;
+                if (!(ep_state & EP_HALTED))
+                        goto bandwidth_change;
+                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
+                                "Completed config ep cmd - "
+                                "last ep index = %d, state = %d",
+                                ep_index, ep_state);
+                /* Clear internal halted state and restart ring(s) */
+                virt_dev->eps[ep_index].ep_state &= ~EP_HALTED;
+                ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
+                return;
+        }
+bandwidth_change:
+        xhci_dbg_trace(xhci,  trace_xhci_dbg_context_change,
+                        "Completed config ep cmd");
+        virt_dev->cmd_status = cmd_comp_code;
+        complete(&virt_dev->cmd_completion);
+        return;
+}
+
+static void xhci_handle_cmd_eval_ctx(struct xhci_hcd *xhci, int slot_id,
+                struct xhci_event_cmd *event, u32 cmd_comp_code)
+{
+        struct xhci_virt_device *virt_dev;
+
+        virt_dev = xhci->devs[slot_id];
+        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
+                return;
+        virt_dev->cmd_status = cmd_comp_code;
+        complete(&virt_dev->cmd_completion);
+}
+
+static void xhci_handle_cmd_addr_dev(struct xhci_hcd *xhci, int slot_id,
+                u32 cmd_comp_code)
+{
+        xhci->devs[slot_id]->cmd_status = cmd_comp_code;
+        complete(&xhci->addr_dev);
+}
+
+static void xhci_handle_cmd_reset_dev(struct xhci_hcd *xhci, int slot_id,
+                struct xhci_event_cmd *event)
+{
+        struct xhci_virt_device *virt_dev;
+
+        xhci_dbg(xhci, "Completed reset device command.\n");
+        virt_dev = xhci->devs[slot_id];
+        if (virt_dev)
+                handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
+        else
+                xhci_warn(xhci, "Reset device command completion "
+                                "for disabled slot %u\n", slot_id);
+}
+
+static void xhci_handle_cmd_nec_get_fw(struct xhci_hcd *xhci,
+                struct xhci_event_cmd *event)
+{
+        if (!(xhci->quirks & XHCI_NEC_HOST)) {
+                xhci->error_bitmask |= 1 << 6;
+                return;
+        }
+        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
+                        "NEC firmware version %2x.%02x",
+                        NEC_FW_MAJOR(le32_to_cpu(event->status)),
+                        NEC_FW_MINOR(le32_to_cpu(event->status)));
+}
+
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
         int slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->flags));
         u64 cmd_dma;
         dma_addr_t cmd_dequeue_dma;
-        struct xhci_input_control_ctx *ctrl_ctx;
-        struct xhci_virt_device *virt_dev;
-        unsigned int ep_index;
-        struct xhci_ring *ep_ring;
-        unsigned int ep_state;
+        u32 cmd_comp_code;
+        union xhci_trb *cmd_trb;
+        u32 cmd_type;
 
         cmd_dma = le64_to_cpu(event->cmd_trb);
+        cmd_trb = xhci->cmd_ring->dequeue;
         cmd_dequeue_dma = xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
-                        xhci->cmd_ring->dequeue);
+                        cmd_trb);
         /* Is the command ring deq ptr out of sync with the deq seg ptr? */
         if (cmd_dequeue_dma == 0) {
                 xhci->error_bitmask |= 1 << 4;
@@ -1398,135 +1528,69 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 return;
         }
 
-        trace_xhci_cmd_completion(&xhci->cmd_ring->dequeue->generic,
-                                        (struct xhci_generic_trb *) event);
+        trace_xhci_cmd_completion(cmd_trb, (struct xhci_generic_trb *) event);
 
-        if ((GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_CMD_ABORT) ||
-                (GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_CMD_STOP)) {
+        cmd_comp_code = GET_COMP_CODE(le32_to_cpu(event->status));
+        if (cmd_comp_code == COMP_CMD_ABORT || cmd_comp_code == COMP_CMD_STOP) {
                 /* If the return value is 0, we think the trb pointed by
                  * command ring dequeue pointer is a good trb. The good
                  * trb means we don't want to cancel the trb, but it have
                  * been stopped by host. So we should handle it normally.
                  * Otherwise, driver should invoke inc_deq() and return.
                  */
-                if (handle_stopped_cmd_ring(xhci,
-                                GET_COMP_CODE(le32_to_cpu(event->status)))) {
+                if (handle_stopped_cmd_ring(xhci, cmd_comp_code)) {
                         inc_deq(xhci, xhci->cmd_ring);
                         return;
                 }
+                /* There is no command to handle if we get a stop event when the
+                 * command ring is empty, event->cmd_trb points to the next
+                 * unset command
+                 */
+                if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
+                        return;
         }
 
-        switch (le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])
-                & TRB_TYPE_BITMASK) {
-        case TRB_TYPE(TRB_ENABLE_SLOT):
-                if (GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_SUCCESS)
-                        xhci->slot_id = slot_id;
-                else
-                        xhci->slot_id = 0;
-                complete(&xhci->addr_dev);
+        cmd_type = TRB_FIELD_TO_TYPE(le32_to_cpu(cmd_trb->generic.field[3]));
+        switch (cmd_type) {
+        case TRB_ENABLE_SLOT:
+                xhci_handle_cmd_enable_slot(xhci, slot_id, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_DISABLE_SLOT):
-                if (xhci->devs[slot_id]) {
-                        if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
-                                /* Delete default control endpoint resources */
-                                xhci_free_device_endpoint_resources(xhci,
-                                                xhci->devs[slot_id], true);
-                        xhci_free_virt_device(xhci, slot_id);
-                }
+        case TRB_DISABLE_SLOT:
+                xhci_handle_cmd_disable_slot(xhci, slot_id);
                 break;
-        case TRB_TYPE(TRB_CONFIG_EP):
-                virt_dev = xhci->devs[slot_id];
-                if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                        break;
-                /*
-                 * Configure endpoint commands can come from the USB core
-                 * configuration or alt setting changes, or because the HW
-                 * needed an extra configure endpoint command after a reset
-                 * endpoint command or streams were being configured.
-                 * If the command was for a halted endpoint, the xHCI driver
-                 * is not waiting on the configure endpoint command.
-                 */
-                ctrl_ctx = xhci_get_input_control_ctx(xhci,
-                                virt_dev->in_ctx);
-                if (!ctrl_ctx) {
-                        xhci_warn(xhci, "Could not get input context, bad type.\n");
-                        break;
-                }
-                /* Input ctx add_flags are the endpoint index plus one */
-                ep_index = xhci_last_valid_endpoint(le32_to_cpu(ctrl_ctx->add_flags)) - 1;
-                /* A usb_set_interface() call directly after clearing a halted
-                 * condition may race on this quirky hardware.  Not worth
-                 * worrying about, since this is prototype hardware.  Not sure
-                 * if this will work for streams, but streams support was
-                 * untested on this prototype.
-                 */
-                if (xhci->quirks & XHCI_RESET_EP_QUIRK &&
-                                ep_index != (unsigned int) -1 &&
-                    le32_to_cpu(ctrl_ctx->add_flags) - SLOT_FLAG ==
-                    le32_to_cpu(ctrl_ctx->drop_flags)) {
-                        ep_ring = xhci->devs[slot_id]->eps[ep_index].ring;
-                        ep_state = xhci->devs[slot_id]->eps[ep_index].ep_state;
-                        if (!(ep_state & EP_HALTED))
-                                goto bandwidth_change;
-                        xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
-                                        "Completed config ep cmd - "
-                                        "last ep index = %d, state = %d",
-                                        ep_index, ep_state);
-                        /* Clear internal halted state and restart ring(s) */
-                        xhci->devs[slot_id]->eps[ep_index].ep_state &=
-                                ~EP_HALTED;
-                        ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
-                        break;
-                }
-bandwidth_change:
-                xhci_dbg_trace(xhci,  trace_xhci_dbg_context_change,
-                                "Completed config ep cmd");
-                xhci->devs[slot_id]->cmd_status =
-                        GET_COMP_CODE(le32_to_cpu(event->status));
-                complete(&xhci->devs[slot_id]->cmd_completion);
+        case TRB_CONFIG_EP:
+                xhci_handle_cmd_config_ep(xhci, slot_id, event, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_EVAL_CONTEXT):
-                virt_dev = xhci->devs[slot_id];
-                if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                        break;
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
-                complete(&xhci->devs[slot_id]->cmd_completion);
+        case TRB_EVAL_CONTEXT:
+                xhci_handle_cmd_eval_ctx(xhci, slot_id, event, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_ADDR_DEV):
-                xhci->devs[slot_id]->cmd_status = GET_COMP_CODE(le32_to_cpu(event->status));
-                complete(&xhci->addr_dev);
+        case TRB_ADDR_DEV:
+                xhci_handle_cmd_addr_dev(xhci, slot_id, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_STOP_RING):
-                handle_stopped_endpoint(xhci, xhci->cmd_ring->dequeue, event);
+        case TRB_STOP_RING:
+                WARN_ON(slot_id != TRB_TO_SLOT_ID(
+                                le32_to_cpu(cmd_trb->generic.field[3])));
+                xhci_handle_cmd_stop_ep(xhci, slot_id, cmd_trb, event);
                 break;
-        case TRB_TYPE(TRB_SET_DEQ):
-                handle_set_deq_completion(xhci, event, xhci->cmd_ring->dequeue);
+        case TRB_SET_DEQ:
+                WARN_ON(slot_id != TRB_TO_SLOT_ID(
+                                le32_to_cpu(cmd_trb->generic.field[3])));
+                xhci_handle_cmd_set_deq(xhci, slot_id, cmd_trb, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_CMD_NOOP):
+        case TRB_CMD_NOOP:
                 break;
-        case TRB_TYPE(TRB_RESET_EP):
-                handle_reset_ep_completion(xhci, event, xhci->cmd_ring->dequeue);
+        case TRB_RESET_EP:
+                WARN_ON(slot_id != TRB_TO_SLOT_ID(
+                                le32_to_cpu(cmd_trb->generic.field[3])));
+                xhci_handle_cmd_reset_ep(xhci, slot_id, cmd_trb, cmd_comp_code);
                 break;
-        case TRB_TYPE(TRB_RESET_DEV):
-                xhci_dbg(xhci, "Completed reset device command.\n");
-                slot_id = TRB_TO_SLOT_ID(
-                        le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3]));
-                virt_dev = xhci->devs[slot_id];
-                if (virt_dev)
-                        handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
-                else
-                        xhci_warn(xhci, "Reset device command completion "
-                                        "for disabled slot %u\n", slot_id);
+        case TRB_RESET_DEV:
+                WARN_ON(slot_id != TRB_TO_SLOT_ID(
+                                le32_to_cpu(cmd_trb->generic.field[3])));
+                xhci_handle_cmd_reset_dev(xhci, slot_id, event);
                 break;
-        case TRB_TYPE(TRB_NEC_GET_FW):
-                if (!(xhci->quirks & XHCI_NEC_HOST)) {
-                        xhci->error_bitmask |= 1 << 6;
-                        break;
-                }
-                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
-                        "NEC firmware version %2x.%02x",
-                         NEC_FW_MAJOR(le32_to_cpu(event->status)),
-                         NEC_FW_MINOR(le32_to_cpu(event->status)));
+        case TRB_NEC_GET_FW:
+                xhci_handle_cmd_nec_get_fw(xhci, event);
                 break;
         default:
                 /* Skip over unknown commands on the event ring */
@@ -1743,6 +1807,19 @@ static void handle_port_status(struct xhci_hcd *xhci,
                 }
         }
 
+        /*
+         * Check to see if xhci-hub.c is waiting on RExit to U0 transition (or
+         * RExit to a disconnect state).  If so, let the the driver know it's
+         * out of the RExit state.
+         */
+        if (!DEV_SUPERSPEED(temp) &&
+                        test_and_clear_bit(faked_port_index,
+                                &bus_state->rexit_ports)) {
+                complete(&bus_state->rexit_done[faked_port_index]);
+                bogus_port_status = true;
+                goto cleanup;
+        }
+
         if (hcd->speed != HCD_USB3)
                 xhci_test_and_clear_bit(xhci, port_array, faked_port_index,
                                         PORT_PLC);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 49b6edb84a79..4265b48856f6 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -730,6 +730,9 @@ void xhci_shutdown(struct usb_hcd *hcd)
 
         spin_lock_irq(&xhci->lock);
         xhci_halt(xhci);
+        /* Workaround for spurious wakeups at shutdown with HSW */
+        if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
+                xhci_reset(xhci);
         spin_unlock_irq(&xhci->lock);
 
         xhci_cleanup_msix(xhci);
@@ -737,6 +740,10 @@ void xhci_shutdown(struct usb_hcd *hcd)
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "xhci_shutdown completed - status = %x",
                         xhci_readl(xhci, &xhci->op_regs->status));
+
+        /* Yet another workaround for spurious wakeups at shutdown with HSW */
+        if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
+                pci_set_power_state(to_pci_dev(hcd->self.controller), PCI_D3hot);
 }
 
 #ifdef CONFIG_PM
@@ -839,6 +846,7 @@ static void xhci_clear_command_ring(struct xhci_hcd *xhci)
 int xhci_suspend(struct xhci_hcd *xhci)
 {
         int                     rc = 0;
+        unsigned int            delay = XHCI_MAX_HALT_USEC;
         struct usb_hcd          *hcd = xhci_to_hcd(xhci);
         u32                     command;
 
@@ -861,8 +869,12 @@ int xhci_suspend(struct xhci_hcd *xhci)
         command = xhci_readl(xhci, &xhci->op_regs->command);
         command &= ~CMD_RUN;
         xhci_writel(xhci, command, &xhci->op_regs->command);
+
+        /* Some chips from Fresco Logic need an extraordinary delay */
+        delay *= (xhci->quirks & XHCI_SLOW_SUSPEND) ? 10 : 1;
+
         if (xhci_handshake(xhci, &xhci->op_regs->status,
-                      STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC)) {
+                      STS_HALT, STS_HALT, delay)) {
                 xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n");
                 spin_unlock_irq(&xhci->lock);
                 return -ETIMEDOUT;
@@ -2598,15 +2610,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         if (command) {
                 cmd_completion = command->completion;
                 cmd_status = &command->status;
-                command->command_trb = xhci->cmd_ring->enqueue;
-
-                /* Enqueue pointer can be left pointing to the link TRB,
-                 * we must handle that
-                 */
-                if (TRB_TYPE_LINK_LE32(command->command_trb->link.control))
-                        command->command_trb =
-                                xhci->cmd_ring->enq_seg->next->trbs;
-
+                command->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
                 list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
         } else {
                 cmd_completion = &virt_dev->cmd_completion;
@@ -2614,7 +2618,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         }
         init_completion(cmd_completion);
 
-        cmd_trb = xhci->cmd_ring->dequeue;
+        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         if (!ctx_change)
                 ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
                                 udev->slot_id, must_succeed);
@@ -3439,14 +3443,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Attempt to submit the Reset Device command to the command ring */
         spin_lock_irqsave(&xhci->lock, flags);
-        reset_device_cmd->command_trb = xhci->cmd_ring->enqueue;
-
-        /* Enqueue pointer can be left pointing to the link TRB,
-         * we must handle that
-         */
-        if (TRB_TYPE_LINK_LE32(reset_device_cmd->command_trb->link.control))
-                reset_device_cmd->command_trb =
-                        xhci->cmd_ring->enq_seg->next->trbs;
+        reset_device_cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
 
         list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
         ret = xhci_queue_reset_device(xhci, slot_id);
@@ -3462,7 +3459,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         /* Wait for the Reset Device command to finish */
         timeleft = wait_for_completion_interruptible_timeout(
                         reset_device_cmd->completion,
-                        USB_CTRL_SET_TIMEOUT);
+                        XHCI_CMD_DEFAULT_TIMEOUT);
         if (timeleft <= 0) {
                 xhci_warn(xhci, "%s while waiting for reset device command\n",
                                 timeleft == 0 ? "Timeout" : "Signal");
@@ -3586,11 +3583,6 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 del_timer_sync(&virt_dev->eps[i].stop_cmd_timer);
         }
 
-        if (udev->usb2_hw_lpm_enabled) {
-                xhci_set_usb2_hardware_lpm(hcd, udev, 0);
-                udev->usb2_hw_lpm_enabled = 0;
-        }
-
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
         state = xhci_readl(xhci, &xhci->op_regs->status);
@@ -3650,7 +3642,7 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
         union xhci_trb *cmd_trb;
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci->cmd_ring->dequeue;
+        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -3724,9 +3716,6 @@ disable_slot:
  * the device).
  * We should be protected by the usb_address0_mutex in khubd's hub_port_init, so
  * we should only issue and wait on one address command at the same time.
- *
- * We add one to the device address issued by the hardware because the USB core
- * uses address 1 for the root hubs (even though they're not really devices).
  */
 int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
 {
@@ -3785,7 +3774,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
                                 slot_ctx->dev_info >> 27);
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci->cmd_ring->dequeue;
+        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma,
                                         udev->slot_id);
         if (ret) {
@@ -3871,16 +3860,13 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
         trace_xhci_address_ctx(xhci, virt_dev->out_ctx,
                                 slot_ctx->dev_info >> 27);
-        /* Use kernel assigned address for devices; store xHC assigned
-         * address locally. */
-        virt_dev->address = (le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK)
-                + 1;
         /* Zero the input context control for later use */
         ctrl_ctx->add_flags = 0;
         ctrl_ctx->drop_flags = 0;
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
-                        "Internal device address = %d", virt_dev->address);
+                       "Internal device address = %d",
+                       le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK);
 
         return 0;
 }
@@ -4028,133 +4014,6 @@ static int xhci_calculate_usb2_hw_lpm_params(struct usb_device *udev)
         return PORT_BESLD(besld) | PORT_L1_TIMEOUT(l1) | PORT_HIRDM(hirdm);
 }
 
-static int xhci_usb2_software_lpm_test(struct usb_hcd *hcd,
-                                        struct usb_device *udev)
-{
-        struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        struct dev_info *dev_info;
-        __le32 __iomem  **port_array;
-        __le32 __iomem  *addr, *pm_addr;
-        u32             temp, dev_id;
-        unsigned int    port_num;
-        unsigned long   flags;
-        int             hird;
-        int             ret;
-
-        if (hcd->speed == HCD_USB3 || !xhci->sw_lpm_support ||
-                        !udev->lpm_capable)
-                return -EINVAL;
-
-        /* we only support lpm for non-hub device connected to root hub yet */
-        if (!udev->parent || udev->parent->parent ||
-                        udev->descriptor.bDeviceClass == USB_CLASS_HUB)
-                return -EINVAL;
-
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        /* Look for devices in lpm_failed_devs list */
-        dev_id = le16_to_cpu(udev->descriptor.idVendor) << 16 |
-                        le16_to_cpu(udev->descriptor.idProduct);
-        list_for_each_entry(dev_info, &xhci->lpm_failed_devs, list) {
-                if (dev_info->dev_id == dev_id) {
-                        ret = -EINVAL;
-                        goto finish;
-                }
-        }
-
-        port_array = xhci->usb2_ports;
-        port_num = udev->portnum - 1;
-
-        if (port_num > HCS_MAX_PORTS(xhci->hcs_params1)) {
-                xhci_dbg(xhci, "invalid port number %d\n", udev->portnum);
-                ret = -EINVAL;
-                goto finish;
-        }
-
-        /*
-         * Test USB 2.0 software LPM.
-         * FIXME: some xHCI 1.0 hosts may implement a new register to set up
-         * hardware-controlled USB 2.0 LPM. See section 5.4.11 and 4.23.5.1.1.1
-         * in the June 2011 errata release.
-         */
-        xhci_dbg(xhci, "test port %d software LPM\n", port_num);
-        /*
-         * Set L1 Device Slot and HIRD/BESL.
-         * Check device's USB 2.0 extension descriptor to determine whether
-         * HIRD or BESL shoule be used. See USB2.0 LPM errata.
-         */
-        pm_addr = port_array[port_num] + PORTPMSC;
-        hird = xhci_calculate_hird_besl(xhci, udev);
-        temp = PORT_L1DS(udev->slot_id) | PORT_HIRD(hird);
-        xhci_writel(xhci, temp, pm_addr);
-
-        /* Set port link state to U2(L1) */
-        addr = port_array[port_num];
-        xhci_set_link_state(xhci, port_array, port_num, XDEV_U2);
-
-        /* wait for ACK */
-        spin_unlock_irqrestore(&xhci->lock, flags);
-        msleep(10);
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        /* Check L1 Status */
-        ret = xhci_handshake(xhci, pm_addr,
-                        PORT_L1S_MASK, PORT_L1S_SUCCESS, 125);
-        if (ret != -ETIMEDOUT) {
-                /* enter L1 successfully */
-                temp = xhci_readl(xhci, addr);
-                xhci_dbg(xhci, "port %d entered L1 state, port status 0x%x\n",
-                                port_num, temp);
-                ret = 0;
-        } else {
-                temp = xhci_readl(xhci, pm_addr);
-                xhci_dbg(xhci, "port %d software lpm failed, L1 status %d\n",
-                                port_num, temp & PORT_L1S_MASK);
-                ret = -EINVAL;
-        }
-
-        /* Resume the port */
-        xhci_set_link_state(xhci, port_array, port_num, XDEV_U0);
-
-        spin_unlock_irqrestore(&xhci->lock, flags);
-        msleep(10);
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        /* Clear PLC */
-        xhci_test_and_clear_bit(xhci, port_array, port_num, PORT_PLC);
-
-        /* Check PORTSC to make sure the device is in the right state */
-        if (!ret) {
-                temp = xhci_readl(xhci, addr);
-                xhci_dbg(xhci, "resumed port %d status 0x%x\n", port_num, temp);
-                if (!(temp & PORT_CONNECT) || !(temp & PORT_PE) ||
-                                (temp & PORT_PLS_MASK) != XDEV_U0) {
-                        xhci_dbg(xhci, "port L1 resume fail\n");
-                        ret = -EINVAL;
-                }
-        }
-
-        if (ret) {
-                /* Insert dev to lpm_failed_devs list */
-                xhci_warn(xhci, "device LPM test failed, may disconnect and "
-                                "re-enumerate\n");
-                dev_info = kzalloc(sizeof(struct dev_info), GFP_ATOMIC);
-                if (!dev_info) {
-                        ret = -ENOMEM;
-                        goto finish;
-                }
-                dev_info->dev_id = dev_id;
-                INIT_LIST_HEAD(&dev_info->list);
-                list_add(&dev_info->list, &xhci->lpm_failed_devs);
-        } else {
-                xhci_ring_device(xhci, udev->slot_id);
-        }
-
-finish:
-        spin_unlock_irqrestore(&xhci->lock, flags);
-        return ret;
-}
-
 int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
                         struct usb_device *udev, int enable)
 {
@@ -4231,7 +4090,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
                 }
 
                 pm_val &= ~PORT_HIRD_MASK;
-                pm_val |= PORT_HIRD(hird) | PORT_RWE;
+                pm_val |= PORT_HIRD(hird) | PORT_RWE | PORT_L1DS(udev->slot_id);
                 xhci_writel(xhci, pm_val, pm_addr);
                 pm_val = xhci_readl(xhci, pm_addr);
                 pm_val |= PORT_HLE;
@@ -4239,7 +4098,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
                 /* flush write */
                 xhci_readl(xhci, pm_addr);
         } else {
-                pm_val &= ~(PORT_HLE | PORT_RWE | PORT_HIRD_MASK);
+                pm_val &= ~(PORT_HLE | PORT_RWE | PORT_HIRD_MASK | PORT_L1DS_MASK);
                 xhci_writel(xhci, pm_val, pm_addr);
                 /* flush write */
                 xhci_readl(xhci, pm_addr);
@@ -4282,24 +4141,26 @@ static int xhci_check_usb2_port_capability(struct xhci_hcd *xhci, int port,
 int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        int             ret;
         int             portnum = udev->portnum - 1;
 
-        ret = xhci_usb2_software_lpm_test(hcd, udev);
-        if (!ret) {
-                xhci_dbg(xhci, "software LPM test succeed\n");
-                if (xhci->hw_lpm_support == 1 &&
-                    xhci_check_usb2_port_capability(xhci, portnum, XHCI_HLC)) {
-                        udev->usb2_hw_lpm_capable = 1;
-                        udev->l1_params.timeout = XHCI_L1_TIMEOUT;
-                        udev->l1_params.besl = XHCI_DEFAULT_BESL;
-                        if (xhci_check_usb2_port_capability(xhci, portnum,
-                                                            XHCI_BLC))
-                                udev->usb2_hw_lpm_besl_capable = 1;
-                        ret = xhci_set_usb2_hardware_lpm(hcd, udev, 1);
-                        if (!ret)
-                                udev->usb2_hw_lpm_enabled = 1;
-                }
+        if (hcd->speed == HCD_USB3 || !xhci->sw_lpm_support ||
+                        !udev->lpm_capable)
+                return 0;
+
+        /* we only support lpm for non-hub device connected to root hub yet */
+        if (!udev->parent || udev->parent->parent ||
+                        udev->descriptor.bDeviceClass == USB_CLASS_HUB)
+                return 0;
+
+        if (xhci->hw_lpm_support == 1 &&
+                        xhci_check_usb2_port_capability(
+                                xhci, portnum, XHCI_HLC)) {
+                udev->usb2_hw_lpm_capable = 1;
+                udev->l1_params.timeout = XHCI_L1_TIMEOUT;
+                udev->l1_params.besl = XHCI_DEFAULT_BESL;
+                if (xhci_check_usb2_port_capability(xhci, portnum,
+                                        XHCI_BLC))
+                        udev->usb2_hw_lpm_besl_capable = 1;
         }
 
         return 0;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 46aa14894148..03c74b7965f8 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -383,6 +383,7 @@ struct xhci_op_regs {
 #define PORT_RWE                (1 << 3)
 #define PORT_HIRD(p)            (((p) & 0xf) << 4)
 #define PORT_HIRD_MASK          (0xf << 4)
+#define PORT_L1DS_MASK          (0xff << 8)
 #define PORT_L1DS(p)            (((p) & 0xff) << 8)
 #define PORT_HLE                (1 << 16)
 
@@ -934,8 +935,6 @@ struct xhci_virt_device {
         /* Rings saved to ensure old alt settings can be re-instated */
         struct xhci_ring                **ring_cache;
         int                             num_rings_cached;
-        /* Store xHC assigned device address */
-        int                             address;
 #define XHCI_MAX_RINGS_CACHED   31
         struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
@@ -1412,8 +1411,18 @@ struct xhci_bus_state {
         unsigned long           resume_done[USB_MAXCHILDREN];
         /* which ports have started to resume */
         unsigned long           resuming_ports;
+        /* Which ports are waiting on RExit to U0 transition. */
+        unsigned long           rexit_ports;
+        struct completion       rexit_done[USB_MAXCHILDREN];
 };
 
+
+/*
+ * It can take up to 20 ms to transition from RExit to U0 on the
+ * Intel Lynx Point LP xHCI host.
+ */
+#define XHCI_MAX_REXIT_TIMEOUT  (20 * 1000)
+
 static inline unsigned int hcd_index(struct usb_hcd *hcd)
 {
         if (hcd->speed == HCD_USB3)
@@ -1538,6 +1547,8 @@ struct xhci_hcd {
 #define XHCI_COMP_MODE_QUIRK    (1 << 14)
 #define XHCI_AVOID_BEI          (1 << 15)
 #define XHCI_PLAT               (1 << 16)
+#define XHCI_SLOW_SUSPEND       (1 << 17)
+#define XHCI_SPURIOUS_WAKEUP    (1 << 18)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
@@ -1840,6 +1851,7 @@ int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
                 union xhci_trb *cmd_trb);
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, unsigned int stream_id);
+union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring);
 
 /* xHCI roothub code */
 void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index e2b21c1d9c40..ba5f70f92888 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -246,6 +246,6 @@ config USB_EZUSB_FX2
 config USB_HSIC_USB3503
        tristate "USB3503 HSIC to USB20 Driver"
        depends on I2C
-       select REGMAP
+       select REGMAP_I2C
        help
          This option enables support for SMSC USB3503 HSIC to USB 2.0 Driver.
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index aa28ac8c7607..b4152820d655 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -120,7 +120,7 @@ get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
                         struct usb_host_endpoint        *e;
 
                         e = alt->endpoint + ep;
-                        switch (e->desc.bmAttributes) {
+                        switch (usb_endpoint_type(&e->desc)) {
                         case USB_ENDPOINT_XFER_BULK:
                                 break;
                         case USB_ENDPOINT_XFER_ISOC:
@@ -437,7 +437,7 @@ alloc_sglist(int nents, int max, int vary)
         if (max == 0)
                 return NULL;
 
-        sg = kmalloc_array(nents, sizeof *sg, GFP_KERNEL);
+        sg = kmalloc_array(nents, sizeof(*sg), GFP_KERNEL);
         if (!sg)
                 return NULL;
         sg_init_table(sg, nents);
@@ -573,7 +573,7 @@ static int is_good_config(struct usbtest_dev *tdev, int len)
 {
         struct usb_config_descriptor    *config;
 
-        if (len < sizeof *config)
+        if (len < sizeof(*config))
                 return 0;
         config = (struct usb_config_descriptor *) tdev->buf;
 
@@ -606,6 +606,76 @@ static int is_good_config(struct usbtest_dev *tdev, int len)
         return 0;
 }
 
+static int is_good_ext(struct usbtest_dev *tdev, u8 *buf)
+{
+        struct usb_ext_cap_descriptor *ext;
+        u32 attr;
+
+        ext = (struct usb_ext_cap_descriptor *) buf;
+
+        if (ext->bLength != USB_DT_USB_EXT_CAP_SIZE) {
+                ERROR(tdev, "bogus usb 2.0 extension descriptor length\n");
+                return 0;
+        }
+
+        attr = le32_to_cpu(ext->bmAttributes);
+        /* bits[1:4] is used and others are reserved */
+        if (attr & ~0x1e) {     /* reserved == 0 */
+                ERROR(tdev, "reserved bits set\n");
+                return 0;
+        }
+
+        return 1;
+}
+
+static int is_good_ss_cap(struct usbtest_dev *tdev, u8 *buf)
+{
+        struct usb_ss_cap_descriptor *ss;
+
+        ss = (struct usb_ss_cap_descriptor *) buf;
+
+        if (ss->bLength != USB_DT_USB_SS_CAP_SIZE) {
+                ERROR(tdev, "bogus superspeed device capability descriptor length\n");
+                return 0;
+        }
+
+        /*
+         * only bit[1] of bmAttributes is used for LTM and others are
+         * reserved
+         */
+        if (ss->bmAttributes & ~0x02) { /* reserved == 0 */
+                ERROR(tdev, "reserved bits set in bmAttributes\n");
+                return 0;
+        }
+
+        /* bits[0:3] of wSpeedSupported is used and others are reserved */
+        if (le16_to_cpu(ss->wSpeedSupported) & ~0x0f) { /* reserved == 0 */
+                ERROR(tdev, "reserved bits set in wSpeedSupported\n");
+                return 0;
+        }
+
+        return 1;
+}
+
+static int is_good_con_id(struct usbtest_dev *tdev, u8 *buf)
+{
+        struct usb_ss_container_id_descriptor *con_id;
+
+        con_id = (struct usb_ss_container_id_descriptor *) buf;
+
+        if (con_id->bLength != USB_DT_USB_SS_CONTN_ID_SIZE) {
+                ERROR(tdev, "bogus container id descriptor length\n");
+                return 0;
+        }
+
+        if (con_id->bReserved) {        /* reserved == 0 */
+                ERROR(tdev, "reserved bits set\n");
+                return 0;
+        }
+
+        return 1;
+}
+
 /* sanity test for standard requests working with usb_control_mesg() and some
  * of the utility functions which use it.
  *
@@ -683,12 +753,96 @@ static int ch9_postconfig(struct usbtest_dev *dev)
 
         /* there's always [9.4.3] a device descriptor [9.6.1] */
         retval = usb_get_descriptor(udev, USB_DT_DEVICE, 0,
-                        dev->buf, sizeof udev->descriptor);
-        if (retval != sizeof udev->descriptor) {
+                        dev->buf, sizeof(udev->descriptor));
+        if (retval != sizeof(udev->descriptor)) {
                 dev_err(&iface->dev, "dev descriptor --> %d\n", retval);
                 return (retval < 0) ? retval : -EDOM;
         }
 
+        /*
+         * there's always [9.4.3] a bos device descriptor [9.6.2] in USB
+         * 3.0 spec
+         */
+        if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0300) {
+                struct usb_bos_descriptor *bos = NULL;
+                struct usb_dev_cap_header *header = NULL;
+                unsigned total, num, length;
+                u8 *buf;
+
+                retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf,
+                                sizeof(*udev->bos->desc));
+                if (retval != sizeof(*udev->bos->desc)) {
+                        dev_err(&iface->dev, "bos descriptor --> %d\n", retval);
+                        return (retval < 0) ? retval : -EDOM;
+                }
+
+                bos = (struct usb_bos_descriptor *)dev->buf;
+                total = le16_to_cpu(bos->wTotalLength);
+                num = bos->bNumDeviceCaps;
+
+                if (total > TBUF_SIZE)
+                        total = TBUF_SIZE;
+
+                /*
+                 * get generic device-level capability descriptors [9.6.2]
+                 * in USB 3.0 spec
+                 */
+                retval = usb_get_descriptor(udev, USB_DT_BOS, 0, dev->buf,
+                                total);
+                if (retval != total) {
+                        dev_err(&iface->dev, "bos descriptor set --> %d\n",
+                                        retval);
+                        return (retval < 0) ? retval : -EDOM;
+                }
+
+                length = sizeof(*udev->bos->desc);
+                buf = dev->buf;
+                for (i = 0; i < num; i++) {
+                        buf += length;
+                        if (buf + sizeof(struct usb_dev_cap_header) >
+                                        dev->buf + total)
+                                break;
+
+                        header = (struct usb_dev_cap_header *)buf;
+                        length = header->bLength;
+
+                        if (header->bDescriptorType !=
+                                        USB_DT_DEVICE_CAPABILITY) {
+                                dev_warn(&udev->dev, "not device capability descriptor, skip\n");
+                                continue;
+                        }
+
+                        switch (header->bDevCapabilityType) {
+                        case USB_CAP_TYPE_EXT:
+                                if (buf + USB_DT_USB_EXT_CAP_SIZE >
+                                                dev->buf + total ||
+                                                !is_good_ext(dev, buf)) {
+                                        dev_err(&iface->dev, "bogus usb 2.0 extension descriptor\n");
+                                        return -EDOM;
+                                }
+                                break;
+                        case USB_SS_CAP_TYPE:
+                                if (buf + USB_DT_USB_SS_CAP_SIZE >
+                                                dev->buf + total ||
+                                                !is_good_ss_cap(dev, buf)) {
+                                        dev_err(&iface->dev, "bogus superspeed device capability descriptor\n");
+                                        return -EDOM;
+                                }
+                                break;
+                        case CONTAINER_ID_TYPE:
+                                if (buf + USB_DT_USB_SS_CONTN_ID_SIZE >
+                                                dev->buf + total ||
+                                                !is_good_con_id(dev, buf)) {
+                                        dev_err(&iface->dev, "bogus container id descriptor\n");
+                                        return -EDOM;
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                }
+        }
+
         /* there's always [9.4.3] at least one config descriptor [9.6.3] */
         for (i = 0; i < udev->descriptor.bNumConfigurations; i++) {
                 retval = usb_get_descriptor(udev, USB_DT_CONFIG, i,
@@ -954,7 +1108,7 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
                  * device, but some are chosen to trigger protocol stalls
                  * or short reads.
                  */
-                memset(&req, 0, sizeof req);
+                memset(&req, 0, sizeof(req));
                 req.bRequest = USB_REQ_GET_DESCRIPTOR;
                 req.bRequestType = USB_DIR_IN|USB_RECIP_DEVICE;
 
@@ -1074,7 +1228,7 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
                 if (!u)
                         goto cleanup;
 
-                reqp = kmalloc(sizeof *reqp, GFP_KERNEL);
+                reqp = kmalloc(sizeof(*reqp), GFP_KERNEL);
                 if (!reqp)
                         goto cleanup;
                 reqp->setup = req;
@@ -1667,13 +1821,13 @@ test_iso_queue(struct usbtest_dev *dev, struct usbtest_param *param,
         if (param->sglen > 10)
                 return -EDOM;
 
-        memset(&context, 0, sizeof context);
+        memset(&context, 0, sizeof(context));
         context.count = param->iterations * param->sglen;
         context.dev = dev;
         init_completion(&context.done);
         spin_lock_init(&context.lock);
 
-        memset(urbs, 0, sizeof urbs);
+        memset(urbs, 0, sizeof(urbs));
         udev = testdev_to_usbdev(dev);
         dev_info(&dev->intf->dev,
                 "... iso period %d %sframes, wMaxPacket %04x\n",
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index c64ee09a7c0e..57dfc0cedb00 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -71,11 +71,11 @@ config USB_MUSB_DA8XX
 
 config USB_MUSB_TUSB6010
         tristate "TUSB6010"
-        depends on GENERIC_HARDIRQS
 
 config USB_MUSB_OMAP2PLUS
         tristate "OMAP2430 and onwards"
         depends on ARCH_OMAP2PLUS
+        select GENERIC_PHY
 
 config USB_MUSB_AM35X
         tristate "AM35x"
@@ -91,7 +91,7 @@ config USB_MUSB_BLACKFIN
         depends on (BF54x && !BF544) || (BF52x && ! BF522 && !BF523)
 
 config USB_MUSB_UX500
-        tristate "U8500 and U5500"
+        tristate "Ux500 platforms"
 
 endchoice
 
@@ -113,7 +113,7 @@ choice
           allow using DMA on multiplatform kernels.
 
 config USB_UX500_DMA
-        bool 'ST Ericsson U8500 and U5500'
+        bool 'ST Ericsson Ux500'
         depends on USB_MUSB_UX500
         help
           Enable DMA transfers on UX500 platforms.
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index 5c310c664218..ca45b39db5b9 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -89,7 +89,6 @@ struct am35x_glue {
         struct clk              *phy_clk;
         struct clk              *clk;
 };
-#define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
 /*
  * am35x_musb_enable - enable interrupts
@@ -452,14 +451,18 @@ static const struct musb_platform_ops am35x_ops = {
         .set_vbus       = am35x_musb_set_vbus,
 };
 
-static u64 am35x_dmamask = DMA_BIT_MASK(32);
+static const struct platform_device_info am35x_dev_info = {
+        .name           = "musb-hdrc",
+        .id             = PLATFORM_DEVID_AUTO,
+        .dma_mask       = DMA_BIT_MASK(32),
+};
 
 static int am35x_probe(struct platform_device *pdev)
 {
         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
         struct platform_device          *musb;
         struct am35x_glue               *glue;
-
+        struct platform_device_info     pinfo;
         struct clk                      *phy_clk;
         struct clk                      *clk;
 
@@ -471,12 +474,6 @@ static int am35x_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
-        if (!musb) {
-                dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
-        }
-
         phy_clk = clk_get(&pdev->dev, "fck");
         if (IS_ERR(phy_clk)) {
                 dev_err(&pdev->dev, "failed to get PHY clock\n");
@@ -503,12 +500,7 @@ static int am35x_probe(struct platform_device *pdev)
                 goto err6;
         }
 
-        musb->dev.parent                = &pdev->dev;
-        musb->dev.dma_mask              = &am35x_dmamask;
-        musb->dev.coherent_dma_mask     = am35x_dmamask;
-
         glue->dev                       = &pdev->dev;
-        glue->musb                      = musb;
         glue->phy_clk                   = phy_clk;
         glue->clk                       = clk;
 
@@ -516,22 +508,17 @@ static int am35x_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, glue);
 
-        ret = platform_device_add_resources(musb, pdev->resource,
-                        pdev->num_resources);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add resources\n");
-                goto err7;
-        }
-
-        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err7;
-        }
-
-        ret = platform_device_add(musb);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register musb device\n");
+        pinfo = am35x_dev_info;
+        pinfo.parent = &pdev->dev;
+        pinfo.res = pdev->resource;
+        pinfo.num_res = pdev->num_resources;
+        pinfo.data = pdata;
+        pinfo.size_data = sizeof(*pdata);
+
+        glue->musb = musb = platform_device_register_full(&pinfo);
+        if (IS_ERR(musb)) {
+                ret = PTR_ERR(musb);
+                dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
                 goto err7;
         }
 
@@ -550,9 +537,6 @@ err4:
         clk_put(phy_clk);
 
 err3:
-        platform_device_put(musb);
-
-err1:
         kfree(glue);
 
 err0:
@@ -615,23 +599,16 @@ static int am35x_resume(struct device *dev)
 
         return 0;
 }
-
-static struct dev_pm_ops am35x_pm_ops = {
-        .suspend        = am35x_suspend,
-        .resume         = am35x_resume,
-};
-
-#define DEV_PM_OPS      &am35x_pm_ops
-#else
-#define DEV_PM_OPS      NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(am35x_pm_ops, am35x_suspend, am35x_resume);
+
 static struct platform_driver am35x_driver = {
         .probe          = am35x_probe,
         .remove         = am35x_remove,
         .driver         = {
                 .name   = "musb-am35x",
-                .pm     = DEV_PM_OPS,
+                .pm     = &am35x_pm_ops,
         },
 };
 
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 72e2056b6082..d9692f78e227 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -561,23 +561,16 @@ static int bfin_resume(struct device *dev)
 
         return 0;
 }
-
-static struct dev_pm_ops bfin_pm_ops = {
-        .suspend        = bfin_suspend,
-        .resume         = bfin_resume,
-};
-
-#define DEV_PM_OPS      &bfin_pm_ops
-#else
-#define DEV_PM_OPS      NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(bfin_pm_ops, bfin_suspend, bfin_resume);
+
 static struct platform_driver bfin_driver = {
         .probe          = bfin_probe,
         .remove         = __exit_p(bfin_remove),
         .driver         = {
                 .name   = "musb-blackfin",
-                .pm     = DEV_PM_OPS,
+                .pm     = &bfin_pm_ops,
         },
 };
 
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index d9ddf4122f37..2f2c1cb36421 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -472,7 +472,11 @@ static const struct musb_platform_ops da8xx_ops = {
         .set_vbus       = da8xx_musb_set_vbus,
 };
 
-static u64 da8xx_dmamask = DMA_BIT_MASK(32);
+static const struct platform_device_info da8xx_dev_info = {
+        .name           = "musb-hdrc",
+        .id             = PLATFORM_DEVID_AUTO,
+        .dma_mask       = DMA_BIT_MASK(32),
+};
 
 static int da8xx_probe(struct platform_device *pdev)
 {
@@ -480,7 +484,7 @@ static int da8xx_probe(struct platform_device *pdev)
         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
         struct platform_device          *musb;
         struct da8xx_glue               *glue;
-
+        struct platform_device_info     pinfo;
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
@@ -491,12 +495,6 @@ static int da8xx_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
-        if (!musb) {
-                dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
-        }
-
         clk = clk_get(&pdev->dev, "usb20");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
@@ -510,12 +508,7 @@ static int da8xx_probe(struct platform_device *pdev)
                 goto err4;
         }
 
-        musb->dev.parent                = &pdev->dev;
-        musb->dev.dma_mask              = &da8xx_dmamask;
-        musb->dev.coherent_dma_mask     = da8xx_dmamask;
-
         glue->dev                       = &pdev->dev;
-        glue->musb                      = musb;
         glue->clk                       = clk;
 
         pdata->platform_ops             = &da8xx_ops;
@@ -535,22 +528,17 @@ static int da8xx_probe(struct platform_device *pdev)
         musb_resources[1].end = pdev->resource[1].end;
         musb_resources[1].flags = pdev->resource[1].flags;
 
-        ret = platform_device_add_resources(musb, musb_resources,
-                        ARRAY_SIZE(musb_resources));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add resources\n");
-                goto err5;
-        }
-
-        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err5;
-        }
-
-        ret = platform_device_add(musb);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register musb device\n");
+        pinfo = da8xx_dev_info;
+        pinfo.parent = &pdev->dev;
+        pinfo.res = musb_resources;
+        pinfo.num_res = ARRAY_SIZE(musb_resources);
+        pinfo.data = pdata;
+        pinfo.size_data = sizeof(*pdata);
+
+        glue->musb = musb = platform_device_register_full(&pinfo);
+        if (IS_ERR(musb)) {
+                ret = PTR_ERR(musb);
+                dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
                 goto err5;
         }
 
@@ -563,9 +551,6 @@ err4:
         clk_put(clk);
 
 err3:
-        platform_device_put(musb);
-
-err1:
         kfree(glue);
 
 err0:
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index ed0834e2b72e..1121fd741bf8 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -505,14 +505,19 @@ static const struct musb_platform_ops davinci_ops = {
         .set_vbus       = davinci_musb_set_vbus,
 };
 
-static u64 davinci_dmamask = DMA_BIT_MASK(32);
+static const struct platform_device_info davinci_dev_info = {
+        .name           = "musb-hdrc",
+        .id             = PLATFORM_DEVID_AUTO,
+        .dma_mask       = DMA_BIT_MASK(32),
+};
 
 static int davinci_probe(struct platform_device *pdev)
 {
-        struct resource musb_resources[2];
+        struct resource                 musb_resources[3];
         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
         struct platform_device          *musb;
         struct davinci_glue             *glue;
+        struct platform_device_info     pinfo;
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
@@ -523,12 +528,6 @@ static int davinci_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
-        if (!musb) {
-                dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
-        }
-
         clk = clk_get(&pdev->dev, "usb");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
@@ -542,12 +541,7 @@ static int davinci_probe(struct platform_device *pdev)
                 goto err4;
         }
 
-        musb->dev.parent                = &pdev->dev;
-        musb->dev.dma_mask              = &davinci_dmamask;
-        musb->dev.coherent_dma_mask     = davinci_dmamask;
-
         glue->dev                       = &pdev->dev;
-        glue->musb                      = musb;
         glue->clk                       = clk;
 
         pdata->platform_ops             = &davinci_ops;
@@ -567,22 +561,26 @@ static int davinci_probe(struct platform_device *pdev)
         musb_resources[1].end = pdev->resource[1].end;
         musb_resources[1].flags = pdev->resource[1].flags;
 
-        ret = platform_device_add_resources(musb, musb_resources,
-                        ARRAY_SIZE(musb_resources));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add resources\n");
-                goto err5;
-        }
-
-        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err5;
-        }
-
-        ret = platform_device_add(musb);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register musb device\n");
+        /*
+         * For DM6467 3 resources are passed. A placeholder for the 3rd
+         * resource is always there, so it's safe to always copy it...
+         */
+        musb_resources[2].name = pdev->resource[2].name;
+        musb_resources[2].start = pdev->resource[2].start;
+        musb_resources[2].end = pdev->resource[2].end;
+        musb_resources[2].flags = pdev->resource[2].flags;
+
+        pinfo = davinci_dev_info;
+        pinfo.parent = &pdev->dev;
+        pinfo.res = musb_resources;
+        pinfo.num_res = ARRAY_SIZE(musb_resources);
+        pinfo.data = pdata;
+        pinfo.size_data = sizeof(*pdata);
+
+        glue->musb = musb = platform_device_register_full(&pinfo);
+        if (IS_ERR(musb)) {
+                ret = PTR_ERR(musb);
+                dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
                 goto err5;
         }
 
@@ -595,9 +593,6 @@ err4:
         clk_put(clk);
 
 err3:
-        platform_device_put(musb);
-
-err1:
         kfree(glue);
 
 err0:
diff --git a/drivers/usb/musb/musb_am335x.c b/drivers/usb/musb/musb_am335x.c
index 41ac5b5b57ce..8be9b02c3cc2 100644
--- a/drivers/usb/musb/musb_am335x.c
+++ b/drivers/usb/musb/musb_am335x.c
@@ -46,7 +46,7 @@ static struct platform_driver am335x_child_driver = {
         .remove         = am335x_child_remove,
         .driver         = {
                 .name   = "am335x-usb-childs",
-                .of_match_table = of_match_ptr(am335x_child_of_match),
+                .of_match_table = am335x_child_of_match,
         },
 };
 
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 18e877ffe7b7..0a43329569d1 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -617,7 +617,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 /* case 3 << MUSB_DEVCTL_VBUS_SHIFT: */
                                 default:
                                         s = "VALID"; break;
-                                }; s; }),
+                                } s; }),
                                 VBUSERR_RETRY_COUNT - musb->vbuserr_retry,
                                 musb->port1_status);
 
@@ -922,6 +922,52 @@ static void musb_generic_disable(struct musb *musb)
 }
 
 /*
+ * Program the HDRC to start (enable interrupts, dma, etc.).
+ */
+void musb_start(struct musb *musb)
+{
+        void __iomem    *regs = musb->mregs;
+        u8              devctl = musb_readb(regs, MUSB_DEVCTL);
+
+        dev_dbg(musb->controller, "<== devctl %02x\n", devctl);
+
+        /*  Set INT enable registers, enable interrupts */
+        musb->intrtxe = musb->epmask;
+        musb_writew(regs, MUSB_INTRTXE, musb->intrtxe);
+        musb->intrrxe = musb->epmask & 0xfffe;
+        musb_writew(regs, MUSB_INTRRXE, musb->intrrxe);
+        musb_writeb(regs, MUSB_INTRUSBE, 0xf7);
+
+        musb_writeb(regs, MUSB_TESTMODE, 0);
+
+        /* put into basic highspeed mode and start session */
+        musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
+                        | MUSB_POWER_HSENAB
+                        /* ENSUSPEND wedges tusb */
+                        /* | MUSB_POWER_ENSUSPEND */
+                   );
+
+        musb->is_active = 0;
+        devctl = musb_readb(regs, MUSB_DEVCTL);
+        devctl &= ~MUSB_DEVCTL_SESSION;
+
+        /* session started after:
+         * (a) ID-grounded irq, host mode;
+         * (b) vbus present/connect IRQ, peripheral mode;
+         * (c) peripheral initiates, using SRP
+         */
+        if (musb->port_mode != MUSB_PORT_MODE_HOST &&
+                        (devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) {
+                musb->is_active = 1;
+        } else {
+                devctl |= MUSB_DEVCTL_SESSION;
+        }
+
+        musb_platform_enable(musb);
+        musb_writeb(regs, MUSB_DEVCTL, devctl);
+}
+
+/*
  * Make the HDRC stop (disable interrupts, etc.);
  * reversible by musb_start
  * called on gadget driver unregister
@@ -1763,8 +1809,7 @@ static void musb_free(struct musb *musb)
                         disable_irq_wake(musb->nIrq);
                 free_irq(musb->nIrq, musb);
         }
-        if (musb->dma_controller)
-                dma_controller_destroy(musb->dma_controller);
+        cancel_work_sync(&musb->irq_work);
 
         musb_host_free(musb);
 }
@@ -1839,8 +1884,13 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
         pm_runtime_get_sync(musb->controller);
 
-        if (use_dma && dev->dma_mask)
+        if (use_dma && dev->dma_mask) {
                 musb->dma_controller = dma_controller_create(musb, musb->mregs);
+                if (IS_ERR(musb->dma_controller)) {
+                        status = PTR_ERR(musb->dma_controller);
+                        goto fail2_5;
+                }
+        }
 
         /* be sure interrupts are disabled before connecting ISR */
         musb_platform_disable(musb);
@@ -1900,6 +1950,8 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
                 if (status < 0)
                         goto fail3;
                 status = musb_gadget_setup(musb);
+                if (status)
+                        musb_host_cleanup(musb);
                 break;
         default:
                 dev_err(dev, "unsupported port mode %d\n", musb->port_mode);
@@ -1926,10 +1978,12 @@ fail5:
 
 fail4:
         musb_gadget_cleanup(musb);
+        musb_host_cleanup(musb);
 
 fail3:
         if (musb->dma_controller)
                 dma_controller_destroy(musb->dma_controller);
+fail2_5:
         pm_runtime_put_sync(musb->controller);
 
 fail2:
@@ -1986,6 +2040,9 @@ static int musb_remove(struct platform_device *pdev)
         musb_exit_debugfs(musb);
         musb_shutdown(pdev);
 
+        if (musb->dma_controller)
+                dma_controller_destroy(musb->dma_controller);
+
         musb_free(musb);
         device_init_wakeup(dev, 0);
         return 0;
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 65f3917b4fc5..29f7cd7c7964 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -46,6 +46,7 @@
 #include <linux/usb.h>
 #include <linux/usb/otg.h>
 #include <linux/usb/musb.h>
+#include <linux/phy/phy.h>
 
 struct musb;
 struct musb_hw_ep;
@@ -341,6 +342,7 @@ struct musb {
         u16                     int_tx;
 
         struct usb_phy          *xceiv;
+        struct phy              *phy;
 
         int nIrq;
         unsigned                irq_wake:1;
@@ -503,6 +505,7 @@ static inline void musb_configure_ep0(struct musb *musb)
 extern const char musb_driver_name[];
 
 extern void musb_stop(struct musb *musb);
+extern void musb_start(struct musb *musb);
 
 extern void musb_write_fifo(struct musb_hw_ep *ep, u16 len, const u8 *src);
 extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index ae959746f77f..ff9d6de2b746 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -484,6 +484,7 @@ static int cppi41_dma_controller_start(struct cppi41_dma_controller *controller)
                 if (ret)
                         goto err;
 
+                ret = -EINVAL;
                 if (port > MUSB_DMA_NUM_CHANNELS || !port)
                         goto err;
                 if (is_tx)
@@ -503,6 +504,7 @@ static int cppi41_dma_controller_start(struct cppi41_dma_controller *controller)
                 dc = dma_request_slave_channel(dev, str);
                 if (!dc) {
                         dev_err(dev, "Falied to request %s.\n", str);
+                        ret = -EPROBE_DEFER;
                         goto err;
                 }
                 cppi41_channel->dc = dc;
@@ -510,7 +512,7 @@ static int cppi41_dma_controller_start(struct cppi41_dma_controller *controller)
         return 0;
 err:
         cppi41_release_all_dma_chans(controller);
-        return -EINVAL;
+        return ret;
 }
 
 void dma_controller_destroy(struct dma_controller *c)
@@ -526,7 +528,7 @@ struct dma_controller *dma_controller_create(struct musb *musb,
                                         void __iomem *base)
 {
         struct cppi41_dma_controller *controller;
-        int ret;
+        int ret = 0;
 
         if (!musb->controller->of_node) {
                 dev_err(musb->controller, "Need DT for the DMA engine.\n");
@@ -553,5 +555,7 @@ struct dma_controller *dma_controller_create(struct musb *musb,
 plat_get_fail:
         kfree(controller);
 kzalloc_fail:
+        if (ret == -EPROBE_DEFER)
+                return ERR_PTR(ret);
         return NULL;
 }
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 4047cbb91bac..1901f6fe5807 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -121,6 +121,43 @@ struct dsps_glue {
         unsigned long last_timer;    /* last timer data for each instance */
 };
 
+static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
+{
+        struct device *dev = musb->controller;
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
+
+        if (timeout == 0)
+                timeout = jiffies + msecs_to_jiffies(3);
+
+        /* Never idle if active, or when VBUS timeout is not set as host */
+        if (musb->is_active || (musb->a_wait_bcon == 0 &&
+                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
+                dev_dbg(musb->controller, "%s active, deleting timer\n",
+                                usb_otg_state_string(musb->xceiv->state));
+                del_timer(&glue->timer);
+                glue->last_timer = jiffies;
+                return;
+        }
+        if (musb->port_mode != MUSB_PORT_MODE_DUAL_ROLE)
+                return;
+
+        if (!musb->g.dev.driver)
+                return;
+
+        if (time_after(glue->last_timer, timeout) &&
+                                timer_pending(&glue->timer)) {
+                dev_dbg(musb->controller,
+                        "Longer idle timer already pending, ignoring...\n");
+                return;
+        }
+        glue->last_timer = timeout;
+
+        dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
+                usb_otg_state_string(musb->xceiv->state),
+                        jiffies_to_msecs(timeout - jiffies));
+        mod_timer(&glue->timer, timeout);
+}
+
 /**
  * dsps_musb_enable - enable interrupts
  */
@@ -143,6 +180,7 @@ static void dsps_musb_enable(struct musb *musb)
         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
         dsps_writel(reg_base, wrp->coreintr_set,
                     (1 << wrp->drvvbus) << wrp->usb_shift);
+        dsps_musb_try_idle(musb, 0);
 }
 
 /**
@@ -171,6 +209,7 @@ static void otg_timer(unsigned long _musb)
         const struct dsps_musb_wrapper *wrp = glue->wrp;
         u8 devctl;
         unsigned long flags;
+        int skip_session = 0;
 
         /*
          * We poll because DSPS IP's won't expose several OTG-critical
@@ -183,10 +222,12 @@ static void otg_timer(unsigned long _musb)
         spin_lock_irqsave(&musb->lock, flags);
         switch (musb->xceiv->state) {
         case OTG_STATE_A_WAIT_BCON:
-                devctl &= ~MUSB_DEVCTL_SESSION;
-                dsps_writeb(musb->mregs, MUSB_DEVCTL, devctl);
+                dsps_writeb(musb->mregs, MUSB_DEVCTL, 0);
+                skip_session = 1;
+                /* fall */
 
-                devctl = dsps_readb(musb->mregs, MUSB_DEVCTL);
+        case OTG_STATE_A_IDLE:
+        case OTG_STATE_B_IDLE:
                 if (devctl & MUSB_DEVCTL_BDEVICE) {
                         musb->xceiv->state = OTG_STATE_B_IDLE;
                         MUSB_DEV_MODE(musb);
@@ -194,60 +235,21 @@ static void otg_timer(unsigned long _musb)
                         musb->xceiv->state = OTG_STATE_A_IDLE;
                         MUSB_HST_MODE(musb);
                 }
+                if (!(devctl & MUSB_DEVCTL_SESSION) && !skip_session)
+                        dsps_writeb(mregs, MUSB_DEVCTL, MUSB_DEVCTL_SESSION);
+                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
                 break;
         case OTG_STATE_A_WAIT_VFALL:
                 musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
                 dsps_writel(musb->ctrl_base, wrp->coreintr_set,
                             MUSB_INTR_VBUSERROR << wrp->usb_shift);
                 break;
-        case OTG_STATE_B_IDLE:
-                devctl = dsps_readb(mregs, MUSB_DEVCTL);
-                if (devctl & MUSB_DEVCTL_BDEVICE)
-                        mod_timer(&glue->timer,
-                                        jiffies + wrp->poll_seconds * HZ);
-                else
-                        musb->xceiv->state = OTG_STATE_A_IDLE;
-                break;
         default:
                 break;
         }
         spin_unlock_irqrestore(&musb->lock, flags);
 }
 
-static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
-{
-        struct device *dev = musb->controller;
-        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
-
-        if (timeout == 0)
-                timeout = jiffies + msecs_to_jiffies(3);
-
-        /* Never idle if active, or when VBUS timeout is not set as host */
-        if (musb->is_active || (musb->a_wait_bcon == 0 &&
-                                musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
-                dev_dbg(musb->controller, "%s active, deleting timer\n",
-                                usb_otg_state_string(musb->xceiv->state));
-                del_timer(&glue->timer);
-                glue->last_timer = jiffies;
-                return;
-        }
-        if (musb->port_mode == MUSB_PORT_MODE_HOST)
-                return;
-
-        if (time_after(glue->last_timer, timeout) &&
-                                timer_pending(&glue->timer)) {
-                dev_dbg(musb->controller,
-                        "Longer idle timer already pending, ignoring...\n");
-                return;
-        }
-        glue->last_timer = timeout;
-
-        dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
-                usb_otg_state_string(musb->xceiv->state),
-                        jiffies_to_msecs(timeout - jiffies));
-        mod_timer(&glue->timer, timeout);
-}
-
 static irqreturn_t dsps_interrupt(int irq, void *hci)
 {
         struct musb  *musb = hci;
@@ -443,7 +445,7 @@ static int get_musb_port_mode(struct device *dev)
         case USB_DR_MODE_OTG:
         default:
                 return MUSB_PORT_MODE_DUAL_ROLE;
-        };
+        }
 }
 
 static int dsps_create_musb_pdev(struct dsps_glue *glue,
@@ -535,6 +537,9 @@ static int dsps_probe(struct platform_device *pdev)
         struct dsps_glue *glue;
         int ret;
 
+        if (!strcmp(pdev->name, "musb-hdrc"))
+                return -ENODEV;
+
         match = of_match_node(musb_dsps_of_match, pdev->dev.of_node);
         if (!match) {
                 dev_err(&pdev->dev, "fail to get matching of_match struct\n");
@@ -628,7 +633,7 @@ static struct platform_driver dsps_usbss_driver = {
         .remove         = dsps_remove,
         .driver         = {
                 .name   = "musb-dsps",
-                .of_match_table = of_match_ptr(musb_dsps_of_match),
+                .of_match_table = musb_dsps_of_match,
         },
 };
 
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 9a08679d204d..d2d3a173b315 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1121,7 +1121,7 @@ static int musb_gadget_enable(struct usb_ep *ep,
                         case USB_ENDPOINT_XFER_BULK:    s = "bulk"; break;
                         case USB_ENDPOINT_XFER_INT:     s = "int"; break;
                         default:                        s = "iso"; break;
-                        }; s; }),
+                        } s; }),
                         musb_ep->is_in ? "IN" : "OUT",
                         musb_ep->dma ? "dma, " : "",
                         musb_ep->packet_sz);
@@ -1790,6 +1790,10 @@ int musb_gadget_setup(struct musb *musb)
         musb->g.max_speed = USB_SPEED_HIGH;
         musb->g.speed = USB_SPEED_UNKNOWN;
 
+        MUSB_DEV_MODE(musb);
+        musb->xceiv->otg->default_a = 0;
+        musb->xceiv->state = OTG_STATE_B_IDLE;
+
         /* this "gadget" abstracts/virtualizes the controller */
         musb->g.name = musb_driver_name;
         musb->g.is_otg = 1;
@@ -1855,6 +1859,8 @@ static int musb_gadget_start(struct usb_gadget *g,
         musb->xceiv->state = OTG_STATE_B_IDLE;
         spin_unlock_irqrestore(&musb->lock, flags);
 
+        musb_start(musb);
+
         /* REVISIT:  funcall to other code, which also
          * handles power budgeting ... this way also
          * ensures HdrcStart is indirectly called.
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 9a2b8c85f19a..6582a20bec05 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -253,7 +253,7 @@ musb_start_urb(struct musb *musb, int is_in, struct musb_qh *qh)
                         case USB_ENDPOINT_XFER_BULK:    s = "-bulk"; break;
                         case USB_ENDPOINT_XFER_ISOC:    s = "-iso"; break;
                         default:                        s = "-intr"; break;
-                        }; s; }),
+                        } s; }),
                         epnum, buf + offset, len);
 
         /* Configure endpoint */
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index a523950c2b32..9af6bba5eac9 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -44,52 +44,6 @@
 
 #include "musb_core.h"
 
-/*
-* Program the HDRC to start (enable interrupts, dma, etc.).
-*/
-static void musb_start(struct musb *musb)
-{
-        void __iomem    *regs = musb->mregs;
-        u8              devctl = musb_readb(regs, MUSB_DEVCTL);
-
-        dev_dbg(musb->controller, "<== devctl %02x\n", devctl);
-
-        /*  Set INT enable registers, enable interrupts */
-        musb->intrtxe = musb->epmask;
-        musb_writew(regs, MUSB_INTRTXE, musb->intrtxe);
-        musb->intrrxe = musb->epmask & 0xfffe;
-        musb_writew(regs, MUSB_INTRRXE, musb->intrrxe);
-        musb_writeb(regs, MUSB_INTRUSBE, 0xf7);
-
-        musb_writeb(regs, MUSB_TESTMODE, 0);
-
-        /* put into basic highspeed mode and start session */
-        musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
-                                                | MUSB_POWER_HSENAB
-                                                /* ENSUSPEND wedges tusb */
-                                                /* | MUSB_POWER_ENSUSPEND */
-                                                );
-
-        musb->is_active = 0;
-        devctl = musb_readb(regs, MUSB_DEVCTL);
-        devctl &= ~MUSB_DEVCTL_SESSION;
-
-        /* session started after:
-         * (a) ID-grounded irq, host mode;
-         * (b) vbus present/connect IRQ, peripheral mode;
-         * (c) peripheral initiates, using SRP
-         */
-        if (musb->port_mode != MUSB_PORT_MODE_HOST &&
-            (devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS) {
-                musb->is_active = 1;
-        } else {
-                devctl |= MUSB_DEVCTL_SESSION;
-        }
-
-        musb_platform_enable(musb);
-        musb_writeb(regs, MUSB_DEVCTL, devctl);
-}
-
 static void musb_port_suspend(struct musb *musb, bool do_suspend)
 {
         struct usb_otg  *otg = musb->xceiv->otg;
@@ -266,6 +220,23 @@ int musb_hub_status_data(struct usb_hcd *hcd, char *buf)
         return retval;
 }
 
+static int musb_has_gadget(struct musb *musb)
+{
+        /*
+         * In host-only mode we start a connection right away. In OTG mode
+         * we have to wait until we loaded a gadget. We don't really need a
+         * gadget if we operate as a host but we should not start a session
+         * as a device without a gadget or else we explode.
+         */
+#ifdef CONFIG_USB_MUSB_HOST
+        return 1;
+#else
+        if (musb->port_mode == MUSB_PORT_MODE_HOST)
+                return 1;
+        return musb->g.dev.driver != NULL;
+#endif
+}
+
 int musb_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
@@ -408,7 +379,7 @@ int musb_hub_control(
                          * initialization logic, e.g. for OTG, or change any
                          * logic relating to VBUS power-up.
                          */
-                        if (!hcd->self.is_b_host)
+                        if (!hcd->self.is_b_host && musb_has_gadget(musb))
                                 musb_start(musb);
                         break;
                 case USB_PORT_FEAT_RESET:
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index 59d2245db1c8..2a408cdaf7b2 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -38,6 +38,7 @@
 #include <linux/delay.h>
 #include <linux/usb/musb-omap.h>
 #include <linux/usb/omap_control_usb.h>
+#include <linux/of_platform.h>
 
 #include "musb_core.h"
 #include "omap2430.h"
@@ -305,6 +306,9 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
         default:
                 dev_dbg(dev, "ID float\n");
         }
+
+        atomic_notifier_call_chain(&musb->xceiv->notifier,
+                        musb->xceiv->last_event, NULL);
 }
 
 
@@ -348,11 +352,21 @@ static int omap2430_musb_init(struct musb *musb)
          * up through ULPI.  TWL4030-family PMICs include one,
          * which needs a driver, drivers aren't always needed.
          */
-        if (dev->parent->of_node)
+        if (dev->parent->of_node) {
+                musb->phy = devm_phy_get(dev->parent, "usb2-phy");
+
+                /* We can't totally remove musb->xceiv as of now because
+                 * musb core uses xceiv.state and xceiv.otg. Once we have
+                 * a separate state machine to handle otg, these can be moved
+                 * out of xceiv and then we can start using the generic PHY
+                 * framework
+                 */
                 musb->xceiv = devm_usb_get_phy_by_phandle(dev->parent,
                     "usb-phy", 0);
-        else
+        } else {
                 musb->xceiv = devm_usb_get_phy_dev(dev, 0);
+                musb->phy = devm_phy_get(dev, "usb");
+        }
 
         if (IS_ERR(musb->xceiv)) {
                 status = PTR_ERR(musb->xceiv);
@@ -364,6 +378,10 @@ static int omap2430_musb_init(struct musb *musb)
                 return -EPROBE_DEFER;
         }
 
+        if (IS_ERR(musb->phy)) {
+                pr_err("HS USB OTG: no PHY configured\n");
+                return PTR_ERR(musb->phy);
+        }
         musb->isr = omap2430_musb_interrupt;
 
         status = pm_runtime_get_sync(dev);
@@ -397,7 +415,7 @@ static int omap2430_musb_init(struct musb *musb)
         if (glue->status != OMAP_MUSB_UNKNOWN)
                 omap_musb_set_mailbox(glue);
 
-        usb_phy_init(musb->xceiv);
+        phy_init(musb->phy);
 
         pm_runtime_put_noidle(musb->controller);
         return 0;
@@ -460,6 +478,7 @@ static int omap2430_musb_exit(struct musb *musb)
         del_timer_sync(&musb_idle_timer);
 
         omap2430_low_level_exit(musb);
+        phy_exit(musb->phy);
 
         return 0;
 }
@@ -509,8 +528,12 @@ static int omap2430_probe(struct platform_device *pdev)
         glue->dev                       = &pdev->dev;
         glue->musb                      = musb;
         glue->status                    = OMAP_MUSB_UNKNOWN;
+        glue->control_otghs = ERR_PTR(-ENODEV);
 
         if (np) {
+                struct device_node *control_node;
+                struct platform_device *control_pdev;
+
                 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
                 if (!pdata) {
                         dev_err(&pdev->dev,
@@ -539,22 +562,20 @@ static int omap2430_probe(struct platform_device *pdev)
                 of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
                 of_property_read_u32(np, "power", (u32 *)&pdata->power);
                 config->multipoint = of_property_read_bool(np, "multipoint");
-                pdata->has_mailbox = of_property_read_bool(np,
-                    "ti,has-mailbox");
 
                 pdata->board_data       = data;
                 pdata->config           = config;
-        }
 
-        if (pdata->has_mailbox) {
-                glue->control_otghs = omap_get_control_dev();
-                if (IS_ERR(glue->control_otghs)) {
-                        dev_vdbg(&pdev->dev, "Failed to get control device\n");
-                        ret = PTR_ERR(glue->control_otghs);
-                        goto err2;
+                control_node = of_parse_phandle(np, "ctrl-module", 0);
+                if (control_node) {
+                        control_pdev = of_find_device_by_node(control_node);
+                        if (!control_pdev) {
+                                dev_err(&pdev->dev, "Failed to get control device\n");
+                                ret = -EINVAL;
+                                goto err2;
+                        }
+                        glue->control_otghs = &control_pdev->dev;
                 }
-        } else {
-                glue->control_otghs = ERR_PTR(-ENODEV);
         }
         pdata->platform_ops             = &omap2430_ops;
 
@@ -638,7 +659,7 @@ static int omap2430_runtime_suspend(struct device *dev)
                                 OTG_INTERFSEL);
 
                 omap2430_low_level_exit(musb);
-                usb_phy_set_suspend(musb->xceiv, 1);
+                phy_power_off(musb->phy);
         }
 
         return 0;
@@ -653,8 +674,7 @@ static int omap2430_runtime_resume(struct device *dev)
                 omap2430_low_level_init(musb);
                 musb_writel(musb->mregs, OTG_INTERFSEL,
                                 musb->context.otg_interfsel);
-
-                usb_phy_set_suspend(musb->xceiv, 0);
+                phy_power_on(musb->phy);
         }
 
         return 0;
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index b3b3ed723882..4432314d70ee 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -1152,7 +1152,11 @@ static const struct musb_platform_ops tusb_ops = {
         .set_vbus       = tusb_musb_set_vbus,
 };
 
-static u64 tusb_dmamask = DMA_BIT_MASK(32);
+static const struct platform_device_info tusb_dev_info = {
+        .name           = "musb-hdrc",
+        .id             = PLATFORM_DEVID_AUTO,
+        .dma_mask       = DMA_BIT_MASK(32),
+};
 
 static int tusb_probe(struct platform_device *pdev)
 {
@@ -1160,7 +1164,7 @@ static int tusb_probe(struct platform_device *pdev)
         struct musb_hdrc_platform_data  *pdata = dev_get_platdata(&pdev->dev);
         struct platform_device          *musb;
         struct tusb6010_glue            *glue;
-
+        struct platform_device_info     pinfo;
         int                             ret = -ENOMEM;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
@@ -1169,18 +1173,7 @@ static int tusb_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
-        if (!musb) {
-                dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
-        }
-
-        musb->dev.parent                = &pdev->dev;
-        musb->dev.dma_mask              = &tusb_dmamask;
-        musb->dev.coherent_dma_mask     = tusb_dmamask;
-
         glue->dev                       = &pdev->dev;
-        glue->musb                      = musb;
 
         pdata->platform_ops             = &tusb_ops;
 
@@ -1204,31 +1197,23 @@ static int tusb_probe(struct platform_device *pdev)
         musb_resources[2].end = pdev->resource[2].end;
         musb_resources[2].flags = pdev->resource[2].flags;
 
-        ret = platform_device_add_resources(musb, musb_resources,
-                        ARRAY_SIZE(musb_resources));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add resources\n");
-                goto err3;
-        }
-
-        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
-        if (ret) {
-                dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err3;
-        }
-
-        ret = platform_device_add(musb);
-        if (ret) {
-                dev_err(&pdev->dev, "failed to register musb device\n");
+        pinfo = tusb_dev_info;
+        pinfo.parent = &pdev->dev;
+        pinfo.res = musb_resources;
+        pinfo.num_res = ARRAY_SIZE(musb_resources);
+        pinfo.data = pdata;
+        pinfo.size_data = sizeof(*pdata);
+
+        glue->musb = musb = platform_device_register_full(&pinfo);
+        if (IS_ERR(musb)) {
+                ret = PTR_ERR(musb);
+                dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
                 goto err3;
         }
 
         return 0;
 
 err3:
-        platform_device_put(musb);
-
-err1:
         kfree(glue);
 
 err0:
diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c
index 59256b12f746..122446bf1664 100644
--- a/drivers/usb/musb/ux500.c
+++ b/drivers/usb/musb/ux500.c
@@ -259,7 +259,7 @@ static int ux500_probe(struct platform_device *pdev)
                 goto err1;
         }
 
-        clk = clk_get(&pdev->dev, "usb");
+        clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
@@ -376,17 +376,10 @@ static int ux500_resume(struct device *dev)
 
         return 0;
 }
-
-static const struct dev_pm_ops ux500_pm_ops = {
-        .suspend        = ux500_suspend,
-        .resume         = ux500_resume,
-};
-
-#define DEV_PM_OPS      (&ux500_pm_ops)
-#else
-#define DEV_PM_OPS      NULL
 #endif
 
+static SIMPLE_DEV_PM_OPS(ux500_pm_ops, ux500_suspend, ux500_resume);
+
 static const struct of_device_id ux500_match[] = {
         { .compatible = "stericsson,db8500-musb", },
         {}
@@ -397,7 +390,7 @@ static struct platform_driver ux500_driver = {
         .remove         = ux500_remove,
         .driver         = {
                 .name   = "musb-ux500",
-                .pm     = DEV_PM_OPS,
+                .pm     = &ux500_pm_ops,
                 .of_match_table = ux500_match,
         },
 };
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index d5589f9c60a9..08e2f39027ec 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -66,17 +66,6 @@ config OMAP_CONTROL_USB
           power on the USB2 PHY is present in OMAP4 and OMAP5. OMAP5 has an
           additional register to power on USB3 PHY.
 
-config OMAP_USB2
-        tristate "OMAP USB2 PHY Driver"
-        depends on ARCH_OMAP2PLUS
-        select OMAP_CONTROL_USB
-        select USB_PHY
-        help
-          Enable this to support the transceiver that is part of SOC. This
-          driver takes care of all the PHY functionality apart from comparator.
-          The USB OTG controller communicates with the comparator using this
-          driver.
-
 config OMAP_USB3
         tristate "OMAP USB3 PHY Driver"
         depends on ARCH_OMAP2PLUS || COMPILE_TEST
@@ -93,6 +82,7 @@ config AM335X_CONTROL_USB
 
 config AM335X_PHY_USB
         tristate "AM335x USB PHY Driver"
+        depends on ARM || COMPILE_TEST
         select USB_PHY
         select AM335X_CONTROL_USB
         select NOP_USB_XCEIV
@@ -123,16 +113,6 @@ config SAMSUNG_USB3PHY
           Enable this to support Samsung USB 3.0 (Super Speed) phy controller
           for samsung SoCs.
 
-config TWL4030_USB
-        tristate "TWL4030 USB Transceiver Driver"
-        depends on TWL4030_CORE && REGULATOR_TWL4030 && USB_MUSB_OMAP2PLUS
-        select USB_PHY
-        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.
-
 config TWL6030_USB
         tristate "TWL6030 USB Transceiver Driver"
         depends on TWL4030_CORE && OMAP_USB2 && USB_MUSB_OMAP2PLUS
@@ -214,6 +194,19 @@ config USB_RCAR_PHY
           To compile this driver as a module, choose M here: the
           module will be called phy-rcar-usb.
 
+config USB_RCAR_GEN2_PHY
+        tristate "Renesas R-Car Gen2 USB PHY support"
+        depends on ARCH_R8A7790 || ARCH_R8A7791 || COMPILE_TEST
+        select USB_PHY
+        help
+          Say Y here to add support for the Renesas R-Car Gen2 USB PHY driver.
+          It is typically used to control internal USB PHY for USBHS,
+          and to configure shared USB channels 0 and 2.
+          This driver supports R8A7790 and R8A7791.
+
+          To compile this driver as a module, choose M here: the
+          module will be called phy-rcar-gen2-usb.
+
 config USB_ULPI
         bool "Generic ULPI Transceiver Driver"
         depends on ARM
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index 2135e85f46ed..022c1da7fb78 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -15,12 +15,10 @@ obj-$(CONFIG_NOP_USB_XCEIV)		+= phy-generic.o
 obj-$(CONFIG_OMAP_CONTROL_USB)          += phy-omap-control.o
 obj-$(CONFIG_AM335X_CONTROL_USB)        += phy-am335x-control.o
 obj-$(CONFIG_AM335X_PHY_USB)            += phy-am335x.o
-obj-$(CONFIG_OMAP_USB2)                 += phy-omap-usb2.o
 obj-$(CONFIG_OMAP_USB3)                 += phy-omap-usb3.o
 obj-$(CONFIG_SAMSUNG_USBPHY)            += phy-samsung-usb.o
 obj-$(CONFIG_SAMSUNG_USB2PHY)           += phy-samsung-usb2.o
 obj-$(CONFIG_SAMSUNG_USB3PHY)           += phy-samsung-usb3.o
-obj-$(CONFIG_TWL4030_USB)               += phy-twl4030-usb.o
 obj-$(CONFIG_TWL6030_USB)               += phy-twl6030-usb.o
 obj-$(CONFIG_USB_EHCI_TEGRA)            += phy-tegra-usb.o
 obj-$(CONFIG_USB_GPIO_VBUS)             += phy-gpio-vbus-usb.o
@@ -29,5 +27,6 @@ obj-$(CONFIG_USB_MSM_OTG)		+= phy-msm-usb.o
 obj-$(CONFIG_USB_MV_OTG)                += phy-mv-usb.o
 obj-$(CONFIG_USB_MXS_PHY)               += phy-mxs-usb.o
 obj-$(CONFIG_USB_RCAR_PHY)              += phy-rcar-usb.o
+obj-$(CONFIG_USB_RCAR_GEN2_PHY)         += phy-rcar-gen2-usb.o
 obj-$(CONFIG_USB_ULPI)                  += phy-ulpi.o
 obj-$(CONFIG_USB_ULPI_VIEWPORT)         += phy-ulpi-viewport.o
diff --git a/drivers/usb/phy/phy-am335x-control.c b/drivers/usb/phy/phy-am335x-control.c
index 22cf07d62e4c..634f49acd20e 100644
--- a/drivers/usb/phy/phy-am335x-control.c
+++ b/drivers/usb/phy/phy-am335x-control.c
@@ -26,6 +26,41 @@ struct am335x_control_usb {
 #define USBPHY_OTGVDET_EN       (1 << 19)
 #define USBPHY_OTGSESSEND_EN    (1 << 20)
 
+#define AM335X_PHY0_WK_EN       (1 << 0)
+#define AM335X_PHY1_WK_EN       (1 << 8)
+
+static void am335x_phy_wkup(struct  phy_control *phy_ctrl, u32 id, bool on)
+{
+        struct am335x_control_usb *usb_ctrl;
+        u32 val;
+        u32 reg;
+
+        usb_ctrl = container_of(phy_ctrl, struct am335x_control_usb, phy_ctrl);
+
+        switch (id) {
+        case 0:
+                reg = AM335X_PHY0_WK_EN;
+                break;
+        case 1:
+                reg = AM335X_PHY1_WK_EN;
+                break;
+        default:
+                WARN_ON(1);
+                return;
+        }
+
+        spin_lock(&usb_ctrl->lock);
+        val = readl(usb_ctrl->wkup);
+
+        if (on)
+                val |= reg;
+        else
+                val &= ~reg;
+
+        writel(val, usb_ctrl->wkup);
+        spin_unlock(&usb_ctrl->lock);
+}
+
 static void am335x_phy_power(struct phy_control *phy_ctrl, u32 id, bool on)
 {
         struct am335x_control_usb *usb_ctrl;
@@ -59,6 +94,7 @@ static void am335x_phy_power(struct phy_control *phy_ctrl, u32 id, bool on)
 
 static const struct phy_control ctrl_am335x = {
         .phy_power = am335x_phy_power,
+        .phy_wkup = am335x_phy_wkup,
 };
 
 static const struct of_device_id omap_control_usb_id_table[] = {
@@ -117,6 +153,12 @@ static int am335x_control_usb_probe(struct platform_device *pdev)
         ctrl_usb->phy_reg = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(ctrl_usb->phy_reg))
                 return PTR_ERR(ctrl_usb->phy_reg);
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "wakeup");
+        ctrl_usb->wkup = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(ctrl_usb->wkup))
+                return PTR_ERR(ctrl_usb->wkup);
+
         spin_lock_init(&ctrl_usb->lock);
         ctrl_usb->phy_ctrl = *phy_ctrl;
 
@@ -129,7 +171,7 @@ static struct platform_driver am335x_control_driver = {
         .driver         = {
                 .name   = "am335x-control-usb",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(omap_control_usb_id_table),
+                .of_match_table = omap_control_usb_id_table,
         },
 };
 
diff --git a/drivers/usb/phy/phy-am335x.c b/drivers/usb/phy/phy-am335x.c
index c4d614d1f173..6370e50649d7 100644
--- a/drivers/usb/phy/phy-am335x.c
+++ b/drivers/usb/phy/phy-am335x.c
@@ -53,21 +53,20 @@ static int am335x_phy_probe(struct platform_device *pdev)
         }
 
         ret = usb_phy_gen_create_phy(dev, &am_phy->usb_phy_gen,
-                        USB_PHY_TYPE_USB2, 0, false, false);
+                        USB_PHY_TYPE_USB2, 0, false);
         if (ret)
                 return ret;
 
         ret = usb_add_phy_dev(&am_phy->usb_phy_gen.phy);
         if (ret)
-                goto err_add;
+                return ret;
         am_phy->usb_phy_gen.phy.init = am335x_init;
         am_phy->usb_phy_gen.phy.shutdown = am335x_shutdown;
 
         platform_set_drvdata(pdev, am_phy);
+
         return 0;
 
-err_add:
-        usb_phy_gen_cleanup_phy(&am_phy->usb_phy_gen);
         return ret;
 }
 
@@ -79,6 +78,40 @@ static int am335x_phy_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_RUNTIME
+
+static int am335x_phy_runtime_suspend(struct device *dev)
+{
+        struct platform_device  *pdev = to_platform_device(dev);
+        struct am335x_phy *am_phy = platform_get_drvdata(pdev);
+
+        if (device_may_wakeup(dev))
+                phy_ctrl_wkup(am_phy->phy_ctrl, am_phy->id, true);
+        phy_ctrl_power(am_phy->phy_ctrl, am_phy->id, false);
+        return 0;
+}
+
+static int am335x_phy_runtime_resume(struct device *dev)
+{
+        struct platform_device  *pdev = to_platform_device(dev);
+        struct am335x_phy       *am_phy = platform_get_drvdata(pdev);
+
+        phy_ctrl_power(am_phy->phy_ctrl, am_phy->id, true);
+        if (device_may_wakeup(dev))
+                phy_ctrl_wkup(am_phy->phy_ctrl, am_phy->id, false);
+        return 0;
+}
+
+static const struct dev_pm_ops am335x_pm_ops = {
+        SET_RUNTIME_PM_OPS(am335x_phy_runtime_suspend,
+                        am335x_phy_runtime_resume, NULL)
+};
+
+#define DEV_PM_OPS      (&am335x_pm_ops)
+#else
+#define DEV_PM_OPS      NULL
+#endif
+
 static const struct of_device_id am335x_phy_ids[] = {
         { .compatible = "ti,am335x-usb-phy" },
         { }
@@ -91,7 +124,8 @@ static struct platform_driver am335x_phy_driver = {
         .driver         = {
                 .name   = "am335x-phy-driver",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(am335x_phy_ids),
+                .pm = DEV_PM_OPS,
+                .of_match_table = am335x_phy_ids,
         },
 };
 
diff --git a/drivers/usb/phy/phy-fsl-usb.c b/drivers/usb/phy/phy-fsl-usb.c
index fa7c9f9628b5..7f3c73b967ce 100644
--- a/drivers/usb/phy/phy-fsl-usb.c
+++ b/drivers/usb/phy/phy-fsl-usb.c
@@ -134,7 +134,7 @@ int write_ulpi(u8 addr, u8 data)
 /* Operations that will be called from OTG Finite State Machine */
 
 /* Charge vbus for vbus pulsing in SRP */
-void fsl_otg_chrg_vbus(int on)
+void fsl_otg_chrg_vbus(struct otg_fsm *fsm, int on)
 {
         u32 tmp;
 
@@ -170,7 +170,7 @@ void fsl_otg_dischrg_vbus(int on)
 }
 
 /* A-device driver vbus, controlled through PP bit in PORTSC */
-void fsl_otg_drv_vbus(int on)
+void fsl_otg_drv_vbus(struct otg_fsm *fsm, int on)
 {
         u32 tmp;
 
@@ -188,7 +188,7 @@ void fsl_otg_drv_vbus(int on)
  * Pull-up D+, signalling connect by periperal. Also used in
  * data-line pulsing in SRP
  */
-void fsl_otg_loc_conn(int on)
+void fsl_otg_loc_conn(struct otg_fsm *fsm, int on)
 {
         u32 tmp;
 
@@ -207,7 +207,7 @@ void fsl_otg_loc_conn(int on)
  * port.  In host mode, controller will automatically send SOF.
  * Suspend will block the data on the port.
  */
-void fsl_otg_loc_sof(int on)
+void fsl_otg_loc_sof(struct otg_fsm *fsm, int on)
 {
         u32 tmp;
 
@@ -222,7 +222,7 @@ void fsl_otg_loc_sof(int on)
 }
 
 /* Start SRP pulsing by data-line pulsing, followed with v-bus pulsing. */
-void fsl_otg_start_pulse(void)
+void fsl_otg_start_pulse(struct otg_fsm *fsm)
 {
         u32 tmp;
 
@@ -235,7 +235,7 @@ void fsl_otg_start_pulse(void)
         fsl_otg_loc_conn(1);
 #endif
 
-        fsl_otg_add_timer(b_data_pulse_tmr);
+        fsl_otg_add_timer(fsm, b_data_pulse_tmr);
 }
 
 void b_data_pulse_end(unsigned long foo)
@@ -252,14 +252,14 @@ void b_data_pulse_end(unsigned long foo)
 void fsl_otg_pulse_vbus(void)
 {
         srp_wait_done = 0;
-        fsl_otg_chrg_vbus(1);
+        fsl_otg_chrg_vbus(&fsl_otg_dev->fsm, 1);
         /* start the timer to end vbus charge */
-        fsl_otg_add_timer(b_vbus_pulse_tmr);
+        fsl_otg_add_timer(&fsl_otg_dev->fsm, b_vbus_pulse_tmr);
 }
 
 void b_vbus_pulse_end(unsigned long foo)
 {
-        fsl_otg_chrg_vbus(0);
+        fsl_otg_chrg_vbus(&fsl_otg_dev->fsm, 0);
 
         /*
          * As USB3300 using the same a_sess_vld and b_sess_vld voltage
@@ -267,7 +267,7 @@ void b_vbus_pulse_end(unsigned long foo)
          * residual voltage of vbus pulsing and A device pull up
          */
         fsl_otg_dischrg_vbus(1);
-        fsl_otg_add_timer(b_srp_wait_tmr);
+        fsl_otg_add_timer(&fsl_otg_dev->fsm, b_srp_wait_tmr);
 }
 
 void b_srp_end(unsigned long foo)
@@ -289,7 +289,7 @@ void a_wait_enum(unsigned long foo)
 {
         VDBG("a_wait_enum timeout\n");
         if (!fsl_otg_dev->phy.otg->host->b_hnp_enable)
-                fsl_otg_add_timer(a_wait_enum_tmr);
+                fsl_otg_add_timer(&fsl_otg_dev->fsm, a_wait_enum_tmr);
         else
                 otg_statemachine(&fsl_otg_dev->fsm);
 }
@@ -375,8 +375,42 @@ void fsl_otg_uninit_timers(void)
         kfree(b_vbus_pulse_tmr);
 }
 
+static struct fsl_otg_timer *fsl_otg_get_timer(enum otg_fsm_timer t)
+{
+        struct fsl_otg_timer *timer;
+
+        /* REVISIT: use array of pointers to timers instead */
+        switch (t) {
+        case A_WAIT_VRISE:
+                timer = a_wait_vrise_tmr;
+                break;
+        case A_WAIT_BCON:
+                timer = a_wait_vrise_tmr;
+                break;
+        case A_AIDL_BDIS:
+                timer = a_wait_vrise_tmr;
+                break;
+        case B_ASE0_BRST:
+                timer = a_wait_vrise_tmr;
+                break;
+        case B_SE0_SRP:
+                timer = a_wait_vrise_tmr;
+                break;
+        case B_SRP_FAIL:
+                timer = a_wait_vrise_tmr;
+                break;
+        case A_WAIT_ENUM:
+                timer = a_wait_vrise_tmr;
+                break;
+        default:
+                timer = NULL;
+        }
+
+        return timer;
+}
+
 /* Add timer to timer list */
-void fsl_otg_add_timer(void *gtimer)
+void fsl_otg_add_timer(struct otg_fsm *fsm, void *gtimer)
 {
         struct fsl_otg_timer *timer = gtimer;
         struct fsl_otg_timer *tmp_timer;
@@ -394,8 +428,19 @@ void fsl_otg_add_timer(void *gtimer)
         list_add_tail(&timer->list, &active_timers);
 }
 
+static void fsl_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct fsl_otg_timer *timer;
+
+        timer = fsl_otg_get_timer(t);
+        if (!timer)
+                return;
+
+        fsl_otg_add_timer(fsm, timer);
+}
+
 /* Remove timer from the timer list; clear timeout status */
-void fsl_otg_del_timer(void *gtimer)
+void fsl_otg_del_timer(struct otg_fsm *fsm, void *gtimer)
 {
         struct fsl_otg_timer *timer = gtimer;
         struct fsl_otg_timer *tmp_timer, *del_tmp;
@@ -405,6 +450,17 @@ void fsl_otg_del_timer(void *gtimer)
                         list_del(&timer->list);
 }
 
+static void fsl_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct fsl_otg_timer *timer;
+
+        timer = fsl_otg_get_timer(t);
+        if (!timer)
+                return;
+
+        fsl_otg_del_timer(fsm, timer);
+}
+
 /*
  * Reduce timer count by 1, and find timeout conditions.
  * Called by fsl_otg 1ms timer interrupt
@@ -468,7 +524,7 @@ int fsl_otg_start_host(struct otg_fsm *fsm, int on)
                                 retval = dev->driver->pm->resume(dev);
                                 if (fsm->id) {
                                         /* default-b */
-                                        fsl_otg_drv_vbus(1);
+                                        fsl_otg_drv_vbus(fsm, 1);
                                         /*
                                          * Workaround: b_host can't driver
                                          * vbus, but PP in PORTSC needs to
@@ -493,7 +549,7 @@ int fsl_otg_start_host(struct otg_fsm *fsm, int on)
                                         retval = dev->driver->pm->suspend(dev);
                                 if (fsm->id)
                                         /* default-b */
-                                        fsl_otg_drv_vbus(0);
+                                        fsl_otg_drv_vbus(fsm, 0);
                         }
                         otg_dev->host_working = 0;
                 }
@@ -757,8 +813,8 @@ static struct otg_fsm_ops fsl_otg_ops = {
         .loc_sof = fsl_otg_loc_sof,
         .start_pulse = fsl_otg_start_pulse,
 
-        .add_timer = fsl_otg_add_timer,
-        .del_timer = fsl_otg_del_timer,
+        .add_timer = fsl_otg_fsm_add_timer,
+        .del_timer = fsl_otg_fsm_del_timer,
 
         .start_host = fsl_otg_start_host,
         .start_gadget = fsl_otg_start_gadget,
@@ -1011,7 +1067,7 @@ static int show_fsl_usb2_otg_state(struct device *dev,
                         "b_bus_suspend: %d\n"
                         "b_conn: %d\n"
                         "b_se0_srp: %d\n"
-                        "b_sess_end: %d\n"
+                        "b_ssend_srp: %d\n"
                         "b_sess_vld: %d\n"
                         "id: %d\n",
                         fsm->a_bus_req,
@@ -1026,7 +1082,7 @@ static int show_fsl_usb2_otg_state(struct device *dev,
                         fsm->b_bus_suspend,
                         fsm->b_conn,
                         fsm->b_se0_srp,
-                        fsm->b_sess_end,
+                        fsm->b_ssend_srp,
                         fsm->b_sess_vld,
                         fsm->id);
         size -= t;
@@ -1057,7 +1113,7 @@ static long fsl_otg_ioctl(struct file *file, unsigned int cmd,
                 break;
 
         case SET_A_SUSPEND_REQ:
-                fsl_otg_dev->fsm.a_suspend_req = arg;
+                fsl_otg_dev->fsm.a_suspend_req_inf = arg;
                 break;
 
         case SET_A_BUS_DROP:
diff --git a/drivers/usb/phy/phy-fsl-usb.h b/drivers/usb/phy/phy-fsl-usb.h
index e1859b8ef567..7365170a2f23 100644
--- a/drivers/usb/phy/phy-fsl-usb.h
+++ b/drivers/usb/phy/phy-fsl-usb.h
@@ -401,6 +401,6 @@ struct fsl_otg_config {
 #define GET_A_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 8, int)
 #define GET_B_BUS_REQ           _IOR(OTG_IOCTL_MAGIC, 9, int)
 
-void fsl_otg_add_timer(void *timer);
-void fsl_otg_del_timer(void *timer);
+void fsl_otg_add_timer(struct otg_fsm *fsm, void *timer);
+void fsl_otg_del_timer(struct otg_fsm *fsm, void *timer);
 void fsl_otg_pulse_vbus(void);
diff --git a/drivers/usb/phy/phy-fsm-usb.c b/drivers/usb/phy/phy-fsm-usb.c
index 7f4596606e18..329c2d2f8595 100644
--- a/drivers/usb/phy/phy-fsm-usb.c
+++ b/drivers/usb/phy/phy-fsm-usb.c
@@ -41,17 +41,17 @@ static int otg_set_protocol(struct otg_fsm *fsm, int protocol)
                         fsm->protocol, protocol);
                 /* stop old protocol */
                 if (fsm->protocol == PROTO_HOST)
-                        ret = fsm->ops->start_host(fsm, 0);
+                        ret = otg_start_host(fsm, 0);
                 else if (fsm->protocol == PROTO_GADGET)
-                        ret = fsm->ops->start_gadget(fsm, 0);
+                        ret = otg_start_gadget(fsm, 0);
                 if (ret)
                         return ret;
 
                 /* start new protocol */
                 if (protocol == PROTO_HOST)
-                        ret = fsm->ops->start_host(fsm, 1);
+                        ret = otg_start_host(fsm, 1);
                 else if (protocol == PROTO_GADGET)
-                        ret = fsm->ops->start_gadget(fsm, 1);
+                        ret = otg_start_gadget(fsm, 1);
                 if (ret)
                         return ret;
 
@@ -69,42 +69,50 @@ void otg_leave_state(struct otg_fsm *fsm, enum usb_otg_state old_state)
 {
         switch (old_state) {
         case OTG_STATE_B_IDLE:
-                otg_del_timer(fsm, b_se0_srp_tmr);
+                otg_del_timer(fsm, B_SE0_SRP);
                 fsm->b_se0_srp = 0;
+                fsm->adp_sns = 0;
+                fsm->adp_prb = 0;
                 break;
         case OTG_STATE_B_SRP_INIT:
+                fsm->data_pulse = 0;
                 fsm->b_srp_done = 0;
                 break;
         case OTG_STATE_B_PERIPHERAL:
                 break;
         case OTG_STATE_B_WAIT_ACON:
-                otg_del_timer(fsm, b_ase0_brst_tmr);
+                otg_del_timer(fsm, B_ASE0_BRST);
                 fsm->b_ase0_brst_tmout = 0;
                 break;
         case OTG_STATE_B_HOST:
                 break;
         case OTG_STATE_A_IDLE:
+                fsm->adp_prb = 0;
                 break;
         case OTG_STATE_A_WAIT_VRISE:
-                otg_del_timer(fsm, a_wait_vrise_tmr);
+                otg_del_timer(fsm, A_WAIT_VRISE);
                 fsm->a_wait_vrise_tmout = 0;
                 break;
         case OTG_STATE_A_WAIT_BCON:
-                otg_del_timer(fsm, a_wait_bcon_tmr);
+                otg_del_timer(fsm, A_WAIT_BCON);
                 fsm->a_wait_bcon_tmout = 0;
                 break;
         case OTG_STATE_A_HOST:
-                otg_del_timer(fsm, a_wait_enum_tmr);
+                otg_del_timer(fsm, A_WAIT_ENUM);
                 break;
         case OTG_STATE_A_SUSPEND:
-                otg_del_timer(fsm, a_aidl_bdis_tmr);
+                otg_del_timer(fsm, A_AIDL_BDIS);
                 fsm->a_aidl_bdis_tmout = 0;
-                fsm->a_suspend_req = 0;
+                fsm->a_suspend_req_inf = 0;
                 break;
         case OTG_STATE_A_PERIPHERAL:
+                otg_del_timer(fsm, A_BIDL_ADIS);
+                fsm->a_bidl_adis_tmout = 0;
                 break;
         case OTG_STATE_A_WAIT_VFALL:
-                otg_del_timer(fsm, a_wait_vrise_tmr);
+                otg_del_timer(fsm, A_WAIT_VFALL);
+                fsm->a_wait_vfall_tmout = 0;
+                otg_del_timer(fsm, A_WAIT_VRISE);
                 break;
         case OTG_STATE_A_VBUS_ERR:
                 break;
@@ -127,14 +135,19 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 otg_chrg_vbus(fsm, 0);
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
+                /*
+                 * Driver is responsible for starting ADP probing
+                 * if ADP sensing times out.
+                 */
+                otg_start_adp_sns(fsm);
                 otg_set_protocol(fsm, PROTO_UNDEF);
-                otg_add_timer(fsm, b_se0_srp_tmr);
+                otg_add_timer(fsm, B_SE0_SRP);
                 break;
         case OTG_STATE_B_SRP_INIT:
                 otg_start_pulse(fsm);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_UNDEF);
-                otg_add_timer(fsm, b_srp_fail_tmr);
+                otg_add_timer(fsm, B_SRP_FAIL);
                 break;
         case OTG_STATE_B_PERIPHERAL:
                 otg_chrg_vbus(fsm, 0);
@@ -147,7 +160,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_HOST);
-                otg_add_timer(fsm, b_ase0_brst_tmr);
+                otg_add_timer(fsm, B_ASE0_BRST);
                 fsm->a_bus_suspend = 0;
                 break;
         case OTG_STATE_B_HOST:
@@ -163,6 +176,7 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 otg_chrg_vbus(fsm, 0);
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
+                otg_start_adp_prb(fsm);
                 otg_set_protocol(fsm, PROTO_HOST);
                 break;
         case OTG_STATE_A_WAIT_VRISE:
@@ -170,14 +184,14 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_HOST);
-                otg_add_timer(fsm, a_wait_vrise_tmr);
+                otg_add_timer(fsm, A_WAIT_VRISE);
                 break;
         case OTG_STATE_A_WAIT_BCON:
                 otg_drv_vbus(fsm, 1);
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_HOST);
-                otg_add_timer(fsm, a_wait_bcon_tmr);
+                otg_add_timer(fsm, A_WAIT_BCON);
                 break;
         case OTG_STATE_A_HOST:
                 otg_drv_vbus(fsm, 1);
@@ -188,15 +202,15 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                  * When HNP is triggered while a_bus_req = 0, a_host will
                  * suspend too fast to complete a_set_b_hnp_en
                  */
-                if (!fsm->a_bus_req || fsm->a_suspend_req)
-                        otg_add_timer(fsm, a_wait_enum_tmr);
+                if (!fsm->a_bus_req || fsm->a_suspend_req_inf)
+                        otg_add_timer(fsm, A_WAIT_ENUM);
                 break;
         case OTG_STATE_A_SUSPEND:
                 otg_drv_vbus(fsm, 1);
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_HOST);
-                otg_add_timer(fsm, a_aidl_bdis_tmr);
+                otg_add_timer(fsm, A_AIDL_BDIS);
 
                 break;
         case OTG_STATE_A_PERIPHERAL:
@@ -204,12 +218,14 @@ int otg_set_state(struct otg_fsm *fsm, enum usb_otg_state new_state)
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_GADGET);
                 otg_drv_vbus(fsm, 1);
+                otg_add_timer(fsm, A_BIDL_ADIS);
                 break;
         case OTG_STATE_A_WAIT_VFALL:
                 otg_drv_vbus(fsm, 0);
                 otg_loc_conn(fsm, 0);
                 otg_loc_sof(fsm, 0);
                 otg_set_protocol(fsm, PROTO_HOST);
+                otg_add_timer(fsm, A_WAIT_VFALL);
                 break;
         case OTG_STATE_A_VBUS_ERR:
                 otg_drv_vbus(fsm, 0);
@@ -250,7 +266,8 @@ int otg_statemachine(struct otg_fsm *fsm)
                         otg_set_state(fsm, OTG_STATE_A_IDLE);
                 else if (fsm->b_sess_vld && fsm->otg->gadget)
                         otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
-                else if (fsm->b_bus_req && fsm->b_sess_end && fsm->b_se0_srp)
+                else if ((fsm->b_bus_req || fsm->adp_change || fsm->power_up) &&
+                                fsm->b_ssend_srp && fsm->b_se0_srp)
                         otg_set_state(fsm, OTG_STATE_B_SRP_INIT);
                 break;
         case OTG_STATE_B_SRP_INIT:
@@ -277,13 +294,14 @@ int otg_statemachine(struct otg_fsm *fsm)
         case OTG_STATE_B_HOST:
                 if (!fsm->id || !fsm->b_sess_vld)
                         otg_set_state(fsm, OTG_STATE_B_IDLE);
-                else if (!fsm->b_bus_req || !fsm->a_conn)
+                else if (!fsm->b_bus_req || !fsm->a_conn || fsm->test_device)
                         otg_set_state(fsm, OTG_STATE_B_PERIPHERAL);
                 break;
         case OTG_STATE_A_IDLE:
                 if (fsm->id)
                         otg_set_state(fsm, OTG_STATE_B_IDLE);
-                else if (!fsm->a_bus_drop && (fsm->a_bus_req || fsm->a_srp_det))
+                else if (!fsm->a_bus_drop && (fsm->a_bus_req ||
+                          fsm->a_srp_det || fsm->adp_change || fsm->power_up))
                         otg_set_state(fsm, OTG_STATE_A_WAIT_VRISE);
                 break;
         case OTG_STATE_A_WAIT_VRISE:
@@ -301,7 +319,7 @@ int otg_statemachine(struct otg_fsm *fsm)
                         otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
                 break;
         case OTG_STATE_A_HOST:
-                if ((!fsm->a_bus_req || fsm->a_suspend_req) &&
+                if ((!fsm->a_bus_req || fsm->a_suspend_req_inf) &&
                                 fsm->otg->host->b_hnp_enable)
                         otg_set_state(fsm, OTG_STATE_A_SUSPEND);
                 else if (fsm->id || !fsm->b_conn || fsm->a_bus_drop)
@@ -324,14 +342,14 @@ int otg_statemachine(struct otg_fsm *fsm)
         case OTG_STATE_A_PERIPHERAL:
                 if (fsm->id || fsm->a_bus_drop)
                         otg_set_state(fsm, OTG_STATE_A_WAIT_VFALL);
-                else if (fsm->b_bus_suspend)
+                else if (fsm->a_bidl_adis_tmout || fsm->b_bus_suspend)
                         otg_set_state(fsm, OTG_STATE_A_WAIT_BCON);
                 else if (!fsm->a_vbus_vld)
                         otg_set_state(fsm, OTG_STATE_A_VBUS_ERR);
                 break;
         case OTG_STATE_A_WAIT_VFALL:
-                if (fsm->id || fsm->a_bus_req || (!fsm->a_sess_vld &&
-                                        !fsm->b_conn))
+                if (fsm->a_wait_vfall_tmout || fsm->id || fsm->a_bus_req ||
+                                (!fsm->a_sess_vld && !fsm->b_conn))
                         otg_set_state(fsm, OTG_STATE_A_IDLE);
                 break;
         case OTG_STATE_A_VBUS_ERR:
diff --git a/drivers/usb/phy/phy-fsm-usb.h b/drivers/usb/phy/phy-fsm-usb.h
index fbe586206f33..7441b46a27f1 100644
--- a/drivers/usb/phy/phy-fsm-usb.h
+++ b/drivers/usb/phy/phy-fsm-usb.h
@@ -34,45 +34,76 @@
 #define PROTO_HOST      (1)
 #define PROTO_GADGET    (2)
 
+enum otg_fsm_timer {
+        /* Standard OTG timers */
+        A_WAIT_VRISE,
+        A_WAIT_VFALL,
+        A_WAIT_BCON,
+        A_AIDL_BDIS,
+        B_ASE0_BRST,
+        A_BIDL_ADIS,
+
+        /* Auxiliary timers */
+        B_SE0_SRP,
+        B_SRP_FAIL,
+        A_WAIT_ENUM,
+
+        NUM_OTG_FSM_TIMERS,
+};
+
 /* OTG state machine according to the OTG spec */
 struct otg_fsm {
         /* Input */
+        int id;
+        int adp_change;
+        int power_up;
+        int test_device;
+        int a_bus_drop;
+        int a_bus_req;
+        int a_srp_det;
+        int a_vbus_vld;
+        int b_conn;
         int a_bus_resume;
         int a_bus_suspend;
         int a_conn;
+        int b_bus_req;
+        int b_se0_srp;
+        int b_ssend_srp;
+        int b_sess_vld;
+        /* Auxilary inputs */
         int a_sess_vld;
-        int a_srp_det;
-        int a_vbus_vld;
         int b_bus_resume;
         int b_bus_suspend;
-        int b_conn;
-        int b_se0_srp;
-        int b_sess_end;
-        int b_sess_vld;
-        int id;
+
+        /* Output */
+        int data_pulse;
+        int drv_vbus;
+        int loc_conn;
+        int loc_sof;
+        int adp_prb;
+        int adp_sns;
 
         /* Internal variables */
         int a_set_b_hnp_en;
         int b_srp_done;
         int b_hnp_enable;
+        int a_clr_err;
+
+        /* Informative variables */
+        int a_bus_drop_inf;
+        int a_bus_req_inf;
+        int a_clr_err_inf;
+        int b_bus_req_inf;
+        /* Auxilary informative variables */
+        int a_suspend_req_inf;
 
         /* Timeout indicator for timers */
         int a_wait_vrise_tmout;
+        int a_wait_vfall_tmout;
         int a_wait_bcon_tmout;
         int a_aidl_bdis_tmout;
         int b_ase0_brst_tmout;
-
-        /* Informative variables */
-        int a_bus_drop;
-        int a_bus_req;
-        int a_clr_err;
-        int a_suspend_req;
-        int b_bus_req;
-
-        /* Output */
-        int drv_vbus;
-        int loc_conn;
-        int loc_sof;
+        int a_bidl_adis_tmout;
 
         struct otg_fsm_ops *ops;
         struct usb_otg *otg;
@@ -83,65 +114,123 @@ struct otg_fsm {
 };
 
 struct otg_fsm_ops {
-        void    (*chrg_vbus)(int on);
-        void    (*drv_vbus)(int on);
-        void    (*loc_conn)(int on);
-        void    (*loc_sof)(int on);
-        void    (*start_pulse)(void);
-        void    (*add_timer)(void *timer);
-        void    (*del_timer)(void *timer);
+        void    (*chrg_vbus)(struct otg_fsm *fsm, int on);
+        void    (*drv_vbus)(struct otg_fsm *fsm, int on);
+        void    (*loc_conn)(struct otg_fsm *fsm, int on);
+        void    (*loc_sof)(struct otg_fsm *fsm, int on);
+        void    (*start_pulse)(struct otg_fsm *fsm);
+        void    (*start_adp_prb)(struct otg_fsm *fsm);
+        void    (*start_adp_sns)(struct otg_fsm *fsm);
+        void    (*add_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
+        void    (*del_timer)(struct otg_fsm *fsm, enum otg_fsm_timer timer);
         int     (*start_host)(struct otg_fsm *fsm, int on);
         int     (*start_gadget)(struct otg_fsm *fsm, int on);
 };
 
 
-static inline void otg_chrg_vbus(struct otg_fsm *fsm, int on)
+static inline int otg_chrg_vbus(struct otg_fsm *fsm, int on)
 {
-        fsm->ops->chrg_vbus(on);
+        if (!fsm->ops->chrg_vbus)
+                return -EOPNOTSUPP;
+        fsm->ops->chrg_vbus(fsm, on);
+        return 0;
 }
 
-static inline void otg_drv_vbus(struct otg_fsm *fsm, int on)
+static inline int otg_drv_vbus(struct otg_fsm *fsm, int on)
 {
+        if (!fsm->ops->drv_vbus)
+                return -EOPNOTSUPP;
         if (fsm->drv_vbus != on) {
                 fsm->drv_vbus = on;
-                fsm->ops->drv_vbus(on);
+                fsm->ops->drv_vbus(fsm, on);
         }
+        return 0;
 }
 
-static inline void otg_loc_conn(struct otg_fsm *fsm, int on)
+static inline int otg_loc_conn(struct otg_fsm *fsm, int on)
 {
+        if (!fsm->ops->loc_conn)
+                return -EOPNOTSUPP;
         if (fsm->loc_conn != on) {
                 fsm->loc_conn = on;
-                fsm->ops->loc_conn(on);
+                fsm->ops->loc_conn(fsm, on);
         }
+        return 0;
 }
 
-static inline void otg_loc_sof(struct otg_fsm *fsm, int on)
+static inline int otg_loc_sof(struct otg_fsm *fsm, int on)
 {
+        if (!fsm->ops->loc_sof)
+                return -EOPNOTSUPP;
         if (fsm->loc_sof != on) {
                 fsm->loc_sof = on;
-                fsm->ops->loc_sof(on);
+                fsm->ops->loc_sof(fsm, on);
+        }
+        return 0;
+}
+
+static inline int otg_start_pulse(struct otg_fsm *fsm)
+{
+        if (!fsm->ops->start_pulse)
+                return -EOPNOTSUPP;
+        if (!fsm->data_pulse) {
+                fsm->data_pulse = 1;
+                fsm->ops->start_pulse(fsm);
         }
+        return 0;
 }
 
-static inline void otg_start_pulse(struct otg_fsm *fsm)
+static inline int otg_start_adp_prb(struct otg_fsm *fsm)
 {
-        fsm->ops->start_pulse();
+        if (!fsm->ops->start_adp_prb)
+                return -EOPNOTSUPP;
+        if (!fsm->adp_prb) {
+                fsm->adp_sns = 0;
+                fsm->adp_prb = 1;
+                fsm->ops->start_adp_prb(fsm);
+        }
+        return 0;
 }
 
-static inline void otg_add_timer(struct otg_fsm *fsm, void *timer)
+static inline int otg_start_adp_sns(struct otg_fsm *fsm)
 {
-        fsm->ops->add_timer(timer);
+        if (!fsm->ops->start_adp_sns)
+                return -EOPNOTSUPP;
+        if (!fsm->adp_sns) {
+                fsm->adp_sns = 1;
+                fsm->ops->start_adp_sns(fsm);
+        }
+        return 0;
 }
 
-static inline void otg_del_timer(struct otg_fsm *fsm, void *timer)
+static inline int otg_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer)
 {
-        fsm->ops->del_timer(timer);
+        if (!fsm->ops->add_timer)
+                return -EOPNOTSUPP;
+        fsm->ops->add_timer(fsm, timer);
+        return 0;
 }
 
-int otg_statemachine(struct otg_fsm *fsm);
+static inline int otg_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer timer)
+{
+        if (!fsm->ops->del_timer)
+                return -EOPNOTSUPP;
+        fsm->ops->del_timer(fsm, timer);
+        return 0;
+}
 
-/* Defined by device specific driver, for different timer implementation */
-extern struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr,
-        *a_aidl_bdis_tmr, *b_ase0_brst_tmr, *b_se0_srp_tmr, *b_srp_fail_tmr,
-        *a_wait_enum_tmr;
+static inline int otg_start_host(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->start_host)
+                return -EOPNOTSUPP;
+        return fsm->ops->start_host(fsm, on);
+}
+
+static inline int otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        if (!fsm->ops->start_gadget)
+                return -EOPNOTSUPP;
+        return fsm->ops->start_gadget(fsm, on);
+}
+
+int otg_statemachine(struct otg_fsm *fsm);
diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c
index efe59f3f7fda..fce3a9e9bb5d 100644
--- a/drivers/usb/phy/phy-generic.c
+++ b/drivers/usb/phy/phy-generic.c
@@ -35,6 +35,9 @@
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
 #include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
 
 #include "phy-generic.h"
 
@@ -64,6 +67,23 @@ static int nop_set_suspend(struct usb_phy *x, int suspend)
         return 0;
 }
 
+static void nop_reset_set(struct usb_phy_gen_xceiv *nop, int asserted)
+{
+        int value;
+
+        if (!gpio_is_valid(nop->gpio_reset))
+                return;
+
+        value = asserted;
+        if (nop->reset_active_low)
+                value = !value;
+
+        gpio_set_value_cansleep(nop->gpio_reset, value);
+
+        if (!asserted)
+                usleep_range(10000, 20000);
+}
+
 int usb_gen_phy_init(struct usb_phy *phy)
 {
         struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
@@ -74,13 +94,10 @@ int usb_gen_phy_init(struct usb_phy *phy)
         }
 
         if (!IS_ERR(nop->clk))
-                clk_enable(nop->clk);
+                clk_prepare_enable(nop->clk);
 
-        if (!IS_ERR(nop->reset)) {
-                /* De-assert RESET */
-                if (regulator_enable(nop->reset))
-                        dev_err(phy->dev, "Failed to de-assert reset\n");
-        }
+        /* De-assert RESET */
+        nop_reset_set(nop, 0);
 
         return 0;
 }
@@ -90,14 +107,11 @@ void usb_gen_phy_shutdown(struct usb_phy *phy)
 {
         struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
 
-        if (!IS_ERR(nop->reset)) {
-                /* Assert RESET */
-                if (regulator_disable(nop->reset))
-                        dev_err(phy->dev, "Failed to assert reset\n");
-        }
+        /* Assert RESET */
+        nop_reset_set(nop, 1);
 
         if (!IS_ERR(nop->clk))
-                clk_disable(nop->clk);
+                clk_disable_unprepare(nop->clk);
 
         if (!IS_ERR(nop->vcc)) {
                 if (regulator_disable(nop->vcc))
@@ -136,8 +150,7 @@ static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
 }
 
 int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                enum usb_phy_type type, u32 clk_rate, bool needs_vcc,
-                bool needs_reset)
+                enum usb_phy_type type, u32 clk_rate, bool needs_vcc)
 {
         int err;
 
@@ -160,14 +173,6 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
                 }
         }
 
-        if (!IS_ERR(nop->clk)) {
-                err = clk_prepare(nop->clk);
-                if (err) {
-                        dev_err(dev, "Error preparing clock\n");
-                        return err;
-                }
-        }
-
         nop->vcc = devm_regulator_get(dev, "vcc");
         if (IS_ERR(nop->vcc)) {
                 dev_dbg(dev, "Error getting vcc regulator: %ld\n",
@@ -176,12 +181,22 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
                         return -EPROBE_DEFER;
         }
 
-        nop->reset = devm_regulator_get(dev, "reset");
-        if (IS_ERR(nop->reset)) {
-                dev_dbg(dev, "Error getting reset regulator: %ld\n",
-                                        PTR_ERR(nop->reset));
-                if (needs_reset)
-                        return -EPROBE_DEFER;
+        if (gpio_is_valid(nop->gpio_reset)) {
+                unsigned long gpio_flags;
+
+                /* Assert RESET */
+                if (nop->reset_active_low)
+                        gpio_flags = GPIOF_OUT_INIT_LOW;
+                else
+                        gpio_flags = GPIOF_OUT_INIT_HIGH;
+
+                err = devm_gpio_request_one(dev, nop->gpio_reset,
+                                                gpio_flags, dev_name(dev));
+                if (err) {
+                        dev_err(dev, "Error requesting RESET GPIO %d\n",
+                                        nop->gpio_reset);
+                        return err;
+                }
         }
 
         nop->dev                = dev;
@@ -200,13 +215,6 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
 }
 EXPORT_SYMBOL_GPL(usb_phy_gen_create_phy);
 
-void usb_phy_gen_cleanup_phy(struct usb_phy_gen_xceiv *nop)
-{
-        if (!IS_ERR(nop->clk))
-                clk_unprepare(nop->clk);
-}
-EXPORT_SYMBOL_GPL(usb_phy_gen_cleanup_phy);
-
 static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
@@ -217,31 +225,36 @@ static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
         int err;
         u32 clk_rate = 0;
         bool needs_vcc = false;
-        bool needs_reset = false;
+
+        nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
+        if (!nop)
+                return -ENOMEM;
+
+        nop->reset_active_low = true;   /* default behaviour */
 
         if (dev->of_node) {
                 struct device_node *node = dev->of_node;
+                enum of_gpio_flags flags;
 
                 if (of_property_read_u32(node, "clock-frequency", &clk_rate))
                         clk_rate = 0;
 
                 needs_vcc = of_property_read_bool(node, "vcc-supply");
-                needs_reset = of_property_read_bool(node, "reset-supply");
+                nop->gpio_reset = of_get_named_gpio_flags(node, "reset-gpios",
+                                                                0, &flags);
+                if (nop->gpio_reset == -EPROBE_DEFER)
+                        return -EPROBE_DEFER;
+
+                nop->reset_active_low = flags & OF_GPIO_ACTIVE_LOW;
 
         } else if (pdata) {
                 type = pdata->type;
                 clk_rate = pdata->clk_rate;
                 needs_vcc = pdata->needs_vcc;
-                needs_reset = pdata->needs_reset;
+                nop->gpio_reset = pdata->gpio_reset;
         }
 
-        nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
-        if (!nop)
-                return -ENOMEM;
-
-
-        err = usb_phy_gen_create_phy(dev, nop, type, clk_rate, needs_vcc,
-                        needs_reset);
+        err = usb_phy_gen_create_phy(dev, nop, type, clk_rate, needs_vcc);
         if (err)
                 return err;
 
@@ -252,15 +265,13 @@ static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
         if (err) {
                 dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
                         err);
-                goto err_add;
+                return err;
         }
 
         platform_set_drvdata(pdev, nop);
 
         return 0;
 
-err_add:
-        usb_phy_gen_cleanup_phy(nop);
         return err;
 }
 
@@ -268,7 +279,6 @@ static int usb_phy_gen_xceiv_remove(struct platform_device *pdev)
 {
         struct usb_phy_gen_xceiv *nop = platform_get_drvdata(pdev);
 
-        usb_phy_gen_cleanup_phy(nop);
         usb_remove_phy(&nop->phy);
 
         return 0;
diff --git a/drivers/usb/phy/phy-generic.h b/drivers/usb/phy/phy-generic.h
index 61687d5a965b..d2a220d81734 100644
--- a/drivers/usb/phy/phy-generic.h
+++ b/drivers/usb/phy/phy-generic.h
@@ -6,15 +6,14 @@ struct usb_phy_gen_xceiv {
         struct device *dev;
         struct clk *clk;
         struct regulator *vcc;
-        struct regulator *reset;
+        int gpio_reset;
+        bool reset_active_low;
 };
 
 int usb_gen_phy_init(struct usb_phy *phy);
 void usb_gen_phy_shutdown(struct usb_phy *phy);
 
 int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                enum usb_phy_type type, u32 clk_rate, bool needs_vcc,
-                bool needs_reset);
-void usb_phy_gen_cleanup_phy(struct usb_phy_gen_xceiv *nop);
+                enum usb_phy_type type, u32 clk_rate, bool needs_vcc);
 
 #endif
diff --git a/drivers/usb/phy/phy-gpio-vbus-usb.c b/drivers/usb/phy/phy-gpio-vbus-usb.c
index b2f29c9aebbf..02799a5efcd4 100644
--- a/drivers/usb/phy/phy-gpio-vbus-usb.c
+++ b/drivers/usb/phy/phy-gpio-vbus-usb.c
@@ -241,7 +241,7 @@ static int gpio_vbus_set_suspend(struct usb_phy *phy, int suspend)
 
 /* platform driver interface */
 
-static int __init gpio_vbus_probe(struct platform_device *pdev)
+static int gpio_vbus_probe(struct platform_device *pdev)
 {
         struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev);
         struct gpio_vbus_data *gpio_vbus;
@@ -349,7 +349,7 @@ err_gpio:
         return err;
 }
 
-static int __exit gpio_vbus_remove(struct platform_device *pdev)
+static int gpio_vbus_remove(struct platform_device *pdev)
 {
         struct gpio_vbus_data *gpio_vbus = platform_get_drvdata(pdev);
         struct gpio_vbus_mach_info *pdata = dev_get_platdata(&pdev->dev);
@@ -398,8 +398,6 @@ static const struct dev_pm_ops gpio_vbus_dev_pm_ops = {
 };
 #endif
 
-/* NOTE:  the gpio-vbus device may *NOT* be hotplugged */
-
 MODULE_ALIAS("platform:gpio-vbus");
 
 static struct platform_driver gpio_vbus_driver = {
@@ -410,10 +408,11 @@ static struct platform_driver gpio_vbus_driver = {
                 .pm = &gpio_vbus_dev_pm_ops,
 #endif
         },
-        .remove  = __exit_p(gpio_vbus_remove),
+        .probe          = gpio_vbus_probe,
+        .remove         = gpio_vbus_remove,
 };
 
-module_platform_driver_probe(gpio_vbus_driver, gpio_vbus_probe);
+module_platform_driver(gpio_vbus_driver);
 
 MODULE_DESCRIPTION("simple GPIO controlled OTG transceiver driver");
 MODULE_AUTHOR("Philipp Zabel");
diff --git a/drivers/usb/phy/phy-omap-control.c b/drivers/usb/phy/phy-omap-control.c
index a4dda8e12562..09c5ace1edd8 100644
--- a/drivers/usb/phy/phy-omap-control.c
+++ b/drivers/usb/phy/phy-omap-control.c
@@ -20,87 +20,77 @@
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/of.h>
+#include <linux/of_device.h>
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/clk.h>
 #include <linux/usb/omap_control_usb.h>
 
-static struct omap_control_usb *control_usb;
-
-/**
- * omap_get_control_dev - returns the device pointer for this control device
- *
- * This API should be called to get the device pointer for this control
- * module device. This device pointer should be used for called other
- * exported API's in this driver.
- *
- * To be used by PHY driver and glue driver.
- */
-struct device *omap_get_control_dev(void)
-{
-        if (!control_usb)
-                return ERR_PTR(-ENODEV);
-
-        return control_usb->dev;
-}
-EXPORT_SYMBOL_GPL(omap_get_control_dev);
-
 /**
- * omap_control_usb3_phy_power - power on/off the serializer using control
- *      module
+ * omap_control_usb_phy_power - power on/off the phy using control module reg
  * @dev: the control module device
- * @on: 0 to off and 1 to on based on powering on or off the PHY
- *
- * usb3 PHY driver should call this API to power on or off the PHY.
+ * @on: 0 or 1, based on powering on or off the PHY
  */
-void omap_control_usb3_phy_power(struct device *dev, bool on)
+void omap_control_usb_phy_power(struct device *dev, int on)
 {
         u32 val;
         unsigned long rate;
-        struct omap_control_usb *control_usb = dev_get_drvdata(dev);
+        struct omap_control_usb *control_usb;
 
-        if (control_usb->type != OMAP_CTRL_DEV_TYPE2)
+        if (IS_ERR(dev) || !dev) {
+                pr_err("%s: invalid device\n", __func__);
                 return;
+        }
 
-        rate = clk_get_rate(control_usb->sys_clk);
-        rate = rate/1000000;
-
-        val = readl(control_usb->phy_power);
-
-        if (on) {
-                val &= ~(OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK |
-                        OMAP_CTRL_USB_PWRCTL_CLK_FREQ_MASK);
-                val |= OMAP_CTRL_USB3_PHY_TX_RX_POWERON <<
-                        OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;
-                val |= rate << OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT;
-        } else {
-                val &= ~OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK;
-                val |= OMAP_CTRL_USB3_PHY_TX_RX_POWEROFF <<
-                        OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;
+        control_usb = dev_get_drvdata(dev);
+        if (!control_usb) {
+                dev_err(dev, "%s: invalid control usb device\n", __func__);
+                return;
         }
 
-        writel(val, control_usb->phy_power);
-}
-EXPORT_SYMBOL_GPL(omap_control_usb3_phy_power);
+        if (control_usb->type == OMAP_CTRL_TYPE_OTGHS)
+                return;
 
-/**
- * omap_control_usb_phy_power - power on/off the phy using control module reg
- * @dev: the control module device
- * @on: 0 or 1, based on powering on or off the PHY
- */
-void omap_control_usb_phy_power(struct device *dev, int on)
-{
-        u32 val;
-        struct omap_control_usb *control_usb = dev_get_drvdata(dev);
+        val = readl(control_usb->power);
 
-        val = readl(control_usb->dev_conf);
+        switch (control_usb->type) {
+        case OMAP_CTRL_TYPE_USB2:
+                if (on)
+                        val &= ~OMAP_CTRL_DEV_PHY_PD;
+                else
+                        val |= OMAP_CTRL_DEV_PHY_PD;
+                break;
 
-        if (on)
-                val &= ~OMAP_CTRL_DEV_PHY_PD;
-        else
-                val |= OMAP_CTRL_DEV_PHY_PD;
+        case OMAP_CTRL_TYPE_PIPE3:
+                rate = clk_get_rate(control_usb->sys_clk);
+                rate = rate/1000000;
+
+                if (on) {
+                        val &= ~(OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK |
+                                        OMAP_CTRL_USB_PWRCTL_CLK_FREQ_MASK);
+                        val |= OMAP_CTRL_USB3_PHY_TX_RX_POWERON <<
+                                OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;
+                        val |= rate << OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT;
+                } else {
+                        val &= ~OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK;
+                        val |= OMAP_CTRL_USB3_PHY_TX_RX_POWEROFF <<
+                                OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT;
+                }
+                break;
 
-        writel(val, control_usb->dev_conf);
+        case OMAP_CTRL_TYPE_DRA7USB2:
+                if (on)
+                        val &= ~OMAP_CTRL_USB2_PHY_PD;
+                else
+                        val |= OMAP_CTRL_USB2_PHY_PD;
+                break;
+        default:
+                dev_err(dev, "%s: type %d not recognized\n",
+                                        __func__, control_usb->type);
+                break;
+        }
+
+        writel(val, control_usb->power);
 }
 EXPORT_SYMBOL_GPL(omap_control_usb_phy_power);
 
@@ -172,11 +162,19 @@ void omap_control_usb_set_mode(struct device *dev,
 {
         struct omap_control_usb *ctrl_usb;
 
-        if (IS_ERR(dev) || control_usb->type != OMAP_CTRL_DEV_TYPE1)
+        if (IS_ERR(dev) || !dev)
                 return;
 
         ctrl_usb = dev_get_drvdata(dev);
 
+        if (!ctrl_usb) {
+                dev_err(dev, "Invalid control usb device\n");
+                return;
+        }
+
+        if (ctrl_usb->type != OMAP_CTRL_TYPE_OTGHS)
+                return;
+
         switch (mode) {
         case USB_MODE_HOST:
                 omap_control_usb_host_mode(ctrl_usb);
@@ -193,12 +191,46 @@ void omap_control_usb_set_mode(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(omap_control_usb_set_mode);
 
+#ifdef CONFIG_OF
+
+static const enum omap_control_usb_type otghs_data = OMAP_CTRL_TYPE_OTGHS;
+static const enum omap_control_usb_type usb2_data = OMAP_CTRL_TYPE_USB2;
+static const enum omap_control_usb_type pipe3_data = OMAP_CTRL_TYPE_PIPE3;
+static const enum omap_control_usb_type dra7usb2_data = OMAP_CTRL_TYPE_DRA7USB2;
+
+static const struct of_device_id omap_control_usb_id_table[] = {
+        {
+                .compatible = "ti,control-phy-otghs",
+                .data = &otghs_data,
+        },
+        {
+                .compatible = "ti,control-phy-usb2",
+                .data = &usb2_data,
+        },
+        {
+                .compatible = "ti,control-phy-pipe3",
+                .data = &pipe3_data,
+        },
+        {
+                .compatible = "ti,control-phy-dra7usb2",
+                .data = &dra7usb2_data,
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, omap_control_usb_id_table);
+#endif
+
+
 static int omap_control_usb_probe(struct platform_device *pdev)
 {
         struct resource *res;
-        struct device_node *np = pdev->dev.of_node;
-        struct omap_control_usb_platform_data *pdata =
-                        dev_get_platdata(&pdev->dev);
+        const struct of_device_id *of_id;
+        struct omap_control_usb *control_usb;
+
+        of_id = of_match_device(of_match_ptr(omap_control_usb_id_table),
+                                                                &pdev->dev);
+        if (!of_id)
+                return -EINVAL;
 
         control_usb = devm_kzalloc(&pdev->dev, sizeof(*control_usb),
                 GFP_KERNEL);
@@ -207,40 +239,27 @@ static int omap_control_usb_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
-        if (np) {
-                of_property_read_u32(np, "ti,type", &control_usb->type);
-        } else if (pdata) {
-                control_usb->type = pdata->type;
-        } else {
-                dev_err(&pdev->dev, "no pdata present\n");
-                return -EINVAL;
-        }
-
-        control_usb->dev        = &pdev->dev;
-
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                "control_dev_conf");
-        control_usb->dev_conf = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(control_usb->dev_conf))
-                return PTR_ERR(control_usb->dev_conf);
+        control_usb->dev = &pdev->dev;
+        control_usb->type = *(enum omap_control_usb_type *)of_id->data;
 
-        if (control_usb->type == OMAP_CTRL_DEV_TYPE1) {
+        if (control_usb->type == OMAP_CTRL_TYPE_OTGHS) {
                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
                         "otghs_control");
                 control_usb->otghs_control = devm_ioremap_resource(
                         &pdev->dev, res);
                 if (IS_ERR(control_usb->otghs_control))
                         return PTR_ERR(control_usb->otghs_control);
-        }
-
-        if (control_usb->type == OMAP_CTRL_DEV_TYPE2) {
+        } else {
                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
-                        "phy_power_usb");
-                control_usb->phy_power = devm_ioremap_resource(
-                        &pdev->dev, res);
-                if (IS_ERR(control_usb->phy_power))
-                        return PTR_ERR(control_usb->phy_power);
+                                "power");
+                control_usb->power = devm_ioremap_resource(&pdev->dev, res);
+                if (IS_ERR(control_usb->power)) {
+                        dev_err(&pdev->dev, "Couldn't get power register\n");
+                        return PTR_ERR(control_usb->power);
+                }
+        }
 
+        if (control_usb->type == OMAP_CTRL_TYPE_PIPE3) {
                 control_usb->sys_clk = devm_clk_get(control_usb->dev,
                         "sys_clkin");
                 if (IS_ERR(control_usb->sys_clk)) {
@@ -249,20 +268,11 @@ static int omap_control_usb_probe(struct platform_device *pdev)
                 }
         }
 
-
         dev_set_drvdata(control_usb->dev, control_usb);
 
         return 0;
 }
 
-#ifdef CONFIG_OF
-static const struct of_device_id omap_control_usb_id_table[] = {
-        { .compatible = "ti,omap-control-usb" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, omap_control_usb_id_table);
-#endif
-
 static struct platform_driver omap_control_usb_driver = {
         .probe          = omap_control_usb_probe,
         .driver         = {
diff --git a/drivers/usb/phy/phy-omap-usb2.c b/drivers/usb/phy/phy-omap-usb2.c
deleted file mode 100644
index d266861d24f7..000000000000
--- a/drivers/usb/phy/phy-omap-usb2.c
+++ /dev/null
@@ -1,272 +0,0 @@
-/*
- * omap-usb2.c - USB PHY, talking to musb controller in OMAP.
- *
- * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.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.
- *
- * Author: Kishon Vijay Abraham I <kishon@ti.com>
- *
- * 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/module.h>
-#include <linux/platform_device.h>
-#include <linux/slab.h>
-#include <linux/of.h>
-#include <linux/io.h>
-#include <linux/usb/omap_usb.h>
-#include <linux/usb/phy_companion.h>
-#include <linux/clk.h>
-#include <linux/err.h>
-#include <linux/pm_runtime.h>
-#include <linux/delay.h>
-#include <linux/usb/omap_control_usb.h>
-
-/**
- * omap_usb2_set_comparator - links the comparator present in the sytem with
- *      this phy
- * @comparator - the companion phy(comparator) for this phy
- *
- * The phy companion driver should call this API passing the phy_companion
- * filled with set_vbus and start_srp to be used by usb phy.
- *
- * For use by phy companion driver
- */
-int omap_usb2_set_comparator(struct phy_companion *comparator)
-{
-        struct omap_usb *phy;
-        struct usb_phy  *x = usb_get_phy(USB_PHY_TYPE_USB2);
-
-        if (IS_ERR(x))
-                return -ENODEV;
-
-        phy = phy_to_omapusb(x);
-        phy->comparator = comparator;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(omap_usb2_set_comparator);
-
-static int omap_usb_set_vbus(struct usb_otg *otg, bool enabled)
-{
-        struct omap_usb *phy = phy_to_omapusb(otg->phy);
-
-        if (!phy->comparator)
-                return -ENODEV;
-
-        return phy->comparator->set_vbus(phy->comparator, enabled);
-}
-
-static int omap_usb_start_srp(struct usb_otg *otg)
-{
-        struct omap_usb *phy = phy_to_omapusb(otg->phy);
-
-        if (!phy->comparator)
-                return -ENODEV;
-
-        return phy->comparator->start_srp(phy->comparator);
-}
-
-static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
-{
-        struct usb_phy  *phy = otg->phy;
-
-        otg->host = host;
-        if (!host)
-                phy->state = OTG_STATE_UNDEFINED;
-
-        return 0;
-}
-
-static int omap_usb_set_peripheral(struct usb_otg *otg,
-                struct usb_gadget *gadget)
-{
-        struct usb_phy  *phy = otg->phy;
-
-        otg->gadget = gadget;
-        if (!gadget)
-                phy->state = OTG_STATE_UNDEFINED;
-
-        return 0;
-}
-
-static int omap_usb2_suspend(struct usb_phy *x, int suspend)
-{
-        struct omap_usb *phy = phy_to_omapusb(x);
-        int ret;
-
-        if (suspend && !phy->is_suspended) {
-                omap_control_usb_phy_power(phy->control_dev, 0);
-                pm_runtime_put_sync(phy->dev);
-                phy->is_suspended = 1;
-        } else if (!suspend && phy->is_suspended) {
-                ret = pm_runtime_get_sync(phy->dev);
-                if (ret < 0) {
-                        dev_err(phy->dev, "get_sync failed with err %d\n", ret);
-                        return ret;
-                }
-                omap_control_usb_phy_power(phy->control_dev, 1);
-                phy->is_suspended = 0;
-        }
-
-        return 0;
-}
-
-static int omap_usb2_probe(struct platform_device *pdev)
-{
-        struct omap_usb                 *phy;
-        struct usb_otg                  *otg;
-
-        phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
-        if (!phy) {
-                dev_err(&pdev->dev, "unable to allocate memory for USB2 PHY\n");
-                return -ENOMEM;
-        }
-
-        otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
-        if (!otg) {
-                dev_err(&pdev->dev, "unable to allocate memory for USB OTG\n");
-                return -ENOMEM;
-        }
-
-        phy->dev                = &pdev->dev;
-
-        phy->phy.dev            = phy->dev;
-        phy->phy.label          = "omap-usb2";
-        phy->phy.set_suspend    = omap_usb2_suspend;
-        phy->phy.otg            = otg;
-        phy->phy.type           = USB_PHY_TYPE_USB2;
-
-        phy->control_dev = omap_get_control_dev();
-        if (IS_ERR(phy->control_dev)) {
-                dev_dbg(&pdev->dev, "Failed to get control device\n");
-                return -ENODEV;
-        }
-
-        phy->is_suspended       = 1;
-        omap_control_usb_phy_power(phy->control_dev, 0);
-
-        otg->set_host           = omap_usb_set_host;
-        otg->set_peripheral     = omap_usb_set_peripheral;
-        otg->set_vbus           = omap_usb_set_vbus;
-        otg->start_srp          = omap_usb_start_srp;
-        otg->phy                = &phy->phy;
-
-        phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
-        if (IS_ERR(phy->wkupclk)) {
-                dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
-                return PTR_ERR(phy->wkupclk);
-        }
-        clk_prepare(phy->wkupclk);
-
-        phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
-        if (IS_ERR(phy->optclk))
-                dev_vdbg(&pdev->dev, "unable to get refclk960m\n");
-        else
-                clk_prepare(phy->optclk);
-
-        usb_add_phy_dev(&phy->phy);
-
-        platform_set_drvdata(pdev, phy);
-
-        pm_runtime_enable(phy->dev);
-
-        return 0;
-}
-
-static int omap_usb2_remove(struct platform_device *pdev)
-{
-        struct omap_usb *phy = platform_get_drvdata(pdev);
-
-        clk_unprepare(phy->wkupclk);
-        if (!IS_ERR(phy->optclk))
-                clk_unprepare(phy->optclk);
-        usb_remove_phy(&phy->phy);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_RUNTIME
-
-static int omap_usb2_runtime_suspend(struct device *dev)
-{
-        struct platform_device  *pdev = to_platform_device(dev);
-        struct omap_usb *phy = platform_get_drvdata(pdev);
-
-        clk_disable(phy->wkupclk);
-        if (!IS_ERR(phy->optclk))
-                clk_disable(phy->optclk);
-
-        return 0;
-}
-
-static int omap_usb2_runtime_resume(struct device *dev)
-{
-        struct platform_device  *pdev = to_platform_device(dev);
-        struct omap_usb *phy = platform_get_drvdata(pdev);
-        int ret;
-
-        ret = clk_enable(phy->wkupclk);
-        if (ret < 0) {
-                dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
-                goto err0;
-        }
-
-        if (!IS_ERR(phy->optclk)) {
-                ret = clk_enable(phy->optclk);
-                if (ret < 0) {
-                        dev_err(phy->dev, "Failed to enable optclk %d\n", ret);
-                        goto err1;
-                }
-        }
-
-        return 0;
-
-err1:
-        clk_disable(phy->wkupclk);
-
-err0:
-        return ret;
-}
-
-static const struct dev_pm_ops omap_usb2_pm_ops = {
-        SET_RUNTIME_PM_OPS(omap_usb2_runtime_suspend, omap_usb2_runtime_resume,
-                NULL)
-};
-
-#define DEV_PM_OPS     (&omap_usb2_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
-#endif
-
-#ifdef CONFIG_OF
-static const struct of_device_id omap_usb2_id_table[] = {
-        { .compatible = "ti,omap-usb2" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, omap_usb2_id_table);
-#endif
-
-static struct platform_driver omap_usb2_driver = {
-        .probe          = omap_usb2_probe,
-        .remove         = omap_usb2_remove,
-        .driver         = {
-                .name   = "omap-usb2",
-                .owner  = THIS_MODULE,
-                .pm     = DEV_PM_OPS,
-                .of_match_table = of_match_ptr(omap_usb2_id_table),
-        },
-};
-
-module_platform_driver(omap_usb2_driver);
-
-MODULE_ALIAS("platform: omap_usb2");
-MODULE_AUTHOR("Texas Instruments Inc.");
-MODULE_DESCRIPTION("OMAP USB2 phy driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/phy/phy-omap-usb3.c b/drivers/usb/phy/phy-omap-usb3.c
index fc15694d3031..0c6ba29bdddd 100644
--- a/drivers/usb/phy/phy-omap-usb3.c
+++ b/drivers/usb/phy/phy-omap-usb3.c
@@ -26,6 +26,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/delay.h>
 #include <linux/usb/omap_control_usb.h>
+#include <linux/of_platform.h>
 
 #define PLL_STATUS              0x00000004
 #define PLL_GO                  0x00000008
@@ -79,7 +80,7 @@ static struct usb_dpll_params *omap_usb3_get_dpll_params(unsigned long rate)
                         return &dpll_map[i].params;
         }
 
-        return 0;
+        return NULL;
 }
 
 static int omap_usb3_suspend(struct usb_phy *x, int suspend)
@@ -100,7 +101,7 @@ static int omap_usb3_suspend(struct usb_phy *x, int suspend)
                         udelay(1);
                 } while (--timeout);
 
-                omap_control_usb3_phy_power(phy->control_dev, 0);
+                omap_control_usb_phy_power(phy->control_dev, 0);
 
                 phy->is_suspended       = 1;
         } else if (!suspend && phy->is_suspended) {
@@ -189,15 +190,21 @@ static int omap_usb3_init(struct usb_phy *x)
         if (ret)
                 return ret;
 
-        omap_control_usb3_phy_power(phy->control_dev, 1);
+        omap_control_usb_phy_power(phy->control_dev, 1);
 
         return 0;
 }
 
 static int omap_usb3_probe(struct platform_device *pdev)
 {
-        struct omap_usb                 *phy;
-        struct resource                 *res;
+        struct omap_usb *phy;
+        struct resource *res;
+        struct device_node *node = pdev->dev.of_node;
+        struct device_node *control_node;
+        struct platform_device *control_pdev;
+
+        if (!node)
+                return -EINVAL;
 
         phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
         if (!phy) {
@@ -239,13 +246,20 @@ static int omap_usb3_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
-        phy->control_dev = omap_get_control_dev();
-        if (IS_ERR(phy->control_dev)) {
-                dev_dbg(&pdev->dev, "Failed to get control device\n");
-                return -ENODEV;
+        control_node = of_parse_phandle(node, "ctrl-module", 0);
+        if (!control_node) {
+                dev_err(&pdev->dev, "Failed to get control device phandle\n");
+                return -EINVAL;
         }
+        control_pdev = of_find_device_by_node(control_node);
+        if (!control_pdev) {
+                dev_err(&pdev->dev, "Failed to get control device\n");
+                return -EINVAL;
+        }
+
+        phy->control_dev = &control_pdev->dev;
 
-        omap_control_usb3_phy_power(phy->control_dev, 0);
+        omap_control_usb_phy_power(phy->control_dev, 0);
         usb_add_phy_dev(&phy->phy);
 
         platform_set_drvdata(pdev, phy);
diff --git a/drivers/usb/phy/phy-rcar-gen2-usb.c b/drivers/usb/phy/phy-rcar-gen2-usb.c
new file mode 100644
index 000000000000..a99a6953f11c
--- /dev/null
+++ b/drivers/usb/phy/phy-rcar-gen2-usb.c
@@ -0,0 +1,248 @@
+/*
+ * Renesas R-Car Gen2 USB phy driver
+ *
+ * Copyright (C) 2013 Renesas Solutions Corp.
+ * Copyright (C) 2013 Cogent Embedded, 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/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/platform_data/usb-rcar-gen2-phy.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/usb/otg.h>
+
+struct rcar_gen2_usb_phy_priv {
+        struct usb_phy phy;
+        void __iomem *base;
+        struct clk *clk;
+        spinlock_t lock;
+        int usecount;
+        u32 ugctrl2;
+};
+
+#define usb_phy_to_priv(p) container_of(p, struct rcar_gen2_usb_phy_priv, phy)
+
+/* Low Power Status register */
+#define USBHS_LPSTS_REG                 0x02
+#define USBHS_LPSTS_SUSPM               (1 << 14)
+
+/* USB General control register */
+#define USBHS_UGCTRL_REG                0x80
+#define USBHS_UGCTRL_CONNECT            (1 << 2)
+#define USBHS_UGCTRL_PLLRESET           (1 << 0)
+
+/* USB General control register 2 */
+#define USBHS_UGCTRL2_REG               0x84
+#define USBHS_UGCTRL2_USB0_PCI          (1 << 4)
+#define USBHS_UGCTRL2_USB0_HS           (3 << 4)
+#define USBHS_UGCTRL2_USB2_PCI          (0 << 31)
+#define USBHS_UGCTRL2_USB2_SS           (1 << 31)
+
+/* USB General status register */
+#define USBHS_UGSTS_REG                 0x88
+#define USBHS_UGSTS_LOCK                (3 << 8)
+
+/* Enable USBHS internal phy */
+static int __rcar_gen2_usbhs_phy_enable(void __iomem *base)
+{
+        u32 val;
+        int i;
+
+        /* USBHS PHY power on */
+        val = ioread32(base + USBHS_UGCTRL_REG);
+        val &= ~USBHS_UGCTRL_PLLRESET;
+        iowrite32(val, base + USBHS_UGCTRL_REG);
+
+        val = ioread16(base + USBHS_LPSTS_REG);
+        val |= USBHS_LPSTS_SUSPM;
+        iowrite16(val, base + USBHS_LPSTS_REG);
+
+        for (i = 0; i < 20; i++) {
+                val = ioread32(base + USBHS_UGSTS_REG);
+                if ((val & USBHS_UGSTS_LOCK) == USBHS_UGSTS_LOCK) {
+                        val = ioread32(base + USBHS_UGCTRL_REG);
+                        val |= USBHS_UGCTRL_CONNECT;
+                        iowrite32(val, base + USBHS_UGCTRL_REG);
+                        return 0;
+                }
+                udelay(1);
+        }
+
+        /* Timed out waiting for the PLL lock */
+        return -ETIMEDOUT;
+}
+
+/* Disable USBHS internal phy */
+static int __rcar_gen2_usbhs_phy_disable(void __iomem *base)
+{
+        u32 val;
+
+        /* USBHS PHY power off */
+        val = ioread32(base + USBHS_UGCTRL_REG);
+        val &= ~USBHS_UGCTRL_CONNECT;
+        iowrite32(val, base + USBHS_UGCTRL_REG);
+
+        val = ioread16(base + USBHS_LPSTS_REG);
+        val &= ~USBHS_LPSTS_SUSPM;
+        iowrite16(val, base + USBHS_LPSTS_REG);
+
+        val = ioread32(base + USBHS_UGCTRL_REG);
+        val |= USBHS_UGCTRL_PLLRESET;
+        iowrite32(val, base + USBHS_UGCTRL_REG);
+        return 0;
+}
+
+/* Setup USB channels */
+static void __rcar_gen2_usb_phy_init(struct rcar_gen2_usb_phy_priv *priv)
+{
+        u32 val;
+
+        clk_prepare_enable(priv->clk);
+
+        /* Set USB channels in the USBHS UGCTRL2 register */
+        val = ioread32(priv->base);
+        val &= ~(USBHS_UGCTRL2_USB0_HS | USBHS_UGCTRL2_USB2_SS);
+        val |= priv->ugctrl2;
+        iowrite32(val, priv->base);
+}
+
+/* Shutdown USB channels */
+static void __rcar_gen2_usb_phy_shutdown(struct rcar_gen2_usb_phy_priv *priv)
+{
+        __rcar_gen2_usbhs_phy_disable(priv->base);
+        clk_disable_unprepare(priv->clk);
+}
+
+static int rcar_gen2_usb_phy_set_suspend(struct usb_phy *phy, int suspend)
+{
+        struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        retval = suspend ? __rcar_gen2_usbhs_phy_disable(priv->base) :
+                           __rcar_gen2_usbhs_phy_enable(priv->base);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return retval;
+}
+
+static int rcar_gen2_usb_phy_init(struct usb_phy *phy)
+{
+        struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        /*
+         * Enable the clock and setup USB channels
+         * if it's the first user
+         */
+        if (!priv->usecount++)
+                __rcar_gen2_usb_phy_init(priv);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        return 0;
+}
+
+static void rcar_gen2_usb_phy_shutdown(struct usb_phy *phy)
+{
+        struct rcar_gen2_usb_phy_priv *priv = usb_phy_to_priv(phy);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (!priv->usecount) {
+                dev_warn(phy->dev, "Trying to disable phy with 0 usecount\n");
+                goto out;
+        }
+
+        /* Disable everything if it's the last user */
+        if (!--priv->usecount)
+                __rcar_gen2_usb_phy_shutdown(priv);
+out:
+        spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static int rcar_gen2_usb_phy_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct rcar_gen2_phy_platform_data *pdata;
+        struct rcar_gen2_usb_phy_priv *priv;
+        struct resource *res;
+        void __iomem *base;
+        struct clk *clk;
+        int retval;
+
+        pdata = dev_get_platdata(&pdev->dev);
+        if (!pdata) {
+                dev_err(dev, "No platform data\n");
+                return -EINVAL;
+        }
+
+        clk = devm_clk_get(&pdev->dev, "usbhs");
+        if (IS_ERR(clk)) {
+                dev_err(&pdev->dev, "Can't get the clock\n");
+                return PTR_ERR(clk);
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
+
+        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                dev_err(dev, "Memory allocation failed\n");
+                return -ENOMEM;
+        }
+
+        spin_lock_init(&priv->lock);
+        priv->clk = clk;
+        priv->base = base;
+        priv->ugctrl2 = pdata->chan0_pci ?
+                        USBHS_UGCTRL2_USB0_PCI : USBHS_UGCTRL2_USB0_HS;
+        priv->ugctrl2 |= pdata->chan2_pci ?
+                        USBHS_UGCTRL2_USB2_PCI : USBHS_UGCTRL2_USB2_SS;
+        priv->phy.dev = dev;
+        priv->phy.label = dev_name(dev);
+        priv->phy.init = rcar_gen2_usb_phy_init;
+        priv->phy.shutdown = rcar_gen2_usb_phy_shutdown;
+        priv->phy.set_suspend = rcar_gen2_usb_phy_set_suspend;
+
+        retval = usb_add_phy(&priv->phy, USB_PHY_TYPE_USB2);
+        if (retval < 0) {
+                dev_err(dev, "Failed to add USB phy\n");
+                return retval;
+        }
+
+        platform_set_drvdata(pdev, priv);
+
+        return retval;
+}
+
+static int rcar_gen2_usb_phy_remove(struct platform_device *pdev)
+{
+        struct rcar_gen2_usb_phy_priv *priv = platform_get_drvdata(pdev);
+
+        usb_remove_phy(&priv->phy);
+
+        return 0;
+}
+
+static struct platform_driver rcar_gen2_usb_phy_driver = {
+        .driver = {
+                .name = "usb_phy_rcar_gen2",
+        },
+        .probe = rcar_gen2_usb_phy_probe,
+        .remove = rcar_gen2_usb_phy_remove,
+};
+
+module_platform_driver(rcar_gen2_usb_phy_driver);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Renesas R-Car Gen2 USB phy");
+MODULE_AUTHOR("Valentine Barshak <valentine.barshak@cogentembedded.com>");
diff --git a/drivers/usb/phy/phy-samsung-usb2.c b/drivers/usb/phy/phy-samsung-usb2.c
index ff70e4b19b97..b3ba86627b72 100644
--- a/drivers/usb/phy/phy-samsung-usb2.c
+++ b/drivers/usb/phy/phy-samsung-usb2.c
@@ -411,6 +411,7 @@ static int samsung_usb2phy_probe(struct platform_device *pdev)
         sphy->drv_data          = drv_data;
         sphy->phy.dev           = sphy->dev;
         sphy->phy.label         = "samsung-usb2phy";
+        sphy->phy.type          = USB_PHY_TYPE_USB2;
         sphy->phy.init          = samsung_usb2phy_init;
         sphy->phy.shutdown      = samsung_usb2phy_shutdown;
 
@@ -426,7 +427,7 @@ static int samsung_usb2phy_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, sphy);
 
-        return usb_add_phy(&sphy->phy, USB_PHY_TYPE_USB2);
+        return usb_add_phy_dev(&sphy->phy);
 }
 
 static int samsung_usb2phy_remove(struct platform_device *pdev)
diff --git a/drivers/usb/phy/phy-samsung-usb3.c b/drivers/usb/phy/phy-samsung-usb3.c
index c6eb22213de6..cc0819248acf 100644
--- a/drivers/usb/phy/phy-samsung-usb3.c
+++ b/drivers/usb/phy/phy-samsung-usb3.c
@@ -271,6 +271,7 @@ static int samsung_usb3phy_probe(struct platform_device *pdev)
         sphy->clk               = clk;
         sphy->phy.dev           = sphy->dev;
         sphy->phy.label         = "samsung-usb3phy";
+        sphy->phy.type          = USB_PHY_TYPE_USB3;
         sphy->phy.init          = samsung_usb3phy_init;
         sphy->phy.shutdown      = samsung_usb3phy_shutdown;
         sphy->drv_data          = samsung_usbphy_get_driver_data(pdev);
@@ -283,7 +284,7 @@ static int samsung_usb3phy_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, sphy);
 
-        return usb_add_phy(&sphy->phy, USB_PHY_TYPE_USB3);
+        return usb_add_phy_dev(&sphy->phy);
 }
 
 static int samsung_usb3phy_remove(struct platform_device *pdev)
diff --git a/drivers/usb/phy/phy-tegra-usb.c b/drivers/usb/phy/phy-tegra-usb.c
index e9cb1cb8abc7..82232acf1ab6 100644
--- a/drivers/usb/phy/phy-tegra-usb.c
+++ b/drivers/usb/phy/phy-tegra-usb.c
@@ -1090,7 +1090,7 @@ static struct platform_driver tegra_usb_phy_driver = {
         .driver         = {
                 .name   = "tegra-phy",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(tegra_usb_phy_id_table),
+                .of_match_table = tegra_usb_phy_id_table,
         },
 };
 module_platform_driver(tegra_usb_phy_driver);
diff --git a/drivers/usb/phy/phy-twl4030-usb.c b/drivers/usb/phy/phy-twl4030-usb.c
deleted file mode 100644
index 90730c8762b8..000000000000
--- a/drivers/usb/phy/phy-twl4030-usb.c
+++ /dev/null
@@ -1,794 +0,0 @@
-/*
- * 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/usb/musb-omap.h>
-#include <linux/usb/ulpi.h>
-#include <linux/i2c/twl.h>
-#include <linux/regulator/consumer.h>
-#include <linux/err.h>
-#include <linux/slab.h>
-
-/* Register defines */
-
-#define MCPC_CTRL                       0x30
-#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_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_MCPC_CK_EN           (1 << 0)
-
-#define OTHER_FUNC_CTRL                 0x80
-#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_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_FALL               0x89
-#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_OTG_ENAB             (1 << 5)
-
-#define OTHER_IFC_CTRL2                 0xAF
-#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_ERROR                  0xB5
-#define ULPI_I2C_CONFLICT_INTEN         (1 << 0)
-
-#define OTHER_FUNC_CTRL2                0xB8
-#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 TWL_MODULE_PM_MASTER */
-#define STS_HW_CONDITIONS               0x0F
-
-/* In module TWL_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)
-
-struct twl4030_usb {
-        struct usb_phy          phy;
-        struct device           *dev;
-
-        /* TWL4030 internal USB regulator supplies */
-        struct regulator        *usb1v5;
-        struct regulator        *usb1v8;
-        struct regulator        *usb3v1;
-
-        /* for vbus reporting with irqs disabled */
-        spinlock_t              lock;
-
-        /* pin configuration */
-        enum twl4030_usb_mode   usb_mode;
-
-        int                     irq;
-        enum omap_musb_vbus_id_status linkstat;
-        bool                    vbus_supplied;
-        u8                      asleep;
-        bool                    irq_enabled;
-
-        struct delayed_work     id_workaround_work;
-};
-
-/* internal define on top of container_of */
-#define phy_to_twl(x)           container_of((x), struct twl4030_usb, phy)
-
-/*-------------------------------------------------------------------------*/
-
-static int twl4030_i2c_write_u8_verify(struct twl4030_usb *twl,
-                u8 module, u8 data, u8 address)
-{
-        u8 check;
-
-        if ((twl_i2c_write_u8(module, data, address) >= 0) &&
-            (twl_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 ((twl_i2c_write_u8(module, data, address) >= 0) &&
-            (twl_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, TWL_MODULE_USB, (data), (address))
-
-static inline int twl4030_usb_write(struct twl4030_usb *twl,
-                u8 address, u8 data)
-{
-        int ret = 0;
-
-        ret = twl_i2c_write_u8(TWL_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 = twl_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, TWL_MODULE_USB, address);
-}
-
-/*-------------------------------------------------------------------------*/
-
-static inline int
-twl4030_usb_set_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
-{
-        return twl4030_usb_write(twl, ULPI_SET(reg), bits);
-}
-
-static inline int
-twl4030_usb_clear_bits(struct twl4030_usb *twl, u8 reg, u8 bits)
-{
-        return twl4030_usb_write(twl, ULPI_CLR(reg), bits);
-}
-
-/*-------------------------------------------------------------------------*/
-
-static bool twl4030_is_driving_vbus(struct twl4030_usb *twl)
-{
-        int ret;
-
-        ret = twl4030_usb_read(twl, PHY_CLK_CTRL_STS);
-        if (ret < 0 || !(ret & PHY_DPLL_CLK))
-                /*
-                 * if clocks are off, registers are not updated,
-                 * but we can assume we don't drive VBUS in this case
-                 */
-                return false;
-
-        ret = twl4030_usb_read(twl, ULPI_OTG_CTRL);
-        if (ret < 0)
-                return false;
-
-        return (ret & (ULPI_OTG_DRVVBUS | ULPI_OTG_CHRGVBUS)) ? true : false;
-}
-
-static enum omap_musb_vbus_id_status
-        twl4030_usb_linkstat(struct twl4030_usb *twl)
-{
-        int     status;
-        enum omap_musb_vbus_id_status linkstat = OMAP_MUSB_UNKNOWN;
-
-        twl->vbus_supplied = false;
-
-        /*
-         * For ID/VBUS sensing, see manual section 15.4.8 ...
-         * except when using only battery backup power, two
-         * comparators produce VBUS_PRES and ID_PRES signals,
-         * which don't match docs elsewhere.  But ... BIT(7)
-         * and BIT(2) of STS_HW_CONDITIONS, respectively, do
-         * seem to match up.  If either is true the USB_PRES
-         * signal is active, the OTG module is activated, and
-         * its interrupt may be raised (may wake the system).
-         */
-        status = twl4030_readb(twl, TWL_MODULE_PM_MASTER, STS_HW_CONDITIONS);
-        if (status < 0)
-                dev_err(twl->dev, "USB link status err %d\n", status);
-        else if (status & (BIT(7) | BIT(2))) {
-                if (status & BIT(7)) {
-                        if (twl4030_is_driving_vbus(twl))
-                                status &= ~BIT(7);
-                        else
-                                twl->vbus_supplied = true;
-                }
-
-                if (status & BIT(2))
-                        linkstat = OMAP_MUSB_ID_GROUND;
-                else if (status & BIT(7))
-                        linkstat = OMAP_MUSB_VBUS_VALID;
-                else
-                        linkstat = OMAP_MUSB_VBUS_OFF;
-        } else {
-                if (twl->linkstat != OMAP_MUSB_UNKNOWN)
-                        linkstat = OMAP_MUSB_VBUS_OFF;
-        }
-
-        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...
-         */
-
-        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, ULPI_IFC_CTRL,
-                                        ULPI_IFC_CTRL_CARKITMODE);
-                twl4030_usb_set_bits(twl, POWER_CTRL, POWER_CTRL_OTG_ENAB);
-                twl4030_usb_clear_bits(twl, ULPI_FUNC_CTRL,
-                                        ULPI_FUNC_CTRL_XCVRSEL_MASK |
-                                        ULPI_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 = twl4030_usb_read(twl, PHY_PWR_CTRL);
-
-        if (on)
-                pwr &= ~PHY_PWR_PHYPWD;
-        else
-                pwr |= PHY_PWR_PHYPWD;
-
-        WARN_ON(twl4030_usb_write_verify(twl, PHY_PWR_CTRL, pwr) < 0);
-}
-
-static void twl4030_phy_power(struct twl4030_usb *twl, int on)
-{
-        int ret;
-
-        if (on) {
-                ret = regulator_enable(twl->usb3v1);
-                if (ret)
-                        dev_err(twl->dev, "Failed to enable usb3v1\n");
-
-                ret = regulator_enable(twl->usb1v8);
-                if (ret)
-                        dev_err(twl->dev, "Failed to enable usb1v8\n");
-
-                /*
-                 * Disabling usb3v1 regulator (= writing 0 to VUSB3V1_DEV_GRP
-                 * in twl4030) resets the VUSB_DEDICATED2 register. This reset
-                 * enables VUSB3V1_SLEEP bit that remaps usb3v1 ACTIVE state to
-                 * SLEEP. We work around this by clearing the bit after usv3v1
-                 * is re-activated. This ensures that VUSB3V1 is really active.
-                 */
-                twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);
-
-                ret = regulator_enable(twl->usb1v5);
-                if (ret)
-                        dev_err(twl->dev, "Failed to enable usb1v5\n");
-
-                __twl4030_phy_power(twl, 1);
-                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 {
-                __twl4030_phy_power(twl, 0);
-                regulator_disable(twl->usb1v5);
-                regulator_disable(twl->usb1v8);
-                regulator_disable(twl->usb3v1);
-        }
-}
-
-static void twl4030_phy_suspend(struct twl4030_usb *twl, int controller_off)
-{
-        if (twl->asleep)
-                return;
-
-        twl4030_phy_power(twl, 0);
-        twl->asleep = 1;
-        dev_dbg(twl->dev, "%s\n", __func__);
-}
-
-static void __twl4030_phy_resume(struct twl4030_usb *twl)
-{
-        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);
-}
-
-static void twl4030_phy_resume(struct twl4030_usb *twl)
-{
-        if (!twl->asleep)
-                return;
-        __twl4030_phy_resume(twl);
-        twl->asleep = 0;
-        dev_dbg(twl->dev, "%s\n", __func__);
-
-        /*
-         * XXX When VBUS gets driven after musb goes to A mode,
-         * ID_PRES related interrupts no longer arrive, why?
-         * Register itself is updated fine though, so we must poll.
-         */
-        if (twl->linkstat == OMAP_MUSB_ID_GROUND) {
-                cancel_delayed_work(&twl->id_workaround_work);
-                schedule_delayed_work(&twl->id_workaround_work, HZ);
-        }
-}
-
-static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
-{
-        /* Enable writing to power configuration registers */
-        twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG1,
-                         TWL4030_PM_MASTER_PROTECT_KEY);
-
-        twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG2,
-                         TWL4030_PM_MASTER_PROTECT_KEY);
-
-        /* Keep VUSB3V1 LDO in sleep state until VBUS/ID change detected*/
-        /*twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);*/
-
-        /* input to VUSB3V1 LDO is from VBAT, not VBUS */
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
-
-        /* Initialize 3.1V regulator */
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP);
-
-        twl->usb3v1 = devm_regulator_get(twl->dev, "usb3v1");
-        if (IS_ERR(twl->usb3v1))
-                return -ENODEV;
-
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
-
-        /* Initialize 1.5V regulator */
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP);
-
-        twl->usb1v5 = devm_regulator_get(twl->dev, "usb1v5");
-        if (IS_ERR(twl->usb1v5))
-                return -ENODEV;
-
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
-
-        /* Initialize 1.8V regulator */
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP);
-
-        twl->usb1v8 = devm_regulator_get(twl->dev, "usb1v8");
-        if (IS_ERR(twl->usb1v8))
-                return -ENODEV;
-
-        twl_i2c_write_u8(TWL_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
-
-        /* disable access to power configuration registers */
-        twl_i2c_write_u8(TWL_MODULE_PM_MASTER, 0,
-                         TWL4030_PM_MASTER_PROTECT_KEY);
-
-        return 0;
-}
-
-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->vbus_supplied ? "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;
-        enum omap_musb_vbus_id_status status;
-        bool status_changed = false;
-
-        status = twl4030_usb_linkstat(twl);
-
-        spin_lock_irq(&twl->lock);
-        if (status >= 0 && status != twl->linkstat) {
-                twl->linkstat = status;
-                status_changed = true;
-        }
-        spin_unlock_irq(&twl->lock);
-
-        if (status_changed) {
-                /* 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.
-                 */
-                omap_musb_mailbox(status);
-        }
-        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
-
-        return IRQ_HANDLED;
-}
-
-static void twl4030_id_workaround_work(struct work_struct *work)
-{
-        struct twl4030_usb *twl = container_of(work, struct twl4030_usb,
-                id_workaround_work.work);
-        enum omap_musb_vbus_id_status status;
-        bool status_changed = false;
-
-        status = twl4030_usb_linkstat(twl);
-
-        spin_lock_irq(&twl->lock);
-        if (status >= 0 && status != twl->linkstat) {
-                twl->linkstat = status;
-                status_changed = true;
-        }
-        spin_unlock_irq(&twl->lock);
-
-        if (status_changed) {
-                dev_dbg(twl->dev, "handle missing status change to %d\n",
-                                status);
-                omap_musb_mailbox(status);
-        }
-
-        /* don't schedule during sleep - irq works right then */
-        if (status == OMAP_MUSB_ID_GROUND && !twl->asleep) {
-                cancel_delayed_work(&twl->id_workaround_work);
-                schedule_delayed_work(&twl->id_workaround_work, HZ);
-        }
-}
-
-static int twl4030_usb_phy_init(struct usb_phy *phy)
-{
-        struct twl4030_usb *twl = phy_to_twl(phy);
-        enum omap_musb_vbus_id_status status;
-
-        /*
-         * Start in sleep state, we'll get called through set_suspend()
-         * callback when musb is runtime resumed and it's time to start.
-         */
-        __twl4030_phy_power(twl, 0);
-        twl->asleep = 1;
-
-        status = twl4030_usb_linkstat(twl);
-        twl->linkstat = status;
-
-        if (status == OMAP_MUSB_ID_GROUND || status == OMAP_MUSB_VBUS_VALID)
-                omap_musb_mailbox(twl->linkstat);
-
-        sysfs_notify(&twl->dev->kobj, NULL, "vbus");
-        return 0;
-}
-
-static int twl4030_set_suspend(struct usb_phy *x, int suspend)
-{
-        struct twl4030_usb *twl = phy_to_twl(x);
-
-        if (suspend)
-                twl4030_phy_suspend(twl, 1);
-        else
-                twl4030_phy_resume(twl);
-
-        return 0;
-}
-
-static int twl4030_set_peripheral(struct usb_otg *otg,
-                                        struct usb_gadget *gadget)
-{
-        if (!otg)
-                return -ENODEV;
-
-        otg->gadget = gadget;
-        if (!gadget)
-                otg->phy->state = OTG_STATE_UNDEFINED;
-
-        return 0;
-}
-
-static int twl4030_set_host(struct usb_otg *otg, struct usb_bus *host)
-{
-        if (!otg)
-                return -ENODEV;
-
-        otg->host = host;
-        if (!host)
-                otg->phy->state = OTG_STATE_UNDEFINED;
-
-        return 0;
-}
-
-static int twl4030_usb_probe(struct platform_device *pdev)
-{
-        struct twl4030_usb_data *pdata = dev_get_platdata(&pdev->dev);
-        struct twl4030_usb      *twl;
-        int                     status, err;
-        struct usb_otg          *otg;
-        struct device_node      *np = pdev->dev.of_node;
-
-        twl = devm_kzalloc(&pdev->dev, sizeof *twl, GFP_KERNEL);
-        if (!twl)
-                return -ENOMEM;
-
-        if (np)
-                of_property_read_u32(np, "usb_mode",
-                                (enum twl4030_usb_mode *)&twl->usb_mode);
-        else if (pdata)
-                twl->usb_mode = pdata->usb_mode;
-        else {
-                dev_err(&pdev->dev, "twl4030 initialized without pdata\n");
-                return -EINVAL;
-        }
-
-        otg = devm_kzalloc(&pdev->dev, sizeof *otg, GFP_KERNEL);
-        if (!otg)
-                return -ENOMEM;
-
-        twl->dev                = &pdev->dev;
-        twl->irq                = platform_get_irq(pdev, 0);
-        twl->vbus_supplied      = false;
-        twl->asleep             = 1;
-        twl->linkstat           = OMAP_MUSB_UNKNOWN;
-
-        twl->phy.dev            = twl->dev;
-        twl->phy.label          = "twl4030";
-        twl->phy.otg            = otg;
-        twl->phy.type           = USB_PHY_TYPE_USB2;
-        twl->phy.set_suspend    = twl4030_set_suspend;
-        twl->phy.init           = twl4030_usb_phy_init;
-
-        otg->phy                = &twl->phy;
-        otg->set_host           = twl4030_set_host;
-        otg->set_peripheral     = twl4030_set_peripheral;
-
-        /* init spinlock for workqueue */
-        spin_lock_init(&twl->lock);
-
-        INIT_DELAYED_WORK(&twl->id_workaround_work, twl4030_id_workaround_work);
-
-        err = twl4030_usb_ldo_init(twl);
-        if (err) {
-                dev_err(&pdev->dev, "ldo init failed\n");
-                return err;
-        }
-        usb_add_phy_dev(&twl->phy);
-
-        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 = devm_request_threaded_irq(twl->dev, twl->irq, NULL,
-                        twl4030_usb_irq, IRQF_TRIGGER_FALLING |
-                        IRQF_TRIGGER_RISING | IRQF_ONESHOT, "twl4030_usb", twl);
-        if (status < 0) {
-                dev_dbg(&pdev->dev, "can't get IRQ %d, err %d\n",
-                        twl->irq, status);
-                return status;
-        }
-
-        dev_info(&pdev->dev, "Initialized TWL4030 USB module\n");
-        return 0;
-}
-
-static int twl4030_usb_remove(struct platform_device *pdev)
-{
-        struct twl4030_usb *twl = platform_get_drvdata(pdev);
-        int val;
-
-        cancel_delayed_work(&twl->id_workaround_work);
-        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);
-
-        if (!twl->asleep)
-                twl4030_phy_power(twl, 0);
-
-        return 0;
-}
-
-#ifdef CONFIG_OF
-static const struct of_device_id twl4030_usb_id_table[] = {
-        { .compatible = "ti,twl4030-usb" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, twl4030_usb_id_table);
-#endif
-
-static struct platform_driver twl4030_usb_driver = {
-        .probe          = twl4030_usb_probe,
-        .remove         = twl4030_usb_remove,
-        .driver         = {
-                .name   = "twl4030_usb",
-                .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(twl4030_usb_id_table),
-        },
-};
-
-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/phy/phy-twl6030-usb.c b/drivers/usb/phy/phy-twl6030-usb.c
index 16dbc9382678..30e8a61552d4 100644
--- a/drivers/usb/phy/phy-twl6030-usb.c
+++ b/drivers/usb/phy/phy-twl6030-usb.c
@@ -33,6 +33,7 @@
 #include <linux/err.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/of.h>
 
 /* usb register definitions */
 #define USB_VENDOR_ID_LSB               0x00
diff --git a/drivers/usb/phy/phy-ulpi-viewport.c b/drivers/usb/phy/phy-ulpi-viewport.c
index 7c22a5390fc3..18bb8264b5a0 100644
--- a/drivers/usb/phy/phy-ulpi-viewport.c
+++ b/drivers/usb/phy/phy-ulpi-viewport.c
@@ -36,7 +36,7 @@ static int ulpi_viewport_wait(void __iomem *view, u32 mask)
                         return 0;
 
                 udelay(1);
-        };
+        }
 
         return -ETIMEDOUT;
 }
diff --git a/drivers/usb/phy/phy.c b/drivers/usb/phy/phy.c
index a9984c700d2c..1b74523e1fee 100644
--- a/drivers/usb/phy/phy.c
+++ b/drivers/usb/phy/phy.c
@@ -98,7 +98,7 @@ struct usb_phy *devm_usb_get_phy(struct device *dev, enum usb_phy_type type)
 
         ptr = devres_alloc(devm_usb_phy_release, sizeof(*ptr), GFP_KERNEL);
         if (!ptr)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         phy = usb_get_phy(type);
         if (!IS_ERR(phy)) {
diff --git a/drivers/usb/renesas_usbhs/Kconfig b/drivers/usb/renesas_usbhs/Kconfig
index 019bf7e49ee6..1c4195abc108 100644
--- a/drivers/usb/renesas_usbhs/Kconfig
+++ b/drivers/usb/renesas_usbhs/Kconfig
@@ -4,7 +4,7 @@
 
 config USB_RENESAS_USBHS
         tristate 'Renesas USBHS controller'
-        depends on USB_GADGET && GENERIC_HARDIRQS
+        depends on USB_GADGET
         default n
         help
           Renesas USBHS is a discrete USB host and peripheral controller chip
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index c454bfa22a10..ddb9c51f2c99 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -60,7 +60,7 @@ config USB_SERIAL_SIMPLE
                 - Suunto ANT+ USB device.
                 - Fundamental Software dongle.
                 - HP4x calculators
-                - a number of Motoroloa phones
+                - a number of Motorola phones
                 - Siemens USB/MPI adapter.
                 - ViVOtech ViVOpay USB device.
                 - Infineon Modem Flashloader USB interface
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 781426230d69..6e1b69d0f5f5 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -279,7 +279,7 @@ static void cyberjack_read_int_callback(struct urb *urb)
 
                 old_rdtodo = priv->rdtodo;
 
-                if (old_rdtodo + size < old_rdtodo) {
+                if (old_rdtodo > SHRT_MAX - size) {
                         dev_dbg(dev, "To many bulk_in urbs to do.\n");
                         spin_unlock(&priv->lock);
                         goto resubmit;
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index c45f9c0a1b34..9ced8937a8f3 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -904,6 +904,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
         /* Crucible Devices */
         { USB_DEVICE(FTDI_VID, FTDI_CT_COMET_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_Z3X_PID) },
         { }                                     /* Terminating entry */
 };
 
@@ -1966,8 +1967,16 @@ static int ftdi_process_packet(struct usb_serial_port *port,
                         port->icount.dsr++;
                 if (diff_status & FTDI_RS0_RI)
                         port->icount.rng++;
-                if (diff_status & FTDI_RS0_RLSD)
+                if (diff_status & FTDI_RS0_RLSD) {
+                        struct tty_struct *tty;
+
                         port->icount.dcd++;
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty)
+                                usb_serial_handle_dcd_change(port, tty,
+                                                status & FTDI_RS0_RLSD);
+                        tty_kref_put(tty);
+                }
 
                 wake_up_interruptible(&port->port.delta_msr_wait);
                 priv->prev_status = status;
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 1b8af461b522..a7019d1e3058 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -1307,3 +1307,9 @@
  * Manufacturer: Crucible Technologies
  */
 #define FTDI_CT_COMET_PID       0x8e08
+
+/*
+ * Product: Z3X Box
+ * Manufacturer: Smart GSM Team
+ */
+#define FTDI_Z3X_PID            0x0011
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 1f31e6b4c251..2b01ec8651c2 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -7,7 +7,6 @@
  *      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>
@@ -37,7 +36,6 @@ MODULE_PARM_DESC(product, "User specified USB idProduct");
 
 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
 
-/* All of the device info needed for the Generic Serial Converter */
 struct usb_serial_driver usb_serial_generic_device = {
         .driver = {
                 .owner =        THIS_MODULE,
@@ -66,7 +64,6 @@ int usb_serial_generic_register(void)
         generic_device_ids[0].match_flags =
                 USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
 
-        /* register our generic driver with ourselves */
         retval = usb_serial_register_drivers(serial_drivers,
                         "usbserial_generic", generic_device_ids);
 #endif
@@ -76,7 +73,6 @@ int usb_serial_generic_register(void)
 void usb_serial_generic_deregister(void)
 {
 #ifdef CONFIG_USB_SERIAL_GENERIC
-        /* remove our generic driver */
         usb_serial_deregister_drivers(serial_drivers);
 #endif
 }
@@ -86,13 +82,11 @@ int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port
         int result = 0;
         unsigned long flags;
 
-        /* clear the throttle flags */
         spin_lock_irqsave(&port->lock, flags);
         port->throttled = 0;
         port->throttle_req = 0;
         spin_unlock_irqrestore(&port->lock, flags);
 
-        /* if we have a bulk endpoint, start reading from it */
         if (port->bulk_in_size)
                 result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
 
@@ -127,12 +121,16 @@ int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
 }
 
 /**
- * usb_serial_generic_write_start - kick off an URB write
- * @port:       Pointer to the &struct usb_serial_port data
+ * usb_serial_generic_write_start - start writing buffered data
+ * @port: usb-serial port
+ * @mem_flags: flags to use for memory allocations
+ *
+ * Serialised using USB_SERIAL_WRITE_BUSY flag.
  *
- * Returns zero on success, or a negative errno value
+ * Return: Zero on success or if busy, otherwise a negative errno value.
  */
-static int usb_serial_generic_write_start(struct usb_serial_port *port)
+int usb_serial_generic_write_start(struct usb_serial_port *port,
+                                                        gfp_t mem_flags)
 {
         struct urb *urb;
         int count, result;
@@ -163,7 +161,7 @@ retry:
         spin_unlock_irqrestore(&port->lock, flags);
 
         clear_bit(i, &port->write_urbs_free);
-        result = usb_submit_urb(urb, GFP_ATOMIC);
+        result = usb_submit_urb(urb, mem_flags);
         if (result) {
                 dev_err_console(port, "%s - error submitting urb: %d\n",
                                                 __func__, result);
@@ -175,34 +173,34 @@ retry:
                 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
                 return result;
         }
-
-        /* Try sending off another urb, unless in irq context (in which case
-         * there will be no free urb). */
-        if (!in_irq())
+        /*
+         * Try sending off another urb, unless called from completion handler
+         * (in which case there will be no free urb or no data).
+         */
+        if (mem_flags != GFP_ATOMIC)
                 goto retry;
 
         clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(usb_serial_generic_write_start);
 
 /**
- * usb_serial_generic_write - generic write function for serial USB devices
- * @tty:        Pointer to &struct tty_struct for the device
- * @port:       Pointer to the &usb_serial_port structure for the device
- * @buf:        Pointer to the data to write
- * @count:      Number of bytes to write
+ * usb_serial_generic_write - generic write function
+ * @tty: tty for the port
+ * @port: usb-serial port
+ * @buf: data to write
+ * @count: number of bytes to write
  *
- * Returns the number of characters actually written, which may be anything
- * from zero to @count. If an error occurs, it returns the negative errno
- * value.
+ * Return: The number of characters buffered, which may be anything from
+ * zero to @count, or a negative errno value.
  */
 int usb_serial_generic_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count)
 {
         int result;
 
-        /* only do something if we have a bulk out endpoint */
         if (!port->bulk_out_size)
                 return -ENODEV;
 
@@ -210,7 +208,7 @@ int usb_serial_generic_write(struct tty_struct *tty,
                 return 0;
 
         count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
-        result = usb_serial_generic_write_start(port);
+        result = usb_serial_generic_write_start(port, GFP_KERNEL);
         if (result)
                 return result;
 
@@ -337,10 +335,11 @@ void usb_serial_generic_process_read_urb(struct urb *urb)
 
         if (!urb->actual_length)
                 return;
-
-        /* The per character mucking around with sysrq path it too slow for
-           stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
-           where the USB serial is not a console anyway */
+        /*
+         * The per character mucking around with sysrq path it too slow for
+         * stuff like 3G modems, so shortcircuit it in the 99.9999999% of
+         * cases where the USB serial is not a console anyway.
+         */
         if (!port->port.console || !port->sysrq)
                 tty_insert_flip_string(&port->port, ch, urb->actual_length);
         else {
@@ -413,7 +412,7 @@ void usb_serial_generic_write_bulk_callback(struct urb *urb)
                 kfifo_reset_out(&port->write_fifo);
                 spin_unlock_irqrestore(&port->lock, flags);
         } else {
-                usb_serial_generic_write_start(port);
+                usb_serial_generic_write_start(port, GFP_ATOMIC);
         }
 
         usb_serial_port_softint(port);
@@ -425,8 +424,6 @@ void usb_serial_generic_throttle(struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         unsigned long flags;
 
-        /* Set the throttle request flag. It will be picked up
-         * by usb_serial_generic_read_bulk_callback(). */
         spin_lock_irqsave(&port->lock, flags);
         port->throttle_req = 1;
         spin_unlock_irqrestore(&port->lock, flags);
@@ -438,7 +435,6 @@ void usb_serial_generic_unthrottle(struct tty_struct *tty)
         struct usb_serial_port *port = tty->driver_data;
         int was_throttled;
 
-        /* Clear the throttle flags */
         spin_lock_irq(&port->lock);
         was_throttled = port->throttled;
         port->throttled = port->throttle_req = 0;
@@ -558,10 +554,10 @@ int usb_serial_handle_break(struct usb_serial_port *port)
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 
 /**
- *      usb_serial_handle_dcd_change - handle a change of carrier detect state
- *      @port: usb_serial_port structure for the open port
- *      @tty: tty_struct structure for the port
- *      @status: new carrier detect status, nonzero if active
+ * usb_serial_handle_dcd_change - handle a change of carrier detect state
+ * @port: usb-serial port
+ * @tty: tty for the port
+ * @status: new carrier detect status, nonzero if active
  */
 void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port,
                                 struct tty_struct *tty, unsigned int status)
@@ -570,6 +566,16 @@ void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port,
 
         dev_dbg(&usb_port->dev, "%s - status %d\n", __func__, status);
 
+        if (tty) {
+                struct tty_ldisc *ld = tty_ldisc_ref(tty);
+
+                if (ld) {
+                        if (ld->ops->dcd_change)
+                                ld->ops->dcd_change(tty, status);
+                        tty_ldisc_deref(ld);
+                }
+        }
+
         if (status)
                 wake_up_interruptible(&port->open_wait);
         else if (tty && !C_CLOCAL(tty))
@@ -595,7 +601,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
                 }
 
                 if (port->bulk_out_size) {
-                        r = usb_serial_generic_write_start(port);
+                        r = usb_serial_generic_write_start(port, GFP_NOIO);
                         if (r < 0)
                                 c++;
                 }
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 84657e07dc5d..439c951f261b 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -455,7 +455,7 @@ static int parport_prologue(struct parport *pp)
                 return -1;
         }
         mos_parport->msg_pending = true;   /* synch usb call pending */
-        INIT_COMPLETION(mos_parport->syncmsg_compl);
+        reinit_completion(&mos_parport->syncmsg_compl);
         spin_unlock(&release_lock);
 
         mutex_lock(&mos_parport->serial->disc_mutex);
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index fdf953539c62..e5bdd987b9e8 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -1532,7 +1532,11 @@ static int mos7840_tiocmget(struct tty_struct *tty)
                 return -ENODEV;
 
         status = mos7840_get_uart_reg(port, MODEM_STATUS_REGISTER, &msr);
+        if (status != 1)
+                return -EIO;
         status = mos7840_get_uart_reg(port, MODEM_CONTROL_REGISTER, &mcr);
+        if (status != 1)
+                return -EIO;
         result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)
             | ((mcr & MCR_RTS) ? TIOCM_RTS : 0)
             | ((mcr & MCR_LOOPBACK) ? TIOCM_LOOP : 0)
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 1cf6f125f5f0..c3d94853b4ab 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -81,6 +81,7 @@ static void option_instat_callback(struct urb *urb);
 
 #define HUAWEI_VENDOR_ID                        0x12D1
 #define HUAWEI_PRODUCT_E173                     0x140C
+#define HUAWEI_PRODUCT_E1750                    0x1406
 #define HUAWEI_PRODUCT_K4505                    0x1464
 #define HUAWEI_PRODUCT_K3765                    0x1465
 #define HUAWEI_PRODUCT_K4605                    0x14C6
@@ -450,6 +451,10 @@ static void option_instat_callback(struct urb *urb);
 #define CHANGHONG_VENDOR_ID                     0x2077
 #define CHANGHONG_PRODUCT_CH690                 0x7001
 
+/* Inovia */
+#define INOVIA_VENDOR_ID                        0x20a6
+#define INOVIA_SEW858                           0x1105
+
 /* some devices interfaces need special handling due to a number of reasons */
 enum option_blacklist_reason {
                 OPTION_BLACKLIST_NONE = 0,
@@ -567,6 +572,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1c23, USB_CLASS_COMM, 0x02, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E173, 0xff, 0xff, 0xff),
                 .driver_info = (kernel_ulong_t) &net_intf1_blacklist },
+        { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_E1750, 0xff, 0xff, 0xff),
+                .driver_info = (kernel_ulong_t) &net_intf2_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1441, USB_CLASS_COMM, 0x02, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0x1442, USB_CLASS_COMM, 0x02, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, HUAWEI_PRODUCT_K4505, 0xff, 0xff, 0xff),
@@ -686,6 +693,222 @@ static const struct usb_device_id option_ids[] = {
         { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7A) },
         { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7B) },
         { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x02, 0x7C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x01) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x02) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x03) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x04) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x05) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x06) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x0F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x10) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x12) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x13) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x14) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x15) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x17) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x18) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x19) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x1C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x31) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x32) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x33) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x34) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x35) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x36) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x3F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x48) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x49) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x4C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x61) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x62) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x63) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x64) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x65) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x66) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x6F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x78) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x79) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x03, 0x7C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x01) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x02) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x03) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x04) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x05) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x06) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x0F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x10) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x12) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x13) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x14) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x15) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x17) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x18) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x19) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x1C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x31) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x32) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x33) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x34) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x35) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x36) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x3F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x48) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x49) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x4C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x61) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x62) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x63) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x64) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x65) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x66) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x6F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x78) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x79) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x04, 0x7C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x01) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x02) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x03) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x04) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x05) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x06) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x0F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x10) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x12) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x13) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x14) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x15) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x17) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x18) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x19) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x1C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x31) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x32) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x33) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x34) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x35) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x36) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x3F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x48) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x49) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x4C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x61) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x62) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x63) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x64) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x65) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x66) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x6F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x78) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x79) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x05, 0x7C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x01) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x02) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x03) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x04) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x05) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x06) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x0F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x10) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x12) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x13) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x14) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x15) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x17) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x18) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x19) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x1C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x31) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x32) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x33) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x34) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x35) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x36) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x3F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x48) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x49) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x4C) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x61) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x62) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x63) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x64) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x65) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x66) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6D) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6E) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x6F) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x78) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x79) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7A) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7B) },
+        { USB_VENDOR_AND_INTERFACE_INFO(HUAWEI_VENDOR_ID, 0xff, 0x06, 0x7C) },
 
 
         { USB_DEVICE(NOVATELWIRELESS_VENDOR_ID, NOVATELWIRELESS_PRODUCT_V640) },
@@ -1153,6 +1376,23 @@ static const struct usb_device_id option_ids[] = {
                 .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1426, 0xff, 0xff, 0xff),  /* ZTE MF91 */
                 .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1533, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1534, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1535, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1545, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1546, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1547, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1565, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1566, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1567, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1589, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1590, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1591, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1592, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1594, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1596, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1598, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1600, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
           0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
@@ -1254,7 +1494,9 @@ static const struct usb_device_id option_ids[] = {
 
         { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD100) },
         { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD145) },
-        { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD200) },
+        { USB_DEVICE(OLIVETTI_VENDOR_ID, OLIVETTI_PRODUCT_OLICARD200),
+                .driver_info = (kernel_ulong_t)&net_intf6_blacklist
+        },
         { USB_DEVICE(CELOT_VENDOR_ID, CELOT_PRODUCT_CT680M) }, /* CT-650 CDMA 450 1xEVDO modem */
         { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_GT_B3730, USB_CLASS_CDC_DATA, 0x00, 0x00) }, /* Samsung GT-B3730 LTE USB modem.*/
         { USB_DEVICE(YUGA_VENDOR_ID, YUGA_PRODUCT_CEM600) },
@@ -1342,6 +1584,7 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x00, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */
         { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */
+        { USB_DEVICE(INOVIA_VENDOR_ID, INOVIA_SEW858) },
         { } /* Terminating entry */
 };
 MODULE_DEVICE_TABLE(usb, option_ids);
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index e7a84f0f5179..1e6de4cd079d 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -4,11 +4,6 @@
  * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
  * Copyright (C) 2003 IBM Corp.
  *
- * Copyright (C) 2009, 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
- *  - fixes, improvements and documentation for the baud rate encoding methods
- * Copyright (C) 2013 Reinhard Max <max@suse.de>
- *  - fixes and improvements for the divisor based baud rate encoding method
- *
  * Original driver for 2.2.x by anonymous
  *
  *      This program is free software; you can redistribute it and/or
@@ -134,17 +129,10 @@ MODULE_DEVICE_TABLE(usb, id_table);
 
 
 enum pl2303_type {
-        type_0,         /* H version ? */
-        type_1,         /* H version ? */
-        HX_TA,          /* HX(A) / X(A) / TA version  */ /* TODO: improve */
-        HXD_EA_RA_SA,   /* HXD / EA / RA / SA version */ /* TODO: improve */
-        TB,             /* TB version */
+        type_0,         /* don't know the difference between type 0 and */
+        type_1,         /* type 1, until someone from prolific tells us... */
+        HX,             /* HX version of the pl2303 chip */
 };
-/*
- * NOTE: don't know the difference between type 0 and type 1,
- * until someone from Prolific tells us...
- * TODO: distinguish between X/HX, TA and HXD, EA, RA, SA variants
- */
 
 struct pl2303_serial_private {
         enum pl2303_type type;
@@ -184,7 +172,6 @@ static int pl2303_startup(struct usb_serial *serial)
 {
         struct pl2303_serial_private *spriv;
         enum pl2303_type type = type_0;
-        char *type_str = "unknown (treating as type_0)";
         unsigned char *buf;
 
         spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
@@ -197,38 +184,15 @@ static int pl2303_startup(struct usb_serial *serial)
                 return -ENOMEM;
         }
 
-        if (serial->dev->descriptor.bDeviceClass == 0x02) {
+        if (serial->dev->descriptor.bDeviceClass == 0x02)
                 type = type_0;
-                type_str = "type_0";
-        } else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40) {
-                /*
-                 * NOTE: The bcdDevice version is the only difference between
-                 * the device descriptors of the X/HX, HXD, EA, RA, SA, TA, TB
-                 */
-                if (le16_to_cpu(serial->dev->descriptor.bcdDevice) == 0x300) {
-                        type = HX_TA;
-                        type_str = "X/HX/TA";
-                } else if (le16_to_cpu(serial->dev->descriptor.bcdDevice)
-                                                                     == 0x400) {
-                        type = HXD_EA_RA_SA;
-                        type_str = "HXD/EA/RA/SA";
-                } else if (le16_to_cpu(serial->dev->descriptor.bcdDevice)
-                                                                     == 0x500) {
-                        type = TB;
-                        type_str = "TB";
-                } else {
-                        dev_info(&serial->interface->dev,
-                                           "unknown/unsupported device type\n");
-                        kfree(spriv);
-                        kfree(buf);
-                        return -ENODEV;
-                }
-        } else if (serial->dev->descriptor.bDeviceClass == 0x00
-                   || serial->dev->descriptor.bDeviceClass == 0xFF) {
+        else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
+                type = HX;
+        else if (serial->dev->descriptor.bDeviceClass == 0x00)
                 type = type_1;
-                type_str = "type_1";
-        }
-        dev_dbg(&serial->interface->dev, "device type: %s\n", type_str);
+        else if (serial->dev->descriptor.bDeviceClass == 0xFF)
+                type = type_1;
+        dev_dbg(&serial->interface->dev, "device type: %d\n", type);
 
         spriv->type = type;
         usb_set_serial_data(serial, spriv);
@@ -243,10 +207,10 @@ static int pl2303_startup(struct usb_serial *serial)
         pl2303_vendor_read(0x8383, 0, serial, buf);
         pl2303_vendor_write(0, 1, serial);
         pl2303_vendor_write(1, 0, serial);
-        if (type == type_0 || type == type_1)
-                pl2303_vendor_write(2, 0x24, serial);
-        else
+        if (type == HX)
                 pl2303_vendor_write(2, 0x44, serial);
+        else
+                pl2303_vendor_write(2, 0x24, serial);
 
         kfree(buf);
         return 0;
@@ -300,170 +264,65 @@ static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
         return retval;
 }
 
-static int pl2303_baudrate_encode_direct(int baud, enum pl2303_type type,
-                                                                      u8 buf[4])
+static void pl2303_encode_baudrate(struct tty_struct *tty,
+                                        struct usb_serial_port *port,
+                                        u8 buf[4])
 {
-        /*
-         * NOTE: Only the values defined in baud_sup are supported !
-         *       => if unsupported values are set, the PL2303 seems to
-         *          use 9600 baud (at least my PL2303X always does)
-         */
         const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
-                                 4800, 7200, 9600, 14400, 19200, 28800, 38400,
-                                 57600, 115200, 230400, 460800, 614400, 921600,
-                                 1228800, 2457600, 3000000, 6000000, 12000000 };
+                                 4800, 7200, 9600, 14400, 19200, 28800, 38400,
+                                 57600, 115200, 230400, 460800, 500000, 614400,
+                                 921600, 1228800, 2457600, 3000000, 6000000 };
+
+        struct usb_serial *serial = port->serial;
+        struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
+        int baud;
+        int i;
+
         /*
-         * NOTE: With the exception of type_0/1 devices, the following
-         * additional baud rates are supported (tested with HX rev. 3A only):
-         * 110*, 56000*, 128000, 134400, 161280, 201600, 256000*, 268800,
-         * 403200, 806400.      (*: not HX)
-         *
-         * Maximum values: HXD, TB: 12000000; HX, TA: 6000000;
-         *                 type_0+1: 1228800; RA: 921600; SA: 115200
-         *
-         * As long as we are not using this encoding method for anything else
-         * than the type_0+1 and HX chips, there is no point in complicating
-         * the code to support them.
+         * NOTE: Only the values defined in baud_sup are supported!
+         *       => if unsupported values are set, the PL2303 seems to use
+         *          9600 baud (at least my PL2303X always does)
          */
-        int i;
+        baud = tty_get_baud_rate(tty);
+        dev_dbg(&port->dev, "baud requested = %d\n", baud);
+        if (!baud)
+                return;
 
         /* Set baudrate to nearest supported value */
         for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
                 if (baud_sup[i] > baud)
                         break;
         }
+
         if (i == ARRAY_SIZE(baud_sup))
                 baud = baud_sup[i - 1];
         else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
                 baud = baud_sup[i - 1];
         else
                 baud = baud_sup[i];
-        /* Respect the chip type specific baud rate limits */
-        /*
-         * FIXME: as long as we don't know how to distinguish between the
-         * HXD, EA, RA, and SA chip variants, allow the max. value of 12M.
-         */
-        if (type == HX_TA)
-                baud = min_t(int, baud, 6000000);
-        else if (type == type_0 || type == type_1)
-                baud = min_t(int, baud, 1228800);
-        /* Direct (standard) baud rate encoding method */
-        put_unaligned_le32(baud, buf);
 
-        return baud;
-}
-
-static int pl2303_baudrate_encode_divisor(int baud, enum pl2303_type type,
-                                                                      u8 buf[4])
-{
-        /*
-         * Divisor based baud rate encoding method
-         *
-         * NOTE: it's not clear if the type_0/1 chips support this method
-         *
-         * divisor = 12MHz * 32 / baudrate = 2^A * B
-         *
-         * with
-         *
-         * A = buf[1] & 0x0e
-         * B = buf[0]  +  (buf[1] & 0x01) << 8
-         *
-         * Special cases:
-         * => 8 < B < 16: device seems to work not properly
-         * => B <= 8: device uses the max. value B = 512 instead
-         */
-        unsigned int A, B;
+        /* type_0, type_1 only support up to 1228800 baud */
+        if (spriv->type != HX)
+                baud = min_t(int, baud, 1228800);
 
-        /*
-         * NOTE: The Windows driver allows maximum baud rates of 110% of the
-         * specified maximium value.
-         * Quick tests with early (2004) HX (rev. A) chips suggest, that even
-         * higher baud rates (up to the maximum of 24M baud !) are working fine,
-         * but that should really be tested carefully in "real life" scenarios
-         * before removing the upper limit completely.
-         * Baud rates smaller than the specified 75 baud are definitely working
-         * fine.
-         */
-        if (type == type_0 || type == type_1)
-                baud = min_t(int, baud, 1228800 * 1.1);
-        else if (type == HX_TA)
-                baud = min_t(int, baud, 6000000 * 1.1);
-        else if (type == HXD_EA_RA_SA)
-                /* HXD, EA: 12Mbps; RA: 1Mbps; SA: 115200 bps */
-                /*
-                 * FIXME: as long as we don't know how to distinguish between
-                 * these chip variants, allow the max. of these values
-                 */
-                baud = min_t(int, baud, 12000000 * 1.1);
-        else if (type == TB)
-                baud = min_t(int, baud, 12000000 * 1.1);
-        /* Determine factors A and B */
-        A = 0;
-        B = 12000000 * 32 / baud;  /* 12MHz */
-        B <<= 1; /* Add one bit for rounding */
-        while (B > (512 << 1) && A <= 14) {
-                A += 2;
-                B >>= 2;
-        }
-        if (A > 14) { /* max. divisor = min. baudrate reached */
-                A = 14;
-                B = 512;
-                /* => ~45.78 baud */
+        if (baud <= 115200) {
+                put_unaligned_le32(baud, buf);
         } else {
-                B = (B + 1) >> 1; /* Round the last bit */
-        }
-        /* Handle special cases */
-        if (B == 512)
-                B = 0; /* also: 1 to 8 */
-        else if (B < 16)
                 /*
-                 * NOTE: With the current algorithm this happens
-                 * only for A=0 and means that the min. divisor
-                 * (respectively: the max. baudrate) is reached.
+                 * Apparently the formula for higher speeds is:
+                 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
                  */
-                B = 16;         /* => 24 MBaud */
-        /* Encode the baud rate */
-        buf[3] = 0x80;     /* Select divisor encoding method */
-        buf[2] = 0;
-        buf[1] = (A & 0x0e);            /* A */
-        buf[1] |= ((B & 0x100) >> 8);   /* MSB of B */
-        buf[0] = B & 0xff;              /* 8 LSBs of B */
-        /* Calculate the actual/resulting baud rate */
-        if (B <= 8)
-                B = 512;
-        baud = 12000000 * 32 / ((1 << A) * B);
-
-        return baud;
-}
-
-static void pl2303_encode_baudrate(struct tty_struct *tty,
-                                        struct usb_serial_port *port,
-                                        enum pl2303_type type,
-                                        u8 buf[4])
-{
-        int baud;
+                unsigned tmp = 12000000 * 32 / baud;
+                buf[3] = 0x80;
+                buf[2] = 0;
+                buf[1] = (tmp >= 256);
+                while (tmp >= 256) {
+                        tmp >>= 2;
+                        buf[1] <<= 1;
+                }
+                buf[0] = tmp;
+        }
 
-        baud = tty_get_baud_rate(tty);
-        dev_dbg(&port->dev, "baud requested = %d\n", baud);
-        if (!baud)
-                return;
-        /*
-         * There are two methods for setting/encoding the baud rate
-         * 1) Direct method: encodes the baud rate value directly
-         *    => supported by all chip types
-         * 2) Divisor based method: encodes a divisor to a base value (12MHz*32)
-         *    => supported by HX chips (and likely not by type_0/1 chips)
-         *
-         * NOTE: Although the divisor based baud rate encoding method is much
-         * more flexible, some of the standard baud rate values can not be
-         * realized exactly. But the difference is very small (max. 0.2%) and
-         * the device likely uses the same baud rate generator for both methods
-         * so that there is likley no difference.
-         */
-        if (type == type_0 || type == type_1)
-                baud = pl2303_baudrate_encode_direct(baud, type, buf);
-        else
-                baud = pl2303_baudrate_encode_divisor(baud, type, buf);
         /* Save resulting baud rate */
         tty_encode_baud_rate(tty, baud, baud);
         dev_dbg(&port->dev, "baud set = %d\n", baud);
@@ -520,8 +379,8 @@ static void pl2303_set_termios(struct tty_struct *tty,
                 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
         }
 
-        /* For reference:   buf[0]:buf[3] baud rate value */
-        pl2303_encode_baudrate(tty, port, spriv->type, buf);
+        /* For reference buf[0]:buf[3] baud rate value */
+        pl2303_encode_baudrate(tty, port, &buf[0]);
 
         /* For reference buf[4]=0 is 1 stop bits */
         /* For reference buf[4]=1 is 1.5 stop bits */
@@ -598,10 +457,10 @@ static void pl2303_set_termios(struct tty_struct *tty,
         dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %7ph\n", i, buf);
 
         if (C_CRTSCTS(tty)) {
-                if (spriv->type == type_0 || spriv->type == type_1)
-                        pl2303_vendor_write(0x0, 0x41, serial);
-                else
+                if (spriv->type == HX)
                         pl2303_vendor_write(0x0, 0x61, serial);
+                else
+                        pl2303_vendor_write(0x0, 0x41, serial);
         } else {
                 pl2303_vendor_write(0x0, 0x0, serial);
         }
@@ -638,7 +497,7 @@ static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
         int result;
 
-        if (spriv->type == type_0 || spriv->type == type_1) {
+        if (spriv->type != HX) {
                 usb_clear_halt(serial->dev, port->write_urb->pipe);
                 usb_clear_halt(serial->dev, port->read_urb->pipe);
         } else {
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 760b78560f67..c9a35697ebe9 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -190,6 +190,7 @@ static struct usb_device_id ti_id_table_combined[] = {
         { USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
         { USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
         { USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_PRODUCT_ID) },
+        { USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_STRIP_PORT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, FRI2_PRODUCT_ID) },
         { }     /* terminator */
 };
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 94d75edef77f..18509e6c21ab 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -211,8 +211,11 @@ static int slave_configure(struct scsi_device *sdev)
                 /*
                  * Many devices do not respond properly to READ_CAPACITY_16.
                  * Tell the SCSI layer to try READ_CAPACITY_10 first.
+                 * However some USB 3.0 drive enclosures return capacity
+                 * modulo 2TB. Those must use READ_CAPACITY_16
                  */
-                sdev->try_rc_10_first = 1;
+                if (!(us->fflags & US_FL_NEEDS_CAP16))
+                        sdev->try_rc_10_first = 1;
 
                 /* assume SPC3 or latter devices support sense size > 18 */
                 if (sdev->scsi_level > SCSI_SPC_2)
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index c015f2c16729..de32cfa5bfa6 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1925,6 +1925,13 @@ UNUSUAL_DEV(  0x1652, 0x6600, 0x0201, 0x0201,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_IGNORE_RESIDUE ),
 
+/* Reported by Oliver Neukum <oneukum@suse.com> */
+UNUSUAL_DEV(  0x174c, 0x55aa, 0x0100, 0x0100,
+                "ASMedia",
+                "AS2105",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NEEDS_CAP16),
+
 /* Reported by Jesse Feddema <jdfeddema@gmail.com> */
 UNUSUAL_DEV(  0x177f, 0x0400, 0x0000, 0x0000,
                 "Yarvik",
diff --git a/drivers/usb/wusbcore/cbaf.c b/drivers/usb/wusbcore/cbaf.c
index 7f78f300f8fb..f06ed82e63d1 100644
--- a/drivers/usb/wusbcore/cbaf.c
+++ b/drivers/usb/wusbcore/cbaf.c
@@ -208,9 +208,9 @@ static int cbaf_check(struct cbaf *cbaf)
                                 ar_name = "ASSOCIATE";
                                 ar_assoc = 1;
                                 break;
-                        };
+                        }
                         break;
-                };
+                }
 
                 dev_dbg(dev, "Association request #%02u: 0x%04x/%04x "
                          "(%zu bytes): %s\n",
@@ -623,6 +623,8 @@ static int cbaf_probe(struct usb_interface *iface,
 
 error_create_group:
 error_check:
+        usb_put_intf(iface);
+        usb_put_dev(cbaf->usb_dev);
         kfree(cbaf->buffer);
 error_kmalloc_buffer:
         kfree(cbaf);
@@ -637,6 +639,7 @@ static void cbaf_disconnect(struct usb_interface *iface)
         sysfs_remove_group(&dev->kobj, &cbaf_dev_attr_group);
         usb_set_intfdata(iface, NULL);
         usb_put_intf(iface);
+        usb_put_dev(cbaf->usb_dev);
         kfree(cbaf->buffer);
         /* paranoia: clean up crypto keys */
         kzfree(cbaf);
diff --git a/drivers/usb/wusbcore/devconnect.c b/drivers/usb/wusbcore/devconnect.c
index 33a12788f9ca..e538b72c4e3a 100644
--- a/drivers/usb/wusbcore/devconnect.c
+++ b/drivers/usb/wusbcore/devconnect.c
@@ -973,7 +973,7 @@ int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
         default:
                 WARN_ON(1);
                 result = NOTIFY_BAD;
-        };
+        }
         return result;
 }
 
diff --git a/drivers/usb/wusbcore/wa-hc.c b/drivers/usb/wusbcore/wa-hc.c
index a09b65ebd9bb..368360f9a93a 100644
--- a/drivers/usb/wusbcore/wa-hc.c
+++ b/drivers/usb/wusbcore/wa-hc.c
@@ -33,7 +33,8 @@
  * wa->usb_dev and wa->usb_iface initialized and refcounted,
  * wa->wa_descr initialized.
  */
-int wa_create(struct wahc *wa, struct usb_interface *iface)
+int wa_create(struct wahc *wa, struct usb_interface *iface,
+        kernel_ulong_t quirks)
 {
         int result;
         struct device *dev = &iface->dev;
@@ -41,14 +42,15 @@ int wa_create(struct wahc *wa, struct usb_interface *iface)
         result = wa_rpipes_create(wa);
         if (result < 0)
                 goto error_rpipes_create;
+        wa->quirks = quirks;
         /* Fill up Data Transfer EP pointers */
         wa->dti_epd = &iface->cur_altsetting->endpoint[1].desc;
         wa->dto_epd = &iface->cur_altsetting->endpoint[2].desc;
-        wa->xfer_result_size = usb_endpoint_maxp(wa->dti_epd);
-        wa->xfer_result = kmalloc(wa->xfer_result_size, GFP_KERNEL);
-        if (wa->xfer_result == NULL) {
+        wa->dti_buf_size = usb_endpoint_maxp(wa->dti_epd);
+        wa->dti_buf = kmalloc(wa->dti_buf_size, GFP_KERNEL);
+        if (wa->dti_buf == NULL) {
                 result = -ENOMEM;
-                goto error_xfer_result_alloc;
+                goto error_dti_buf_alloc;
         }
         result = wa_nep_create(wa, iface);
         if (result < 0) {
@@ -59,8 +61,8 @@ int wa_create(struct wahc *wa, struct usb_interface *iface)
         return 0;
 
 error_nep_create:
-        kfree(wa->xfer_result);
-error_xfer_result_alloc:
+        kfree(wa->dti_buf);
+error_dti_buf_alloc:
         wa_rpipes_destroy(wa);
 error_rpipes_create:
         return result;
@@ -76,7 +78,7 @@ void __wa_destroy(struct wahc *wa)
                 usb_kill_urb(wa->buf_in_urb);
                 usb_put_urb(wa->buf_in_urb);
         }
-        kfree(wa->xfer_result);
+        kfree(wa->dti_buf);
         wa_nep_destroy(wa);
         wa_rpipes_destroy(wa);
 }
diff --git a/drivers/usb/wusbcore/wa-hc.h b/drivers/usb/wusbcore/wa-hc.h
index cf250c21e946..e614f02f0cf2 100644
--- a/drivers/usb/wusbcore/wa-hc.h
+++ b/drivers/usb/wusbcore/wa-hc.h
@@ -117,11 +117,25 @@ struct wa_rpipe {
         struct wahc *wa;
         spinlock_t seg_lock;
         struct list_head seg_list;
+        struct list_head list_node;
         atomic_t segs_available;
         u8 buffer[1];   /* For reads/writes on USB */
 };
 
 
+enum wa_dti_state {
+        WA_DTI_TRANSFER_RESULT_PENDING,
+        WA_DTI_ISOC_PACKET_STATUS_PENDING
+};
+
+enum wa_quirks {
+        /*
+         * The Alereon HWA expects the data frames in isochronous transfer
+         * requests to be concatenated and not sent as separate packets.
+         */
+        WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC      = 0x01,
+};
+
 /**
  * Instance of a HWA Host Controller
  *
@@ -178,14 +192,26 @@ struct wahc {
 
         u16 rpipes;
         unsigned long *rpipe_bm;        /* rpipe usage bitmap */
-        spinlock_t rpipe_bm_lock;       /* protect rpipe_bm */
+        struct list_head rpipe_delayed_list;    /* delayed RPIPES. */
+        spinlock_t rpipe_lock;  /* protect rpipe_bm and delayed list */
         struct mutex rpipe_mutex;       /* assigning resources to endpoints */
 
+        /*
+         * dti_state is used to track the state of the dti_urb.  When dti_state
+         * is WA_DTI_ISOC_PACKET_STATUS_PENDING, dti_isoc_xfer_in_progress and
+         * dti_isoc_xfer_seg identify which xfer the incoming isoc packet status
+         * refers to.
+         */
+        enum wa_dti_state dti_state;
+        u32 dti_isoc_xfer_in_progress;
+        u8  dti_isoc_xfer_seg;
         struct urb *dti_urb;            /* URB for reading xfer results */
         struct urb *buf_in_urb;         /* URB for reading data in */
         struct edc dti_edc;             /* DTI error density counter */
-        struct wa_xfer_result *xfer_result; /* real size = dti_ep maxpktsize */
-        size_t xfer_result_size;
+        void *dti_buf;
+        size_t dti_buf_size;
+
+        unsigned long dto_in_use;       /* protect dto endoint serialization. */
 
         s32 status;                     /* For reading status */
 
@@ -200,10 +226,13 @@ struct wahc {
         struct work_struct xfer_enqueue_work;
         struct work_struct xfer_error_work;
         atomic_t xfer_id_count;
+
+        kernel_ulong_t  quirks;
 };
 
 
-extern int wa_create(struct wahc *wa, struct usb_interface *iface);
+extern int wa_create(struct wahc *wa, struct usb_interface *iface,
+        kernel_ulong_t);
 extern void __wa_destroy(struct wahc *wa);
 void wa_reset_all(struct wahc *wa);
 
@@ -239,7 +268,8 @@ static inline void wa_nep_disarm(struct wahc *wa)
 /* RPipes */
 static inline void wa_rpipe_init(struct wahc *wa)
 {
-        spin_lock_init(&wa->rpipe_bm_lock);
+        INIT_LIST_HEAD(&wa->rpipe_delayed_list);
+        spin_lock_init(&wa->rpipe_lock);
         mutex_init(&wa->rpipe_mutex);
 }
 
@@ -247,6 +277,7 @@ static inline void wa_init(struct wahc *wa)
 {
         edc_init(&wa->nep_edc);
         atomic_set(&wa->notifs_queued, 0);
+        wa->dti_state = WA_DTI_TRANSFER_RESULT_PENDING;
         wa_rpipe_init(wa);
         edc_init(&wa->dti_edc);
         INIT_LIST_HEAD(&wa->xfer_list);
@@ -255,6 +286,7 @@ static inline void wa_init(struct wahc *wa)
         spin_lock_init(&wa->xfer_list_lock);
         INIT_WORK(&wa->xfer_enqueue_work, wa_urb_enqueue_run);
         INIT_WORK(&wa->xfer_error_work, wa_process_errored_transfers_run);
+        wa->dto_in_use = 0;
         atomic_set(&wa->xfer_id_count, 1);
 }
 
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index fd4f1ce6256a..b48e74cc54d7 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -143,17 +143,18 @@ static void rpipe_init(struct wa_rpipe *rpipe)
         kref_init(&rpipe->refcnt);
         spin_lock_init(&rpipe->seg_lock);
         INIT_LIST_HEAD(&rpipe->seg_list);
+        INIT_LIST_HEAD(&rpipe->list_node);
 }
 
 static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
+        spin_lock_irqsave(&wa->rpipe_lock, flags);
         rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
         if (rpipe_idx < wa->rpipes)
                 set_bit(rpipe_idx, wa->rpipe_bm);
-        spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
+        spin_unlock_irqrestore(&wa->rpipe_lock, flags);
 
         return rpipe_idx;
 }
@@ -162,9 +163,9 @@ static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
+        spin_lock_irqsave(&wa->rpipe_lock, flags);
         clear_bit(rpipe_idx, wa->rpipe_bm);
-        spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
+        spin_unlock_irqrestore(&wa->rpipe_lock, flags);
 }
 
 void rpipe_destroy(struct kref *_rpipe)
@@ -333,7 +334,10 @@ static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
         /* FIXME: compute so seg_size > ep->maxpktsize */
         rpipe->descr.wBlocks = cpu_to_le16(16);         /* given */
         /* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
-        rpipe->descr.wMaxPacketSize = cpu_to_le16(ep->desc.wMaxPacketSize);
+        if (usb_endpoint_xfer_isoc(&ep->desc))
+                rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
+        else
+                rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;
 
         rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
                                 epcd->bMaxBurst, 16U), 1U);
@@ -361,8 +365,10 @@ static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
                         epcd->bMaxSequence, 32U), 2U);
         rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
         rpipe->descr.bInterval = ep->desc.bInterval;
-        /* FIXME: bOverTheAirInterval */
-        rpipe->descr.bOverTheAirInterval = 0;   /* 0 if not isoc */
+        if (usb_endpoint_xfer_isoc(&ep->desc))
+                rpipe->descr.bOverTheAirInterval = epcd->bOverTheAirInterval;
+        else
+                rpipe->descr.bOverTheAirInterval = 0;   /* 0 if not isoc */
         /* FIXME: xmit power & preamble blah blah */
         rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
                                         USB_ENDPOINT_XFERTYPE_MASK);
@@ -477,7 +483,7 @@ error:
  */
 int wa_rpipes_create(struct wahc *wa)
 {
-        wa->rpipes = wa->wa_descr->wNumRPipes;
+        wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes);
         wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
                                GFP_KERNEL);
         if (wa->rpipe_bm == NULL)
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index 6ad02f57c366..ed5abe87b049 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -91,7 +91,8 @@
 #include "wusbhc.h"
 
 enum {
-        WA_SEGS_MAX = 255,
+        /* [WUSB] section 8.3.3 allocates 7 bits for the segment index. */
+        WA_SEGS_MAX = 128,
 };
 
 enum wa_seg_status {
@@ -107,6 +108,7 @@ enum wa_seg_status {
 };
 
 static void wa_xfer_delayed_run(struct wa_rpipe *);
+static int __wa_xfer_delayed_run(struct wa_rpipe *rpipe, int *dto_waiting);
 
 /*
  * Life cycle governed by 'struct urb' (the refcount of the struct is
@@ -114,24 +116,27 @@ static void wa_xfer_delayed_run(struct wa_rpipe *);
  * struct).
  */
 struct wa_seg {
-        struct urb urb;
-        struct urb *dto_urb;            /* for data output? */
+        struct urb tr_urb;              /* transfer request urb. */
+        struct urb *isoc_pack_desc_urb; /* for isoc packet descriptor. */
+        struct urb *dto_urb;            /* for data output. */
         struct list_head list_node;     /* for rpipe->req_list */
         struct wa_xfer *xfer;           /* out xfer */
         u8 index;                       /* which segment we are */
+        int isoc_frame_count;   /* number of isoc frames in this segment. */
+        int isoc_frame_offset;  /* starting frame offset in the xfer URB. */
+        int isoc_size;  /* size of all isoc frames sent by this seg. */
         enum wa_seg_status status;
         ssize_t result;                 /* bytes xfered or error */
         struct wa_xfer_hdr xfer_hdr;
-        u8 xfer_extra[];                /* xtra space for xfer_hdr_ctl */
 };
 
 static inline void wa_seg_init(struct wa_seg *seg)
 {
-        usb_init_urb(&seg->urb);
+        usb_init_urb(&seg->tr_urb);
 
         /* set the remaining memory to 0. */
-        memset(((void *)seg) + sizeof(seg->urb), 0,
-                sizeof(*seg) - sizeof(seg->urb));
+        memset(((void *)seg) + sizeof(seg->tr_urb), 0,
+                sizeof(*seg) - sizeof(seg->tr_urb));
 }
 
 /*
@@ -153,12 +158,17 @@ struct wa_xfer {
         unsigned is_dma:1;
         size_t seg_size;
         int result;
+        /* Isoc frame that the current transfer buffer corresponds to. */
+        int dto_isoc_frame_index;
 
         gfp_t gfp;                      /* allocation mask */
 
         struct wusb_dev *wusb_dev;      /* for activity timestamps */
 };
 
+static void __wa_populate_dto_urb_isoc(struct wa_xfer *xfer,
+        struct wa_seg *seg, int curr_iso_frame);
+
 static inline void wa_xfer_init(struct wa_xfer *xfer)
 {
         kref_init(&xfer->refcnt);
@@ -169,7 +179,7 @@ static inline void wa_xfer_init(struct wa_xfer *xfer)
 /*
  * Destroy a transfer structure
  *
- * Note that freeing xfer->seg[cnt]->urb will free the containing
+ * Note that freeing xfer->seg[cnt]->tr_urb will free the containing
  * xfer->seg[cnt] memory that was allocated by __wa_xfer_setup_segs.
  */
 static void wa_xfer_destroy(struct kref *_xfer)
@@ -178,9 +188,17 @@ static void wa_xfer_destroy(struct kref *_xfer)
         if (xfer->seg) {
                 unsigned cnt;
                 for (cnt = 0; cnt < xfer->segs; cnt++) {
-                        usb_free_urb(xfer->seg[cnt]->dto_urb);
-                        usb_free_urb(&xfer->seg[cnt]->urb);
+                        struct wa_seg *seg = xfer->seg[cnt];
+                        if (seg) {
+                                usb_free_urb(seg->isoc_pack_desc_urb);
+                                if (seg->dto_urb) {
+                                        kfree(seg->dto_urb->sg);
+                                        usb_free_urb(seg->dto_urb);
+                                }
+                                usb_free_urb(&seg->tr_urb);
+                        }
                 }
+                kfree(xfer->seg);
         }
         kfree(xfer);
 }
@@ -196,6 +214,59 @@ static void wa_xfer_put(struct wa_xfer *xfer)
 }
 
 /*
+ * Try to get exclusive access to the DTO endpoint resource.  Return true
+ * if successful.
+ */
+static inline int __wa_dto_try_get(struct wahc *wa)
+{
+        return (test_and_set_bit(0, &wa->dto_in_use) == 0);
+}
+
+/* Release the DTO endpoint resource. */
+static inline void __wa_dto_put(struct wahc *wa)
+{
+        clear_bit_unlock(0, &wa->dto_in_use);
+}
+
+/* Service RPIPEs that are waiting on the DTO resource. */
+static void wa_check_for_delayed_rpipes(struct wahc *wa)
+{
+        unsigned long flags;
+        int dto_waiting = 0;
+        struct wa_rpipe *rpipe;
+
+        spin_lock_irqsave(&wa->rpipe_lock, flags);
+        while (!list_empty(&wa->rpipe_delayed_list) && !dto_waiting) {
+                rpipe = list_first_entry(&wa->rpipe_delayed_list,
+                                struct wa_rpipe, list_node);
+                __wa_xfer_delayed_run(rpipe, &dto_waiting);
+                /* remove this RPIPE from the list if it is not waiting. */
+                if (!dto_waiting) {
+                        pr_debug("%s: RPIPE %d serviced and removed from delayed list.\n",
+                                __func__,
+                                le16_to_cpu(rpipe->descr.wRPipeIndex));
+                        list_del_init(&rpipe->list_node);
+                }
+        }
+        spin_unlock_irqrestore(&wa->rpipe_lock, flags);
+}
+
+/* add this RPIPE to the end of the delayed RPIPE list. */
+static void wa_add_delayed_rpipe(struct wahc *wa, struct wa_rpipe *rpipe)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&wa->rpipe_lock, flags);
+        /* add rpipe to the list if it is not already on it. */
+        if (list_empty(&rpipe->list_node)) {
+                pr_debug("%s: adding RPIPE %d to the delayed list.\n",
+                        __func__, le16_to_cpu(rpipe->descr.wRPipeIndex));
+                list_add_tail(&rpipe->list_node, &wa->rpipe_delayed_list);
+        }
+        spin_unlock_irqrestore(&wa->rpipe_lock, flags);
+}
+
+/*
  * xfer is referenced
  *
  * xfer->lock has to be unlocked
@@ -232,6 +303,31 @@ static void wa_xfer_completion(struct wa_xfer *xfer)
 }
 
 /*
+ * Initialize a transfer's ID
+ *
+ * We need to use a sequential number; if we use the pointer or the
+ * hash of the pointer, it can repeat over sequential transfers and
+ * then it will confuse the HWA....wonder why in hell they put a 32
+ * bit handle in there then.
+ */
+static void wa_xfer_id_init(struct wa_xfer *xfer)
+{
+        xfer->id = atomic_add_return(1, &xfer->wa->xfer_id_count);
+}
+
+/* Return the xfer's ID. */
+static inline u32 wa_xfer_id(struct wa_xfer *xfer)
+{
+        return xfer->id;
+}
+
+/* Return the xfer's ID in transport format (little endian). */
+static inline __le32 wa_xfer_id_le32(struct wa_xfer *xfer)
+{
+        return cpu_to_le32(xfer->id);
+}
+
+/*
  * If transfer is done, wrap it up and return true
  *
  * xfer->lock has to be locked
@@ -253,33 +349,37 @@ static unsigned __wa_xfer_is_done(struct wa_xfer *xfer)
                 switch (seg->status) {
                 case WA_SEG_DONE:
                         if (found_short && seg->result > 0) {
-                                dev_dbg(dev, "xfer %p#%u: bad short segments (%zu)\n",
-                                        xfer, cnt, seg->result);
+                                dev_dbg(dev, "xfer %p ID %08X#%u: bad short segments (%zu)\n",
+                                        xfer, wa_xfer_id(xfer), cnt,
+                                        seg->result);
                                 urb->status = -EINVAL;
                                 goto out;
                         }
                         urb->actual_length += seg->result;
-                        if (seg->result < xfer->seg_size
+                        if (!(usb_pipeisoc(xfer->urb->pipe))
+                                && seg->result < xfer->seg_size
                             && cnt != xfer->segs-1)
                                 found_short = 1;
-                        dev_dbg(dev, "xfer %p#%u: DONE short %d "
+                        dev_dbg(dev, "xfer %p ID %08X#%u: DONE short %d "
                                 "result %zu urb->actual_length %d\n",
-                                xfer, seg->index, found_short, seg->result,
-                                urb->actual_length);
+                                xfer, wa_xfer_id(xfer), seg->index, found_short,
+                                seg->result, urb->actual_length);
                         break;
                 case WA_SEG_ERROR:
                         xfer->result = seg->result;
-                        dev_dbg(dev, "xfer %p#%u: ERROR result %zu\n",
-                                xfer, seg->index, seg->result);
+                        dev_dbg(dev, "xfer %p ID %08X#%u: ERROR result %zu(0x%08zX)\n",
+                                xfer, wa_xfer_id(xfer), seg->index, seg->result,
+                                seg->result);
                         goto out;
                 case WA_SEG_ABORTED:
-                        dev_dbg(dev, "xfer %p#%u ABORTED: result %d\n",
-                                xfer, seg->index, urb->status);
+                        dev_dbg(dev, "xfer %p ID %08X#%u ABORTED: result %d\n",
+                                xfer, wa_xfer_id(xfer), seg->index,
+                                urb->status);
                         xfer->result = urb->status;
                         goto out;
                 default:
-                        dev_warn(dev, "xfer %p#%u: is_done bad state %d\n",
-                                 xfer, cnt, seg->status);
+                        dev_warn(dev, "xfer %p ID %08X#%u: is_done bad state %d\n",
+                                 xfer, wa_xfer_id(xfer), cnt, seg->status);
                         xfer->result = -EINVAL;
                         goto out;
                 }
@@ -290,29 +390,6 @@ out:
 }
 
 /*
- * Initialize a transfer's ID
- *
- * We need to use a sequential number; if we use the pointer or the
- * hash of the pointer, it can repeat over sequential transfers and
- * then it will confuse the HWA....wonder why in hell they put a 32
- * bit handle in there then.
- */
-static void wa_xfer_id_init(struct wa_xfer *xfer)
-{
-        xfer->id = atomic_add_return(1, &xfer->wa->xfer_id_count);
-}
-
-/*
- * Return the xfer's ID associated with xfer
- *
- * Need to generate a
- */
-static u32 wa_xfer_id(struct wa_xfer *xfer)
-{
-        return xfer->id;
-}
-
-/*
  * Search for a transfer list ID on the HCD's URB list
  *
  * For 32 bit architectures, we use the pointer itself; for 64 bits, a
@@ -356,15 +433,11 @@ static void __wa_xfer_abort_cb(struct urb *urb)
  *
  * The callback (see above) does nothing but freeing up the data by
  * putting the URB. Because the URB is allocated at the head of the
- * struct, the whole space we allocated is kfreed.
- *
- * We'll get an 'aborted transaction' xfer result on DTI, that'll
- * politely ignore because at this point the transaction has been
- * marked as aborted already.
+ * struct, the whole space we allocated is kfreed. *
  */
-static void __wa_xfer_abort(struct wa_xfer *xfer)
+static int __wa_xfer_abort(struct wa_xfer *xfer)
 {
-        int result;
+        int result = -ENOMEM;
         struct device *dev = &xfer->wa->usb_iface->dev;
         struct wa_xfer_abort_buffer *b;
         struct wa_rpipe *rpipe = xfer->ep->hcpriv;
@@ -375,7 +448,7 @@ static void __wa_xfer_abort(struct wa_xfer *xfer)
         b->cmd.bLength =  sizeof(b->cmd);
         b->cmd.bRequestType = WA_XFER_ABORT;
         b->cmd.wRPipe = rpipe->descr.wRPipeIndex;
-        b->cmd.dwTransferID = wa_xfer_id(xfer);
+        b->cmd.dwTransferID = wa_xfer_id_le32(xfer);
 
         usb_init_urb(&b->urb);
         usb_fill_bulk_urb(&b->urb, xfer->wa->usb_dev,
@@ -385,7 +458,7 @@ static void __wa_xfer_abort(struct wa_xfer *xfer)
         result = usb_submit_urb(&b->urb, GFP_ATOMIC);
         if (result < 0)
                 goto error_submit;
-        return;                         /* callback frees! */
+        return result;                          /* callback frees! */
 
 
 error_submit:
@@ -394,11 +467,52 @@ error_submit:
                         xfer, result);
         kfree(b);
 error_kmalloc:
-        return;
+        return result;
 
 }
 
 /*
+ * Calculate the number of isoc frames starting from isoc_frame_offset
+ * that will fit a in transfer segment.
+ */
+static int __wa_seg_calculate_isoc_frame_count(struct wa_xfer *xfer,
+        int isoc_frame_offset, int *total_size)
+{
+        int segment_size = 0, frame_count = 0;
+        int index = isoc_frame_offset;
+        struct usb_iso_packet_descriptor *iso_frame_desc =
+                xfer->urb->iso_frame_desc;
+
+        while ((index < xfer->urb->number_of_packets)
+                && ((segment_size + iso_frame_desc[index].length)
+                                <= xfer->seg_size)) {
+                /*
+                 * For Alereon HWA devices, only include an isoc frame in a
+                 * segment if it is physically contiguous with the previous
+                 * frame.  This is required because those devices expect
+                 * the isoc frames to be sent as a single USB transaction as
+                 * opposed to one transaction per frame with standard HWA.
+                 */
+                if ((xfer->wa->quirks & WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC)
+                        && (index > isoc_frame_offset)
+                        && ((iso_frame_desc[index - 1].offset +
+                                iso_frame_desc[index - 1].length) !=
+                                iso_frame_desc[index].offset))
+                        break;
+
+                /* this frame fits. count it. */
+                ++frame_count;
+                segment_size += iso_frame_desc[index].length;
+
+                /* move to the next isoc frame. */
+                ++index;
+        }
+
+        *total_size = segment_size;
+        return frame_count;
+}
+
+/*
  *
  * @returns < 0 on error, transfer segment request size if ok
  */
@@ -422,43 +536,92 @@ static ssize_t __wa_xfer_setup_sizes(struct wa_xfer *xfer,
                 result = sizeof(struct wa_xfer_bi);
                 break;
         case USB_ENDPOINT_XFER_ISOC:
-                dev_err(dev, "FIXME: ISOC not implemented\n");
-                result = -ENOSYS;
-                goto error;
+                if (usb_pipeout(urb->pipe)) {
+                        *pxfer_type = WA_XFER_TYPE_ISO;
+                        result = sizeof(struct wa_xfer_hwaiso);
+                } else {
+                        dev_err(dev, "FIXME: ISOC IN not implemented\n");
+                        result = -ENOSYS;
+                        goto error;
+                }
+                break;
         default:
                 /* never happens */
                 BUG();
                 result = -EINVAL;       /* shut gcc up */
-        };
+        }
         xfer->is_inbound = urb->pipe & USB_DIR_IN ? 1 : 0;
         xfer->is_dma = urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP ? 1 : 0;
-        xfer->seg_size = le16_to_cpu(rpipe->descr.wBlocks)
-                * 1 << (xfer->wa->wa_descr->bRPipeBlockSize - 1);
-        /* Compute the segment size and make sure it is a multiple of
-         * the maxpktsize (WUSB1.0[8.3.3.1])...not really too much of
-         * a check (FIXME) */
+
         maxpktsize = le16_to_cpu(rpipe->descr.wMaxPacketSize);
-        if (xfer->seg_size < maxpktsize) {
-                dev_err(dev, "HW BUG? seg_size %zu smaller than maxpktsize "
-                        "%zu\n", xfer->seg_size, maxpktsize);
-                result = -EINVAL;
-                goto error;
+        if ((rpipe->descr.bmAttribute & 0x3) == USB_ENDPOINT_XFER_ISOC) {
+                int index = 0;
+
+                xfer->seg_size = maxpktsize;
+                xfer->segs = 0;
+                /*
+                 * loop over urb->number_of_packets to determine how many
+                 * xfer segments will be needed to send the isoc frames.
+                 */
+                while (index < urb->number_of_packets) {
+                        int seg_size; /* don't care. */
+                        index += __wa_seg_calculate_isoc_frame_count(xfer,
+                                        index, &seg_size);
+                        ++xfer->segs;
+                }
+        } else {
+                xfer->seg_size = le16_to_cpu(rpipe->descr.wBlocks)
+                        * 1 << (xfer->wa->wa_descr->bRPipeBlockSize - 1);
+                /* Compute the segment size and make sure it is a multiple of
+                 * the maxpktsize (WUSB1.0[8.3.3.1])...not really too much of
+                 * a check (FIXME) */
+                if (xfer->seg_size < maxpktsize) {
+                        dev_err(dev,
+                                "HW BUG? seg_size %zu smaller than maxpktsize %zu\n",
+                                xfer->seg_size, maxpktsize);
+                        result = -EINVAL;
+                        goto error;
+                }
+                xfer->seg_size = (xfer->seg_size / maxpktsize) * maxpktsize;
+                xfer->segs = DIV_ROUND_UP(urb->transfer_buffer_length,
+                                                xfer->seg_size);
+                if (xfer->segs == 0 && *pxfer_type == WA_XFER_TYPE_CTL)
+                        xfer->segs = 1;
         }
-        xfer->seg_size = (xfer->seg_size / maxpktsize) * maxpktsize;
-        xfer->segs = DIV_ROUND_UP(urb->transfer_buffer_length, xfer->seg_size);
-        if (xfer->segs >= WA_SEGS_MAX) {
-                dev_err(dev, "BUG? ops, number of segments %d bigger than %d\n",
-                        (int)(urb->transfer_buffer_length / xfer->seg_size),
+
+        if (xfer->segs > WA_SEGS_MAX) {
+                dev_err(dev, "BUG? oops, number of segments %zu bigger than %d\n",
+                        (urb->transfer_buffer_length/xfer->seg_size),
                         WA_SEGS_MAX);
                 result = -EINVAL;
                 goto error;
         }
-        if (xfer->segs == 0 && *pxfer_type == WA_XFER_TYPE_CTL)
-                xfer->segs = 1;
 error:
         return result;
 }
 
+static void __wa_setup_isoc_packet_descr(
+                struct wa_xfer_packet_info_hwaiso *packet_desc,
+                struct wa_xfer *xfer,
+                struct wa_seg *seg) {
+        struct usb_iso_packet_descriptor *iso_frame_desc =
+                xfer->urb->iso_frame_desc;
+        int frame_index;
+
+        /* populate isoc packet descriptor. */
+        packet_desc->bPacketType = WA_XFER_ISO_PACKET_INFO;
+        packet_desc->wLength = cpu_to_le16(sizeof(*packet_desc) +
+                (sizeof(packet_desc->PacketLength[0]) *
+                        seg->isoc_frame_count));
+        for (frame_index = 0; frame_index < seg->isoc_frame_count;
+                ++frame_index) {
+                int offset_index = frame_index + seg->isoc_frame_offset;
+                packet_desc->PacketLength[frame_index] =
+                        cpu_to_le16(iso_frame_desc[offset_index].length);
+        }
+}
+
+
 /* Fill in the common request header and xfer-type specific data. */
 static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
                                  struct wa_xfer_hdr *xfer_hdr0,
@@ -466,12 +629,13 @@ static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
                                  size_t xfer_hdr_size)
 {
         struct wa_rpipe *rpipe = xfer->ep->hcpriv;
+        struct wa_seg *seg = xfer->seg[0];
 
-        xfer_hdr0 = &xfer->seg[0]->xfer_hdr;
+        xfer_hdr0 = &seg->xfer_hdr;
         xfer_hdr0->bLength = xfer_hdr_size;
         xfer_hdr0->bRequestType = xfer_type;
         xfer_hdr0->wRPipe = rpipe->descr.wRPipeIndex;
-        xfer_hdr0->dwTransferID = wa_xfer_id(xfer);
+        xfer_hdr0->dwTransferID = wa_xfer_id_le32(xfer);
         xfer_hdr0->bTransferSegment = 0;
         switch (xfer_type) {
         case WA_XFER_TYPE_CTL: {
@@ -484,8 +648,18 @@ static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
         }
         case WA_XFER_TYPE_BI:
                 break;
-        case WA_XFER_TYPE_ISO:
-                printk(KERN_ERR "FIXME: ISOC not implemented\n");
+        case WA_XFER_TYPE_ISO: {
+                struct wa_xfer_hwaiso *xfer_iso =
+                        container_of(xfer_hdr0, struct wa_xfer_hwaiso, hdr);
+                struct wa_xfer_packet_info_hwaiso *packet_desc =
+                        ((void *)xfer_iso) + xfer_hdr_size;
+
+                /* populate the isoc section of the transfer request. */
+                xfer_iso->dwNumOfPackets = cpu_to_le32(seg->isoc_frame_count);
+                /* populate isoc packet descriptor. */
+                __wa_setup_isoc_packet_descr(packet_desc, xfer, seg);
+                break;
+        }
         default:
                 BUG();
         };
@@ -494,12 +668,12 @@ static void __wa_xfer_setup_hdr0(struct wa_xfer *xfer,
 /*
  * Callback for the OUT data phase of the segment request
  *
- * Check wa_seg_cb(); most comments also apply here because this
+ * Check wa_seg_tr_cb(); most comments also apply here because this
  * function does almost the same thing and they work closely
  * together.
  *
  * If the seg request has failed but this DTO phase has succeeded,
- * wa_seg_cb() has already failed the segment and moved the
+ * wa_seg_tr_cb() has already failed the segment and moved the
  * status to WA_SEG_ERROR, so this will go through 'case 0' and
  * effectively do nothing.
  */
@@ -512,6 +686,139 @@ static void wa_seg_dto_cb(struct urb *urb)
         struct wa_rpipe *rpipe;
         unsigned long flags;
         unsigned rpipe_ready = 0;
+        int data_send_done = 1, release_dto = 0, holding_dto = 0;
+        u8 done = 0;
+        int result;
+
+        /* free the sg if it was used. */
+        kfree(urb->sg);
+        urb->sg = NULL;
+
+        spin_lock_irqsave(&xfer->lock, flags);
+        wa = xfer->wa;
+        dev = &wa->usb_iface->dev;
+        if (usb_pipeisoc(xfer->urb->pipe)) {
+                /* Alereon HWA sends all isoc frames in a single transfer. */
+                if (wa->quirks & WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC)
+                        xfer->dto_isoc_frame_index += seg->isoc_frame_count;
+                else
+                        xfer->dto_isoc_frame_index += 1;
+                if (xfer->dto_isoc_frame_index < seg->isoc_frame_count) {
+                        data_send_done = 0;
+                        holding_dto = 1; /* checked in error cases. */
+                        /*
+                         * if this is the last isoc frame of the segment, we
+                         * can release DTO after sending this frame.
+                         */
+                        if ((xfer->dto_isoc_frame_index + 1) >=
+                                seg->isoc_frame_count)
+                                release_dto = 1;
+                }
+                dev_dbg(dev, "xfer 0x%08X#%u: isoc frame = %d, holding_dto = %d, release_dto = %d.\n",
+                        wa_xfer_id(xfer), seg->index,
+                        xfer->dto_isoc_frame_index, holding_dto, release_dto);
+        }
+        spin_unlock_irqrestore(&xfer->lock, flags);
+
+        switch (urb->status) {
+        case 0:
+                spin_lock_irqsave(&xfer->lock, flags);
+                seg->result += urb->actual_length;
+                if (data_send_done) {
+                        dev_dbg(dev, "xfer 0x%08X#%u: data out done (%zu bytes)\n",
+                                wa_xfer_id(xfer), seg->index, seg->result);
+                        if (seg->status < WA_SEG_PENDING)
+                                seg->status = WA_SEG_PENDING;
+                } else {
+                        /* should only hit this for isoc xfers. */
+                        /*
+                         * Populate the dto URB with the next isoc frame buffer,
+                         * send the URB and release DTO if we no longer need it.
+                         */
+                         __wa_populate_dto_urb_isoc(xfer, seg,
+                                seg->isoc_frame_offset +
+                                xfer->dto_isoc_frame_index);
+
+                        /* resubmit the URB with the next isoc frame. */
+                        result = usb_submit_urb(seg->dto_urb, GFP_ATOMIC);
+                        if (result < 0) {
+                                dev_err(dev, "xfer 0x%08X#%u: DTO submit failed: %d\n",
+                                       wa_xfer_id(xfer), seg->index, result);
+                                spin_unlock_irqrestore(&xfer->lock, flags);
+                                goto error_dto_submit;
+                        }
+                }
+                spin_unlock_irqrestore(&xfer->lock, flags);
+                if (release_dto) {
+                        __wa_dto_put(wa);
+                        wa_check_for_delayed_rpipes(wa);
+                }
+                break;
+        case -ECONNRESET:       /* URB unlinked; no need to do anything */
+        case -ENOENT:           /* as it was done by the who unlinked us */
+                if (holding_dto) {
+                        __wa_dto_put(wa);
+                        wa_check_for_delayed_rpipes(wa);
+                }
+                break;
+        default:                /* Other errors ... */
+                dev_err(dev, "xfer 0x%08X#%u: data out error %d\n",
+                        wa_xfer_id(xfer), seg->index, urb->status);
+                goto error_default;
+        }
+
+        return;
+
+error_dto_submit:
+error_default:
+        spin_lock_irqsave(&xfer->lock, flags);
+        rpipe = xfer->ep->hcpriv;
+        if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
+                    EDC_ERROR_TIMEFRAME)){
+                dev_err(dev, "DTO: URB max acceptable errors exceeded, resetting device\n");
+                wa_reset_all(wa);
+        }
+        if (seg->status != WA_SEG_ERROR) {
+                seg->status = WA_SEG_ERROR;
+                seg->result = urb->status;
+                xfer->segs_done++;
+                __wa_xfer_abort(xfer);
+                rpipe_ready = rpipe_avail_inc(rpipe);
+                done = __wa_xfer_is_done(xfer);
+        }
+        spin_unlock_irqrestore(&xfer->lock, flags);
+        if (holding_dto) {
+                __wa_dto_put(wa);
+                wa_check_for_delayed_rpipes(wa);
+        }
+        if (done)
+                wa_xfer_completion(xfer);
+        if (rpipe_ready)
+                wa_xfer_delayed_run(rpipe);
+
+}
+
+/*
+ * Callback for the isoc packet descriptor phase of the segment request
+ *
+ * Check wa_seg_tr_cb(); most comments also apply here because this
+ * function does almost the same thing and they work closely
+ * together.
+ *
+ * If the seg request has failed but this phase has succeeded,
+ * wa_seg_tr_cb() has already failed the segment and moved the
+ * status to WA_SEG_ERROR, so this will go through 'case 0' and
+ * effectively do nothing.
+ */
+static void wa_seg_iso_pack_desc_cb(struct urb *urb)
+{
+        struct wa_seg *seg = urb->context;
+        struct wa_xfer *xfer = seg->xfer;
+        struct wahc *wa;
+        struct device *dev;
+        struct wa_rpipe *rpipe;
+        unsigned long flags;
+        unsigned rpipe_ready = 0;
         u8 done = 0;
 
         switch (urb->status) {
@@ -519,11 +826,10 @@ static void wa_seg_dto_cb(struct urb *urb)
                 spin_lock_irqsave(&xfer->lock, flags);
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
-                dev_dbg(dev, "xfer %p#%u: data out done (%d bytes)\n",
-                        xfer, seg->index, urb->actual_length);
-                if (seg->status < WA_SEG_PENDING)
+                dev_dbg(dev, "iso xfer %08X#%u: packet descriptor done\n",
+                        wa_xfer_id(xfer), seg->index);
+                if (xfer->is_inbound && seg->status < WA_SEG_PENDING)
                         seg->status = WA_SEG_PENDING;
-                seg->result = urb->actual_length;
                 spin_unlock_irqrestore(&xfer->lock, flags);
                 break;
         case -ECONNRESET:       /* URB unlinked; no need to do anything */
@@ -534,15 +840,15 @@ static void wa_seg_dto_cb(struct urb *urb)
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
                 rpipe = xfer->ep->hcpriv;
-                dev_dbg(dev, "xfer %p#%u: data out error %d\n",
-                        xfer, seg->index, urb->status);
+                pr_err_ratelimited("iso xfer %08X#%u: packet descriptor error %d\n",
+                                wa_xfer_id(xfer), seg->index, urb->status);
                 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
                             EDC_ERROR_TIMEFRAME)){
-                        dev_err(dev, "DTO: URB max acceptable errors "
-                                "exceeded, resetting device\n");
+                        dev_err(dev, "DTO: URB max acceptable errors exceeded, resetting device\n");
                         wa_reset_all(wa);
                 }
                 if (seg->status != WA_SEG_ERROR) {
+                        usb_unlink_urb(seg->dto_urb);
                         seg->status = WA_SEG_ERROR;
                         seg->result = urb->status;
                         xfer->segs_done++;
@@ -572,11 +878,11 @@ static void wa_seg_dto_cb(struct urb *urb)
  * We have to check before setting the status to WA_SEG_PENDING
  * because sometimes the xfer result callback arrives before this
  * callback (geeeeeeze), so it might happen that we are already in
- * another state. As well, we don't set it if the transfer is inbound,
+ * another state. As well, we don't set it if the transfer is not inbound,
  * as in that case, wa_seg_dto_cb will do it when the OUT data phase
  * finishes.
  */
-static void wa_seg_cb(struct urb *urb)
+static void wa_seg_tr_cb(struct urb *urb)
 {
         struct wa_seg *seg = urb->context;
         struct wa_xfer *xfer = seg->xfer;
@@ -592,8 +898,11 @@ static void wa_seg_cb(struct urb *urb)
                 spin_lock_irqsave(&xfer->lock, flags);
                 wa = xfer->wa;
                 dev = &wa->usb_iface->dev;
-                dev_dbg(dev, "xfer %p#%u: request done\n", xfer, seg->index);
-                if (xfer->is_inbound && seg->status < WA_SEG_PENDING)
+                dev_dbg(dev, "xfer %p ID 0x%08X#%u: request done\n",
+                        xfer, wa_xfer_id(xfer), seg->index);
+                if (xfer->is_inbound &&
+                        seg->status < WA_SEG_PENDING &&
+                        !(usb_pipeisoc(xfer->urb->pipe)))
                         seg->status = WA_SEG_PENDING;
                 spin_unlock_irqrestore(&xfer->lock, flags);
                 break;
@@ -606,14 +915,16 @@ static void wa_seg_cb(struct urb *urb)
                 dev = &wa->usb_iface->dev;
                 rpipe = xfer->ep->hcpriv;
                 if (printk_ratelimit())
-                        dev_err(dev, "xfer %p#%u: request error %d\n",
-                                xfer, seg->index, urb->status);
+                        dev_err(dev, "xfer %p ID 0x%08X#%u: request error %d\n",
+                                xfer, wa_xfer_id(xfer), seg->index,
+                                urb->status);
                 if (edc_inc(&wa->nep_edc, EDC_MAX_ERRORS,
                             EDC_ERROR_TIMEFRAME)){
                         dev_err(dev, "DTO: URB max acceptable errors "
                                 "exceeded, resetting device\n");
                         wa_reset_all(wa);
                 }
+                usb_unlink_urb(seg->isoc_pack_desc_urb);
                 usb_unlink_urb(seg->dto_urb);
                 seg->status = WA_SEG_ERROR;
                 seg->result = urb->status;
@@ -629,9 +940,11 @@ static void wa_seg_cb(struct urb *urb)
         }
 }
 
-/* allocate an SG list to store bytes_to_transfer bytes and copy the
+/*
+ * Allocate an SG list to store bytes_to_transfer bytes and copy the
  * subset of the in_sg that matches the buffer subset
- * we are about to transfer. */
+ * we are about to transfer.
+ */
 static struct scatterlist *wa_xfer_create_subset_sg(struct scatterlist *in_sg,
         const unsigned int bytes_transferred,
         const unsigned int bytes_to_transfer, unsigned int *out_num_sgs)
@@ -710,6 +1023,75 @@ static struct scatterlist *wa_xfer_create_subset_sg(struct scatterlist *in_sg,
 }
 
 /*
+ * Populate DMA buffer info for the isoc dto urb.
+ */
+static void __wa_populate_dto_urb_isoc(struct wa_xfer *xfer,
+        struct wa_seg *seg, int curr_iso_frame)
+{
+        seg->dto_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        seg->dto_urb->sg = NULL;
+        seg->dto_urb->num_sgs = 0;
+        /* dto urb buffer address pulled from iso_frame_desc. */
+        seg->dto_urb->transfer_dma = xfer->urb->transfer_dma +
+                xfer->urb->iso_frame_desc[curr_iso_frame].offset;
+        /* The Alereon HWA sends a single URB with all isoc segs. */
+        if (xfer->wa->quirks & WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC)
+                seg->dto_urb->transfer_buffer_length = seg->isoc_size;
+        else
+                seg->dto_urb->transfer_buffer_length =
+                        xfer->urb->iso_frame_desc[curr_iso_frame].length;
+}
+
+/*
+ * Populate buffer ptr and size, DMA buffer or SG list for the dto urb.
+ */
+static int __wa_populate_dto_urb(struct wa_xfer *xfer,
+        struct wa_seg *seg, size_t buf_itr_offset, size_t buf_itr_size)
+{
+        int result = 0;
+
+        if (xfer->is_dma) {
+                seg->dto_urb->transfer_dma =
+                        xfer->urb->transfer_dma + buf_itr_offset;
+                seg->dto_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+                seg->dto_urb->sg = NULL;
+                seg->dto_urb->num_sgs = 0;
+        } else {
+                /* do buffer or SG processing. */
+                seg->dto_urb->transfer_flags &=
+                        ~URB_NO_TRANSFER_DMA_MAP;
+                /* this should always be 0 before a resubmit. */
+                seg->dto_urb->num_mapped_sgs = 0;
+
+                if (xfer->urb->transfer_buffer) {
+                        seg->dto_urb->transfer_buffer =
+                                xfer->urb->transfer_buffer +
+                                buf_itr_offset;
+                        seg->dto_urb->sg = NULL;
+                        seg->dto_urb->num_sgs = 0;
+                } else {
+                        seg->dto_urb->transfer_buffer = NULL;
+
+                        /*
+                         * allocate an SG list to store seg_size bytes
+                         * and copy the subset of the xfer->urb->sg that
+                         * matches the buffer subset we are about to
+                         * read.
+                         */
+                        seg->dto_urb->sg = wa_xfer_create_subset_sg(
+                                xfer->urb->sg,
+                                buf_itr_offset, buf_itr_size,
+                                &(seg->dto_urb->num_sgs));
+                        if (!(seg->dto_urb->sg))
+                                result = -ENOMEM;
+                }
+        }
+        seg->dto_urb->transfer_buffer_length = buf_itr_size;
+
+        return result;
+}
+
+/*
  * Allocate the segs array and initialize each of them
  *
  * The segments are freed by wa_xfer_destroy() when the xfer use count
@@ -719,13 +1101,14 @@ static struct scatterlist *wa_xfer_create_subset_sg(struct scatterlist *in_sg,
  */
 static int __wa_xfer_setup_segs(struct wa_xfer *xfer, size_t xfer_hdr_size)
 {
-        int result, cnt;
+        int result, cnt, iso_frame_offset;
         size_t alloc_size = sizeof(*xfer->seg[0])
                 - sizeof(xfer->seg[0]->xfer_hdr) + xfer_hdr_size;
         struct usb_device *usb_dev = xfer->wa->usb_dev;
         const struct usb_endpoint_descriptor *dto_epd = xfer->wa->dto_epd;
         struct wa_seg *seg;
         size_t buf_itr, buf_size, buf_itr_size;
+        int xfer_isoc_frame_offset = 0;
 
         result = -ENOMEM;
         xfer->seg = kcalloc(xfer->segs, sizeof(xfer->seg[0]), GFP_ATOMIC);
@@ -733,18 +1116,35 @@ static int __wa_xfer_setup_segs(struct wa_xfer *xfer, size_t xfer_hdr_size)
                 goto error_segs_kzalloc;
         buf_itr = 0;
         buf_size = xfer->urb->transfer_buffer_length;
+        iso_frame_offset = 0;
         for (cnt = 0; cnt < xfer->segs; cnt++) {
-                seg = xfer->seg[cnt] = kmalloc(alloc_size, GFP_ATOMIC);
+                size_t iso_pkt_descr_size = 0;
+                int seg_isoc_frame_count = 0, seg_isoc_size = 0;
+
+                if (usb_pipeisoc(xfer->urb->pipe)) {
+                        seg_isoc_frame_count =
+                                __wa_seg_calculate_isoc_frame_count(xfer,
+                                        xfer_isoc_frame_offset, &seg_isoc_size);
+
+                        iso_pkt_descr_size =
+                                sizeof(struct wa_xfer_packet_info_hwaiso) +
+                                (seg_isoc_frame_count * sizeof(__le16));
+                }
+                seg = xfer->seg[cnt] = kmalloc(alloc_size + iso_pkt_descr_size,
+                                                GFP_ATOMIC);
                 if (seg == NULL)
                         goto error_seg_kmalloc;
                 wa_seg_init(seg);
                 seg->xfer = xfer;
                 seg->index = cnt;
-                usb_fill_bulk_urb(&seg->urb, usb_dev,
+                seg->isoc_frame_count = seg_isoc_frame_count;
+                seg->isoc_frame_offset = xfer_isoc_frame_offset;
+                seg->isoc_size = seg_isoc_size;
+                usb_fill_bulk_urb(&seg->tr_urb, usb_dev,
                                   usb_sndbulkpipe(usb_dev,
                                                   dto_epd->bEndpointAddress),
                                   &seg->xfer_hdr, xfer_hdr_size,
-                                  wa_seg_cb, seg);
+                                  wa_seg_tr_cb, seg);
                 buf_itr_size = min(buf_size, xfer->seg_size);
                 if (xfer->is_inbound == 0 && buf_size > 0) {
                         /* outbound data. */
@@ -756,69 +1156,64 @@ static int __wa_xfer_setup_segs(struct wa_xfer *xfer, size_t xfer_hdr_size)
                                 usb_sndbulkpipe(usb_dev,
                                                 dto_epd->bEndpointAddress),
                                 NULL, 0, wa_seg_dto_cb, seg);
-                        if (xfer->is_dma) {
-                                seg->dto_urb->transfer_dma =
-                                        xfer->urb->transfer_dma + buf_itr;
-                                seg->dto_urb->transfer_flags |=
-                                        URB_NO_TRANSFER_DMA_MAP;
-                                seg->dto_urb->transfer_buffer = NULL;
-                                seg->dto_urb->sg = NULL;
-                                seg->dto_urb->num_sgs = 0;
+
+                        if (usb_pipeisoc(xfer->urb->pipe)) {
+                                /* iso packet descriptor. */
+                                seg->isoc_pack_desc_urb =
+                                                usb_alloc_urb(0, GFP_ATOMIC);
+                                if (seg->isoc_pack_desc_urb == NULL)
+                                        goto error_iso_pack_desc_alloc;
+                                /*
+                                 * The buffer for the isoc packet descriptor
+                                 * after the transfer request header in the
+                                 * segment object memory buffer.
+                                 */
+                                usb_fill_bulk_urb(
+                                        seg->isoc_pack_desc_urb, usb_dev,
+                                        usb_sndbulkpipe(usb_dev,
+                                                dto_epd->bEndpointAddress),
+                                        (void *)(&seg->xfer_hdr) +
+                                                xfer_hdr_size,
+                                        iso_pkt_descr_size,
+                                        wa_seg_iso_pack_desc_cb, seg);
+
+                                /*
+                                 * Fill in the xfer buffer information for the
+                                 * first isoc frame.  Subsequent frames in this
+                                 * segment will be filled in and sent from the
+                                 * DTO completion routine, if needed.
+                                 */
+                                __wa_populate_dto_urb_isoc(xfer, seg,
+                                        xfer_isoc_frame_offset);
+                                /* adjust starting frame offset for next seg. */
+                                xfer_isoc_frame_offset += seg_isoc_frame_count;
                         } else {
-                                /* do buffer or SG processing. */
-                                seg->dto_urb->transfer_flags &=
-                                        ~URB_NO_TRANSFER_DMA_MAP;
-                                /* this should always be 0 before a resubmit. */
-                                seg->dto_urb->num_mapped_sgs = 0;
-
-                                if (xfer->urb->transfer_buffer) {
-                                        seg->dto_urb->transfer_buffer =
-                                                xfer->urb->transfer_buffer +
-                                                buf_itr;
-                                        seg->dto_urb->sg = NULL;
-                                        seg->dto_urb->num_sgs = 0;
-                                } else {
-                                        /* allocate an SG list to store seg_size
-                                            bytes and copy the subset of the
-                                            xfer->urb->sg that matches the
-                                            buffer subset we are about to read.
-                                        */
-                                        seg->dto_urb->sg =
-                                                wa_xfer_create_subset_sg(
-                                                xfer->urb->sg,
-                                                buf_itr, buf_itr_size,
-                                                &(seg->dto_urb->num_sgs));
-
-                                        if (!(seg->dto_urb->sg)) {
-                                                seg->dto_urb->num_sgs   = 0;
-                                                goto error_sg_alloc;
-                                        }
-
-                                        seg->dto_urb->transfer_buffer = NULL;
-                                }
+                                /* fill in the xfer buffer information. */
+                                result = __wa_populate_dto_urb(xfer, seg,
+                                                        buf_itr, buf_itr_size);
+                                if (result < 0)
+                                        goto error_seg_outbound_populate;
+
+                                buf_itr += buf_itr_size;
+                                buf_size -= buf_itr_size;
                         }
-                        seg->dto_urb->transfer_buffer_length = buf_itr_size;
                 }
                 seg->status = WA_SEG_READY;
-                buf_itr += buf_itr_size;
-                buf_size -= buf_itr_size;
         }
         return 0;
 
-error_sg_alloc:
+        /*
+         * Free the memory for the current segment which failed to init.
+         * Use the fact that cnt is left at were it failed.  The remaining
+         * segments will be cleaned up by wa_xfer_destroy.
+         */
+error_iso_pack_desc_alloc:
+error_seg_outbound_populate:
         usb_free_urb(xfer->seg[cnt]->dto_urb);
 error_dto_alloc:
         kfree(xfer->seg[cnt]);
-        cnt--;
+        xfer->seg[cnt] = NULL;
 error_seg_kmalloc:
-        /* use the fact that cnt is left at were it failed */
-        for (; cnt >= 0; cnt--) {
-                if (xfer->seg[cnt] && xfer->is_inbound == 0) {
-                        usb_free_urb(xfer->seg[cnt]->dto_urb);
-                        kfree(xfer->seg[cnt]->dto_urb->sg);
-                }
-                kfree(xfer->seg[cnt]);
-        }
 error_segs_kzalloc:
         return result;
 }
@@ -856,21 +1251,45 @@ static int __wa_xfer_setup(struct wa_xfer *xfer, struct urb *urb)
         wa_xfer_id_init(xfer);
         __wa_xfer_setup_hdr0(xfer, xfer_hdr0, xfer_type, xfer_hdr_size);
 
-        /* Fill remainig headers */
+        /* Fill remaining headers */
         xfer_hdr = xfer_hdr0;
-        transfer_size = urb->transfer_buffer_length;
-        xfer_hdr0->dwTransferLength = transfer_size > xfer->seg_size ?
-                xfer->seg_size : transfer_size;
-        transfer_size -=  xfer->seg_size;
-        for (cnt = 1; cnt < xfer->segs; cnt++) {
-                xfer_hdr = &xfer->seg[cnt]->xfer_hdr;
-                memcpy(xfer_hdr, xfer_hdr0, xfer_hdr_size);
-                xfer_hdr->bTransferSegment = cnt;
-                xfer_hdr->dwTransferLength = transfer_size > xfer->seg_size ?
-                        cpu_to_le32(xfer->seg_size)
-                        : cpu_to_le32(transfer_size);
-                xfer->seg[cnt]->status = WA_SEG_READY;
+        if (xfer_type == WA_XFER_TYPE_ISO) {
+                xfer_hdr0->dwTransferLength =
+                        cpu_to_le32(xfer->seg[0]->isoc_size);
+                for (cnt = 1; cnt < xfer->segs; cnt++) {
+                        struct wa_xfer_packet_info_hwaiso *packet_desc;
+                        struct wa_seg *seg = xfer->seg[cnt];
+
+                        xfer_hdr = &seg->xfer_hdr;
+                        packet_desc = ((void *)xfer_hdr) + xfer_hdr_size;
+                        /*
+                         * Copy values from the 0th header. Segment specific
+                         * values are set below.
+                         */
+                        memcpy(xfer_hdr, xfer_hdr0, xfer_hdr_size);
+                        xfer_hdr->bTransferSegment = cnt;
+                        xfer_hdr->dwTransferLength =
+                                cpu_to_le32(seg->isoc_size);
+                        __wa_setup_isoc_packet_descr(packet_desc, xfer, seg);
+                        seg->status = WA_SEG_READY;
+                }
+        } else {
+                transfer_size = urb->transfer_buffer_length;
+                xfer_hdr0->dwTransferLength = transfer_size > xfer->seg_size ?
+                        cpu_to_le32(xfer->seg_size) :
+                        cpu_to_le32(transfer_size);
                 transfer_size -=  xfer->seg_size;
+                for (cnt = 1; cnt < xfer->segs; cnt++) {
+                        xfer_hdr = &xfer->seg[cnt]->xfer_hdr;
+                        memcpy(xfer_hdr, xfer_hdr0, xfer_hdr_size);
+                        xfer_hdr->bTransferSegment = cnt;
+                        xfer_hdr->dwTransferLength =
+                                transfer_size > xfer->seg_size ?
+                                        cpu_to_le32(xfer->seg_size)
+                                        : cpu_to_le32(transfer_size);
+                        xfer->seg[cnt]->status = WA_SEG_READY;
+                        transfer_size -=  xfer->seg_size;
+                }
         }
         xfer_hdr->bTransferSegment |= 0x80;     /* this is the last segment */
         result = 0;
@@ -885,20 +1304,46 @@ error_setup_sizes:
  * rpipe->seg_lock is held!
  */
 static int __wa_seg_submit(struct wa_rpipe *rpipe, struct wa_xfer *xfer,
-                           struct wa_seg *seg)
+                           struct wa_seg *seg, int *dto_done)
 {
         int result;
-        result = usb_submit_urb(&seg->urb, GFP_ATOMIC);
+
+        /* default to done unless we encounter a multi-frame isoc segment. */
+        *dto_done = 1;
+
+        /* submit the transfer request. */
+        result = usb_submit_urb(&seg->tr_urb, GFP_ATOMIC);
         if (result < 0) {
-                printk(KERN_ERR "xfer %p#%u: REQ submit failed: %d\n",
-                       xfer, seg->index, result);
+                pr_err("%s: xfer %p#%u: REQ submit failed: %d\n",
+                       __func__, xfer, seg->index, result);
                 goto error_seg_submit;
         }
+        /* submit the isoc packet descriptor if present. */
+        if (seg->isoc_pack_desc_urb) {
+                struct wahc *wa = xfer->wa;
+
+                result = usb_submit_urb(seg->isoc_pack_desc_urb, GFP_ATOMIC);
+                if (result < 0) {
+                        pr_err("%s: xfer %p#%u: ISO packet descriptor submit failed: %d\n",
+                               __func__, xfer, seg->index, result);
+                        goto error_iso_pack_desc_submit;
+                }
+                xfer->dto_isoc_frame_index = 0;
+                /*
+                 * If this segment contains more than one isoc frame, hold
+                 * onto the dto resource until we send all frames.
+                 * Only applies to non-Alereon devices.
+                 */
+                if (((wa->quirks & WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC) == 0)
+                        && (seg->isoc_frame_count > 1))
+                        *dto_done = 0;
+        }
+        /* submit the out data if this is an out request. */
         if (seg->dto_urb) {
                 result = usb_submit_urb(seg->dto_urb, GFP_ATOMIC);
                 if (result < 0) {
-                        printk(KERN_ERR "xfer %p#%u: DTO submit failed: %d\n",
-                               xfer, seg->index, result);
+                        pr_err("%s: xfer %p#%u: DTO submit failed: %d\n",
+                               __func__, xfer, seg->index, result);
                         goto error_dto_submit;
                 }
         }
@@ -907,38 +1352,48 @@ static int __wa_seg_submit(struct wa_rpipe *rpipe, struct wa_xfer *xfer,
         return 0;
 
 error_dto_submit:
-        usb_unlink_urb(&seg->urb);
+        usb_unlink_urb(seg->isoc_pack_desc_urb);
+error_iso_pack_desc_submit:
+        usb_unlink_urb(&seg->tr_urb);
 error_seg_submit:
         seg->status = WA_SEG_ERROR;
         seg->result = result;
+        *dto_done = 1;
         return result;
 }
 
 /*
- * Execute more queued request segments until the maximum concurrent allowed
+ * Execute more queued request segments until the maximum concurrent allowed.
+ * Return true if the DTO resource was acquired and released.
  *
  * The ugly unlock/lock sequence on the error path is needed as the
  * xfer->lock normally nests the seg_lock and not viceversa.
- *
  */
-static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
+static int __wa_xfer_delayed_run(struct wa_rpipe *rpipe, int *dto_waiting)
 {
-        int result;
+        int result, dto_acquired = 0, dto_done = 0;
         struct device *dev = &rpipe->wa->usb_iface->dev;
         struct wa_seg *seg;
         struct wa_xfer *xfer;
         unsigned long flags;
 
+        *dto_waiting = 0;
+
         spin_lock_irqsave(&rpipe->seg_lock, flags);
         while (atomic_read(&rpipe->segs_available) > 0
-              && !list_empty(&rpipe->seg_list)) {
+              && !list_empty(&rpipe->seg_list)
+              && (dto_acquired = __wa_dto_try_get(rpipe->wa))) {
                 seg = list_first_entry(&(rpipe->seg_list), struct wa_seg,
                                  list_node);
                 list_del(&seg->list_node);
                 xfer = seg->xfer;
-                result = __wa_seg_submit(rpipe, xfer, seg);
-                dev_dbg(dev, "xfer %p#%u submitted from delayed [%d segments available] %d\n",
-                        xfer, seg->index, atomic_read(&rpipe->segs_available), result);
+                result = __wa_seg_submit(rpipe, xfer, seg, &dto_done);
+                /* release the dto resource if this RPIPE is done with it. */
+                if (dto_done)
+                        __wa_dto_put(rpipe->wa);
+                dev_dbg(dev, "xfer %p ID %08X#%u submitted from delayed [%d segments available] %d\n",
+                        xfer, wa_xfer_id(xfer), seg->index,
+                        atomic_read(&rpipe->segs_available), result);
                 if (unlikely(result < 0)) {
                         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
                         spin_lock_irqsave(&xfer->lock, flags);
@@ -948,7 +1403,37 @@ static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
                         spin_lock_irqsave(&rpipe->seg_lock, flags);
                 }
         }
+        /*
+         * Mark this RPIPE as waiting if dto was not acquired, there are
+         * delayed segs and no active transfers to wake us up later.
+         */
+        if (!dto_acquired && !list_empty(&rpipe->seg_list)
+                && (atomic_read(&rpipe->segs_available) ==
+                        le16_to_cpu(rpipe->descr.wRequests)))
+                *dto_waiting = 1;
+
         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
+
+        return dto_done;
+}
+
+static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
+{
+        int dto_waiting;
+        int dto_done = __wa_xfer_delayed_run(rpipe, &dto_waiting);
+
+        /*
+         * If this RPIPE is waiting on the DTO resource, add it to the tail of
+         * the waiting list.
+         * Otherwise, if the WA DTO resource was acquired and released by
+         *  __wa_xfer_delayed_run, another RPIPE may have attempted to acquire
+         * DTO and failed during that time.  Check the delayed list and process
+         * any waiters.  Start searching from the next RPIPE index.
+         */
+        if (dto_waiting)
+                wa_add_delayed_rpipe(rpipe->wa, rpipe);
+        else if (dto_done)
+                wa_check_for_delayed_rpipes(rpipe->wa);
 }
 
 /*
@@ -960,7 +1445,7 @@ static void wa_xfer_delayed_run(struct wa_rpipe *rpipe)
  */
 static int __wa_xfer_submit(struct wa_xfer *xfer)
 {
-        int result;
+        int result, dto_acquired = 0, dto_done = 0, dto_waiting = 0;
         struct wahc *wa = xfer->wa;
         struct device *dev = &wa->usb_iface->dev;
         unsigned cnt;
@@ -979,27 +1464,58 @@ static int __wa_xfer_submit(struct wa_xfer *xfer)
         result = 0;
         spin_lock_irqsave(&rpipe->seg_lock, flags);
         for (cnt = 0; cnt < xfer->segs; cnt++) {
+                int delay_seg = 1;
+
                 available = atomic_read(&rpipe->segs_available);
                 empty = list_empty(&rpipe->seg_list);
                 seg = xfer->seg[cnt];
-                dev_dbg(dev, "xfer %p#%u: available %u empty %u (%s)\n",
-                        xfer, cnt, available, empty,
-                        available == 0 || !empty ? "delayed" : "submitted");
-                if (available == 0 || !empty) {
-                        dev_dbg(dev, "xfer %p#%u: delayed\n", xfer, cnt);
+                if (available && empty) {
+                        /*
+                         * Only attempt to acquire DTO if we have a segment
+                         * to send.
+                         */
+                        dto_acquired = __wa_dto_try_get(rpipe->wa);
+                        if (dto_acquired) {
+                                delay_seg = 0;
+                                result = __wa_seg_submit(rpipe, xfer, seg,
+                                                        &dto_done);
+                                dev_dbg(dev, "xfer %p ID 0x%08X#%u: available %u empty %u submitted\n",
+                                        xfer, wa_xfer_id(xfer), cnt, available,
+                                        empty);
+                                if (dto_done)
+                                        __wa_dto_put(rpipe->wa);
+
+                                if (result < 0) {
+                                        __wa_xfer_abort(xfer);
+                                        goto error_seg_submit;
+                                }
+                        }
+                }
+
+                if (delay_seg) {
+                        dev_dbg(dev, "xfer %p ID 0x%08X#%u: available %u empty %u delayed\n",
+                                xfer, wa_xfer_id(xfer), cnt, available,  empty);
                         seg->status = WA_SEG_DELAYED;
                         list_add_tail(&seg->list_node, &rpipe->seg_list);
-                } else {
-                        result = __wa_seg_submit(rpipe, xfer, seg);
-                        if (result < 0) {
-                                __wa_xfer_abort(xfer);
-                                goto error_seg_submit;
-                        }
                 }
                 xfer->segs_submitted++;
         }
 error_seg_submit:
+        /*
+         * Mark this RPIPE as waiting if dto was not acquired, there are
+         * delayed segs and no active transfers to wake us up later.
+         */
+        if (!dto_acquired && !list_empty(&rpipe->seg_list)
+                && (atomic_read(&rpipe->segs_available) ==
+                        le16_to_cpu(rpipe->descr.wRequests)))
+                dto_waiting = 1;
         spin_unlock_irqrestore(&rpipe->seg_lock, flags);
+
+        if (dto_waiting)
+                wa_add_delayed_rpipe(rpipe->wa, rpipe);
+        else if (dto_done)
+                wa_check_for_delayed_rpipes(rpipe->wa);
+
         return result;
 }
 
@@ -1025,7 +1541,7 @@ error_seg_submit:
  * result never kicks in, the xfer will timeout from the USB code and
  * dequeue() will be called.
  */
-static void wa_urb_enqueue_b(struct wa_xfer *xfer)
+static int wa_urb_enqueue_b(struct wa_xfer *xfer)
 {
         int result;
         unsigned long flags;
@@ -1036,18 +1552,22 @@ static void wa_urb_enqueue_b(struct wa_xfer *xfer)
         unsigned done;
 
         result = rpipe_get_by_ep(wa, xfer->ep, urb, xfer->gfp);
-        if (result < 0)
+        if (result < 0) {
+                pr_err("%s: error_rpipe_get\n", __func__);
                 goto error_rpipe_get;
+        }
         result = -ENODEV;
         /* FIXME: segmentation broken -- kills DWA */
         mutex_lock(&wusbhc->mutex);             /* get a WUSB dev */
         if (urb->dev == NULL) {
                 mutex_unlock(&wusbhc->mutex);
+                pr_err("%s: error usb dev gone\n", __func__);
                 goto error_dev_gone;
         }
         wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, urb->dev);
         if (wusb_dev == NULL) {
                 mutex_unlock(&wusbhc->mutex);
+                pr_err("%s: error wusb dev gone\n", __func__);
                 goto error_dev_gone;
         }
         mutex_unlock(&wusbhc->mutex);
@@ -1055,21 +1575,28 @@ static void wa_urb_enqueue_b(struct wa_xfer *xfer)
         spin_lock_irqsave(&xfer->lock, flags);
         xfer->wusb_dev = wusb_dev;
         result = urb->status;
-        if (urb->status != -EINPROGRESS)
+        if (urb->status != -EINPROGRESS) {
+                pr_err("%s: error_dequeued\n", __func__);
                 goto error_dequeued;
+        }
 
         result = __wa_xfer_setup(xfer, urb);
-        if (result < 0)
+        if (result < 0) {
+                pr_err("%s: error_xfer_setup\n", __func__);
                 goto error_xfer_setup;
+        }
         result = __wa_xfer_submit(xfer);
-        if (result < 0)
+        if (result < 0) {
+                pr_err("%s: error_xfer_submit\n", __func__);
                 goto error_xfer_submit;
+        }
         spin_unlock_irqrestore(&xfer->lock, flags);
-        return;
+        return 0;
 
-        /* this is basically wa_xfer_completion() broken up wa_xfer_giveback()
-         * does a wa_xfer_put() that will call wa_xfer_destroy() and clean
-         * upundo setup().
+        /*
+         * this is basically wa_xfer_completion() broken up wa_xfer_giveback()
+         * does a wa_xfer_put() that will call wa_xfer_destroy() and undo
+         * setup().
          */
 error_xfer_setup:
 error_dequeued:
@@ -1081,8 +1608,7 @@ error_dev_gone:
         rpipe_put(xfer->ep->hcpriv);
 error_rpipe_get:
         xfer->result = result;
-        wa_xfer_giveback(xfer);
-        return;
+        return result;
 
 error_xfer_submit:
         done = __wa_xfer_is_done(xfer);
@@ -1090,6 +1616,8 @@ error_xfer_submit:
         spin_unlock_irqrestore(&xfer->lock, flags);
         if (done)
                 wa_xfer_completion(xfer);
+        /* return success since the completion routine will run. */
+        return 0;
 }
 
 /*
@@ -1123,7 +1651,8 @@ void wa_urb_enqueue_run(struct work_struct *ws)
                 list_del_init(&xfer->list_node);
 
                 urb = xfer->urb;
-                wa_urb_enqueue_b(xfer);
+                if (wa_urb_enqueue_b(xfer) < 0)
+                        wa_xfer_giveback(xfer);
                 usb_put_urb(urb);       /* taken when queuing */
         }
 }
@@ -1229,7 +1758,19 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
                 spin_unlock_irqrestore(&wa->xfer_list_lock, my_flags);
                 queue_work(wusbd, &wa->xfer_enqueue_work);
         } else {
-                wa_urb_enqueue_b(xfer);
+                result = wa_urb_enqueue_b(xfer);
+                if (result < 0) {
+                        /*
+                         * URB submit/enqueue failed.  Clean up, return an
+                         * error and do not run the callback.  This avoids
+                         * an infinite submit/complete loop.
+                         */
+                        dev_err(dev, "%s: URB enqueue failed: %d\n",
+                           __func__, result);
+                        wa_put(xfer->wa);
+                        wa_xfer_put(xfer);
+                        return result;
+                }
         }
         return 0;
 
@@ -1264,7 +1805,7 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         struct wa_xfer *xfer;
         struct wa_seg *seg;
         struct wa_rpipe *rpipe;
-        unsigned cnt;
+        unsigned cnt, done = 0, xfer_abort_pending;
         unsigned rpipe_ready = 0;
 
         xfer = urb->hcpriv;
@@ -1278,6 +1819,7 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
                 goto out;
         }
         spin_lock_irqsave(&xfer->lock, flags);
+        pr_debug("%s: DEQUEUE xfer id 0x%08X\n", __func__, wa_xfer_id(xfer));
         rpipe = xfer->ep->hcpriv;
         if (rpipe == NULL) {
                 pr_debug("%s: xfer id 0x%08X has no RPIPE.  %s",
@@ -1293,9 +1835,11 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         if (xfer->seg == NULL)          /* still hasn't reached */
                 goto out_unlock;        /* setup(), enqueue_b() completes */
         /* Ok, the xfer is in flight already, it's been setup and submitted.*/
-        __wa_xfer_abort(xfer);
+        xfer_abort_pending = __wa_xfer_abort(xfer) >= 0;
         for (cnt = 0; cnt < xfer->segs; cnt++) {
                 seg = xfer->seg[cnt];
+                pr_debug("%s: xfer id 0x%08X#%d status = %d\n",
+                        __func__, wa_xfer_id(xfer), cnt, seg->status);
                 switch (seg->status) {
                 case WA_SEG_NOTREADY:
                 case WA_SEG_READY:
@@ -1304,42 +1848,50 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
                         WARN_ON(1);
                         break;
                 case WA_SEG_DELAYED:
+                        /*
+                         * delete from rpipe delayed list.  If no segments on
+                         * this xfer have been submitted, __wa_xfer_is_done will
+                         * trigger a giveback below.  Otherwise, the submitted
+                         * segments will be completed in the DTI interrupt.
+                         */
                         seg->status = WA_SEG_ABORTED;
                         spin_lock_irqsave(&rpipe->seg_lock, flags2);
                         list_del(&seg->list_node);
                         xfer->segs_done++;
-                        rpipe_ready = rpipe_avail_inc(rpipe);
                         spin_unlock_irqrestore(&rpipe->seg_lock, flags2);
                         break;
-                case WA_SEG_SUBMITTED:
-                        seg->status = WA_SEG_ABORTED;
-                        usb_unlink_urb(&seg->urb);
-                        if (xfer->is_inbound == 0)
-                                usb_unlink_urb(seg->dto_urb);
-                        xfer->segs_done++;
-                        rpipe_ready = rpipe_avail_inc(rpipe);
-                        break;
-                case WA_SEG_PENDING:
-                        seg->status = WA_SEG_ABORTED;
-                        xfer->segs_done++;
-                        rpipe_ready = rpipe_avail_inc(rpipe);
-                        break;
-                case WA_SEG_DTI_PENDING:
-                        usb_unlink_urb(wa->dti_urb);
-                        seg->status = WA_SEG_ABORTED;
-                        xfer->segs_done++;
-                        rpipe_ready = rpipe_avail_inc(rpipe);
-                        break;
                 case WA_SEG_DONE:
                 case WA_SEG_ERROR:
                 case WA_SEG_ABORTED:
                         break;
+                        /*
+                         * In the states below, the HWA device already knows
+                         * about the transfer.  If an abort request was sent,
+                         * allow the HWA to process it and wait for the
+                         * results.  Otherwise, the DTI state and seg completed
+                         * counts can get out of sync.
+                         */
+                case WA_SEG_SUBMITTED:
+                case WA_SEG_PENDING:
+                case WA_SEG_DTI_PENDING:
+                        /*
+                         * Check if the abort was successfully sent.  This could
+                         * be false if the HWA has been removed but we haven't
+                         * gotten the disconnect notification yet.
+                         */
+                        if (!xfer_abort_pending) {
+                                seg->status = WA_SEG_ABORTED;
+                                rpipe_ready = rpipe_avail_inc(rpipe);
+                                xfer->segs_done++;
+                        }
+                        break;
                 }
         }
         xfer->result = urb->status;     /* -ENOENT or -ECONNRESET */
-        __wa_xfer_is_done(xfer);
+        done = __wa_xfer_is_done(xfer);
         spin_unlock_irqrestore(&xfer->lock, flags);
-        wa_xfer_completion(xfer);
+        if (done)
+                wa_xfer_completion(xfer);
         if (rpipe_ready)
                 wa_xfer_delayed_run(rpipe);
         return 0;
@@ -1410,13 +1962,56 @@ static int wa_xfer_status_to_errno(u8 status)
 }
 
 /*
+ * If a last segment flag and/or a transfer result error is encountered,
+ * no other segment transfer results will be returned from the device.
+ * Mark the remaining submitted or pending xfers as completed so that
+ * the xfer will complete cleanly.
+ */
+static void wa_complete_remaining_xfer_segs(struct wa_xfer *xfer,
+                struct wa_seg *incoming_seg)
+{
+        int index;
+        struct wa_rpipe *rpipe = xfer->ep->hcpriv;
+
+        for (index = incoming_seg->index + 1; index < xfer->segs_submitted;
+                index++) {
+                struct wa_seg *current_seg = xfer->seg[index];
+
+                BUG_ON(current_seg == NULL);
+
+                switch (current_seg->status) {
+                case WA_SEG_SUBMITTED:
+                case WA_SEG_PENDING:
+                case WA_SEG_DTI_PENDING:
+                        rpipe_avail_inc(rpipe);
+                /*
+                 * do not increment RPIPE avail for the WA_SEG_DELAYED case
+                 * since it has not been submitted to the RPIPE.
+                 */
+                case WA_SEG_DELAYED:
+                        xfer->segs_done++;
+                        current_seg->status = incoming_seg->status;
+                        break;
+                case WA_SEG_ABORTED:
+                        break;
+                default:
+                        WARN(1, "%s: xfer 0x%08X#%d. bad seg status = %d\n",
+                                __func__, wa_xfer_id(xfer), index,
+                                current_seg->status);
+                        break;
+                }
+        }
+}
+
+/*
  * Process a xfer result completion message
  *
- * inbound transfers: need to schedule a DTI read
+ * inbound transfers: need to schedule a buf_in_urb read
  *
  * FIXME: this function needs to be broken up in parts
  */
-static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
+static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer,
+                struct wa_xfer_result *xfer_result)
 {
         int result;
         struct device *dev = &wa->usb_iface->dev;
@@ -1424,8 +2019,7 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
         u8 seg_idx;
         struct wa_seg *seg;
         struct wa_rpipe *rpipe;
-        struct wa_xfer_result *xfer_result = wa->xfer_result;
-        u8 done = 0;
+        unsigned done = 0;
         u8 usb_status;
         unsigned rpipe_ready = 0;
 
@@ -1436,8 +2030,8 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
         seg = xfer->seg[seg_idx];
         rpipe = xfer->ep->hcpriv;
         usb_status = xfer_result->bTransferStatus;
-        dev_dbg(dev, "xfer %p#%u: bTransferStatus 0x%02x (seg status %u)\n",
-                xfer, seg_idx, usb_status, seg->status);
+        dev_dbg(dev, "xfer %p ID 0x%08X#%u: bTransferStatus 0x%02x (seg status %u)\n",
+                xfer, wa_xfer_id(xfer), seg_idx, usb_status, seg->status);
         if (seg->status == WA_SEG_ABORTED
             || seg->status == WA_SEG_ERROR)     /* already handled */
                 goto segment_aborted;
@@ -1453,12 +2047,19 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer)
                 seg->result = wa_xfer_status_to_errno(usb_status);
                 dev_err(dev, "DTI: xfer %p#:%08X:%u failed (0x%02x)\n",
                         xfer, xfer->id, seg->index, usb_status);
+                seg->status = ((usb_status & 0x7F) == WA_XFER_STATUS_ABORTED) ?
+                        WA_SEG_ABORTED : WA_SEG_ERROR;
                 goto error_complete;
         }
         /* FIXME: we ignore warnings, tally them for stats */
         if (usb_status & 0x40)          /* Warning?... */
                 usb_status = 0;         /* ... pass */
-        if (xfer->is_inbound) { /* IN data phase: read to buffer */
+        if (usb_pipeisoc(xfer->urb->pipe)) {
+                /* set up WA state to read the isoc packet status next. */
+                wa->dti_isoc_xfer_in_progress = wa_xfer_id(xfer);
+                wa->dti_isoc_xfer_seg = seg_idx;
+                wa->dti_state = WA_DTI_ISOC_PACKET_STATUS_PENDING;
+        } else if (xfer->is_inbound) {  /* IN data phase: read to buffer */
                 seg->status = WA_SEG_DTI_PENDING;
                 BUG_ON(wa->buf_in_urb->status == -EINPROGRESS);
                 /* this should always be 0 before a resubmit. */
@@ -1535,12 +2136,14 @@ error_submit_buf_in:
                         xfer, seg_idx, result);
         seg->result = result;
         kfree(wa->buf_in_urb->sg);
+        wa->buf_in_urb->sg = NULL;
 error_sg_alloc:
         __wa_xfer_abort(xfer);
-error_complete:
         seg->status = WA_SEG_ERROR;
+error_complete:
         xfer->segs_done++;
         rpipe_ready = rpipe_avail_inc(rpipe);
+        wa_complete_remaining_xfer_segs(xfer, seg);
         done = __wa_xfer_is_done(xfer);
         /*
          * queue work item to clear STALL for control endpoints.
@@ -1552,10 +2155,8 @@ error_complete:
 
                 dev_info(dev, "Control EP stall.  Queue delayed work.\n");
                 spin_lock_irq(&wa->xfer_list_lock);
-                /* remove xfer from xfer_list. */
-                list_del(&xfer->list_node);
-                /* add xfer to xfer_errored_list. */
-                list_add_tail(&xfer->list_node, &wa->xfer_errored_list);
+                /* move xfer from xfer_list to xfer_errored_list. */
+                list_move_tail(&xfer->list_node, &wa->xfer_errored_list);
                 spin_unlock_irq(&wa->xfer_list_lock);
                 spin_unlock_irqrestore(&xfer->lock, flags);
                 queue_work(wusbd, &wa->xfer_error_work);
@@ -1587,6 +2188,90 @@ segment_aborted:
 }
 
 /*
+ * Process a isochronous packet status message
+ *
+ * inbound transfers: need to schedule a buf_in_urb read
+ */
+static void wa_process_iso_packet_status(struct wahc *wa, struct urb *urb)
+{
+        struct device *dev = &wa->usb_iface->dev;
+        struct wa_xfer_packet_status_hwaiso *packet_status;
+        struct wa_xfer_packet_status_len_hwaiso *status_array;
+        struct wa_xfer *xfer;
+        unsigned long flags;
+        struct wa_seg *seg;
+        struct wa_rpipe *rpipe;
+        unsigned done = 0;
+        unsigned rpipe_ready = 0, seg_index;
+        int expected_size;
+
+        /* We have a xfer result buffer; check it */
+        dev_dbg(dev, "DTI: isoc packet status %d bytes at %p\n",
+                urb->actual_length, urb->transfer_buffer);
+        packet_status = (struct wa_xfer_packet_status_hwaiso *)(wa->dti_buf);
+        if (packet_status->bPacketType != WA_XFER_ISO_PACKET_STATUS) {
+                dev_err(dev, "DTI Error: isoc packet status--bad type 0x%02x\n",
+                        packet_status->bPacketType);
+                goto error_parse_buffer;
+        }
+        xfer = wa_xfer_get_by_id(wa, wa->dti_isoc_xfer_in_progress);
+        if (xfer == NULL) {
+                dev_err(dev, "DTI Error: isoc packet status--unknown xfer 0x%08x\n",
+                        wa->dti_isoc_xfer_in_progress);
+                goto error_parse_buffer;
+        }
+        spin_lock_irqsave(&xfer->lock, flags);
+        if (unlikely(wa->dti_isoc_xfer_seg >= xfer->segs))
+                goto error_bad_seg;
+        seg = xfer->seg[wa->dti_isoc_xfer_seg];
+        rpipe = xfer->ep->hcpriv;
+        expected_size = sizeof(*packet_status) +
+                        (sizeof(packet_status->PacketStatus[0]) *
+                        seg->isoc_frame_count);
+        if (urb->actual_length != expected_size) {
+                dev_err(dev, "DTI Error: isoc packet status--bad urb length (%d bytes vs %d needed)\n",
+                        urb->actual_length, expected_size);
+                goto error_bad_seg;
+        }
+        if (le16_to_cpu(packet_status->wLength) != expected_size) {
+                dev_err(dev, "DTI Error: isoc packet status--bad length %u\n",
+                        le16_to_cpu(packet_status->wLength));
+                goto error_bad_seg;
+        }
+        /* isoc packet status and lengths back xfer urb. */
+        status_array = packet_status->PacketStatus;
+        for (seg_index = 0; seg_index < seg->isoc_frame_count; ++seg_index) {
+                xfer->urb->iso_frame_desc[seg->index].status =
+                        wa_xfer_status_to_errno(
+                        le16_to_cpu(status_array[seg_index].PacketStatus));
+                xfer->urb->iso_frame_desc[seg->index].actual_length =
+                        le16_to_cpu(status_array[seg_index].PacketLength);
+        }
+
+        if (!xfer->is_inbound) {
+                /* OUT transfer, complete it -- */
+                seg->status = WA_SEG_DONE;
+                xfer->segs_done++;
+                rpipe_ready = rpipe_avail_inc(rpipe);
+                done = __wa_xfer_is_done(xfer);
+        }
+        spin_unlock_irqrestore(&xfer->lock, flags);
+        wa->dti_state = WA_DTI_TRANSFER_RESULT_PENDING;
+        if (done)
+                wa_xfer_completion(xfer);
+        if (rpipe_ready)
+                wa_xfer_delayed_run(rpipe);
+        wa_xfer_put(xfer);
+        return;
+
+error_bad_seg:
+        spin_unlock_irqrestore(&xfer->lock, flags);
+        wa_xfer_put(xfer);
+error_parse_buffer:
+        return;
+}
+
+/*
  * Callback for the IN data phase
  *
  * If successful transition state; otherwise, take a note of the
@@ -1687,56 +2372,61 @@ static void wa_buf_in_cb(struct urb *urb)
  * We go back to OFF when we detect a ENOENT or ESHUTDOWN (or too many
  * errors) in the URBs.
  */
-static void wa_xfer_result_cb(struct urb *urb)
+static void wa_dti_cb(struct urb *urb)
 {
         int result;
         struct wahc *wa = urb->context;
         struct device *dev = &wa->usb_iface->dev;
-        struct wa_xfer_result *xfer_result;
         u32 xfer_id;
-        struct wa_xfer *xfer;
         u8 usb_status;
 
         BUG_ON(wa->dti_urb != urb);
         switch (wa->dti_urb->status) {
         case 0:
-                /* We have a xfer result buffer; check it */
-                dev_dbg(dev, "DTI: xfer result %d bytes at %p\n",
-                        urb->actual_length, urb->transfer_buffer);
-                if (wa->dti_urb->actual_length != sizeof(*xfer_result)) {
-                        dev_err(dev, "DTI Error: xfer result--bad size "
-                                "xfer result (%d bytes vs %zu needed)\n",
-                                urb->actual_length, sizeof(*xfer_result));
-                        break;
-                }
-                xfer_result = wa->xfer_result;
-                if (xfer_result->hdr.bLength != sizeof(*xfer_result)) {
-                        dev_err(dev, "DTI Error: xfer result--"
-                                "bad header length %u\n",
-                                xfer_result->hdr.bLength);
-                        break;
-                }
-                if (xfer_result->hdr.bNotifyType != WA_XFER_RESULT) {
-                        dev_err(dev, "DTI Error: xfer result--"
-                                "bad header type 0x%02x\n",
-                                xfer_result->hdr.bNotifyType);
-                        break;
-                }
-                usb_status = xfer_result->bTransferStatus & 0x3f;
-                if (usb_status == WA_XFER_STATUS_NOT_FOUND)
-                        /* taken care of already */
-                        break;
-                xfer_id = xfer_result->dwTransferID;
-                xfer = wa_xfer_get_by_id(wa, xfer_id);
-                if (xfer == NULL) {
-                        /* FIXME: transaction might have been cancelled */
-                        dev_err(dev, "DTI Error: xfer result--"
-                                "unknown xfer 0x%08x (status 0x%02x)\n",
-                                xfer_id, usb_status);
-                        break;
+                if (wa->dti_state == WA_DTI_TRANSFER_RESULT_PENDING) {
+                        struct wa_xfer_result *xfer_result;
+                        struct wa_xfer *xfer;
+
+                        /* We have a xfer result buffer; check it */
+                        dev_dbg(dev, "DTI: xfer result %d bytes at %p\n",
+                                urb->actual_length, urb->transfer_buffer);
+                        if (urb->actual_length != sizeof(*xfer_result)) {
+                                dev_err(dev, "DTI Error: xfer result--bad size xfer result (%d bytes vs %zu needed)\n",
+                                        urb->actual_length,
+                                        sizeof(*xfer_result));
+                                break;
+                        }
+                        xfer_result = (struct wa_xfer_result *)(wa->dti_buf);
+                        if (xfer_result->hdr.bLength != sizeof(*xfer_result)) {
+                                dev_err(dev, "DTI Error: xfer result--bad header length %u\n",
+                                        xfer_result->hdr.bLength);
+                                break;
+                        }
+                        if (xfer_result->hdr.bNotifyType != WA_XFER_RESULT) {
+                                dev_err(dev, "DTI Error: xfer result--bad header type 0x%02x\n",
+                                        xfer_result->hdr.bNotifyType);
+                                break;
+                        }
+                        usb_status = xfer_result->bTransferStatus & 0x3f;
+                        if (usb_status == WA_XFER_STATUS_NOT_FOUND)
+                                /* taken care of already */
+                                break;
+                        xfer_id = le32_to_cpu(xfer_result->dwTransferID);
+                        xfer = wa_xfer_get_by_id(wa, xfer_id);
+                        if (xfer == NULL) {
+                                /* FIXME: transaction not found. */
+                                dev_err(dev, "DTI Error: xfer result--unknown xfer 0x%08x (status 0x%02x)\n",
+                                        xfer_id, usb_status);
+                                break;
+                        }
+                        wa_xfer_result_chew(wa, xfer, xfer_result);
+                        wa_xfer_put(xfer);
+                } else if (wa->dti_state == WA_DTI_ISOC_PACKET_STATUS_PENDING) {
+                        wa_process_iso_packet_status(wa, urb);
+                } else {
+                        dev_err(dev, "DTI Error: unexpected EP state = %d\n",
+                                wa->dti_state);
                 }
-                wa_xfer_result_chew(wa, xfer);
-                wa_xfer_put(xfer);
                 break;
         case -ENOENT:           /* (we killed the URB)...so, no broadcast */
         case -ESHUTDOWN:        /* going away! */
@@ -1777,7 +2467,7 @@ out:
  * don't really set it up and start it until the first xfer complete
  * notification arrives, which is what we do here.
  *
- * Follow up in wa_xfer_result_cb(), as that's where the whole state
+ * Follow up in wa_dti_cb(), as that's where the whole state
  * machine starts.
  *
  * So here we just initialize the DTI URB for reading transfer result
@@ -1813,8 +2503,8 @@ void wa_handle_notif_xfer(struct wahc *wa, struct wa_notif_hdr *notif_hdr)
         usb_fill_bulk_urb(
                 wa->dti_urb, wa->usb_dev,
                 usb_rcvbulkpipe(wa->usb_dev, 0x80 | notif_xfer->bEndpoint),
-                wa->xfer_result, wa->xfer_result_size,
-                wa_xfer_result_cb, wa);
+                wa->dti_buf, wa->dti_buf_size,
+                wa_dti_cb, wa);
 
         wa->buf_in_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (wa->buf_in_urb == NULL) {
@@ -1836,6 +2526,7 @@ out:
 
 error_dti_urb_submit:
         usb_put_urb(wa->buf_in_urb);
+        wa->buf_in_urb = NULL;
 error_buf_in_urb_alloc:
         usb_put_urb(wa->dti_urb);
         wa->dti_urb = NULL;