194 files changed, 7875 insertions, 4307 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index cf1b19bca306..ae481c37a208 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -149,4 +149,14 @@ source "drivers/usb/phy/Kconfig"
 
 source "drivers/usb/gadget/Kconfig"
 
+config USB_LED_TRIG
+        bool "USB LED Triggers"
+        depends on LEDS_CLASS && USB_COMMON && LEDS_TRIGGERS
+        help
+          This option adds LED triggers for USB host and/or gadget activity.
+
+          Say Y here if you are working on a system with led-class supported
+          LEDs and you want to use them as activity indicators for USB host or
+          gadget.
+
 endif # USB_SUPPORT
diff --git a/drivers/usb/README b/drivers/usb/README
index 284f46b3e1cc..2144e7dbfa41 100644
--- a/drivers/usb/README
+++ b/drivers/usb/README
@@ -24,7 +24,7 @@ Here is a list of what each subdirectory here is, and what is contained in
 them.
 
 core/           - This is for the core USB host code, including the
-                  usbfs files and the hub class driver ("khubd").
+                  usbfs files and the hub class driver ("hub_wq").
 
 host/           - This is for USB host controller drivers.  This
                   includes UHCI, OHCI, EHCI, and others that might
diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
index 9563cb56d564..ea40626e0246 100644
--- a/drivers/usb/chipidea/ci.h
+++ b/drivers/usb/chipidea/ci.h
@@ -99,10 +99,10 @@ enum ci_role {
 
 /**
  * struct ci_role_driver - host/gadget role driver
- * start: start this role
- * stop: stop this role
- * irq: irq handler for this role
- * name: role name string (host/gadget)
+ * @start: start this role
+ * @stop: stop this role
+ * @irq: irq handler for this role
+ * @name: role name string (host/gadget)
  */
 struct ci_role_driver {
         int             (*start)(struct ci_hdrc *);
@@ -245,6 +245,7 @@ static inline void ci_role_stop(struct ci_hdrc *ci)
 
 /**
  * hw_read: reads from a hw register
+ * @ci: the controller
  * @reg:  register index
  * @mask: bitfield mask
  *
@@ -277,6 +278,7 @@ static inline void __hw_write(struct ci_hdrc *ci, u32 val,
 
 /**
  * hw_write: writes to a hw register
+ * @ci: the controller
  * @reg:  register index
  * @mask: bitfield mask
  * @data: new value
@@ -293,6 +295,7 @@ static inline void hw_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
 
 /**
  * hw_test_and_clear: tests & clears a hw register
+ * @ci: the controller
  * @reg:  register index
  * @mask: bitfield mask
  *
@@ -309,6 +312,7 @@ static inline u32 hw_test_and_clear(struct ci_hdrc *ci, enum ci_hw_regs reg,
 
 /**
  * hw_test_and_write: tests & writes a hw register
+ * @ci: the controller
  * @reg:  register index
  * @mask: bitfield mask
  * @data: new value
@@ -327,6 +331,8 @@ static inline u32 hw_test_and_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
 /**
  * ci_otg_is_fsm_mode: runtime check if otg controller
  * is in otg fsm mode.
+ *
+ * @ci: chipidea device
  */
 static inline bool ci_otg_is_fsm_mode(struct ci_hdrc *ci)
 {
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_hdrc_imx.c
index 65444b02bd68..a7ab0f15926e 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.c
+++ b/drivers/usb/chipidea/ci_hdrc_imx.c
@@ -54,6 +54,7 @@ struct ci_hdrc_imx_data {
 
 static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev)
 {
+        struct platform_device *misc_pdev;
         struct device_node *np = dev->of_node;
         struct of_phandle_args args;
         struct imx_usbmisc_data *data;
@@ -79,8 +80,15 @@ static struct imx_usbmisc_data *usbmisc_get_init_data(struct device *dev)
         }
 
         data->index = args.args[0];
+
+        misc_pdev = of_find_device_by_node(args.np);
         of_node_put(args.np);
 
+        if (!misc_pdev)
+                return ERR_PTR(-EPROBE_DEFER);
+
+        data->dev = &misc_pdev->dev;
+
         if (of_find_property(np, "disable-over-current", NULL))
                 data->disable_oc = 1;
 
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.h b/drivers/usb/chipidea/ci_hdrc_imx.h
index 996ec93467b2..4ed828f75a1e 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.h
+++ b/drivers/usb/chipidea/ci_hdrc_imx.h
@@ -13,6 +13,7 @@
 #define __DRIVER_USB_CHIPIDEA_CI_HDRC_IMX_H
 
 struct imx_usbmisc_data {
+        struct device *dev;
         int index;
 
         unsigned int disable_oc:1; /* over current detect disabled */
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 619d13e29995..3df5005c554d 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -139,6 +139,8 @@ static int hw_alloc_regmap(struct ci_hdrc *ci, bool is_lpm)
 /**
  * hw_read_intr_enable: returns interrupt enable register
  *
+ * @ci: the controller
+ *
  * This function returns register data
  */
 u32 hw_read_intr_enable(struct ci_hdrc *ci)
@@ -149,6 +151,8 @@ u32 hw_read_intr_enable(struct ci_hdrc *ci)
 /**
  * hw_read_intr_status: returns interrupt status register
  *
+ * @ci: the controller
+ *
  * This function returns register data
  */
 u32 hw_read_intr_status(struct ci_hdrc *ci)
@@ -176,6 +180,8 @@ int hw_port_test_set(struct ci_hdrc *ci, u8 mode)
 /**
  * hw_port_test_get: reads port test mode value
  *
+ * @ci: the controller
+ *
  * This function returns port test mode value
  */
 u8 hw_port_test_get(struct ci_hdrc *ci)
@@ -295,7 +301,7 @@ static void hw_phymode_configure(struct ci_hdrc *ci)
 /**
  * ci_usb_phy_init: initialize phy according to different phy type
  * @ci: the controller
-  *
+ *
  * This function returns an error code if usb_phy_init has failed
  */
 static int ci_usb_phy_init(struct ci_hdrc *ci)
@@ -473,6 +479,10 @@ static int ci_get_platdata(struct device *dev,
                                 PTR_ERR(platdata->reg_vbus));
                         return PTR_ERR(platdata->reg_vbus);
                 }
+                /* Get TPL support */
+                if (!platdata->tpl_support)
+                        platdata->tpl_support =
+                                of_usb_host_tpl_support(dev->of_node);
         }
 
         if (of_usb_get_maximum_speed(dev->of_node) == USB_SPEED_FULL)
@@ -658,7 +668,7 @@ static int ci_hdrc_probe(struct platform_device *pdev)
                 goto deinit_phy;
         }
 
-        if (ci->is_otg) {
+        if (ci->is_otg && ci->roles[CI_ROLE_GADGET]) {
                 /* Disable and clear all OTG irq */
                 hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
                                                         OTGSC_INT_STATUS_BITS);
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index a93d950e9468..ebde7b6ce687 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -59,7 +59,8 @@ static int host_start(struct ci_hdrc *ci)
         hcd->has_tt = 1;
 
         hcd->power_budget = ci->platdata->power_budget;
-        hcd->phy = ci->transceiver;
+        hcd->usb_phy = ci->transceiver;
+        hcd->tpl_support = ci->platdata->tpl_support;
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = ci->hw_bank.cap;
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index b8125aa64ad8..0444d3f8971a 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -627,7 +627,7 @@ __acquires(hwep->lock)
 
                 if (hwreq->req.complete != NULL) {
                         spin_unlock(hwep->lock);
-                        hwreq->req.complete(&hwep->ep, &hwreq->req);
+                        usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
                         spin_lock(hwep->lock);
                 }
         }
@@ -922,7 +922,7 @@ __acquires(hwep->lock)
                         if ((hwep->type == USB_ENDPOINT_XFER_CONTROL) &&
                                         hwreq->req.length)
                                 hweptemp = hwep->ci->ep0in;
-                        hwreq->req.complete(&hweptemp->ep, &hwreq->req);
+                        usb_gadget_giveback_request(&hweptemp->ep, &hwreq->req);
                         spin_lock(hwep->lock);
                 }
         }
@@ -1347,7 +1347,7 @@ static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
 
         if (hwreq->req.complete != NULL) {
                 spin_unlock(hwep->lock);
-                hwreq->req.complete(&hwep->ep, &hwreq->req);
+                usb_gadget_giveback_request(&hwep->ep, &hwreq->req);
                 spin_lock(hwep->lock);
         }
 
diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbmisc_imx.c
index 85293b8b1df9..926c997ef310 100644
--- a/drivers/usb/chipidea/usbmisc_imx.c
+++ b/drivers/usb/chipidea/usbmisc_imx.c
@@ -57,6 +57,8 @@
 
 #define MX6_BM_OVER_CUR_DIS             BIT(7)
 
+#define VF610_OVER_CUR_DIS              BIT(7)
+
 struct usbmisc_ops {
         /* It's called once when probe a usb device */
         int (*init)(struct imx_usbmisc_data *data);
@@ -71,10 +73,9 @@ struct imx_usbmisc {
         const struct usbmisc_ops *ops;
 };
 
-static struct imx_usbmisc *usbmisc;
-
 static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
         unsigned long flags;
         u32 val = 0;
 
@@ -108,6 +109,7 @@ static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
 
 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
         void __iomem *reg;
         unsigned long flags;
         u32 val;
@@ -130,6 +132,7 @@ static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 
 static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
         unsigned long flags;
         u32 val;
 
@@ -160,6 +163,7 @@ static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
 
 static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
         void __iomem *reg = NULL;
         unsigned long flags;
         u32 val = 0;
@@ -204,6 +208,7 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
 
 static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
         unsigned long flags;
         u32 reg;
 
@@ -221,6 +226,26 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
         return 0;
 }
 
+static int usbmisc_vf610_init(struct imx_usbmisc_data *data)
+{
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+        u32 reg;
+
+        /*
+         * Vybrid only has one misc register set, but in two different
+         * areas. These is reflected in two instances of this driver.
+         */
+        if (data->index >= 1)
+                return -EINVAL;
+
+        if (data->disable_oc) {
+                reg = readl(usbmisc->base);
+                writel(reg | VF610_OVER_CUR_DIS, usbmisc->base);
+        }
+
+        return 0;
+}
+
 static const struct usbmisc_ops imx25_usbmisc_ops = {
         .init = usbmisc_imx25_init,
         .post = usbmisc_imx25_post,
@@ -238,10 +263,14 @@ static const struct usbmisc_ops imx6q_usbmisc_ops = {
         .init = usbmisc_imx6q_init,
 };
 
+static const struct usbmisc_ops vf610_usbmisc_ops = {
+        .init = usbmisc_vf610_init,
+};
+
 int imx_usbmisc_init(struct imx_usbmisc_data *data)
 {
-        if (!usbmisc)
-                return -EPROBE_DEFER;
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+
         if (!usbmisc->ops->init)
                 return 0;
         return usbmisc->ops->init(data);
@@ -250,8 +279,8 @@ EXPORT_SYMBOL_GPL(imx_usbmisc_init);
 
 int imx_usbmisc_init_post(struct imx_usbmisc_data *data)
 {
-        if (!usbmisc)
-                return -EPROBE_DEFER;
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(data->dev);
+
         if (!usbmisc->ops->post)
                 return 0;
         return usbmisc->ops->post(data);
@@ -283,6 +312,10 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = {
                 .compatible = "fsl,imx6q-usbmisc",
                 .data = &imx6q_usbmisc_ops,
         },
+        {
+                .compatible = "fsl,vf610-usbmisc",
+                .data = &vf610_usbmisc_ops,
+        },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, usbmisc_imx_dt_ids);
@@ -294,9 +327,6 @@ static int usbmisc_imx_probe(struct platform_device *pdev)
         int ret;
         struct of_device_id *tmp_dev;
 
-        if (usbmisc)
-                return -EBUSY;
-
         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
@@ -325,15 +355,15 @@ static int usbmisc_imx_probe(struct platform_device *pdev)
         tmp_dev = (struct of_device_id *)
                 of_match_device(usbmisc_imx_dt_ids, &pdev->dev);
         data->ops = (const struct usbmisc_ops *)tmp_dev->data;
-        usbmisc = data;
+        platform_set_drvdata(pdev, data);
 
         return 0;
 }
 
 static int usbmisc_imx_remove(struct platform_device *pdev)
 {
+        struct imx_usbmisc *usbmisc = dev_get_drvdata(&pdev->dev);
         clk_disable_unprepare(usbmisc->clk);
-        usbmisc = NULL;
         return 0;
 }
 
diff --git a/drivers/usb/common/Makefile b/drivers/usb/common/Makefile
index 752646167e1e..ca2f8bd0e431 100644
--- a/drivers/usb/common/Makefile
+++ b/drivers/usb/common/Makefile
@@ -2,5 +2,8 @@
 # Makefile for the usb common parts.
 #
 
-obj-$(CONFIG_USB_COMMON) += usb-common.o
+obj-$(CONFIG_USB_COMMON)          += usb-common.o
+usb-common-y                      += common.o
+usb-common-$(CONFIG_USB_LED_TRIG) += led.o
+
 obj-$(CONFIG_USB_OTG_FSM) += usb-otg-fsm.o
diff --git a/drivers/usb/common/usb-common.c b/drivers/usb/common/common.c
index 6dfd30a863c7..b530fd403ffb 100644
--- a/drivers/usb/common/usb-common.c
+++ b/drivers/usb/common/common.c
@@ -139,6 +139,21 @@ enum usb_device_speed of_usb_get_maximum_speed(struct device_node *np)
 }
 EXPORT_SYMBOL_GPL(of_usb_get_maximum_speed);
 
+/**
+ * of_usb_host_tpl_support - to get if Targeted Peripheral List is supported
+ * for given targeted hosts (non-PC hosts)
+ * @np: Pointer to the given device_node
+ *
+ * The function gets if the targeted hosts support TPL or not
+ */
+bool of_usb_host_tpl_support(struct device_node *np)
+{
+        if (of_find_property(np, "tpl-support", NULL))
+                return true;
+
+        return false;
+}
+EXPORT_SYMBOL_GPL(of_usb_host_tpl_support);
 #endif
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/common/led.c b/drivers/usb/common/led.c
new file mode 100644
index 000000000000..df23da00a901
--- /dev/null
+++ b/drivers/usb/common/led.c
@@ -0,0 +1,57 @@
+/*
+ * LED Triggers for USB Activity
+ *
+ * Copyright 2014 Michal Sojka <sojka@merica.cz>
+ *
+ * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/leds.h>
+#include <linux/usb.h>
+
+#define BLINK_DELAY 30
+
+static unsigned long usb_blink_delay = BLINK_DELAY;
+
+DEFINE_LED_TRIGGER(ledtrig_usb_gadget);
+DEFINE_LED_TRIGGER(ledtrig_usb_host);
+
+void usb_led_activity(enum usb_led_event ev)
+{
+        struct led_trigger *trig = NULL;
+
+        switch (ev) {
+        case USB_LED_EVENT_GADGET:
+                trig = ledtrig_usb_gadget;
+                break;
+        case USB_LED_EVENT_HOST:
+                trig = ledtrig_usb_host;
+                break;
+        }
+        /* led_trigger_blink_oneshot() handles trig == NULL gracefully */
+        led_trigger_blink_oneshot(trig, &usb_blink_delay, &usb_blink_delay, 0);
+}
+EXPORT_SYMBOL_GPL(usb_led_activity);
+
+
+static int __init ledtrig_usb_init(void)
+{
+        led_trigger_register_simple("usb-gadget", &ledtrig_usb_gadget);
+        led_trigger_register_simple("usb-host", &ledtrig_usb_host);
+        return 0;
+}
+
+static void __exit ledtrig_usb_exit(void)
+{
+        led_trigger_unregister_simple(ledtrig_usb_gadget);
+        led_trigger_unregister_simple(ledtrig_usb_host);
+}
+
+module_init(ledtrig_usb_init);
+module_exit(ledtrig_usb_exit);
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 1060657ca1b0..9cfda6a72194 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -56,22 +56,16 @@ config USB_OTG
           connector.
 
 config USB_OTG_WHITELIST
-        bool "Rely on OTG Targeted Peripherals List"
-        depends on USB_OTG || EXPERT
-        default y if USB_OTG
+        bool "Rely on OTG and EH Targeted Peripherals List"
+        depends on USB
         help
           If you say Y here, the "otg_whitelist.h" file will be used as a
           product whitelist, so USB peripherals not listed there will be
           rejected during enumeration.  This behavior is required by the
-          USB OTG specification for all devices not on your product's
+          USB OTG and EH specification for all devices not on your product's
           "Targeted Peripherals List".  "Embedded Hosts" are likewise
           allowed to support only a limited number of peripherals.
 
-          Otherwise, peripherals not listed there will only generate a
-          warning and enumeration will continue.  That's more like what
-          normal Linux-USB hosts do (other than the warning), and is
-          convenient for many stages of product development.
-
 config USB_OTG_BLACKLIST_HUB
         bool "Disable external hubs"
         depends on USB_OTG || EXPERT
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 487abcfcccd8..b84fb141e122 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -42,6 +42,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/types.h>
 
+#include <linux/phy/phy.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
 #include <linux/usb/phy.h>
@@ -1272,7 +1273,7 @@ EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
  * The usb core itself is however optimized for host controllers that can dma
  * using regular system memory - like pci devices doing bus mastering.
  *
- * To support host controllers with limited dma capabilites we provide dma
+ * To support host controllers with limited dma capabilities we provide dma
  * bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag.
  * For this to work properly the host controller code must first use the
  * function dma_declare_coherent_memory() to point out which memory area
@@ -1664,6 +1665,8 @@ static void __usb_hcd_giveback_urb(struct urb *urb)
         usbmon_urb_complete(&hcd->self, urb, status);
         usb_anchor_suspend_wakeups(anchor);
         usb_unanchor_urb(urb);
+        if (likely(status == 0))
+                usb_led_activity(USB_LED_EVENT_HOST);
 
         /* pass ownership to the completion handler */
         urb->status = status;
@@ -2301,7 +2304,7 @@ EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
  * Context: in_interrupt()
  *
  * Starts enumeration, with an immediate reset followed later by
- * khubd identifying and possibly configuring the device.
+ * hub_wq identifying and possibly configuring the device.
  * This is needed by OTG controller drivers, where it helps meet
  * HNP protocol timing requirements for starting a port reset.
  *
@@ -2320,7 +2323,7 @@ int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
         if (port_num && hcd->driver->start_port_reset)
                 status = hcd->driver->start_port_reset(hcd, port_num);
 
-        /* run khubd shortly after (first) root port reset finishes;
+        /* allocate hub_wq shortly after (first) root port reset finishes;
          * it may issue others, until at least 50 msecs have passed.
          */
         if (status == 0)
@@ -2383,20 +2386,20 @@ void usb_hc_died (struct usb_hcd *hcd)
         if (hcd->rh_registered) {
                 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 
-                /* make khubd clean up old urbs and devices */
+                /* make hub_wq clean up old urbs and devices */
                 usb_set_device_state (hcd->self.root_hub,
                                 USB_STATE_NOTATTACHED);
-                usb_kick_khubd (hcd->self.root_hub);
+                usb_kick_hub_wq(hcd->self.root_hub);
         }
         if (usb_hcd_is_primary_hcd(hcd) && hcd->shared_hcd) {
                 hcd = hcd->shared_hcd;
                 if (hcd->rh_registered) {
                         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
 
-                        /* make khubd clean up old urbs and devices */
+                        /* make hub_wq clean up old urbs and devices */
                         usb_set_device_state(hcd->self.root_hub,
                                         USB_STATE_NOTATTACHED);
-                        usb_kick_khubd(hcd->self.root_hub);
+                        usb_kick_hub_wq(hcd->self.root_hub);
                 }
         }
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
@@ -2627,7 +2630,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
         int retval;
         struct usb_device *rhdev;
 
-        if (IS_ENABLED(CONFIG_USB_PHY) && !hcd->phy) {
+        if (IS_ENABLED(CONFIG_USB_PHY) && !hcd->usb_phy) {
                 struct usb_phy *phy = usb_get_phy_dev(hcd->self.controller, 0);
 
                 if (IS_ERR(phy)) {
@@ -2640,11 +2643,34 @@ int usb_add_hcd(struct usb_hcd *hcd,
                                 usb_put_phy(phy);
                                 return retval;
                         }
-                        hcd->phy = phy;
+                        hcd->usb_phy = phy;
                         hcd->remove_phy = 1;
                 }
         }
 
+        if (IS_ENABLED(CONFIG_GENERIC_PHY)) {
+                struct phy *phy = phy_get(hcd->self.controller, "usb");
+
+                if (IS_ERR(phy)) {
+                        retval = PTR_ERR(phy);
+                        if (retval == -EPROBE_DEFER)
+                                goto err_phy;
+                } else {
+                        retval = phy_init(phy);
+                        if (retval) {
+                                phy_put(phy);
+                                goto err_phy;
+                        }
+                        retval = phy_power_on(phy);
+                        if (retval) {
+                                phy_exit(phy);
+                                phy_put(phy);
+                                goto err_phy;
+                        }
+                        hcd->phy = phy;
+                }
+        }
+
         dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
 
         /* Keep old behaviour if authorized_default is not in [0, 1]. */
@@ -2655,12 +2681,12 @@ int usb_add_hcd(struct usb_hcd *hcd,
         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
 
         /* HC is in reset state, but accessible.  Now do the one-time init,
-         * bottom up so that hcds can customize the root hubs before khubd
+         * bottom up so that hcds can customize the root hubs before hub_wq
          * starts talking to them.  (Note, bus id is assigned early too.)
          */
         if ((retval = hcd_buffer_create(hcd)) != 0) {
                 dev_dbg(hcd->self.controller, "pool alloc failed\n");
-                goto err_remove_phy;
+                goto err_create_buf;
         }
 
         if ((retval = usb_register_bus(&hcd->self)) < 0)
@@ -2787,12 +2813,19 @@ err_allocate_root_hub:
         usb_deregister_bus(&hcd->self);
 err_register_bus:
         hcd_buffer_destroy(hcd);
-err_remove_phy:
-        if (hcd->remove_phy && hcd->phy) {
-                usb_phy_shutdown(hcd->phy);
-                usb_put_phy(hcd->phy);
+err_create_buf:
+        if (IS_ENABLED(CONFIG_GENERIC_PHY) && hcd->phy) {
+                phy_power_off(hcd->phy);
+                phy_exit(hcd->phy);
+                phy_put(hcd->phy);
                 hcd->phy = NULL;
         }
+err_phy:
+        if (hcd->remove_phy && hcd->usb_phy) {
+                usb_phy_shutdown(hcd->usb_phy);
+                usb_put_phy(hcd->usb_phy);
+                hcd->usb_phy = NULL;
+        }
         return retval;
 }
 EXPORT_SYMBOL_GPL(usb_add_hcd);
@@ -2864,11 +2897,18 @@ void usb_remove_hcd(struct usb_hcd *hcd)
 
         usb_deregister_bus(&hcd->self);
         hcd_buffer_destroy(hcd);
-        if (hcd->remove_phy && hcd->phy) {
-                usb_phy_shutdown(hcd->phy);
-                usb_put_phy(hcd->phy);
+
+        if (IS_ENABLED(CONFIG_GENERIC_PHY) && hcd->phy) {
+                phy_power_off(hcd->phy);
+                phy_exit(hcd->phy);
+                phy_put(hcd->phy);
                 hcd->phy = NULL;
         }
+        if (hcd->remove_phy && hcd->usb_phy) {
+                usb_phy_shutdown(hcd->usb_phy);
+                usb_put_phy(hcd->usb_phy);
+                hcd->usb_phy = NULL;
+        }
 
         usb_put_invalidate_rhdev(hcd);
 }
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index d481c99a20d7..11e80ac31324 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -22,9 +22,8 @@
 #include <linux/usb/hcd.h>
 #include <linux/usb/otg.h>
 #include <linux/usb/quirks.h>
-#include <linux/kthread.h>
+#include <linux/workqueue.h>
 #include <linux/mutex.h>
-#include <linux/freezer.h>
 #include <linux/random.h>
 #include <linux/pm_qos.h>
 
@@ -32,6 +31,7 @@
 #include <asm/byteorder.h>
 
 #include "hub.h"
+#include "otg_whitelist.h"
 
 #define USB_VENDOR_GENESYS_LOGIC                0x05e3
 #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND        0x01
@@ -41,14 +41,9 @@
  * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
 static DEFINE_SPINLOCK(device_state_lock);
 
-/* khubd's worklist and its lock */
-static DEFINE_SPINLOCK(hub_event_lock);
-static LIST_HEAD(hub_event_list);       /* List of hubs needing servicing */
-
-/* Wakes up khubd */
-static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
-
-static struct task_struct *khubd_task;
+/* workqueue to process hub events */
+static struct workqueue_struct *hub_wq;
+static void hub_event(struct work_struct *work);
 
 /* synchronize hub-port add/remove and peering operations */
 DEFINE_MUTEX(usb_port_peer_mutex);
@@ -104,6 +99,7 @@ EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 #define HUB_DEBOUNCE_STEP         25
 #define HUB_DEBOUNCE_STABLE      100
 
+static void hub_release(struct kref *kref);
 static int usb_reset_and_verify_device(struct usb_device *udev);
 
 static inline char *portspeed(struct usb_hub *hub, int portstatus)
@@ -575,28 +571,39 @@ static int hub_port_status(struct usb_hub *hub, int port1,
         return ret;
 }
 
-static void kick_khubd(struct usb_hub *hub)
+static void kick_hub_wq(struct usb_hub *hub)
 {
-        unsigned long   flags;
+        struct usb_interface *intf;
 
-        spin_lock_irqsave(&hub_event_lock, flags);
-        if (!hub->disconnected && list_empty(&hub->event_list)) {
-                list_add_tail(&hub->event_list, &hub_event_list);
+        if (hub->disconnected || work_pending(&hub->events))
+                return;
 
-                /* Suppress autosuspend until khubd runs */
-                usb_autopm_get_interface_no_resume(
-                                to_usb_interface(hub->intfdev));
-                wake_up(&khubd_wait);
-        }
-        spin_unlock_irqrestore(&hub_event_lock, flags);
+        /*
+         * Suppress autosuspend until the event is proceed.
+         *
+         * Be careful and make sure that the symmetric operation is
+         * always called. We are here only when there is no pending
+         * work for this hub. Therefore put the interface either when
+         * the new work is called or when it is canceled.
+         */
+        intf = to_usb_interface(hub->intfdev);
+        usb_autopm_get_interface_no_resume(intf);
+        kref_get(&hub->kref);
+
+        if (queue_work(hub_wq, &hub->events))
+                return;
+
+        /* the work has already been scheduled */
+        usb_autopm_put_interface_async(intf);
+        kref_put(&hub->kref, hub_release);
 }
 
-void usb_kick_khubd(struct usb_device *hdev)
+void usb_kick_hub_wq(struct usb_device *hdev)
 {
         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
 
         if (hub)
-                kick_khubd(hub);
+                kick_hub_wq(hub);
 }
 
 /*
@@ -618,7 +625,7 @@ void usb_wakeup_notification(struct usb_device *hdev,
         hub = usb_hub_to_struct_hub(hdev);
         if (hub) {
                 set_bit(portnum, hub->wakeup_bits);
-                kick_khubd(hub);
+                kick_hub_wq(hub);
         }
 }
 EXPORT_SYMBOL_GPL(usb_wakeup_notification);
@@ -645,7 +652,7 @@ static void hub_irq(struct urb *urb)
                 hub->error = status;
                 /* FALL THROUGH */
 
-        /* let khubd handle things */
+        /* let hub_wq handle things */
         case 0:                 /* we got data:  port status changed */
                 bits = 0;
                 for (i = 0; i < urb->actual_length; ++i)
@@ -657,8 +664,8 @@ static void hub_irq(struct urb *urb)
 
         hub->nerrors = 0;
 
-        /* Something happened, let khubd figure it out */
-        kick_khubd(hub);
+        /* Something happened, let hub_wq figure it out */
+        kick_hub_wq(hub);
 
 resubmit:
         if (hub->quiescing)
@@ -688,7 +695,7 @@ hub_clear_tt_buffer (struct usb_device *hdev, u16 devinfo, u16 tt)
 }
 
 /*
- * enumeration blocks khubd for a long time. we use keventd instead, since
+ * enumeration blocks hub_wq for a long time. we use keventd instead, since
  * long blocking there is the exception, not the rule.  accordingly, HCDs
  * talking to TTs must queue control transfers (not just bulk and iso), so
  * both can talk to the same hub concurrently.
@@ -954,7 +961,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 
 /*
  * Disable a port and mark a logical connect-change event, so that some
- * time later khubd will disconnect() any existing usb_device on the port
+ * time later hub_wq will disconnect() any existing usb_device on the port
  * and will re-enumerate if there actually is a device attached.
  */
 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
@@ -967,12 +974,12 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
          *  - SRP saves power that way
          *  - ... new call, TBD ...
          * That's easy if this hub can switch power per-port, and
-         * khubd reactivates the port later (timer, SRP, etc).
+         * hub_wq reactivates the port later (timer, SRP, etc).
          * Powerdown must be optional, because of reset/DFU.
          */
 
         set_bit(port1, hub->change_bits);
-        kick_khubd(hub);
+        kick_hub_wq(hub);
 }
 
 /**
@@ -980,7 +987,7 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
  * @udev: device to be disabled and removed
  * Context: @udev locked, must be able to sleep.
  *
- * After @udev's port has been disabled, khubd is notified and it will
+ * After @udev's port has been disabled, hub_wq is notified and it will
  * see that the device has been disconnected.  When the device is
  * physically unplugged and something is plugged in, the events will
  * be received and processed normally.
@@ -1100,7 +1107,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
  init2:
 
         /*
-         * Check each port and set hub->change_bits to let khubd know
+         * Check each port and set hub->change_bits to let hub_wq know
          * which ports need attention.
          */
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
@@ -1167,7 +1174,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                         clear_bit(port1, hub->removed_bits);
 
                 if (!udev || udev->state == USB_STATE_NOTATTACHED) {
-                        /* Tell khubd to disconnect the device or
+                        /* Tell hub_wq to disconnect the device or
                          * check for a new connection
                          */
                         if (udev || (portstatus & USB_PORT_STAT_CONNECTION) ||
@@ -1180,7 +1187,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                 USB_SS_PORT_LS_U0;
                         /* The power session apparently survived the resume.
                          * If there was an overcurrent or suspend change
-                         * (i.e., remote wakeup request), have khubd
+                         * (i.e., remote wakeup request), have hub_wq
                          * take care of it.  Look at the port link state
                          * for USB 3.0 hubs, since they don't have a suspend
                          * change bit, and they don't set the port link change
@@ -1201,7 +1208,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                 set_bit(port1, hub->change_bits);
 
                 } else {
-                        /* The power session is gone; tell khubd */
+                        /* The power session is gone; tell hub_wq */
                         usb_set_device_state(udev, USB_STATE_NOTATTACHED);
                         set_bit(port1, hub->change_bits);
                 }
@@ -1209,10 +1216,10 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
 
         /* If no port-status-change flags were set, we don't need any
          * debouncing.  If flags were set we can try to debounce the
-         * ports all at once right now, instead of letting khubd do them
+         * ports all at once right now, instead of letting hub_wq do them
          * one at a time later on.
          *
-         * If any port-status changes do occur during this delay, khubd
+         * If any port-status changes do occur during this delay, hub_wq
          * will see them later and handle them normally.
          */
         if (need_debounce_delay) {
@@ -1240,7 +1247,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                 &hub->leds, LED_CYCLE_PERIOD);
 
         /* Scan all ports that need attention */
-        kick_khubd(hub);
+        kick_hub_wq(hub);
 
         /* Allow autosuspend if it was suppressed */
         if (type <= HUB_INIT3)
@@ -1273,7 +1280,7 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
 
         cancel_delayed_work_sync(&hub->init_work);
 
-        /* khubd and related activity won't re-trigger */
+        /* hub_wq and related activity won't re-trigger */
         hub->quiescing = 1;
 
         if (type != HUB_SUSPEND) {
@@ -1284,7 +1291,7 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
                 }
         }
 
-        /* Stop khubd and related activity */
+        /* Stop hub_wq and related activity */
         usb_kill_urb(hub->urb);
         if (hub->has_indicators)
                 cancel_delayed_work_sync(&hub->leds);
@@ -1606,7 +1613,7 @@ static int hub_configure(struct usb_hub *hub,
         if (ret < 0)
                 goto fail;
 
-        /* Update the HCD's internal representation of this hub before khubd
+        /* Update the HCD's internal representation of this hub before hub_wq
          * starts getting port status changes for devices under the hub.
          */
         if (hcd->driver->update_hub_device) {
@@ -1634,6 +1641,7 @@ static void hub_release(struct kref *kref)
 {
         struct usb_hub *hub = container_of(kref, struct usb_hub, kref);
 
+        usb_put_dev(hub->hdev);
         usb_put_intf(to_usb_interface(hub->intfdev));
         kfree(hub);
 }
@@ -1646,14 +1654,11 @@ static void hub_disconnect(struct usb_interface *intf)
         struct usb_device *hdev = interface_to_usbdev(intf);
         int port1;
 
-        /* Take the hub off the event list and don't let it be added again */
-        spin_lock_irq(&hub_event_lock);
-        if (!list_empty(&hub->event_list)) {
-                list_del_init(&hub->event_list);
-                usb_autopm_put_interface_no_suspend(intf);
-        }
+        /*
+         * Stop adding new hub events. We do not want to block here and thus
+         * will not try to remove any pending work item.
+         */
         hub->disconnected = 1;
-        spin_unlock_irq(&hub_event_lock);
 
         /* Disconnect all children and quiesce the hub */
         hub->error = 0;
@@ -1793,12 +1798,13 @@ descriptor_error:
         }
 
         kref_init(&hub->kref);
-        INIT_LIST_HEAD(&hub->event_list);
         hub->intfdev = &intf->dev;
         hub->hdev = hdev;
         INIT_DELAYED_WORK(&hub->leds, led_work);
         INIT_DELAYED_WORK(&hub->init_work, NULL);
+        INIT_WORK(&hub->events, hub_event);
         usb_get_intf(intf);
+        usb_get_dev(hdev);
 
         usb_set_intfdata (intf, hub);
         intf->needs_remote_wakeup = 1;
@@ -1983,8 +1989,10 @@ void usb_set_device_state(struct usb_device *udev,
                                         || new_state == USB_STATE_SUSPENDED)
                                 ;       /* No change to wakeup settings */
                         else if (new_state == USB_STATE_CONFIGURED)
-                                wakeup = udev->actconfig->desc.bmAttributes
-                                         & USB_CONFIG_ATT_WAKEUP;
+                                wakeup = (udev->quirks &
+                                        USB_QUIRK_IGNORE_REMOTE_WAKEUP) ? 0 :
+                                        udev->actconfig->desc.bmAttributes &
+                                        USB_CONFIG_ATT_WAKEUP;
                         else
                                 wakeup = 0;
                 }
@@ -2037,7 +2045,8 @@ static void choose_devnum(struct usb_device *udev)
         int             devnum;
         struct usb_bus  *bus = udev->bus;
 
-        /* If khubd ever becomes multithreaded, this will need a lock */
+        /* be safe when more hub events are proceed in parallel */
+        mutex_lock(&bus->usb_address0_mutex);
         if (udev->wusb) {
                 devnum = udev->portnum + 1;
                 BUG_ON(test_bit(devnum, bus->devmap.devicemap));
@@ -2055,6 +2064,7 @@ static void choose_devnum(struct usb_device *udev)
                 set_bit(devnum, bus->devmap.devicemap);
                 udev->devnum = devnum;
         }
+        mutex_unlock(&bus->usb_address0_mutex);
 }
 
 static void release_devnum(struct usb_device *udev)
@@ -2205,9 +2215,6 @@ static void announce_device(struct usb_device *udev)
 static inline void announce_device(struct usb_device *udev) { }
 #endif
 
-#ifdef  CONFIG_USB_OTG
-#include "otg_whitelist.h"
-#endif
 
 /**
  * usb_enumerate_device_otg - FIXME (usbcore-internal)
@@ -2267,21 +2274,6 @@ static int usb_enumerate_device_otg(struct usb_device *udev)
                         }
                 }
         }
-
-        if (!is_targeted(udev)) {
-
-                /* Maybe it can talk to us, though we can't talk to it.
-                 * (Includes HNP test device.)
-                 */
-                if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
-                        err = usb_port_suspend(udev, PMSG_SUSPEND);
-                        if (err < 0)
-                                dev_dbg(&udev->dev, "HNP fail, %d\n", err);
-                }
-                err = -ENOTSUPP;
-                goto fail;
-        }
-fail:
 #endif
         return err;
 }
@@ -2304,6 +2296,7 @@ fail:
 static int usb_enumerate_device(struct usb_device *udev)
 {
         int err;
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
 
         if (udev->config == NULL) {
                 err = usb_get_configuration(udev);
@@ -2325,6 +2318,20 @@ static int usb_enumerate_device(struct usb_device *udev)
         if (err < 0)
                 return err;
 
+        if (IS_ENABLED(CONFIG_USB_OTG_WHITELIST) && hcd->tpl_support &&
+                !is_targeted(udev)) {
+                /* Maybe it can talk to us, though we can't talk to it.
+                 * (Includes HNP test device.)
+                 */
+                if (IS_ENABLED(CONFIG_USB_OTG) && (udev->bus->b_hnp_enable
+                        || udev->bus->is_b_host)) {
+                        err = usb_port_suspend(udev, PMSG_AUTO_SUSPEND);
+                        if (err < 0)
+                                dev_dbg(&udev->dev, "HNP fail, %d\n", err);
+                }
+                return -ENOTSUPP;
+        }
+
         usb_detect_interface_quirks(udev);
 
         return 0;
@@ -3070,7 +3077,7 @@ static unsigned wakeup_enabled_descendants(struct usb_device *udev)
  * Once VBUS drop breaks the circuit, the port it's using has to go through
  * normal re-enumeration procedures, starting with enabling VBUS power.
  * Other than re-initializing the hub (plug/unplug, except for root hubs),
- * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
+ * Linux (2.6) currently has NO mechanisms to initiate that:  no hub_wq
  * timer, no SRP, no requests through sysfs.
  *
  * If Runtime PM isn't enabled or used, non-SuperSpeed devices may not get
@@ -3212,7 +3219,7 @@ static int finish_port_resume(struct usb_device *udev)
         /* usb ch9 identifies four variants of SUSPENDED, based on what
          * state the device resumes to.  Linux currently won't see the
          * first two on the host side; they'd be inside hub_port_init()
-         * during many timeouts, but khubd can't suspend until later.
+         * during many timeouts, but hub_wq can't suspend until later.
          */
         usb_set_device_state(udev, udev->actconfig
                         ? USB_STATE_CONFIGURED
@@ -3577,7 +3584,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
 
         dev_dbg(&intf->dev, "%s\n", __func__);
 
-        /* stop khubd and related activity */
+        /* stop hub_wq and related activity */
         hub_quiesce(hub, HUB_SUSPEND);
         return 0;
 }
@@ -4461,8 +4468,8 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         if (retval)
                 goto fail;
 
-        if (hcd->phy && !hdev->parent)
-                usb_phy_notify_connect(hcd->phy, udev->speed);
+        if (hcd->usb_phy && !hdev->parent)
+                usb_phy_notify_connect(hcd->usb_phy, udev->speed);
 
         /*
          * Some superspeed devices have finished the link training process
@@ -4538,6 +4545,9 @@ check_highspeed (struct usb_hub *hub, struct usb_device *udev, int port1)
         struct usb_qualifier_descriptor *qual;
         int                             status;
 
+        if (udev->quirks & USB_QUIRK_DEVICE_QUALIFIER)
+                return;
+
         qual = kmalloc (sizeof *qual, GFP_KERNEL);
         if (qual == NULL)
                 return;
@@ -4617,9 +4627,9 @@ static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
 
         /* Disconnect any existing devices under this port */
         if (udev) {
-                if (hcd->phy && !hdev->parent &&
+                if (hcd->usb_phy && !hdev->parent &&
                                 !(portstatus & USB_PORT_STAT_CONNECTION))
-                        usb_phy_notify_disconnect(hcd->phy, udev->speed);
+                        usb_phy_notify_disconnect(hcd->usb_phy, udev->speed);
                 usb_disconnect(&port_dev->child);
         }
 
@@ -4970,10 +4980,10 @@ static void port_event(struct usb_hub *hub, int port1)
          * On disconnect USB3 protocol ports transit from U0 to
          * SS.Inactive to Rx.Detect. If this happens a warm-
          * reset is not needed, but a (re)connect may happen
-         * before khubd runs and sees the disconnect, and the
+         * before hub_wq runs and sees the disconnect, and the
          * device may be an unknown state.
          *
-         * If the port went through SS.Inactive without khubd
+         * If the port went through SS.Inactive without hub_wq
          * seeing it the C_LINK_STATE change flag will be set,
          * and we reset the dev to put it in a known state.
          */
@@ -4992,10 +5002,8 @@ static void port_event(struct usb_hub *hub, int port1)
                 hub_port_connect_change(hub, port1, portstatus, portchange);
 }
 
-
-static void hub_events(void)
+static void hub_event(struct work_struct *work)
 {
-        struct list_head *tmp;
         struct usb_device *hdev;
         struct usb_interface *intf;
         struct usb_hub *hub;
@@ -5004,166 +5012,117 @@ static void hub_events(void)
         u16 hubchange;
         int i, ret;
 
-        /*
-         *  We restart the list every time to avoid a deadlock with
-         * deleting hubs downstream from this one. This should be
-         * safe since we delete the hub from the event list.
-         * Not the most efficient, but avoids deadlocks.
-         */
-        while (1) {
+        hub = container_of(work, struct usb_hub, events);
+        hdev = hub->hdev;
+        hub_dev = hub->intfdev;
+        intf = to_usb_interface(hub_dev);
+
+        dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
+                        hdev->state, hdev->maxchild,
+                        /* NOTE: expects max 15 ports... */
+                        (u16) hub->change_bits[0],
+                        (u16) hub->event_bits[0]);
+
+        /* Lock the device, then check to see if we were
+         * disconnected while waiting for the lock to succeed. */
+        usb_lock_device(hdev);
+        if (unlikely(hub->disconnected))
+                goto out_hdev_lock;
+
+        /* If the hub has died, clean up after it */
+        if (hdev->state == USB_STATE_NOTATTACHED) {
+                hub->error = -ENODEV;
+                hub_quiesce(hub, HUB_DISCONNECT);
+                goto out_hdev_lock;
+        }
+
+        /* Autoresume */
+        ret = usb_autopm_get_interface(intf);
+        if (ret) {
+                dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
+                goto out_hdev_lock;
+        }
 
-                /* Grab the first entry at the beginning of the list */
-                spin_lock_irq(&hub_event_lock);
-                if (list_empty(&hub_event_list)) {
-                        spin_unlock_irq(&hub_event_lock);
-                        break;
-                }
+        /* If this is an inactive hub, do nothing */
+        if (hub->quiescing)
+                goto out_autopm;
 
-                tmp = hub_event_list.next;
-                list_del_init(tmp);
-
-                hub = list_entry(tmp, struct usb_hub, event_list);
-                kref_get(&hub->kref);
-                hdev = hub->hdev;
-                usb_get_dev(hdev);
-                spin_unlock_irq(&hub_event_lock);
-
-                hub_dev = hub->intfdev;
-                intf = to_usb_interface(hub_dev);
-                dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
-                                hdev->state, hdev->maxchild,
-                                /* NOTE: expects max 15 ports... */
-                                (u16) hub->change_bits[0],
-                                (u16) hub->event_bits[0]);
-
-                /* Lock the device, then check to see if we were
-                 * disconnected while waiting for the lock to succeed. */
-                usb_lock_device(hdev);
-                if (unlikely(hub->disconnected))
-                        goto loop_disconnected;
-
-                /* If the hub has died, clean up after it */
-                if (hdev->state == USB_STATE_NOTATTACHED) {
-                        hub->error = -ENODEV;
-                        hub_quiesce(hub, HUB_DISCONNECT);
-                        goto loop;
-                }
+        if (hub->error) {
+                dev_dbg(hub_dev, "resetting for error %d\n", hub->error);
 
-                /* Autoresume */
-                ret = usb_autopm_get_interface(intf);
+                ret = usb_reset_device(hdev);
                 if (ret) {
-                        dev_dbg(hub_dev, "Can't autoresume: %d\n", ret);
-                        goto loop;
+                        dev_dbg(hub_dev, "error resetting hub: %d\n", ret);
+                        goto out_autopm;
                 }
 
-                /* If this is an inactive hub, do nothing */
-                if (hub->quiescing)
-                        goto loop_autopm;
-
-                if (hub->error) {
-                        dev_dbg (hub_dev, "resetting for error %d\n",
-                                hub->error);
+                hub->nerrors = 0;
+                hub->error = 0;
+        }
 
-                        ret = usb_reset_device(hdev);
-                        if (ret) {
-                                dev_dbg (hub_dev,
-                                        "error resetting hub: %d\n", ret);
-                                goto loop_autopm;
-                        }
+        /* deal with port status changes */
+        for (i = 1; i <= hdev->maxchild; i++) {
+                struct usb_port *port_dev = hub->ports[i - 1];
 
-                        hub->nerrors = 0;
-                        hub->error = 0;
+                if (test_bit(i, hub->event_bits)
+                                || test_bit(i, hub->change_bits)
+                                || test_bit(i, hub->wakeup_bits)) {
+                        /*
+                         * The get_noresume and barrier ensure that if
+                         * the port was in the process of resuming, we
+                         * flush that work and keep the port active for
+                         * the duration of the port_event().  However,
+                         * if the port is runtime pm suspended
+                         * (powered-off), we leave it in that state, run
+                         * an abbreviated port_event(), and move on.
+                         */
+                        pm_runtime_get_noresume(&port_dev->dev);
+                        pm_runtime_barrier(&port_dev->dev);
+                        usb_lock_port(port_dev);
+                        port_event(hub, i);
+                        usb_unlock_port(port_dev);
+                        pm_runtime_put_sync(&port_dev->dev);
                 }
+        }
 
-                /* deal with port status changes */
-                for (i = 1; i <= hdev->maxchild; i++) {
-                        struct usb_port *port_dev = hub->ports[i - 1];
-
-                        if (test_bit(i, hub->event_bits)
-                                        || test_bit(i, hub->change_bits)
-                                        || test_bit(i, hub->wakeup_bits)) {
-                                /*
-                                 * The get_noresume and barrier ensure that if
-                                 * the port was in the process of resuming, we
-                                 * flush that work and keep the port active for
-                                 * the duration of the port_event().  However,
-                                 * if the port is runtime pm suspended
-                                 * (powered-off), we leave it in that state, run
-                                 * an abbreviated port_event(), and move on.
-                                 */
-                                pm_runtime_get_noresume(&port_dev->dev);
-                                pm_runtime_barrier(&port_dev->dev);
-                                usb_lock_port(port_dev);
-                                port_event(hub, i);
-                                usb_unlock_port(port_dev);
-                                pm_runtime_put_sync(&port_dev->dev);
-                        }
+        /* deal with hub status changes */
+        if (test_and_clear_bit(0, hub->event_bits) == 0)
+                ;       /* do nothing */
+        else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
+                dev_err(hub_dev, "get_hub_status failed\n");
+        else {
+                if (hubchange & HUB_CHANGE_LOCAL_POWER) {
+                        dev_dbg(hub_dev, "power change\n");
+                        clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
+                        if (hubstatus & HUB_STATUS_LOCAL_POWER)
+                                /* FIXME: Is this always true? */
+                                hub->limited_power = 1;
+                        else
+                                hub->limited_power = 0;
                 }
+                if (hubchange & HUB_CHANGE_OVERCURRENT) {
+                        u16 status = 0;
+                        u16 unused;
 
-                /* deal with hub status changes */
-                if (test_and_clear_bit(0, hub->event_bits) == 0)
-                        ;       /* do nothing */
-                else if (hub_hub_status(hub, &hubstatus, &hubchange) < 0)
-                        dev_err (hub_dev, "get_hub_status failed\n");
-                else {
-                        if (hubchange & HUB_CHANGE_LOCAL_POWER) {
-                                dev_dbg (hub_dev, "power change\n");
-                                clear_hub_feature(hdev, C_HUB_LOCAL_POWER);
-                                if (hubstatus & HUB_STATUS_LOCAL_POWER)
-                                        /* FIXME: Is this always true? */
-                                        hub->limited_power = 1;
-                                else
-                                        hub->limited_power = 0;
-                        }
-                        if (hubchange & HUB_CHANGE_OVERCURRENT) {
-                                u16 status = 0;
-                                u16 unused;
-
-                                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_hub_status(hub, &status, &unused);
-                                if (status & HUB_STATUS_OVERCURRENT)
-                                        dev_err(hub_dev, "over-current "
-                                                "condition\n");
-                        }
+                        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_hub_status(hub, &status, &unused);
+                        if (status & HUB_STATUS_OVERCURRENT)
+                                dev_err(hub_dev, "over-current condition\n");
                 }
+        }
 
- loop_autopm:
-                /* Balance the usb_autopm_get_interface() above */
-                usb_autopm_put_interface_no_suspend(intf);
- loop:
-                /* Balance the usb_autopm_get_interface_no_resume() in
-                 * kick_khubd() and allow autosuspend.
-                 */
-                usb_autopm_put_interface(intf);
- loop_disconnected:
-                usb_unlock_device(hdev);
-                usb_put_dev(hdev);
-                kref_put(&hub->kref, hub_release);
-
-        } /* end while (1) */
-}
-
-static int hub_thread(void *__unused)
-{
-        /* khubd needs to be freezable to avoid interfering with USB-PERSIST
-         * port handover.  Otherwise it might see that a full-speed device
-         * was gone before the EHCI controller had handed its port over to
-         * the companion full-speed controller.
-         */
-        set_freezable();
-
-        do {
-                hub_events();
-                wait_event_freezable(khubd_wait,
-                                !list_empty(&hub_event_list) ||
-                                kthread_should_stop());
-        } while (!kthread_should_stop() || !list_empty(&hub_event_list));
+out_autopm:
+        /* Balance the usb_autopm_get_interface() above */
+        usb_autopm_put_interface_no_suspend(intf);
+out_hdev_lock:
+        usb_unlock_device(hdev);
 
-        pr_debug("%s: khubd exiting\n", usbcore_name);
-        return 0;
+        /* Balance the stuff in kick_hub_wq() and allow autosuspend */
+        usb_autopm_put_interface(intf);
+        kref_put(&hub->kref, hub_release);
 }
 
 static const struct usb_device_id hub_id_table[] = {
@@ -5203,20 +5162,26 @@ int usb_hub_init(void)
                 return -1;
         }
 
-        khubd_task = kthread_run(hub_thread, NULL, "khubd");
-        if (!IS_ERR(khubd_task))
+        /*
+         * The workqueue needs to be freezable to avoid interfering with
+         * USB-PERSIST port handover. Otherwise it might see that a full-speed
+         * device was gone before the EHCI controller had handed its port
+         * over to the companion full-speed controller.
+         */
+        hub_wq = alloc_workqueue("usb_hub_wq", WQ_FREEZABLE, 0);
+        if (hub_wq)
                 return 0;
 
         /* Fall through if kernel_thread failed */
         usb_deregister(&hub_driver);
-        printk(KERN_ERR "%s: can't start khubd\n", usbcore_name);
+        pr_err("%s: can't allocate workqueue for usb hub\n", usbcore_name);
 
         return -1;
 }
 
 void usb_hub_cleanup(void)
 {
-        kthread_stop(khubd_task);
+        destroy_workqueue(hub_wq);
 
         /*
          * Hub resources are freed for us by usb_deregister. It calls
@@ -5325,7 +5290,7 @@ static int descriptors_changed(struct usb_device *udev,
  * former operating configuration.  If the reset fails, or the device's
  * descriptors change from their values before the reset, or the original
  * configuration and altsettings cannot be restored, a flag will be set
- * telling khubd to pretend the device has been disconnected and then
+ * telling hub_wq to pretend the device has been disconnected and then
  * re-connected.  All drivers will be unbound, and the device will be
  * re-enumerated and probed all over again.
  *
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index c77d8778af4b..688817fb3246 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -41,7 +41,6 @@ struct usb_hub {
         int                     error;          /* last reported error */
         int                     nerrors;        /* track consecutive errors */
 
-        struct list_head        event_list;     /* hubs w/data or errs ready */
         unsigned long           event_bits[1];  /* status change bitmask */
         unsigned long           change_bits[1]; /* ports with logical connect
                                                         status change */
@@ -77,6 +76,7 @@ struct usb_hub {
         u8                      indicator[USB_MAXCHILDREN];
         struct delayed_work     leds;
         struct delayed_work     init_work;
+        struct work_struct      events;
         struct usb_port         **ports;
 };
 
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 0c8a7fc4dad8..f7b7713cfb2a 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -770,9 +770,7 @@ static int usb_get_langid(struct usb_device *dev, unsigned char *tbuf)
                 dev->string_langid = 0x0409;
                 dev->have_langid = 1;
                 dev_err(&dev->dev,
-                        "string descriptor 0 malformed (err = %d), "
-                        "defaulting to 0x%04x\n",
-                                err, dev->string_langid);
+                        "language id specifier not provided by device, defaulting to English\n");
                 return 0;
         }
 
diff --git a/drivers/usb/core/otg_whitelist.h b/drivers/usb/core/otg_whitelist.h
index e8cdce571bb1..de0c9c9d7091 100644
--- a/drivers/usb/core/otg_whitelist.h
+++ b/drivers/usb/core/otg_whitelist.h
@@ -10,8 +10,8 @@
  */
 
 /*
- * This OTG Whitelist is the OTG "Targeted Peripheral List".  It should
- * mostly use of USB_DEVICE() or USB_DEVICE_VER() entries..
+ * This OTG and Embedded Host Whitelist is "Targeted Peripheral List".
+ * It should mostly use of USB_DEVICE() or USB_DEVICE_VER() entries..
  *
  * YOU _SHOULD_ CHANGE THIS LIST TO MATCH YOUR PRODUCT AND ITS TESTING!
  */
@@ -50,10 +50,6 @@ static int is_targeted(struct usb_device *dev)
 {
         struct usb_device_id    *id = whitelist_table;
 
-        /* possible in developer configs only! */
-        if (!dev->bus->otg_port)
-                return 1;
-
         /* HNP test device is _never_ targeted (see OTG spec 6.6.6) */
         if ((le16_to_cpu(dev->descriptor.idVendor) == 0x1a0a &&
              le16_to_cpu(dev->descriptor.idProduct) == 0xbadd))
@@ -103,10 +99,7 @@ static int is_targeted(struct usb_device *dev)
         dev_err(&dev->dev, "device v%04x p%04x is not supported\n",
                 le16_to_cpu(dev->descriptor.idVendor),
                 le16_to_cpu(dev->descriptor.idProduct));
-#ifdef  CONFIG_USB_OTG_WHITELIST
+
         return 0;
-#else
-        return 1;
-#endif
 }
 
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index bae636e2a1a3..5ae883dc21f5 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -93,6 +93,10 @@ static const struct usb_device_id usb_quirk_list[] = {
         { USB_DEVICE(0x04e8, 0x6601), .driver_info =
                         USB_QUIRK_CONFIG_INTF_STRINGS },
 
+        /* Elan Touchscreen */
+        { USB_DEVICE(0x04f3, 0x0089), .driver_info =
+                        USB_QUIRK_DEVICE_QUALIFIER },
+
         /* Roland SC-8820 */
         { USB_DEVICE(0x0582, 0x0007), .driver_info = USB_QUIRK_RESET_RESUME },
 
@@ -159,6 +163,10 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* USB3503 */
         { USB_DEVICE(0x0424, 0x3503), .driver_info = USB_QUIRK_RESET_RESUME },
 
+        /* ASUS Base Station(T100) */
+        { USB_DEVICE(0x0b05, 0x17e0), .driver_info =
+                        USB_QUIRK_IGNORE_REMOTE_WAKEUP },
+
         { }  /* terminating entry must be last */
 };
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index d9d08720c386..b1b34d0557c9 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -48,7 +48,7 @@ static inline unsigned usb_get_max_power(struct usb_device *udev,
         return c->desc.bMaxPower * mul;
 }
 
-extern void usb_kick_khubd(struct usb_device *dev);
+extern void usb_kick_hub_wq(struct usb_device *dev);
 extern int usb_match_one_id_intf(struct usb_device *dev,
                                  struct usb_host_interface *intf,
                                  const struct usb_device_id *id);
diff --git a/drivers/usb/dwc2/core.c b/drivers/usb/dwc2/core.c
index 27d2c9b8a034..d9269459d481 100644
--- a/drivers/usb/dwc2/core.c
+++ b/drivers/usb/dwc2/core.c
@@ -118,6 +118,7 @@ static int dwc2_core_reset(struct dwc2_hsotg *hsotg)
 {
         u32 greset;
         int count = 0;
+        u32 gusbcfg;
 
         dev_vdbg(hsotg->dev, "%s()\n", __func__);
 
@@ -148,6 +149,23 @@ static int dwc2_core_reset(struct dwc2_hsotg *hsotg)
                 }
         } while (greset & GRSTCTL_CSFTRST);
 
+        if (hsotg->dr_mode == USB_DR_MODE_HOST) {
+                gusbcfg = readl(hsotg->regs + GUSBCFG);
+                gusbcfg &= ~GUSBCFG_FORCEDEVMODE;
+                gusbcfg |= GUSBCFG_FORCEHOSTMODE;
+                writel(gusbcfg, hsotg->regs + GUSBCFG);
+        } else if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL) {
+                gusbcfg = readl(hsotg->regs + GUSBCFG);
+                gusbcfg &= ~GUSBCFG_FORCEHOSTMODE;
+                gusbcfg |= GUSBCFG_FORCEDEVMODE;
+                writel(gusbcfg, hsotg->regs + GUSBCFG);
+        } else if (hsotg->dr_mode == USB_DR_MODE_OTG) {
+                gusbcfg = readl(hsotg->regs + GUSBCFG);
+                gusbcfg &= ~GUSBCFG_FORCEHOSTMODE;
+                gusbcfg &= ~GUSBCFG_FORCEDEVMODE;
+                writel(gusbcfg, hsotg->regs + GUSBCFG);
+        }
+
         /*
          * NOTE: This long sleep is _very_ important, otherwise the core will
          * not stay in host mode after a connector ID change!
@@ -2674,23 +2692,23 @@ int dwc2_get_hwparams(struct dwc2_hsotg *hsotg)
         hwcfg2 = readl(hsotg->regs + GHWCFG2);
         hwcfg3 = readl(hsotg->regs + GHWCFG3);
         hwcfg4 = readl(hsotg->regs + GHWCFG4);
-        gnptxfsiz = readl(hsotg->regs + GNPTXFSIZ);
         grxfsiz = readl(hsotg->regs + GRXFSIZ);
 
         dev_dbg(hsotg->dev, "hwcfg1=%08x\n", hwcfg1);
         dev_dbg(hsotg->dev, "hwcfg2=%08x\n", hwcfg2);
         dev_dbg(hsotg->dev, "hwcfg3=%08x\n", hwcfg3);
         dev_dbg(hsotg->dev, "hwcfg4=%08x\n", hwcfg4);
-        dev_dbg(hsotg->dev, "gnptxfsiz=%08x\n", gnptxfsiz);
         dev_dbg(hsotg->dev, "grxfsiz=%08x\n", grxfsiz);
 
-        /* Force host mode to get HPTXFSIZ exact power on value */
+        /* Force host mode to get HPTXFSIZ / GNPTXFSIZ exact power on value */
         gusbcfg = readl(hsotg->regs + GUSBCFG);
         gusbcfg |= GUSBCFG_FORCEHOSTMODE;
         writel(gusbcfg, hsotg->regs + GUSBCFG);
         usleep_range(100000, 150000);
 
+        gnptxfsiz = readl(hsotg->regs + GNPTXFSIZ);
         hptxfsiz = readl(hsotg->regs + HPTXFSIZ);
+        dev_dbg(hsotg->dev, "gnptxfsiz=%08x\n", gnptxfsiz);
         dev_dbg(hsotg->dev, "hptxfsiz=%08x\n", hptxfsiz);
         gusbcfg = readl(hsotg->regs + GUSBCFG);
         gusbcfg &= ~GUSBCFG_FORCEHOSTMODE;
@@ -2725,6 +2743,13 @@ int dwc2_get_hwparams(struct dwc2_hsotg *hsotg)
         width = (hwcfg3 & GHWCFG3_XFER_SIZE_CNTR_WIDTH_MASK) >>
                 GHWCFG3_XFER_SIZE_CNTR_WIDTH_SHIFT;
         hw->max_transfer_size = (1 << (width + 11)) - 1;
+        /*
+         * Clip max_transfer_size to 65535. dwc2_hc_setup_align_buf() allocates
+         * coherent buffers with this size, and if it's too large we can
+         * exhaust the coherent DMA pool.
+         */
+        if (hw->max_transfer_size > 65535)
+                hw->max_transfer_size = 65535;
         width = (hwcfg3 & GHWCFG3_PACKET_SIZE_CNTR_WIDTH_MASK) >>
                 GHWCFG3_PACKET_SIZE_CNTR_WIDTH_SHIFT;
         hw->max_packet_count = (1 << (width + 4)) - 1;
diff --git a/drivers/usb/dwc2/core.h b/drivers/usb/dwc2/core.h
index 1efd10cc9629..bf015ab3b44c 100644
--- a/drivers/usb/dwc2/core.h
+++ b/drivers/usb/dwc2/core.h
@@ -139,6 +139,7 @@ struct s3c_hsotg_ep {
         unsigned int            last_load;
         unsigned int            fifo_load;
         unsigned short          fifo_size;
+        unsigned short          fifo_index;
 
         unsigned char           dir_in;
         unsigned char           index;
@@ -194,8 +195,10 @@ struct s3c_hsotg {
         struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
 
         u32                     phyif;
+        int                     fifo_mem;
         unsigned int            dedicated_fifos:1;
         unsigned char           num_of_eps;
+        u32                     fifo_map;
 
         struct dentry           *debug_root;
         struct dentry           *debug_file;
@@ -501,6 +504,10 @@ struct dwc2_hw_params {
  *                      a_peripheral and b_device=>b_host) this may not match
  *                      the core, but allows the software to determine
  *                      transitions
+ * @dr_mode:            Requested mode of operation, one of following:
+ *                      - USB_DR_MODE_PERIPHERAL
+ *                      - USB_DR_MODE_HOST
+ *                      - USB_DR_MODE_OTG
  * @queuing_high_bandwidth: True if multiple packets of a high-bandwidth
  *                      transfer are in process of being queued
  * @srp_success:        Stores status of SRP request in the case of a FS PHY
@@ -592,6 +599,7 @@ struct dwc2_hsotg {
         /** Params to actually use */
         struct dwc2_core_params *core_params;
         enum usb_otg_state op_state;
+        enum usb_dr_mode dr_mode;
 
         unsigned int queuing_high_bandwidth:1;
         unsigned int srp_success:1;
diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c
index ce6071d65d51..7b5856fadd93 100644
--- a/drivers/usb/dwc2/gadget.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -182,16 +182,33 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
 
         /* start at the end of the GNPTXFSIZ, rounded up */
         addr = 2048 + 1024;
-        size = 768;
 
         /*
-         * currently we allocate TX FIFOs for all possible endpoints,
-         * and assume that they are all the same size.
+         * Because we have not enough memory to have each TX FIFO of size at
+         * least 3072 bytes (the maximum single packet size), we create four
+         * FIFOs of lenght 1024, and four of length 3072 bytes, and assing
+         * them to endpoints dynamically according to maxpacket size value of
+         * given endpoint.
          */
 
-        for (ep = 1; ep <= 15; ep++) {
+        /* 256*4=1024 bytes FIFO length */
+        size = 256;
+        for (ep = 1; ep <= 4; ep++) {
                 val = addr;
                 val |= size << FIFOSIZE_DEPTH_SHIFT;
+                WARN_ONCE(addr + size > hsotg->fifo_mem,
+                          "insufficient fifo memory");
+                addr += size;
+
+                writel(val, hsotg->regs + DPTXFSIZN(ep));
+        }
+        /* 768*4=3072 bytes FIFO length */
+        size = 768;
+        for (ep = 5; ep <= 8; ep++) {
+                val = addr;
+                val |= size << FIFOSIZE_DEPTH_SHIFT;
+                WARN_ONCE(addr + size > hsotg->fifo_mem,
+                          "insufficient fifo memory");
                 addr += size;
 
                 writel(val, hsotg->regs + DPTXFSIZN(ep));
@@ -987,8 +1004,8 @@ static int s3c_hsotg_process_req_feature(struct s3c_hsotg *hsotg,
                                         hs_req = ep->req;
                                         ep->req = NULL;
                                         list_del_init(&hs_req->queue);
-                                        hs_req->req.complete(&ep->ep,
-                                                             &hs_req->req);
+                                        usb_gadget_giveback_request(&ep->ep,
+                                                                    &hs_req->req);
                                 }
 
                                 /* If we have pending request, then start it */
@@ -1245,7 +1262,7 @@ static void s3c_hsotg_complete_request(struct s3c_hsotg *hsotg,
 
         if (hs_req->req.complete) {
                 spin_unlock(&hsotg->lock);
-                hs_req->req.complete(&hs_ep->ep, &hs_req->req);
+                usb_gadget_giveback_request(&hs_ep->ep, &hs_req->req);
                 spin_lock(&hsotg->lock);
         }
 
@@ -1832,7 +1849,7 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 if (dir_in) {
                         int epctl = readl(hsotg->regs + epctl_reg);
 
-                        s3c_hsotg_txfifo_flush(hsotg, idx);
+                        s3c_hsotg_txfifo_flush(hsotg, hs_ep->fifo_index);
 
                         if ((epctl & DXEPCTL_STALL) &&
                                 (epctl & DXEPCTL_EPTYPE_BULK)) {
@@ -1981,6 +1998,7 @@ static void kill_all_requests(struct s3c_hsotg *hsotg,
                               int result, bool force)
 {
         struct s3c_hsotg_req *req, *treq;
+        unsigned size;
 
         list_for_each_entry_safe(req, treq, &ep->queue, queue) {
                 /*
@@ -1994,9 +2012,11 @@ static void kill_all_requests(struct s3c_hsotg *hsotg,
                 s3c_hsotg_complete_request(hsotg, ep, req,
                                            result);
         }
-        if (hsotg->dedicated_fifos)
-                if ((readl(hsotg->regs + DTXFSTS(ep->index)) & 0xffff) * 4 < 3072)
-                        s3c_hsotg_txfifo_flush(hsotg, ep->index);
+        if (!hsotg->dedicated_fifos)
+                return;
+        size = (readl(hsotg->regs + DTXFSTS(ep->index)) & 0xffff) * 4;
+        if (size < ep->fifo_size)
+                s3c_hsotg_txfifo_flush(hsotg, ep->fifo_index);
 }
 
 /**
@@ -2437,6 +2457,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
         u32 epctrl;
         u32 mps;
         int dir_in;
+        int i, val, size;
         int ret = 0;
 
         dev_dbg(hsotg->dev,
@@ -2509,17 +2530,8 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
                 break;
 
         case USB_ENDPOINT_XFER_INT:
-                if (dir_in) {
-                        /*
-                         * Allocate our TxFNum by simply using the index
-                         * of the endpoint for the moment. We could do
-                         * something better if the host indicates how
-                         * many FIFOs we are expecting to use.
-                         */
-
+                if (dir_in)
                         hs_ep->periodic = 1;
-                        epctrl |= DXEPCTL_TXFNUM(index);
-                }
 
                 epctrl |= DXEPCTL_EPTYPE_INTERRUPT;
                 break;
@@ -2533,8 +2545,25 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
          * if the hardware has dedicated fifos, we must give each IN EP
          * a unique tx-fifo even if it is non-periodic.
          */
-        if (dir_in && hsotg->dedicated_fifos)
-                epctrl |= DXEPCTL_TXFNUM(index);
+        if (dir_in && hsotg->dedicated_fifos) {
+                size = hs_ep->ep.maxpacket*hs_ep->mc;
+                for (i = 1; i <= 8; ++i) {
+                        if (hsotg->fifo_map & (1<<i))
+                                continue;
+                        val = readl(hsotg->regs + DPTXFSIZN(i));
+                        val = (val >> FIFOSIZE_DEPTH_SHIFT)*4;
+                        if (val < size)
+                                continue;
+                        hsotg->fifo_map |= 1<<i;
+
+                        epctrl |= DXEPCTL_TXFNUM(i);
+                        hs_ep->fifo_index = i;
+                        hs_ep->fifo_size = val;
+                        break;
+                }
+                if (i == 8)
+                        return -ENOMEM;
+        }
 
         /* for non control endpoints, set PID to D0 */
         if (index)
@@ -2568,7 +2597,7 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
         u32 epctrl_reg;
         u32 ctrl;
 
-        dev_info(hsotg->dev, "%s(ep %p)\n", __func__, ep);
+        dev_dbg(hsotg->dev, "%s(ep %p)\n", __func__, ep);
 
         if (ep == &hsotg->eps[0].ep) {
                 dev_err(hsotg->dev, "%s: called for ep0\n", __func__);
@@ -2581,6 +2610,9 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
         /* terminate all requests with shutdown */
         kill_all_requests(hsotg, hs_ep, -ESHUTDOWN, false);
 
+        hsotg->fifo_map &= ~(1<<hs_ep->fifo_index);
+        hs_ep->fifo_index = 0;
+        hs_ep->fifo_size = 0;
 
         ctrl = readl(hsotg->regs + epctrl_reg);
         ctrl &= ~DXEPCTL_EPENA;
@@ -2626,7 +2658,7 @@ static int s3c_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
         struct s3c_hsotg *hs = hs_ep->parent;
         unsigned long flags;
 
-        dev_info(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
+        dev_dbg(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
 
         spin_lock_irqsave(&hs->lock, flags);
 
@@ -2861,6 +2893,8 @@ static int s3c_hsotg_udc_start(struct usb_gadget *gadget,
         hsotg->gadget.dev.of_node = hsotg->dev->of_node;
         hsotg->gadget.speed = USB_SPEED_UNKNOWN;
 
+        clk_enable(hsotg->clk);
+
         ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
                                     hsotg->supplies);
         if (ret) {
@@ -2909,6 +2943,8 @@ static int s3c_hsotg_udc_stop(struct usb_gadget *gadget,
 
         regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
 
+        clk_disable(hsotg->clk);
+
         return 0;
 }
 
@@ -2935,13 +2971,15 @@ static int s3c_hsotg_pullup(struct usb_gadget *gadget, int is_on)
         struct s3c_hsotg *hsotg = to_hsotg(gadget);
         unsigned long flags = 0;
 
-        dev_dbg(hsotg->dev, "%s: is_in: %d\n", __func__, is_on);
+        dev_dbg(hsotg->dev, "%s: is_on: %d\n", __func__, is_on);
 
         spin_lock_irqsave(&hsotg->lock, flags);
         if (is_on) {
                 s3c_hsotg_phy_enable(hsotg);
+                clk_enable(hsotg->clk);
                 s3c_hsotg_core_init(hsotg);
         } else {
+                clk_disable(hsotg->clk);
                 s3c_hsotg_phy_disable(hsotg);
         }
 
@@ -2972,7 +3010,6 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
                                        struct s3c_hsotg_ep *hs_ep,
                                        int epnum)
 {
-        u32 ptxfifo;
         char *dir;
 
         if (epnum == 0)
@@ -3001,15 +3038,6 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
         hs_ep->ep.ops = &s3c_hsotg_ep_ops;
 
         /*
-         * Read the FIFO size for the Periodic TX FIFO, even if we're
-         * an OUT endpoint, we may as well do this if in future the
-         * code is changed to make each endpoint's direction changeable.
-         */
-
-        ptxfifo = readl(hsotg->regs + DPTXFSIZN(epnum));
-        hs_ep->fifo_size = FIFOSIZE_DEPTH_GET(ptxfifo) * 4;
-
-        /*
          * if we're using dma, we need to set the next-endpoint pointer
          * to be something valid.
          */
@@ -3029,19 +3057,22 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
  */
 static void s3c_hsotg_hw_cfg(struct s3c_hsotg *hsotg)
 {
-        u32 cfg2, cfg4;
+        u32 cfg2, cfg3, cfg4;
         /* check hardware configuration */
 
         cfg2 = readl(hsotg->regs + 0x48);
         hsotg->num_of_eps = (cfg2 >> 10) & 0xF;
 
-        dev_info(hsotg->dev, "EPs:%d\n", hsotg->num_of_eps);
+        cfg3 = readl(hsotg->regs + 0x4C);
+        hsotg->fifo_mem = (cfg3 >> 16);
 
         cfg4 = readl(hsotg->regs + 0x50);
         hsotg->dedicated_fifos = (cfg4 >> 25) & 1;
 
-        dev_info(hsotg->dev, "%s fifos\n",
-                 hsotg->dedicated_fifos ? "dedicated" : "shared");
+        dev_info(hsotg->dev, "EPs: %d, %s fifos, %d entries in SPRAM\n",
+                 hsotg->num_of_eps,
+                 hsotg->dedicated_fifos ? "dedicated" : "shared",
+                 hsotg->fifo_mem);
 }
 
 /**
@@ -3392,6 +3423,9 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
         if (!hsotg)
                 return -ENOMEM;
 
+        /* Set default UTMI width */
+        hsotg->phyif = GUSBCFG_PHYIF16;
+
         /*
          * Attempt to find a generic PHY, then look for an old style
          * USB PHY, finally fall back to pdata
@@ -3410,8 +3444,15 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
                         hsotg->plat = plat;
                 } else
                         hsotg->uphy = uphy;
-        } else
+        } else {
                 hsotg->phy = phy;
+                /*
+                 * If using the generic PHY framework, check if the PHY bus
+                 * width is 8-bit and set the phyif appropriately.
+                 */
+                if (phy_get_bus_width(phy) == 8)
+                        hsotg->phyif = GUSBCFG_PHYIF8;
+        }
 
         hsotg->dev = dev;
 
@@ -3471,22 +3512,12 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
                 goto err_supplies;
         }
 
-        /* Set default UTMI width */
-        hsotg->phyif = GUSBCFG_PHYIF16;
-
-        /*
-         * If using the generic PHY framework, check if the PHY bus
-         * width is 8-bit and set the phyif appropriately.
-         */
-        if (hsotg->phy && (phy_get_bus_width(phy) == 8))
-                hsotg->phyif = GUSBCFG_PHYIF8;
-
         /* usb phy enable */
         s3c_hsotg_phy_enable(hsotg);
 
         s3c_hsotg_corereset(hsotg);
-        s3c_hsotg_init(hsotg);
         s3c_hsotg_hw_cfg(hsotg);
+        s3c_hsotg_init(hsotg);
 
         ret = devm_request_irq(&pdev->dev, hsotg->irq, s3c_hsotg_irq, 0,
                                 dev_name(dev), hsotg);
@@ -3611,6 +3642,7 @@ static int s3c_hsotg_suspend(struct platform_device *pdev, pm_message_t state)
 
                 ret = regulator_bulk_disable(ARRAY_SIZE(hsotg->supplies),
                                              hsotg->supplies);
+                clk_disable(hsotg->clk);
         }
 
         return ret;
@@ -3625,6 +3657,8 @@ static int s3c_hsotg_resume(struct platform_device *pdev)
         if (hsotg->driver) {
                 dev_info(hsotg->dev, "resuming usb gadget %s\n",
                          hsotg->driver->driver.name);
+
+                clk_enable(hsotg->clk);
                 ret = regulator_bulk_enable(ARRAY_SIZE(hsotg->supplies),
                                       hsotg->supplies);
         }
diff --git a/drivers/usb/dwc2/hcd.c b/drivers/usb/dwc2/hcd.c
index 4d918ed8d343..0a0e6f0ad15f 100644
--- a/drivers/usb/dwc2/hcd.c
+++ b/drivers/usb/dwc2/hcd.c
@@ -697,29 +697,45 @@ static void *dwc2_hc_init_xfer(struct dwc2_hsotg *hsotg,
 }
 
 static int dwc2_hc_setup_align_buf(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh,
-                                   struct dwc2_host_chan *chan, void *bufptr)
+                                   struct dwc2_host_chan *chan,
+                                   struct dwc2_hcd_urb *urb, void *bufptr)
 {
         u32 buf_size;
-
-        if (chan->ep_type != USB_ENDPOINT_XFER_ISOC)
-                buf_size = hsotg->core_params->max_transfer_size;
-        else
-                buf_size = 4096;
+        struct urb *usb_urb;
+        struct usb_hcd *hcd;
 
         if (!qh->dw_align_buf) {
+                if (chan->ep_type != USB_ENDPOINT_XFER_ISOC)
+                        buf_size = hsotg->core_params->max_transfer_size;
+                else
+                        /* 3072 = 3 max-size Isoc packets */
+                        buf_size = 3072;
+
                 qh->dw_align_buf = dma_alloc_coherent(hsotg->dev, buf_size,
                                                       &qh->dw_align_buf_dma,
                                                       GFP_ATOMIC);
                 if (!qh->dw_align_buf)
                         return -ENOMEM;
+                qh->dw_align_buf_size = buf_size;
         }
 
-        if (!chan->ep_is_in && chan->xfer_len) {
-                dma_sync_single_for_cpu(hsotg->dev, chan->xfer_dma, buf_size,
-                                        DMA_TO_DEVICE);
-                memcpy(qh->dw_align_buf, bufptr, chan->xfer_len);
-                dma_sync_single_for_device(hsotg->dev, chan->xfer_dma, buf_size,
-                                           DMA_TO_DEVICE);
+        if (chan->xfer_len) {
+                dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n", __func__);
+                usb_urb = urb->priv;
+
+                if (usb_urb) {
+                        if (usb_urb->transfer_flags &
+                            (URB_SETUP_MAP_SINGLE | URB_DMA_MAP_SG |
+                             URB_DMA_MAP_PAGE | URB_DMA_MAP_SINGLE)) {
+                                hcd = dwc2_hsotg_to_hcd(hsotg);
+                                usb_hcd_unmap_urb_for_dma(hcd, usb_urb);
+                        }
+                        if (!chan->ep_is_in)
+                                memcpy(qh->dw_align_buf, bufptr,
+                                       chan->xfer_len);
+                } else {
+                        dev_warn(hsotg->dev, "no URB in dwc2_urb\n");
+                }
         }
 
         chan->align_buf = qh->dw_align_buf_dma;
@@ -828,7 +844,7 @@ static int dwc2_assign_and_init_hc(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh)
         /* Non DWORD-aligned buffer case */
         if (bufptr) {
                 dev_vdbg(hsotg->dev, "Non-aligned buffer\n");
-                if (dwc2_hc_setup_align_buf(hsotg, qh, chan, bufptr)) {
+                if (dwc2_hc_setup_align_buf(hsotg, qh, chan, urb, bufptr)) {
                         dev_err(hsotg->dev,
                                 "%s: Failed to allocate memory to handle non-dword aligned buffer\n",
                                 __func__);
diff --git a/drivers/usb/dwc2/hcd.h b/drivers/usb/dwc2/hcd.h
index fdc6d489084a..a12bb1538666 100644
--- a/drivers/usb/dwc2/hcd.h
+++ b/drivers/usb/dwc2/hcd.h
@@ -243,7 +243,8 @@ enum dwc2_transaction_type {
  * @ntd:                Actual number of transfer descriptors in a list
  * @dw_align_buf:       Used instead of original buffer if its physical address
  *                      is not dword-aligned
- * @dw_align_buf_dma:   DMA address for align_buf
+ * @dw_align_buf_size:  Size of dw_align_buf
+ * @dw_align_buf_dma:   DMA address for dw_align_buf
  * @qtd_list:           List of QTDs for this QH
  * @channel:            Host channel currently processing transfers for this QH
  * @qh_list_entry:      Entry for QH in either the periodic or non-periodic
@@ -276,6 +277,7 @@ struct dwc2_qh {
         u16 start_split_frame;
         u16 ntd;
         u8 *dw_align_buf;
+        int dw_align_buf_size;
         dma_addr_t dw_align_buf_dma;
         struct list_head qtd_list;
         struct dwc2_host_chan *channel;
diff --git a/drivers/usb/dwc2/hcd_intr.c b/drivers/usb/dwc2/hcd_intr.c
index 47b9eb5389b4..551ba878b003 100644
--- a/drivers/usb/dwc2/hcd_intr.c
+++ b/drivers/usb/dwc2/hcd_intr.c
@@ -465,12 +465,8 @@ static int dwc2_update_urb_state(struct dwc2_hsotg *hsotg,
         /* Non DWORD-aligned buffer case handling */
         if (chan->align_buf && xfer_length && chan->ep_is_in) {
                 dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n", __func__);
-                dma_sync_single_for_cpu(hsotg->dev, urb->dma, urb->length,
-                                        DMA_FROM_DEVICE);
                 memcpy(urb->buf + urb->actual_length, chan->qh->dw_align_buf,
                        xfer_length);
-                dma_sync_single_for_device(hsotg->dev, urb->dma, urb->length,
-                                           DMA_FROM_DEVICE);
         }
 
         dev_vdbg(hsotg->dev, "urb->actual_length=%d xfer_length=%d\n",
@@ -560,14 +556,9 @@ static enum dwc2_halt_status dwc2_update_isoc_urb_state(
                     chan->ep_is_in) {
                         dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n",
                                  __func__);
-                        dma_sync_single_for_cpu(hsotg->dev, urb->dma,
-                                                urb->length, DMA_FROM_DEVICE);
                         memcpy(urb->buf + frame_desc->offset +
                                qtd->isoc_split_offset, chan->qh->dw_align_buf,
                                frame_desc->actual_length);
-                        dma_sync_single_for_device(hsotg->dev, urb->dma,
-                                                   urb->length,
-                                                   DMA_FROM_DEVICE);
                 }
                 break;
         case DWC2_HC_XFER_FRAME_OVERRUN:
@@ -594,14 +585,9 @@ static enum dwc2_halt_status dwc2_update_isoc_urb_state(
                     chan->ep_is_in) {
                         dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n",
                                  __func__);
-                        dma_sync_single_for_cpu(hsotg->dev, urb->dma,
-                                                urb->length, DMA_FROM_DEVICE);
                         memcpy(urb->buf + frame_desc->offset +
                                qtd->isoc_split_offset, chan->qh->dw_align_buf,
                                frame_desc->actual_length);
-                        dma_sync_single_for_device(hsotg->dev, urb->dma,
-                                                   urb->length,
-                                                   DMA_FROM_DEVICE);
                 }
 
                 /* Skip whole frame */
@@ -937,12 +923,8 @@ static int dwc2_xfercomp_isoc_split_in(struct dwc2_hsotg *hsotg,
 
         if (chan->align_buf) {
                 dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n", __func__);
-                dma_sync_single_for_cpu(hsotg->dev, qtd->urb->dma,
-                                        qtd->urb->length, DMA_FROM_DEVICE);
                 memcpy(qtd->urb->buf + frame_desc->offset +
                        qtd->isoc_split_offset, chan->qh->dw_align_buf, len);
-                dma_sync_single_for_device(hsotg->dev, qtd->urb->dma,
-                                           qtd->urb->length, DMA_FROM_DEVICE);
         }
 
         qtd->isoc_split_offset += len;
@@ -1170,12 +1152,8 @@ static void dwc2_update_urb_state_abn(struct dwc2_hsotg *hsotg,
         /* Non DWORD-aligned buffer case handling */
         if (chan->align_buf && xfer_length && chan->ep_is_in) {
                 dev_vdbg(hsotg->dev, "%s(): non-aligned buffer\n", __func__);
-                dma_sync_single_for_cpu(hsotg->dev, urb->dma, urb->length,
-                                        DMA_FROM_DEVICE);
                 memcpy(urb->buf + urb->actual_length, chan->qh->dw_align_buf,
                        xfer_length);
-                dma_sync_single_for_device(hsotg->dev, urb->dma, urb->length,
-                                           DMA_FROM_DEVICE);
         }
 
         urb->actual_length += xfer_length;
@@ -1890,12 +1868,20 @@ static void dwc2_hc_chhltd_intr_dma(struct dwc2_hsotg *hsotg,
                                         "hcint 0x%08x, intsts 0x%08x\n",
                                         chan->hcint,
                                         readl(hsotg->regs + GINTSTS));
+                                goto error;
                         }
                 }
         } else {
                 dev_info(hsotg->dev,
                          "NYET/NAK/ACK/other in non-error case, 0x%08x\n",
                          chan->hcint);
+error:
+                /* Failthrough: use 3-strikes rule */
+                qtd->error_count++;
+                dwc2_update_urb_state_abn(hsotg, chan, chnum, qtd->urb,
+                                          qtd, DWC2_HC_XFER_XACT_ERR);
+                dwc2_hcd_save_data_toggle(hsotg, chan, chnum, qtd);
+                dwc2_halt_channel(hsotg, chan, qtd, DWC2_HC_XFER_XACT_ERR);
         }
 }
 
diff --git a/drivers/usb/dwc2/hcd_queue.c b/drivers/usb/dwc2/hcd_queue.c
index 9540f7e1e20e..bb97838bc6c0 100644
--- a/drivers/usb/dwc2/hcd_queue.c
+++ b/drivers/usb/dwc2/hcd_queue.c
@@ -229,19 +229,11 @@ static struct dwc2_qh *dwc2_hcd_qh_create(struct dwc2_hsotg *hsotg,
  */
 void dwc2_hcd_qh_free(struct dwc2_hsotg *hsotg, struct dwc2_qh *qh)
 {
-        u32 buf_size;
-
-        if (hsotg->core_params->dma_desc_enable > 0) {
+        if (hsotg->core_params->dma_desc_enable > 0)
                 dwc2_hcd_qh_free_ddma(hsotg, qh);
-        } else if (qh->dw_align_buf) {
-                if (qh->ep_type == USB_ENDPOINT_XFER_ISOC)
-                        buf_size = 4096;
-                else
-                        buf_size = hsotg->core_params->max_transfer_size;
-                dma_free_coherent(hsotg->dev, buf_size, qh->dw_align_buf,
-                                  qh->dw_align_buf_dma);
-        }
-
+        else if (qh->dw_align_buf)
+                dma_free_coherent(hsotg->dev, qh->dw_align_buf_size,
+                                  qh->dw_align_buf, qh->dw_align_buf_dma);
         kfree(qh);
 }
 
diff --git a/drivers/usb/dwc2/platform.c b/drivers/usb/dwc2/platform.c
index a10e7a353576..121dbdafc06b 100644
--- a/drivers/usb/dwc2/platform.c
+++ b/drivers/usb/dwc2/platform.c
@@ -42,6 +42,8 @@
 #include <linux/of_device.h>
 #include <linux/platform_device.h>
 
+#include <linux/usb/of.h>
+
 #include "core.h"
 #include "hcd.h"
 
@@ -75,6 +77,34 @@ static const struct dwc2_core_params params_bcm2835 = {
         .uframe_sched                   = 0,
 };
 
+static const struct dwc2_core_params params_rk3066 = {
+        .otg_cap                        = 2,    /* non-HNP/non-SRP */
+        .otg_ver                        = -1,
+        .dma_enable                     = -1,
+        .dma_desc_enable                = 0,
+        .speed                          = -1,
+        .enable_dynamic_fifo            = 1,
+        .en_multiple_tx_fifo            = -1,
+        .host_rx_fifo_size              = 520,  /* 520 DWORDs */
+        .host_nperio_tx_fifo_size       = 128,  /* 128 DWORDs */
+        .host_perio_tx_fifo_size        = 256,  /* 256 DWORDs */
+        .max_transfer_size              = 65535,
+        .max_packet_count               = -1,
+        .host_channels                  = -1,
+        .phy_type                       = -1,
+        .phy_utmi_width                 = -1,
+        .phy_ulpi_ddr                   = -1,
+        .phy_ulpi_ext_vbus              = -1,
+        .i2c_enable                     = -1,
+        .ulpi_fs_ls                     = -1,
+        .host_support_fs_ls_low_power   = -1,
+        .host_ls_low_power_phy_clk      = -1,
+        .ts_dline                       = -1,
+        .reload_ctl                     = -1,
+        .ahbcfg                         = 0x7, /* INCR16 */
+        .uframe_sched                   = -1,
+};
+
 /**
  * dwc2_driver_remove() - Called when the DWC_otg core is unregistered with the
  * DWC_otg driver
@@ -97,6 +127,7 @@ static int dwc2_driver_remove(struct platform_device *dev)
 
 static const struct of_device_id dwc2_of_match_table[] = {
         { .compatible = "brcm,bcm2835-usb", .data = &params_bcm2835 },
+        { .compatible = "rockchip,rk3066-usb", .data = &params_rk3066 },
         { .compatible = "snps,dwc2", .data = NULL },
         {},
 };
@@ -171,6 +202,8 @@ static int dwc2_driver_probe(struct platform_device *dev)
         dev_dbg(&dev->dev, "mapped PA %08lx to VA %p\n",
                 (unsigned long)res->start, hsotg->regs);
 
+        hsotg->dr_mode = of_usb_get_dr_mode(dev->dev.of_node);
+
         retval = dwc2_hcd_init(hsotg, irq, params);
         if (retval)
                 return retval;
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index 785510a0a0c3..f4e5cc60db0b 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -80,6 +80,23 @@ config USB_DWC3_KEYSTONE
           Support of USB2/3 functionality in TI Keystone2 platforms.
           Say 'Y' or 'M' here if you have one such device
 
+config USB_DWC3_ST
+        tristate "STMicroelectronics Platforms"
+        depends on ARCH_STI && OF
+        default USB_DWC3
+        help
+          STMicroelectronics SoCs with one DesignWare Core USB3 IP
+          inside (i.e. STiH407).
+          Say 'Y' or 'M' if you have one such device.
+
+config USB_DWC3_QCOM
+        tristate "Qualcomm Platforms"
+        depends on ARCH_QCOM || COMPILE_TEST
+        default USB_DWC3
+        help
+          Recent Qualcomm SoCs ship with one DesignWare Core USB3 IP inside,
+          say 'Y' or 'M' if you have one such device.
+
 comment "Debugging features"
 
 config USB_DWC3_DEBUG
diff --git a/drivers/usb/dwc3/Makefile b/drivers/usb/dwc3/Makefile
index 10ac3e72482e..bb34fbcfeab3 100644
--- a/drivers/usb/dwc3/Makefile
+++ b/drivers/usb/dwc3/Makefile
@@ -1,9 +1,12 @@
+# define_trace.h needs to know how to find our header
+CFLAGS_trace.o                          := -I$(src)
+
 ccflags-$(CONFIG_USB_DWC3_DEBUG)        := -DDEBUG
 ccflags-$(CONFIG_USB_DWC3_VERBOSE)      += -DVERBOSE_DEBUG
 
 obj-$(CONFIG_USB_DWC3)                  += dwc3.o
 
-dwc3-y                                  := core.o
+dwc3-y                                  := core.o debug.o trace.o
 
 ifneq ($(filter y,$(CONFIG_USB_DWC3_HOST) $(CONFIG_USB_DWC3_DUAL_ROLE)),)
         dwc3-y                          += host.o
@@ -33,3 +36,5 @@ obj-$(CONFIG_USB_DWC3_OMAP)		+= dwc3-omap.o
 obj-$(CONFIG_USB_DWC3_EXYNOS)           += dwc3-exynos.o
 obj-$(CONFIG_USB_DWC3_PCI)              += dwc3-pci.o
 obj-$(CONFIG_USB_DWC3_KEYSTONE)         += dwc3-keystone.o
+obj-$(CONFIG_USB_DWC3_QCOM)             += dwc3-qcom.o
+obj-$(CONFIG_USB_DWC3_ST)               += dwc3-st.o
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 9069984fe5cf..b0f4d52b7f04 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -186,10 +186,8 @@ static int dwc3_alloc_event_buffers(struct dwc3 *dwc, unsigned length)
 
         dwc->ev_buffs = devm_kzalloc(dwc->dev, sizeof(*dwc->ev_buffs) * num,
                         GFP_KERNEL);
-        if (!dwc->ev_buffs) {
-                dev_err(dwc->dev, "can't allocate event buffers array\n");
+        if (!dwc->ev_buffs)
                 return -ENOMEM;
-        }
 
         for (i = 0; i < num; i++) {
                 struct dwc3_event_buffer        *evt;
@@ -639,10 +637,9 @@ static int dwc3_probe(struct platform_device *pdev)
         void                    *mem;
 
         mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
-        if (!mem) {
-                dev_err(dev, "not enough memory\n");
+        if (!mem)
                 return -ENOMEM;
-        }
+
         dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
         dwc->mem = mem;
         dwc->dev = dev;
diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h
index 48fb264065db..66f62563bcf9 100644
--- a/drivers/usb/dwc3/core.h
+++ b/drivers/usb/dwc3/core.h
@@ -33,6 +33,8 @@
 
 #include <linux/phy/phy.h>
 
+#define DWC3_MSG_MAX    500
+
 /* Global constants */
 #define DWC3_EP0_BOUNCE_SIZE    512
 #define DWC3_ENDPOINTS_NUM      32
@@ -938,7 +940,7 @@ int dwc3_gadget_get_link_state(struct dwc3 *dwc);
 int dwc3_gadget_set_link_state(struct dwc3 *dwc, enum dwc3_link_state state);
 int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep,
                 unsigned cmd, struct dwc3_gadget_ep_cmd_params *params);
-int dwc3_send_gadget_generic_command(struct dwc3 *dwc, int cmd, u32 param);
+int dwc3_send_gadget_generic_command(struct dwc3 *dwc, unsigned cmd, u32 param);
 #else
 static inline int dwc3_gadget_init(struct dwc3 *dwc)
 { return 0; }
diff --git a/drivers/usb/dwc3/debug.c b/drivers/usb/dwc3/debug.c
new file mode 100644
index 000000000000..0be6885bc370
--- /dev/null
+++ b/drivers/usb/dwc3/debug.c
@@ -0,0 +1,32 @@
+/**
+ * debug.c - DesignWare USB3 DRD Controller Debug/Trace Support
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Felipe Balbi <balbi@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2  of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include "debug.h"
+
+void dwc3_trace(void (*trace)(struct va_format *), const char *fmt, ...)
+{
+        struct va_format vaf;
+        va_list args;
+
+        va_start(args, fmt);
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        trace(&vaf);
+
+        va_end(args);
+}
diff --git a/drivers/usb/dwc3/debug.h b/drivers/usb/dwc3/debug.h
index fceb39dc4bba..07fbc2d94fd4 100644
--- a/drivers/usb/dwc3/debug.h
+++ b/drivers/usb/dwc3/debug.h
@@ -16,8 +16,206 @@
  * GNU General Public License for more details.
  */
 
+#ifndef __DWC3_DEBUG_H
+#define __DWC3_DEBUG_H
+
 #include "core.h"
 
+/**
+ * dwc3_gadget_ep_cmd_string - returns endpoint command string
+ * @cmd: command code
+ */
+static inline const char *
+dwc3_gadget_ep_cmd_string(u8 cmd)
+{
+        switch (cmd) {
+        case DWC3_DEPCMD_DEPSTARTCFG:
+                return "Start New Configuration";
+        case DWC3_DEPCMD_ENDTRANSFER:
+                return "End Transfer";
+        case DWC3_DEPCMD_UPDATETRANSFER:
+                return "Update Transfer";
+        case DWC3_DEPCMD_STARTTRANSFER:
+                return "Start Transfer";
+        case DWC3_DEPCMD_CLEARSTALL:
+                return "Clear Stall";
+        case DWC3_DEPCMD_SETSTALL:
+                return "Set Stall";
+        case DWC3_DEPCMD_GETEPSTATE:
+                return "Get Endpoint State";
+        case DWC3_DEPCMD_SETTRANSFRESOURCE:
+                return "Set Endpoint Transfer Resource";
+        case DWC3_DEPCMD_SETEPCONFIG:
+                return "Set Endpoint Configuration";
+        default:
+                return "UNKNOWN command";
+        }
+}
+
+/**
+ * dwc3_gadget_generic_cmd_string - returns generic command string
+ * @cmd: command code
+ */
+static inline const char *
+dwc3_gadget_generic_cmd_string(u8 cmd)
+{
+        switch (cmd) {
+        case DWC3_DGCMD_SET_LMP:
+                return "Set LMP";
+        case DWC3_DGCMD_SET_PERIODIC_PAR:
+                return "Set Periodic Parameters";
+        case DWC3_DGCMD_XMIT_FUNCTION:
+                return "Transmit Function Wake Device Notification";
+        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
+                return "Set Scratchpad Buffer Array Address Lo";
+        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
+                return "Set Scratchpad Buffer Array Address Hi";
+        case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
+                return "Selected FIFO Flush";
+        case DWC3_DGCMD_ALL_FIFO_FLUSH:
+                return "All FIFO Flush";
+        case DWC3_DGCMD_SET_ENDPOINT_NRDY:
+                return "Set Endpoint NRDY";
+        case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
+                return "Run SoC Bus Loopback Test";
+        default:
+                return "UNKNOWN";
+        }
+}
+
+/**
+ * dwc3_gadget_link_string - returns link name
+ * @link_state: link state code
+ */
+static inline const char *
+dwc3_gadget_link_string(enum dwc3_link_state link_state)
+{
+        switch (link_state) {
+        case DWC3_LINK_STATE_U0:
+                return "U0";
+        case DWC3_LINK_STATE_U1:
+                return "U1";
+        case DWC3_LINK_STATE_U2:
+                return "U2";
+        case DWC3_LINK_STATE_U3:
+                return "U3";
+        case DWC3_LINK_STATE_SS_DIS:
+                return "SS.Disabled";
+        case DWC3_LINK_STATE_RX_DET:
+                return "RX.Detect";
+        case DWC3_LINK_STATE_SS_INACT:
+                return "SS.Inactive";
+        case DWC3_LINK_STATE_POLL:
+                return "Polling";
+        case DWC3_LINK_STATE_RECOV:
+                return "Recovery";
+        case DWC3_LINK_STATE_HRESET:
+                return "Hot Reset";
+        case DWC3_LINK_STATE_CMPLY:
+                return "Compliance";
+        case DWC3_LINK_STATE_LPBK:
+                return "Loopback";
+        case DWC3_LINK_STATE_RESET:
+                return "Reset";
+        case DWC3_LINK_STATE_RESUME:
+                return "Resume";
+        default:
+                return "UNKNOWN link state\n";
+        }
+}
+
+/**
+ * dwc3_gadget_event_string - returns event name
+ * @event: the event code
+ */
+static inline const char *dwc3_gadget_event_string(u8 event)
+{
+        switch (event) {
+        case DWC3_DEVICE_EVENT_DISCONNECT:
+                return "Disconnect";
+        case DWC3_DEVICE_EVENT_RESET:
+                return "Reset";
+        case DWC3_DEVICE_EVENT_CONNECT_DONE:
+                return "Connection Done";
+        case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
+                return "Link Status Change";
+        case DWC3_DEVICE_EVENT_WAKEUP:
+                return "WakeUp";
+        case DWC3_DEVICE_EVENT_EOPF:
+                return "End-Of-Frame";
+        case DWC3_DEVICE_EVENT_SOF:
+                return "Start-Of-Frame";
+        case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
+                return "Erratic Error";
+        case DWC3_DEVICE_EVENT_CMD_CMPL:
+                return "Command Complete";
+        case DWC3_DEVICE_EVENT_OVERFLOW:
+                return "Overflow";
+        }
+
+        return "UNKNOWN";
+}
+
+/**
+ * dwc3_ep_event_string - returns event name
+ * @event: then event code
+ */
+static inline const char *dwc3_ep_event_string(u8 event)
+{
+        switch (event) {
+        case DWC3_DEPEVT_XFERCOMPLETE:
+                return "Transfer Complete";
+        case DWC3_DEPEVT_XFERINPROGRESS:
+                return "Transfer In-Progress";
+        case DWC3_DEPEVT_XFERNOTREADY:
+                return "Transfer Not Ready";
+        case DWC3_DEPEVT_RXTXFIFOEVT:
+                return "FIFO";
+        case DWC3_DEPEVT_STREAMEVT:
+                return "Stream";
+        case DWC3_DEPEVT_EPCMDCMPLT:
+                return "Endpoint Command Complete";
+        }
+
+        return "UNKNOWN";
+}
+
+/**
+ * dwc3_gadget_event_type_string - return event name
+ * @event: the event code
+ */
+static inline const char *dwc3_gadget_event_type_string(u8 event)
+{
+        switch (event) {
+        case DWC3_DEVICE_EVENT_DISCONNECT:
+                return "Disconnect";
+        case DWC3_DEVICE_EVENT_RESET:
+                return "Reset";
+        case DWC3_DEVICE_EVENT_CONNECT_DONE:
+                return "Connect Done";
+        case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
+                return "Link Status Change";
+        case DWC3_DEVICE_EVENT_WAKEUP:
+                return "Wake-Up";
+        case DWC3_DEVICE_EVENT_HIBER_REQ:
+                return "Hibernation";
+        case DWC3_DEVICE_EVENT_EOPF:
+                return "End of Periodic Frame";
+        case DWC3_DEVICE_EVENT_SOF:
+                return "Start of Frame";
+        case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
+                return "Erratic Error";
+        case DWC3_DEVICE_EVENT_CMD_CMPL:
+                return "Command Complete";
+        case DWC3_DEVICE_EVENT_OVERFLOW:
+                return "Overflow";
+        default:
+                return "UNKNOWN";
+        }
+}
+
+void dwc3_trace(void (*trace)(struct va_format *), const char *fmt, ...);
+
 #ifdef CONFIG_DEBUG_FS
 extern int dwc3_debugfs_init(struct dwc3 *);
 extern void dwc3_debugfs_exit(struct dwc3 *);
@@ -27,4 +225,4 @@ static inline int dwc3_debugfs_init(struct dwc3 *d)
 static inline void dwc3_debugfs_exit(struct dwc3 *d)
 {  }
 #endif
-
+#endif /* __DWC3_DEBUG_H */
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index f9fb8adb785b..3951a65fea04 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -113,10 +113,8 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
         int                     ret;
 
         exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL);
-        if (!exynos) {
-                dev_err(dev, "not enough memory\n");
+        if (!exynos)
                 return -ENOMEM;
-        }
 
         /*
          * Right now device-tree probed devices don't get dma_mask set.
diff --git a/drivers/usb/dwc3/dwc3-keystone.c b/drivers/usb/dwc3/dwc3-keystone.c
index 1fad1618df6e..7ec8495f4523 100644
--- a/drivers/usb/dwc3/dwc3-keystone.c
+++ b/drivers/usb/dwc3/dwc3-keystone.c
@@ -189,7 +189,6 @@ static struct platform_driver kdwc3_driver = {
         .remove         = kdwc3_remove,
         .driver         = {
                 .name   = "keystone-dwc3",
-                .owner          = THIS_MODULE,
                 .of_match_table = kdwc3_of_match,
         },
 };
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index fc0de3753648..2f537d588225 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -481,10 +481,8 @@ static int dwc3_omap_probe(struct platform_device *pdev)
         }
 
         omap = devm_kzalloc(dev, sizeof(*omap), GFP_KERNEL);
-        if (!omap) {
-                dev_err(dev, "not enough memory\n");
+        if (!omap)
                 return -ENOMEM;
-        }
 
         platform_set_drvdata(pdev, omap);
 
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index a60bab7dfa0a..436fb08c40b8 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -103,10 +103,8 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         struct device           *dev = &pci->dev;
 
         glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
-        if (!glue) {
-                dev_err(dev, "not enough memory\n");
+        if (!glue)
                 return -ENOMEM;
-        }
 
         glue->dev = dev;
 
diff --git a/drivers/usb/dwc3/dwc3-qcom.c b/drivers/usb/dwc3/dwc3-qcom.c
new file mode 100644
index 000000000000..8c2e8eec80c2
--- /dev/null
+++ b/drivers/usb/dwc3/dwc3-qcom.c
@@ -0,0 +1,130 @@
+/* Copyright (c) 2013-2014, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+
+struct dwc3_qcom {
+        struct device           *dev;
+
+        struct clk              *core_clk;
+        struct clk              *iface_clk;
+        struct clk              *sleep_clk;
+};
+
+static int dwc3_qcom_probe(struct platform_device *pdev)
+{
+        struct device_node *node = pdev->dev.of_node;
+        struct dwc3_qcom *qdwc;
+        int ret;
+
+        qdwc = devm_kzalloc(&pdev->dev, sizeof(*qdwc), GFP_KERNEL);
+        if (!qdwc)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, qdwc);
+
+        qdwc->dev = &pdev->dev;
+
+        qdwc->core_clk = devm_clk_get(qdwc->dev, "core");
+        if (IS_ERR(qdwc->core_clk)) {
+                dev_err(qdwc->dev, "failed to get core clock\n");
+                return PTR_ERR(qdwc->core_clk);
+        }
+
+        qdwc->iface_clk = devm_clk_get(qdwc->dev, "iface");
+        if (IS_ERR(qdwc->iface_clk)) {
+                dev_dbg(qdwc->dev, "failed to get optional iface clock\n");
+                qdwc->iface_clk = NULL;
+        }
+
+        qdwc->sleep_clk = devm_clk_get(qdwc->dev, "sleep");
+        if (IS_ERR(qdwc->sleep_clk)) {
+                dev_dbg(qdwc->dev, "failed to get optional sleep clock\n");
+                qdwc->sleep_clk = NULL;
+        }
+
+        ret = clk_prepare_enable(qdwc->core_clk);
+        if (ret) {
+                dev_err(qdwc->dev, "failed to enable core clock\n");
+                goto err_core;
+        }
+
+        ret = clk_prepare_enable(qdwc->iface_clk);
+        if (ret) {
+                dev_err(qdwc->dev, "failed to enable optional iface clock\n");
+                goto err_iface;
+        }
+
+        ret = clk_prepare_enable(qdwc->sleep_clk);
+        if (ret) {
+                dev_err(qdwc->dev, "failed to enable optional sleep clock\n");
+                goto err_sleep;
+        }
+
+        ret = of_platform_populate(node, NULL, NULL, qdwc->dev);
+        if (ret) {
+                dev_err(qdwc->dev, "failed to register core - %d\n", ret);
+                goto err_clks;
+        }
+
+        return 0;
+
+err_clks:
+        clk_disable_unprepare(qdwc->sleep_clk);
+err_sleep:
+        clk_disable_unprepare(qdwc->iface_clk);
+err_iface:
+        clk_disable_unprepare(qdwc->core_clk);
+err_core:
+        return ret;
+}
+
+static int dwc3_qcom_remove(struct platform_device *pdev)
+{
+        struct dwc3_qcom *qdwc = platform_get_drvdata(pdev);
+
+        of_platform_depopulate(&pdev->dev);
+
+        clk_disable_unprepare(qdwc->sleep_clk);
+        clk_disable_unprepare(qdwc->iface_clk);
+        clk_disable_unprepare(qdwc->core_clk);
+
+        return 0;
+}
+
+static const struct of_device_id of_dwc3_match[] = {
+        { .compatible = "qcom,dwc3" },
+        { /* Sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, of_dwc3_match);
+
+static struct platform_driver dwc3_qcom_driver = {
+        .probe          = dwc3_qcom_probe,
+        .remove         = dwc3_qcom_remove,
+        .driver         = {
+                .name   = "qcom-dwc3",
+                .of_match_table = of_dwc3_match,
+        },
+};
+
+module_platform_driver(dwc3_qcom_driver);
+
+MODULE_ALIAS("platform:qcom-dwc3");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("DesignWare USB3 QCOM Glue Layer");
+MODULE_AUTHOR("Ivan T. Ivanov <iivanov@mm-sol.com>");
diff --git a/drivers/usb/dwc3/dwc3-st.c b/drivers/usb/dwc3/dwc3-st.c
new file mode 100644
index 000000000000..c7602b5362ad
--- /dev/null
+++ b/drivers/usb/dwc3/dwc3-st.c
@@ -0,0 +1,367 @@
+/**
+ * dwc3-st.c Support for dwc3 platform devices on ST Microelectronics platforms
+ *
+ * This is a small driver for the dwc3 to provide the glue logic
+ * to configure the controller. Tested on STi platforms.
+ *
+ * Copyright (C) 2014 Stmicroelectronics
+ *
+ * Author: Giuseppe Cavallaro <peppe.cavallaro@st.com>
+ * Contributors: Aymen Bouattay <aymen.bouattay@st.com>
+ *               Peter Griffin <peter.griffin@linaro.org>
+ *
+ * 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.
+ *
+ * Inspired by dwc3-omap.c and dwc3-exynos.c.
+ */
+
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/kernel.h>
+#include <linux/mfd/syscon.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/regmap.h>
+#include <linux/reset.h>
+#include <linux/usb/of.h>
+
+#include "core.h"
+#include "io.h"
+
+/* glue registers */
+#define CLKRST_CTRL             0x00
+#define AUX_CLK_EN              BIT(0)
+#define SW_PIPEW_RESET_N        BIT(4)
+#define EXT_CFG_RESET_N         BIT(8)
+/*
+ * 1'b0 : The host controller complies with the xHCI revision 0.96
+ * 1'b1 : The host controller complies with the xHCI revision 1.0
+ */
+#define XHCI_REVISION           BIT(12)
+
+#define USB2_VBUS_MNGMNT_SEL1   0x2C
+/*
+ * For all fields in USB2_VBUS_MNGMNT_SEL1
+ * 2’b00 : Override value from Reg 0x30 is selected
+ * 2’b01 : utmiotg_<signal_name> from usb3_top is selected
+ * 2’b10 : pipew_<signal_name> from PIPEW instance is selected
+ * 2’b11 : value is 1'b0
+ */
+#define USB2_VBUS_REG30         0x0
+#define USB2_VBUS_UTMIOTG       0x1
+#define USB2_VBUS_PIPEW         0x2
+#define USB2_VBUS_ZERO          0x3
+
+#define SEL_OVERRIDE_VBUSVALID(n)       (n << 0)
+#define SEL_OVERRIDE_POWERPRESENT(n)    (n << 4)
+#define SEL_OVERRIDE_BVALID(n)          (n << 8)
+
+/* Static DRD configuration */
+#define USB3_CONTROL_MASK               0xf77
+
+#define USB3_DEVICE_NOT_HOST            BIT(0)
+#define USB3_FORCE_VBUSVALID            BIT(1)
+#define USB3_DELAY_VBUSVALID            BIT(2)
+#define USB3_SEL_FORCE_OPMODE           BIT(4)
+#define USB3_FORCE_OPMODE(n)            (n << 5)
+#define USB3_SEL_FORCE_DPPULLDOWN2      BIT(8)
+#define USB3_FORCE_DPPULLDOWN2          BIT(9)
+#define USB3_SEL_FORCE_DMPULLDOWN2      BIT(10)
+#define USB3_FORCE_DMPULLDOWN2          BIT(11)
+
+/**
+ * struct st_dwc3 - dwc3-st driver private structure
+ * @dev:                device pointer
+ * @glue_base:          ioaddr for the glue registers
+ * @regmap:             regmap pointer for getting syscfg
+ * @syscfg_reg_off:     usb syscfg control offset
+ * @dr_mode:            drd static host/device config
+ * @rstc_pwrdn:         rest controller for powerdown signal
+ * @rstc_rst:           reset controller for softreset signal
+ */
+
+struct st_dwc3 {
+        struct device *dev;
+        void __iomem *glue_base;
+        struct regmap *regmap;
+        int syscfg_reg_off;
+        enum usb_dr_mode dr_mode;
+        struct reset_control *rstc_pwrdn;
+        struct reset_control *rstc_rst;
+};
+
+static inline u32 st_dwc3_readl(void __iomem *base, u32 offset)
+{
+        return readl_relaxed(base + offset);
+}
+
+static inline void st_dwc3_writel(void __iomem *base, u32 offset, u32 value)
+{
+        writel_relaxed(value, base + offset);
+}
+
+/**
+ * st_dwc3_drd_init: program the port
+ * @dwc3_data: driver private structure
+ * Description: this function is to program the port as either host or device
+ * according to the static configuration passed from devicetree.
+ * OTG and dual role are not yet supported!
+ */
+static int st_dwc3_drd_init(struct st_dwc3 *dwc3_data)
+{
+        u32 val;
+        int err;
+
+        err = regmap_read(dwc3_data->regmap, dwc3_data->syscfg_reg_off, &val);
+        if (err)
+                return err;
+
+        val &= USB3_CONTROL_MASK;
+
+        switch (dwc3_data->dr_mode) {
+        case USB_DR_MODE_PERIPHERAL:
+
+                val &= ~(USB3_FORCE_VBUSVALID | USB3_DELAY_VBUSVALID
+                        | USB3_SEL_FORCE_OPMODE | USB3_FORCE_OPMODE(0x3)
+                        | USB3_SEL_FORCE_DPPULLDOWN2 | USB3_FORCE_DPPULLDOWN2
+                        | USB3_SEL_FORCE_DMPULLDOWN2 | USB3_FORCE_DMPULLDOWN2);
+
+                val |= USB3_DEVICE_NOT_HOST;
+
+                dev_dbg(dwc3_data->dev, "Configuring as Device\n");
+                break;
+
+        case USB_DR_MODE_HOST:
+
+                val &= ~(USB3_DEVICE_NOT_HOST | USB3_FORCE_VBUSVALID
+                        | USB3_SEL_FORCE_OPMODE | USB3_FORCE_OPMODE(0x3)
+                        | USB3_SEL_FORCE_DPPULLDOWN2 | USB3_FORCE_DPPULLDOWN2
+                        | USB3_SEL_FORCE_DMPULLDOWN2 | USB3_FORCE_DMPULLDOWN2);
+
+                /*
+                 * USB3_DELAY_VBUSVALID is ANDed with USB_C_VBUSVALID. Thus,
+                 * when set to ‘0‘, it can delay the arrival of VBUSVALID
+                 * information to VBUSVLDEXT2 input of the pico PHY.
+                 * We don't want to do that so we set the bit to '1'.
+                 */
+
+                val |= USB3_DELAY_VBUSVALID;
+
+                dev_dbg(dwc3_data->dev, "Configuring as Host\n");
+                break;
+
+        default:
+                dev_err(dwc3_data->dev, "Unsupported mode of operation %d\n",
+                        dwc3_data->dr_mode);
+                return -EINVAL;
+        }
+
+        return regmap_write(dwc3_data->regmap, dwc3_data->syscfg_reg_off, val);
+}
+
+/**
+ * st_dwc3_init: init the controller via glue logic
+ * @dwc3_data: driver private structure
+ */
+static void st_dwc3_init(struct st_dwc3 *dwc3_data)
+{
+        u32 reg = st_dwc3_readl(dwc3_data->glue_base, CLKRST_CTRL);
+
+        reg |= AUX_CLK_EN | EXT_CFG_RESET_N | XHCI_REVISION;
+        reg &= ~SW_PIPEW_RESET_N;
+        st_dwc3_writel(dwc3_data->glue_base, CLKRST_CTRL, reg);
+
+        /* configure mux for vbus, powerpresent and bvalid signals */
+        reg = st_dwc3_readl(dwc3_data->glue_base, USB2_VBUS_MNGMNT_SEL1);
+
+        reg |= SEL_OVERRIDE_VBUSVALID(USB2_VBUS_UTMIOTG) |
+                SEL_OVERRIDE_POWERPRESENT(USB2_VBUS_UTMIOTG) |
+                SEL_OVERRIDE_BVALID(USB2_VBUS_UTMIOTG);
+
+        st_dwc3_writel(dwc3_data->glue_base, USB2_VBUS_MNGMNT_SEL1, reg);
+
+        reg = st_dwc3_readl(dwc3_data->glue_base, CLKRST_CTRL);
+        reg |= SW_PIPEW_RESET_N;
+        st_dwc3_writel(dwc3_data->glue_base, CLKRST_CTRL, reg);
+}
+
+static int st_dwc3_probe(struct platform_device *pdev)
+{
+        struct st_dwc3 *dwc3_data;
+        struct resource *res;
+        struct device *dev = &pdev->dev;
+        struct device_node *node = dev->of_node, *child;
+        struct regmap *regmap;
+        int ret;
+
+        dwc3_data = devm_kzalloc(dev, sizeof(*dwc3_data), GFP_KERNEL);
+        if (!dwc3_data)
+                return -ENOMEM;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "reg-glue");
+        dwc3_data->glue_base = devm_ioremap_resource(dev, res);
+        if (IS_ERR(dwc3_data->glue_base))
+                return PTR_ERR(dwc3_data->glue_base);
+
+        regmap = syscon_regmap_lookup_by_phandle(node, "st,syscfg");
+        if (IS_ERR(regmap))
+                return PTR_ERR(regmap);
+
+        dma_set_coherent_mask(dev, dev->coherent_dma_mask);
+        dwc3_data->dev = dev;
+        dwc3_data->regmap = regmap;
+
+        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "syscfg-reg");
+        if (!res) {
+                ret = -ENXIO;
+                goto undo_platform_dev_alloc;
+        }
+
+        dwc3_data->syscfg_reg_off = res->start;
+
+        dev_vdbg(&pdev->dev, "glue-logic addr 0x%p, syscfg-reg offset 0x%x\n",
+                 dwc3_data->glue_base, dwc3_data->syscfg_reg_off);
+
+        dwc3_data->rstc_pwrdn = devm_reset_control_get(dev, "powerdown");
+        if (IS_ERR(dwc3_data->rstc_pwrdn)) {
+                dev_err(&pdev->dev, "could not get power controller\n");
+                ret = PTR_ERR(dwc3_data->rstc_pwrdn);
+                goto undo_platform_dev_alloc;
+        }
+
+        /* Manage PowerDown */
+        reset_control_deassert(dwc3_data->rstc_pwrdn);
+
+        dwc3_data->rstc_rst = devm_reset_control_get(dev, "softreset");
+        if (IS_ERR(dwc3_data->rstc_rst)) {
+                dev_err(&pdev->dev, "could not get reset controller\n");
+                ret = PTR_ERR(dwc3_data->rstc_pwrdn);
+                goto undo_powerdown;
+        }
+
+        /* Manage SoftReset */
+        reset_control_deassert(dwc3_data->rstc_rst);
+
+        child = of_get_child_by_name(node, "dwc3");
+        if (!child) {
+                dev_err(&pdev->dev, "failed to find dwc3 core node\n");
+                ret = -ENODEV;
+                goto undo_softreset;
+        }
+
+        dwc3_data->dr_mode = of_usb_get_dr_mode(child);
+
+        /* Allocate and initialize the core */
+        ret = of_platform_populate(node, NULL, NULL, dev);
+        if (ret) {
+                dev_err(dev, "failed to add dwc3 core\n");
+                goto undo_softreset;
+        }
+
+        /*
+         * Configure the USB port as device or host according to the static
+         * configuration passed from DT.
+         * DRD is the only mode currently supported so this will be enhanced
+         * as soon as OTG is available.
+         */
+        ret = st_dwc3_drd_init(dwc3_data);
+        if (ret) {
+                dev_err(dev, "drd initialisation failed\n");
+                goto undo_softreset;
+        }
+
+        /* ST glue logic init */
+        st_dwc3_init(dwc3_data);
+
+        platform_set_drvdata(pdev, dwc3_data);
+        return 0;
+
+undo_softreset:
+        reset_control_assert(dwc3_data->rstc_rst);
+undo_powerdown:
+        reset_control_assert(dwc3_data->rstc_pwrdn);
+undo_platform_dev_alloc:
+        platform_device_put(pdev);
+        return ret;
+}
+
+static int st_dwc3_remove(struct platform_device *pdev)
+{
+        struct st_dwc3 *dwc3_data = platform_get_drvdata(pdev);
+
+        of_platform_depopulate(&pdev->dev);
+
+        reset_control_assert(dwc3_data->rstc_pwrdn);
+        reset_control_assert(dwc3_data->rstc_rst);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int st_dwc3_suspend(struct device *dev)
+{
+        struct st_dwc3 *dwc3_data = dev_get_drvdata(dev);
+
+        reset_control_assert(dwc3_data->rstc_pwrdn);
+        reset_control_assert(dwc3_data->rstc_rst);
+
+        pinctrl_pm_select_sleep_state(dev);
+
+        return 0;
+}
+
+static int st_dwc3_resume(struct device *dev)
+{
+        struct st_dwc3 *dwc3_data = dev_get_drvdata(dev);
+        int ret;
+
+        pinctrl_pm_select_default_state(dev);
+
+        reset_control_deassert(dwc3_data->rstc_pwrdn);
+        reset_control_deassert(dwc3_data->rstc_rst);
+
+        ret = st_dwc3_drd_init(dwc3_data);
+        if (ret) {
+                dev_err(dev, "drd initialisation failed\n");
+                return ret;
+        }
+
+        /* ST glue logic init */
+        st_dwc3_init(dwc3_data);
+
+        return 0;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+static SIMPLE_DEV_PM_OPS(st_dwc3_dev_pm_ops, st_dwc3_suspend, st_dwc3_resume);
+
+static const struct of_device_id st_dwc3_match[] = {
+        { .compatible = "st,stih407-dwc3" },
+        { /* sentinel */ },
+};
+
+MODULE_DEVICE_TABLE(of, st_dwc3_match);
+
+static struct platform_driver st_dwc3_driver = {
+        .probe = st_dwc3_probe,
+        .remove = st_dwc3_remove,
+        .driver = {
+                .name = "usb-st-dwc3",
+                .of_match_table = st_dwc3_match,
+                .pm = &st_dwc3_dev_pm_ops,
+        },
+};
+
+module_platform_driver(st_dwc3_driver);
+
+MODULE_AUTHOR("Giuseppe Cavallaro <peppe.cavallaro@st.com>");
+MODULE_DESCRIPTION("DesignWare USB3 STi Glue Layer");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c
index 21a352079bc2..b35938777dde 100644
--- a/drivers/usb/dwc3/ep0.c
+++ b/drivers/usb/dwc3/ep0.c
@@ -31,6 +31,7 @@
 #include <linux/usb/composite.h>
 
 #include "core.h"
+#include "debug.h"
 #include "gadget.h"
 #include "io.h"
 
@@ -65,7 +66,7 @@ static int dwc3_ep0_start_trans(struct dwc3 *dwc, u8 epnum, dma_addr_t buf_dma,
 
         dep = dwc->eps[epnum];
         if (dep->flags & DWC3_EP_BUSY) {
-                dev_vdbg(dwc->dev, "%s: still busy\n", dep->name);
+                dwc3_trace(trace_dwc3_ep0, "%s still busy", dep->name);
                 return 0;
         }
 
@@ -88,7 +89,8 @@ static int dwc3_ep0_start_trans(struct dwc3 *dwc, u8 epnum, dma_addr_t buf_dma,
         ret = dwc3_send_gadget_ep_cmd(dwc, dep->number,
                         DWC3_DEPCMD_STARTTRANSFER, &params);
         if (ret < 0) {
-                dev_dbg(dwc->dev, "failed to send STARTTRANSFER command\n");
+                dwc3_trace(trace_dwc3_ep0, "%s STARTTRANSFER failed",
+                                dep->name);
                 return ret;
         }
 
@@ -153,7 +155,8 @@ static int __dwc3_gadget_ep0_queue(struct dwc3_ep *dep,
                 if (dwc->ep0state == EP0_STATUS_PHASE)
                         __dwc3_ep0_do_control_status(dwc, dwc->eps[direction]);
                 else
-                        dev_dbg(dwc->dev, "too early for delayed status\n");
+                        dwc3_trace(trace_dwc3_ep0,
+                                        "too early for delayed status");
 
                 return 0;
         }
@@ -217,7 +220,8 @@ int dwc3_gadget_ep0_queue(struct usb_ep *ep, struct usb_request *request,
 
         spin_lock_irqsave(&dwc->lock, flags);
         if (!dep->endpoint.desc) {
-                dev_dbg(dwc->dev, "trying to queue request %p to disabled %s\n",
+                dwc3_trace(trace_dwc3_ep0,
+                                "trying to queue request %p to disabled %s",
                                 request, dep->name);
                 ret = -ESHUTDOWN;
                 goto out;
@@ -229,7 +233,8 @@ int dwc3_gadget_ep0_queue(struct usb_ep *ep, struct usb_request *request,
                 goto out;
         }
 
-        dev_vdbg(dwc->dev, "queueing request %p to %s length %d, state '%s'\n",
+        dwc3_trace(trace_dwc3_ep0,
+                        "queueing request %p to %s length %d state '%s'",
                         request, dep->name, request->length,
                         dwc3_ep0_state_string(dwc->ep0state));
 
@@ -485,12 +490,13 @@ static int dwc3_ep0_set_address(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
 
         addr = le16_to_cpu(ctrl->wValue);
         if (addr > 127) {
-                dev_dbg(dwc->dev, "invalid device address %d\n", addr);
+                dwc3_trace(trace_dwc3_ep0, "invalid device address %d", addr);
                 return -EINVAL;
         }
 
         if (state == USB_STATE_CONFIGURED) {
-                dev_dbg(dwc->dev, "trying to set address when configured\n");
+                dwc3_trace(trace_dwc3_ep0,
+                                "trying to set address when configured");
                 return -EINVAL;
         }
 
@@ -556,7 +562,7 @@ static int dwc3_ep0_set_config(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
                         dwc3_writel(dwc->regs, DWC3_DCTL, reg);
 
                         dwc->resize_fifos = true;
-                        dev_dbg(dwc->dev, "resize fifos flag SET\n");
+                        dwc3_trace(trace_dwc3_ep0, "resize FIFOs flag SET");
                 }
                 break;
 
@@ -680,35 +686,35 @@ static int dwc3_ep0_std_request(struct dwc3 *dwc, struct usb_ctrlrequest *ctrl)
 
         switch (ctrl->bRequest) {
         case USB_REQ_GET_STATUS:
-                dev_vdbg(dwc->dev, "USB_REQ_GET_STATUS\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_GET_STATUS\n");
                 ret = dwc3_ep0_handle_status(dwc, ctrl);
                 break;
         case USB_REQ_CLEAR_FEATURE:
-                dev_vdbg(dwc->dev, "USB_REQ_CLEAR_FEATURE\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_CLEAR_FEATURE\n");
                 ret = dwc3_ep0_handle_feature(dwc, ctrl, 0);
                 break;
         case USB_REQ_SET_FEATURE:
-                dev_vdbg(dwc->dev, "USB_REQ_SET_FEATURE\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_FEATURE\n");
                 ret = dwc3_ep0_handle_feature(dwc, ctrl, 1);
                 break;
         case USB_REQ_SET_ADDRESS:
-                dev_vdbg(dwc->dev, "USB_REQ_SET_ADDRESS\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_ADDRESS\n");
                 ret = dwc3_ep0_set_address(dwc, ctrl);
                 break;
         case USB_REQ_SET_CONFIGURATION:
-                dev_vdbg(dwc->dev, "USB_REQ_SET_CONFIGURATION\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_CONFIGURATION\n");
                 ret = dwc3_ep0_set_config(dwc, ctrl);
                 break;
         case USB_REQ_SET_SEL:
-                dev_vdbg(dwc->dev, "USB_REQ_SET_SEL\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_SEL\n");
                 ret = dwc3_ep0_set_sel(dwc, ctrl);
                 break;
         case USB_REQ_SET_ISOCH_DELAY:
-                dev_vdbg(dwc->dev, "USB_REQ_SET_ISOCH_DELAY\n");
+                dwc3_trace(trace_dwc3_ep0, "USB_REQ_SET_ISOCH_DELAY\n");
                 ret = dwc3_ep0_set_isoch_delay(dwc, ctrl);
                 break;
         default:
-                dev_vdbg(dwc->dev, "Forwarding to gadget driver\n");
+                dwc3_trace(trace_dwc3_ep0, "Forwarding to gadget driver\n");
                 ret = dwc3_ep0_delegate_req(dwc, ctrl);
                 break;
         }
@@ -726,6 +732,8 @@ static void dwc3_ep0_inspect_setup(struct dwc3 *dwc,
         if (!dwc->gadget_driver)
                 goto out;
 
+        trace_dwc3_ctrl_req(ctrl);
+
         len = le16_to_cpu(ctrl->wLength);
         if (!len) {
                 dwc->three_stage_setup = false;
@@ -774,7 +782,7 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc,
 
         status = DWC3_TRB_SIZE_TRBSTS(trb->size);
         if (status == DWC3_TRBSTS_SETUP_PENDING) {
-                dev_dbg(dwc->dev, "Setup Pending received\n");
+                dwc3_trace(trace_dwc3_ep0, "Setup Pending received");
 
                 if (r)
                         dwc3_gadget_giveback(ep0, r, -ECONNRESET);
@@ -834,7 +842,7 @@ static void dwc3_ep0_complete_status(struct dwc3 *dwc,
 
                 ret = dwc3_gadget_set_test_mode(dwc, dwc->test_mode_nr);
                 if (ret < 0) {
-                        dev_dbg(dwc->dev, "Invalid Test #%d\n",
+                        dwc3_trace(trace_dwc3_ep0, "Invalid Test #%d",
                                         dwc->test_mode_nr);
                         dwc3_ep0_stall_and_restart(dwc);
                         return;
@@ -843,7 +851,7 @@ static void dwc3_ep0_complete_status(struct dwc3 *dwc,
 
         status = DWC3_TRB_SIZE_TRBSTS(trb->size);
         if (status == DWC3_TRBSTS_SETUP_PENDING)
-                dev_dbg(dwc->dev, "Setup Pending received\n");
+                dwc3_trace(trace_dwc3_ep0, "Setup Pending received\n");
 
         dwc->ep0state = EP0_SETUP_PHASE;
         dwc3_ep0_out_start(dwc);
@@ -860,17 +868,17 @@ static void dwc3_ep0_xfer_complete(struct dwc3 *dwc,
 
         switch (dwc->ep0state) {
         case EP0_SETUP_PHASE:
-                dev_vdbg(dwc->dev, "Inspecting Setup Bytes\n");
+                dwc3_trace(trace_dwc3_ep0, "Setup Phase");
                 dwc3_ep0_inspect_setup(dwc, event);
                 break;
 
         case EP0_DATA_PHASE:
-                dev_vdbg(dwc->dev, "Data Phase\n");
+                dwc3_trace(trace_dwc3_ep0, "Data Phase");
                 dwc3_ep0_complete_data(dwc, event);
                 break;
 
         case EP0_STATUS_PHASE:
-                dev_vdbg(dwc->dev, "Status Phase\n");
+                dwc3_trace(trace_dwc3_ep0, "Status Phase");
                 dwc3_ep0_complete_status(dwc, event);
                 break;
         default:
@@ -946,7 +954,7 @@ static int dwc3_ep0_start_control_status(struct dwc3_ep *dep)
 static void __dwc3_ep0_do_control_status(struct dwc3 *dwc, struct dwc3_ep *dep)
 {
         if (dwc->resize_fifos) {
-                dev_dbg(dwc->dev, "starting to resize fifos\n");
+                dwc3_trace(trace_dwc3_ep0, "Resizing FIFOs");
                 dwc3_gadget_resize_tx_fifos(dwc);
                 dwc->resize_fifos = 0;
         }
@@ -987,7 +995,7 @@ static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
 
         switch (event->status) {
         case DEPEVT_STATUS_CONTROL_DATA:
-                dev_vdbg(dwc->dev, "Control Data\n");
+                dwc3_trace(trace_dwc3_ep0, "Control Data");
 
                 /*
                  * We already have a DATA transfer in the controller's cache,
@@ -1001,7 +1009,8 @@ static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
                 if (dwc->ep0_expect_in != event->endpoint_number) {
                         struct dwc3_ep  *dep = dwc->eps[dwc->ep0_expect_in];
 
-                        dev_vdbg(dwc->dev, "Wrong direction for Data phase\n");
+                        dwc3_trace(trace_dwc3_ep0,
+                                        "Wrong direction for Data phase");
                         dwc3_ep0_end_control_data(dwc, dep);
                         dwc3_ep0_stall_and_restart(dwc);
                         return;
@@ -1013,13 +1022,13 @@ static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
                 if (dwc->ep0_next_event != DWC3_EP0_NRDY_STATUS)
                         return;
 
-                dev_vdbg(dwc->dev, "Control Status\n");
+                dwc3_trace(trace_dwc3_ep0, "Control Status");
 
                 dwc->ep0state = EP0_STATUS_PHASE;
 
                 if (dwc->delayed_status) {
                         WARN_ON_ONCE(event->endpoint_number != 1);
-                        dev_vdbg(dwc->dev, "Mass Storage delayed status\n");
+                        dwc3_trace(trace_dwc3_ep0, "Delayed Status");
                         return;
                 }
 
@@ -1032,7 +1041,7 @@ void dwc3_ep0_interrupt(struct dwc3 *dwc,
 {
         u8                      epnum = event->endpoint_number;
 
-        dev_dbg(dwc->dev, "%s while ep%d%s in state '%s'\n",
+        dwc3_trace(trace_dwc3_ep0, "%s while ep%d%s in state '%s'",
                         dwc3_ep_event_string(event->endpoint_event),
                         epnum >> 1, (epnum & 1) ? "in" : "out",
                         dwc3_ep0_state_string(dwc->ep0state));
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 490a6ca00733..3818b26bfc05 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -30,6 +30,7 @@
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
+#include "debug.h"
 #include "core.h"
 #include "gadget.h"
 #include "io.h"
@@ -266,107 +267,19 @@ void dwc3_gadget_giveback(struct dwc3_ep *dep, struct dwc3_request *req,
         dev_dbg(dwc->dev, "request %p from %s completed %d/%d ===> %d\n",
                         req, dep->name, req->request.actual,
                         req->request.length, status);
+        trace_dwc3_gadget_giveback(req);
 
         spin_unlock(&dwc->lock);
-        req->request.complete(&dep->endpoint, &req->request);
+        usb_gadget_giveback_request(&dep->endpoint, &req->request);
         spin_lock(&dwc->lock);
 }
 
-static const char *dwc3_gadget_ep_cmd_string(u8 cmd)
-{
-        switch (cmd) {
-        case DWC3_DEPCMD_DEPSTARTCFG:
-                return "Start New Configuration";
-        case DWC3_DEPCMD_ENDTRANSFER:
-                return "End Transfer";
-        case DWC3_DEPCMD_UPDATETRANSFER:
-                return "Update Transfer";
-        case DWC3_DEPCMD_STARTTRANSFER:
-                return "Start Transfer";
-        case DWC3_DEPCMD_CLEARSTALL:
-                return "Clear Stall";
-        case DWC3_DEPCMD_SETSTALL:
-                return "Set Stall";
-        case DWC3_DEPCMD_GETEPSTATE:
-                return "Get Endpoint State";
-        case DWC3_DEPCMD_SETTRANSFRESOURCE:
-                return "Set Endpoint Transfer Resource";
-        case DWC3_DEPCMD_SETEPCONFIG:
-                return "Set Endpoint Configuration";
-        default:
-                return "UNKNOWN command";
-        }
-}
-
-static const char *dwc3_gadget_generic_cmd_string(u8 cmd)
-{
-        switch (cmd) {
-        case DWC3_DGCMD_SET_LMP:
-                return "Set LMP";
-        case DWC3_DGCMD_SET_PERIODIC_PAR:
-                return "Set Periodic Parameters";
-        case DWC3_DGCMD_XMIT_FUNCTION:
-                return "Transmit Function Wake Device Notification";
-        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_LO:
-                return "Set Scratchpad Buffer Array Address Lo";
-        case DWC3_DGCMD_SET_SCRATCHPAD_ADDR_HI:
-                return "Set Scratchpad Buffer Array Address Hi";
-        case DWC3_DGCMD_SELECTED_FIFO_FLUSH:
-                return "Selected FIFO Flush";
-        case DWC3_DGCMD_ALL_FIFO_FLUSH:
-                return "All FIFO Flush";
-        case DWC3_DGCMD_SET_ENDPOINT_NRDY:
-                return "Set Endpoint NRDY";
-        case DWC3_DGCMD_RUN_SOC_BUS_LOOPBACK:
-                return "Run SoC Bus Loopback Test";
-        default:
-                return "UNKNOWN";
-        }
-}
-
-static const char *dwc3_gadget_link_string(enum dwc3_link_state link_state)
-{
-        switch (link_state) {
-        case DWC3_LINK_STATE_U0:
-                return "U0";
-        case DWC3_LINK_STATE_U1:
-                return "U1";
-        case DWC3_LINK_STATE_U2:
-                return "U2";
-        case DWC3_LINK_STATE_U3:
-                return "U3";
-        case DWC3_LINK_STATE_SS_DIS:
-                return "SS.Disabled";
-        case DWC3_LINK_STATE_RX_DET:
-                return "RX.Detect";
-        case DWC3_LINK_STATE_SS_INACT:
-                return "SS.Inactive";
-        case DWC3_LINK_STATE_POLL:
-                return "Polling";
-        case DWC3_LINK_STATE_RECOV:
-                return "Recovery";
-        case DWC3_LINK_STATE_HRESET:
-                return "Hot Reset";
-        case DWC3_LINK_STATE_CMPLY:
-                return "Compliance";
-        case DWC3_LINK_STATE_LPBK:
-                return "Loopback";
-        case DWC3_LINK_STATE_RESET:
-                return "Reset";
-        case DWC3_LINK_STATE_RESUME:
-                return "Resume";
-        default:
-                return "UNKNOWN link state\n";
-        }
-}
-
-int dwc3_send_gadget_generic_command(struct dwc3 *dwc, int cmd, u32 param)
+int dwc3_send_gadget_generic_command(struct dwc3 *dwc, unsigned cmd, u32 param)
 {
         u32             timeout = 500;
         u32             reg;
 
-        dev_vdbg(dwc->dev, "generic cmd '%s' [%d] param %08x\n",
-                        dwc3_gadget_generic_cmd_string(cmd), cmd, param);
+        trace_dwc3_gadget_generic_cmd(cmd, param);
 
         dwc3_writel(dwc->regs, DWC3_DGCMDPAR, param);
         dwc3_writel(dwc->regs, DWC3_DGCMD, cmd | DWC3_DGCMD_CMDACT);
@@ -397,10 +310,7 @@ int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep,
         u32                     timeout = 500;
         u32                     reg;
 
-        dev_vdbg(dwc->dev, "%s: cmd '%s' [%d] params %08x %08x %08x\n",
-                        dep->name,
-                        dwc3_gadget_ep_cmd_string(cmd), cmd, params->param0,
-                        params->param1, params->param2);
+        trace_dwc3_gadget_ep_cmd(dep, cmd, params);
 
         dwc3_writel(dwc->regs, DWC3_DEPCMDPAR0(ep), params->param0);
         dwc3_writel(dwc->regs, DWC3_DEPCMDPAR1(ep), params->param1);
@@ -789,17 +699,16 @@ static struct usb_request *dwc3_gadget_ep_alloc_request(struct usb_ep *ep,
 {
         struct dwc3_request             *req;
         struct dwc3_ep                  *dep = to_dwc3_ep(ep);
-        struct dwc3                     *dwc = dep->dwc;
 
         req = kzalloc(sizeof(*req), gfp_flags);
-        if (!req) {
-                dev_err(dwc->dev, "not enough memory\n");
+        if (!req)
                 return NULL;
-        }
 
         req->epnum      = dep->number;
         req->dep        = dep;
 
+        trace_dwc3_alloc_request(req);
+
         return &req->request;
 }
 
@@ -808,6 +717,7 @@ static void dwc3_gadget_ep_free_request(struct usb_ep *ep,
 {
         struct dwc3_request             *req = to_dwc3_request(request);
 
+        trace_dwc3_free_request(req);
         kfree(req);
 }
 
@@ -889,6 +799,8 @@ static void dwc3_prepare_one_trb(struct dwc3_ep *dep,
                 trb->ctrl |= DWC3_TRB_CTRL_SID_SOFN(req->request.stream_id);
 
         trb->ctrl |= DWC3_TRB_CTRL_HWO;
+
+        trace_dwc3_prepare_trb(dep, trb);
 }
 
 /*
@@ -1235,6 +1147,7 @@ static int dwc3_gadget_ep_queue(struct usb_ep *ep, struct usb_request *request,
 
         dev_vdbg(dwc->dev, "queing request %p to %s length %d\n",
                         request, ep->name, request->length);
+        trace_dwc3_ep_queue(req);
 
         ret = __dwc3_gadget_ep_queue(dep, req);
         spin_unlock_irqrestore(&dwc->lock, flags);
@@ -1254,6 +1167,8 @@ static int dwc3_gadget_ep_dequeue(struct usb_ep *ep,
         unsigned long                   flags;
         int                             ret = 0;
 
+        trace_dwc3_ep_dequeue(req);
+
         spin_lock_irqsave(&dwc->lock, flags);
 
         list_for_each_entry(r, &dep->request_list, list) {
@@ -1744,11 +1659,8 @@ static int dwc3_gadget_init_hw_endpoints(struct dwc3 *dwc,
                 u8 epnum = (i << 1) | (!!direction);
 
                 dep = kzalloc(sizeof(*dep), GFP_KERNEL);
-                if (!dep) {
-                        dev_err(dwc->dev, "can't allocate endpoint %d\n",
-                                        epnum);
+                if (!dep)
                         return -ENOMEM;
-                }
 
                 dep->dwc = dwc;
                 dep->number = epnum;
@@ -1847,6 +1759,8 @@ static int __dwc3_cleanup_done_trbs(struct dwc3 *dwc, struct dwc3_ep *dep,
         unsigned int            s_pkt = 0;
         unsigned int            trb_status;
 
+        trace_dwc3_complete_trb(dep, trb);
+
         if ((trb->ctrl & DWC3_TRB_CTRL_HWO) && status != -ESHUTDOWN)
                 /*
                  * We continue despite the error. There is not much we
@@ -2021,9 +1935,6 @@ static void dwc3_endpoint_interrupt(struct dwc3 *dwc,
         if (!(dep->flags & DWC3_EP_ENABLED))
                 return;
 
-        dev_vdbg(dwc->dev, "%s: %s\n", dep->name,
-                        dwc3_ep_event_string(event->endpoint_event));
-
         if (epnum == 0 || epnum == 1) {
                 dwc3_ep0_interrupt(dwc, event);
                 return;
@@ -2210,8 +2121,6 @@ static void dwc3_gadget_disconnect_interrupt(struct dwc3 *dwc)
 {
         int                     reg;
 
-        dev_vdbg(dwc->dev, "%s\n", __func__);
-
         reg = dwc3_readl(dwc->regs, DWC3_DCTL);
         reg &= ~DWC3_DCTL_INITU1ENA;
         dwc3_writel(dwc->regs, DWC3_DCTL, reg);
@@ -2230,8 +2139,6 @@ static void dwc3_gadget_reset_interrupt(struct dwc3 *dwc)
 {
         u32                     reg;
 
-        dev_vdbg(dwc->dev, "%s\n", __func__);
-
         /*
          * WORKAROUND: DWC3 revisions <1.88a have an issue which
          * would cause a missing Disconnect Event if there's a
@@ -2316,8 +2223,6 @@ static void dwc3_gadget_conndone_interrupt(struct dwc3 *dwc)
         u32                     reg;
         u8                      speed;
 
-        dev_vdbg(dwc->dev, "%s\n", __func__);
-
         reg = dwc3_readl(dwc->regs, DWC3_DSTS);
         speed = reg & DWC3_DSTS_CONNECTSPD;
         dwc->speed = speed;
@@ -2415,8 +2320,6 @@ static void dwc3_gadget_conndone_interrupt(struct dwc3 *dwc)
 
 static void dwc3_gadget_wakeup_interrupt(struct dwc3 *dwc)
 {
-        dev_vdbg(dwc->dev, "%s\n", __func__);
-
         /*
          * TODO take core out of low power mode when that's
          * implemented.
@@ -2521,10 +2424,6 @@ static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
                 break;
         }
 
-        dev_vdbg(dwc->dev, "link change: %s [%d] -> %s [%d]\n",
-                        dwc3_gadget_link_string(dwc->link_state),
-                        dwc->link_state, dwc3_gadget_link_string(next), next);
-
         dwc->link_state = next;
 }
 
@@ -2601,6 +2500,8 @@ static void dwc3_gadget_interrupt(struct dwc3 *dwc,
 static void dwc3_process_event_entry(struct dwc3 *dwc,
                 const union dwc3_event *event)
 {
+        trace_dwc3_event(event->raw);
+
         /* Endpoint IRQ, handle it and return early */
         if (event->type.is_devspec == 0) {
                 /* depevt */
@@ -2754,7 +2655,6 @@ int dwc3_gadget_init(struct dwc3 *dwc)
 
         dwc->setup_buf = kzalloc(DWC3_EP0_BOUNCE_SIZE, GFP_KERNEL);
         if (!dwc->setup_buf) {
-                dev_err(dwc->dev, "failed to allocate setup buffer\n");
                 ret = -ENOMEM;
                 goto err2;
         }
diff --git a/drivers/usb/dwc3/gadget.h b/drivers/usb/dwc3/gadget.h
index a0ee75b68a80..178ad8982206 100644
--- a/drivers/usb/dwc3/gadget.h
+++ b/drivers/usb/dwc3/gadget.h
@@ -103,60 +103,4 @@ static inline u32 dwc3_gadget_ep_get_transfer_index(struct dwc3 *dwc, u8 number)
         return DWC3_DEPCMD_GET_RSC_IDX(res_id);
 }
 
-/**
- * dwc3_gadget_event_string - returns event name
- * @event: the event code
- */
-static inline const char *dwc3_gadget_event_string(u8 event)
-{
-        switch (event) {
-        case DWC3_DEVICE_EVENT_DISCONNECT:
-                return "Disconnect";
-        case DWC3_DEVICE_EVENT_RESET:
-                return "Reset";
-        case DWC3_DEVICE_EVENT_CONNECT_DONE:
-                return "Connection Done";
-        case DWC3_DEVICE_EVENT_LINK_STATUS_CHANGE:
-                return "Link Status Change";
-        case DWC3_DEVICE_EVENT_WAKEUP:
-                return "WakeUp";
-        case DWC3_DEVICE_EVENT_EOPF:
-                return "End-Of-Frame";
-        case DWC3_DEVICE_EVENT_SOF:
-                return "Start-Of-Frame";
-        case DWC3_DEVICE_EVENT_ERRATIC_ERROR:
-                return "Erratic Error";
-        case DWC3_DEVICE_EVENT_CMD_CMPL:
-                return "Command Complete";
-        case DWC3_DEVICE_EVENT_OVERFLOW:
-                return "Overflow";
-        }
-
-        return "UNKNOWN";
-}
-
-/**
- * dwc3_ep_event_string - returns event name
- * @event: then event code
- */
-static inline const char *dwc3_ep_event_string(u8 event)
-{
-        switch (event) {
-        case DWC3_DEPEVT_XFERCOMPLETE:
-                return "Transfer Complete";
-        case DWC3_DEPEVT_XFERINPROGRESS:
-                return "Transfer In-Progress";
-        case DWC3_DEPEVT_XFERNOTREADY:
-                return "Transfer Not Ready";
-        case DWC3_DEPEVT_RXTXFIFOEVT:
-                return "FIFO";
-        case DWC3_DEPEVT_STREAMEVT:
-                return "Stream";
-        case DWC3_DEPEVT_EPCMDCMPLT:
-                return "Endpoint Command Complete";
-        }
-
-        return "UNKNOWN";
-}
-
 #endif /* __DRIVERS_USB_DWC3_GADGET_H */
diff --git a/drivers/usb/dwc3/io.h b/drivers/usb/dwc3/io.h
index d94441c14d8c..6a79c8e66bbc 100644
--- a/drivers/usb/dwc3/io.h
+++ b/drivers/usb/dwc3/io.h
@@ -20,27 +20,51 @@
 #define __DRIVERS_USB_DWC3_IO_H
 
 #include <linux/io.h>
-
+#include "trace.h"
+#include "debug.h"
 #include "core.h"
 
 static inline u32 dwc3_readl(void __iomem *base, u32 offset)
 {
+        u32 offs = offset - DWC3_GLOBALS_REGS_START;
+        u32 value;
+
         /*
          * We requested the mem region starting from the Globals address
          * space, see dwc3_probe in core.c.
          * However, the offsets are given starting from xHCI address space.
          */
-        return readl(base + (offset - DWC3_GLOBALS_REGS_START));
+        value = readl(base + offs);
+
+        /*
+         * When tracing we want to make it easy to find the correct address on
+         * documentation, so we revert it back to the proper addresses, the
+         * same way they are described on SNPS documentation
+         */
+        dwc3_trace(trace_dwc3_readl, "addr %p value %08x",
+                        base - DWC3_GLOBALS_REGS_START + offset, value);
+
+        return value;
 }
 
 static inline void dwc3_writel(void __iomem *base, u32 offset, u32 value)
 {
+        u32 offs = offset - DWC3_GLOBALS_REGS_START;
+
         /*
          * We requested the mem region starting from the Globals address
          * space, see dwc3_probe in core.c.
          * However, the offsets are given starting from xHCI address space.
          */
-        writel(value, base + (offset - DWC3_GLOBALS_REGS_START));
+        writel(value, base + offs);
+
+        /*
+         * When tracing we want to make it easy to find the correct address on
+         * documentation, so we revert it back to the proper addresses, the
+         * same way they are described on SNPS documentation
+         */
+        dwc3_trace(trace_dwc3_writel, "addr %p value %08x",
+                        base - DWC3_GLOBALS_REGS_START + offset, value);
 }
 
 #endif /* __DRIVERS_USB_DWC3_IO_H */
diff --git a/drivers/usb/dwc3/trace.c b/drivers/usb/dwc3/trace.c
new file mode 100644
index 000000000000..6cd166412ad0
--- /dev/null
+++ b/drivers/usb/dwc3/trace.c
@@ -0,0 +1,19 @@
+/**
+ * trace.c - DesignWare USB3 DRD Controller Trace Support
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Felipe Balbi <balbi@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2  of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#define CREATE_TRACE_POINTS
+#include "trace.h"
diff --git a/drivers/usb/dwc3/trace.h b/drivers/usb/dwc3/trace.h
new file mode 100644
index 000000000000..78aff1da089a
--- /dev/null
+++ b/drivers/usb/dwc3/trace.h
@@ -0,0 +1,220 @@
+/**
+ * trace.h - DesignWare USB3 DRD Controller Trace Support
+ *
+ * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * Author: Felipe Balbi <balbi@ti.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2  of
+ * the License as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM dwc3
+
+#if !defined(__DWC3_TRACE_H) || defined(TRACE_HEADER_MULTI_READ)
+#define __DWC3_TRACE_H
+
+#include <linux/types.h>
+#include <linux/tracepoint.h>
+#include <asm/byteorder.h>
+#include "core.h"
+#include "debug.h"
+
+DECLARE_EVENT_CLASS(dwc3_log_msg,
+        TP_PROTO(struct va_format *vaf),
+        TP_ARGS(vaf),
+        TP_STRUCT__entry(__dynamic_array(char, msg, DWC3_MSG_MAX)),
+        TP_fast_assign(
+                vsnprintf(__get_str(msg), DWC3_MSG_MAX, vaf->fmt, *vaf->va);
+        ),
+        TP_printk("%s", __get_str(msg))
+);
+
+DEFINE_EVENT(dwc3_log_msg, dwc3_readl,
+        TP_PROTO(struct va_format *vaf),
+        TP_ARGS(vaf)
+);
+
+DEFINE_EVENT(dwc3_log_msg, dwc3_writel,
+        TP_PROTO(struct va_format *vaf),
+        TP_ARGS(vaf)
+);
+
+DEFINE_EVENT(dwc3_log_msg, dwc3_ep0,
+        TP_PROTO(struct va_format *vaf),
+        TP_ARGS(vaf)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_event,
+        TP_PROTO(u32 event),
+        TP_ARGS(event),
+        TP_STRUCT__entry(
+                __field(u32, event)
+        ),
+        TP_fast_assign(
+                __entry->event = event;
+        ),
+        TP_printk("event %08x\n", __entry->event)
+);
+
+DEFINE_EVENT(dwc3_log_event, dwc3_event,
+        TP_PROTO(u32 event),
+        TP_ARGS(event)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_ctrl,
+        TP_PROTO(struct usb_ctrlrequest *ctrl),
+        TP_ARGS(ctrl),
+        TP_STRUCT__entry(
+                __field(struct usb_ctrlrequest *, ctrl)
+        ),
+        TP_fast_assign(
+                __entry->ctrl = ctrl;
+        ),
+        TP_printk("bRequestType %02x bRequest %02x wValue %04x wIndex %04x wLength %d",
+                __entry->ctrl->bRequestType, __entry->ctrl->bRequest,
+                le16_to_cpu(__entry->ctrl->wValue), le16_to_cpu(__entry->ctrl->wIndex),
+                le16_to_cpu(__entry->ctrl->wLength)
+        )
+);
+
+DEFINE_EVENT(dwc3_log_ctrl, dwc3_ctrl_req,
+        TP_PROTO(struct usb_ctrlrequest *ctrl),
+        TP_ARGS(ctrl)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_request,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req),
+        TP_STRUCT__entry(
+                __field(struct dwc3_request *, req)
+        ),
+        TP_fast_assign(
+                __entry->req = req;
+        ),
+        TP_printk("%s: req %p length %u/%u ==> %d",
+                __entry->req->dep->name, __entry->req,
+                __entry->req->request.actual, __entry->req->request.length,
+                __entry->req->request.status
+        )
+);
+
+DEFINE_EVENT(dwc3_log_request, dwc3_alloc_request,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req)
+);
+
+DEFINE_EVENT(dwc3_log_request, dwc3_free_request,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req)
+);
+
+DEFINE_EVENT(dwc3_log_request, dwc3_ep_queue,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req)
+);
+
+DEFINE_EVENT(dwc3_log_request, dwc3_ep_dequeue,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req)
+);
+
+DEFINE_EVENT(dwc3_log_request, dwc3_gadget_giveback,
+        TP_PROTO(struct dwc3_request *req),
+        TP_ARGS(req)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_generic_cmd,
+        TP_PROTO(unsigned int cmd, u32 param),
+        TP_ARGS(cmd, param),
+        TP_STRUCT__entry(
+                __field(unsigned int, cmd)
+                __field(u32, param)
+        ),
+        TP_fast_assign(
+                __entry->cmd = cmd;
+                __entry->param = param;
+        ),
+        TP_printk("cmd '%s' [%d] param %08x\n",
+                dwc3_gadget_generic_cmd_string(__entry->cmd),
+                __entry->cmd, __entry->param
+        )
+);
+
+DEFINE_EVENT(dwc3_log_generic_cmd, dwc3_gadget_generic_cmd,
+        TP_PROTO(unsigned int cmd, u32 param),
+        TP_ARGS(cmd, param)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_gadget_ep_cmd,
+        TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
+                struct dwc3_gadget_ep_cmd_params *params),
+        TP_ARGS(dep, cmd, params),
+        TP_STRUCT__entry(
+                __field(struct dwc3_ep *, dep)
+                __field(unsigned int, cmd)
+                __field(struct dwc3_gadget_ep_cmd_params *, params)
+        ),
+        TP_fast_assign(
+                __entry->dep = dep;
+                __entry->cmd = cmd;
+                __entry->params = params;
+        ),
+        TP_printk("%s: cmd '%s' [%d] params %08x %08x %08x\n",
+                __entry->dep->name, dwc3_gadget_ep_cmd_string(__entry->cmd),
+                __entry->cmd, __entry->params->param0,
+                __entry->params->param1, __entry->params->param2
+        )
+);
+
+DEFINE_EVENT(dwc3_log_gadget_ep_cmd, dwc3_gadget_ep_cmd,
+        TP_PROTO(struct dwc3_ep *dep, unsigned int cmd,
+                struct dwc3_gadget_ep_cmd_params *params),
+        TP_ARGS(dep, cmd, params)
+);
+
+DECLARE_EVENT_CLASS(dwc3_log_trb,
+        TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
+        TP_ARGS(dep, trb),
+        TP_STRUCT__entry(
+                __field(struct dwc3_ep *, dep)
+                __field(struct dwc3_trb *, trb)
+        ),
+        TP_fast_assign(
+                __entry->dep = dep;
+                __entry->trb = trb;
+        ),
+        TP_printk("%s: trb %p bph %08x bpl %08x size %08x ctrl %08x\n",
+                __entry->dep->name, __entry->trb, __entry->trb->bph,
+                __entry->trb->bpl, __entry->trb->size, __entry->trb->ctrl
+        )
+);
+
+DEFINE_EVENT(dwc3_log_trb, dwc3_prepare_trb,
+        TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
+        TP_ARGS(dep, trb)
+);
+
+DEFINE_EVENT(dwc3_log_trb, dwc3_complete_trb,
+        TP_PROTO(struct dwc3_ep *dep, struct dwc3_trb *trb),
+        TP_ARGS(dep, trb)
+);
+
+#endif /* __DWC3_TRACE_H */
+
+/* this part has to be here */
+
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH .
+
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_FILE trace
+
+#include <trace/define_trace.h>
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 5c822afb6d70..c4880fc0d86e 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -181,6 +181,15 @@ config USB_F_MASS_STORAGE
 config USB_F_FS
         tristate
 
+config USB_F_UAC1
+        tristate
+
+config USB_F_UAC2
+        tristate
+
+config USB_F_UVC
+        tristate
+
 choice
         tristate "USB Gadget Drivers"
         default USB_ETH
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 9add915d41f7..598a67d6ba05 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -3,7 +3,7 @@
 #
 subdir-ccflags-$(CONFIG_USB_GADGET_DEBUG)       := -DDEBUG
 subdir-ccflags-$(CONFIG_USB_GADGET_VERBOSE)     += -DVERBOSE_DEBUG
-ccflags-y                               += -Idrivers/usb/gadget/udc
+ccflags-y                               += -I$(srctree)/drivers/usb/gadget/udc
 
 obj-$(CONFIG_USB_LIBCOMPOSITE)  += libcomposite.o
 libcomposite-y                  := usbstring.o config.o epautoconf.o
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 6935a822ce2b..a8c18df171c3 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -1956,7 +1956,6 @@ void composite_dev_cleanup(struct usb_composite_dev *cdev)
         }
         if (cdev->req) {
                 kfree(cdev->req->buf);
-                usb_ep_dequeue(cdev->gadget->ep0, cdev->req);
                 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
         }
         cdev->next_string_id = 0;
@@ -2073,6 +2072,7 @@ static const struct usb_gadget_driver composite_driver_template = {
         .unbind         = composite_unbind,
 
         .setup          = composite_setup,
+        .reset          = composite_disconnect,
         .disconnect     = composite_disconnect,
 
         .suspend        = composite_suspend,
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
index 811c2c7cc269..34034333f7f6 100644
--- a/drivers/usb/gadget/configfs.c
+++ b/drivers/usb/gadget/configfs.c
@@ -1450,6 +1450,7 @@ static const struct usb_gadget_driver configfs_driver_template = {
         .unbind         = configfs_composite_unbind,
 
         .setup          = composite_setup,
+        .reset          = composite_disconnect,
         .disconnect     = composite_disconnect,
 
         .max_speed      = USB_SPEED_SUPER,
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index 83ae1065149d..90701aa5a826 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -2,8 +2,8 @@
 # USB peripheral controller drivers
 #
 
-ccflags-y                       := -Idrivers/usb/gadget/
-ccflags-y                       += -Idrivers/usb/gadget/udc/
+ccflags-y                       := -I$(srctree)/drivers/usb/gadget/
+ccflags-y                       += -I$(srctree)/drivers/usb/gadget/udc/
 
 # USB Functions
 usb_f_acm-y                     := f_acm.o
@@ -32,3 +32,9 @@ usb_f_mass_storage-y		:= f_mass_storage.o storage_common.o
 obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
 usb_f_fs-y                      := f_fs.o
 obj-$(CONFIG_USB_F_FS)          += usb_f_fs.o
+usb_f_uac1-y                    := f_uac1.o u_uac1.o
+obj-$(CONFIG_USB_F_UAC1)        += usb_f_uac1.o
+usb_f_uac2-y                    := f_uac2.o
+obj-$(CONFIG_USB_F_UAC2)        += usb_f_uac2.o
+usb_f_uvc-y                     := f_uvc.o uvc_queue.o uvc_v4l2.o uvc_video.o
+obj-$(CONFIG_USB_F_UVC)         += usb_f_uvc.o
diff --git a/drivers/usb/gadget/function/f_acm.c b/drivers/usb/gadget/function/f_acm.c
index ab1065afbbd0..6da4685490ef 100644
--- a/drivers/usb/gadget/function/f_acm.c
+++ b/drivers/usb/gadget/function/f_acm.c
@@ -313,15 +313,15 @@ static void acm_complete_set_line_coding(struct usb_ep *ep,
         struct usb_composite_dev *cdev = acm->port.func.config->cdev;
 
         if (req->status != 0) {
-                DBG(cdev, "acm ttyGS%d completion, err %d\n",
-                                acm->port_num, req->status);
+                dev_dbg(&cdev->gadget->dev, "acm ttyGS%d completion, err %d\n",
+                        acm->port_num, req->status);
                 return;
         }
 
         /* normal completion */
         if (req->actual != sizeof(acm->port_line_coding)) {
-                DBG(cdev, "acm ttyGS%d short resp, len %d\n",
-                                acm->port_num, req->actual);
+                dev_dbg(&cdev->gadget->dev, "acm ttyGS%d short resp, len %d\n",
+                        acm->port_num, req->actual);
                 usb_ep_set_halt(ep);
         } else {
                 struct usb_cdc_line_coding      *value = req->buf;
@@ -397,14 +397,16 @@ static int acm_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 
         default:
 invalid:
-                VDBG(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
-                        ctrl->bRequestType, ctrl->bRequest,
-                        w_value, w_index, w_length);
+                dev_vdbg(&cdev->gadget->dev,
+                         "invalid control req%02x.%02x v%04x i%04x l%d\n",
+                         ctrl->bRequestType, ctrl->bRequest,
+                         w_value, w_index, w_length);
         }
 
         /* respond with data transfer or status phase? */
         if (value >= 0) {
-                DBG(cdev, "acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
+                dev_dbg(&cdev->gadget->dev,
+                        "acm ttyGS%d req%02x.%02x v%04x i%04x l%d\n",
                         acm->port_num, ctrl->bRequestType, ctrl->bRequest,
                         w_value, w_index, w_length);
                 req->zero = 0;
@@ -428,10 +430,12 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 
         if (intf == acm->ctrl_id) {
                 if (acm->notify->driver_data) {
-                        VDBG(cdev, "reset acm control interface %d\n", intf);
+                        dev_vdbg(&cdev->gadget->dev,
+                                 "reset acm control interface %d\n", intf);
                         usb_ep_disable(acm->notify);
                 } else {
-                        VDBG(cdev, "init acm ctrl interface %d\n", intf);
+                        dev_vdbg(&cdev->gadget->dev,
+                                 "init acm ctrl interface %d\n", intf);
                         if (config_ep_by_speed(cdev->gadget, f, acm->notify))
                                 return -EINVAL;
                 }
@@ -440,11 +444,13 @@ static int acm_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 
         } else if (intf == acm->data_id) {
                 if (acm->port.in->driver_data) {
-                        DBG(cdev, "reset acm ttyGS%d\n", acm->port_num);
+                        dev_dbg(&cdev->gadget->dev,
+                                "reset acm ttyGS%d\n", acm->port_num);
                         gserial_disconnect(&acm->port);
                 }
                 if (!acm->port.in->desc || !acm->port.out->desc) {
-                        DBG(cdev, "activate acm ttyGS%d\n", acm->port_num);
+                        dev_dbg(&cdev->gadget->dev,
+                                "activate acm ttyGS%d\n", acm->port_num);
                         if (config_ep_by_speed(cdev->gadget, f,
                                                acm->port.in) ||
                             config_ep_by_speed(cdev->gadget, f,
@@ -467,7 +473,7 @@ static void acm_disable(struct usb_function *f)
         struct f_acm    *acm = func_to_acm(f);
         struct usb_composite_dev *cdev = f->config->cdev;
 
-        DBG(cdev, "acm ttyGS%d deactivated\n", acm->port_num);
+        dev_dbg(&cdev->gadget->dev, "acm ttyGS%d deactivated\n", acm->port_num);
         gserial_disconnect(&acm->port);
         usb_ep_disable(acm->notify);
         acm->notify->driver_data = NULL;
@@ -537,8 +543,8 @@ static int acm_notify_serial_state(struct f_acm *acm)
 
         spin_lock(&acm->lock);
         if (acm->notify_req) {
-                DBG(cdev, "acm ttyGS%d serial state %04x\n",
-                                acm->port_num, acm->serial_state);
+                dev_dbg(&cdev->gadget->dev, "acm ttyGS%d serial state %04x\n",
+                        acm->port_num, acm->serial_state);
                 status = acm_cdc_notify(acm, USB_CDC_NOTIFY_SERIAL_STATE,
                                 0, &acm->serial_state, sizeof(acm->serial_state));
         } else {
@@ -691,12 +697,13 @@ acm_bind(struct usb_configuration *c, struct usb_function *f)
         if (status)
                 goto fail;
 
-        DBG(cdev, "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
-                        acm->port_num,
-                        gadget_is_superspeed(c->cdev->gadget) ? "super" :
-                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
-                        acm->port.in->name, acm->port.out->name,
-                        acm->notify->name);
+        dev_dbg(&cdev->gadget->dev,
+                "acm ttyGS%d: %s speed IN/%s OUT/%s NOTIFY/%s\n",
+                acm->port_num,
+                gadget_is_superspeed(c->cdev->gadget) ? "super" :
+                gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                acm->port.in->name, acm->port.out->name,
+                acm->notify->name);
         return 0;
 
 fail:
diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
index 0dc3552d1360..4ad11e03cf54 100644
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@ -1032,6 +1032,29 @@ static long ffs_epfile_ioctl(struct file *file, unsigned code,
                 case FUNCTIONFS_ENDPOINT_REVMAP:
                         ret = epfile->ep->num;
                         break;
+                case FUNCTIONFS_ENDPOINT_DESC:
+                {
+                        int desc_idx;
+                        struct usb_endpoint_descriptor *desc;
+
+                        switch (epfile->ffs->gadget->speed) {
+                        case USB_SPEED_SUPER:
+                                desc_idx = 2;
+                                break;
+                        case USB_SPEED_HIGH:
+                                desc_idx = 1;
+                                break;
+                        default:
+                                desc_idx = 0;
+                        }
+                        desc = epfile->ep->descs[desc_idx];
+
+                        spin_unlock_irq(&epfile->ffs->eps_lock);
+                        ret = copy_to_user((void *)value, desc, sizeof(*desc));
+                        if (ret)
+                                ret = -EFAULT;
+                        return ret;
+                }
                 default:
                         ret = -ENOTTY;
                 }
@@ -1534,7 +1557,10 @@ static int ffs_epfiles_create(struct ffs_data *ffs)
                 epfile->ffs = ffs;
                 mutex_init(&epfile->mutex);
                 init_waitqueue_head(&epfile->wait);
-                sprintf(epfiles->name, "ep%u",  i);
+                if (ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
+                        sprintf(epfiles->name, "ep%02x", ffs->eps_addrmap[i]);
+                else
+                        sprintf(epfiles->name, "ep%u", i);
                 if (!unlikely(ffs_sb_create_file(ffs->sb, epfiles->name, epfile,
                                                  &ffs_epfile_operations,
                                                  &epfile->dentry))) {
@@ -2083,10 +2109,12 @@ static int __ffs_data_got_descs(struct ffs_data *ffs,
                 break;
         case FUNCTIONFS_DESCRIPTORS_MAGIC_V2:
                 flags = get_unaligned_le32(data + 8);
+                ffs->user_flags = flags;
                 if (flags & ~(FUNCTIONFS_HAS_FS_DESC |
                               FUNCTIONFS_HAS_HS_DESC |
                               FUNCTIONFS_HAS_SS_DESC |
-                              FUNCTIONFS_HAS_MS_OS_DESC)) {
+                              FUNCTIONFS_HAS_MS_OS_DESC |
+                              FUNCTIONFS_VIRTUAL_ADDR)) {
                         ret = -ENOSYS;
                         goto error;
                 }
@@ -2346,7 +2374,8 @@ static void __ffs_event_add(struct ffs_data *ffs,
                 break;
 
         default:
-                BUG();
+                WARN(1, "%d: unknown event, this should not happen\n", type);
+                return;
         }
 
         {
@@ -2393,7 +2422,8 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         struct usb_endpoint_descriptor *ds = (void *)desc;
         struct ffs_function *func = priv;
         struct ffs_ep *ffs_ep;
-        unsigned ep_desc_id, idx;
+        unsigned ep_desc_id;
+        int idx;
         static const char *speed_names[] = { "full", "high", "super" };
 
         if (type != FFS_DESCRIPTOR)
@@ -2441,7 +2471,13 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
         } else {
                 struct usb_request *req;
                 struct usb_ep *ep;
+                u8 bEndpointAddress;
 
+                /*
+                 * We back up bEndpointAddress because autoconfig overwrites
+                 * it with physical endpoint address.
+                 */
+                bEndpointAddress = ds->bEndpointAddress;
                 pr_vdebug("autoconfig\n");
                 ep = usb_ep_autoconfig(func->gadget, ds);
                 if (unlikely(!ep))
@@ -2456,6 +2492,12 @@ static int __ffs_func_bind_do_descs(enum ffs_entity_type type, u8 *valuep,
                 ffs_ep->req = req;
                 func->eps_revmap[ds->bEndpointAddress &
                                  USB_ENDPOINT_NUMBER_MASK] = idx + 1;
+                /*
+                 * If we use virtual address mapping, we restore
+                 * original bEndpointAddress value.
+                 */
+                if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
+                        ds->bEndpointAddress = bEndpointAddress;
         }
         ffs_dump_mem(": Rewritten ep desc", ds, ds->bLength);
 
@@ -2900,6 +2942,8 @@ static int ffs_func_setup(struct usb_function *f,
                 ret = ffs_func_revmap_ep(func, le16_to_cpu(creq->wIndex));
                 if (unlikely(ret < 0))
                         return ret;
+                if (func->ffs->user_flags & FUNCTIONFS_VIRTUAL_ADDR)
+                        ret = func->ffs->eps_addrmap[ret];
                 break;
 
         default:
diff --git a/drivers/usb/gadget/function/f_loopback.c b/drivers/usb/gadget/function/f_loopback.c
index 4557cd03f0b1..bf04389137e6 100644
--- a/drivers/usb/gadget/function/f_loopback.c
+++ b/drivers/usb/gadget/function/f_loopback.c
@@ -298,7 +298,8 @@ static void disable_loopback(struct f_loopback *loop)
         struct usb_composite_dev        *cdev;
 
         cdev = loop->function.config->cdev;
-        disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL);
+        disable_endpoints(cdev, loop->in_ep, loop->out_ep, NULL, NULL, NULL,
+                        NULL);
         VDBG(cdev, "%s disabled\n", loop->function.name);
 }
 
diff --git a/drivers/usb/gadget/function/f_mass_storage.c b/drivers/usb/gadget/function/f_mass_storage.c
index b96393908860..811929cd4c9e 100644
--- a/drivers/usb/gadget/function/f_mass_storage.c
+++ b/drivers/usb/gadget/function/f_mass_storage.c
@@ -566,22 +566,22 @@ static void start_transfer(struct fsg_dev *fsg, struct usb_ep *ep,
         *pbusy = 1;
         *state = BUF_STATE_BUSY;
         spin_unlock_irq(&fsg->common->lock);
+
         rc = usb_ep_queue(ep, req, GFP_KERNEL);
-        if (rc != 0) {
-                *pbusy = 0;
-                *state = BUF_STATE_EMPTY;
+        if (rc == 0)
+                return;  /* All good, we're done */
 
-                /* We can't do much more than wait for a reset */
+        *pbusy = 0;
+        *state = BUF_STATE_EMPTY;
 
-                /*
-                 * Note: currently the net2280 driver fails zero-length
-                 * submissions if DMA is enabled.
-                 */
-                if (rc != -ESHUTDOWN &&
-                    !(rc == -EOPNOTSUPP && req->length == 0))
-                        WARNING(fsg, "error in submission: %s --> %d\n",
-                                ep->name, rc);
-        }
+        /* We can't do much more than wait for a reset */
+
+        /*
+         * Note: currently the net2280 driver fails zero-length
+         * submissions if DMA is enabled.
+         */
+        if (rc != -ESHUTDOWN && !(rc == -EOPNOTSUPP && req->length == 0))
+                WARNING(fsg, "error in submission: %s --> %d\n", ep->name, rc);
 }
 
 static bool start_in_transfer(struct fsg_common *common, struct fsg_buffhd *bh)
@@ -3665,4 +3665,3 @@ void fsg_config_from_params(struct fsg_config *cfg,
         cfg->fsg_num_buffers = fsg_num_buffers;
 }
 EXPORT_SYMBOL_GPL(fsg_config_from_params);
-
diff --git a/drivers/usb/gadget/function/f_obex.c b/drivers/usb/gadget/function/f_obex.c
index aebae1853bce..5f40080c92cc 100644
--- a/drivers/usb/gadget/function/f_obex.c
+++ b/drivers/usb/gadget/function/f_obex.c
@@ -200,19 +200,22 @@ static int obex_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 if (alt != 0)
                         goto fail;
                 /* NOP */
-                DBG(cdev, "reset obex ttyGS%d control\n", obex->port_num);
+                dev_dbg(&cdev->gadget->dev,
+                        "reset obex ttyGS%d control\n", obex->port_num);
 
         } else if (intf == obex->data_id) {
                 if (alt > 1)
                         goto fail;
 
                 if (obex->port.in->driver_data) {
-                        DBG(cdev, "reset obex ttyGS%d\n", obex->port_num);
+                        dev_dbg(&cdev->gadget->dev,
+                                "reset obex ttyGS%d\n", obex->port_num);
                         gserial_disconnect(&obex->port);
                 }
 
                 if (!obex->port.in->desc || !obex->port.out->desc) {
-                        DBG(cdev, "init obex ttyGS%d\n", obex->port_num);
+                        dev_dbg(&cdev->gadget->dev,
+                                "init obex ttyGS%d\n", obex->port_num);
                         if (config_ep_by_speed(cdev->gadget, f,
                                                obex->port.in) ||
                             config_ep_by_speed(cdev->gadget, f,
@@ -224,7 +227,8 @@ static int obex_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
                 }
 
                 if (alt == 1) {
-                        DBG(cdev, "activate obex ttyGS%d\n", obex->port_num);
+                        dev_dbg(&cdev->gadget->dev,
+                                "activate obex ttyGS%d\n", obex->port_num);
                         gserial_connect(&obex->port, obex->port_num);
                 }
 
@@ -252,7 +256,7 @@ static void obex_disable(struct usb_function *f)
         struct f_obex   *obex = func_to_obex(f);
         struct usb_composite_dev *cdev = f->config->cdev;
 
-        DBG(cdev, "obex ttyGS%d disable\n", obex->port_num);
+        dev_dbg(&cdev->gadget->dev, "obex ttyGS%d disable\n", obex->port_num);
         gserial_disconnect(&obex->port);
 }
 
@@ -269,7 +273,8 @@ static void obex_connect(struct gserial *g)
 
         status = usb_function_activate(&g->func);
         if (status)
-                DBG(cdev, "obex ttyGS%d function activate --> %d\n",
+                dev_dbg(&cdev->gadget->dev,
+                        "obex ttyGS%d function activate --> %d\n",
                         obex->port_num, status);
 }
 
@@ -284,7 +289,8 @@ static void obex_disconnect(struct gserial *g)
 
         status = usb_function_deactivate(&g->func);
         if (status)
-                DBG(cdev, "obex ttyGS%d function deactivate --> %d\n",
+                dev_dbg(&cdev->gadget->dev,
+                        "obex ttyGS%d function deactivate --> %d\n",
                         obex->port_num, status);
 }
 
@@ -383,10 +389,10 @@ static int obex_bind(struct usb_configuration *c, struct usb_function *f)
                 obex->can_activate = true;
 
 
-        DBG(cdev, "obex ttyGS%d: %s speed IN/%s OUT/%s\n",
-                        obex->port_num,
-                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
-                        obex->port.in->name, obex->port.out->name);
+        dev_dbg(&cdev->gadget->dev, "obex ttyGS%d: %s speed IN/%s OUT/%s\n",
+                obex->port_num,
+                gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                obex->port.in->name, obex->port.out->name);
 
         return 0;
 
diff --git a/drivers/usb/gadget/function/f_serial.c b/drivers/usb/gadget/function/f_serial.c
index 9ecbcbf36a45..2e02dfabc7ae 100644
--- a/drivers/usb/gadget/function/f_serial.c
+++ b/drivers/usb/gadget/function/f_serial.c
@@ -155,11 +155,13 @@ static int gser_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         /* we know alt == 0, so this is an activation or a reset */
 
         if (gser->port.in->driver_data) {
-                DBG(cdev, "reset generic ttyGS%d\n", gser->port_num);
+                dev_dbg(&cdev->gadget->dev,
+                        "reset generic ttyGS%d\n", gser->port_num);
                 gserial_disconnect(&gser->port);
         }
         if (!gser->port.in->desc || !gser->port.out->desc) {
-                DBG(cdev, "activate generic ttyGS%d\n", gser->port_num);
+                dev_dbg(&cdev->gadget->dev,
+                        "activate generic ttyGS%d\n", gser->port_num);
                 if (config_ep_by_speed(cdev->gadget, f, gser->port.in) ||
                     config_ep_by_speed(cdev->gadget, f, gser->port.out)) {
                         gser->port.in->desc = NULL;
@@ -176,7 +178,8 @@ static void gser_disable(struct usb_function *f)
         struct f_gser   *gser = func_to_gser(f);
         struct usb_composite_dev *cdev = f->config->cdev;
 
-        DBG(cdev, "generic ttyGS%d deactivated\n", gser->port_num);
+        dev_dbg(&cdev->gadget->dev,
+                "generic ttyGS%d deactivated\n", gser->port_num);
         gserial_disconnect(&gser->port);
 }
 
@@ -239,11 +242,11 @@ static int gser_bind(struct usb_configuration *c, struct usb_function *f)
                         gser_ss_function);
         if (status)
                 goto fail;
-        DBG(cdev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
-                        gser->port_num,
-                        gadget_is_superspeed(c->cdev->gadget) ? "super" :
-                        gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
-                        gser->port.in->name, gser->port.out->name);
+        dev_dbg(&cdev->gadget->dev, "generic ttyGS%d: %s speed IN/%s OUT/%s\n",
+                gser->port_num,
+                gadget_is_superspeed(c->cdev->gadget) ? "super" :
+                gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full",
+                gser->port.in->name, gser->port.out->name);
         return 0;
 
 fail:
diff --git a/drivers/usb/gadget/function/f_sourcesink.c b/drivers/usb/gadget/function/f_sourcesink.c
index d3cd52db78fe..80be25b32cd7 100644
--- a/drivers/usb/gadget/function/f_sourcesink.c
+++ b/drivers/usb/gadget/function/f_sourcesink.c
@@ -23,6 +23,15 @@
 #include "gadget_chips.h"
 #include "u_f.h"
 
+#define USB_MS_TO_SS_INTERVAL(x) USB_MS_TO_HS_INTERVAL(x)
+
+enum eptype {
+        EP_CONTROL = 0,
+        EP_BULK,
+        EP_ISOC,
+        EP_INTERRUPT,
+};
+
 /*
  * SOURCE/SINK FUNCTION ... a primary testing vehicle for USB peripheral
  * controller drivers.
@@ -55,6 +64,8 @@ struct f_sourcesink {
         struct usb_ep           *out_ep;
         struct usb_ep           *iso_in_ep;
         struct usb_ep           *iso_out_ep;
+        struct usb_ep           *int_in_ep;
+        struct usb_ep           *int_out_ep;
         int                     cur_alt;
 };
 
@@ -68,6 +79,10 @@ static unsigned isoc_interval;
 static unsigned isoc_maxpacket;
 static unsigned isoc_mult;
 static unsigned isoc_maxburst;
+static unsigned int_interval; /* In ms */
+static unsigned int_maxpacket;
+static unsigned int_mult;
+static unsigned int_maxburst;
 static unsigned buflen;
 
 /*-------------------------------------------------------------------------*/
@@ -92,6 +107,16 @@ static struct usb_interface_descriptor source_sink_intf_alt1 = {
         /* .iInterface          = DYNAMIC */
 };
 
+static struct usb_interface_descriptor source_sink_intf_alt2 = {
+        .bLength =              USB_DT_INTERFACE_SIZE,
+        .bDescriptorType =      USB_DT_INTERFACE,
+
+        .bAlternateSetting =    2,
+        .bNumEndpoints =        2,
+        .bInterfaceClass =      USB_CLASS_VENDOR_SPEC,
+        /* .iInterface          = DYNAMIC */
+};
+
 /* full speed support: */
 
 static struct usb_endpoint_descriptor fs_source_desc = {
@@ -130,6 +155,26 @@ static struct usb_endpoint_descriptor fs_iso_sink_desc = {
         .bInterval =            4,
 };
 
+static struct usb_endpoint_descriptor fs_int_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_IN,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(64),
+        .bInterval =            GZERO_INT_INTERVAL,
+};
+
+static struct usb_endpoint_descriptor fs_int_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bEndpointAddress =     USB_DIR_OUT,
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(64),
+        .bInterval =            GZERO_INT_INTERVAL,
+};
+
 static struct usb_descriptor_header *fs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &fs_sink_desc,
@@ -140,6 +185,10 @@ static struct usb_descriptor_header *fs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &fs_source_desc,
         (struct usb_descriptor_header *) &fs_iso_sink_desc,
         (struct usb_descriptor_header *) &fs_iso_source_desc,
+        (struct usb_descriptor_header *) &source_sink_intf_alt2,
+#define FS_ALT_IFC_2_OFFSET     8
+        (struct usb_descriptor_header *) &fs_int_sink_desc,
+        (struct usb_descriptor_header *) &fs_int_source_desc,
         NULL,
 };
 
@@ -179,6 +228,24 @@ static struct usb_endpoint_descriptor hs_iso_sink_desc = {
         .bInterval =            4,
 };
 
+static struct usb_endpoint_descriptor hs_int_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+        .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
+};
+
+static struct usb_endpoint_descriptor hs_int_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+        .bInterval =            USB_MS_TO_HS_INTERVAL(GZERO_INT_INTERVAL),
+};
+
 static struct usb_descriptor_header *hs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &hs_source_desc,
@@ -189,6 +256,10 @@ static struct usb_descriptor_header *hs_source_sink_descs[] = {
         (struct usb_descriptor_header *) &hs_sink_desc,
         (struct usb_descriptor_header *) &hs_iso_source_desc,
         (struct usb_descriptor_header *) &hs_iso_sink_desc,
+        (struct usb_descriptor_header *) &source_sink_intf_alt2,
+#define HS_ALT_IFC_2_OFFSET     8
+        (struct usb_descriptor_header *) &hs_int_source_desc,
+        (struct usb_descriptor_header *) &hs_int_sink_desc,
         NULL,
 };
 
@@ -264,6 +335,42 @@ static struct usb_ss_ep_comp_descriptor ss_iso_sink_comp_desc = {
         .wBytesPerInterval =    cpu_to_le16(1024),
 };
 
+static struct usb_endpoint_descriptor ss_int_source_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+        .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
+};
+
+struct usb_ss_ep_comp_descriptor ss_int_source_comp_desc = {
+        .bLength =              USB_DT_SS_EP_COMP_SIZE,
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+
+        .bMaxBurst =            0,
+        .bmAttributes =         0,
+        .wBytesPerInterval =    cpu_to_le16(1024),
+};
+
+static struct usb_endpoint_descriptor ss_int_sink_desc = {
+        .bLength =              USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType =      USB_DT_ENDPOINT,
+
+        .bmAttributes =         USB_ENDPOINT_XFER_INT,
+        .wMaxPacketSize =       cpu_to_le16(1024),
+        .bInterval =            USB_MS_TO_SS_INTERVAL(GZERO_INT_INTERVAL),
+};
+
+struct usb_ss_ep_comp_descriptor ss_int_sink_comp_desc = {
+        .bLength =              USB_DT_SS_EP_COMP_SIZE,
+        .bDescriptorType =      USB_DT_SS_ENDPOINT_COMP,
+
+        .bMaxBurst =            0,
+        .bmAttributes =         0,
+        .wBytesPerInterval =    cpu_to_le16(1024),
+};
+
 static struct usb_descriptor_header *ss_source_sink_descs[] = {
         (struct usb_descriptor_header *) &source_sink_intf_alt0,
         (struct usb_descriptor_header *) &ss_source_desc,
@@ -280,6 +387,12 @@ static struct usb_descriptor_header *ss_source_sink_descs[] = {
         (struct usb_descriptor_header *) &ss_iso_source_comp_desc,
         (struct usb_descriptor_header *) &ss_iso_sink_desc,
         (struct usb_descriptor_header *) &ss_iso_sink_comp_desc,
+        (struct usb_descriptor_header *) &source_sink_intf_alt2,
+#define SS_ALT_IFC_2_OFFSET     14
+        (struct usb_descriptor_header *) &ss_int_source_desc,
+        (struct usb_descriptor_header *) &ss_int_source_comp_desc,
+        (struct usb_descriptor_header *) &ss_int_sink_desc,
+        (struct usb_descriptor_header *) &ss_int_sink_comp_desc,
         NULL,
 };
 
@@ -301,6 +414,21 @@ static struct usb_gadget_strings *sourcesink_strings[] = {
 };
 
 /*-------------------------------------------------------------------------*/
+static const char *get_ep_string(enum eptype ep_type)
+{
+        switch (ep_type) {
+        case EP_ISOC:
+                return "ISOC-";
+        case EP_INTERRUPT:
+                return "INTERRUPT-";
+        case EP_CONTROL:
+                return "CTRL-";
+        case EP_BULK:
+                return "BULK-";
+        default:
+                return "UNKNOWN-";
+        }
+}
 
 static inline struct usb_request *ss_alloc_ep_req(struct usb_ep *ep, int len)
 {
@@ -328,7 +456,8 @@ static void disable_ep(struct usb_composite_dev *cdev, struct usb_ep *ep)
 
 void disable_endpoints(struct usb_composite_dev *cdev,
                 struct usb_ep *in, struct usb_ep *out,
-                struct usb_ep *iso_in, struct usb_ep *iso_out)
+                struct usb_ep *iso_in, struct usb_ep *iso_out,
+                struct usb_ep *int_in, struct usb_ep *int_out)
 {
         disable_ep(cdev, in);
         disable_ep(cdev, out);
@@ -336,6 +465,10 @@ void disable_endpoints(struct usb_composite_dev *cdev,
                 disable_ep(cdev, iso_in);
         if (iso_out)
                 disable_ep(cdev, iso_out);
+        if (int_in)
+                disable_ep(cdev, int_in);
+        if (int_out)
+                disable_ep(cdev, int_out);
 }
 
 static int
@@ -352,6 +485,7 @@ sourcesink_bind(struct usb_configuration *c, struct usb_function *f)
                 return id;
         source_sink_intf_alt0.bInterfaceNumber = id;
         source_sink_intf_alt1.bInterfaceNumber = id;
+        source_sink_intf_alt2.bInterfaceNumber = id;
 
         /* allocate bulk endpoints */
         ss->in_ep = usb_ep_autoconfig(cdev->gadget, &fs_source_desc);
@@ -412,14 +546,55 @@ no_iso:
         if (isoc_maxpacket > 1024)
                 isoc_maxpacket = 1024;
 
+        /* sanity check the interrupt module parameters */
+        if (int_interval < 1)
+                int_interval = 1;
+        if (int_interval > 4096)
+                int_interval = 4096;
+        if (int_mult > 2)
+                int_mult = 2;
+        if (int_maxburst > 15)
+                int_maxburst = 15;
+
+        /* fill in the FS interrupt descriptors from the module parameters */
+        fs_int_source_desc.wMaxPacketSize = int_maxpacket > 64 ?
+                                                64 : int_maxpacket;
+        fs_int_source_desc.bInterval = int_interval > 255 ?
+                                                255 : int_interval;
+        fs_int_sink_desc.wMaxPacketSize = int_maxpacket > 64 ?
+                                                64 : int_maxpacket;
+        fs_int_sink_desc.bInterval = int_interval > 255 ?
+                                                255 : int_interval;
+
+        /* allocate int endpoints */
+        ss->int_in_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_source_desc);
+        if (!ss->int_in_ep)
+                goto no_int;
+        ss->int_in_ep->driver_data = cdev;      /* claim */
+
+        ss->int_out_ep = usb_ep_autoconfig(cdev->gadget, &fs_int_sink_desc);
+        if (ss->int_out_ep) {
+                ss->int_out_ep->driver_data = cdev;     /* claim */
+        } else {
+                ss->int_in_ep->driver_data = NULL;
+                ss->int_in_ep = NULL;
+no_int:
+                fs_source_sink_descs[FS_ALT_IFC_2_OFFSET] = NULL;
+                hs_source_sink_descs[HS_ALT_IFC_2_OFFSET] = NULL;
+                ss_source_sink_descs[SS_ALT_IFC_2_OFFSET] = NULL;
+        }
+
+        if (int_maxpacket > 1024)
+                int_maxpacket = 1024;
+
         /* support high speed hardware */
         hs_source_desc.bEndpointAddress = fs_source_desc.bEndpointAddress;
         hs_sink_desc.bEndpointAddress = fs_sink_desc.bEndpointAddress;
 
         /*
-         * Fill in the HS isoc descriptors from the module parameters.
-         * We assume that the user knows what they are doing and won't
-         * give parameters that their UDC doesn't support.
+         * Fill in the HS isoc and interrupt descriptors from the module
+         * parameters. We assume that the user knows what they are doing and
+         * won't give parameters that their UDC doesn't support.
          */
         hs_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
         hs_iso_source_desc.wMaxPacketSize |= isoc_mult << 11;
@@ -432,6 +607,17 @@ no_iso:
         hs_iso_sink_desc.bInterval = isoc_interval;
         hs_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 
+        hs_int_source_desc.wMaxPacketSize = int_maxpacket;
+        hs_int_source_desc.wMaxPacketSize |= int_mult << 11;
+        hs_int_source_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
+        hs_int_source_desc.bEndpointAddress =
+                fs_int_source_desc.bEndpointAddress;
+
+        hs_int_sink_desc.wMaxPacketSize = int_maxpacket;
+        hs_int_sink_desc.wMaxPacketSize |= int_mult << 11;
+        hs_int_sink_desc.bInterval = USB_MS_TO_HS_INTERVAL(int_interval);
+        hs_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
+
         /* support super speed hardware */
         ss_source_desc.bEndpointAddress =
                 fs_source_desc.bEndpointAddress;
@@ -439,9 +625,9 @@ no_iso:
                 fs_sink_desc.bEndpointAddress;
 
         /*
-         * Fill in the SS isoc descriptors from the module parameters.
-         * We assume that the user knows what they are doing and won't
-         * give parameters that their UDC doesn't support.
+         * Fill in the SS isoc and interrupt descriptors from the module
+         * parameters. We assume that the user knows what they are doing and
+         * won't give parameters that their UDC doesn't support.
          */
         ss_iso_source_desc.wMaxPacketSize = isoc_maxpacket;
         ss_iso_source_desc.bInterval = isoc_interval;
@@ -460,17 +646,37 @@ no_iso:
                 isoc_maxpacket * (isoc_mult + 1) * (isoc_maxburst + 1);
         ss_iso_sink_desc.bEndpointAddress = fs_iso_sink_desc.bEndpointAddress;
 
+        ss_int_source_desc.wMaxPacketSize = int_maxpacket;
+        ss_int_source_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
+        ss_int_source_comp_desc.bmAttributes = int_mult;
+        ss_int_source_comp_desc.bMaxBurst = int_maxburst;
+        ss_int_source_comp_desc.wBytesPerInterval =
+                int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
+        ss_int_source_desc.bEndpointAddress =
+                fs_int_source_desc.bEndpointAddress;
+
+        ss_int_sink_desc.wMaxPacketSize = int_maxpacket;
+        ss_int_sink_desc.bInterval = USB_MS_TO_SS_INTERVAL(int_interval);
+        ss_int_sink_comp_desc.bmAttributes = int_mult;
+        ss_int_sink_comp_desc.bMaxBurst = int_maxburst;
+        ss_int_sink_comp_desc.wBytesPerInterval =
+                int_maxpacket * (int_mult + 1) * (int_maxburst + 1);
+        ss_int_sink_desc.bEndpointAddress = fs_int_sink_desc.bEndpointAddress;
+
         ret = usb_assign_descriptors(f, fs_source_sink_descs,
                         hs_source_sink_descs, ss_source_sink_descs);
         if (ret)
                 return ret;
 
-        DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s\n",
+        DBG(cdev, "%s speed %s: IN/%s, OUT/%s, ISO-IN/%s, ISO-OUT/%s, "
+                        "INT-IN/%s, INT-OUT/%s\n",
             (gadget_is_superspeed(c->cdev->gadget) ? "super" :
              (gadget_is_dualspeed(c->cdev->gadget) ? "dual" : "full")),
                         f->name, ss->in_ep->name, ss->out_ep->name,
                         ss->iso_in_ep ? ss->iso_in_ep->name : "<none>",
-                        ss->iso_out_ep ? ss->iso_out_ep->name : "<none>");
+                        ss->iso_out_ep ? ss->iso_out_ep->name : "<none>",
+                        ss->int_in_ep ? ss->int_in_ep->name : "<none>",
+                        ss->int_out_ep ? ss->int_out_ep->name : "<none>");
         return 0;
 }
 
@@ -601,14 +807,15 @@ static void source_sink_complete(struct usb_ep *ep, struct usb_request *req)
 }
 
 static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
-                bool is_iso, int speed)
+                enum eptype ep_type, int speed)
 {
         struct usb_ep           *ep;
         struct usb_request      *req;
         int                     i, size, status;
 
         for (i = 0; i < 8; i++) {
-                if (is_iso) {
+                switch (ep_type) {
+                case EP_ISOC:
                         switch (speed) {
                         case USB_SPEED_SUPER:
                                 size = isoc_maxpacket * (isoc_mult + 1) *
@@ -624,9 +831,28 @@ static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
                         }
                         ep = is_in ? ss->iso_in_ep : ss->iso_out_ep;
                         req = ss_alloc_ep_req(ep, size);
-                } else {
+                        break;
+                case EP_INTERRUPT:
+                        switch (speed) {
+                        case USB_SPEED_SUPER:
+                                size = int_maxpacket * (int_mult + 1) *
+                                                (int_maxburst + 1);
+                                break;
+                        case USB_SPEED_HIGH:
+                                size = int_maxpacket * (int_mult + 1);
+                                break;
+                        default:
+                                size = int_maxpacket > 1023 ?
+                                                1023 : int_maxpacket;
+                                break;
+                        }
+                        ep = is_in ? ss->int_in_ep : ss->int_out_ep;
+                        req = ss_alloc_ep_req(ep, size);
+                        break;
+                default:
                         ep = is_in ? ss->in_ep : ss->out_ep;
                         req = ss_alloc_ep_req(ep, 0);
+                        break;
                 }
 
                 if (!req)
@@ -644,12 +870,12 @@ static int source_sink_start_ep(struct f_sourcesink *ss, bool is_in,
 
                         cdev = ss->function.config->cdev;
                         ERROR(cdev, "start %s%s %s --> %d\n",
-                              is_iso ? "ISO-" : "", is_in ? "IN" : "OUT",
-                              ep->name, status);
+                                get_ep_string(ep_type), is_in ? "IN" : "OUT",
+                                ep->name, status);
                         free_ep_req(ep, req);
                 }
 
-                if (!is_iso)
+                if (!(ep_type == EP_ISOC))
                         break;
         }
 
@@ -662,7 +888,7 @@ static void disable_source_sink(struct f_sourcesink *ss)
 
         cdev = ss->function.config->cdev;
         disable_endpoints(cdev, ss->in_ep, ss->out_ep, ss->iso_in_ep,
-                        ss->iso_out_ep);
+                        ss->iso_out_ep, ss->int_in_ep, ss->int_out_ep);
         VDBG(cdev, "%s disabled\n", ss->function.name);
 }
 
@@ -674,6 +900,62 @@ enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
         int                                     speed = cdev->gadget->speed;
         struct usb_ep                           *ep;
 
+        if (alt == 2) {
+                /* Configure for periodic interrupt endpoint */
+                ep = ss->int_in_ep;
+                if (ep) {
+                        result = config_ep_by_speed(cdev->gadget,
+                                        &(ss->function), ep);
+                        if (result)
+                                return result;
+
+                        result = usb_ep_enable(ep);
+                        if (result < 0)
+                                return result;
+
+                        ep->driver_data = ss;
+                        result = source_sink_start_ep(ss, true, EP_INTERRUPT,
+                                        speed);
+                        if (result < 0) {
+fail1:
+                                ep = ss->int_in_ep;
+                                if (ep) {
+                                        usb_ep_disable(ep);
+                                        ep->driver_data = NULL;
+                                }
+                                return result;
+                        }
+                }
+
+                /*
+                 * one interrupt endpoint reads (sinks) anything OUT (from the
+                 * host)
+                 */
+                ep = ss->int_out_ep;
+                if (ep) {
+                        result = config_ep_by_speed(cdev->gadget,
+                                        &(ss->function), ep);
+                        if (result)
+                                goto fail1;
+
+                        result = usb_ep_enable(ep);
+                        if (result < 0)
+                                goto fail1;
+
+                        ep->driver_data = ss;
+                        result = source_sink_start_ep(ss, false, EP_INTERRUPT,
+                                        speed);
+                        if (result < 0) {
+                                ep = ss->int_out_ep;
+                                usb_ep_disable(ep);
+                                ep->driver_data = NULL;
+                                goto fail1;
+                        }
+                }
+
+                goto out;
+        }
+
         /* one bulk endpoint writes (sources) zeroes IN (to the host) */
         ep = ss->in_ep;
         result = config_ep_by_speed(cdev->gadget, &(ss->function), ep);
@@ -684,7 +966,7 @@ enable_source_sink(struct usb_composite_dev *cdev, struct f_sourcesink *ss,
                 return result;
         ep->driver_data = ss;
 
-        result = source_sink_start_ep(ss, true, false, speed);
+        result = source_sink_start_ep(ss, true, EP_BULK, speed);
         if (result < 0) {
 fail:
                 ep = ss->in_ep;
@@ -703,7 +985,7 @@ fail:
                 goto fail;
         ep->driver_data = ss;
 
-        result = source_sink_start_ep(ss, false, false, speed);
+        result = source_sink_start_ep(ss, false, EP_BULK, speed);
         if (result < 0) {
 fail2:
                 ep = ss->out_ep;
@@ -726,7 +1008,7 @@ fail2:
                         goto fail2;
                 ep->driver_data = ss;
 
-                result = source_sink_start_ep(ss, true, true, speed);
+                result = source_sink_start_ep(ss, true, EP_ISOC, speed);
                 if (result < 0) {
 fail3:
                         ep = ss->iso_in_ep;
@@ -749,13 +1031,14 @@ fail3:
                         goto fail3;
                 ep->driver_data = ss;
 
-                result = source_sink_start_ep(ss, false, true, speed);
+                result = source_sink_start_ep(ss, false, EP_ISOC, speed);
                 if (result < 0) {
                         usb_ep_disable(ep);
                         ep->driver_data = NULL;
                         goto fail3;
                 }
         }
+
 out:
         ss->cur_alt = alt;
 
@@ -771,6 +1054,8 @@ static int sourcesink_set_alt(struct usb_function *f,
 
         if (ss->in_ep->driver_data)
                 disable_source_sink(ss);
+        else if (alt == 2 && ss->int_in_ep->driver_data)
+                disable_source_sink(ss);
         return enable_source_sink(cdev, ss, alt);
 }
 
@@ -883,6 +1168,10 @@ static struct usb_function *source_sink_alloc_func(
         isoc_maxpacket = ss_opts->isoc_maxpacket;
         isoc_mult = ss_opts->isoc_mult;
         isoc_maxburst = ss_opts->isoc_maxburst;
+        int_interval = ss_opts->int_interval;
+        int_maxpacket = ss_opts->int_maxpacket;
+        int_mult = ss_opts->int_mult;
+        int_maxburst = ss_opts->int_maxburst;
         buflen = ss_opts->bulk_buflen;
 
         ss->function.name = "source/sink";
@@ -1179,6 +1468,182 @@ static struct f_ss_opts_attribute f_ss_opts_bulk_buflen =
                         f_ss_opts_bulk_buflen_show,
                         f_ss_opts_bulk_buflen_store);
 
+static ssize_t f_ss_opts_int_interval_show(struct f_ss_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->int_interval);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_ss_opts_int_interval_store(struct f_ss_opts *opts,
+                                       const char *page, size_t len)
+{
+        int ret;
+        u32 num;
+
+        mutex_lock(&opts->lock);
+        if (opts->refcnt) {
+                ret = -EBUSY;
+                goto end;
+        }
+
+        ret = kstrtou32(page, 0, &num);
+        if (ret)
+                goto end;
+
+        if (num > 4096) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        opts->int_interval = num;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_ss_opts_attribute f_ss_opts_int_interval =
+        __CONFIGFS_ATTR(int_interval, S_IRUGO | S_IWUSR,
+                        f_ss_opts_int_interval_show,
+                        f_ss_opts_int_interval_store);
+
+static ssize_t f_ss_opts_int_maxpacket_show(struct f_ss_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->int_maxpacket);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_ss_opts_int_maxpacket_store(struct f_ss_opts *opts,
+                                       const char *page, size_t len)
+{
+        int ret;
+        u16 num;
+
+        mutex_lock(&opts->lock);
+        if (opts->refcnt) {
+                ret = -EBUSY;
+                goto end;
+        }
+
+        ret = kstrtou16(page, 0, &num);
+        if (ret)
+                goto end;
+
+        if (num > 1024) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        opts->int_maxpacket = num;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_ss_opts_attribute f_ss_opts_int_maxpacket =
+        __CONFIGFS_ATTR(int_maxpacket, S_IRUGO | S_IWUSR,
+                        f_ss_opts_int_maxpacket_show,
+                        f_ss_opts_int_maxpacket_store);
+
+static ssize_t f_ss_opts_int_mult_show(struct f_ss_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->int_mult);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_ss_opts_int_mult_store(struct f_ss_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;
+
+        if (num > 2) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        opts->int_mult = num;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_ss_opts_attribute f_ss_opts_int_mult =
+        __CONFIGFS_ATTR(int_mult, S_IRUGO | S_IWUSR,
+                        f_ss_opts_int_mult_show,
+                        f_ss_opts_int_mult_store);
+
+static ssize_t f_ss_opts_int_maxburst_show(struct f_ss_opts *opts, char *page)
+{
+        int result;
+
+        mutex_lock(&opts->lock);
+        result = sprintf(page, "%d", opts->int_maxburst);
+        mutex_unlock(&opts->lock);
+
+        return result;
+}
+
+static ssize_t f_ss_opts_int_maxburst_store(struct f_ss_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;
+
+        if (num > 15) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        opts->int_maxburst = num;
+        ret = len;
+end:
+        mutex_unlock(&opts->lock);
+        return ret;
+}
+
+static struct f_ss_opts_attribute f_ss_opts_int_maxburst =
+        __CONFIGFS_ATTR(int_maxburst, S_IRUGO | S_IWUSR,
+                        f_ss_opts_int_maxburst_show,
+                        f_ss_opts_int_maxburst_store);
+
 static struct configfs_attribute *ss_attrs[] = {
         &f_ss_opts_pattern.attr,
         &f_ss_opts_isoc_interval.attr,
@@ -1186,6 +1651,10 @@ static struct configfs_attribute *ss_attrs[] = {
         &f_ss_opts_isoc_mult.attr,
         &f_ss_opts_isoc_maxburst.attr,
         &f_ss_opts_bulk_buflen.attr,
+        &f_ss_opts_int_interval.attr,
+        &f_ss_opts_int_maxpacket.attr,
+        &f_ss_opts_int_mult.attr,
+        &f_ss_opts_int_maxburst.attr,
         NULL,
 };
 
@@ -1215,6 +1684,8 @@ static struct usb_function_instance *source_sink_alloc_inst(void)
         ss_opts->isoc_interval = GZERO_ISOC_INTERVAL;
         ss_opts->isoc_maxpacket = GZERO_ISOC_MAXPACKET;
         ss_opts->bulk_buflen = GZERO_BULK_BUFLEN;
+        ss_opts->int_interval = GZERO_INT_INTERVAL;
+        ss_opts->int_maxpacket = GZERO_INT_MAXPACKET;
 
         config_group_init_type_name(&ss_opts->func_inst.group, "",
                                     &ss_func_type);
diff --git a/drivers/usb/gadget/function/f_uac1.c b/drivers/usb/gadget/function/f_uac1.c
index 2b4c82d84bfc..f7b203293205 100644
--- a/drivers/usb/gadget/function/f_uac1.c
+++ b/drivers/usb/gadget/function/f_uac1.c
@@ -11,24 +11,12 @@
 
 #include <linux/slab.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/atomic.h>
 
 #include "u_uac1.h"
 
-#define OUT_EP_MAX_PACKET_SIZE  200
-static int req_buf_size = OUT_EP_MAX_PACKET_SIZE;
-module_param(req_buf_size, int, S_IRUGO);
-MODULE_PARM_DESC(req_buf_size, "ISO OUT endpoint request buffer size");
-
-static int req_count = 256;
-module_param(req_count, int, S_IRUGO);
-MODULE_PARM_DESC(req_count, "ISO OUT endpoint request count");
-
-static int audio_buf_size = 48000;
-module_param(audio_buf_size, int, S_IRUGO);
-MODULE_PARM_DESC(audio_buf_size, "Audio buffer size");
-
 static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value);
 static int generic_get_cmd(struct usb_audio_control *con, u8 cmd);
 
@@ -46,7 +34,7 @@ static int generic_get_cmd(struct usb_audio_control *con, u8 cmd);
 #define F_AUDIO_NUM_INTERFACES  2
 
 /* B.3.1  Standard AC Interface Descriptor */
-static struct usb_interface_descriptor ac_interface_desc __initdata = {
+static struct usb_interface_descriptor ac_interface_desc = {
         .bLength =              USB_DT_INTERFACE_SIZE,
         .bDescriptorType =      USB_DT_INTERFACE,
         .bNumEndpoints =        0,
@@ -183,12 +171,12 @@ static struct usb_endpoint_descriptor as_out_ep_desc  = {
         .bEndpointAddress =     USB_DIR_OUT,
         .bmAttributes =         USB_ENDPOINT_SYNC_ADAPTIVE
                                 | USB_ENDPOINT_XFER_ISOC,
-        .wMaxPacketSize =       __constant_cpu_to_le16(OUT_EP_MAX_PACKET_SIZE),
+        .wMaxPacketSize =       cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
         .bInterval =            4,
 };
 
 /* Class-specific AS ISO OUT Endpoint Descriptor */
-static struct uac_iso_endpoint_descriptor as_iso_out_desc __initdata = {
+static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
         .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
         .bDescriptorType =      USB_DT_CS_ENDPOINT,
         .bDescriptorSubtype =   UAC_EP_GENERAL,
@@ -197,7 +185,7 @@ static struct uac_iso_endpoint_descriptor as_iso_out_desc __initdata = {
         .wLockDelay =           __constant_cpu_to_le16(1),
 };
 
-static struct usb_descriptor_header *f_audio_desc[] __initdata = {
+static struct usb_descriptor_header *f_audio_desc[] = {
         (struct usb_descriptor_header *)&ac_interface_desc,
         (struct usb_descriptor_header *)&ac_header_desc,
 
@@ -216,6 +204,37 @@ static struct usb_descriptor_header *f_audio_desc[] __initdata = {
         NULL,
 };
 
+enum {
+        STR_AC_IF,
+        STR_INPUT_TERMINAL,
+        STR_INPUT_TERMINAL_CH_NAMES,
+        STR_FEAT_DESC_0,
+        STR_OUTPUT_TERMINAL,
+        STR_AS_IF_ALT0,
+        STR_AS_IF_ALT1,
+};
+
+static struct usb_string strings_uac1[] = {
+        [STR_AC_IF].s = "AC Interface",
+        [STR_INPUT_TERMINAL].s = "Input terminal",
+        [STR_INPUT_TERMINAL_CH_NAMES].s = "Channels",
+        [STR_FEAT_DESC_0].s = "Volume control & mute",
+        [STR_OUTPUT_TERMINAL].s = "Output terminal",
+        [STR_AS_IF_ALT0].s = "AS Interface",
+        [STR_AS_IF_ALT1].s = "AS Interface",
+        { },
+};
+
+static struct usb_gadget_strings str_uac1 = {
+        .language = 0x0409,     /* en-us */
+        .strings = strings_uac1,
+};
+
+static struct usb_gadget_strings *uac1_strings[] = {
+        &str_uac1,
+        NULL,
+};
+
 /*
  * This function is an ALSA sound card following USB Audio Class Spec 1.0.
  */
@@ -300,8 +319,14 @@ static int f_audio_out_ep_complete(struct usb_ep *ep, struct usb_request *req)
         struct f_audio *audio = req->context;
         struct usb_composite_dev *cdev = audio->card.func.config->cdev;
         struct f_audio_buf *copy_buf = audio->copy_buf;
+        struct f_uac1_opts *opts;
+        int audio_buf_size;
         int err;
 
+        opts = container_of(audio->card.func.fi, struct f_uac1_opts,
+                            func_inst);
+        audio_buf_size = opts->audio_buf_size;
+
         if (!copy_buf)
                 return -EINVAL;
 
@@ -546,10 +571,17 @@ static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         struct usb_composite_dev *cdev = f->config->cdev;
         struct usb_ep *out_ep = audio->out_ep;
         struct usb_request *req;
+        struct f_uac1_opts *opts;
+        int req_buf_size, req_count, audio_buf_size;
         int i = 0, err = 0;
 
         DBG(cdev, "intf %d, alt %d\n", intf, alt);
 
+        opts = container_of(f->fi, struct f_uac1_opts, func_inst);
+        req_buf_size = opts->req_buf_size;
+        req_count = opts->req_count;
+        audio_buf_size = opts->audio_buf_size;
+
         if (intf == 1) {
                 if (alt == 1) {
                         usb_ep_enable(out_ep);
@@ -625,13 +657,37 @@ static void f_audio_build_desc(struct f_audio *audio)
 }
 
 /* audio function driver setup/binding */
-static int __init
+static int
 f_audio_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct usb_composite_dev *cdev = c->cdev;
         struct f_audio          *audio = func_to_audio(f);
+        struct usb_string       *us;
         int                     status;
         struct usb_ep           *ep = NULL;
+        struct f_uac1_opts      *audio_opts;
+
+        audio_opts = container_of(f->fi, struct f_uac1_opts, func_inst);
+        audio->card.gadget = c->cdev->gadget;
+        audio_opts->card = &audio->card;
+        /* set up ASLA audio devices */
+        if (!audio_opts->bound) {
+                status = gaudio_setup(&audio->card);
+                if (status < 0)
+                        return status;
+                audio_opts->bound = true;
+        }
+        us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1));
+        if (IS_ERR(us))
+                return PTR_ERR(us);
+        ac_interface_desc.iInterface = us[STR_AC_IF].id;
+        input_terminal_desc.iTerminal = us[STR_INPUT_TERMINAL].id;
+        input_terminal_desc.iChannelNames = us[STR_INPUT_TERMINAL_CH_NAMES].id;
+        feature_unit_desc.iFeature = us[STR_FEAT_DESC_0].id;
+        output_terminal_desc.iTerminal = us[STR_OUTPUT_TERMINAL].id;
+        as_interface_alt_0_desc.iInterface = us[STR_AS_IF_ALT0].id;
+        as_interface_alt_1_desc.iInterface = us[STR_AS_IF_ALT1].id;
+
 
         f_audio_build_desc(audio);
 
@@ -666,20 +722,12 @@ f_audio_bind(struct usb_configuration *c, struct usb_function *f)
         return 0;
 
 fail:
+        gaudio_cleanup(&audio->card);
         if (ep)
                 ep->driver_data = NULL;
         return status;
 }
 
-static void
-f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
-{
-        struct f_audio          *audio = func_to_audio(f);
-
-        usb_free_all_descriptors(f);
-        kfree(audio);
-}
-
 /*-------------------------------------------------------------------------*/
 
 static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value)
@@ -695,7 +743,7 @@ static int generic_get_cmd(struct usb_audio_control *con, u8 cmd)
 }
 
 /* Todo: add more control selecotor dynamically */
-static int __init control_selector_init(struct f_audio *audio)
+static int control_selector_init(struct f_audio *audio)
 {
         INIT_LIST_HEAD(&audio->cs);
         list_add(&feature_unit.list, &audio->cs);
@@ -712,57 +760,226 @@ static int __init control_selector_init(struct f_audio *audio)
         return 0;
 }
 
-/**
- * audio_bind_config - add USB audio function to a configuration
- * @c: the configuration to supcard the USB audio function
- * Context: single threaded during gadget setup
- *
- * Returns zero on success, else negative errno.
- */
-static int __init audio_bind_config(struct usb_configuration *c)
+static inline struct f_uac1_opts *to_f_uac1_opts(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct f_uac1_opts,
+                            func_inst.group);
+}
+
+CONFIGFS_ATTR_STRUCT(f_uac1_opts);
+CONFIGFS_ATTR_OPS(f_uac1_opts);
+
+static void f_uac1_attr_release(struct config_item *item)
+{
+        struct f_uac1_opts *opts = to_f_uac1_opts(item);
+
+        usb_put_function_instance(&opts->func_inst);
+}
+
+static struct configfs_item_operations f_uac1_item_ops = {
+        .release        = f_uac1_attr_release,
+        .show_attribute = f_uac1_opts_attr_show,
+        .store_attribute = f_uac1_opts_attr_store,
+};
+
+#define UAC1_INT_ATTRIBUTE(name)                                        \
+static ssize_t f_uac1_opts_##name##_show(struct f_uac1_opts *opts,      \
+                                         char *page)                    \
+{                                                                       \
+        int result;                                                     \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        result = sprintf(page, "%u\n", opts->name);                     \
+        mutex_unlock(&opts->lock);                                      \
+                                                                        \
+        return result;                                                  \
+}                                                                       \
+                                                                        \
+static ssize_t f_uac1_opts_##name##_store(struct f_uac1_opts *opts,     \
+                                          const char *page, size_t len) \
+{                                                                       \
+        int ret;                                                        \
+        u32 num;                                                        \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        if (opts->refcnt) {                                             \
+                ret = -EBUSY;                                           \
+                goto end;                                               \
+        }                                                               \
+                                                                        \
+        ret = kstrtou32(page, 0, &num);                                 \
+        if (ret)                                                        \
+                goto end;                                               \
+                                                                        \
+        opts->name = num;                                               \
+        ret = len;                                                      \
+                                                                        \
+end:                                                                    \
+        mutex_unlock(&opts->lock);                                      \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static struct f_uac1_opts_attribute f_uac1_opts_##name =                \
+        __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR,                        \
+                        f_uac1_opts_##name##_show,                      \
+                        f_uac1_opts_##name##_store)
+
+UAC1_INT_ATTRIBUTE(req_buf_size);
+UAC1_INT_ATTRIBUTE(req_count);
+UAC1_INT_ATTRIBUTE(audio_buf_size);
+
+#define UAC1_STR_ATTRIBUTE(name)                                        \
+static ssize_t f_uac1_opts_##name##_show(struct f_uac1_opts *opts,      \
+                                         char *page)                    \
+{                                                                       \
+        int result;                                                     \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        result = sprintf(page, "%s\n", opts->name);                     \
+        mutex_unlock(&opts->lock);                                      \
+                                                                        \
+        return result;                                                  \
+}                                                                       \
+                                                                        \
+static ssize_t f_uac1_opts_##name##_store(struct f_uac1_opts *opts,     \
+                                          const char *page, size_t len) \
+{                                                                       \
+        int ret = -EBUSY;                                               \
+        char *tmp;                                                      \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        if (opts->refcnt)                                               \
+                goto end;                                               \
+                                                                        \
+        tmp = kstrndup(page, len, GFP_KERNEL);                          \
+        if (tmp) {                                                      \
+                ret = -ENOMEM;                                          \
+                goto end;                                               \
+        }                                                               \
+        if (opts->name##_alloc)                                         \
+                kfree(opts->name);                                      \
+        opts->name##_alloc = true;                                      \
+        opts->name = tmp;                                               \
+        ret = len;                                                      \
+                                                                        \
+end:                                                                    \
+        mutex_unlock(&opts->lock);                                      \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static struct f_uac1_opts_attribute f_uac1_opts_##name =                \
+        __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR,                        \
+                        f_uac1_opts_##name##_show,                      \
+                        f_uac1_opts_##name##_store)
+
+UAC1_STR_ATTRIBUTE(fn_play);
+UAC1_STR_ATTRIBUTE(fn_cap);
+UAC1_STR_ATTRIBUTE(fn_cntl);
+
+static struct configfs_attribute *f_uac1_attrs[] = {
+        &f_uac1_opts_req_buf_size.attr,
+        &f_uac1_opts_req_count.attr,
+        &f_uac1_opts_audio_buf_size.attr,
+        &f_uac1_opts_fn_play.attr,
+        &f_uac1_opts_fn_cap.attr,
+        &f_uac1_opts_fn_cntl.attr,
+        NULL,
+};
+
+static struct config_item_type f_uac1_func_type = {
+        .ct_item_ops    = &f_uac1_item_ops,
+        .ct_attrs       = f_uac1_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static void f_audio_free_inst(struct usb_function_instance *f)
+{
+        struct f_uac1_opts *opts;
+
+        opts = container_of(f, struct f_uac1_opts, func_inst);
+        gaudio_cleanup(opts->card);
+        if (opts->fn_play_alloc)
+                kfree(opts->fn_play);
+        if (opts->fn_cap_alloc)
+                kfree(opts->fn_cap);
+        if (opts->fn_cntl_alloc)
+                kfree(opts->fn_cntl);
+        kfree(opts);
+}
+
+static struct usb_function_instance *f_audio_alloc_inst(void)
+{
+        struct f_uac1_opts *opts;
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+
+        mutex_init(&opts->lock);
+        opts->func_inst.free_func_inst = f_audio_free_inst;
+
+        config_group_init_type_name(&opts->func_inst.group, "",
+                                    &f_uac1_func_type);
+
+        opts->req_buf_size = UAC1_OUT_EP_MAX_PACKET_SIZE;
+        opts->req_count = UAC1_REQ_COUNT;
+        opts->audio_buf_size = UAC1_AUDIO_BUF_SIZE;
+        opts->fn_play = FILE_PCM_PLAYBACK;
+        opts->fn_cap = FILE_PCM_CAPTURE;
+        opts->fn_cntl = FILE_CONTROL;
+        return &opts->func_inst;
+}
+
+static void f_audio_free(struct usb_function *f)
+{
+        struct f_audio *audio = func_to_audio(f);
+        struct f_uac1_opts *opts;
+
+        opts = container_of(f->fi, struct f_uac1_opts, func_inst);
+        kfree(audio);
+        mutex_lock(&opts->lock);
+        --opts->refcnt;
+        mutex_unlock(&opts->lock);
+}
+
+static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        usb_free_all_descriptors(f);
+}
+
+static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
 {
         struct f_audio *audio;
-        int status;
+        struct f_uac1_opts *opts;
 
         /* allocate and initialize one new instance */
-        audio = kzalloc(sizeof *audio, GFP_KERNEL);
+        audio = kzalloc(sizeof(*audio), GFP_KERNEL);
         if (!audio)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
         audio->card.func.name = "g_audio";
-        audio->card.gadget = c->cdev->gadget;
 
+        opts = container_of(fi, struct f_uac1_opts, func_inst);
+        mutex_lock(&opts->lock);
+        ++opts->refcnt;
+        mutex_unlock(&opts->lock);
         INIT_LIST_HEAD(&audio->play_queue);
         spin_lock_init(&audio->lock);
 
-        /* set up ASLA audio devices */
-        status = gaudio_setup(&audio->card);
-        if (status < 0)
-                goto setup_fail;
-
-        audio->card.func.strings = audio_strings;
         audio->card.func.bind = f_audio_bind;
         audio->card.func.unbind = f_audio_unbind;
         audio->card.func.set_alt = f_audio_set_alt;
         audio->card.func.setup = f_audio_setup;
         audio->card.func.disable = f_audio_disable;
+        audio->card.func.free_func = f_audio_free;
 
         control_selector_init(audio);
 
         INIT_WORK(&audio->playback_work, f_audio_playback_work);
 
-        status = usb_add_function(c, &audio->card.func);
-        if (status)
-                goto add_fail;
-
-        INFO(c->cdev, "audio_buf_size %d, req_buf_size %d, req_count %d\n",
-                audio_buf_size, req_buf_size, req_count);
-
-        return status;
-
-add_fail:
-        gaudio_cleanup();
-setup_fail:
-        kfree(audio);
-        return status;
+        return &audio->card.func;
 }
+
+DECLARE_USB_FUNCTION_INIT(uac1, f_audio_alloc_inst, f_audio_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Bryan Wu");
diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
index 3ed89ecc8d6d..a5a27a504d67 100644
--- a/drivers/usb/gadget/function/f_uac2.c
+++ b/drivers/usb/gadget/function/f_uac2.c
@@ -20,35 +20,7 @@
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
 
-/* Playback(USB-IN) Default Stereo - Fl/Fr */
-static int p_chmask = 0x3;
-module_param(p_chmask, uint, S_IRUGO);
-MODULE_PARM_DESC(p_chmask, "Playback Channel Mask");
-
-/* Playback Default 48 KHz */
-static int p_srate = 48000;
-module_param(p_srate, uint, S_IRUGO);
-MODULE_PARM_DESC(p_srate, "Playback Sampling Rate");
-
-/* Playback Default 16bits/sample */
-static int p_ssize = 2;
-module_param(p_ssize, uint, S_IRUGO);
-MODULE_PARM_DESC(p_ssize, "Playback Sample Size(bytes)");
-
-/* Capture(USB-OUT) Default Stereo - Fl/Fr */
-static int c_chmask = 0x3;
-module_param(c_chmask, uint, S_IRUGO);
-MODULE_PARM_DESC(c_chmask, "Capture Channel Mask");
-
-/* Capture Default 64 KHz */
-static int c_srate = 64000;
-module_param(c_srate, uint, S_IRUGO);
-MODULE_PARM_DESC(c_srate, "Capture Sampling Rate");
-
-/* Capture Default 16bits/sample */
-static int c_ssize = 2;
-module_param(c_ssize, uint, S_IRUGO);
-MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
+#include "u_uac2.h"
 
 /* Keep everyone on toes */
 #define USB_XFERS       2
@@ -120,6 +92,15 @@ struct snd_uac2_chip {
 
         struct snd_card *card;
         struct snd_pcm *pcm;
+
+        /* timekeeping for the playback endpoint */
+        unsigned int p_interval;
+        unsigned int p_residue;
+
+        /* pre-calculated values for playback iso completion */
+        unsigned int p_pktsize;
+        unsigned int p_pktsize_residue;
+        unsigned int p_framesize;
 };
 
 #define BUFF_SIZE_MAX   (PAGE_SIZE * 16)
@@ -149,8 +130,6 @@ struct audio_dev {
         struct snd_uac2_chip uac2;
 };
 
-static struct audio_dev *agdev_g;
-
 static inline
 struct audio_dev *func_to_agdev(struct usb_function *f)
 {
@@ -170,6 +149,12 @@ struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
 }
 
 static inline
+struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
+{
+        return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
+}
+
+static inline
 uint num_channels(uint chanmask)
 {
         uint num = 0;
@@ -187,8 +172,8 @@ agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
 {
         unsigned pending;
         unsigned long flags;
+        unsigned int hw_ptr;
         bool update_alsa = false;
-        unsigned char *src, *dst;
         int status = req->status;
         struct uac2_req *ur = req->context;
         struct snd_pcm_substream *substream;
@@ -216,12 +201,27 @@ agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
         spin_lock_irqsave(&prm->lock, flags);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-                src = prm->dma_area + prm->hw_ptr;
+                /*
+                 * For each IN packet, take the quotient of the current data
+                 * rate and the endpoint's interval as the base packet size.
+                 * If there is a residue from this division, add it to the
+                 * residue accumulator.
+                 */
+                req->length = uac2->p_pktsize;
+                uac2->p_residue += uac2->p_pktsize_residue;
+
+                /*
+                 * Whenever there are more bytes in the accumulator than we
+                 * need to add one more sample frame, increase this packet's
+                 * size and decrease the accumulator.
+                 */
+                if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
+                        req->length += uac2->p_framesize;
+                        uac2->p_residue -= uac2->p_framesize *
+                                           uac2->p_interval;
+                }
+
                 req->actual = req->length;
-                dst = req->buf;
-        } else {
-                dst = prm->dma_area + prm->hw_ptr;
-                src = req->buf;
         }
 
         pending = prm->hw_ptr % prm->period_size;
@@ -229,12 +229,32 @@ agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
         if (pending >= prm->period_size)
                 update_alsa = true;
 
+        hw_ptr = prm->hw_ptr;
         prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
 
         spin_unlock_irqrestore(&prm->lock, flags);
 
         /* Pack USB load in ALSA ring buffer */
-        memcpy(dst, src, req->actual);
+        pending = prm->dma_bytes - hw_ptr;
+
+        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+                if (unlikely(pending < req->actual)) {
+                        memcpy(req->buf, prm->dma_area + hw_ptr, pending);
+                        memcpy(req->buf + pending, prm->dma_area,
+                               req->actual - pending);
+                } else {
+                        memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
+                }
+        } else {
+                if (unlikely(pending < req->actual)) {
+                        memcpy(prm->dma_area + hw_ptr, req->buf, pending);
+                        memcpy(prm->dma_area, req->buf + pending,
+                               req->actual - pending);
+                } else {
+                        memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
+                }
+        }
+
 exit:
         if (usb_ep_queue(ep, req, GFP_ATOMIC))
                 dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
@@ -342,6 +362,21 @@ static int uac2_pcm_open(struct snd_pcm_substream *substream)
 {
         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
         struct snd_pcm_runtime *runtime = substream->runtime;
+        struct audio_dev *audio_dev;
+        struct f_uac2_opts *opts;
+        int p_ssize, c_ssize;
+        int p_srate, c_srate;
+        int p_chmask, c_chmask;
+
+        audio_dev = uac2_to_agdev(uac2);
+        opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
+        p_ssize = opts->p_ssize;
+        c_ssize = opts->c_ssize;
+        p_srate = opts->p_srate;
+        c_srate = opts->c_srate;
+        p_chmask = opts->p_chmask;
+        c_chmask = opts->c_chmask;
+        uac2->p_residue = 0;
 
         runtime->hw = uac2_pcm_hardware;
 
@@ -411,7 +446,15 @@ static int snd_uac2_probe(struct platform_device *pdev)
         struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
         struct snd_card *card;
         struct snd_pcm *pcm;
+        struct audio_dev *audio_dev;
+        struct f_uac2_opts *opts;
         int err;
+        int p_chmask, c_chmask;
+
+        audio_dev = uac2_to_agdev(uac2);
+        opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
+        p_chmask = opts->p_chmask;
+        c_chmask = opts->c_chmask;
 
         /* Choose any slot, with no id */
         err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
@@ -919,20 +962,58 @@ free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
                         "%s:%d Error!\n", __func__, __LINE__);
 }
 
-static int __init
+static int
 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 {
         struct audio_dev *agdev = func_to_agdev(fn);
         struct snd_uac2_chip *uac2 = &agdev->uac2;
         struct usb_composite_dev *cdev = cfg->cdev;
         struct usb_gadget *gadget = cdev->gadget;
+        struct device *dev = &uac2->pdev.dev;
         struct uac2_rtd_params *prm;
+        struct f_uac2_opts *uac2_opts;
+        struct usb_string *us;
         int ret;
 
+        uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
+
+        us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
+        if (IS_ERR(us))
+                return PTR_ERR(us);
+        iad_desc.iFunction = us[STR_ASSOC].id;
+        std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
+        in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
+        out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
+        usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
+        io_in_it_desc.iTerminal = us[STR_IO_IT].id;
+        usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
+        io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
+        std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
+        std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
+        std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
+        std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
+
+
+        /* Initialize the configurable parameters */
+        usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
+        usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
+        io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
+        io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
+        as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
+        as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
+        as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
+        as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
+        as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
+        as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
+        as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
+        as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
+
+        snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
+        snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
+
         ret = usb_interface_id(cfg, fn);
         if (ret < 0) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 return ret;
         }
         std_ac_if_desc.bInterfaceNumber = ret;
@@ -941,8 +1022,7 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 
         ret = usb_interface_id(cfg, fn);
         if (ret < 0) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 return ret;
         }
         std_as_out_if0_desc.bInterfaceNumber = ret;
@@ -952,8 +1032,7 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 
         ret = usb_interface_id(cfg, fn);
         if (ret < 0) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 return ret;
         }
         std_as_in_if0_desc.bInterfaceNumber = ret;
@@ -963,16 +1042,14 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 
         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
         if (!agdev->out_ep) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
         agdev->out_ep->driver_data = agdev;
 
         agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
         if (!agdev->in_ep) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
         agdev->in_ep->driver_data = agdev;
@@ -1020,27 +1097,6 @@ err:
         return -EINVAL;
 }
 
-static void
-afunc_unbind(struct usb_configuration *cfg, struct usb_function *fn)
-{
-        struct audio_dev *agdev = func_to_agdev(fn);
-        struct uac2_rtd_params *prm;
-
-        alsa_uac2_exit(agdev);
-
-        prm = &agdev->uac2.p_prm;
-        kfree(prm->rbuf);
-
-        prm = &agdev->uac2.c_prm;
-        kfree(prm->rbuf);
-        usb_free_all_descriptors(fn);
-
-        if (agdev->in_ep)
-                agdev->in_ep->driver_data = NULL;
-        if (agdev->out_ep)
-                agdev->out_ep->driver_data = NULL;
-}
-
 static int
 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
 {
@@ -1048,23 +1104,22 @@ afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
         struct audio_dev *agdev = func_to_agdev(fn);
         struct snd_uac2_chip *uac2 = &agdev->uac2;
         struct usb_gadget *gadget = cdev->gadget;
+        struct device *dev = &uac2->pdev.dev;
         struct usb_request *req;
         struct usb_ep *ep;
         struct uac2_rtd_params *prm;
-        int i;
+        int req_len, i;
 
         /* No i/f has more than 2 alt settings */
         if (alt > 1) {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 return -EINVAL;
         }
 
         if (intf == agdev->ac_intf) {
                 /* Control I/f has only 1 AltSetting - 0 */
                 if (alt) {
-                        dev_err(&uac2->pdev.dev,
-                                "%s:%d Error!\n", __func__, __LINE__);
+                        dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                         return -EINVAL;
                 }
                 return 0;
@@ -1075,14 +1130,43 @@ afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
                 prm = &uac2->c_prm;
                 config_ep_by_speed(gadget, fn, ep);
                 agdev->as_out_alt = alt;
+                req_len = prm->max_psize;
         } else if (intf == agdev->as_in_intf) {
+                struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
+                unsigned int factor, rate;
+                struct usb_endpoint_descriptor *ep_desc;
+
                 ep = agdev->in_ep;
                 prm = &uac2->p_prm;
                 config_ep_by_speed(gadget, fn, ep);
                 agdev->as_in_alt = alt;
+
+                /* pre-calculate the playback endpoint's interval */
+                if (gadget->speed == USB_SPEED_FULL) {
+                        ep_desc = &fs_epin_desc;
+                        factor = 1000;
+                } else {
+                        ep_desc = &hs_epin_desc;
+                        factor = 125;
+                }
+
+                /* pre-compute some values for iso_complete() */
+                uac2->p_framesize = opts->p_ssize *
+                                    num_channels(opts->p_chmask);
+                rate = opts->p_srate * uac2->p_framesize;
+                uac2->p_interval = (1 << (ep_desc->bInterval - 1)) * factor;
+                uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
+                                        prm->max_psize);
+
+                if (uac2->p_pktsize < prm->max_psize)
+                        uac2->p_pktsize_residue = rate % uac2->p_interval;
+                else
+                        uac2->p_pktsize_residue = 0;
+
+                req_len = uac2->p_pktsize;
+                uac2->p_residue = 0;
         } else {
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
+                dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
                 return -EINVAL;
         }
 
@@ -1095,31 +1179,23 @@ afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
         usb_ep_enable(ep);
 
         for (i = 0; i < USB_XFERS; i++) {
-                if (prm->ureq[i].req) {
-                        if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
-                                dev_err(&uac2->pdev.dev, "%d Error!\n",
-                                        __LINE__);
-                        continue;
-                }
-
-                req = usb_ep_alloc_request(ep, GFP_ATOMIC);
-                if (req == NULL) {
-                        dev_err(&uac2->pdev.dev,
-                                "%s:%d Error!\n", __func__, __LINE__);
-                        return -EINVAL;
+                if (!prm->ureq[i].req) {
+                        req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+                        if (req == NULL)
+                                return -ENOMEM;
+
+                        prm->ureq[i].req = req;
+                        prm->ureq[i].pp = prm;
+
+                        req->zero = 0;
+                        req->context = &prm->ureq[i];
+                        req->length = req_len;
+                        req->complete = agdev_iso_complete;
+                        req->buf = prm->rbuf + i * prm->max_psize;
                 }
 
-                prm->ureq[i].req = req;
-                prm->ureq[i].pp = prm;
-
-                req->zero = 0;
-                req->context = &prm->ureq[i];
-                req->length = prm->max_psize;
-                req->complete = agdev_iso_complete;
-                req->buf = prm->rbuf + i * req->length;
-
-                if (usb_ep_queue(ep, req, GFP_ATOMIC))
-                        dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
+                if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
+                        dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
         }
 
         return 0;
@@ -1164,12 +1240,18 @@ in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
         struct usb_request *req = fn->config->cdev->req;
         struct audio_dev *agdev = func_to_agdev(fn);
         struct snd_uac2_chip *uac2 = &agdev->uac2;
+        struct f_uac2_opts *opts;
         u16 w_length = le16_to_cpu(cr->wLength);
         u16 w_index = le16_to_cpu(cr->wIndex);
         u16 w_value = le16_to_cpu(cr->wValue);
         u8 entity_id = (w_index >> 8) & 0xff;
         u8 control_selector = w_value >> 8;
         int value = -EOPNOTSUPP;
+        int p_srate, c_srate;
+
+        opts = agdev_to_uac2_opts(agdev);
+        p_srate = opts->p_srate;
+        c_srate = opts->c_srate;
 
         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
                 struct cntrl_cur_lay3 c;
@@ -1199,6 +1281,7 @@ in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
         struct usb_request *req = fn->config->cdev->req;
         struct audio_dev *agdev = func_to_agdev(fn);
         struct snd_uac2_chip *uac2 = &agdev->uac2;
+        struct f_uac2_opts *opts;
         u16 w_length = le16_to_cpu(cr->wLength);
         u16 w_index = le16_to_cpu(cr->wIndex);
         u16 w_value = le16_to_cpu(cr->wValue);
@@ -1206,6 +1289,11 @@ in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
         u8 control_selector = w_value >> 8;
         struct cntrl_range_lay3 r;
         int value = -EOPNOTSUPP;
+        int p_srate, c_srate;
+
+        opts = agdev_to_uac2_opts(agdev);
+        p_srate = opts->p_srate;
+        c_srate = opts->c_srate;
 
         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
                 if (entity_id == USB_IN_CLK_ID)
@@ -1309,66 +1397,184 @@ afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
         return value;
 }
 
-static int audio_bind_config(struct usb_configuration *cfg)
+static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
 {
-        int res;
-
-        agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL);
-        if (agdev_g == NULL)
-                return -ENOMEM;
-
-        res = usb_string_ids_tab(cfg->cdev, strings_fn);
-        if (res)
-                return res;
-        iad_desc.iFunction = strings_fn[STR_ASSOC].id;
-        std_ac_if_desc.iInterface = strings_fn[STR_IF_CTRL].id;
-        in_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_IN].id;
-        out_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_OUT].id;
-        usb_out_it_desc.iTerminal = strings_fn[STR_USB_IT].id;
-        io_in_it_desc.iTerminal = strings_fn[STR_IO_IT].id;
-        usb_in_ot_desc.iTerminal = strings_fn[STR_USB_OT].id;
-        io_out_ot_desc.iTerminal = strings_fn[STR_IO_OT].id;
-        std_as_out_if0_desc.iInterface = strings_fn[STR_AS_OUT_ALT0].id;
-        std_as_out_if1_desc.iInterface = strings_fn[STR_AS_OUT_ALT1].id;
-        std_as_in_if0_desc.iInterface = strings_fn[STR_AS_IN_ALT0].id;
-        std_as_in_if1_desc.iInterface = strings_fn[STR_AS_IN_ALT1].id;
-
-        agdev_g->func.name = "uac2_func";
-        agdev_g->func.strings = fn_strings;
-        agdev_g->func.bind = afunc_bind;
-        agdev_g->func.unbind = afunc_unbind;
-        agdev_g->func.set_alt = afunc_set_alt;
-        agdev_g->func.get_alt = afunc_get_alt;
-        agdev_g->func.disable = afunc_disable;
-        agdev_g->func.setup = afunc_setup;
+        return container_of(to_config_group(item), struct f_uac2_opts,
+                            func_inst.group);
+}
 
-        /* Initialize the configurable parameters */
-        usb_out_it_desc.bNrChannels = num_channels(c_chmask);
-        usb_out_it_desc.bmChannelConfig = cpu_to_le32(c_chmask);
-        io_in_it_desc.bNrChannels = num_channels(p_chmask);
-        io_in_it_desc.bmChannelConfig = cpu_to_le32(p_chmask);
-        as_out_hdr_desc.bNrChannels = num_channels(c_chmask);
-        as_out_hdr_desc.bmChannelConfig = cpu_to_le32(c_chmask);
-        as_in_hdr_desc.bNrChannels = num_channels(p_chmask);
-        as_in_hdr_desc.bmChannelConfig = cpu_to_le32(p_chmask);
-        as_out_fmt1_desc.bSubslotSize = c_ssize;
-        as_out_fmt1_desc.bBitResolution = c_ssize * 8;
-        as_in_fmt1_desc.bSubslotSize = p_ssize;
-        as_in_fmt1_desc.bBitResolution = p_ssize * 8;
-
-        snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", p_srate);
-        snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", c_srate);
-
-        res = usb_add_function(cfg, &agdev_g->func);
-        if (res < 0)
-                kfree(agdev_g);
-
-        return res;
+CONFIGFS_ATTR_STRUCT(f_uac2_opts);
+CONFIGFS_ATTR_OPS(f_uac2_opts);
+
+static void f_uac2_attr_release(struct config_item *item)
+{
+        struct f_uac2_opts *opts = to_f_uac2_opts(item);
+
+        usb_put_function_instance(&opts->func_inst);
 }
 
-static void
-uac2_unbind_config(struct usb_configuration *cfg)
+static struct configfs_item_operations f_uac2_item_ops = {
+        .release        = f_uac2_attr_release,
+        .show_attribute = f_uac2_opts_attr_show,
+        .store_attribute = f_uac2_opts_attr_store,
+};
+
+#define UAC2_ATTRIBUTE(name)                                            \
+static ssize_t f_uac2_opts_##name##_show(struct f_uac2_opts *opts,      \
+                                         char *page)                    \
+{                                                                       \
+        int result;                                                     \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        result = sprintf(page, "%u\n", opts->name);                     \
+        mutex_unlock(&opts->lock);                                      \
+                                                                        \
+        return result;                                                  \
+}                                                                       \
+                                                                        \
+static ssize_t f_uac2_opts_##name##_store(struct f_uac2_opts *opts,     \
+                                          const char *page, size_t len) \
+{                                                                       \
+        int ret;                                                        \
+        u32 num;                                                        \
+                                                                        \
+        mutex_lock(&opts->lock);                                        \
+        if (opts->refcnt) {                                             \
+                ret = -EBUSY;                                           \
+                goto end;                                               \
+        }                                                               \
+                                                                        \
+        ret = kstrtou32(page, 0, &num);                                 \
+        if (ret)                                                        \
+                goto end;                                               \
+                                                                        \
+        opts->name = num;                                               \
+        ret = len;                                                      \
+                                                                        \
+end:                                                                    \
+        mutex_unlock(&opts->lock);                                      \
+        return ret;                                                     \
+}                                                                       \
+                                                                        \
+static struct f_uac2_opts_attribute f_uac2_opts_##name =                \
+        __CONFIGFS_ATTR(name, S_IRUGO | S_IWUSR,                        \
+                        f_uac2_opts_##name##_show,                      \
+                        f_uac2_opts_##name##_store)
+
+UAC2_ATTRIBUTE(p_chmask);
+UAC2_ATTRIBUTE(p_srate);
+UAC2_ATTRIBUTE(p_ssize);
+UAC2_ATTRIBUTE(c_chmask);
+UAC2_ATTRIBUTE(c_srate);
+UAC2_ATTRIBUTE(c_ssize);
+
+static struct configfs_attribute *f_uac2_attrs[] = {
+        &f_uac2_opts_p_chmask.attr,
+        &f_uac2_opts_p_srate.attr,
+        &f_uac2_opts_p_ssize.attr,
+        &f_uac2_opts_c_chmask.attr,
+        &f_uac2_opts_c_srate.attr,
+        &f_uac2_opts_c_ssize.attr,
+        NULL,
+};
+
+static struct config_item_type f_uac2_func_type = {
+        .ct_item_ops    = &f_uac2_item_ops,
+        .ct_attrs       = f_uac2_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+static void afunc_free_inst(struct usb_function_instance *f)
 {
-        kfree(agdev_g);
-        agdev_g = NULL;
+        struct f_uac2_opts *opts;
+
+        opts = container_of(f, struct f_uac2_opts, func_inst);
+        kfree(opts);
 }
+
+static struct usb_function_instance *afunc_alloc_inst(void)
+{
+        struct f_uac2_opts *opts;
+
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+
+        mutex_init(&opts->lock);
+        opts->func_inst.free_func_inst = afunc_free_inst;
+
+        config_group_init_type_name(&opts->func_inst.group, "",
+                                    &f_uac2_func_type);
+
+        opts->p_chmask = UAC2_DEF_PCHMASK;
+        opts->p_srate = UAC2_DEF_PSRATE;
+        opts->p_ssize = UAC2_DEF_PSSIZE;
+        opts->c_chmask = UAC2_DEF_CCHMASK;
+        opts->c_srate = UAC2_DEF_CSRATE;
+        opts->c_ssize = UAC2_DEF_CSSIZE;
+        return &opts->func_inst;
+}
+
+static void afunc_free(struct usb_function *f)
+{
+        struct audio_dev *agdev;
+        struct f_uac2_opts *opts;
+
+        agdev = func_to_agdev(f);
+        opts = container_of(f->fi, struct f_uac2_opts, func_inst);
+        kfree(agdev);
+        mutex_lock(&opts->lock);
+        --opts->refcnt;
+        mutex_unlock(&opts->lock);
+}
+
+static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct audio_dev *agdev = func_to_agdev(f);
+        struct uac2_rtd_params *prm;
+
+        alsa_uac2_exit(agdev);
+
+        prm = &agdev->uac2.p_prm;
+        kfree(prm->rbuf);
+
+        prm = &agdev->uac2.c_prm;
+        kfree(prm->rbuf);
+        usb_free_all_descriptors(f);
+
+        if (agdev->in_ep)
+                agdev->in_ep->driver_data = NULL;
+        if (agdev->out_ep)
+                agdev->out_ep->driver_data = NULL;
+}
+
+struct usb_function *afunc_alloc(struct usb_function_instance *fi)
+{
+        struct audio_dev *agdev;
+        struct f_uac2_opts *opts;
+
+        agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
+        if (agdev == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        opts = container_of(fi, struct f_uac2_opts, func_inst);
+        mutex_lock(&opts->lock);
+        ++opts->refcnt;
+        mutex_unlock(&opts->lock);
+
+        agdev->func.name = "uac2_func";
+        agdev->func.bind = afunc_bind;
+        agdev->func.unbind = afunc_unbind;
+        agdev->func.set_alt = afunc_set_alt;
+        agdev->func.get_alt = afunc_get_alt;
+        agdev->func.disable = afunc_disable;
+        agdev->func.setup = afunc_setup;
+        agdev->func.free_func = afunc_free;
+
+        return &agdev->func;
+}
+
+DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Yadwinder Singh");
+MODULE_AUTHOR("Jaswinder Singh");
diff --git a/drivers/usb/gadget/function/f_uvc.c b/drivers/usb/gadget/function/f_uvc.c
index e2a1f50bd93c..e126439e4b65 100644
--- a/drivers/usb/gadget/function/f_uvc.c
+++ b/drivers/usb/gadget/function/f_uvc.c
@@ -11,6 +11,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
@@ -27,24 +28,12 @@
 #include <media/v4l2-event.h>
 
 #include "uvc.h"
+#include "uvc_v4l2.h"
+#include "uvc_video.h"
+#include "u_uvc.h"
 
 unsigned int uvc_gadget_trace_param;
 
-/*-------------------------------------------------------------------------*/
-
-/* module parameters specific to the Video streaming endpoint */
-static unsigned int streaming_interval = 1;
-module_param(streaming_interval, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(streaming_interval, "1 - 16");
-
-static unsigned int streaming_maxpacket = 1024;
-module_param(streaming_maxpacket, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(streaming_maxpacket, "1 - 1023 (FS), 1 - 3072 (hs/ss)");
-
-static unsigned int streaming_maxburst;
-module_param(streaming_maxburst, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(streaming_maxburst, "0 - 15 (ss only)");
-
 /* --------------------------------------------------------------------------
  * Function descriptors
  */
@@ -75,7 +64,7 @@ static struct usb_gadget_strings *uvc_function_strings[] = {
 
 #define UVC_STATUS_MAX_PACKET_SIZE              16      /* 16 bytes status */
 
-static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
+static struct usb_interface_assoc_descriptor uvc_iad = {
         .bLength                = sizeof(uvc_iad),
         .bDescriptorType        = USB_DT_INTERFACE_ASSOCIATION,
         .bFirstInterface        = 0,
@@ -86,7 +75,7 @@ static struct usb_interface_assoc_descriptor uvc_iad __initdata = {
         .iFunction              = 0,
 };
 
-static struct usb_interface_descriptor uvc_control_intf __initdata = {
+static struct usb_interface_descriptor uvc_control_intf = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_CONTROL,
@@ -98,7 +87,7 @@ static struct usb_interface_descriptor uvc_control_intf __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_endpoint_descriptor uvc_control_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_control_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -107,7 +96,7 @@ static struct usb_endpoint_descriptor uvc_control_ep __initdata = {
         .bInterval              = 8,
 };
 
-static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp __initdata = {
+static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp = {
         .bLength                = sizeof(uvc_ss_control_comp),
         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
         /* The following 3 values can be tweaked if necessary. */
@@ -116,14 +105,14 @@ static struct usb_ss_ep_comp_descriptor uvc_ss_control_comp __initdata = {
         .wBytesPerInterval      = cpu_to_le16(UVC_STATUS_MAX_PACKET_SIZE),
 };
 
-static struct uvc_control_endpoint_descriptor uvc_control_cs_ep __initdata = {
+static struct uvc_control_endpoint_descriptor uvc_control_cs_ep = {
         .bLength                = UVC_DT_CONTROL_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_CS_ENDPOINT,
         .bDescriptorSubType     = UVC_EP_INTERRUPT,
         .wMaxTransferSize       = cpu_to_le16(UVC_STATUS_MAX_PACKET_SIZE),
 };
 
-static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
+static struct usb_interface_descriptor uvc_streaming_intf_alt0 = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_STREAMING,
@@ -135,7 +124,7 @@ static struct usb_interface_descriptor uvc_streaming_intf_alt0 __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
+static struct usb_interface_descriptor uvc_streaming_intf_alt1 = {
         .bLength                = USB_DT_INTERFACE_SIZE,
         .bDescriptorType        = USB_DT_INTERFACE,
         .bInterfaceNumber       = UVC_INTF_VIDEO_STREAMING,
@@ -147,7 +136,7 @@ static struct usb_interface_descriptor uvc_streaming_intf_alt1 __initdata = {
         .iInterface             = 0,
 };
 
-static struct usb_endpoint_descriptor uvc_fs_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_fs_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -158,7 +147,7 @@ static struct usb_endpoint_descriptor uvc_fs_streaming_ep __initdata = {
          */
 };
 
-static struct usb_endpoint_descriptor uvc_hs_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_hs_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
         .bEndpointAddress       = USB_DIR_IN,
@@ -169,7 +158,7 @@ static struct usb_endpoint_descriptor uvc_hs_streaming_ep __initdata = {
          */
 };
 
-static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
+static struct usb_endpoint_descriptor uvc_ss_streaming_ep = {
         .bLength                = USB_DT_ENDPOINT_SIZE,
         .bDescriptorType        = USB_DT_ENDPOINT,
 
@@ -181,7 +170,7 @@ static struct usb_endpoint_descriptor uvc_ss_streaming_ep __initdata = {
          */
 };
 
-static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp __initdata = {
+static struct usb_ss_ep_comp_descriptor uvc_ss_streaming_comp = {
         .bLength                = sizeof(uvc_ss_streaming_comp),
         .bDescriptorType        = USB_DT_SS_ENDPOINT_COMP,
         /* The bMaxBurst, bmAttributes and wBytesPerInterval values will be
@@ -208,6 +197,12 @@ static const struct usb_descriptor_header * const uvc_ss_streaming[] = {
         NULL,
 };
 
+void uvc_set_trace_param(unsigned int trace)
+{
+        uvc_gadget_trace_param = trace;
+}
+EXPORT_SYMBOL(uvc_set_trace_param);
+
 /* --------------------------------------------------------------------------
  * Control requests
  */
@@ -251,6 +246,12 @@ uvc_function_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
         if (le16_to_cpu(ctrl->wLength) > UVC_MAX_REQUEST_SIZE)
                 return -EINVAL;
 
+        /* Tell the complete callback to generate an event for the next request
+         * that will be enqueued by UVCIOC_SEND_RESPONSE.
+         */
+        uvc->event_setup_out = !(ctrl->bRequestType & USB_DIR_IN);
+        uvc->event_length = le16_to_cpu(ctrl->wLength);
+
         memset(&v4l2_event, 0, sizeof(v4l2_event));
         v4l2_event.type = UVC_EVENT_SETUP;
         memcpy(&uvc_event->req, ctrl, sizeof(uvc_event->req));
@@ -408,7 +409,9 @@ uvc_register_video(struct uvc_device *uvc)
 
         video->v4l2_dev = &uvc->v4l2_dev;
         video->fops = &uvc_v4l2_fops;
+        video->ioctl_ops = &uvc_v4l2_ioctl_ops;
         video->release = video_device_release;
+        video->vfl_dir = VFL_DIR_TX;
         strlcpy(video->name, cdev->gadget->name, sizeof(video->name));
 
         uvc->vdev = video;
@@ -434,7 +437,7 @@ uvc_register_video(struct uvc_device *uvc)
                 } \
         } while (0)
 
-static struct usb_descriptor_header ** __init
+static struct usb_descriptor_header **
 uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
 {
         struct uvc_input_header_descriptor *uvc_streaming_header;
@@ -554,45 +557,26 @@ uvc_copy_descriptors(struct uvc_device *uvc, enum usb_device_speed speed)
         return hdr;
 }
 
-static void
-uvc_function_unbind(struct usb_configuration *c, struct usb_function *f)
-{
-        struct usb_composite_dev *cdev = c->cdev;
-        struct uvc_device *uvc = to_uvc(f);
-
-        INFO(cdev, "uvc_function_unbind\n");
-
-        video_unregister_device(uvc->vdev);
-        v4l2_device_unregister(&uvc->v4l2_dev);
-        uvc->control_ep->driver_data = NULL;
-        uvc->video.ep->driver_data = NULL;
-
-        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id = 0;
-        usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
-        kfree(uvc->control_buf);
-
-        usb_free_all_descriptors(f);
-
-        kfree(uvc);
-}
-
-static int __init
+static int
 uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
 {
         struct usb_composite_dev *cdev = c->cdev;
         struct uvc_device *uvc = to_uvc(f);
+        struct usb_string *us;
         unsigned int max_packet_mult;
         unsigned int max_packet_size;
         struct usb_ep *ep;
+        struct f_uvc_opts *opts;
         int ret = -EINVAL;
 
         INFO(cdev, "uvc_function_bind\n");
 
+        opts = to_f_uvc_opts(f->fi);
         /* Sanity check the streaming endpoint module parameters.
          */
-        streaming_interval = clamp(streaming_interval, 1U, 16U);
-        streaming_maxpacket = clamp(streaming_maxpacket, 1U, 3072U);
-        streaming_maxburst = min(streaming_maxburst, 15U);
+        opts->streaming_interval = clamp(opts->streaming_interval, 1U, 16U);
+        opts->streaming_maxpacket = clamp(opts->streaming_maxpacket, 1U, 3072U);
+        opts->streaming_maxburst = min(opts->streaming_maxburst, 15U);
 
         /* Fill in the FS/HS/SS Video Streaming specific descriptors from the
          * module parameters.
@@ -600,30 +584,32 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
          * NOTE: We assume that the user knows what they are doing and won't
          * give parameters that their UDC doesn't support.
          */
-        if (streaming_maxpacket <= 1024) {
+        if (opts->streaming_maxpacket <= 1024) {
                 max_packet_mult = 1;
-                max_packet_size = streaming_maxpacket;
-        } else if (streaming_maxpacket <= 2048) {
+                max_packet_size = opts->streaming_maxpacket;
+        } else if (opts->streaming_maxpacket <= 2048) {
                 max_packet_mult = 2;
-                max_packet_size = streaming_maxpacket / 2;
+                max_packet_size = opts->streaming_maxpacket / 2;
         } else {
                 max_packet_mult = 3;
-                max_packet_size = streaming_maxpacket / 3;
+                max_packet_size = opts->streaming_maxpacket / 3;
         }
 
-        uvc_fs_streaming_ep.wMaxPacketSize = min(streaming_maxpacket, 1023U);
-        uvc_fs_streaming_ep.bInterval = streaming_interval;
+        uvc_fs_streaming_ep.wMaxPacketSize =
+                cpu_to_le16(min(opts->streaming_maxpacket, 1023U));
+        uvc_fs_streaming_ep.bInterval = opts->streaming_interval;
 
-        uvc_hs_streaming_ep.wMaxPacketSize = max_packet_size;
-        uvc_hs_streaming_ep.wMaxPacketSize |= ((max_packet_mult - 1) << 11);
-        uvc_hs_streaming_ep.bInterval = streaming_interval;
+        uvc_hs_streaming_ep.wMaxPacketSize =
+                cpu_to_le16(max_packet_size | ((max_packet_mult - 1) << 11));
+        uvc_hs_streaming_ep.bInterval = opts->streaming_interval;
 
-        uvc_ss_streaming_ep.wMaxPacketSize = max_packet_size;
-        uvc_ss_streaming_ep.bInterval = streaming_interval;
+        uvc_ss_streaming_ep.wMaxPacketSize = cpu_to_le16(max_packet_size);
+        uvc_ss_streaming_ep.bInterval = opts->streaming_interval;
         uvc_ss_streaming_comp.bmAttributes = max_packet_mult - 1;
-        uvc_ss_streaming_comp.bMaxBurst = streaming_maxburst;
+        uvc_ss_streaming_comp.bMaxBurst = opts->streaming_maxburst;
         uvc_ss_streaming_comp.wBytesPerInterval =
-                max_packet_size * max_packet_mult * streaming_maxburst;
+                cpu_to_le16(max_packet_size * max_packet_mult *
+                            opts->streaming_maxburst);
 
         /* Allocate endpoints. */
         ep = usb_ep_autoconfig(cdev->gadget, &uvc_control_ep);
@@ -653,6 +639,18 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         uvc_hs_streaming_ep.bEndpointAddress = uvc->video.ep->address;
         uvc_ss_streaming_ep.bEndpointAddress = uvc->video.ep->address;
 
+        us = usb_gstrings_attach(cdev, uvc_function_strings,
+                                 ARRAY_SIZE(uvc_en_us_strings));
+        if (IS_ERR(us)) {
+                ret = PTR_ERR(us);
+                goto error;
+        }
+        uvc_iad.iFunction = us[UVC_STRING_CONTROL_IDX].id;
+        uvc_control_intf.iInterface = us[UVC_STRING_CONTROL_IDX].id;
+        ret = us[UVC_STRING_STREAMING_IDX].id;
+        uvc_streaming_intf_alt0.iInterface = ret;
+        uvc_streaming_intf_alt1.iInterface = ret;
+
         /* Allocate interface IDs. */
         if ((ret = usb_interface_id(c, f)) < 0)
                 goto error;
@@ -697,7 +695,7 @@ uvc_function_bind(struct usb_configuration *c, struct usb_function *f)
         }
 
         /* Initialise video. */
-        ret = uvc_video_init(&uvc->video);
+        ret = uvcg_video_init(&uvc->video);
         if (ret < 0)
                 goto error;
 
@@ -720,10 +718,9 @@ error:
         if (uvc->video.ep)
                 uvc->video.ep->driver_data = NULL;
 
-        if (uvc->control_req) {
+        if (uvc->control_req)
                 usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
-                kfree(uvc->control_buf);
-        }
+        kfree(uvc->control_buf);
 
         usb_free_all_descriptors(f);
         return ret;
@@ -733,104 +730,81 @@ error:
  * USB gadget function
  */
 
-/**
- * uvc_bind_config - add a UVC function to a configuration
- * @c: the configuration to support the UVC instance
- * Context: single threaded during gadget setup
- *
- * Returns zero on success, else negative errno.
- *
- * Caller must have called @uvc_setup(). Caller is also responsible for
- * calling @uvc_cleanup() before module unload.
- */
-int __init
-uvc_bind_config(struct usb_configuration *c,
-                const struct uvc_descriptor_header * const *fs_control,
-                const struct uvc_descriptor_header * const *ss_control,
-                const struct uvc_descriptor_header * const *fs_streaming,
-                const struct uvc_descriptor_header * const *hs_streaming,
-                const struct uvc_descriptor_header * const *ss_streaming)
+static void uvc_free_inst(struct usb_function_instance *f)
 {
-        struct uvc_device *uvc;
-        int ret = 0;
+        struct f_uvc_opts *opts = to_f_uvc_opts(f);
 
-        /* TODO Check if the USB device controller supports the required
-         * features.
-         */
-        if (!gadget_is_dualspeed(c->cdev->gadget))
-                return -EINVAL;
+        kfree(opts);
+}
 
-        uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
-        if (uvc == NULL)
-                return -ENOMEM;
+static struct usb_function_instance *uvc_alloc_inst(void)
+{
+        struct f_uvc_opts *opts;
 
-        uvc->state = UVC_STATE_DISCONNECTED;
+        opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+        if (!opts)
+                return ERR_PTR(-ENOMEM);
+        opts->func_inst.free_func_inst = uvc_free_inst;
 
-        /* Validate the descriptors. */
-        if (fs_control == NULL || fs_control[0] == NULL ||
-            fs_control[0]->bDescriptorSubType != UVC_VC_HEADER)
-                goto error;
+        return &opts->func_inst;
+}
 
-        if (ss_control == NULL || ss_control[0] == NULL ||
-            ss_control[0]->bDescriptorSubType != UVC_VC_HEADER)
-                goto error;
+static void uvc_free(struct usb_function *f)
+{
+        struct uvc_device *uvc = to_uvc(f);
 
-        if (fs_streaming == NULL || fs_streaming[0] == NULL ||
-            fs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
-                goto error;
+        kfree(uvc);
+}
 
-        if (hs_streaming == NULL || hs_streaming[0] == NULL ||
-            hs_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
-                goto error;
+static void uvc_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+        struct usb_composite_dev *cdev = c->cdev;
+        struct uvc_device *uvc = to_uvc(f);
 
-        if (ss_streaming == NULL || ss_streaming[0] == NULL ||
-            ss_streaming[0]->bDescriptorSubType != UVC_VS_INPUT_HEADER)
-                goto error;
+        INFO(cdev, "%s\n", __func__);
 
-        uvc->desc.fs_control = fs_control;
-        uvc->desc.ss_control = ss_control;
-        uvc->desc.fs_streaming = fs_streaming;
-        uvc->desc.hs_streaming = hs_streaming;
-        uvc->desc.ss_streaming = ss_streaming;
+        video_unregister_device(uvc->vdev);
+        v4l2_device_unregister(&uvc->v4l2_dev);
+        uvc->control_ep->driver_data = NULL;
+        uvc->video.ep->driver_data = NULL;
 
-        /* String descriptors are global, we only need to allocate string IDs
-         * for the first UVC function. UVC functions beyond the first (if any)
-         * will reuse the same IDs.
-         */
-        if (uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id == 0) {
-                ret = usb_string_ids_tab(c->cdev, uvc_en_us_strings);
-                if (ret)
-                        goto error;
-                uvc_iad.iFunction =
-                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
-                uvc_control_intf.iInterface =
-                        uvc_en_us_strings[UVC_STRING_CONTROL_IDX].id;
-                ret = uvc_en_us_strings[UVC_STRING_STREAMING_IDX].id;
-                uvc_streaming_intf_alt0.iInterface = ret;
-                uvc_streaming_intf_alt1.iInterface = ret;
-        }
+        usb_ep_free_request(cdev->gadget->ep0, uvc->control_req);
+        kfree(uvc->control_buf);
+
+        usb_free_all_descriptors(f);
+}
+
+static struct usb_function *uvc_alloc(struct usb_function_instance *fi)
+{
+        struct uvc_device *uvc;
+        struct f_uvc_opts *opts;
+
+        uvc = kzalloc(sizeof(*uvc), GFP_KERNEL);
+        if (uvc == NULL)
+                return ERR_PTR(-ENOMEM);
+
+        uvc->state = UVC_STATE_DISCONNECTED;
+        opts = to_f_uvc_opts(fi);
+
+        uvc->desc.fs_control = opts->fs_control;
+        uvc->desc.ss_control = opts->ss_control;
+        uvc->desc.fs_streaming = opts->fs_streaming;
+        uvc->desc.hs_streaming = opts->hs_streaming;
+        uvc->desc.ss_streaming = opts->ss_streaming;
 
         /* Register the function. */
         uvc->func.name = "uvc";
-        uvc->func.strings = uvc_function_strings;
         uvc->func.bind = uvc_function_bind;
-        uvc->func.unbind = uvc_function_unbind;
+        uvc->func.unbind = uvc_unbind;
         uvc->func.get_alt = uvc_function_get_alt;
         uvc->func.set_alt = uvc_function_set_alt;
         uvc->func.disable = uvc_function_disable;
         uvc->func.setup = uvc_function_setup;
+        uvc->func.free_func = uvc_free;
 
-        ret = usb_add_function(c, &uvc->func);
-        if (ret)
-                kfree(uvc);
-
-        return ret;
-
-error:
-        kfree(uvc);
-        return ret;
+        return &uvc->func;
 }
 
-module_param_named(trace, uvc_gadget_trace_param, uint, S_IRUGO|S_IWUSR);
-MODULE_PARM_DESC(trace, "Trace level bitmask");
-
+DECLARE_USB_FUNCTION_INIT(uvc, uvc_alloc_inst, uvc_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Laurent Pinchart");
diff --git a/drivers/usb/gadget/function/f_uvc.h b/drivers/usb/gadget/function/f_uvc.h
index ec52752f7326..d0a73bdcbba1 100644
--- a/drivers/usb/gadget/function/f_uvc.h
+++ b/drivers/usb/gadget/function/f_uvc.h
@@ -16,12 +16,13 @@
 #include <linux/usb/composite.h>
 #include <linux/usb/video.h>
 
-int uvc_bind_config(struct usb_configuration *c,
-                    const struct uvc_descriptor_header * const *fs_control,
-                    const struct uvc_descriptor_header * const *hs_control,
-                    const struct uvc_descriptor_header * const *fs_streaming,
-                    const struct uvc_descriptor_header * const *hs_streaming,
-                    const struct uvc_descriptor_header * const *ss_streaming);
+#include "uvc.h"
+
+void uvc_function_setup_continue(struct uvc_device *uvc);
+
+void uvc_function_connect(struct uvc_device *uvc);
+
+void uvc_function_disconnect(struct uvc_device *uvc);
 
 #endif /* _F_UVC_H_ */
 
diff --git a/drivers/usb/gadget/function/g_zero.h b/drivers/usb/gadget/function/g_zero.h
index 15f180904f8a..2ce28b9d97cc 100644
--- a/drivers/usb/gadget/function/g_zero.h
+++ b/drivers/usb/gadget/function/g_zero.h
@@ -10,6 +10,8 @@
 #define GZERO_QLEN              32
 #define GZERO_ISOC_INTERVAL     4
 #define GZERO_ISOC_MAXPACKET    1024
+#define GZERO_INT_INTERVAL      1 /* Default interrupt interval = 1 ms */
+#define GZERO_INT_MAXPACKET     1024
 
 struct usb_zero_options {
         unsigned pattern;
@@ -17,6 +19,10 @@ struct usb_zero_options {
         unsigned isoc_maxpacket;
         unsigned isoc_mult;
         unsigned isoc_maxburst;
+        unsigned int_interval; /* In ms */
+        unsigned int_maxpacket;
+        unsigned int_mult;
+        unsigned int_maxburst;
         unsigned bulk_buflen;
         unsigned qlen;
 };
@@ -28,6 +34,10 @@ struct f_ss_opts {
         unsigned isoc_maxpacket;
         unsigned isoc_mult;
         unsigned isoc_maxburst;
+        unsigned int_interval; /* In ms */
+        unsigned int_maxpacket;
+        unsigned int_mult;
+        unsigned int_maxburst;
         unsigned bulk_buflen;
 
         /*
@@ -62,6 +72,7 @@ int lb_modinit(void);
 void free_ep_req(struct usb_ep *ep, struct usb_request *req);
 void disable_endpoints(struct usb_composite_dev *cdev,
                 struct usb_ep *in, struct usb_ep *out,
-                struct usb_ep *iso_in, struct usb_ep *iso_out);
+                struct usb_ep *iso_in, struct usb_ep *iso_out,
+                struct usb_ep *int_in, struct usb_ep *int_out);
 
 #endif /* __G_ZERO_H */
diff --git a/drivers/usb/gadget/function/u_fs.h b/drivers/usb/gadget/function/u_fs.h
index d48897e8ffeb..cd128e31f808 100644
--- a/drivers/usb/gadget/function/u_fs.h
+++ b/drivers/usb/gadget/function/u_fs.h
@@ -224,6 +224,8 @@ struct ffs_data {
         void                            *ms_os_descs_ext_prop_name_avail;
         void                            *ms_os_descs_ext_prop_data_avail;
 
+        unsigned                        user_flags;
+
         u8                              eps_addrmap[15];
 
         unsigned short                  strings_count;
diff --git a/drivers/usb/gadget/function/u_serial.c b/drivers/usb/gadget/function/u_serial.c
index ad0aca812002..491082aaf103 100644
--- a/drivers/usb/gadget/function/u_serial.c
+++ b/drivers/usb/gadget/function/u_serial.c
@@ -55,11 +55,8 @@
  * for a telephone or fax link.  And ttyGS2 might be something that just
  * needs a simple byte stream interface for some messaging protocol that
  * is managed in userspace ... OBEX, PTP, and MTP have been mentioned.
- */
-
-#define PREFIX  "ttyGS"
-
-/*
+ *
+ *
  * gserial is the lifecycle interface, used by USB functions
  * gs_port is the I/O nexus, used by the tty driver
  * tty_struct links to the tty/filesystem framework
@@ -385,9 +382,9 @@ __acquires(&port->port_lock)
                 list_del(&req->list);
                 req->zero = (gs_buf_data_avail(&port->port_write_buf) == 0);
 
-                pr_vdebug(PREFIX "%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
-                                port->port_num, len, *((u8 *)req->buf),
-                                *((u8 *)req->buf+1), *((u8 *)req->buf+2));
+                pr_vdebug("ttyGS%d: tx len=%d, 0x%02x 0x%02x 0x%02x ...\n",
+                          port->port_num, len, *((u8 *)req->buf),
+                          *((u8 *)req->buf+1), *((u8 *)req->buf+2));
 
                 /* Drop lock while we call out of driver; completions
                  * could be issued while we do so.  Disconnection may
@@ -503,13 +500,13 @@ static void gs_rx_push(unsigned long _port)
                 switch (req->status) {
                 case -ESHUTDOWN:
                         disconnect = true;
-                        pr_vdebug(PREFIX "%d: shutdown\n", port->port_num);
+                        pr_vdebug("ttyGS%d: shutdown\n", port->port_num);
                         break;
 
                 default:
                         /* presumably a transient fault */
-                        pr_warning(PREFIX "%d: unexpected RX status %d\n",
-                                        port->port_num, req->status);
+                        pr_warn("ttyGS%d: unexpected RX status %d\n",
+                                port->port_num, req->status);
                         /* FALLTHROUGH */
                 case 0:
                         /* normal completion */
@@ -537,9 +534,8 @@ static void gs_rx_push(unsigned long _port)
                         if (count != size) {
                                 /* stop pushing; TTY layer can't handle more */
                                 port->n_read += count;
-                                pr_vdebug(PREFIX "%d: rx block %d/%d\n",
-                                                port->port_num,
-                                                count, req->actual);
+                                pr_vdebug("ttyGS%d: rx block %d/%d\n",
+                                          port->port_num, count, req->actual);
                                 break;
                         }
                         port->n_read = 0;
@@ -569,7 +565,7 @@ static void gs_rx_push(unsigned long _port)
                         if (do_push)
                                 tasklet_schedule(&port->push);
                         else
-                                pr_warning(PREFIX "%d: RX not scheduled?\n",
+                                pr_warn("ttyGS%d: RX not scheduled?\n",
                                         port->port_num);
                 }
         }
@@ -985,7 +981,7 @@ static void gs_unthrottle(struct tty_struct *tty)
                  * read queue backs up enough we'll be NAKing OUT packets.
                  */
                 tasklet_schedule(&port->push);
-                pr_vdebug(PREFIX "%d: unthrottle\n", port->port_num);
+                pr_vdebug("ttyGS%d: unthrottle\n", port->port_num);
         }
         spin_unlock_irqrestore(&port->port_lock, flags);
 }
@@ -1295,7 +1291,7 @@ static int userial_init(void)
                 return -ENOMEM;
 
         gs_tty_driver->driver_name = "g_serial";
-        gs_tty_driver->name = PREFIX;
+        gs_tty_driver->name = "ttyGS";
         /* uses dynamically assigned dev_t values */
 
         gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
diff --git a/drivers/usb/gadget/function/u_uac1.c b/drivers/usb/gadget/function/u_uac1.c
index 7a55fea43430..a44a07f30281 100644
--- a/drivers/usb/gadget/function/u_uac1.c
+++ b/drivers/usb/gadget/function/u_uac1.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/delay.h>
@@ -23,22 +24,6 @@
  * This component encapsulates the ALSA devices for USB audio gadget
  */
 
-#define FILE_PCM_PLAYBACK       "/dev/snd/pcmC0D0p"
-#define FILE_PCM_CAPTURE        "/dev/snd/pcmC0D0c"
-#define FILE_CONTROL            "/dev/snd/controlC0"
-
-static char *fn_play = FILE_PCM_PLAYBACK;
-module_param(fn_play, charp, S_IRUGO);
-MODULE_PARM_DESC(fn_play, "Playback PCM device file name");
-
-static char *fn_cap = FILE_PCM_CAPTURE;
-module_param(fn_cap, charp, S_IRUGO);
-MODULE_PARM_DESC(fn_cap, "Capture PCM device file name");
-
-static char *fn_cntl = FILE_CONTROL;
-module_param(fn_cntl, charp, S_IRUGO);
-MODULE_PARM_DESC(fn_cntl, "Control device file name");
-
 /*-------------------------------------------------------------------------*/
 
 /**
@@ -167,7 +152,7 @@ static int playback_default_hw_params(struct gaudio_snd_dev *snd)
 /**
  * Playback audio buffer data by ALSA PCM device
  */
-static size_t u_audio_playback(struct gaudio *card, void *buf, size_t count)
+size_t u_audio_playback(struct gaudio *card, void *buf, size_t count)
 {
         struct gaudio_snd_dev   *snd = &card->playback;
         struct snd_pcm_substream *substream = snd->substream;
@@ -202,12 +187,12 @@ try_again:
         return 0;
 }
 
-static int u_audio_get_playback_channels(struct gaudio *card)
+int u_audio_get_playback_channels(struct gaudio *card)
 {
         return card->playback.channels;
 }
 
-static int u_audio_get_playback_rate(struct gaudio *card)
+int u_audio_get_playback_rate(struct gaudio *card)
 {
         return card->playback.rate;
 }
@@ -220,6 +205,13 @@ static int gaudio_open_snd_dev(struct gaudio *card)
 {
         struct snd_pcm_file *pcm_file;
         struct gaudio_snd_dev *snd;
+        struct f_uac1_opts *opts;
+        char *fn_play, *fn_cap, *fn_cntl;
+
+        opts = container_of(card->func.fi, struct f_uac1_opts, func_inst);
+        fn_play = opts->fn_play;
+        fn_cap = opts->fn_cap;
+        fn_cntl = opts->fn_cntl;
 
         if (!card)
                 return -ENODEV;
@@ -293,7 +285,6 @@ static int gaudio_close_snd_dev(struct gaudio *gau)
         return 0;
 }
 
-static struct gaudio *the_card;
 /**
  * gaudio_setup - setup ALSA interface and preparing for USB transfer
  *
@@ -301,15 +292,13 @@ static struct gaudio *the_card;
  *
  * Returns negative errno, or zero on success
  */
-int __init gaudio_setup(struct gaudio *card)
+int gaudio_setup(struct gaudio *card)
 {
         int     ret;
 
         ret = gaudio_open_snd_dev(card);
         if (ret)
                 ERROR(card, "we need at least one control device\n");
-        else if (!the_card)
-                the_card = card;
 
         return ret;
 
@@ -320,11 +309,10 @@ int __init gaudio_setup(struct gaudio *card)
  *
  * This is called to free all resources allocated by @gaudio_setup().
  */
-void gaudio_cleanup(void)
+void gaudio_cleanup(struct gaudio *the_card)
 {
         if (the_card) {
                 gaudio_close_snd_dev(the_card);
-                the_card = NULL;
         }
 }
 
diff --git a/drivers/usb/gadget/function/u_uac1.h b/drivers/usb/gadget/function/u_uac1.h
index 18c2e729faf6..f8b17fe82efe 100644
--- a/drivers/usb/gadget/function/u_uac1.h
+++ b/drivers/usb/gadget/function/u_uac1.h
@@ -23,6 +23,14 @@
 
 #include "gadget_chips.h"
 
+#define FILE_PCM_PLAYBACK       "/dev/snd/pcmC0D0p"
+#define FILE_PCM_CAPTURE        "/dev/snd/pcmC0D0c"
+#define FILE_CONTROL            "/dev/snd/controlC0"
+
+#define UAC1_OUT_EP_MAX_PACKET_SIZE     200
+#define UAC1_REQ_COUNT                  256
+#define UAC1_AUDIO_BUF_SIZE             48000
+
 /*
  * This represents the USB side of an audio card device, managed by a USB
  * function which provides control and stream interfaces.
@@ -50,7 +58,28 @@ struct gaudio {
         /* TODO */
 };
 
+struct f_uac1_opts {
+        struct usb_function_instance    func_inst;
+        int                             req_buf_size;
+        int                             req_count;
+        int                             audio_buf_size;
+        char                            *fn_play;
+        char                            *fn_cap;
+        char                            *fn_cntl;
+        unsigned                        bound:1;
+        unsigned                        fn_play_alloc:1;
+        unsigned                        fn_cap_alloc:1;
+        unsigned                        fn_cntl_alloc:1;
+        struct gaudio                   *card;
+        struct mutex                    lock;
+        int                             refcnt;
+};
+
 int gaudio_setup(struct gaudio *card);
-void gaudio_cleanup(void);
+void gaudio_cleanup(struct gaudio *the_card);
+
+size_t u_audio_playback(struct gaudio *card, void *buf, size_t count);
+int u_audio_get_playback_channels(struct gaudio *card);
+int u_audio_get_playback_rate(struct gaudio *card);
 
 #endif /* __U_AUDIO_H */
diff --git a/drivers/usb/gadget/function/u_uac2.h b/drivers/usb/gadget/function/u_uac2.h
new file mode 100644
index 000000000000..78dd37279bd4
--- /dev/null
+++ b/drivers/usb/gadget/function/u_uac2.h
@@ -0,0 +1,42 @@
+/*
+ * u_uac2.h
+ *
+ * Utility definitions for UAC2 function
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef U_UAC2_H
+#define U_UAC2_H
+
+#include <linux/usb/composite.h>
+
+#define UAC2_DEF_PCHMASK 0x3
+#define UAC2_DEF_PSRATE 48000
+#define UAC2_DEF_PSSIZE 2
+#define UAC2_DEF_CCHMASK 0x3
+#define UAC2_DEF_CSRATE 64000
+#define UAC2_DEF_CSSIZE 2
+
+struct f_uac2_opts {
+        struct usb_function_instance    func_inst;
+        int                             p_chmask;
+        int                             p_srate;
+        int                             p_ssize;
+        int                             c_chmask;
+        int                             c_srate;
+        int                             c_ssize;
+        bool                            bound;
+
+        struct mutex                    lock;
+        int                             refcnt;
+};
+
+#endif
diff --git a/drivers/usb/gadget/function/u_uvc.h b/drivers/usb/gadget/function/u_uvc.h
new file mode 100644
index 000000000000..2a8dfdff0332
--- /dev/null
+++ b/drivers/usb/gadget/function/u_uvc.h
@@ -0,0 +1,39 @@
+/*
+ * u_uvc.h
+ *
+ * Utility definitions for the uvc function
+ *
+ * Copyright (c) 2013-2014 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef U_UVC_H
+#define U_UVC_H
+
+#include <linux/usb/composite.h>
+
+#define to_f_uvc_opts(f)        container_of(f, struct f_uvc_opts, func_inst)
+
+struct f_uvc_opts {
+        struct usb_function_instance                    func_inst;
+        unsigned int                                    uvc_gadget_trace_param;
+        unsigned int                                    streaming_interval;
+        unsigned int                                    streaming_maxpacket;
+        unsigned int                                    streaming_maxburst;
+        const struct uvc_descriptor_header * const      *fs_control;
+        const struct uvc_descriptor_header * const      *ss_control;
+        const struct uvc_descriptor_header * const      *fs_streaming;
+        const struct uvc_descriptor_header * const      *hs_streaming;
+        const struct uvc_descriptor_header * const      *ss_streaming;
+};
+
+void uvc_set_trace_param(unsigned int trace);
+
+#endif /* U_UVC_H */
+
diff --git a/drivers/usb/gadget/function/uvc.h b/drivers/usb/gadget/function/uvc.h
index 7a9111de8054..f67695cb28f8 100644
--- a/drivers/usb/gadget/function/uvc.h
+++ b/drivers/usb/gadget/function/uvc.h
@@ -53,6 +53,7 @@ struct uvc_event
 #ifdef __KERNEL__
 
 #include <linux/usb.h>  /* For usb_endpoint_* */
+#include <linux/usb/composite.h>
 #include <linux/usb/gadget.h>
 #include <linux/videodev2.h>
 #include <linux/version.h>
@@ -96,9 +97,6 @@ extern unsigned int uvc_gadget_trace_param;
  * Driver specific constants
  */
 
-#define DRIVER_VERSION                          "0.1.0"
-#define DRIVER_VERSION_NUMBER                   KERNEL_VERSION(0, 1, 0)
-
 #define UVC_NUM_REQUESTS                        4
 #define UVC_MAX_REQUEST_SIZE                    64
 #define UVC_MAX_EVENTS                          4
diff --git a/drivers/usb/gadget/function/uvc_queue.c b/drivers/usb/gadget/function/uvc_queue.c
index 1c29bc954db9..8ea8b3b227b4 100644
--- a/drivers/usb/gadget/function/uvc_queue.c
+++ b/drivers/usb/gadget/function/uvc_queue.c
@@ -28,7 +28,7 @@
 /* ------------------------------------------------------------------------
  * Video buffers queue management.
  *
- * Video queues is initialized by uvc_queue_init(). The function performs
+ * Video queues is initialized by uvcg_queue_init(). The function performs
  * basic initialization of the uvc_video_queue struct and never fails.
  *
  * Video buffers are managed by videobuf2. The driver uses a mutex to protect
@@ -126,13 +126,12 @@ static struct vb2_ops uvc_queue_qops = {
         .wait_finish = uvc_wait_finish,
 };
 
-static int uvc_queue_init(struct uvc_video_queue *queue,
-                          enum v4l2_buf_type type)
+int uvcg_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type)
 {
         int ret;
 
         queue->queue.type = type;
-        queue->queue.io_modes = VB2_MMAP | VB2_USERPTR;
+        queue->queue.io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF;
         queue->queue.drv_priv = queue;
         queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
         queue->queue.ops = &uvc_queue_qops;
@@ -154,7 +153,7 @@ static int uvc_queue_init(struct uvc_video_queue *queue,
 /*
  * Free the video buffers.
  */
-static void uvc_free_buffers(struct uvc_video_queue *queue)
+void uvcg_free_buffers(struct uvc_video_queue *queue)
 {
         mutex_lock(&queue->mutex);
         vb2_queue_release(&queue->queue);
@@ -164,8 +163,8 @@ static void uvc_free_buffers(struct uvc_video_queue *queue)
 /*
  * Allocate the video buffers.
  */
-static int uvc_alloc_buffers(struct uvc_video_queue *queue,
-                             struct v4l2_requestbuffers *rb)
+int uvcg_alloc_buffers(struct uvc_video_queue *queue,
+                              struct v4l2_requestbuffers *rb)
 {
         int ret;
 
@@ -176,8 +175,7 @@ static int uvc_alloc_buffers(struct uvc_video_queue *queue,
         return ret ? ret : rb->count;
 }
 
-static int uvc_query_buffer(struct uvc_video_queue *queue,
-                            struct v4l2_buffer *buf)
+int uvcg_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
 {
         int ret;
 
@@ -188,8 +186,7 @@ static int uvc_query_buffer(struct uvc_video_queue *queue,
         return ret;
 }
 
-static int uvc_queue_buffer(struct uvc_video_queue *queue,
-                            struct v4l2_buffer *buf)
+int uvcg_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf)
 {
         unsigned long flags;
         int ret;
@@ -213,8 +210,8 @@ done:
  * Dequeue a video buffer. If nonblocking is false, block until a buffer is
  * available.
  */
-static int uvc_dequeue_buffer(struct uvc_video_queue *queue,
-                              struct v4l2_buffer *buf, int nonblocking)
+int uvcg_dequeue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf,
+                        int nonblocking)
 {
         int ret;
 
@@ -231,8 +228,8 @@ static int uvc_dequeue_buffer(struct uvc_video_queue *queue,
  * This function implements video queue polling and is intended to be used by
  * the device poll handler.
  */
-static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
-                                   struct file *file, poll_table *wait)
+unsigned int uvcg_queue_poll(struct uvc_video_queue *queue, struct file *file,
+                             poll_table *wait)
 {
         unsigned int ret;
 
@@ -243,8 +240,7 @@ static unsigned int uvc_queue_poll(struct uvc_video_queue *queue,
         return ret;
 }
 
-static int uvc_queue_mmap(struct uvc_video_queue *queue,
-                          struct vm_area_struct *vma)
+int uvcg_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma)
 {
         int ret;
 
@@ -261,8 +257,8 @@ static int uvc_queue_mmap(struct uvc_video_queue *queue,
  *
  * NO-MMU arch need this function to make mmap() work correctly.
  */
-static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
-                unsigned long pgoff)
+unsigned long uvcg_queue_get_unmapped_area(struct uvc_video_queue *queue,
+                                           unsigned long pgoff)
 {
         unsigned long ret;
 
@@ -285,7 +281,7 @@ static unsigned long uvc_queue_get_unmapped_area(struct uvc_video_queue *queue,
  * This function acquires the irq spinlock and can be called from interrupt
  * context.
  */
-static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
+void uvcg_queue_cancel(struct uvc_video_queue *queue, int disconnect)
 {
         struct uvc_buffer *buf;
         unsigned long flags;
@@ -324,9 +320,9 @@ static void uvc_queue_cancel(struct uvc_video_queue *queue, int disconnect)
  * the main queue.
  *
  * This function can't be called from interrupt context. Use
- * uvc_queue_cancel() instead.
+ * uvcg_queue_cancel() instead.
  */
-static int uvc_queue_enable(struct uvc_video_queue *queue, int enable)
+int uvcg_queue_enable(struct uvc_video_queue *queue, int enable)
 {
         unsigned long flags;
         int ret = 0;
@@ -363,8 +359,8 @@ done:
 }
 
 /* called with &queue_irqlock held.. */
-static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
-                                                struct uvc_buffer *buf)
+struct uvc_buffer *uvcg_queue_next_buffer(struct uvc_video_queue *queue,
+                                          struct uvc_buffer *buf)
 {
         struct uvc_buffer *nextbuf;
 
@@ -392,7 +388,7 @@ static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         return nextbuf;
 }
 
-static struct uvc_buffer *uvc_queue_head(struct uvc_video_queue *queue)
+struct uvc_buffer *uvcg_queue_head(struct uvc_video_queue *queue)
 {
         struct uvc_buffer *buf = NULL;
 
diff --git a/drivers/usb/gadget/function/uvc_queue.h b/drivers/usb/gadget/function/uvc_queue.h
index 8e76ce982f1e..03919c724961 100644
--- a/drivers/usb/gadget/function/uvc_queue.h
+++ b/drivers/usb/gadget/function/uvc_queue.h
@@ -57,6 +57,39 @@ static inline int uvc_queue_streaming(struct uvc_video_queue *queue)
         return vb2_is_streaming(&queue->queue);
 }
 
+int uvcg_queue_init(struct uvc_video_queue *queue, enum v4l2_buf_type type);
+
+void uvcg_free_buffers(struct uvc_video_queue *queue);
+
+int uvcg_alloc_buffers(struct uvc_video_queue *queue,
+                       struct v4l2_requestbuffers *rb);
+
+int uvcg_query_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf);
+
+int uvcg_queue_buffer(struct uvc_video_queue *queue, struct v4l2_buffer *buf);
+
+int uvcg_dequeue_buffer(struct uvc_video_queue *queue,
+                        struct v4l2_buffer *buf, int nonblocking);
+
+unsigned int uvcg_queue_poll(struct uvc_video_queue *queue,
+                             struct file *file, poll_table *wait);
+
+int uvcg_queue_mmap(struct uvc_video_queue *queue, struct vm_area_struct *vma);
+
+#ifndef CONFIG_MMU
+unsigned long uvcg_queue_get_unmapped_area(struct uvc_video_queue *queue,
+                                           unsigned long pgoff);
+#endif /* CONFIG_MMU */
+
+void uvcg_queue_cancel(struct uvc_video_queue *queue, int disconnect);
+
+int uvcg_queue_enable(struct uvc_video_queue *queue, int enable);
+
+struct uvc_buffer *uvcg_queue_next_buffer(struct uvc_video_queue *queue,
+                                          struct uvc_buffer *buf);
+
+struct uvc_buffer *uvcg_queue_head(struct uvc_video_queue *queue);
+
 #endif /* __KERNEL__ */
 
 #endif /* _UVC_QUEUE_H_ */
diff --git a/drivers/usb/gadget/function/uvc_v4l2.c b/drivers/usb/gadget/function/uvc_v4l2.c
index ad48e81155e2..5aad7fededa5 100644
--- a/drivers/usb/gadget/function/uvc_v4l2.c
+++ b/drivers/usb/gadget/function/uvc_v4l2.c
@@ -23,8 +23,10 @@
 #include <media/v4l2-event.h>
 #include <media/v4l2-ioctl.h>
 
+#include "f_uvc.h"
 #include "uvc.h"
 #include "uvc_queue.h"
+#include "uvc_video.h"
 
 /* --------------------------------------------------------------------------
  * Requests handling
@@ -48,7 +50,7 @@ uvc_send_response(struct uvc_device *uvc, struct uvc_request_data *data)
 }
 
 /* --------------------------------------------------------------------------
- * V4L2
+ * V4L2 ioctls
  */
 
 struct uvc_format
@@ -63,8 +65,29 @@ static struct uvc_format uvc_formats[] = {
 };
 
 static int
-uvc_v4l2_get_format(struct uvc_video *video, struct v4l2_format *fmt)
+uvc_v4l2_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
 {
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct usb_composite_dev *cdev = uvc->func.config->cdev;
+
+        strlcpy(cap->driver, "g_uvc", sizeof(cap->driver));
+        strlcpy(cap->card, cdev->gadget->name, sizeof(cap->card));
+        strlcpy(cap->bus_info, dev_name(&cdev->gadget->dev),
+                sizeof(cap->bus_info));
+
+        cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
+
+        return 0;
+}
+
+static int
+uvc_v4l2_get_format(struct file *file, void *fh, struct v4l2_format *fmt)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_video *video = &uvc->video;
+
         fmt->fmt.pix.pixelformat = video->fcc;
         fmt->fmt.pix.width = video->width;
         fmt->fmt.pix.height = video->height;
@@ -78,8 +101,11 @@ uvc_v4l2_get_format(struct uvc_video *video, struct v4l2_format *fmt)
 }
 
 static int
-uvc_v4l2_set_format(struct uvc_video *video, struct v4l2_format *fmt)
+uvc_v4l2_set_format(struct file *file, void *fh, struct v4l2_format *fmt)
 {
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_video *video = &uvc->video;
         struct uvc_format *format;
         unsigned int imagesize;
         unsigned int bpl;
@@ -116,209 +142,184 @@ uvc_v4l2_set_format(struct uvc_video *video, struct v4l2_format *fmt)
 }
 
 static int
-uvc_v4l2_open(struct file *file)
+uvc_v4l2_reqbufs(struct file *file, void *fh, struct v4l2_requestbuffers *b)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
-        struct uvc_file_handle *handle;
-
-        handle = kzalloc(sizeof(*handle), GFP_KERNEL);
-        if (handle == NULL)
-                return -ENOMEM;
-
-        v4l2_fh_init(&handle->vfh, vdev);
-        v4l2_fh_add(&handle->vfh);
+        struct uvc_video *video = &uvc->video;
 
-        handle->device = &uvc->video;
-        file->private_data = &handle->vfh;
+        if (b->type != video->queue.queue.type)
+                return -EINVAL;
 
-        uvc_function_connect(uvc);
-        return 0;
+        return uvcg_alloc_buffers(&video->queue, b);
 }
 
 static int
-uvc_v4l2_release(struct file *file)
+uvc_v4l2_querybuf(struct file *file, void *fh, struct v4l2_buffer *b)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
-        struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data);
-        struct uvc_video *video = handle->device;
-
-        uvc_function_disconnect(uvc);
-
-        uvc_video_enable(video, 0);
-        uvc_free_buffers(&video->queue);
-
-        file->private_data = NULL;
-        v4l2_fh_del(&handle->vfh);
-        v4l2_fh_exit(&handle->vfh);
-        kfree(handle);
+        struct uvc_video *video = &uvc->video;
 
-        return 0;
+        return uvcg_query_buffer(&video->queue, b);
 }
 
-static long
-uvc_v4l2_do_ioctl(struct file *file, unsigned int cmd, void *arg)
+static int
+uvc_v4l2_qbuf(struct file *file, void *fh, struct v4l2_buffer *b)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
-        struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data);
-        struct usb_composite_dev *cdev = uvc->func.config->cdev;
         struct uvc_video *video = &uvc->video;
-        int ret = 0;
-
-        switch (cmd) {
-        /* Query capabilities */
-        case VIDIOC_QUERYCAP:
-        {
-                struct v4l2_capability *cap = arg;
-
-                memset(cap, 0, sizeof *cap);
-                strlcpy(cap->driver, "g_uvc", sizeof(cap->driver));
-                strlcpy(cap->card, cdev->gadget->name, sizeof(cap->card));
-                strlcpy(cap->bus_info, dev_name(&cdev->gadget->dev),
-                        sizeof cap->bus_info);
-                cap->version = DRIVER_VERSION_NUMBER;
-                cap->capabilities = V4L2_CAP_VIDEO_OUTPUT | V4L2_CAP_STREAMING;
-                break;
-        }
-
-        /* Get & Set format */
-        case VIDIOC_G_FMT:
-        {
-                struct v4l2_format *fmt = arg;
+        int ret;
 
-                if (fmt->type != video->queue.queue.type)
-                        return -EINVAL;
+        ret = uvcg_queue_buffer(&video->queue, b);
+        if (ret < 0)
+                return ret;
 
-                return uvc_v4l2_get_format(video, fmt);
-        }
+        return uvcg_video_pump(video);
+}
 
-        case VIDIOC_S_FMT:
-        {
-                struct v4l2_format *fmt = arg;
+static int
+uvc_v4l2_dqbuf(struct file *file, void *fh, struct v4l2_buffer *b)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_video *video = &uvc->video;
 
-                if (fmt->type != video->queue.queue.type)
-                        return -EINVAL;
+        return uvcg_dequeue_buffer(&video->queue, b, file->f_flags & O_NONBLOCK);
+}
 
-                return uvc_v4l2_set_format(video, fmt);
-        }
+static int
+uvc_v4l2_streamon(struct file *file, void *fh, enum v4l2_buf_type type)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_video *video = &uvc->video;
+        int ret;
 
-        /* Buffers & streaming */
-        case VIDIOC_REQBUFS:
-        {
-                struct v4l2_requestbuffers *rb = arg;
+        if (type != video->queue.queue.type)
+                return -EINVAL;
 
-                if (rb->type != video->queue.queue.type)
-                        return -EINVAL;
+        /* Enable UVC video. */
+        ret = uvcg_video_enable(video, 1);
+        if (ret < 0)
+                return ret;
 
-                ret = uvc_alloc_buffers(&video->queue, rb);
-                if (ret < 0)
-                        return ret;
+        /*
+         * Complete the alternate setting selection setup phase now that
+         * userspace is ready to provide video frames.
+         */
+        uvc_function_setup_continue(uvc);
+        uvc->state = UVC_STATE_STREAMING;
 
-                ret = 0;
-                break;
-        }
-
-        case VIDIOC_QUERYBUF:
-        {
-                struct v4l2_buffer *buf = arg;
+        return 0;
+}
 
-                return uvc_query_buffer(&video->queue, buf);
-        }
+static int
+uvc_v4l2_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_video *video = &uvc->video;
 
-        case VIDIOC_QBUF:
-                if ((ret = uvc_queue_buffer(&video->queue, arg)) < 0)
-                        return ret;
+        if (type != video->queue.queue.type)
+                return -EINVAL;
 
-                return uvc_video_pump(video);
+        return uvcg_video_enable(video, 0);
+}
 
-        case VIDIOC_DQBUF:
-                return uvc_dequeue_buffer(&video->queue, arg,
-                        file->f_flags & O_NONBLOCK);
+static int
+uvc_v4l2_subscribe_event(struct v4l2_fh *fh,
+                         const struct v4l2_event_subscription *sub)
+{
+        if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
+                return -EINVAL;
 
-        case VIDIOC_STREAMON:
-        {
-                int *type = arg;
+        return v4l2_event_subscribe(fh, sub, 2, NULL);
+}
 
-                if (*type != video->queue.queue.type)
-                        return -EINVAL;
+static int
+uvc_v4l2_unsubscribe_event(struct v4l2_fh *fh,
+                           const struct v4l2_event_subscription *sub)
+{
+        return v4l2_event_unsubscribe(fh, sub);
+}
 
-                /* Enable UVC video. */
-                ret = uvc_video_enable(video, 1);
-                if (ret < 0)
-                        return ret;
+static long
+uvc_v4l2_ioctl_default(struct file *file, void *fh, bool valid_prio,
+                       unsigned int cmd, void *arg)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
 
-                /*
-                 * Complete the alternate setting selection setup phase now that
-                 * userspace is ready to provide video frames.
-                 */
-                uvc_function_setup_continue(uvc);
-                uvc->state = UVC_STATE_STREAMING;
+        switch (cmd) {
+        case UVCIOC_SEND_RESPONSE:
+                return uvc_send_response(uvc, arg);
 
-                return 0;
+        default:
+                return -ENOIOCTLCMD;
         }
+}
 
-        case VIDIOC_STREAMOFF:
-        {
-                int *type = arg;
-
-                if (*type != video->queue.queue.type)
-                        return -EINVAL;
+const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops = {
+        .vidioc_querycap = uvc_v4l2_querycap,
+        .vidioc_g_fmt_vid_out = uvc_v4l2_get_format,
+        .vidioc_s_fmt_vid_out = uvc_v4l2_set_format,
+        .vidioc_reqbufs = uvc_v4l2_reqbufs,
+        .vidioc_querybuf = uvc_v4l2_querybuf,
+        .vidioc_qbuf = uvc_v4l2_qbuf,
+        .vidioc_dqbuf = uvc_v4l2_dqbuf,
+        .vidioc_streamon = uvc_v4l2_streamon,
+        .vidioc_streamoff = uvc_v4l2_streamoff,
+        .vidioc_subscribe_event = uvc_v4l2_subscribe_event,
+        .vidioc_unsubscribe_event = uvc_v4l2_unsubscribe_event,
+        .vidioc_default = uvc_v4l2_ioctl_default,
+};
 
-                return uvc_video_enable(video, 0);
-        }
+/* --------------------------------------------------------------------------
+ * V4L2
+ */
 
-        /* Events */
-        case VIDIOC_DQEVENT:
-        {
-                struct v4l2_event *event = arg;
-
-                ret = v4l2_event_dequeue(&handle->vfh, event,
-                                         file->f_flags & O_NONBLOCK);
-                if (ret == 0 && event->type == UVC_EVENT_SETUP) {
-                        struct uvc_event *uvc_event = (void *)&event->u.data;
-
-                        /* Tell the complete callback to generate an event for
-                         * the next request that will be enqueued by
-                         * uvc_event_write.
-                         */
-                        uvc->event_setup_out =
-                                !(uvc_event->req.bRequestType & USB_DIR_IN);
-                        uvc->event_length = uvc_event->req.wLength;
-                }
+static int
+uvc_v4l2_open(struct file *file)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_file_handle *handle;
 
-                return ret;
-        }
+        handle = kzalloc(sizeof(*handle), GFP_KERNEL);
+        if (handle == NULL)
+                return -ENOMEM;
 
-        case VIDIOC_SUBSCRIBE_EVENT:
-        {
-                struct v4l2_event_subscription *sub = arg;
+        v4l2_fh_init(&handle->vfh, vdev);
+        v4l2_fh_add(&handle->vfh);
 
-                if (sub->type < UVC_EVENT_FIRST || sub->type > UVC_EVENT_LAST)
-                        return -EINVAL;
+        handle->device = &uvc->video;
+        file->private_data = &handle->vfh;
 
-                return v4l2_event_subscribe(&handle->vfh, arg, 2, NULL);
-        }
+        uvc_function_connect(uvc);
+        return 0;
+}
 
-        case VIDIOC_UNSUBSCRIBE_EVENT:
-                return v4l2_event_unsubscribe(&handle->vfh, arg);
+static int
+uvc_v4l2_release(struct file *file)
+{
+        struct video_device *vdev = video_devdata(file);
+        struct uvc_device *uvc = video_get_drvdata(vdev);
+        struct uvc_file_handle *handle = to_uvc_file_handle(file->private_data);
+        struct uvc_video *video = handle->device;
 
-        case UVCIOC_SEND_RESPONSE:
-                ret = uvc_send_response(uvc, arg);
-                break;
+        uvc_function_disconnect(uvc);
 
-        default:
-                return -ENOIOCTLCMD;
-        }
+        uvcg_video_enable(video, 0);
+        uvcg_free_buffers(&video->queue);
 
-        return ret;
-}
+        file->private_data = NULL;
+        v4l2_fh_del(&handle->vfh);
+        v4l2_fh_exit(&handle->vfh);
+        kfree(handle);
 
-static long
-uvc_v4l2_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
-{
-        return video_usercopy(file, cmd, arg, uvc_v4l2_do_ioctl);
+        return 0;
 }
 
 static int
@@ -327,7 +328,7 @@ uvc_v4l2_mmap(struct file *file, struct vm_area_struct *vma)
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
 
-        return uvc_queue_mmap(&uvc->video.queue, vma);
+        return uvcg_queue_mmap(&uvc->video.queue, vma);
 }
 
 static unsigned int
@@ -336,30 +337,30 @@ uvc_v4l2_poll(struct file *file, poll_table *wait)
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
 
-        return uvc_queue_poll(&uvc->video.queue, file, wait);
+        return uvcg_queue_poll(&uvc->video.queue, file, wait);
 }
 
 #ifndef CONFIG_MMU
-static unsigned long uvc_v4l2_get_unmapped_area(struct file *file,
+static unsigned long uvcg_v4l2_get_unmapped_area(struct file *file,
                 unsigned long addr, unsigned long len, unsigned long pgoff,
                 unsigned long flags)
 {
         struct video_device *vdev = video_devdata(file);
         struct uvc_device *uvc = video_get_drvdata(vdev);
 
-        return uvc_queue_get_unmapped_area(&uvc->video.queue, pgoff);
+        return uvcg_queue_get_unmapped_area(&uvc->video.queue, pgoff);
 }
 #endif
 
-static struct v4l2_file_operations uvc_v4l2_fops = {
+struct v4l2_file_operations uvc_v4l2_fops = {
         .owner          = THIS_MODULE,
         .open           = uvc_v4l2_open,
         .release        = uvc_v4l2_release,
-        .ioctl          = uvc_v4l2_ioctl,
+        .ioctl          = video_ioctl2,
         .mmap           = uvc_v4l2_mmap,
         .poll           = uvc_v4l2_poll,
 #ifndef CONFIG_MMU
-        .get_unmapped_area = uvc_v4l2_get_unmapped_area,
+        .get_unmapped_area = uvcg_v4l2_get_unmapped_area,
 #endif
 };
 
diff --git a/drivers/usb/gadget/function/uvc_v4l2.h b/drivers/usb/gadget/function/uvc_v4l2.h
new file mode 100644
index 000000000000..2683b92fda65
--- /dev/null
+++ b/drivers/usb/gadget/function/uvc_v4l2.h
@@ -0,0 +1,22 @@
+/*
+ *      uvc_v4l2.h  --  USB Video Class Gadget driver
+ *
+ * Copyright (C) 2009-2010
+ *              Laurent Pinchart (laurent.pinchart@ideasonboard.com)
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *              Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __UVC_V4L2_H__
+#define __UVC_V4L2_H__
+
+extern const struct v4l2_ioctl_ops uvc_v4l2_ioctl_ops;
+extern struct v4l2_file_operations uvc_v4l2_fops;
+
+#endif /* __UVC_V4L2_H__ */
diff --git a/drivers/usb/gadget/function/uvc_video.c b/drivers/usb/gadget/function/uvc_video.c
index a5eb9a3fbb7a..c3e1f27dbbef 100644
--- a/drivers/usb/gadget/function/uvc_video.c
+++ b/drivers/usb/gadget/function/uvc_video.c
@@ -15,6 +15,7 @@
 #include <linux/errno.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/video.h>
 
 #include <media/v4l2-dev.h>
 
@@ -85,7 +86,7 @@ uvc_video_encode_bulk(struct usb_request *req, struct uvc_video *video,
         if (buf->bytesused == video->queue.buf_used) {
                 video->queue.buf_used = 0;
                 buf->state = UVC_BUF_STATE_DONE;
-                uvc_queue_next_buffer(&video->queue, buf);
+                uvcg_queue_next_buffer(&video->queue, buf);
                 video->fid ^= UVC_STREAM_FID;
 
                 video->payload_size = 0;
@@ -118,7 +119,7 @@ uvc_video_encode_isoc(struct usb_request *req, struct uvc_video *video,
         if (buf->bytesused == video->queue.buf_used) {
                 video->queue.buf_used = 0;
                 buf->state = UVC_BUF_STATE_DONE;
-                uvc_queue_next_buffer(&video->queue, buf);
+                uvcg_queue_next_buffer(&video->queue, buf);
                 video->fid ^= UVC_STREAM_FID;
         }
 }
@@ -171,19 +172,19 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req)
                 break;
 
         case -ESHUTDOWN:        /* disconnect from host. */
-                printk(KERN_INFO "VS request cancelled.\n");
-                uvc_queue_cancel(queue, 1);
+                printk(KERN_DEBUG "VS request cancelled.\n");
+                uvcg_queue_cancel(queue, 1);
                 goto requeue;
 
         default:
                 printk(KERN_INFO "VS request completed with status %d.\n",
                         req->status);
-                uvc_queue_cancel(queue, 0);
+                uvcg_queue_cancel(queue, 0);
                 goto requeue;
         }
 
         spin_lock_irqsave(&video->queue.irqlock, flags);
-        buf = uvc_queue_head(&video->queue);
+        buf = uvcg_queue_head(&video->queue);
         if (buf == NULL) {
                 spin_unlock_irqrestore(&video->queue.irqlock, flags);
                 goto requeue;
@@ -195,7 +196,7 @@ uvc_video_complete(struct usb_ep *ep, struct usb_request *req)
                 printk(KERN_INFO "Failed to queue request (%d).\n", ret);
                 usb_ep_set_halt(ep);
                 spin_unlock_irqrestore(&video->queue.irqlock, flags);
-                uvc_queue_cancel(queue, 0);
+                uvcg_queue_cancel(queue, 0);
                 goto requeue;
         }
         spin_unlock_irqrestore(&video->queue.irqlock, flags);
@@ -274,13 +275,12 @@ error:
  */
 
 /*
- * uvc_video_pump - Pump video data into the USB requests
+ * uvcg_video_pump - Pump video data into the USB requests
  *
  * This function fills the available USB requests (listed in req_free) with
  * video data from the queued buffers.
  */
-static int
-uvc_video_pump(struct uvc_video *video)
+int uvcg_video_pump(struct uvc_video *video)
 {
         struct uvc_video_queue *queue = &video->queue;
         struct usb_request *req;
@@ -288,7 +288,7 @@ uvc_video_pump(struct uvc_video *video)
         unsigned long flags;
         int ret;
 
-        /* FIXME TODO Race between uvc_video_pump and requests completion
+        /* FIXME TODO Race between uvcg_video_pump and requests completion
          * handler ???
          */
 
@@ -309,10 +309,10 @@ uvc_video_pump(struct uvc_video *video)
                 /* Retrieve the first available video buffer and fill the
                  * request, protected by the video queue irqlock.
                  */
-                spin_lock_irqsave(&video->queue.irqlock, flags);
-                buf = uvc_queue_head(&video->queue);
+                spin_lock_irqsave(&queue->irqlock, flags);
+                buf = uvcg_queue_head(queue);
                 if (buf == NULL) {
-                        spin_unlock_irqrestore(&video->queue.irqlock, flags);
+                        spin_unlock_irqrestore(&queue->irqlock, flags);
                         break;
                 }
 
@@ -323,11 +323,11 @@ uvc_video_pump(struct uvc_video *video)
                 if (ret < 0) {
                         printk(KERN_INFO "Failed to queue request (%d)\n", ret);
                         usb_ep_set_halt(video->ep);
-                        spin_unlock_irqrestore(&video->queue.irqlock, flags);
-                        uvc_queue_cancel(queue, 0);
+                        spin_unlock_irqrestore(&queue->irqlock, flags);
+                        uvcg_queue_cancel(queue, 0);
                         break;
                 }
-                spin_unlock_irqrestore(&video->queue.irqlock, flags);
+                spin_unlock_irqrestore(&queue->irqlock, flags);
         }
 
         spin_lock_irqsave(&video->req_lock, flags);
@@ -339,8 +339,7 @@ uvc_video_pump(struct uvc_video *video)
 /*
  * Enable or disable the video stream.
  */
-static int
-uvc_video_enable(struct uvc_video *video, int enable)
+int uvcg_video_enable(struct uvc_video *video, int enable)
 {
         unsigned int i;
         int ret;
@@ -356,11 +355,11 @@ uvc_video_enable(struct uvc_video *video, int enable)
                         usb_ep_dequeue(video->ep, video->req[i]);
 
                 uvc_video_free_requests(video);
-                uvc_queue_enable(&video->queue, 0);
+                uvcg_queue_enable(&video->queue, 0);
                 return 0;
         }
 
-        if ((ret = uvc_queue_enable(&video->queue, 1)) < 0)
+        if ((ret = uvcg_queue_enable(&video->queue, 1)) < 0)
                 return ret;
 
         if ((ret = uvc_video_alloc_requests(video)) < 0)
@@ -372,14 +371,13 @@ uvc_video_enable(struct uvc_video *video, int enable)
         } else
                 video->encode = uvc_video_encode_isoc;
 
-        return uvc_video_pump(video);
+        return uvcg_video_pump(video);
 }
 
 /*
  * Initialize the UVC video stream.
  */
-static int
-uvc_video_init(struct uvc_video *video)
+int uvcg_video_init(struct uvc_video *video)
 {
         INIT_LIST_HEAD(&video->req_free);
         spin_lock_init(&video->req_lock);
@@ -391,7 +389,7 @@ uvc_video_init(struct uvc_video *video)
         video->imagesize = 320 * 240 * 2;
 
         /* Initialize the video buffers queue. */
-        uvc_queue_init(&video->queue, V4L2_BUF_TYPE_VIDEO_OUTPUT);
+        uvcg_queue_init(&video->queue, V4L2_BUF_TYPE_VIDEO_OUTPUT);
         return 0;
 }
 
diff --git a/drivers/usb/gadget/function/uvc_video.h b/drivers/usb/gadget/function/uvc_video.h
new file mode 100644
index 000000000000..ef00f06fa00b
--- /dev/null
+++ b/drivers/usb/gadget/function/uvc_video.h
@@ -0,0 +1,24 @@
+/*
+ *      uvc_video.h  --  USB Video Class Gadget driver
+ *
+ * Copyright (C) 2009-2010
+ *              Laurent Pinchart (laurent.pinchart@ideasonboard.com)
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *              Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __UVC_VIDEO_H__
+#define __UVC_VIDEO_H__
+
+int uvcg_video_pump(struct uvc_video *video);
+
+int uvcg_video_enable(struct uvc_video *video, int enable);
+
+int uvcg_video_init(struct uvc_video *video);
+
+#endif /* __UVC_VIDEO_H__ */
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index aa376f006333..24392d269709 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -54,6 +54,8 @@ config USB_AUDIO
         depends on SND
         select USB_LIBCOMPOSITE
         select SND_PCM
+        select USB_F_UAC1 if GADGET_UAC1
+        select USB_F_UAC2 if !GADGET_UAC1
         help
           This Gadget Audio driver is compatible with USB Audio Class
           specification 2.0. It implements 1 AudioControl interface,
@@ -466,6 +468,7 @@ config USB_G_WEBCAM
         depends on VIDEO_DEV
         select USB_LIBCOMPOSITE
         select VIDEOBUF2_VMALLOC
+        select USB_F_UVC
         help
           The Webcam Gadget acts as a composite USB Audio and Video Class
           device. It provides a userspace API to process UVC control requests
diff --git a/drivers/usb/gadget/legacy/Makefile b/drivers/usb/gadget/legacy/Makefile
index edba2d1ee0f3..7f485f25705e 100644
--- a/drivers/usb/gadget/legacy/Makefile
+++ b/drivers/usb/gadget/legacy/Makefile
@@ -2,9 +2,9 @@
 # USB gadget drivers
 #
 
-ccflags-y                       := -Idrivers/usb/gadget/
-ccflags-y                       += -Idrivers/usb/gadget/udc/
-ccflags-y                       += -Idrivers/usb/gadget/function/
+ccflags-y                       := -I$(srctree)/drivers/usb/gadget/
+ccflags-y                       += -I$(srctree)/drivers/usb/gadget/udc/
+ccflags-y                       += -I$(srctree)/drivers/usb/gadget/function/
 
 g_zero-y                        := zero.o
 g_audio-y                       := audio.o
diff --git a/drivers/usb/gadget/legacy/audio.c b/drivers/usb/gadget/legacy/audio.c
index 6eb695e5e43a..f46a3956e43d 100644
--- a/drivers/usb/gadget/legacy/audio.c
+++ b/drivers/usb/gadget/legacy/audio.c
@@ -21,6 +21,66 @@
 
 USB_GADGET_COMPOSITE_OPTIONS();
 
+#ifndef CONFIG_GADGET_UAC1
+#include "u_uac2.h"
+
+/* Playback(USB-IN) Default Stereo - Fl/Fr */
+static int p_chmask = UAC2_DEF_PCHMASK;
+module_param(p_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(p_chmask, "Playback Channel Mask");
+
+/* Playback Default 48 KHz */
+static int p_srate = UAC2_DEF_PSRATE;
+module_param(p_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(p_srate, "Playback Sampling Rate");
+
+/* Playback Default 16bits/sample */
+static int p_ssize = UAC2_DEF_PSSIZE;
+module_param(p_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(p_ssize, "Playback Sample Size(bytes)");
+
+/* Capture(USB-OUT) Default Stereo - Fl/Fr */
+static int c_chmask = UAC2_DEF_CCHMASK;
+module_param(c_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(c_chmask, "Capture Channel Mask");
+
+/* Capture Default 64 KHz */
+static int c_srate = UAC2_DEF_CSRATE;
+module_param(c_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(c_srate, "Capture Sampling Rate");
+
+/* Capture Default 16bits/sample */
+static int c_ssize = UAC2_DEF_CSSIZE;
+module_param(c_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
+#else
+#include "u_uac1.h"
+
+static char *fn_play = FILE_PCM_PLAYBACK;
+module_param(fn_play, charp, S_IRUGO);
+MODULE_PARM_DESC(fn_play, "Playback PCM device file name");
+
+static char *fn_cap = FILE_PCM_CAPTURE;
+module_param(fn_cap, charp, S_IRUGO);
+MODULE_PARM_DESC(fn_cap, "Capture PCM device file name");
+
+static char *fn_cntl = FILE_CONTROL;
+module_param(fn_cntl, charp, S_IRUGO);
+MODULE_PARM_DESC(fn_cntl, "Control device file name");
+
+static int req_buf_size = UAC1_OUT_EP_MAX_PACKET_SIZE;
+module_param(req_buf_size, int, S_IRUGO);
+MODULE_PARM_DESC(req_buf_size, "ISO OUT endpoint request buffer size");
+
+static int req_count = UAC1_REQ_COUNT;
+module_param(req_count, int, S_IRUGO);
+MODULE_PARM_DESC(req_count, "ISO OUT endpoint request count");
+
+static int audio_buf_size = UAC1_AUDIO_BUF_SIZE;
+module_param(audio_buf_size, int, S_IRUGO);
+MODULE_PARM_DESC(audio_buf_size, "Audio buffer size");
+#endif
+
 /* string IDs are assigned dynamically */
 
 static struct usb_string strings_dev[] = {
@@ -40,12 +100,12 @@ static struct usb_gadget_strings *audio_strings[] = {
         NULL,
 };
 
-#ifdef CONFIG_GADGET_UAC1
-#include "u_uac1.h"
-#include "u_uac1.c"
-#include "f_uac1.c"
+#ifndef CONFIG_GADGET_UAC1
+static struct usb_function_instance *fi_uac2;
+static struct usb_function *f_uac2;
 #else
-#include "f_uac2.c"
+static struct usb_function_instance *fi_uac1;
+static struct usb_function *f_uac1;
 #endif
 
 /*-------------------------------------------------------------------------*/
@@ -109,6 +169,8 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 static int __init audio_do_config(struct usb_configuration *c)
 {
+        int status;
+
         /* FIXME alloc iConfiguration string, set it in c->strings */
 
         if (gadget_is_otg(c->cdev->gadget)) {
@@ -116,7 +178,31 @@ static int __init audio_do_config(struct usb_configuration *c)
                 c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
         }
 
-        audio_bind_config(c);
+#ifdef CONFIG_GADGET_UAC1
+        f_uac1 = usb_get_function(fi_uac1);
+        if (IS_ERR(f_uac1)) {
+                status = PTR_ERR(f_uac1);
+                return status;
+        }
+
+        status = usb_add_function(c, f_uac1);
+        if (status < 0) {
+                usb_put_function(f_uac1);
+                return status;
+        }
+#else
+        f_uac2 = usb_get_function(fi_uac2);
+        if (IS_ERR(f_uac2)) {
+                status = PTR_ERR(f_uac2);
+                return status;
+        }
+
+        status = usb_add_function(c, f_uac2);
+        if (status < 0) {
+                usb_put_function(f_uac2);
+                return status;
+        }
+#endif
 
         return 0;
 }
@@ -126,17 +212,47 @@ static struct usb_configuration audio_config_driver = {
         .bConfigurationValue    = 1,
         /* .iConfiguration = DYNAMIC */
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
-#ifndef CONFIG_GADGET_UAC1
-        .unbind                 = uac2_unbind_config,
-#endif
 };
 
 /*-------------------------------------------------------------------------*/
 
 static int __init audio_bind(struct usb_composite_dev *cdev)
 {
+#ifndef CONFIG_GADGET_UAC1
+        struct f_uac2_opts      *uac2_opts;
+#else
+        struct f_uac1_opts      *uac1_opts;
+#endif
         int                     status;
 
+#ifndef CONFIG_GADGET_UAC1
+        fi_uac2 = usb_get_function_instance("uac2");
+        if (IS_ERR(fi_uac2))
+                return PTR_ERR(fi_uac2);
+#else
+        fi_uac1 = usb_get_function_instance("uac1");
+        if (IS_ERR(fi_uac1))
+                return PTR_ERR(fi_uac1);
+#endif
+
+#ifndef CONFIG_GADGET_UAC1
+        uac2_opts = container_of(fi_uac2, struct f_uac2_opts, func_inst);
+        uac2_opts->p_chmask = p_chmask;
+        uac2_opts->p_srate = p_srate;
+        uac2_opts->p_ssize = p_ssize;
+        uac2_opts->c_chmask = c_chmask;
+        uac2_opts->c_srate = c_srate;
+        uac2_opts->c_ssize = c_ssize;
+#else
+        uac1_opts = container_of(fi_uac1, struct f_uac1_opts, func_inst);
+        uac1_opts->fn_play = fn_play;
+        uac1_opts->fn_cap = fn_cap;
+        uac1_opts->fn_cntl = fn_cntl;
+        uac1_opts->req_buf_size = req_buf_size;
+        uac1_opts->req_count = req_count;
+        uac1_opts->audio_buf_size = audio_buf_size;
+#endif
+
         status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail;
@@ -152,13 +268,26 @@ static int __init audio_bind(struct usb_composite_dev *cdev)
         return 0;
 
 fail:
+#ifndef CONFIG_GADGET_UAC1
+        usb_put_function_instance(fi_uac2);
+#else
+        usb_put_function_instance(fi_uac1);
+#endif
         return status;
 }
 
 static int __exit audio_unbind(struct usb_composite_dev *cdev)
 {
 #ifdef CONFIG_GADGET_UAC1
-        gaudio_cleanup();
+        if (!IS_ERR_OR_NULL(f_uac1))
+                usb_put_function(f_uac1);
+        if (!IS_ERR_OR_NULL(fi_uac1))
+                usb_put_function_instance(fi_uac1);
+#else
+        if (!IS_ERR_OR_NULL(f_uac2))
+                usb_put_function(f_uac2);
+        if (!IS_ERR_OR_NULL(fi_uac2))
+                usb_put_function_instance(fi_uac2);
 #endif
         return 0;
 }
diff --git a/drivers/usb/gadget/legacy/dbgp.c b/drivers/usb/gadget/legacy/dbgp.c
index 225e385a6160..1b075132f8f1 100644
--- a/drivers/usb/gadget/legacy/dbgp.c
+++ b/drivers/usb/gadget/legacy/dbgp.c
@@ -410,6 +410,7 @@ static __refdata struct usb_gadget_driver dbgp_driver = {
         .bind = dbgp_bind,
         .unbind = dbgp_unbind,
         .setup = dbgp_setup,
+        .reset = dbgp_disconnect,
         .disconnect = dbgp_disconnect,
         .driver = {
                 .owner = THIS_MODULE,
diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c
index e96077b8bf79..edefec2cc584 100644
--- a/drivers/usb/gadget/legacy/inode.c
+++ b/drivers/usb/gadget/legacy/inode.c
@@ -1775,6 +1775,7 @@ static struct usb_gadget_driver gadgetfs_driver = {
         .bind           = gadgetfs_bind,
         .unbind         = gadgetfs_unbind,
         .setup          = gadgetfs_setup,
+        .reset          = gadgetfs_disconnect,
         .disconnect     = gadgetfs_disconnect,
         .suspend        = gadgetfs_suspend,
 
diff --git a/drivers/usb/gadget/legacy/webcam.c b/drivers/usb/gadget/legacy/webcam.c
index a11d8e420bfe..04a3da20f742 100644
--- a/drivers/usb/gadget/legacy/webcam.c
+++ b/drivers/usb/gadget/legacy/webcam.c
@@ -12,23 +12,31 @@
 
 #include <linux/kernel.h>
 #include <linux/device.h>
+#include <linux/module.h>
 #include <linux/usb/video.h>
 
-#include "f_uvc.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 "uvc_queue.c"
-#include "uvc_video.c"
-#include "uvc_v4l2.c"
-#include "f_uvc.c"
+#include "u_uvc.h"
 
 USB_GADGET_COMPOSITE_OPTIONS();
+
+/*-------------------------------------------------------------------------*/
+
+/* module parameters specific to the Video streaming endpoint */
+static unsigned int streaming_interval = 1;
+module_param(streaming_interval, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(streaming_interval, "1 - 16");
+
+static unsigned int streaming_maxpacket = 1024;
+module_param(streaming_maxpacket, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(streaming_maxpacket, "1 - 1023 (FS), 1 - 3072 (hs/ss)");
+
+static unsigned int streaming_maxburst;
+module_param(streaming_maxburst, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(streaming_maxburst, "0 - 15 (ss only)");
+
+static unsigned int trace;
+module_param(trace, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(trace, "Trace level bitmask");
 /* --------------------------------------------------------------------------
  * Device descriptor
  */
@@ -63,6 +71,9 @@ static struct usb_gadget_strings *webcam_device_strings[] = {
         NULL,
 };
 
+static struct usb_function_instance *fi_uvc;
+static struct usb_function *f_uvc;
+
 static struct usb_device_descriptor webcam_device_descriptor = {
         .bLength                = USB_DT_DEVICE_SIZE,
         .bDescriptorType        = USB_DT_DEVICE,
@@ -326,9 +337,17 @@ static const struct uvc_descriptor_header * const uvc_ss_streaming_cls[] = {
 static int __init
 webcam_config_bind(struct usb_configuration *c)
 {
-        return uvc_bind_config(c, uvc_fs_control_cls, uvc_ss_control_cls,
-                uvc_fs_streaming_cls, uvc_hs_streaming_cls,
-                uvc_ss_streaming_cls);
+        int status = 0;
+
+        f_uvc = usb_get_function(fi_uvc);
+        if (IS_ERR(f_uvc))
+                return PTR_ERR(f_uvc);
+
+        status = usb_add_function(c, f_uvc);
+        if (status < 0)
+                usb_put_function(f_uvc);
+
+        return status;
 }
 
 static struct usb_configuration webcam_config_driver = {
@@ -342,14 +361,36 @@ static struct usb_configuration webcam_config_driver = {
 static int /* __init_or_exit */
 webcam_unbind(struct usb_composite_dev *cdev)
 {
+        if (!IS_ERR_OR_NULL(f_uvc))
+                usb_put_function(f_uvc);
+        if (!IS_ERR_OR_NULL(fi_uvc))
+                usb_put_function_instance(fi_uvc);
         return 0;
 }
 
 static int __init
 webcam_bind(struct usb_composite_dev *cdev)
 {
+        struct f_uvc_opts *uvc_opts;
         int ret;
 
+        fi_uvc = usb_get_function_instance("uvc");
+        if (IS_ERR(fi_uvc))
+                return PTR_ERR(fi_uvc);
+
+        uvc_opts = container_of(fi_uvc, struct f_uvc_opts, func_inst);
+
+        uvc_opts->streaming_interval = streaming_interval;
+        uvc_opts->streaming_maxpacket = streaming_maxpacket;
+        uvc_opts->streaming_maxburst = streaming_maxburst;
+        uvc_set_trace_param(trace);
+
+        uvc_opts->fs_control = uvc_fs_control_cls;
+        uvc_opts->ss_control = uvc_ss_control_cls;
+        uvc_opts->fs_streaming = uvc_fs_streaming_cls;
+        uvc_opts->hs_streaming = uvc_hs_streaming_cls;
+        uvc_opts->ss_streaming = uvc_ss_streaming_cls;
+
         /* Allocate string descriptor numbers ... note that string contents
          * can be overridden by the composite_dev glue.
          */
@@ -373,7 +414,7 @@ webcam_bind(struct usb_composite_dev *cdev)
         return 0;
 
 error:
-        webcam_unbind(cdev);
+        usb_put_function_instance(fi_uvc);
         return ret;
 }
 
diff --git a/drivers/usb/gadget/legacy/zero.c b/drivers/usb/gadget/legacy/zero.c
index c3d496828b74..ebf09f439f3a 100644
--- a/drivers/usb/gadget/legacy/zero.c
+++ b/drivers/usb/gadget/legacy/zero.c
@@ -68,6 +68,8 @@ static struct usb_zero_options gzero_options = {
         .isoc_maxpacket = GZERO_ISOC_MAXPACKET,
         .bulk_buflen = GZERO_BULK_BUFLEN,
         .qlen = GZERO_QLEN,
+        .int_interval = GZERO_INT_INTERVAL,
+        .int_maxpacket = GZERO_INT_MAXPACKET,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -266,6 +268,21 @@ module_param_named(isoc_maxburst, gzero_options.isoc_maxburst, uint,
                 S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(isoc_maxburst, "0 - 15 (ss only)");
 
+module_param_named(int_interval, gzero_options.int_interval, uint,
+                S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(int_interval, "1 - 16");
+
+module_param_named(int_maxpacket, gzero_options.int_maxpacket, uint,
+                S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(int_maxpacket, "0 - 1023 (fs), 0 - 1024 (hs/ss)");
+
+module_param_named(int_mult, gzero_options.int_mult, uint, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(int_mult, "0 - 2 (hs/ss only)");
+
+module_param_named(int_maxburst, gzero_options.int_maxburst, uint,
+                S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(int_maxburst, "0 - 15 (ss only)");
+
 static struct usb_function *func_lb;
 static struct usb_function_instance *func_inst_lb;
 
@@ -301,6 +318,10 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
         ss_opts->isoc_maxpacket = gzero_options.isoc_maxpacket;
         ss_opts->isoc_mult = gzero_options.isoc_mult;
         ss_opts->isoc_maxburst = gzero_options.isoc_maxburst;
+        ss_opts->int_interval = gzero_options.int_interval;
+        ss_opts->int_maxpacket = gzero_options.int_maxpacket;
+        ss_opts->int_mult = gzero_options.int_mult;
+        ss_opts->int_maxburst = gzero_options.int_maxburst;
         ss_opts->bulk_buflen = gzero_options.bulk_buflen;
 
         func_ss = usb_get_function(func_inst_ss);
diff --git a/drivers/usb/gadget/udc/Kconfig b/drivers/usb/gadget/udc/Kconfig
index 34ebaa68504c..3ea287b0e448 100644
--- a/drivers/usb/gadget/udc/Kconfig
+++ b/drivers/usb/gadget/udc/Kconfig
@@ -163,7 +163,7 @@ config USB_R8A66597
 
 config USB_RENESAS_USBHS_UDC
         tristate 'Renesas USBHS controller'
-        depends on USB_RENESAS_USBHS
+        depends on USB_RENESAS_USBHS && HAS_DMA
         help
            Renesas USBHS is a discrete USB host and peripheral controller chip
            that supports both full and high speed USB 2.0 data transfers.
@@ -354,6 +354,21 @@ config USB_EG20T
           ML7213/ML7831 is completely compatible for Intel EG20T PCH.
 
           This driver can be used with Intel's Quark X1000 SOC platform
+
+config USB_GADGET_XILINX
+        tristate "Xilinx USB Driver"
+        depends on OF || COMPILE_TEST
+        help
+          USB peripheral controller driver for Xilinx USB2 device.
+          Xilinx USB2 device is a soft IP which supports both full
+          and high speed USB 2.0 data transfers. It has seven configurable
+          endpoints(bulk or interrupt or isochronous), as well as
+          endpoint zero(for control transfers).
+
+          Say "y" to link the driver statically, or "m" to build a
+          dynamically linked module called "udc-xilinx" and force all
+          gadget drivers to also be dynamically linked.
+
 #
 # LAST -- dummy/emulated controller
 #
diff --git a/drivers/usb/gadget/udc/Makefile b/drivers/usb/gadget/udc/Makefile
index 4096122bb283..a7f4491593f1 100644
--- a/drivers/usb/gadget/udc/Makefile
+++ b/drivers/usb/gadget/udc/Makefile
@@ -29,3 +29,4 @@ obj-$(CONFIG_USB_FUSB300)	+= fusb300_udc.o
 obj-$(CONFIG_USB_FOTG210_UDC)   += fotg210-udc.o
 obj-$(CONFIG_USB_MV_U3D)        += mv_u3d_core.o
 obj-$(CONFIG_USB_GR_UDC)        += gr_udc.o
+obj-$(CONFIG_USB_GADGET_XILINX) += udc-xilinx.o
diff --git a/drivers/usb/gadget/udc/amd5536udc.c b/drivers/usb/gadget/udc/amd5536udc.c
index 41b062eb4de0..3b9d13848a4f 100644
--- a/drivers/usb/gadget/udc/amd5536udc.c
+++ b/drivers/usb/gadget/udc/amd5536udc.c
@@ -841,7 +841,7 @@ __acquires(ep->dev->lock)
                 &req->req, req->req.length, ep->ep.name, sts);
 
         spin_unlock(&dev->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&dev->lock);
         ep->halted = halted;
 }
diff --git a/drivers/usb/gadget/udc/at91_udc.c b/drivers/usb/gadget/udc/at91_udc.c
index cfd18bcca723..9968f5331fe4 100644
--- a/drivers/usb/gadget/udc/at91_udc.c
+++ b/drivers/usb/gadget/udc/at91_udc.c
@@ -267,7 +267,7 @@ static void done(struct at91_ep *ep, struct at91_request *req, int status)
 
         ep->stopped = 1;
         spin_unlock(&udc->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&udc->lock);
         ep->stopped = stopped;
 
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index c9fe67e29d35..1529926e20a0 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -463,7 +463,7 @@ static void receive_data(struct usba_ep *ep)
                         list_del_init(&req->queue);
                         usba_ep_writel(ep, CTL_DIS, USBA_RX_BK_RDY);
                         spin_unlock(&udc->lock);
-                        req->req.complete(&ep->ep, &req->req);
+                        usb_gadget_giveback_request(&ep->ep, &req->req);
                         spin_lock(&udc->lock);
                 }
 
@@ -495,7 +495,7 @@ request_complete(struct usba_ep *ep, struct usba_request *req, int status)
                 ep->ep.name, req, req->req.status, req->req.actual);
 
         spin_unlock(&udc->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&udc->lock);
 }
 
diff --git a/drivers/usb/gadget/udc/bcm63xx_udc.c b/drivers/usb/gadget/udc/bcm63xx_udc.c
index e969eb809a85..2235b8808700 100644
--- a/drivers/usb/gadget/udc/bcm63xx_udc.c
+++ b/drivers/usb/gadget/udc/bcm63xx_udc.c
@@ -1088,7 +1088,7 @@ static int bcm63xx_ep_disable(struct usb_ep *ep)
                         breq->req.status = -ESHUTDOWN;
 
                         spin_unlock_irqrestore(&udc->lock, flags);
-                        breq->req.complete(&iudma->bep->ep, &breq->req);
+                        usb_gadget_giveback_request(&iudma->bep->ep, &breq->req);
                         spin_lock_irqsave(&udc->lock, flags);
                 }
         }
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c
index 2b54955d3166..81dc5959e36b 100644
--- a/drivers/usb/gadget/udc/dummy_hcd.c
+++ b/drivers/usb/gadget/udc/dummy_hcd.c
@@ -258,7 +258,7 @@ static void nuke(struct dummy *dum, struct dummy_ep *ep)
                 req->req.status = -ESHUTDOWN;
 
                 spin_unlock(&dum->lock);
-                req->req.complete(&ep->ep, &req->req);
+                usb_gadget_giveback_request(&ep->ep, &req->req);
                 spin_lock(&dum->lock);
         }
 }
@@ -658,7 +658,7 @@ static int dummy_queue(struct usb_ep *_ep, struct usb_request *_req,
                 spin_unlock(&dum->lock);
                 _req->actual = _req->length;
                 _req->status = 0;
-                _req->complete(_ep, _req);
+                usb_gadget_giveback_request(_ep, _req);
                 spin_lock(&dum->lock);
         }  else
                 list_add_tail(&req->queue, &ep->queue);
@@ -702,7 +702,7 @@ static int dummy_dequeue(struct usb_ep *_ep, struct usb_request *_req)
                 dev_dbg(udc_dev(dum),
                                 "dequeued req %p from %s, len %d buf %p\n",
                                 req, _ep->name, _req->length, _req->buf);
-                _req->complete(_ep, _req);
+                usb_gadget_giveback_request(_ep, _req);
         }
         local_irq_restore(flags);
         return retval;
@@ -1385,7 +1385,7 @@ top:
                         list_del_init(&req->queue);
 
                         spin_unlock(&dum->lock);
-                        req->req.complete(&ep->ep, &req->req);
+                        usb_gadget_giveback_request(&ep->ep, &req->req);
                         spin_lock(&dum->lock);
 
                         /* requests might have been unlinked... */
@@ -1761,7 +1761,7 @@ restart:
                                                 req);
 
                                 spin_unlock(&dum->lock);
-                                req->req.complete(&ep->ep, &req->req);
+                                usb_gadget_giveback_request(&ep->ep, &req->req);
                                 spin_lock(&dum->lock);
                                 ep->already_seen = 0;
                                 goto restart;
diff --git a/drivers/usb/gadget/udc/fotg210-udc.c b/drivers/usb/gadget/udc/fotg210-udc.c
index e143d69f6017..1d315921bf34 100644
--- a/drivers/usb/gadget/udc/fotg210-udc.c
+++ b/drivers/usb/gadget/udc/fotg210-udc.c
@@ -70,7 +70,7 @@ static void fotg210_done(struct fotg210_ep *ep, struct fotg210_request *req,
                 req->req.status = status;
 
         spin_unlock(&ep->fotg210->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&ep->fotg210->lock);
 
         if (ep->epnum) {
diff --git a/drivers/usb/gadget/udc/fsl_qe_udc.c b/drivers/usb/gadget/udc/fsl_qe_udc.c
index 732430804841..dd18ea38e391 100644
--- a/drivers/usb/gadget/udc/fsl_qe_udc.c
+++ b/drivers/usb/gadget/udc/fsl_qe_udc.c
@@ -118,10 +118,7 @@ static void done(struct qe_ep *ep, struct qe_req *req, int status)
         ep->stopped = 1;
         spin_unlock(&udc->lock);
 
-        /* this complete() should a func implemented by gadget layer,
-         * eg fsg->bulk_in_complete() */
-        if (req->req.complete)
-                req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
 
         spin_lock(&udc->lock);
 
@@ -2728,4 +2725,3 @@ module_platform_driver(udc_driver);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_LICENSE("GPL");
-
diff --git a/drivers/usb/gadget/udc/fsl_udc_core.c b/drivers/usb/gadget/udc/fsl_udc_core.c
index 75b23ea077a7..c3620791a315 100644
--- a/drivers/usb/gadget/udc/fsl_udc_core.c
+++ b/drivers/usb/gadget/udc/fsl_udc_core.c
@@ -197,10 +197,8 @@ __acquires(ep->udc->lock)
         ep->stopped = 1;
 
         spin_unlock(&ep->udc->lock);
-        /* complete() is from gadget layer,
-         * eg fsg->bulk_in_complete() */
-        if (req->req.complete)
-                req->req.complete(&ep->ep, &req->req);
+
+        usb_gadget_giveback_request(&ep->ep, &req->req);
 
         spin_lock(&ep->udc->lock);
         ep->stopped = stopped;
diff --git a/drivers/usb/gadget/udc/fusb300_udc.c b/drivers/usb/gadget/udc/fusb300_udc.c
index 5c5d1adda7eb..8286df72add4 100644
--- a/drivers/usb/gadget/udc/fusb300_udc.c
+++ b/drivers/usb/gadget/udc/fusb300_udc.c
@@ -876,7 +876,7 @@ static void done(struct fusb300_ep *ep, struct fusb300_request *req,
                 req->req.status = status;
 
         spin_unlock(&ep->fusb300->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&ep->fusb300->lock);
 
         if (ep->epnum) {
diff --git a/drivers/usb/gadget/udc/goku_udc.c b/drivers/usb/gadget/udc/goku_udc.c
index 6c85839e15ad..bf9c5ef8b56b 100644
--- a/drivers/usb/gadget/udc/goku_udc.c
+++ b/drivers/usb/gadget/udc/goku_udc.c
@@ -320,7 +320,7 @@ done(struct goku_ep *ep, struct goku_request *req, int status)
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
         spin_unlock(&dev->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&dev->lock);
         ep->stopped = stopped;
 }
diff --git a/drivers/usb/gadget/udc/gr_udc.c b/drivers/usb/gadget/udc/gr_udc.c
index 08df5c4f46ce..1b3048a6a2a3 100644
--- a/drivers/usb/gadget/udc/gr_udc.c
+++ b/drivers/usb/gadget/udc/gr_udc.c
@@ -318,8 +318,26 @@ static void gr_finish_request(struct gr_ep *ep, struct gr_request *req,
         usb_gadget_unmap_request(&dev->gadget, &req->req, ep->is_in);
         gr_free_dma_desc_chain(dev, req);
 
-        if (ep->is_in) /* For OUT, actual gets updated bit by bit */
+        if (ep->is_in) { /* For OUT, req->req.actual gets updated bit by bit */
                 req->req.actual = req->req.length;
+        } else if (req->oddlen && req->req.actual > req->evenlen) {
+                /*
+                 * Copy to user buffer in this case where length was not evenly
+                 * divisible by ep->ep.maxpacket and the last descriptor was
+                 * actually used.
+                 */
+                char *buftail = ((char *)req->req.buf + req->evenlen);
+
+                memcpy(buftail, ep->tailbuf, req->oddlen);
+
+                if (req->req.actual > req->req.length) {
+                        /* We got more data than was requested */
+                        dev_dbg(ep->dev->dev, "Overflow for ep %s\n",
+                                ep->ep.name);
+                        gr_dbgprint_request("OVFL", ep, req);
+                        req->req.status = -EOVERFLOW;
+                }
+        }
 
         if (!status) {
                 if (ep->is_in)
@@ -339,7 +357,7 @@ static void gr_finish_request(struct gr_ep *ep, struct gr_request *req,
         } else if (req->req.complete) {
                 spin_unlock(&dev->lock);
 
-                req->req.complete(&ep->ep, &req->req);
+                usb_gadget_giveback_request(&ep->ep, &req->req);
 
                 spin_lock(&dev->lock);
         }
@@ -379,6 +397,15 @@ static void gr_start_dma(struct gr_ep *ep)
         /* A descriptor should already have been allocated */
         BUG_ON(!req->curr_desc);
 
+        /*
+         * The DMA controller can not handle smaller OUT buffers than
+         * ep->ep.maxpacket. It could lead to buffer overruns if an unexpectedly
+         * long packet are received. Therefore an internal bounce buffer gets
+         * used when such a request gets enabled.
+         */
+        if (!ep->is_in && req->oddlen)
+                req->last_desc->data = ep->tailbuf_paddr;
+
         wmb(); /* Make sure all is settled before handing it over to DMA */
 
         /* Set the descriptor pointer in the hardware */
@@ -480,11 +507,11 @@ static int gr_setup_out_desc_list(struct gr_ep *ep, struct gr_request *req,
                 dma_addr_t start = req->req.dma + bytes_used;
                 u16 size = min(bytes_left, ep->bytes_per_buffer);
 
-                /* Should not happen however - gr_queue stops such lengths */
-                if (size < ep->bytes_per_buffer)
-                        dev_warn(ep->dev->dev,
-                                 "Buffer overrun risk: %u < %u bytes/buffer\n",
-                                 size, ep->bytes_per_buffer);
+                if (size < ep->bytes_per_buffer) {
+                        /* Prepare using bounce buffer */
+                        req->evenlen = req->req.length - bytes_left;
+                        req->oddlen = size;
+                }
 
                 ret = gr_add_dma_desc(ep, req, start, size, gfp_flags);
                 if (ret)
@@ -584,18 +611,6 @@ static int gr_queue(struct gr_ep *ep, struct gr_request *req, gfp_t gfp_flags)
                 return -EINVAL;
         }
 
-        /*
-         * The DMA controller can not handle smaller OUT buffers than
-         * maxpacket. It could lead to buffer overruns if unexpectedly long
-         * packet are received.
-         */
-        if (!ep->is_in && (req->req.length % ep->ep.maxpacket) != 0) {
-                dev_err(dev->dev,
-                        "OUT request length %d is not multiple of maxpacket\n",
-                        req->req.length);
-                return -EMSGSIZE;
-        }
-
         if (unlikely(!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
                 dev_err(dev->dev, "-ESHUTDOWN");
                 return -ESHUTDOWN;
@@ -1286,8 +1301,8 @@ static int gr_handle_out_ep(struct gr_ep *ep)
         if (ctrl & GR_DESC_OUT_CTRL_SE)
                 req->setup = 1;
 
-        if (len < ep->ep.maxpacket || req->req.actual == req->req.length) {
-                /* Short packet or the expected size - we are done */
+        if (len < ep->ep.maxpacket || req->req.actual >= req->req.length) {
+                /* Short packet or >= expected size - we are done */
 
                 if ((ep == &dev->epo[0]) && (dev->ep0state == GR_EP0_OSTATUS)) {
                         /*
@@ -2015,6 +2030,11 @@ static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit)
         }
         list_add_tail(&ep->ep_list, &dev->ep_list);
 
+        ep->tailbuf = dma_alloc_coherent(dev->dev, ep->ep.maxpacket_limit,
+                                         &ep->tailbuf_paddr, GFP_ATOMIC);
+        if (!ep->tailbuf)
+                return -ENOMEM;
+
         return 0;
 }
 
@@ -2067,9 +2087,24 @@ static int gr_udc_init(struct gr_udc *dev)
         return 0;
 }
 
+static void gr_ep_remove(struct gr_udc *dev, int num, int is_in)
+{
+        struct gr_ep *ep;
+
+        if (is_in)
+                ep = &dev->epi[num];
+        else
+                ep = &dev->epo[num];
+
+        if (ep->tailbuf)
+                dma_free_coherent(dev->dev, ep->ep.maxpacket_limit,
+                                  ep->tailbuf, ep->tailbuf_paddr);
+}
+
 static int gr_remove(struct platform_device *pdev)
 {
         struct gr_udc *dev = platform_get_drvdata(pdev);
+        int i;
 
         if (dev->added)
                 usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
@@ -2084,6 +2119,11 @@ static int gr_remove(struct platform_device *pdev)
         gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
         gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
 
+        for (i = 0; i < dev->nepo; i++)
+                gr_ep_remove(dev, i, 0);
+        for (i = 0; i < dev->nepi; i++)
+                gr_ep_remove(dev, i, 1);
+
         return 0;
 }
 static int gr_request_irq(struct gr_udc *dev, int irq)
@@ -2131,7 +2171,6 @@ static int gr_probe(struct platform_device *pdev)
         dev->gadget.name = driver_name;
         dev->gadget.max_speed = USB_SPEED_HIGH;
         dev->gadget.ops = &gr_ops;
-        dev->gadget.quirk_ep_out_aligned_size = true;
 
         spin_lock_init(&dev->lock);
         dev->regs = regs;
diff --git a/drivers/usb/gadget/udc/gr_udc.h b/drivers/usb/gadget/udc/gr_udc.h
index 8388897d9ec3..4297c4e8021f 100644
--- a/drivers/usb/gadget/udc/gr_udc.h
+++ b/drivers/usb/gadget/udc/gr_udc.h
@@ -156,6 +156,10 @@ struct gr_ep {
         struct list_head queue;
 
         struct list_head ep_list;
+
+        /* Bounce buffer for end of "odd" sized OUT requests */
+        void *tailbuf;
+        dma_addr_t tailbuf_paddr;
 };
 
 struct gr_request {
@@ -167,6 +171,9 @@ struct gr_request {
         struct gr_dma_desc *curr_desc; /* Current descriptor */
         struct gr_dma_desc *last_desc; /* Last in the chain */
 
+        u16 evenlen; /* Size of even length head (if oddlen != 0) */
+        u16 oddlen; /* Size of odd length tail if buffer length is "odd" */
+
         u8 setup; /* Setup packet */
 };
 
diff --git a/drivers/usb/gadget/udc/lpc32xx_udc.c b/drivers/usb/gadget/udc/lpc32xx_udc.c
index 1629ad7dcb80..feab0bac8fdc 100644
--- a/drivers/usb/gadget/udc/lpc32xx_udc.c
+++ b/drivers/usb/gadget/udc/lpc32xx_udc.c
@@ -1479,7 +1479,7 @@ static void done(struct lpc32xx_ep *ep, struct lpc32xx_request *req, int status)
 
         ep->req_pending = 0;
         spin_unlock(&udc->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&udc->lock);
 }
 
diff --git a/drivers/usb/gadget/udc/m66592-udc.c b/drivers/usb/gadget/udc/m66592-udc.c
index de88d33b44b2..898565687a8c 100644
--- a/drivers/usb/gadget/udc/m66592-udc.c
+++ b/drivers/usb/gadget/udc/m66592-udc.c
@@ -729,7 +729,7 @@ __acquires(m66592->lock)
                 restart = 1;
 
         spin_unlock(&ep->m66592->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&ep->m66592->lock);
 
         if (restart) {
diff --git a/drivers/usb/gadget/udc/mv_u3d_core.c b/drivers/usb/gadget/udc/mv_u3d_core.c
index 16248711c152..046a1f808b0d 100644
--- a/drivers/usb/gadget/udc/mv_u3d_core.c
+++ b/drivers/usb/gadget/udc/mv_u3d_core.c
@@ -222,12 +222,8 @@ void mv_u3d_done(struct mv_u3d_ep *ep, struct mv_u3d_req *req, int status)
         }
 
         spin_unlock(&ep->u3d->lock);
-        /*
-         * complete() is from gadget layer,
-         * eg fsg->bulk_in_complete()
-         */
-        if (req->req.complete)
-                req->req.complete(&ep->ep, &req->req);
+
+        usb_gadget_giveback_request(&ep->ep, &req->req);
 
         spin_lock(&ep->u3d->lock);
 }
diff --git a/drivers/usb/gadget/udc/mv_udc_core.c b/drivers/usb/gadget/udc/mv_udc_core.c
index 040fb169b162..3c5db80ae325 100644
--- a/drivers/usb/gadget/udc/mv_udc_core.c
+++ b/drivers/usb/gadget/udc/mv_udc_core.c
@@ -248,12 +248,8 @@ static void done(struct mv_ep *ep, struct mv_req *req, int status)
         ep->stopped = 1;
 
         spin_unlock(&ep->udc->lock);
-        /*
-         * complete() is from gadget layer,
-         * eg fsg->bulk_in_complete()
-         */
-        if (req->req.complete)
-                req->req.complete(&ep->ep, &req->req);
+
+        usb_gadget_giveback_request(&ep->ep, &req->req);
 
         spin_lock(&ep->udc->lock);
         ep->stopped = stopped;
diff --git a/drivers/usb/gadget/udc/net2272.c b/drivers/usb/gadget/udc/net2272.c
index 059cfe527982..84d7162a8022 100644
--- a/drivers/usb/gadget/udc/net2272.c
+++ b/drivers/usb/gadget/udc/net2272.c
@@ -394,7 +394,7 @@ net2272_done(struct net2272_ep *ep, struct net2272_request *req, int status)
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
         spin_unlock(&dev->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&dev->lock);
         ep->stopped = stopped;
 }
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index 2e95715b50c0..8d13337e2dde 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -928,7 +928,7 @@ done(struct net2280_ep *ep, struct net2280_request *req, int status)
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
         spin_unlock(&dev->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&dev->lock);
         ep->stopped = stopped;
 }
diff --git a/drivers/usb/gadget/udc/omap_udc.c b/drivers/usb/gadget/udc/omap_udc.c
index e731373fd4d7..dcdfea46003b 100644
--- a/drivers/usb/gadget/udc/omap_udc.c
+++ b/drivers/usb/gadget/udc/omap_udc.c
@@ -315,7 +315,7 @@ done(struct omap_ep *ep, struct omap_req *req, int status)
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
         spin_unlock(&ep->udc->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&ep->udc->lock);
         ep->stopped = stopped;
 }
diff --git a/drivers/usb/gadget/udc/pch_udc.c b/drivers/usb/gadget/udc/pch_udc.c
index 460d953c91b6..ccbe3d4a2a50 100644
--- a/drivers/usb/gadget/udc/pch_udc.c
+++ b/drivers/usb/gadget/udc/pch_udc.c
@@ -1490,7 +1490,7 @@ static void complete_req(struct pch_udc_ep *ep, struct pch_udc_request *req,
         spin_unlock(&dev->lock);
         if (!ep->in)
                 pch_udc_ep_clear_rrdy(ep);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&dev->lock);
         ep->halted = halted;
 }
diff --git a/drivers/usb/gadget/udc/pxa25x_udc.c b/drivers/usb/gadget/udc/pxa25x_udc.c
index 251e4d5ee152..42f7eeb8ff6f 100644
--- a/drivers/usb/gadget/udc/pxa25x_udc.c
+++ b/drivers/usb/gadget/udc/pxa25x_udc.c
@@ -347,7 +347,7 @@ static void done(struct pxa25x_ep *ep, struct pxa25x_request *req, int status)
 
         /* don't modify queue heads during completion callback */
         ep->stopped = 1;
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         ep->stopped = stopped;
 }
 
diff --git a/drivers/usb/gadget/udc/pxa27x_udc.c b/drivers/usb/gadget/udc/pxa27x_udc.c
index 597d39f89420..4868369eeec6 100644
--- a/drivers/usb/gadget/udc/pxa27x_udc.c
+++ b/drivers/usb/gadget/udc/pxa27x_udc.c
@@ -758,7 +758,7 @@ static void req_done(struct pxa_ep *ep, struct pxa27x_request *req, int status,
         if (pflags)
                 spin_unlock_irqrestore(&ep->lock, *pflags);
         local_irq_save(flags);
-        req->req.complete(&req->udc_usb_ep->usb_ep, &req->req);
+        usb_gadget_giveback_request(&req->udc_usb_ep->usb_ep, &req->req);
         local_irq_restore(flags);
         if (pflags)
                 spin_lock_irqsave(&ep->lock, *pflags);
diff --git a/drivers/usb/gadget/udc/r8a66597-udc.c b/drivers/usb/gadget/udc/r8a66597-udc.c
index de2a8713b428..f8186613b53e 100644
--- a/drivers/usb/gadget/udc/r8a66597-udc.c
+++ b/drivers/usb/gadget/udc/r8a66597-udc.c
@@ -430,7 +430,7 @@ static void r8a66597_ep_setting(struct r8a66597 *r8a66597,
         ep->pipenum = pipenum;
         ep->ep.maxpacket = usb_endpoint_maxp(desc);
         r8a66597->pipenum2ep[pipenum] = ep;
-        r8a66597->epaddr2ep[desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK]
+        r8a66597->epaddr2ep[usb_endpoint_num(desc)]
                 = ep;
         INIT_LIST_HEAD(&ep->queue);
 }
@@ -464,7 +464,7 @@ static int alloc_pipe_config(struct r8a66597_ep *ep,
         if (ep->pipenum)        /* already allocated pipe  */
                 return 0;
 
-        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_BULK:
                 if (r8a66597->bulk >= R8A66597_MAX_NUM_BULK) {
                         if (r8a66597->isochronous >= R8A66597_MAX_NUM_ISOC) {
@@ -509,7 +509,7 @@ static int alloc_pipe_config(struct r8a66597_ep *ep,
         }
         ep->type = info.type;
 
-        info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        info.epnum = usb_endpoint_num(desc);
         info.maxpacket = usb_endpoint_maxp(desc);
         info.interval = desc->bInterval;
         if (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
@@ -925,7 +925,7 @@ __acquires(r8a66597->lock)
                 sudmac_free_channel(ep->r8a66597, ep, req);
 
         spin_unlock(&ep->r8a66597->lock);
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         spin_lock(&ep->r8a66597->lock);
 
         if (restart) {
@@ -1846,10 +1846,8 @@ static int r8a66597_sudmac_ioremap(struct r8a66597 *r8a66597,
 
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sudmac");
         r8a66597->sudmac_reg = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(r8a66597->sudmac_reg)) {
-                dev_err(&pdev->dev, "ioremap error(sudmac).\n");
+        if (IS_ERR(r8a66597->sudmac_reg))
                 return PTR_ERR(r8a66597->sudmac_reg);
-        }
 
         return 0;
 }
diff --git a/drivers/usb/gadget/udc/s3c-hsudc.c b/drivers/usb/gadget/udc/s3c-hsudc.c
index 10c6a128250c..dfbf55797360 100644
--- a/drivers/usb/gadget/udc/s3c-hsudc.c
+++ b/drivers/usb/gadget/udc/s3c-hsudc.c
@@ -258,8 +258,7 @@ static void s3c_hsudc_complete_request(struct s3c_hsudc_ep *hsep,
 
         hsep->stopped = 1;
         spin_unlock(&hsudc->lock);
-        if (hsreq->req.complete != NULL)
-                hsreq->req.complete(&hsep->ep, &hsreq->req);
+        usb_gadget_giveback_request(&hsep->ep, &hsreq->req);
         spin_lock(&hsudc->lock);
         hsep->stopped = stopped;
 }
diff --git a/drivers/usb/gadget/udc/s3c2410_udc.c b/drivers/usb/gadget/udc/s3c2410_udc.c
index 357b58e0087b..ff423d15beff 100644
--- a/drivers/usb/gadget/udc/s3c2410_udc.c
+++ b/drivers/usb/gadget/udc/s3c2410_udc.c
@@ -272,7 +272,7 @@ static void s3c2410_udc_done(struct s3c2410_ep *ep,
                 status = req->req.status;
 
         ep->halted = 1;
-        req->req.complete(&ep->ep, &req->req);
+        usb_gadget_giveback_request(&ep->ep, &req->req);
         ep->halted = halted;
 }
 
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c
index b0d98172bc07..f107bb60a5ab 100644
--- a/drivers/usb/gadget/udc/udc-core.c
+++ b/drivers/usb/gadget/udc/udc-core.c
@@ -27,6 +27,7 @@
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb.h>
 
 /**
  * struct usb_udc - describes one usb device controller
@@ -106,11 +107,42 @@ EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
 
 /* ------------------------------------------------------------------------- */
 
+/**
+ * usb_gadget_giveback_request - give the request back to the gadget layer
+ * Context: in_interrupt()
+ *
+ * This is called by device controller drivers in order to return the
+ * completed request back to the gadget layer.
+ */
+void usb_gadget_giveback_request(struct usb_ep *ep,
+                struct usb_request *req)
+{
+        if (likely(req->status == 0))
+                usb_led_activity(USB_LED_EVENT_GADGET);
+
+        req->complete(ep, req);
+}
+EXPORT_SYMBOL_GPL(usb_gadget_giveback_request);
+
+/* ------------------------------------------------------------------------- */
+
 static void usb_gadget_state_work(struct work_struct *work)
 {
         struct usb_gadget       *gadget = work_to_gadget(work);
+        struct usb_udc          *udc = NULL;
+
+        mutex_lock(&udc_lock);
+        list_for_each_entry(udc, &udc_list, list)
+                if (udc->gadget == gadget)
+                        goto found;
+        mutex_unlock(&udc_lock);
+
+        return;
+
+found:
+        mutex_unlock(&udc_lock);
 
-        sysfs_notify(&gadget->dev.kobj, NULL, "state");
+        sysfs_notify(&udc->dev.kobj, NULL, "state");
 }
 
 void usb_gadget_set_state(struct usb_gadget *gadget,
@@ -124,6 +156,23 @@ EXPORT_SYMBOL_GPL(usb_gadget_set_state);
 /* ------------------------------------------------------------------------- */
 
 /**
+ * usb_gadget_udc_reset - notifies the udc core that bus reset occurs
+ * @gadget: The gadget which bus reset occurs
+ * @driver: The gadget driver we want to notify
+ *
+ * If the udc driver has bus reset handler, it needs to call this when the bus
+ * reset occurs, it notifies the gadget driver that the bus reset occurs as
+ * well as updates gadget state.
+ */
+void usb_gadget_udc_reset(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
+{
+        driver->reset(gadget);
+        usb_gadget_set_state(gadget, USB_STATE_DEFAULT);
+}
+EXPORT_SYMBOL_GPL(usb_gadget_udc_reset);
+
+/**
  * usb_gadget_udc_start - tells usb device controller to start up
  * @gadget: The gadget we want to get started
  * @driver: The driver we want to bind to @gadget
diff --git a/drivers/usb/gadget/udc/udc-xilinx.c b/drivers/usb/gadget/udc/udc-xilinx.c
new file mode 100644
index 000000000000..ed27e1687a4e
--- /dev/null
+++ b/drivers/usb/gadget/udc/udc-xilinx.c
@@ -0,0 +1,2180 @@
+/*
+ * Xilinx USB peripheral controller driver
+ *
+ * Copyright (C) 2004 by Thomas Rathbone
+ * Copyright (C) 2005 by HP Labs
+ * Copyright (C) 2005 by David Brownell
+ * Copyright (C) 2010 - 2014 Xilinx, Inc.
+ *
+ * Some parts of this driver code is based on the driver for at91-series
+ * USB peripheral controller (at91_udc.c).
+ *
+ * This program is free software; you can redistribute it
+ * and/or modify it under the terms of the GNU General Public
+ * License as published by the Free Software Foundation;
+ * either version 2 of the License, or (at your option) any
+ * later version.
+ */
+
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/of_platform.h>
+#include <linux/of_irq.h>
+#include <linux/prefetch.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+/* Register offsets for the USB device.*/
+#define XUSB_EP0_CONFIG_OFFSET          0x0000  /* EP0 Config Reg Offset */
+#define XUSB_SETUP_PKT_ADDR_OFFSET      0x0080  /* Setup Packet Address */
+#define XUSB_ADDRESS_OFFSET             0x0100  /* Address Register */
+#define XUSB_CONTROL_OFFSET             0x0104  /* Control Register */
+#define XUSB_STATUS_OFFSET              0x0108  /* Status Register */
+#define XUSB_FRAMENUM_OFFSET            0x010C  /* Frame Number Register */
+#define XUSB_IER_OFFSET                 0x0110  /* Interrupt Enable Register */
+#define XUSB_BUFFREADY_OFFSET           0x0114  /* Buffer Ready Register */
+#define XUSB_TESTMODE_OFFSET            0x0118  /* Test Mode Register */
+#define XUSB_DMA_RESET_OFFSET           0x0200  /* DMA Soft Reset Register */
+#define XUSB_DMA_CONTROL_OFFSET         0x0204  /* DMA Control Register */
+#define XUSB_DMA_DSAR_ADDR_OFFSET       0x0208  /* DMA source Address Reg */
+#define XUSB_DMA_DDAR_ADDR_OFFSET       0x020C  /* DMA destination Addr Reg */
+#define XUSB_DMA_LENGTH_OFFSET          0x0210  /* DMA Length Register */
+#define XUSB_DMA_STATUS_OFFSET          0x0214  /* DMA Status Register */
+
+/* Endpoint Configuration Space offsets */
+#define XUSB_EP_CFGSTATUS_OFFSET        0x00    /* Endpoint Config Status  */
+#define XUSB_EP_BUF0COUNT_OFFSET        0x08    /* Buffer 0 Count */
+#define XUSB_EP_BUF1COUNT_OFFSET        0x0C    /* Buffer 1 Count */
+
+#define XUSB_CONTROL_USB_READY_MASK     0x80000000 /* USB ready Mask */
+#define XUSB_CONTROL_USB_RMTWAKE_MASK   0x40000000 /* Remote wake up mask */
+
+/* Interrupt register related masks.*/
+#define XUSB_STATUS_GLOBAL_INTR_MASK    0x80000000 /* Global Intr Enable */
+#define XUSB_STATUS_DMADONE_MASK        0x04000000 /* DMA done Mask */
+#define XUSB_STATUS_DMAERR_MASK         0x02000000 /* DMA Error Mask */
+#define XUSB_STATUS_DMABUSY_MASK        0x80000000 /* DMA Error Mask */
+#define XUSB_STATUS_RESUME_MASK         0x01000000 /* USB Resume Mask */
+#define XUSB_STATUS_RESET_MASK          0x00800000 /* USB Reset Mask */
+#define XUSB_STATUS_SUSPEND_MASK        0x00400000 /* USB Suspend Mask */
+#define XUSB_STATUS_DISCONNECT_MASK     0x00200000 /* USB Disconnect Mask */
+#define XUSB_STATUS_FIFO_BUFF_RDY_MASK  0x00100000 /* FIFO Buff Ready Mask */
+#define XUSB_STATUS_FIFO_BUFF_FREE_MASK 0x00080000 /* FIFO Buff Free Mask */
+#define XUSB_STATUS_SETUP_PACKET_MASK   0x00040000 /* Setup packet received */
+#define XUSB_STATUS_EP1_BUFF2_COMP_MASK 0x00000200 /* EP 1 Buff 2 Processed */
+#define XUSB_STATUS_EP1_BUFF1_COMP_MASK 0x00000002 /* EP 1 Buff 1 Processed */
+#define XUSB_STATUS_EP0_BUFF2_COMP_MASK 0x00000100 /* EP 0 Buff 2 Processed */
+#define XUSB_STATUS_EP0_BUFF1_COMP_MASK 0x00000001 /* EP 0 Buff 1 Processed */
+#define XUSB_STATUS_HIGH_SPEED_MASK     0x00010000 /* USB Speed Mask */
+/* Suspend,Reset,Suspend and Disconnect Mask */
+#define XUSB_STATUS_INTR_EVENT_MASK     0x01E00000
+/* Buffers  completion Mask */
+#define XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK     0x0000FEFF
+/* Mask for buffer 0 and buffer 1 completion for all Endpoints */
+#define XUSB_STATUS_INTR_BUFF_COMP_SHIFT_MASK   0x00000101
+#define XUSB_STATUS_EP_BUFF2_SHIFT      8          /* EP buffer offset */
+
+/* Endpoint Configuration Status Register */
+#define XUSB_EP_CFG_VALID_MASK          0x80000000 /* Endpoint Valid bit */
+#define XUSB_EP_CFG_STALL_MASK          0x40000000 /* Endpoint Stall bit */
+#define XUSB_EP_CFG_DATA_TOGGLE_MASK    0x08000000 /* Endpoint Data toggle */
+
+/* USB device specific global configuration constants.*/
+#define XUSB_MAX_ENDPOINTS              8       /* Maximum End Points */
+#define XUSB_EP_NUMBER_ZERO             0       /* End point Zero */
+/* DPRAM is the source address for DMA transfer */
+#define XUSB_DMA_READ_FROM_DPRAM        0x80000000
+#define XUSB_DMA_DMASR_BUSY             0x80000000 /* DMA busy */
+#define XUSB_DMA_DMASR_ERROR            0x40000000 /* DMA Error */
+/*
+ * When this bit is set, the DMA buffer ready bit is set by hardware upon
+ * DMA transfer completion.
+ */
+#define XUSB_DMA_BRR_CTRL               0x40000000 /* DMA bufready ctrl bit */
+/* Phase States */
+#define SETUP_PHASE                     0x0000  /* Setup Phase */
+#define DATA_PHASE                      0x0001  /* Data Phase */
+#define STATUS_PHASE                    0x0002  /* Status Phase */
+
+#define EP0_MAX_PACKET          64 /* Endpoint 0 maximum packet length */
+#define STATUSBUFF_SIZE         2  /* Buffer size for GET_STATUS command */
+#define EPNAME_SIZE             4  /* Buffer size for endpoint name */
+
+/* container_of helper macros */
+#define to_udc(g)        container_of((g), struct xusb_udc, gadget)
+#define to_xusb_ep(ep)   container_of((ep), struct xusb_ep, ep_usb)
+#define to_xusb_req(req) container_of((req), struct xusb_req, usb_req)
+
+/**
+ * struct xusb_req - Xilinx USB device request structure
+ * @usb_req: Linux usb request structure
+ * @queue: usb device request queue
+ * @ep: pointer to xusb_endpoint structure
+ */
+struct xusb_req {
+        struct usb_request usb_req;
+        struct list_head queue;
+        struct xusb_ep *ep;
+};
+
+/**
+ * struct xusb_ep - USB end point structure.
+ * @ep_usb: usb endpoint instance
+ * @queue: endpoint message queue
+ * @udc: xilinx usb peripheral driver instance pointer
+ * @desc: pointer to the usb endpoint descriptor
+ * @rambase: the endpoint buffer address
+ * @offset: the endpoint register offset value
+ * @name: name of the endpoint
+ * @epnumber: endpoint number
+ * @maxpacket: maximum packet size the endpoint can store
+ * @buffer0count: the size of the packet recieved in the first buffer
+ * @buffer1count: the size of the packet received in the second buffer
+ * @curbufnum: current buffer of endpoint that will be processed next
+ * @buffer0ready: the busy state of first buffer
+ * @buffer1ready: the busy state of second buffer
+ * @is_in: endpoint direction (IN or OUT)
+ * @is_iso: endpoint type(isochronous or non isochronous)
+ */
+struct xusb_ep {
+        struct usb_ep ep_usb;
+        struct list_head queue;
+        struct xusb_udc *udc;
+        const struct usb_endpoint_descriptor *desc;
+        u32  rambase;
+        u32  offset;
+        char name[4];
+        u16  epnumber;
+        u16  maxpacket;
+        u16  buffer0count;
+        u16  buffer1count;
+        u8   curbufnum;
+        bool buffer0ready;
+        bool buffer1ready;
+        bool is_in;
+        bool is_iso;
+};
+
+/**
+ * struct xusb_udc -  USB peripheral driver structure
+ * @gadget: USB gadget driver instance
+ * @ep: an array of endpoint structures
+ * @driver: pointer to the usb gadget driver instance
+ * @setup: usb_ctrlrequest structure for control requests
+ * @req: pointer to dummy request for get status command
+ * @dev: pointer to device structure in gadget
+ * @usb_state: device in suspended state or not
+ * @remote_wkp: remote wakeup enabled by host
+ * @setupseqtx: tx status
+ * @setupseqrx: rx status
+ * @addr: the usb device base address
+ * @lock: instance of spinlock
+ * @dma_enabled: flag indicating whether the dma is included in the system
+ * @read_fn: function pointer to read device registers
+ * @write_fn: function pointer to write to device registers
+ */
+struct xusb_udc {
+        struct usb_gadget gadget;
+        struct xusb_ep ep[8];
+        struct usb_gadget_driver *driver;
+        struct usb_ctrlrequest setup;
+        struct xusb_req *req;
+        struct device *dev;
+        u32 usb_state;
+        u32 remote_wkp;
+        u32 setupseqtx;
+        u32 setupseqrx;
+        void __iomem *addr;
+        spinlock_t lock;
+        bool dma_enabled;
+
+        unsigned int (*read_fn)(void __iomem *);
+        void (*write_fn)(void __iomem *, u32, u32);
+};
+
+/* Endpoint buffer start addresses in the core */
+static u32 rambase[8] = { 0x22, 0x1000, 0x1100, 0x1200, 0x1300, 0x1400, 0x1500,
+                          0x1600 };
+
+static const char driver_name[] = "xilinx-udc";
+static const char ep0name[] = "ep0";
+
+/* Control endpoint configuration.*/
+static const struct usb_endpoint_descriptor config_bulk_out_desc = {
+        .bLength                = USB_DT_ENDPOINT_SIZE,
+        .bDescriptorType        = USB_DT_ENDPOINT,
+        .bEndpointAddress       = USB_DIR_OUT,
+        .bmAttributes           = USB_ENDPOINT_XFER_BULK,
+        .wMaxPacketSize         = cpu_to_le16(EP0_MAX_PACKET),
+};
+
+/**
+ * xudc_write32 - little endian write to device registers
+ * @addr: base addr of device registers
+ * @offset: register offset
+ * @val: data to be written
+ */
+static void xudc_write32(void __iomem *addr, u32 offset, u32 val)
+{
+        iowrite32(val, addr + offset);
+}
+
+/**
+ * xudc_read32 - little endian read from device registers
+ * @addr: addr of device register
+ * Return: value at addr
+ */
+static unsigned int xudc_read32(void __iomem *addr)
+{
+        return ioread32(addr);
+}
+
+/**
+ * xudc_write32_be - big endian write to device registers
+ * @addr: base addr of device registers
+ * @offset: register offset
+ * @val: data to be written
+ */
+static void xudc_write32_be(void __iomem *addr, u32 offset, u32 val)
+{
+        iowrite32be(val, addr + offset);
+}
+
+/**
+ * xudc_read32_be - big endian read from device registers
+ * @addr: addr of device register
+ * Return: value at addr
+ */
+static unsigned int xudc_read32_be(void __iomem *addr)
+{
+        return ioread32be(addr);
+}
+
+/**
+ * xudc_wrstatus - Sets up the usb device status stages.
+ * @udc: pointer to the usb device controller structure.
+ */
+static void xudc_wrstatus(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO];
+        u32 epcfgreg;
+
+        epcfgreg = udc->read_fn(udc->addr + ep0->offset)|
+                                XUSB_EP_CFG_DATA_TOGGLE_MASK;
+        udc->write_fn(udc->addr, ep0->offset, epcfgreg);
+        udc->write_fn(udc->addr, ep0->offset + XUSB_EP_BUF0COUNT_OFFSET, 0);
+        udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
+}
+
+/**
+ * xudc_epconfig - Configures the given endpoint.
+ * @ep: pointer to the usb device endpoint structure.
+ * @udc: pointer to the usb peripheral controller structure.
+ *
+ * This function configures a specific endpoint with the given configuration
+ * data.
+ */
+static void xudc_epconfig(struct xusb_ep *ep, struct xusb_udc *udc)
+{
+        u32 epcfgreg;
+
+        /*
+         * Configure the end point direction, type, Max Packet Size and the
+         * EP buffer location.
+         */
+        epcfgreg = ((ep->is_in << 29) | (ep->is_iso << 28) |
+                   (ep->ep_usb.maxpacket << 15) | (ep->rambase));
+        udc->write_fn(udc->addr, ep->offset, epcfgreg);
+
+        /* Set the Buffer count and the Buffer ready bits.*/
+        udc->write_fn(udc->addr, ep->offset + XUSB_EP_BUF0COUNT_OFFSET,
+                      ep->buffer0count);
+        udc->write_fn(udc->addr, ep->offset + XUSB_EP_BUF1COUNT_OFFSET,
+                      ep->buffer1count);
+        if (ep->buffer0ready)
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                              1 << ep->epnumber);
+        if (ep->buffer1ready)
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                              1 << (ep->epnumber + XUSB_STATUS_EP_BUFF2_SHIFT));
+}
+
+/**
+ * xudc_start_dma - Starts DMA transfer.
+ * @ep: pointer to the usb device endpoint structure.
+ * @src: DMA source address.
+ * @dst: DMA destination address.
+ * @length: number of bytes to transfer.
+ *
+ * Return: 0 on success, error code on failure
+ *
+ * This function starts DMA transfer by writing to DMA source,
+ * destination and lenth registers.
+ */
+static int xudc_start_dma(struct xusb_ep *ep, dma_addr_t src,
+                          dma_addr_t dst, u32 length)
+{
+        struct xusb_udc *udc = ep->udc;
+        int rc = 0;
+        u32 timeout = 500;
+        u32 reg;
+
+        /*
+         * Set the addresses in the DMA source and
+         * destination registers and then set the length
+         * into the DMA length register.
+         */
+        udc->write_fn(udc->addr, XUSB_DMA_DSAR_ADDR_OFFSET, src);
+        udc->write_fn(udc->addr, XUSB_DMA_DDAR_ADDR_OFFSET, dst);
+        udc->write_fn(udc->addr, XUSB_DMA_LENGTH_OFFSET, length);
+
+        /*
+         * Wait till DMA transaction is complete and
+         * check whether the DMA transaction was
+         * successful.
+         */
+        do {
+                reg = udc->read_fn(udc->addr + XUSB_DMA_STATUS_OFFSET);
+                if (!(reg &  XUSB_DMA_DMASR_BUSY))
+                        break;
+
+                /*
+                 * We can't sleep here, because it's also called from
+                 * interrupt context.
+                 */
+                timeout--;
+                if (!timeout) {
+                        dev_err(udc->dev, "DMA timeout\n");
+                        return -ETIMEDOUT;
+                }
+                udelay(1);
+        } while (1);
+
+        if ((udc->read_fn(udc->addr + XUSB_DMA_STATUS_OFFSET) &
+                          XUSB_DMA_DMASR_ERROR) == XUSB_DMA_DMASR_ERROR){
+                dev_err(udc->dev, "DMA Error\n");
+                rc = -EINVAL;
+        }
+
+        return rc;
+}
+
+/**
+ * xudc_dma_send - Sends IN data using DMA.
+ * @ep: pointer to the usb device endpoint structure.
+ * @req: pointer to the usb request structure.
+ * @buffer: pointer to data to be sent.
+ * @length: number of bytes to send.
+ *
+ * Return: 0 on success, -EAGAIN if no buffer is free and error
+ *         code on failure.
+ *
+ * This function sends data using DMA.
+ */
+static int xudc_dma_send(struct xusb_ep *ep, struct xusb_req *req,
+                         u8 *buffer, u32 length)
+{
+        u32 *eprambase;
+        dma_addr_t src;
+        dma_addr_t dst;
+        struct xusb_udc *udc = ep->udc;
+
+        src = req->usb_req.dma + req->usb_req.actual;
+        if (req->usb_req.length)
+                dma_sync_single_for_device(udc->dev, src,
+                                           length, DMA_TO_DEVICE);
+        if (!ep->curbufnum && !ep->buffer0ready) {
+                /* Get the Buffer address and copy the transmit data.*/
+                eprambase = (u32 __force *)(udc->addr + ep->rambase);
+                dst = virt_to_phys(eprambase);
+                udc->write_fn(udc->addr, ep->offset +
+                              XUSB_EP_BUF0COUNT_OFFSET, length);
+                udc->write_fn(udc->addr, XUSB_DMA_CONTROL_OFFSET,
+                              XUSB_DMA_BRR_CTRL | (1 << ep->epnumber));
+                ep->buffer0ready = 1;
+                ep->curbufnum = 1;
+        } else if (ep->curbufnum && !ep->buffer1ready) {
+                /* Get the Buffer address and copy the transmit data.*/
+                eprambase = (u32 __force *)(udc->addr + ep->rambase +
+                             ep->ep_usb.maxpacket);
+                dst = virt_to_phys(eprambase);
+                udc->write_fn(udc->addr, ep->offset +
+                              XUSB_EP_BUF1COUNT_OFFSET, length);
+                udc->write_fn(udc->addr, XUSB_DMA_CONTROL_OFFSET,
+                              XUSB_DMA_BRR_CTRL | (1 << (ep->epnumber +
+                              XUSB_STATUS_EP_BUFF2_SHIFT)));
+                ep->buffer1ready = 1;
+                ep->curbufnum = 0;
+        } else {
+                /* None of ping pong buffers are ready currently .*/
+                return -EAGAIN;
+        }
+
+        return xudc_start_dma(ep, src, dst, length);
+}
+
+/**
+ * xudc_dma_receive - Receives OUT data using DMA.
+ * @ep: pointer to the usb device endpoint structure.
+ * @req: pointer to the usb request structure.
+ * @buffer: pointer to storage buffer of received data.
+ * @length: number of bytes to receive.
+ *
+ * Return: 0 on success, -EAGAIN if no buffer is free and error
+ *         code on failure.
+ *
+ * This function receives data using DMA.
+ */
+static int xudc_dma_receive(struct xusb_ep *ep, struct xusb_req *req,
+                            u8 *buffer, u32 length)
+{
+        u32 *eprambase;
+        dma_addr_t src;
+        dma_addr_t dst;
+        struct xusb_udc *udc = ep->udc;
+
+        dst = req->usb_req.dma + req->usb_req.actual;
+        if (!ep->curbufnum && !ep->buffer0ready) {
+                /* Get the Buffer address and copy the transmit data */
+                eprambase = (u32 __force *)(udc->addr + ep->rambase);
+                src = virt_to_phys(eprambase);
+                udc->write_fn(udc->addr, XUSB_DMA_CONTROL_OFFSET,
+                              XUSB_DMA_BRR_CTRL | XUSB_DMA_READ_FROM_DPRAM |
+                              (1 << ep->epnumber));
+                ep->buffer0ready = 1;
+                ep->curbufnum = 1;
+        } else if (ep->curbufnum && !ep->buffer1ready) {
+                /* Get the Buffer address and copy the transmit data */
+                eprambase = (u32 __force *)(udc->addr +
+                             ep->rambase + ep->ep_usb.maxpacket);
+                src = virt_to_phys(eprambase);
+                udc->write_fn(udc->addr, XUSB_DMA_CONTROL_OFFSET,
+                              XUSB_DMA_BRR_CTRL | XUSB_DMA_READ_FROM_DPRAM |
+                              (1 << (ep->epnumber +
+                              XUSB_STATUS_EP_BUFF2_SHIFT)));
+                ep->buffer1ready = 1;
+                ep->curbufnum = 0;
+        } else {
+                /* None of the ping-pong buffers are ready currently */
+                return -EAGAIN;
+        }
+
+        return xudc_start_dma(ep, src, dst, length);
+}
+
+/**
+ * xudc_eptxrx - Transmits or receives data to or from an endpoint.
+ * @ep: pointer to the usb endpoint configuration structure.
+ * @req: pointer to the usb request structure.
+ * @bufferptr: pointer to buffer containing the data to be sent.
+ * @bufferlen: The number of data bytes to be sent.
+ *
+ * Return: 0 on success, -EAGAIN if no buffer is free.
+ *
+ * This function copies the transmit/receive data to/from the end point buffer
+ * and enables the buffer for transmission/reception.
+ */
+static int xudc_eptxrx(struct xusb_ep *ep, struct xusb_req *req,
+                       u8 *bufferptr, u32 bufferlen)
+{
+        u32 *eprambase;
+        u32 bytestosend;
+        int rc = 0;
+        struct xusb_udc *udc = ep->udc;
+
+        bytestosend = bufferlen;
+        if (udc->dma_enabled) {
+                if (ep->is_in)
+                        rc = xudc_dma_send(ep, req, bufferptr, bufferlen);
+                else
+                        rc = xudc_dma_receive(ep, req, bufferptr, bufferlen);
+                return rc;
+        }
+        /* Put the transmit buffer into the correct ping-pong buffer.*/
+        if (!ep->curbufnum && !ep->buffer0ready) {
+                /* Get the Buffer address and copy the transmit data.*/
+                eprambase = (u32 __force *)(udc->addr + ep->rambase);
+                if (ep->is_in) {
+                        memcpy(eprambase, bufferptr, bytestosend);
+                        udc->write_fn(udc->addr, ep->offset +
+                                      XUSB_EP_BUF0COUNT_OFFSET, bufferlen);
+                } else {
+                        memcpy(bufferptr, eprambase, bytestosend);
+                }
+                /*
+                 * Enable the buffer for transmission.
+                 */
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                              1 << ep->epnumber);
+                ep->buffer0ready = 1;
+                ep->curbufnum = 1;
+        } else if (ep->curbufnum && !ep->buffer1ready) {
+                /* Get the Buffer address and copy the transmit data.*/
+                eprambase = (u32 __force *)(udc->addr + ep->rambase +
+                             ep->ep_usb.maxpacket);
+                if (ep->is_in) {
+                        memcpy(eprambase, bufferptr, bytestosend);
+                        udc->write_fn(udc->addr, ep->offset +
+                                      XUSB_EP_BUF1COUNT_OFFSET, bufferlen);
+                } else {
+                        memcpy(bufferptr, eprambase, bytestosend);
+                }
+                /*
+                 * Enable the buffer for transmission.
+                 */
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                              1 << (ep->epnumber + XUSB_STATUS_EP_BUFF2_SHIFT));
+                ep->buffer1ready = 1;
+                ep->curbufnum = 0;
+        } else {
+                /* None of the ping-pong buffers are ready currently */
+                return -EAGAIN;
+        }
+        return rc;
+}
+
+/**
+ * xudc_done - Exeutes the endpoint data transfer completion tasks.
+ * @ep: pointer to the usb device endpoint structure.
+ * @req: pointer to the usb request structure.
+ * @status: Status of the data transfer.
+ *
+ * Deletes the message from the queue and updates data transfer completion
+ * status.
+ */
+static void xudc_done(struct xusb_ep *ep, struct xusb_req *req, int status)
+{
+        struct xusb_udc *udc = ep->udc;
+
+        list_del_init(&req->queue);
+
+        if (req->usb_req.status == -EINPROGRESS)
+                req->usb_req.status = status;
+        else
+                status = req->usb_req.status;
+
+        if (status && status != -ESHUTDOWN)
+                dev_dbg(udc->dev, "%s done %p, status %d\n",
+                        ep->ep_usb.name, req, status);
+        /* unmap request if DMA is present*/
+        if (udc->dma_enabled && ep->epnumber && req->usb_req.length)
+                usb_gadget_unmap_request(&udc->gadget, &req->usb_req,
+                                         ep->is_in);
+
+        if (req->usb_req.complete) {
+                spin_unlock(&udc->lock);
+                req->usb_req.complete(&ep->ep_usb, &req->usb_req);
+                spin_lock(&udc->lock);
+        }
+}
+
+/**
+ * xudc_read_fifo - Reads the data from the given endpoint buffer.
+ * @ep: pointer to the usb device endpoint structure.
+ * @req: pointer to the usb request structure.
+ *
+ * Return: 0 if request is completed and -EAGAIN if not completed.
+ *
+ * Pulls OUT packet data from the endpoint buffer.
+ */
+static int xudc_read_fifo(struct xusb_ep *ep, struct xusb_req *req)
+{
+        u8 *buf;
+        u32 is_short, count, bufferspace;
+        u8 bufoffset;
+        u8 two_pkts = 0;
+        int ret;
+        int retval = -EAGAIN;
+        struct xusb_udc *udc = ep->udc;
+
+        if (ep->buffer0ready && ep->buffer1ready) {
+                dev_dbg(udc->dev, "Packet NOT ready!\n");
+                return retval;
+        }
+top:
+        if (ep->curbufnum)
+                bufoffset = XUSB_EP_BUF1COUNT_OFFSET;
+        else
+                bufoffset = XUSB_EP_BUF0COUNT_OFFSET;
+
+        count = udc->read_fn(udc->addr + ep->offset + bufoffset);
+
+        if (!ep->buffer0ready && !ep->buffer1ready)
+                two_pkts = 1;
+
+        buf = req->usb_req.buf + req->usb_req.actual;
+        prefetchw(buf);
+        bufferspace = req->usb_req.length - req->usb_req.actual;
+        is_short = count < ep->ep_usb.maxpacket;
+
+        if (unlikely(!bufferspace)) {
+                /*
+                 * This happens when the driver's buffer
+                 * is smaller than what the host sent.
+                 * discard the extra data.
+                 */
+                if (req->usb_req.status != -EOVERFLOW)
+                        dev_dbg(udc->dev, "%s overflow %d\n",
+                                ep->ep_usb.name, count);
+                req->usb_req.status = -EOVERFLOW;
+                xudc_done(ep, req, -EOVERFLOW);
+                return 0;
+        }
+
+        ret = xudc_eptxrx(ep, req, buf, count);
+        switch (ret) {
+        case 0:
+                req->usb_req.actual += min(count, bufferspace);
+                dev_dbg(udc->dev, "read %s, %d bytes%s req %p %d/%d\n",
+                        ep->ep_usb.name, count, is_short ? "/S" : "", req,
+                        req->usb_req.actual, req->usb_req.length);
+                bufferspace -= count;
+                /* Completion */
+                if ((req->usb_req.actual == req->usb_req.length) || is_short) {
+                        if (udc->dma_enabled && req->usb_req.length)
+                                dma_sync_single_for_cpu(udc->dev,
+                                                        req->usb_req.dma,
+                                                        req->usb_req.actual,
+                                                        DMA_FROM_DEVICE);
+                        xudc_done(ep, req, 0);
+                        return 0;
+                }
+                if (two_pkts) {
+                        two_pkts = 0;
+                        goto top;
+                }
+                break;
+        case -EAGAIN:
+                dev_dbg(udc->dev, "receive busy\n");
+                break;
+        case -EINVAL:
+        case -ETIMEDOUT:
+                /* DMA error, dequeue the request */
+                xudc_done(ep, req, -ECONNRESET);
+                retval = 0;
+                break;
+        }
+
+        return retval;
+}
+
+/**
+ * xudc_write_fifo - Writes data into the given endpoint buffer.
+ * @ep: pointer to the usb device endpoint structure.
+ * @req: pointer to the usb request structure.
+ *
+ * Return: 0 if request is completed and -EAGAIN if not completed.
+ *
+ * Loads endpoint buffer for an IN packet.
+ */
+static int xudc_write_fifo(struct xusb_ep *ep, struct xusb_req *req)
+{
+        u32 max;
+        u32 length;
+        int ret;
+        int retval = -EAGAIN;
+        struct xusb_udc *udc = ep->udc;
+        int is_last, is_short = 0;
+        u8 *buf;
+
+        max = le16_to_cpu(ep->desc->wMaxPacketSize);
+        buf = req->usb_req.buf + req->usb_req.actual;
+        prefetch(buf);
+        length = req->usb_req.length - req->usb_req.actual;
+        length = min(length, max);
+
+        ret = xudc_eptxrx(ep, req, buf, length);
+        switch (ret) {
+        case 0:
+                req->usb_req.actual += length;
+                if (unlikely(length != max)) {
+                        is_last = is_short = 1;
+                } else {
+                        if (likely(req->usb_req.length !=
+                                   req->usb_req.actual) || req->usb_req.zero)
+                                is_last = 0;
+                        else
+                                is_last = 1;
+                }
+                dev_dbg(udc->dev, "%s: wrote %s %d bytes%s%s %d left %p\n",
+                        __func__, ep->ep_usb.name, length, is_last ? "/L" : "",
+                        is_short ? "/S" : "",
+                        req->usb_req.length - req->usb_req.actual, req);
+                /* completion */
+                if (is_last) {
+                        xudc_done(ep, req, 0);
+                        retval = 0;
+                }
+                break;
+        case -EAGAIN:
+                dev_dbg(udc->dev, "Send busy\n");
+                break;
+        case -EINVAL:
+        case -ETIMEDOUT:
+                /* DMA error, dequeue the request */
+                xudc_done(ep, req, -ECONNRESET);
+                retval = 0;
+                break;
+        }
+
+        return retval;
+}
+
+/**
+ * xudc_nuke - Cleans up the data transfer message list.
+ * @ep: pointer to the usb device endpoint structure.
+ * @status: Status of the data transfer.
+ */
+static void xudc_nuke(struct xusb_ep *ep, int status)
+{
+        struct xusb_req *req;
+
+        while (!list_empty(&ep->queue)) {
+                req = list_first_entry(&ep->queue, struct xusb_req, queue);
+                xudc_done(ep, req, status);
+        }
+}
+
+/**
+ * xudc_ep_set_halt - Stalls/unstalls the given endpoint.
+ * @_ep: pointer to the usb device endpoint structure.
+ * @value: value to indicate stall/unstall.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep_set_halt(struct usb_ep *_ep, int value)
+{
+        struct xusb_ep *ep = to_xusb_ep(_ep);
+        struct xusb_udc *udc;
+        unsigned long flags;
+        u32 epcfgreg;
+
+        if (!_ep || (!ep->desc && ep->epnumber)) {
+                pr_debug("%s: bad ep or descriptor\n", __func__);
+                return -EINVAL;
+        }
+        udc = ep->udc;
+
+        if (ep->is_in && (!list_empty(&ep->queue)) && value) {
+                dev_dbg(udc->dev, "requests pending can't halt\n");
+                return -EAGAIN;
+        }
+
+        if (ep->buffer0ready || ep->buffer1ready) {
+                dev_dbg(udc->dev, "HW buffers busy can't halt\n");
+                return -EAGAIN;
+        }
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        if (value) {
+                /* Stall the device.*/
+                epcfgreg = udc->read_fn(udc->addr + ep->offset);
+                epcfgreg |= XUSB_EP_CFG_STALL_MASK;
+                udc->write_fn(udc->addr, ep->offset, epcfgreg);
+        } else {
+                /* Unstall the device.*/
+                epcfgreg = udc->read_fn(udc->addr + ep->offset);
+                epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
+                udc->write_fn(udc->addr, ep->offset, epcfgreg);
+                if (ep->epnumber) {
+                        /* Reset the toggle bit.*/
+                        epcfgreg = udc->read_fn(ep->udc->addr + ep->offset);
+                        epcfgreg &= ~XUSB_EP_CFG_DATA_TOGGLE_MASK;
+                        udc->write_fn(udc->addr, ep->offset, epcfgreg);
+                }
+        }
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/**
+ * xudc_ep_enable - Enables the given endpoint.
+ * @ep: pointer to the xusb endpoint structure.
+ * @desc: pointer to usb endpoint descriptor.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int __xudc_ep_enable(struct xusb_ep *ep,
+                            const struct usb_endpoint_descriptor *desc)
+{
+        struct xusb_udc *udc = ep->udc;
+        u32 tmp;
+        u32 epcfg;
+        u32 ier;
+        u16 maxpacket;
+
+        ep->is_in = ((desc->bEndpointAddress & USB_DIR_IN) != 0);
+        /* Bit 3...0:endpoint number */
+        ep->epnumber = (desc->bEndpointAddress & 0x0f);
+        ep->desc = desc;
+        ep->ep_usb.desc = desc;
+        tmp = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
+        ep->ep_usb.maxpacket = maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+
+        switch (tmp) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                dev_dbg(udc->dev, "only one control endpoint\n");
+                /* NON- ISO */
+                ep->is_iso = 0;
+                return -EINVAL;
+        case USB_ENDPOINT_XFER_INT:
+                /* NON- ISO */
+                ep->is_iso = 0;
+                if (maxpacket > 64) {
+                        dev_dbg(udc->dev, "bogus maxpacket %d\n", maxpacket);
+                        return -EINVAL;
+                }
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                /* NON- ISO */
+                ep->is_iso = 0;
+                if (!(is_power_of_2(maxpacket) && maxpacket >= 8 &&
+                                maxpacket <= 512)) {
+                        dev_dbg(udc->dev, "bogus maxpacket %d\n", maxpacket);
+                        return -EINVAL;
+                }
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                /* ISO */
+                ep->is_iso = 1;
+                break;
+        }
+
+        ep->buffer0ready = 0;
+        ep->buffer1ready = 0;
+        ep->curbufnum = 0;
+        ep->rambase = rambase[ep->epnumber];
+        xudc_epconfig(ep, udc);
+
+        dev_dbg(udc->dev, "Enable Endpoint %d max pkt is %d\n",
+                ep->epnumber, maxpacket);
+
+        /* Enable the End point.*/
+        epcfg = udc->read_fn(udc->addr + ep->offset);
+        epcfg |= XUSB_EP_CFG_VALID_MASK;
+        udc->write_fn(udc->addr, ep->offset, epcfg);
+        if (ep->epnumber)
+                ep->rambase <<= 2;
+
+        /* Enable buffer completion interrupts for endpoint */
+        ier = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+        ier |= (XUSB_STATUS_INTR_BUFF_COMP_SHIFT_MASK << ep->epnumber);
+        udc->write_fn(udc->addr, XUSB_IER_OFFSET, ier);
+
+        /* for OUT endpoint set buffers ready to receive */
+        if (ep->epnumber && !ep->is_in) {
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                              1 << ep->epnumber);
+                ep->buffer0ready = 1;
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET,
+                             (1 << (ep->epnumber +
+                              XUSB_STATUS_EP_BUFF2_SHIFT)));
+                ep->buffer1ready = 1;
+        }
+
+        return 0;
+}
+
+/**
+ * xudc_ep_enable - Enables the given endpoint.
+ * @_ep: pointer to the usb endpoint structure.
+ * @desc: pointer to usb endpoint descriptor.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep_enable(struct usb_ep *_ep,
+                          const struct usb_endpoint_descriptor *desc)
+{
+        struct xusb_ep *ep;
+        struct xusb_udc *udc;
+        unsigned long flags;
+        int ret;
+
+        if (!_ep || !desc || desc->bDescriptorType != USB_DT_ENDPOINT) {
+                pr_debug("%s: bad ep or descriptor\n", __func__);
+                return -EINVAL;
+        }
+
+        ep = to_xusb_ep(_ep);
+        udc = ep->udc;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
+                dev_dbg(udc->dev, "bogus device state\n");
+                return -ESHUTDOWN;
+        }
+
+        spin_lock_irqsave(&udc->lock, flags);
+        ret = __xudc_ep_enable(ep, desc);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+/**
+ * xudc_ep_disable - Disables the given endpoint.
+ * @_ep: pointer to the usb endpoint structure.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep_disable(struct usb_ep *_ep)
+{
+        struct xusb_ep *ep;
+        unsigned long flags;
+        u32 epcfg;
+        struct xusb_udc *udc;
+
+        if (!_ep) {
+                pr_debug("%s: invalid ep\n", __func__);
+                return -EINVAL;
+        }
+
+        ep = to_xusb_ep(_ep);
+        udc = ep->udc;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        xudc_nuke(ep, -ESHUTDOWN);
+
+        /* Restore the endpoint's pristine config */
+        ep->desc = NULL;
+        ep->ep_usb.desc = NULL;
+
+        dev_dbg(udc->dev, "USB Ep %d disable\n ", ep->epnumber);
+        /* Disable the endpoint.*/
+        epcfg = udc->read_fn(udc->addr + ep->offset);
+        epcfg &= ~XUSB_EP_CFG_VALID_MASK;
+        udc->write_fn(udc->addr, ep->offset, epcfg);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/**
+ * xudc_ep_alloc_request - Initializes the request queue.
+ * @_ep: pointer to the usb endpoint structure.
+ * @gfp_flags: Flags related to the request call.
+ *
+ * Return: pointer to request structure on success and a NULL on failure.
+ */
+static struct usb_request *xudc_ep_alloc_request(struct usb_ep *_ep,
+                                                 gfp_t gfp_flags)
+{
+        struct xusb_ep *ep = to_xusb_ep(_ep);
+        struct xusb_udc *udc;
+        struct xusb_req *req;
+
+        udc = ep->udc;
+        req = kzalloc(sizeof(*req), gfp_flags);
+        if (!req) {
+                dev_err(udc->dev, "%s:not enough memory", __func__);
+                return NULL;
+        }
+
+        req->ep = ep;
+        INIT_LIST_HEAD(&req->queue);
+        return &req->usb_req;
+}
+
+/**
+ * xudc_free_request - Releases the request from queue.
+ * @_ep: pointer to the usb device endpoint structure.
+ * @_req: pointer to the usb request structure.
+ */
+static void xudc_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct xusb_req *req = to_xusb_req(_req);
+
+        kfree(req);
+}
+
+/**
+ * xudc_ep0_queue - Adds the request to endpoint 0 queue.
+ * @ep0: pointer to the xusb endpoint 0 structure.
+ * @req: pointer to the xusb request structure.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int __xudc_ep0_queue(struct xusb_ep *ep0, struct xusb_req *req)
+{
+        struct xusb_udc *udc = ep0->udc;
+        u32 length;
+        u8 *corebuf;
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
+                dev_dbg(udc->dev, "%s, bogus device state\n", __func__);
+                return -EINVAL;
+        }
+        if (!list_empty(&ep0->queue)) {
+                dev_dbg(udc->dev, "%s:ep0 busy\n", __func__);
+                return -EBUSY;
+        }
+
+        req->usb_req.status = -EINPROGRESS;
+        req->usb_req.actual = 0;
+
+        list_add_tail(&req->queue, &ep0->queue);
+
+        if (udc->setup.bRequestType & USB_DIR_IN) {
+                prefetch(req->usb_req.buf);
+                length = req->usb_req.length;
+                corebuf = (void __force *) ((ep0->rambase << 2) +
+                           udc->addr);
+                length = req->usb_req.actual = min_t(u32, length,
+                                                     EP0_MAX_PACKET);
+                memcpy(corebuf, req->usb_req.buf, length);
+                udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, length);
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
+        } else {
+                if (udc->setup.wLength) {
+                        /* Enable EP0 buffer to receive data */
+                        udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, 0);
+                        udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
+                } else {
+                        xudc_wrstatus(udc);
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * xudc_ep0_queue - Adds the request to endpoint 0 queue.
+ * @_ep: pointer to the usb endpoint 0 structure.
+ * @_req: pointer to the usb request structure.
+ * @gfp_flags: Flags related to the request call.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep0_queue(struct usb_ep *_ep, struct usb_request *_req,
+                          gfp_t gfp_flags)
+{
+        struct xusb_req *req    = to_xusb_req(_req);
+        struct xusb_ep  *ep0    = to_xusb_ep(_ep);
+        struct xusb_udc *udc    = ep0->udc;
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        ret = __xudc_ep0_queue(ep0, req);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return ret;
+}
+
+/**
+ * xudc_ep_queue - Adds the request to endpoint queue.
+ * @_ep: pointer to the usb endpoint structure.
+ * @_req: pointer to the usb request structure.
+ * @gfp_flags: Flags related to the request call.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
+                         gfp_t gfp_flags)
+{
+        struct xusb_req *req = to_xusb_req(_req);
+        struct xusb_ep  *ep  = to_xusb_ep(_ep);
+        struct xusb_udc *udc = ep->udc;
+        int  ret;
+        unsigned long flags;
+
+        if (!ep->desc) {
+                dev_dbg(udc->dev, "%s:queing request to disabled %s\n",
+                        __func__, ep->name);
+                return -ESHUTDOWN;
+        }
+
+        if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
+                dev_dbg(udc->dev, "%s, bogus device state\n", __func__);
+                return -EINVAL;
+        }
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        _req->status = -EINPROGRESS;
+        _req->actual = 0;
+
+        if (udc->dma_enabled) {
+                ret = usb_gadget_map_request(&udc->gadget, &req->usb_req,
+                                             ep->is_in);
+                if (ret) {
+                        dev_dbg(udc->dev, "gadget_map failed ep%d\n",
+                                ep->epnumber);
+                        spin_unlock_irqrestore(&udc->lock, flags);
+                        return -EAGAIN;
+                }
+        }
+
+        if (list_empty(&ep->queue)) {
+                if (ep->is_in) {
+                        dev_dbg(udc->dev, "xudc_write_fifo from ep_queue\n");
+                        if (!xudc_write_fifo(ep, req))
+                                req = NULL;
+                } else {
+                        dev_dbg(udc->dev, "xudc_read_fifo from ep_queue\n");
+                        if (!xudc_read_fifo(ep, req))
+                                req = NULL;
+                }
+        }
+
+        if (req != NULL)
+                list_add_tail(&req->queue, &ep->queue);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/**
+ * xudc_ep_dequeue - Removes the request from the queue.
+ * @_ep: pointer to the usb device endpoint structure.
+ * @_req: pointer to the usb request structure.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct xusb_ep *ep      = to_xusb_ep(_ep);
+        struct xusb_req *req    = to_xusb_req(_req);
+        struct xusb_udc *udc    = ep->udc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        /* Make sure it's actually queued on this endpoint */
+        list_for_each_entry(req, &ep->queue, queue) {
+                if (&req->usb_req == _req)
+                        break;
+        }
+        if (&req->usb_req != _req) {
+                spin_unlock_irqrestore(&ep->udc->lock, flags);
+                return -EINVAL;
+        }
+        xudc_done(ep, req, -ECONNRESET);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/**
+ * xudc_ep0_enable - Enables the given endpoint.
+ * @ep: pointer to the usb endpoint structure.
+ * @desc: pointer to usb endpoint descriptor.
+ *
+ * Return: error always.
+ *
+ * endpoint 0 enable should not be called by gadget layer.
+ */
+static int xudc_ep0_enable(struct usb_ep *ep,
+                           const struct usb_endpoint_descriptor *desc)
+{
+        return -EINVAL;
+}
+
+/**
+ * xudc_ep0_disable - Disables the given endpoint.
+ * @ep: pointer to the usb endpoint structure.
+ *
+ * Return: error always.
+ *
+ * endpoint 0 disable should not be called by gadget layer.
+ */
+static int xudc_ep0_disable(struct usb_ep *ep)
+{
+        return -EINVAL;
+}
+
+static const struct usb_ep_ops xusb_ep0_ops = {
+        .enable         = xudc_ep0_enable,
+        .disable        = xudc_ep0_disable,
+        .alloc_request  = xudc_ep_alloc_request,
+        .free_request   = xudc_free_request,
+        .queue          = xudc_ep0_queue,
+        .dequeue        = xudc_ep_dequeue,
+        .set_halt       = xudc_ep_set_halt,
+};
+
+static const struct usb_ep_ops xusb_ep_ops = {
+        .enable         = xudc_ep_enable,
+        .disable        = xudc_ep_disable,
+        .alloc_request  = xudc_ep_alloc_request,
+        .free_request   = xudc_free_request,
+        .queue          = xudc_ep_queue,
+        .dequeue        = xudc_ep_dequeue,
+        .set_halt       = xudc_ep_set_halt,
+};
+
+/**
+ * xudc_get_frame - Reads the current usb frame number.
+ * @gadget: pointer to the usb gadget structure.
+ *
+ * Return: current frame number for success and error value on failure.
+ */
+static int xudc_get_frame(struct usb_gadget *gadget)
+{
+        struct xusb_udc *udc;
+        int frame;
+
+        if (!gadget)
+                return -ENODEV;
+
+        udc = to_udc(gadget);
+        frame = udc->read_fn(udc->addr + XUSB_FRAMENUM_OFFSET);
+        return frame;
+}
+
+/**
+ * xudc_wakeup - Send remote wakeup signal to host
+ * @gadget: pointer to the usb gadget structure.
+ *
+ * Return: 0 on success and error on failure
+ */
+static int xudc_wakeup(struct usb_gadget *gadget)
+{
+        struct xusb_udc *udc = to_udc(gadget);
+        u32 crtlreg;
+        int status = -EINVAL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /* Remote wake up not enabled by host */
+        if (!udc->remote_wkp)
+                goto done;
+
+        crtlreg = udc->read_fn(udc->addr + XUSB_CONTROL_OFFSET);
+        crtlreg |= XUSB_CONTROL_USB_RMTWAKE_MASK;
+        /* set remote wake up bit */
+        udc->write_fn(udc->addr, XUSB_CONTROL_OFFSET, crtlreg);
+        /*
+         * wait for a while and reset remote wake up bit since this bit
+         * is not cleared by HW after sending remote wakeup to host.
+         */
+        mdelay(2);
+
+        crtlreg &= ~XUSB_CONTROL_USB_RMTWAKE_MASK;
+        udc->write_fn(udc->addr, XUSB_CONTROL_OFFSET, crtlreg);
+        status = 0;
+done:
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return status;
+}
+
+/**
+ * xudc_pullup - start/stop USB traffic
+ * @gadget: pointer to the usb gadget structure.
+ * @is_on: flag to start or stop
+ *
+ * Return: 0 always
+ *
+ * This function starts/stops SIE engine of IP based on is_on.
+ */
+static int xudc_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct xusb_udc *udc = to_udc(gadget);
+        unsigned long flags;
+        u32 crtlreg;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        crtlreg = udc->read_fn(udc->addr + XUSB_CONTROL_OFFSET);
+        if (is_on)
+                crtlreg |= XUSB_CONTROL_USB_READY_MASK;
+        else
+                crtlreg &= ~XUSB_CONTROL_USB_READY_MASK;
+
+        udc->write_fn(udc->addr, XUSB_CONTROL_OFFSET, crtlreg);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/**
+ * xudc_eps_init - initialize endpoints.
+ * @udc: pointer to the usb device controller structure.
+ */
+static void xudc_eps_init(struct xusb_udc *udc)
+{
+        u32 ep_number;
+
+        INIT_LIST_HEAD(&udc->gadget.ep_list);
+
+        for (ep_number = 0; ep_number < XUSB_MAX_ENDPOINTS; ep_number++) {
+                struct xusb_ep *ep = &udc->ep[ep_number];
+
+                if (ep_number) {
+                        list_add_tail(&ep->ep_usb.ep_list,
+                                      &udc->gadget.ep_list);
+                        usb_ep_set_maxpacket_limit(&ep->ep_usb,
+                                                  (unsigned short) ~0);
+                        snprintf(ep->name, EPNAME_SIZE, "ep%d", ep_number);
+                        ep->ep_usb.name = ep->name;
+                        ep->ep_usb.ops = &xusb_ep_ops;
+                } else {
+                        ep->ep_usb.name = ep0name;
+                        usb_ep_set_maxpacket_limit(&ep->ep_usb, EP0_MAX_PACKET);
+                        ep->ep_usb.ops = &xusb_ep0_ops;
+                }
+
+                ep->udc = udc;
+                ep->epnumber = ep_number;
+                ep->desc = NULL;
+                /*
+                 * The configuration register address offset between
+                 * each endpoint is 0x10.
+                 */
+                ep->offset = XUSB_EP0_CONFIG_OFFSET + (ep_number * 0x10);
+                ep->is_in = 0;
+                ep->is_iso = 0;
+                ep->maxpacket = 0;
+                xudc_epconfig(ep, udc);
+
+                /* Initialize one queue per endpoint */
+                INIT_LIST_HEAD(&ep->queue);
+        }
+}
+
+/**
+ * xudc_stop_activity - Stops any further activity on the device.
+ * @udc: pointer to the usb device controller structure.
+ */
+static void xudc_stop_activity(struct xusb_udc *udc)
+{
+        int i;
+        struct xusb_ep *ep;
+
+        for (i = 0; i < XUSB_MAX_ENDPOINTS; i++) {
+                ep = &udc->ep[i];
+                xudc_nuke(ep, -ESHUTDOWN);
+        }
+}
+
+/**
+ * xudc_start - Starts the device.
+ * @gadget: pointer to the usb gadget structure
+ * @driver: pointer to gadget driver structure
+ *
+ * Return: zero on success and error on failure
+ */
+static int xudc_start(struct usb_gadget *gadget,
+                      struct usb_gadget_driver *driver)
+{
+        struct xusb_udc *udc    = to_udc(gadget);
+        struct xusb_ep *ep0     = &udc->ep[XUSB_EP_NUMBER_ZERO];
+        const struct usb_endpoint_descriptor *desc = &config_bulk_out_desc;
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        if (udc->driver) {
+                dev_err(udc->dev, "%s is already bound to %s\n",
+                        udc->gadget.name, udc->driver->driver.name);
+                ret = -EBUSY;
+                goto err;
+        }
+
+        /* hook up the driver */
+        udc->driver = driver;
+        udc->gadget.speed = driver->max_speed;
+
+        /* Enable the control endpoint. */
+        ret = __xudc_ep_enable(ep0, desc);
+
+        /* Set device address and remote wakeup to 0 */
+        udc->write_fn(udc->addr, XUSB_ADDRESS_OFFSET, 0);
+        udc->remote_wkp = 0;
+err:
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return ret;
+}
+
+/**
+ * xudc_stop - stops the device.
+ * @gadget: pointer to the usb gadget structure
+ * @driver: pointer to usb gadget driver structure
+ *
+ * Return: zero always
+ */
+static int xudc_stop(struct usb_gadget *gadget,
+                     struct usb_gadget_driver *driver)
+{
+        struct xusb_udc *udc = to_udc(gadget);
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        udc->driver = NULL;
+
+        /* Set device address and remote wakeup to 0 */
+        udc->write_fn(udc->addr, XUSB_ADDRESS_OFFSET, 0);
+        udc->remote_wkp = 0;
+
+        xudc_stop_activity(udc);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static const struct usb_gadget_ops xusb_udc_ops = {
+        .get_frame      = xudc_get_frame,
+        .wakeup         = xudc_wakeup,
+        .pullup         = xudc_pullup,
+        .udc_start      = xudc_start,
+        .udc_stop       = xudc_stop,
+};
+
+/**
+ * xudc_clear_stall_all_ep - clears stall of every endpoint.
+ * @udc: pointer to the udc structure.
+ */
+static void xudc_clear_stall_all_ep(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep;
+        u32 epcfgreg;
+        int i;
+
+        for (i = 0; i < XUSB_MAX_ENDPOINTS; i++) {
+                ep = &udc->ep[i];
+                epcfgreg = udc->read_fn(udc->addr + ep->offset);
+                epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
+                udc->write_fn(udc->addr, ep->offset, epcfgreg);
+                if (ep->epnumber) {
+                        /* Reset the toggle bit.*/
+                        epcfgreg = udc->read_fn(udc->addr + ep->offset);
+                        epcfgreg &= ~XUSB_EP_CFG_DATA_TOGGLE_MASK;
+                        udc->write_fn(udc->addr, ep->offset, epcfgreg);
+                }
+        }
+}
+
+/**
+ * xudc_startup_handler - The usb device controller interrupt handler.
+ * @udc: pointer to the udc structure.
+ * @intrstatus: The mask value containing the interrupt sources.
+ *
+ * This function handles the RESET,SUSPEND,RESUME and DISCONNECT interrupts.
+ */
+static void xudc_startup_handler(struct xusb_udc *udc, u32 intrstatus)
+{
+        u32 intrreg;
+
+        if (intrstatus & XUSB_STATUS_RESET_MASK) {
+
+                dev_dbg(udc->dev, "Reset\n");
+
+                if (intrstatus & XUSB_STATUS_HIGH_SPEED_MASK)
+                        udc->gadget.speed = USB_SPEED_HIGH;
+                else
+                        udc->gadget.speed = USB_SPEED_FULL;
+
+                xudc_stop_activity(udc);
+                xudc_clear_stall_all_ep(udc);
+                udc->write_fn(udc->addr, XUSB_TESTMODE_OFFSET, 0);
+
+                /* Set device address and remote wakeup to 0 */
+                udc->write_fn(udc->addr, XUSB_ADDRESS_OFFSET, 0);
+                udc->remote_wkp = 0;
+
+                /* Enable the suspend, resume and disconnect */
+                intrreg = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+                intrreg |= XUSB_STATUS_SUSPEND_MASK | XUSB_STATUS_RESUME_MASK |
+                           XUSB_STATUS_DISCONNECT_MASK;
+                udc->write_fn(udc->addr, XUSB_IER_OFFSET, intrreg);
+        }
+        if (intrstatus & XUSB_STATUS_SUSPEND_MASK) {
+
+                dev_dbg(udc->dev, "Suspend\n");
+
+                /* Enable the reset, resume and disconnect */
+                intrreg = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+                intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_RESUME_MASK |
+                           XUSB_STATUS_DISCONNECT_MASK;
+                udc->write_fn(udc->addr, XUSB_IER_OFFSET, intrreg);
+
+                udc->usb_state = USB_STATE_SUSPENDED;
+
+                if (udc->driver->suspend) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->suspend(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+        if (intrstatus & XUSB_STATUS_RESUME_MASK) {
+                bool condition = (udc->usb_state != USB_STATE_SUSPENDED);
+
+                dev_WARN_ONCE(udc->dev, condition,
+                                "Resume IRQ while not suspended\n");
+
+                dev_dbg(udc->dev, "Resume\n");
+
+                /* Enable the reset, suspend and disconnect */
+                intrreg = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+                intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_SUSPEND_MASK |
+                           XUSB_STATUS_DISCONNECT_MASK;
+                udc->write_fn(udc->addr, XUSB_IER_OFFSET, intrreg);
+
+                udc->usb_state = 0;
+
+                if (udc->driver->resume) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->resume(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+        if (intrstatus & XUSB_STATUS_DISCONNECT_MASK) {
+
+                dev_dbg(udc->dev, "Disconnect\n");
+
+                /* Enable the reset, resume and suspend */
+                intrreg = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+                intrreg |= XUSB_STATUS_RESET_MASK | XUSB_STATUS_RESUME_MASK |
+                           XUSB_STATUS_SUSPEND_MASK;
+                udc->write_fn(udc->addr, XUSB_IER_OFFSET, intrreg);
+
+                if (udc->driver && udc->driver->disconnect) {
+                        spin_unlock(&udc->lock);
+                        udc->driver->disconnect(&udc->gadget);
+                        spin_lock(&udc->lock);
+                }
+        }
+}
+
+/**
+ * xudc_ep0_stall - Stall endpoint zero.
+ * @udc: pointer to the udc structure.
+ *
+ * This function stalls endpoint zero.
+ */
+static void xudc_ep0_stall(struct xusb_udc *udc)
+{
+        u32 epcfgreg;
+        struct xusb_ep *ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO];
+
+        epcfgreg = udc->read_fn(udc->addr + ep0->offset);
+        epcfgreg |= XUSB_EP_CFG_STALL_MASK;
+        udc->write_fn(udc->addr, ep0->offset, epcfgreg);
+}
+
+/**
+ * xudc_setaddress - executes SET_ADDRESS command
+ * @udc: pointer to the udc structure.
+ *
+ * This function executes USB SET_ADDRESS command
+ */
+static void xudc_setaddress(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0     = &udc->ep[0];
+        struct xusb_req *req    = udc->req;
+        int ret;
+
+        req->usb_req.length = 0;
+        ret = __xudc_ep0_queue(ep0, req);
+        if (ret == 0)
+                return;
+
+        dev_err(udc->dev, "Can't respond to SET ADDRESS request\n");
+        xudc_ep0_stall(udc);
+}
+
+/**
+ * xudc_getstatus - executes GET_STATUS command
+ * @udc: pointer to the udc structure.
+ *
+ * This function executes USB GET_STATUS command
+ */
+static void xudc_getstatus(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0     = &udc->ep[0];
+        struct xusb_req *req    = udc->req;
+        struct xusb_ep *target_ep;
+        u16 status = 0;
+        u32 epcfgreg;
+        int epnum;
+        u32 halt;
+        int ret;
+
+        switch (udc->setup.bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                /* Get device status */
+                status = 1 << USB_DEVICE_SELF_POWERED;
+                if (udc->remote_wkp)
+                        status |= (1 << USB_DEVICE_REMOTE_WAKEUP);
+                break;
+        case USB_RECIP_INTERFACE:
+                break;
+        case USB_RECIP_ENDPOINT:
+                epnum = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
+                target_ep = &udc->ep[epnum];
+                epcfgreg = udc->read_fn(udc->addr + target_ep->offset);
+                halt = epcfgreg & XUSB_EP_CFG_STALL_MASK;
+                if (udc->setup.wIndex & USB_DIR_IN) {
+                        if (!target_ep->is_in)
+                                goto stall;
+                } else {
+                        if (target_ep->is_in)
+                                goto stall;
+                }
+                if (halt)
+                        status = 1 << USB_ENDPOINT_HALT;
+                break;
+        default:
+                goto stall;
+        }
+
+        req->usb_req.length = 2;
+        *(u16 *)req->usb_req.buf = cpu_to_le16(status);
+        ret = __xudc_ep0_queue(ep0, req);
+        if (ret == 0)
+                return;
+stall:
+        dev_err(udc->dev, "Can't respond to getstatus request\n");
+        xudc_ep0_stall(udc);
+}
+
+/**
+ * xudc_set_clear_feature - Executes the set feature and clear feature commands.
+ * @udc: pointer to the usb device controller structure.
+ *
+ * Processes the SET_FEATURE and CLEAR_FEATURE commands.
+ */
+static void xudc_set_clear_feature(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0     = &udc->ep[0];
+        struct xusb_req *req    = udc->req;
+        struct xusb_ep *target_ep;
+        u8 endpoint;
+        u8 outinbit;
+        u32 epcfgreg;
+        int flag = (udc->setup.bRequest == USB_REQ_SET_FEATURE ? 1 : 0);
+        int ret;
+
+        switch (udc->setup.bRequestType) {
+        case USB_RECIP_DEVICE:
+                switch (udc->setup.wValue) {
+                case USB_DEVICE_TEST_MODE:
+                        /*
+                         * The Test Mode will be executed
+                         * after the status phase.
+                         */
+                        break;
+                case USB_DEVICE_REMOTE_WAKEUP:
+                        if (flag)
+                                udc->remote_wkp = 1;
+                        else
+                                udc->remote_wkp = 0;
+                        break;
+                default:
+                        xudc_ep0_stall(udc);
+                        break;
+                }
+                break;
+        case USB_RECIP_ENDPOINT:
+                if (!udc->setup.wValue) {
+                        endpoint = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
+                        target_ep = &udc->ep[endpoint];
+                        outinbit = udc->setup.wIndex & USB_ENDPOINT_DIR_MASK;
+                        outinbit = outinbit >> 7;
+
+                        /* Make sure direction matches.*/
+                        if (outinbit != target_ep->is_in) {
+                                xudc_ep0_stall(udc);
+                                return;
+                        }
+                        epcfgreg = udc->read_fn(udc->addr + target_ep->offset);
+                        if (!endpoint) {
+                                /* Clear the stall.*/
+                                epcfgreg &= ~XUSB_EP_CFG_STALL_MASK;
+                                udc->write_fn(udc->addr,
+                                              target_ep->offset, epcfgreg);
+                        } else {
+                                if (flag) {
+                                        epcfgreg |= XUSB_EP_CFG_STALL_MASK;
+                                        udc->write_fn(udc->addr,
+                                                      target_ep->offset,
+                                                      epcfgreg);
+                                } else {
+                                        /* Unstall the endpoint.*/
+                                        epcfgreg &= ~(XUSB_EP_CFG_STALL_MASK |
+                                                XUSB_EP_CFG_DATA_TOGGLE_MASK);
+                                        udc->write_fn(udc->addr,
+                                                      target_ep->offset,
+                                                      epcfgreg);
+                                }
+                        }
+                }
+                break;
+        default:
+                xudc_ep0_stall(udc);
+                return;
+        }
+
+        req->usb_req.length = 0;
+        ret = __xudc_ep0_queue(ep0, req);
+        if (ret == 0)
+                return;
+
+        dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n");
+        xudc_ep0_stall(udc);
+}
+
+/**
+ * xudc_handle_setup - Processes the setup packet.
+ * @udc: pointer to the usb device controller structure.
+ *
+ * Process setup packet and delegate to gadget layer.
+ */
+static void xudc_handle_setup(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0 = &udc->ep[0];
+        struct usb_ctrlrequest setup;
+        u32 *ep0rambase;
+
+        /* Load up the chapter 9 command buffer.*/
+        ep0rambase = (u32 __force *) (udc->addr + XUSB_SETUP_PKT_ADDR_OFFSET);
+        memcpy(&setup, ep0rambase, 8);
+
+        udc->setup = setup;
+        udc->setup.wValue = cpu_to_le16(setup.wValue);
+        udc->setup.wIndex = cpu_to_le16(setup.wIndex);
+        udc->setup.wLength = cpu_to_le16(setup.wLength);
+
+        /* Clear previous requests */
+        xudc_nuke(ep0, -ECONNRESET);
+
+        if (udc->setup.bRequestType & USB_DIR_IN) {
+                /* Execute the get command.*/
+                udc->setupseqrx = STATUS_PHASE;
+                udc->setupseqtx = DATA_PHASE;
+        } else {
+                /* Execute the put command.*/
+                udc->setupseqrx = DATA_PHASE;
+                udc->setupseqtx = STATUS_PHASE;
+        }
+
+        switch (udc->setup.bRequest) {
+        case USB_REQ_GET_STATUS:
+                /* Data+Status phase form udc */
+                if ((udc->setup.bRequestType &
+                                (USB_DIR_IN | USB_TYPE_MASK)) !=
+                                (USB_DIR_IN | USB_TYPE_STANDARD))
+                        break;
+                xudc_getstatus(udc);
+                return;
+        case USB_REQ_SET_ADDRESS:
+                /* Status phase from udc */
+                if (udc->setup.bRequestType != (USB_DIR_OUT |
+                                USB_TYPE_STANDARD | USB_RECIP_DEVICE))
+                        break;
+                xudc_setaddress(udc);
+                return;
+        case USB_REQ_CLEAR_FEATURE:
+        case USB_REQ_SET_FEATURE:
+                /* Requests with no data phase, status phase from udc */
+                if ((udc->setup.bRequestType & USB_TYPE_MASK)
+                                != USB_TYPE_STANDARD)
+                        break;
+                xudc_set_clear_feature(udc);
+                return;
+        default:
+                break;
+        }
+
+        spin_unlock(&udc->lock);
+        if (udc->driver->setup(&udc->gadget, &setup) < 0)
+                xudc_ep0_stall(udc);
+        spin_lock(&udc->lock);
+}
+
+/**
+ * xudc_ep0_out - Processes the endpoint 0 OUT token.
+ * @udc: pointer to the usb device controller structure.
+ */
+static void xudc_ep0_out(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0 = &udc->ep[0];
+        struct xusb_req *req;
+        u8 *ep0rambase;
+        unsigned int bytes_to_rx;
+        void *buffer;
+
+        req = list_first_entry(&ep0->queue, struct xusb_req, queue);
+
+        switch (udc->setupseqrx) {
+        case STATUS_PHASE:
+                /*
+                 * This resets both state machines for the next
+                 * Setup packet.
+                 */
+                udc->setupseqrx = SETUP_PHASE;
+                udc->setupseqtx = SETUP_PHASE;
+                req->usb_req.actual = req->usb_req.length;
+                xudc_done(ep0, req, 0);
+                break;
+        case DATA_PHASE:
+                bytes_to_rx = udc->read_fn(udc->addr +
+                                           XUSB_EP_BUF0COUNT_OFFSET);
+                /* Copy the data to be received from the DPRAM. */
+                ep0rambase = (u8 __force *) (udc->addr +
+                             (ep0->rambase << 2));
+                buffer = req->usb_req.buf + req->usb_req.actual;
+                req->usb_req.actual = req->usb_req.actual + bytes_to_rx;
+                memcpy(buffer, ep0rambase, bytes_to_rx);
+
+                if (req->usb_req.length == req->usb_req.actual) {
+                        /* Data transfer completed get ready for Status stage */
+                        xudc_wrstatus(udc);
+                } else {
+                        /* Enable EP0 buffer to receive data */
+                        udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, 0);
+                        udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+/**
+ * xudc_ep0_in - Processes the endpoint 0 IN token.
+ * @udc: pointer to the usb device controller structure.
+ */
+static void xudc_ep0_in(struct xusb_udc *udc)
+{
+        struct xusb_ep *ep0 = &udc->ep[0];
+        struct xusb_req *req;
+        unsigned int bytes_to_tx;
+        void *buffer;
+        u32 epcfgreg;
+        u16 count = 0;
+        u16 length;
+        u8 *ep0rambase;
+        u8 test_mode = udc->setup.wIndex >> 8;
+
+        req = list_first_entry(&ep0->queue, struct xusb_req, queue);
+        bytes_to_tx = req->usb_req.length - req->usb_req.actual;
+
+        switch (udc->setupseqtx) {
+        case STATUS_PHASE:
+                switch (udc->setup.bRequest) {
+                case USB_REQ_SET_ADDRESS:
+                        /* Set the address of the device.*/
+                        udc->write_fn(udc->addr, XUSB_ADDRESS_OFFSET,
+                                      udc->setup.wValue);
+                        break;
+                case USB_REQ_SET_FEATURE:
+                        if (udc->setup.bRequestType ==
+                                        USB_RECIP_DEVICE) {
+                                if (udc->setup.wValue ==
+                                                USB_DEVICE_TEST_MODE)
+                                        udc->write_fn(udc->addr,
+                                                      XUSB_TESTMODE_OFFSET,
+                                                      test_mode);
+                        }
+                        break;
+                }
+                req->usb_req.actual = req->usb_req.length;
+                xudc_done(ep0, req, 0);
+                break;
+        case DATA_PHASE:
+                if (!bytes_to_tx) {
+                        /*
+                         * We're done with data transfer, next
+                         * will be zero length OUT with data toggle of
+                         * 1. Setup data_toggle.
+                         */
+                        epcfgreg = udc->read_fn(udc->addr + ep0->offset);
+                        epcfgreg |= XUSB_EP_CFG_DATA_TOGGLE_MASK;
+                        udc->write_fn(udc->addr, ep0->offset, epcfgreg);
+                        udc->setupseqtx = STATUS_PHASE;
+                } else {
+                        length = count = min_t(u32, bytes_to_tx,
+                                               EP0_MAX_PACKET);
+                        /* Copy the data to be transmitted into the DPRAM. */
+                        ep0rambase = (u8 __force *) (udc->addr +
+                                     (ep0->rambase << 2));
+                        buffer = req->usb_req.buf + req->usb_req.actual;
+                        req->usb_req.actual = req->usb_req.actual + length;
+                        memcpy(ep0rambase, buffer, length);
+                }
+                udc->write_fn(udc->addr, XUSB_EP_BUF0COUNT_OFFSET, count);
+                udc->write_fn(udc->addr, XUSB_BUFFREADY_OFFSET, 1);
+                break;
+        default:
+                break;
+        }
+}
+
+/**
+ * xudc_ctrl_ep_handler - Endpoint 0 interrupt handler.
+ * @udc: pointer to the udc structure.
+ * @intrstatus: It's the mask value for the interrupt sources on endpoint 0.
+ *
+ * Processes the commands received during enumeration phase.
+ */
+static void xudc_ctrl_ep_handler(struct xusb_udc *udc, u32 intrstatus)
+{
+
+        if (intrstatus & XUSB_STATUS_SETUP_PACKET_MASK) {
+                xudc_handle_setup(udc);
+        } else {
+                if (intrstatus & XUSB_STATUS_FIFO_BUFF_RDY_MASK)
+                        xudc_ep0_out(udc);
+                else if (intrstatus & XUSB_STATUS_FIFO_BUFF_FREE_MASK)
+                        xudc_ep0_in(udc);
+        }
+}
+
+/**
+ * xudc_nonctrl_ep_handler - Non control endpoint interrupt handler.
+ * @udc: pointer to the udc structure.
+ * @epnum: End point number for which the interrupt is to be processed
+ * @intrstatus: mask value for interrupt sources of endpoints other
+ *              than endpoint 0.
+ *
+ * Processes the buffer completion interrupts.
+ */
+static void xudc_nonctrl_ep_handler(struct xusb_udc *udc, u8 epnum,
+                                    u32 intrstatus)
+{
+
+        struct xusb_req *req;
+        struct xusb_ep *ep;
+
+        ep = &udc->ep[epnum];
+        /* Process the End point interrupts.*/
+        if (intrstatus & (XUSB_STATUS_EP0_BUFF1_COMP_MASK << epnum))
+                ep->buffer0ready = 0;
+        if (intrstatus & (XUSB_STATUS_EP0_BUFF2_COMP_MASK << epnum))
+                ep->buffer1ready = 0;
+
+        if (list_empty(&ep->queue))
+                return;
+
+        req = list_first_entry(&ep->queue, struct xusb_req, queue);
+
+        if (ep->is_in)
+                xudc_write_fifo(ep, req);
+        else
+                xudc_read_fifo(ep, req);
+}
+
+/**
+ * xudc_irq - The main interrupt handler.
+ * @irq: The interrupt number.
+ * @_udc: pointer to the usb device controller structure.
+ *
+ * Return: IRQ_HANDLED after the interrupt is handled.
+ */
+static irqreturn_t xudc_irq(int irq, void *_udc)
+{
+        struct xusb_udc *udc = _udc;
+        u32 intrstatus;
+        u32 ier;
+        u8 index;
+        u32 bufintr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        /*
+         * Event interrupts are level sensitive hence first disable
+         * IER, read ISR and figure out active interrupts.
+         */
+        ier = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+        ier &= ~XUSB_STATUS_INTR_EVENT_MASK;
+        udc->write_fn(udc->addr, XUSB_IER_OFFSET, ier);
+
+        /* Read the Interrupt Status Register.*/
+        intrstatus = udc->read_fn(udc->addr + XUSB_STATUS_OFFSET);
+
+        /* Call the handler for the event interrupt.*/
+        if (intrstatus & XUSB_STATUS_INTR_EVENT_MASK) {
+                /*
+                 * Check if there is any action to be done for :
+                 * - USB Reset received {XUSB_STATUS_RESET_MASK}
+                 * - USB Suspend received {XUSB_STATUS_SUSPEND_MASK}
+                 * - USB Resume received {XUSB_STATUS_RESUME_MASK}
+                 * - USB Disconnect received {XUSB_STATUS_DISCONNECT_MASK}
+                 */
+                xudc_startup_handler(udc, intrstatus);
+        }
+
+        /* Check the buffer completion interrupts */
+        if (intrstatus & XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK) {
+                /* Enable Reset, Suspend, Resume and Disconnect  */
+                ier = udc->read_fn(udc->addr + XUSB_IER_OFFSET);
+                ier |= XUSB_STATUS_INTR_EVENT_MASK;
+                udc->write_fn(udc->addr, XUSB_IER_OFFSET, ier);
+
+                if (intrstatus & XUSB_STATUS_EP0_BUFF1_COMP_MASK)
+                        xudc_ctrl_ep_handler(udc, intrstatus);
+
+                for (index = 1; index < 8; index++) {
+                        bufintr = ((intrstatus &
+                                  (XUSB_STATUS_EP1_BUFF1_COMP_MASK <<
+                                  (index - 1))) || (intrstatus &
+                                  (XUSB_STATUS_EP1_BUFF2_COMP_MASK <<
+                                  (index - 1))));
+                        if (bufintr) {
+                                xudc_nonctrl_ep_handler(udc, index,
+                                                        intrstatus);
+                        }
+                }
+        }
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return IRQ_HANDLED;
+}
+
+/**
+ * xudc_probe - The device probe function for driver initialization.
+ * @pdev: pointer to the platform device structure.
+ *
+ * Return: 0 for success and error value on failure
+ */
+static int xudc_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct resource *res;
+        struct xusb_udc *udc;
+        struct xusb_ep *ep0;
+        int irq;
+        int ret;
+        u32 ier;
+        u8 *buff;
+
+        udc = devm_kzalloc(&pdev->dev, sizeof(*udc), GFP_KERNEL);
+        if (!udc)
+                return -ENOMEM;
+
+        /* Create a dummy request for GET_STATUS, SET_ADDRESS */
+        udc->req = devm_kzalloc(&pdev->dev, sizeof(struct xusb_req),
+                                GFP_KERNEL);
+        if (!udc->req)
+                return -ENOMEM;
+
+        buff = devm_kzalloc(&pdev->dev, STATUSBUFF_SIZE, GFP_KERNEL);
+        if (!buff)
+                return -ENOMEM;
+
+        udc->req->usb_req.buf = buff;
+
+        /* Map the registers */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        udc->addr = devm_ioremap_resource(&pdev->dev, res);
+        if (!udc->addr)
+                return -ENOMEM;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "unable to get irq\n");
+                return irq;
+        }
+        ret = devm_request_irq(&pdev->dev, irq, xudc_irq, 0,
+                               dev_name(&pdev->dev), udc);
+        if (ret < 0) {
+                dev_dbg(&pdev->dev, "unable to request irq %d", irq);
+                goto fail;
+        }
+
+        udc->dma_enabled = of_property_read_bool(np, "xlnx,has-builtin-dma");
+
+        /* Setup gadget structure */
+        udc->gadget.ops = &xusb_udc_ops;
+        udc->gadget.max_speed = USB_SPEED_HIGH;
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        udc->gadget.ep0 = &udc->ep[XUSB_EP_NUMBER_ZERO].ep_usb;
+        udc->gadget.name = driver_name;
+
+        spin_lock_init(&udc->lock);
+
+        /* Check for IP endianness */
+        udc->write_fn = xudc_write32_be;
+        udc->read_fn = xudc_read32_be;
+        udc->write_fn(udc->addr, XUSB_TESTMODE_OFFSET, TEST_J);
+        if ((udc->read_fn(udc->addr + XUSB_TESTMODE_OFFSET))
+                        != TEST_J) {
+                udc->write_fn = xudc_write32;
+                udc->read_fn = xudc_read32;
+        }
+        udc->write_fn(udc->addr, XUSB_TESTMODE_OFFSET, 0);
+
+        xudc_eps_init(udc);
+
+        ep0 = &udc->ep[0];
+
+        /* Set device address to 0.*/
+        udc->write_fn(udc->addr, XUSB_ADDRESS_OFFSET, 0);
+
+        ret = usb_add_gadget_udc(&pdev->dev, &udc->gadget);
+        if (ret)
+                goto fail;
+
+        udc->dev = &udc->gadget.dev;
+
+        /* Enable the interrupts.*/
+        ier = XUSB_STATUS_GLOBAL_INTR_MASK | XUSB_STATUS_INTR_EVENT_MASK |
+              XUSB_STATUS_FIFO_BUFF_RDY_MASK | XUSB_STATUS_FIFO_BUFF_FREE_MASK |
+              XUSB_STATUS_SETUP_PACKET_MASK |
+              XUSB_STATUS_INTR_BUFF_COMP_ALL_MASK;
+
+        udc->write_fn(udc->addr, XUSB_IER_OFFSET, ier);
+
+        platform_set_drvdata(pdev, udc);
+
+        dev_vdbg(&pdev->dev, "%s at 0x%08X mapped to 0x%08X %s\n",
+                 driver_name, (u32)res->start, (u32 __force)udc->addr,
+                 udc->dma_enabled ? "with DMA" : "without DMA");
+
+        return 0;
+fail:
+        dev_err(&pdev->dev, "probe failed, %d\n", ret);
+        return ret;
+}
+
+/**
+ * xudc_remove - Releases the resources allocated during the initialization.
+ * @pdev: pointer to the platform device structure.
+ *
+ * Return: 0 always
+ */
+static int xudc_remove(struct platform_device *pdev)
+{
+        struct xusb_udc *udc = platform_get_drvdata(pdev);
+
+        usb_del_gadget_udc(&udc->gadget);
+
+        return 0;
+}
+
+/* Match table for of_platform binding */
+static const struct of_device_id usb_of_match[] = {
+        { .compatible = "xlnx,usb2-device-4.00.a", },
+        { /* end of list */ },
+};
+MODULE_DEVICE_TABLE(of, usb_of_match);
+
+static struct platform_driver xudc_driver = {
+        .driver = {
+                .name = driver_name,
+                .of_match_table = usb_of_match,
+        },
+        .probe = xudc_probe,
+        .remove = xudc_remove,
+};
+
+module_platform_driver(xudc_driver);
+
+MODULE_DESCRIPTION("Xilinx udc driver");
+MODULE_AUTHOR("Xilinx, Inc");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 82800a775501..a8a30b1d4167 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -26,6 +26,11 @@ config USB_XHCI_HCD
 
 if USB_XHCI_HCD
 
+config USB_XHCI_PCI
+       tristate
+       depends on PCI
+       default y
+
 config USB_XHCI_PLATFORM
         tristate
 
@@ -126,7 +131,7 @@ config XPS_USB_HCD_XILINX
         select USB_EHCI_BIG_ENDIAN_DESC
         select USB_EHCI_BIG_ENDIAN_MMIO
         ---help---
-                Xilinx xps USB host controller core is EHCI compilant and has
+                Xilinx xps USB host controller core is EHCI compliant and has
                 transaction translator built-in. It can be configured to either
                 support both high speed and full speed devices, or high speed
                 devices only.
@@ -174,6 +179,15 @@ config USB_EHCI_HCD_SPEAR
           Enables support for the on-chip EHCI controller on
           ST SPEAr chips.
 
+config USB_EHCI_HCD_STI
+        tristate "Support for ST STiHxxx on-chip EHCI USB controller"
+        depends on ARCH_STI && OF
+        select GENERIC_PHY
+        select USB_EHCI_HCD_PLATFORM
+        help
+          Enable support for the on-chip EHCI controller found on
+          STMicroelectronics consumer electronics SoC's.
+
 config USB_EHCI_HCD_AT91
         tristate  "Support for Atmel on-chip EHCI USB controller"
         depends on USB_EHCI_HCD && ARCH_AT91
@@ -402,6 +416,15 @@ config USB_OHCI_HCD_SPEAR
           Enables support for the on-chip OHCI controller on
           ST SPEAr chips.
 
+config USB_OHCI_HCD_STI
+        tristate "Support for ST STiHxxx on-chip OHCI USB controller"
+        depends on ARCH_STI && OF
+        select GENERIC_PHY
+        select USB_OHCI_HCD_PLATFORM
+        help
+          Enable support for the on-chip OHCI controller found on
+          STMicroelectronics consumer electronics SoC's.
+
 config USB_OHCI_HCD_S3C2410
         tristate "OHCI support for Samsung S3C24xx/S3C64xx SoC series"
         depends on USB_OHCI_HCD && (ARCH_S3C24XX || ARCH_S3C64XX)
@@ -709,7 +732,7 @@ config USB_WHCI_HCD
 
 config USB_HWA_HCD
         tristate "Host Wire Adapter (HWA) driver"
-        depends on UWB
+        depends on USB && UWB
         select USB_WUSB
         select UWB_HWA
         help
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 144c038ef70f..348c24321562 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -15,22 +15,22 @@ fhci-$(CONFIG_FHCI_DEBUG) += fhci-dbg.o
 xhci-hcd-y := xhci.o xhci-mem.o
 xhci-hcd-y += xhci-ring.o xhci-hub.o xhci-dbg.o
 xhci-hcd-y += xhci-trace.o
-xhci-hcd-$(CONFIG_PCI)  += xhci-pci.o
 
-ifneq ($(CONFIG_USB_XHCI_PLATFORM), )
-        xhci-hcd-y              += xhci-plat.o
+xhci-plat-hcd-y := xhci-plat.o
 ifneq ($(CONFIG_USB_XHCI_MVEBU), )
-        xhci-hcd-y              += xhci-mvebu.o
+        xhci-plat-hcd-y         += xhci-mvebu.o
 endif
 ifneq ($(CONFIG_USB_XHCI_RCAR), )
-        xhci-hcd-y              += xhci-rcar.o
-endif
+        xhci-plat-hcd-y         += xhci-rcar.o
 endif
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
 
 obj-$(CONFIG_PCI)               += pci-quirks.o
 
+obj-$(CONFIG_USB_XHCI_PCI)      += xhci-pci.o
+obj-$(CONFIG_USB_XHCI_PLATFORM) += xhci-plat-hcd.o
+
 obj-$(CONFIG_USB_EHCI_HCD)      += ehci-hcd.o
 obj-$(CONFIG_USB_EHCI_PCI)      += ehci-pci.o
 obj-$(CONFIG_USB_EHCI_HCD_PLATFORM)     += ehci-platform.o
@@ -38,6 +38,7 @@ 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_HCD_STI)  += ehci-st.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
@@ -55,6 +56,7 @@ 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_STI)  += ohci-st.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
diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index cda0a2f5c467..7189f2e32ac2 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -21,11 +21,8 @@
 #include <linux/of_gpio.h>
 #include <linux/phy/phy.h>
 #include <linux/platform_device.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 "ehci.h"
 
@@ -47,9 +44,7 @@ static struct hc_driver __read_mostly exynos_ehci_hc_driver;
 
 struct exynos_ehci_hcd {
         struct clk *clk;
-        struct usb_phy *phy;
-        struct usb_otg *otg;
-        struct phy *phy_g[PHY_NUMBER];
+        struct phy *phy[PHY_NUMBER];
 };
 
 #define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
@@ -60,20 +55,9 @@ static int exynos_ehci_get_phy(struct device *dev,
         struct device_node *child;
         struct phy *phy;
         int phy_number;
-        int ret = 0;
-
-        exynos_ehci->phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(exynos_ehci->phy)) {
-                ret = PTR_ERR(exynos_ehci->phy);
-                if (ret != -ENXIO && ret != -ENODEV) {
-                        dev_err(dev, "no usb2 phy configured\n");
-                        return ret;
-                }
-                dev_dbg(dev, "Failed to get usb2 phy\n");
-        } else {
-                exynos_ehci->otg = exynos_ehci->phy->otg;
-        }
+        int ret;
 
+        /* Get PHYs for the controller */
         for_each_available_child_of_node(dev->of_node, child) {
                 ret = of_property_read_u32(child, "reg", &phy_number);
                 if (ret) {
@@ -89,19 +73,21 @@ static int exynos_ehci_get_phy(struct device *dev,
                 }
 
                 phy = devm_of_phy_get(dev, child, NULL);
+                exynos_ehci->phy[phy_number] = phy;
                 of_node_put(child);
                 if (IS_ERR(phy)) {
                         ret = PTR_ERR(phy);
-                        if (ret != -ENOSYS && ret != -ENODEV) {
-                                dev_err(dev, "no usb2 phy configured\n");
+                        if (ret == -EPROBE_DEFER) {
+                                return ret;
+                        } else if (ret != -ENOSYS && ret != -ENODEV) {
+                                dev_err(dev,
+                                        "Error retrieving usb2 phy: %d\n", ret);
                                 return ret;
                         }
-                        dev_dbg(dev, "Failed to get usb2 phy\n");
                 }
-                exynos_ehci->phy_g[phy_number] = phy;
         }
 
-        return ret;
+        return 0;
 }
 
 static int exynos_ehci_phy_enable(struct device *dev)
@@ -111,16 +97,13 @@ static int exynos_ehci_phy_enable(struct device *dev)
         int i;
         int ret = 0;
 
-        if (!IS_ERR(exynos_ehci->phy))
-                return usb_phy_init(exynos_ehci->phy);
-
         for (i = 0; ret == 0 && i < PHY_NUMBER; i++)
-                if (!IS_ERR(exynos_ehci->phy_g[i]))
-                        ret = phy_power_on(exynos_ehci->phy_g[i]);
+                if (!IS_ERR(exynos_ehci->phy[i]))
+                        ret = phy_power_on(exynos_ehci->phy[i]);
         if (ret)
                 for (i--; i >= 0; i--)
-                        if (!IS_ERR(exynos_ehci->phy_g[i]))
-                                phy_power_off(exynos_ehci->phy_g[i]);
+                        if (!IS_ERR(exynos_ehci->phy[i]))
+                                phy_power_off(exynos_ehci->phy[i]);
 
         return ret;
 }
@@ -131,14 +114,9 @@ static void exynos_ehci_phy_disable(struct device *dev)
         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
         int i;
 
-        if (!IS_ERR(exynos_ehci->phy)) {
-                usb_phy_shutdown(exynos_ehci->phy);
-                return;
-        }
-
         for (i = 0; i < PHY_NUMBER; i++)
-                if (!IS_ERR(exynos_ehci->phy_g[i]))
-                        phy_power_off(exynos_ehci->phy_g[i]);
+                if (!IS_ERR(exynos_ehci->phy[i]))
+                        phy_power_off(exynos_ehci->phy[i]);
 }
 
 static void exynos_setup_vbus_gpio(struct device *dev)
@@ -231,9 +209,6 @@ skip_phy:
                 goto fail_io;
         }
 
-        if (exynos_ehci->otg)
-                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
-
         err = exynos_ehci_phy_enable(&pdev->dev);
         if (err) {
                 dev_err(&pdev->dev, "Failed to enable USB phy\n");
@@ -273,9 +248,6 @@ static int exynos_ehci_remove(struct platform_device *pdev)
 
         usb_remove_hcd(hcd);
 
-        if (exynos_ehci->otg)
-                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
-
         exynos_ehci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
@@ -298,9 +270,6 @@ static int exynos_ehci_suspend(struct device *dev)
         if (rc)
                 return rc;
 
-        if (exynos_ehci->otg)
-                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
-
         exynos_ehci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
@@ -316,9 +285,6 @@ static int exynos_ehci_resume(struct device *dev)
 
         clk_prepare_enable(exynos_ehci->clk);
 
-        if (exynos_ehci->otg)
-                exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
-
         ret = exynos_ehci_phy_enable(dev);
         if (ret) {
                 dev_err(dev, "Failed to enable USB phy\n");
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index cf2734b532a7..2d2ae8db439e 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -136,15 +136,15 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         if (pdata->operating_mode == FSL_USB2_DR_OTG) {
                 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
 
-                hcd->phy = usb_get_phy(USB_PHY_TYPE_USB2);
+                hcd->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
                 dev_dbg(&pdev->dev, "hcd=0x%p  ehci=0x%p, phy=0x%p\n",
-                        hcd, ehci, hcd->phy);
+                        hcd, ehci, hcd->usb_phy);
 
-                if (!IS_ERR_OR_NULL(hcd->phy)) {
-                        retval = otg_set_host(hcd->phy->otg,
+                if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
+                        retval = otg_set_host(hcd->usb_phy->otg,
                                               &ehci_to_hcd(ehci)->self);
                         if (retval) {
-                                usb_put_phy(hcd->phy);
+                                usb_put_phy(hcd->usb_phy);
                                 goto err2;
                         }
                 } else {
@@ -181,9 +181,9 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
 {
         struct fsl_usb2_platform_data *pdata = dev_get_platdata(&pdev->dev);
 
-        if (!IS_ERR_OR_NULL(hcd->phy)) {
-                otg_set_host(hcd->phy->otg, NULL);
-                usb_put_phy(hcd->phy);
+        if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
+                otg_set_host(hcd->usb_phy->otg, NULL);
+                usb_put_phy(hcd->usb_phy);
         }
 
         usb_remove_hcd(hcd);
@@ -627,7 +627,7 @@ static int ehci_start_port_reset(struct usb_hcd *hcd, unsigned port)
         if (!(status & PORT_CONNECT))
                 return -ENODEV;
 
-        /* khubd will finish the reset later */
+        /* hub_wq will finish the reset later */
         if (ehci_is_TDI(ehci)) {
                 writel(PORT_RESET |
                        (status & ~(PORT_CSC | PORT_PEC | PORT_OCC)),
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 488a30836c36..15feaf924b71 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -788,7 +788,7 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                                 continue;
 
                         /* start 20 msec resume signaling from this port,
-                         * and make khubd collect PORT_STAT_C_SUSPEND to
+                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.  Use 5 ms extra for safety,
                          * like usb_port_resume() does.
                          */
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 6130b7574908..5728829cf6ef 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -656,7 +656,7 @@ ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
 
                 /*
                  * Return status information even for ports with OWNER set.
-                 * Otherwise khubd wouldn't see the disconnect event when a
+                 * Otherwise hub_wq wouldn't see the disconnect event when a
                  * high-speed device is switched over to the companion
                  * controller by the user.
                  */
@@ -902,7 +902,7 @@ int ehci_hub_control(
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
-                 * companion controller, khubd needs to be able to clear
+                 * companion controller, hub_wq needs to be able to clear
                  * the port-change status bits (especially
                  * USB_PORT_STAT_C_CONNECTION).
                  */
@@ -922,7 +922,7 @@ int ehci_hub_control(
 #ifdef CONFIG_USB_OTG
                         if ((hcd->self.otg_port == (wIndex + 1))
                             && hcd->self.b_hnp_enable) {
-                                otg_start_hnp(hcd->phy->otg);
+                                otg_start_hnp(hcd->usb_phy->otg);
                                 break;
                         }
 #endif
@@ -1000,7 +1000,7 @@ int ehci_hub_control(
                          * However, not all EHCI implementations do this
                          * automatically, even if they _do_ support per-port
                          * power switching; they're allowed to just limit the
-                         * current.  khubd will turn the power back on.
+                         * current.  hub_wq will turn the power back on.
                          */
                         if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle))
                                         && HCS_PPC(ehci->hcs_params)) {
@@ -1085,7 +1085,7 @@ int ehci_hub_control(
                 }
 
                 /*
-                 * Even if OWNER is set, there's no harm letting khubd
+                 * Even if OWNER is set, there's no harm letting hub_wq
                  * see the wPortStatus values (they should all be 0 except
                  * for PORT_POWER anyway).
                  */
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index 934b39d5e44a..9dc2118ae808 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -124,7 +124,7 @@ static int ehci_msm_probe(struct platform_device *pdev)
                 goto put_hcd;
         }
 
-        hcd->phy = phy;
+        hcd->usb_phy = phy;
         device_init_wakeup(&pdev->dev, 1);
         /*
          * OTG device parent of HCD takes care of putting
@@ -151,7 +151,7 @@ static int ehci_msm_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
         pm_runtime_set_suspended(&pdev->dev);
 
-        otg_set_host(hcd->phy->otg, NULL);
+        otg_set_host(hcd->usb_phy->otg, NULL);
 
         /* FIXME: need to call usb_remove_hcd() here? */
 
diff --git a/drivers/usb/host/ehci-st.c b/drivers/usb/host/ehci-st.c
new file mode 100644
index 000000000000..7e4bd39cf757
--- /dev/null
+++ b/drivers/usb/host/ehci-st.c
@@ -0,0 +1,375 @@
+/*
+ * ST EHCI driver
+ *
+ * Copyright (C) 2014 STMicroelectronics – All Rights Reserved
+ *
+ * Author: Peter Griffin <peter.griffin@linaro.org>
+ *
+ * Derived from ehci-platform.c
+ *
+ * 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/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/hrtimer.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/reset.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/ehci_pdriver.h>
+
+#include "ehci.h"
+
+#define USB_MAX_CLKS 3
+
+struct st_ehci_platform_priv {
+        struct clk *clks[USB_MAX_CLKS];
+        struct clk *clk48;
+        struct reset_control *rst;
+        struct reset_control *pwr;
+        struct phy *phy;
+};
+
+#define DRIVER_DESC "EHCI STMicroelectronics driver"
+
+#define hcd_to_ehci_priv(h) \
+        ((struct st_ehci_platform_priv *)hcd_to_ehci(h)->priv)
+
+static const char hcd_name[] = "ehci-st";
+
+#define EHCI_CAPS_SIZE 0x10
+#define AHB2STBUS_INSREG01 (EHCI_CAPS_SIZE + 0x84)
+
+static int st_ehci_platform_reset(struct usb_hcd *hcd)
+{
+        struct platform_device *pdev = to_platform_device(hcd->self.controller);
+        struct usb_ehci_pdata *pdata = dev_get_platdata(&pdev->dev);
+        struct ehci_hcd *ehci = hcd_to_ehci(hcd);
+        int retval;
+        u32 threshold;
+
+        /* Set EHCI packet buffer IN/OUT threshold to 128 bytes */
+        threshold = 128 | (128 << 16);
+        writel(threshold, hcd->regs + AHB2STBUS_INSREG01);
+
+        ehci->caps = hcd->regs + pdata->caps_offset;
+        retval = ehci_setup(hcd);
+        if (retval)
+                return retval;
+
+        return 0;
+}
+
+static int st_ehci_platform_power_on(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct st_ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk, ret;
+
+        ret = reset_control_deassert(priv->pwr);
+        if (ret)
+                return ret;
+
+        ret = reset_control_deassert(priv->rst);
+        if (ret)
+                goto err_assert_power;
+
+        /* some SoCs don't have a dedicated 48Mhz clock, but those that do
+           need the rate to be explicitly set */
+        if (priv->clk48) {
+                ret = clk_set_rate(priv->clk48, 48000000);
+                if (ret)
+                        goto err_assert_reset;
+        }
+
+        for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++) {
+                ret = clk_prepare_enable(priv->clks[clk]);
+                if (ret)
+                        goto err_disable_clks;
+        }
+
+        ret = phy_init(priv->phy);
+        if (ret)
+                goto err_disable_clks;
+
+        ret = phy_power_on(priv->phy);
+        if (ret)
+                goto err_exit_phy;
+
+        return 0;
+
+err_exit_phy:
+        phy_exit(priv->phy);
+err_disable_clks:
+        while (--clk >= 0)
+                clk_disable_unprepare(priv->clks[clk]);
+err_assert_reset:
+        reset_control_assert(priv->rst);
+err_assert_power:
+        reset_control_assert(priv->pwr);
+
+        return ret;
+}
+
+static void st_ehci_platform_power_off(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct st_ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk;
+
+        reset_control_assert(priv->pwr);
+
+        reset_control_assert(priv->rst);
+
+        phy_power_off(priv->phy);
+
+        phy_exit(priv->phy);
+
+        for (clk = USB_MAX_CLKS - 1; clk >= 0; clk--)
+                if (priv->clks[clk])
+                        clk_disable_unprepare(priv->clks[clk]);
+
+}
+
+static struct hc_driver __read_mostly ehci_platform_hc_driver;
+
+static const struct ehci_driver_overrides platform_overrides __initconst = {
+        .reset =                st_ehci_platform_reset,
+        .extra_priv_size =      sizeof(struct st_ehci_platform_priv),
+};
+
+static struct usb_ehci_pdata ehci_platform_defaults = {
+        .power_on =             st_ehci_platform_power_on,
+        .power_suspend =        st_ehci_platform_power_off,
+        .power_off =            st_ehci_platform_power_off,
+};
+
+static int st_ehci_platform_probe(struct platform_device *dev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res_mem;
+        struct usb_ehci_pdata *pdata = &ehci_platform_defaults;
+        struct st_ehci_platform_priv *priv;
+        struct ehci_hcd *ehci;
+        int err, irq, clk = 0;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
+                dev_err(&dev->dev, "no irq provided");
+                return irq;
+        }
+        res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res_mem) {
+                dev_err(&dev->dev, "no memory resource provided");
+                return -ENXIO;
+        }
+
+        hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
+                             dev_name(&dev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        platform_set_drvdata(dev, hcd);
+        dev->dev.platform_data = pdata;
+        priv = hcd_to_ehci_priv(hcd);
+        ehci = hcd_to_ehci(hcd);
+
+        priv->phy = devm_phy_get(&dev->dev, "usb");
+        if (IS_ERR(priv->phy)) {
+                err = PTR_ERR(priv->phy);
+                goto err_put_hcd;
+        }
+
+        for (clk = 0; clk < USB_MAX_CLKS; clk++) {
+                priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
+                if (IS_ERR(priv->clks[clk])) {
+                        err = PTR_ERR(priv->clks[clk]);
+                        if (err == -EPROBE_DEFER)
+                                goto err_put_clks;
+                        priv->clks[clk] = NULL;
+                        break;
+                }
+        }
+
+        /* some SoCs don't have a dedicated 48Mhz clock, but those that
+           do need the rate to be explicitly set */
+        priv->clk48 = devm_clk_get(&dev->dev, "clk48");
+        if (IS_ERR(priv->clk48)) {
+                dev_info(&dev->dev, "48MHz clk not found\n");
+                priv->clk48 = NULL;
+        }
+
+        priv->pwr = devm_reset_control_get_optional(&dev->dev, "power");
+        if (IS_ERR(priv->pwr)) {
+                err = PTR_ERR(priv->pwr);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->pwr = NULL;
+        }
+
+        priv->rst = devm_reset_control_get_optional(&dev->dev, "softreset");
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->rst = NULL;
+        }
+
+        if (pdata->power_on) {
+                err = pdata->power_on(dev);
+                if (err < 0)
+                        goto err_put_clks;
+        }
+
+        hcd->rsrc_start = res_mem->start;
+        hcd->rsrc_len = resource_size(res_mem);
+
+        hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
+                goto err_put_clks;
+        }
+
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (err)
+                goto err_put_clks;
+
+        device_wakeup_enable(hcd->self.controller);
+        platform_set_drvdata(dev, hcd);
+
+        return err;
+
+err_put_clks:
+        while (--clk >= 0)
+                clk_put(priv->clks[clk]);
+err_put_hcd:
+        if (pdata == &ehci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        usb_put_hcd(hcd);
+
+        return err;
+}
+
+static int st_ehci_platform_remove(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
+        struct st_ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
+        int clk;
+
+        usb_remove_hcd(hcd);
+
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
+        for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++)
+                clk_put(priv->clks[clk]);
+
+        usb_put_hcd(hcd);
+
+        if (pdata == &ehci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int st_ehci_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+        bool do_wakeup = device_may_wakeup(dev);
+        int ret;
+
+        ret = ehci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
+        if (pdata->power_suspend)
+                pdata->power_suspend(pdev);
+
+        pinctrl_pm_select_sleep_state(dev);
+
+        return ret;
+}
+
+static int st_ehci_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev_get_platdata(dev);
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+        int err;
+
+        pinctrl_pm_select_default_state(dev);
+
+        if (pdata->power_on) {
+                err = pdata->power_on(pdev);
+                if (err < 0)
+                        return err;
+        }
+
+        ehci_resume(hcd, false);
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(st_ehci_pm_ops, st_ehci_suspend, st_ehci_resume);
+
+#endif /* CONFIG_PM_SLEEP */
+
+static const struct of_device_id st_ehci_ids[] = {
+        { .compatible = "st,st-ehci-300x", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, st_ehci_ids);
+
+static struct platform_driver ehci_platform_driver = {
+        .probe          = st_ehci_platform_probe,
+        .remove         = st_ehci_platform_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name   = "st-ehci",
+#ifdef CONFIG_PM_SLEEP
+                .pm     = &st_ehci_pm_ops,
+#endif
+                .of_match_table = st_ehci_ids,
+        }
+};
+
+static int __init ehci_platform_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ehci_init_driver(&ehci_platform_hc_driver, &platform_overrides);
+        return platform_driver_register(&ehci_platform_driver);
+}
+module_init(ehci_platform_init);
+
+static void __exit ehci_platform_cleanup(void)
+{
+        platform_driver_unregister(&ehci_platform_driver);
+}
+module_exit(ehci_platform_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Peter Griffin <peter.griffin@linaro.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 7aafb05e7a40..aaa01971efe9 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -206,7 +206,7 @@ static int tegra_ehci_hub_control(
                 if (tegra->port_resuming && !(temp & PORT_SUSPEND)) {
                         /* Resume completed, re-enable disconnect detection */
                         tegra->port_resuming = 0;
-                        tegra_usb_phy_postresume(hcd->phy);
+                        tegra_usb_phy_postresume(hcd->usb_phy);
                 }
         }
 
@@ -259,7 +259,7 @@ static int tegra_ehci_hub_control(
                         goto done;
 
                 /* Disable disconnect detection during port resume */
-                tegra_usb_phy_preresume(hcd->phy);
+                tegra_usb_phy_preresume(hcd->usb_phy);
 
                 ehci->reset_done[wIndex-1] = jiffies + msecs_to_jiffies(25);
 
@@ -454,7 +454,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                 err = PTR_ERR(u_phy);
                 goto cleanup_clk_en;
         }
-        hcd->phy = u_phy;
+        hcd->usb_phy = u_phy;
 
         tegra->needs_double_reset = of_property_read_bool(pdev->dev.of_node,
                 "nvidia,needs-double-reset");
@@ -475,7 +475,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         ehci->caps = hcd->regs + 0x100;
         ehci->has_hostpc = soc_config->has_hostpc;
 
-        err = usb_phy_init(hcd->phy);
+        err = usb_phy_init(hcd->usb_phy);
         if (err) {
                 dev_err(&pdev->dev, "Failed to initialize phy\n");
                 goto cleanup_clk_en;
@@ -490,7 +490,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
         u_phy->otg->host = hcd_to_bus(hcd);
 
-        err = usb_phy_set_suspend(hcd->phy, 0);
+        err = usb_phy_set_suspend(hcd->usb_phy, 0);
         if (err) {
                 dev_err(&pdev->dev, "Failed to power on the phy\n");
                 goto cleanup_phy;
@@ -517,7 +517,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 cleanup_otg_set_host:
         otg_set_host(u_phy->otg, NULL);
 cleanup_phy:
-        usb_phy_shutdown(hcd->phy);
+        usb_phy_shutdown(hcd->usb_phy);
 cleanup_clk_en:
         clk_disable_unprepare(tegra->clk);
 cleanup_hcd_create:
@@ -531,9 +531,9 @@ static int tegra_ehci_remove(struct platform_device *pdev)
         struct tegra_ehci_hcd *tegra =
                 (struct tegra_ehci_hcd *)hcd_to_ehci(hcd)->priv;
 
-        otg_set_host(hcd->phy->otg, NULL);
+        otg_set_host(hcd->usb_phy->otg, NULL);
 
-        usb_phy_shutdown(hcd->phy);
+        usb_phy_shutdown(hcd->usb_phy);
         usb_remove_hcd(hcd);
 
         clk_disable_unprepare(tegra->clk);
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index fe57710753e8..a2328361dc80 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -31,6 +31,7 @@
 #include <linux/of.h>
 #include <linux/of_platform.h>
 #include <linux/of_address.h>
+#include <linux/of_irq.h>
 
 /**
  * ehci_xilinx_port_handed_over - hand the port out if failed to enable it
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 1cf68eaf2ed8..a1a1ef521436 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -360,12 +360,12 @@ static int fhci_start(struct usb_hcd *hcd)
         hcd->state = HC_STATE_RUNNING;
 
         /*
-         * From here on, khubd concurrently accesses the root
+         * From here on, hub_wq concurrently accesses the root
          * hub; drivers will be talking to enumerated devices.
-         * (On restart paths, khubd already knows about the root
+         * (On restart paths, hub_wq already knows about the root
          * hub and could find work as soon as we wrote FLAG_CF.)
          *
-         * Before this point the HC was idle/ready.  After, khubd
+         * Before this point the HC was idle/ready.  After, hub_wq
          * and device drivers may start it running.
          */
         fhci_usb_enable(fhci);
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index adcd2050dced..3de1278677d0 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -1483,7 +1483,7 @@ fotg210_hub_status_data(struct usb_hcd *hcd, char *buf)
 
         /*
          * Return status information even for ports with OWNER set.
-         * Otherwise khubd wouldn't see the disconnect event when a
+         * Otherwise hub_wq wouldn't see the disconnect event when a
          * high-speed device is switched over to the companion
          * controller by the user.
          */
@@ -1572,7 +1572,7 @@ static int fotg210_hub_control(
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
-                 * companion controller, khubd needs to be able to clear
+                 * companion controller, hub_wq needs to be able to clear
                  * the port-change status bits (especially
                  * USB_PORT_STAT_C_CONNECTION).
                  */
@@ -1723,7 +1723,7 @@ static int fotg210_hub_control(
                 }
 
                 /*
-                 * Even if OWNER is set, there's no harm letting khubd
+                 * Even if OWNER is set, there's no harm letting hub_wq
                  * see the wPortStatus values (they should all be 0 except
                  * for PORT_POWER anyway).
                  */
@@ -5445,7 +5445,7 @@ static irqreturn_t fotg210_irq(struct usb_hcd *hcd)
                                 fotg210->reset_done[0] == 0) {
 
                         /* start 20 msec resume signaling from this port,
-                         * and make khubd collect PORT_STAT_C_SUSPEND to
+                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.  Use 5 ms extra for safety,
                          * like usb_port_resume() does.
                          */
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index ba9499060f63..abe42f31559f 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -1441,7 +1441,7 @@ fusbh200_hub_status_data (struct usb_hcd *hcd, char *buf)
 
         /*
          * Return status information even for ports with OWNER set.
-         * Otherwise khubd wouldn't see the disconnect event when a
+         * Otherwise hub_wq wouldn't see the disconnect event when a
          * high-speed device is switched over to the companion
          * controller by the user.
          */
@@ -1530,7 +1530,7 @@ static int fusbh200_hub_control (
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
-                 * companion controller, khubd needs to be able to clear
+                 * companion controller, hub_wq needs to be able to clear
                  * the port-change status bits (especially
                  * USB_PORT_STAT_C_CONNECTION).
                  */
@@ -1678,7 +1678,7 @@ static int fusbh200_hub_control (
                 }
 
                 /*
-                 * Even if OWNER is set, there's no harm letting khubd
+                 * Even if OWNER is set, there's no harm letting hub_wq
                  * see the wPortStatus values (they should all be 0 except
                  * for PORT_POWER anyway).
                  */
@@ -5355,7 +5355,7 @@ static irqreturn_t fusbh200_irq (struct usb_hcd *hcd)
                                 fusbh200->reset_done[0] == 0) {
 
                         /* start 20 msec resume signaling from this port,
-                         * and make khubd collect PORT_STAT_C_SUSPEND to
+                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.  Use 5 ms extra for safety,
                          * like usb_port_resume() does.
                          */
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 875bcfd3ec1a..4bb37982855e 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -2616,30 +2616,10 @@ static int isp1362_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
         struct isp1362_hcd *isp1362_hcd = hcd_to_isp1362_hcd(hcd);
-        struct resource *res;
 
         remove_debug_file(isp1362_hcd);
         DBG(0, "%s: Removing HCD\n", __func__);
         usb_remove_hcd(hcd);
-
-        DBG(0, "%s: Unmapping data_reg @ %p\n", __func__,
-            isp1362_hcd->data_reg);
-        iounmap(isp1362_hcd->data_reg);
-
-        DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__,
-            isp1362_hcd->addr_reg);
-        iounmap(isp1362_hcd->addr_reg);
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
-        if (res)
-                release_mem_region(res->start, resource_size(res));
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        DBG(0, "%s: release mem_region: %08lx\n", __func__, (long unsigned int)res->start);
-        if (res)
-                release_mem_region(res->start, resource_size(res));
-
         DBG(0, "%s: put_hcd\n", __func__);
         usb_put_hcd(hcd);
         DBG(0, "%s: Done\n", __func__);
@@ -2651,12 +2631,11 @@ static int isp1362_probe(struct platform_device *pdev)
 {
         struct usb_hcd *hcd;
         struct isp1362_hcd *isp1362_hcd;
-        struct resource *addr, *data;
+        struct resource *addr, *data, *irq_res;
         void __iomem *addr_reg;
         void __iomem *data_reg;
         int irq;
         int retval = 0;
-        struct resource *irq_res;
         unsigned int irq_flags = 0;
 
         if (usb_disabled())
@@ -2667,52 +2646,35 @@ static int isp1362_probe(struct platform_device *pdev)
          * specific platform_data.  we don't probe for IRQs, and do only
          * minimal sanity checking.
          */
-        if (pdev->num_resources < 3) {
-                retval = -ENODEV;
-                goto err1;
-        }
-
-        data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
-        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!addr || !data || !irq_res) {
-                retval = -ENODEV;
-                goto err1;
-        }
-        irq = irq_res->start;
+        if (pdev->num_resources < 3)
+                return -ENODEV;
 
         if (pdev->dev.dma_mask) {
                 DBG(1, "won't do DMA");
-                retval = -ENODEV;
-                goto err1;
+                return -ENODEV;
         }
 
-        if (!request_mem_region(addr->start, resource_size(addr), hcd_name)) {
-                retval = -EBUSY;
-                goto err1;
-        }
-        addr_reg = ioremap(addr->start, resource_size(addr));
-        if (addr_reg == NULL) {
-                retval = -ENOMEM;
-                goto err2;
-        }
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq_res)
+                return -ENODEV;
 
-        if (!request_mem_region(data->start, resource_size(data), hcd_name)) {
-                retval = -EBUSY;
-                goto err3;
-        }
-        data_reg = ioremap(data->start, resource_size(data));
-        if (data_reg == NULL) {
-                retval = -ENOMEM;
-                goto err4;
-        }
+        irq = irq_res->start;
+
+        addr = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        addr_reg = devm_ioremap_resource(&pdev->dev, addr);
+        if (IS_ERR(addr_reg))
+                return PTR_ERR(addr_reg);
+
+        data = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        data_reg = devm_ioremap_resource(&pdev->dev, data);
+        if (IS_ERR(data_reg))
+                return PTR_ERR(data_reg);
 
         /* allocate and initialize hcd */
         hcd = usb_create_hcd(&isp1362_hc_driver, &pdev->dev, dev_name(&pdev->dev));
-        if (!hcd) {
-                retval = -ENOMEM;
-                goto err5;
-        }
+        if (!hcd)
+                return -ENOMEM;
+
         hcd->rsrc_start = data->start;
         isp1362_hcd = hcd_to_isp1362_hcd(hcd);
         isp1362_hcd->data_reg = data_reg;
@@ -2729,7 +2691,7 @@ static int isp1362_probe(struct platform_device *pdev)
         if (!isp1362_hcd->board->delay) {
                 dev_err(hcd->self.controller, "No platform delay function given\n");
                 retval = -ENODEV;
-                goto err6;
+                goto err;
         }
 #endif
 
@@ -2744,32 +2706,17 @@ static int isp1362_probe(struct platform_device *pdev)
 
         retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_SHARED);
         if (retval != 0)
-                goto err6;
+                goto err;
         device_wakeup_enable(hcd->self.controller);
 
-        pr_info("%s, irq %d\n", hcd->product_desc, irq);
+        dev_info(&pdev->dev, "%s, irq %d\n", hcd->product_desc, irq);
 
         create_debug_file(isp1362_hcd);
 
         return 0;
 
- err6:
-        DBG(0, "%s: Freeing dev %p\n", __func__, isp1362_hcd);
+ err:
         usb_put_hcd(hcd);
- err5:
-        DBG(0, "%s: Unmapping data_reg @ %p\n", __func__, data_reg);
-        iounmap(data_reg);
- err4:
-        DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)data->start);
-        release_mem_region(data->start, resource_size(data));
- err3:
-        DBG(0, "%s: Unmapping addr_reg @ %p\n", __func__, addr_reg);
-        iounmap(addr_reg);
- err2:
-        DBG(0, "%s: Releasing mem region %08lx\n", __func__, (long unsigned int)addr->start);
-        release_mem_region(addr->start, resource_size(addr));
- err1:
-        pr_err("%s: init error, %d\n", __func__, retval);
 
         return retval;
 }
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 51a0ae9cdd1d..e752c3098f38 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1760,7 +1760,7 @@ static int isp1760_hub_status_data(struct usb_hcd *hcd, char *buf)
 
         /*
          * Return status information even for ports with OWNER set.
-         * Otherwise khubd wouldn't see the disconnect event when a
+         * Otherwise hub_wq wouldn't see the disconnect event when a
          * high-speed device is switched over to the companion
          * controller by the user.
          */
@@ -1871,7 +1871,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
-                 * companion controller, khubd needs to be able to clear
+                 * companion controller, hub_wq needs to be able to clear
                  * the port-change status bits (especially
                  * USB_PORT_STAT_C_CONNECTION).
                  */
@@ -2000,7 +2000,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                         reg_read32(hcd->regs, HC_PORTSC1));
                 }
                 /*
-                 * Even if OWNER is set, there's no harm letting khubd
+                 * Even if OWNER is set, there's no harm letting hub_wq
                  * see the wPortStatus values (they should all be 0 except
                  * for PORT_POWER anyway).
                  */
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index a72ab8fe8cd3..d28b6583ba02 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -19,11 +19,8 @@
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/phy/phy.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"
 
@@ -38,9 +35,7 @@ static struct hc_driver __read_mostly exynos_ohci_hc_driver;
 
 struct exynos_ohci_hcd {
         struct clk *clk;
-        struct usb_phy *phy;
-        struct usb_otg *otg;
-        struct phy *phy_g[PHY_NUMBER];
+        struct phy *phy[PHY_NUMBER];
 };
 
 static int exynos_ohci_get_phy(struct device *dev,
@@ -49,30 +44,9 @@ static int exynos_ohci_get_phy(struct device *dev,
         struct device_node *child;
         struct phy *phy;
         int phy_number;
-        int ret = 0;
-
-        exynos_ohci->phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(exynos_ohci->phy)) {
-                ret = PTR_ERR(exynos_ohci->phy);
-                if (ret != -ENXIO && ret != -ENODEV) {
-                        dev_err(dev, "no usb2 phy configured\n");
-                        return ret;
-                }
-                dev_dbg(dev, "Failed to get usb2 phy\n");
-        } else {
-                exynos_ohci->otg = exynos_ohci->phy->otg;
-        }
+        int ret;
 
-        /*
-         * Getting generic phy:
-         * We are keeping both types of phys as a part of transiting OHCI
-         * to generic phy framework, so as to maintain backward compatibilty
-         * with old DTB.
-         * If there are existing devices using DTB files built from them,
-         * to remove the support for old bindings in this driver,
-         * we need to make sure that such devices have their DTBs
-         * updated to ones built from new DTS.
-         */
+        /* Get PHYs for the controller */
         for_each_available_child_of_node(dev->of_node, child) {
                 ret = of_property_read_u32(child, "reg", &phy_number);
                 if (ret) {
@@ -88,19 +62,21 @@ static int exynos_ohci_get_phy(struct device *dev,
                 }
 
                 phy = devm_of_phy_get(dev, child, NULL);
+                exynos_ohci->phy[phy_number] = phy;
                 of_node_put(child);
                 if (IS_ERR(phy)) {
                         ret = PTR_ERR(phy);
-                        if (ret != -ENOSYS && ret != -ENODEV) {
-                                dev_err(dev, "no usb2 phy configured\n");
+                        if (ret == -EPROBE_DEFER) {
+                                return ret;
+                        } else if (ret != -ENOSYS && ret != -ENODEV) {
+                                dev_err(dev,
+                                        "Error retrieving usb2 phy: %d\n", ret);
                                 return ret;
                         }
-                        dev_dbg(dev, "Failed to get usb2 phy\n");
                 }
-                exynos_ohci->phy_g[phy_number] = phy;
         }
 
-        return ret;
+        return 0;
 }
 
 static int exynos_ohci_phy_enable(struct device *dev)
@@ -110,16 +86,13 @@ static int exynos_ohci_phy_enable(struct device *dev)
         int i;
         int ret = 0;
 
-        if (!IS_ERR(exynos_ohci->phy))
-                return usb_phy_init(exynos_ohci->phy);
-
         for (i = 0; ret == 0 && i < PHY_NUMBER; i++)
-                if (!IS_ERR(exynos_ohci->phy_g[i]))
-                        ret = phy_power_on(exynos_ohci->phy_g[i]);
+                if (!IS_ERR(exynos_ohci->phy[i]))
+                        ret = phy_power_on(exynos_ohci->phy[i]);
         if (ret)
                 for (i--; i >= 0; i--)
-                        if (!IS_ERR(exynos_ohci->phy_g[i]))
-                                phy_power_off(exynos_ohci->phy_g[i]);
+                        if (!IS_ERR(exynos_ohci->phy[i]))
+                                phy_power_off(exynos_ohci->phy[i]);
 
         return ret;
 }
@@ -130,14 +103,9 @@ static void exynos_ohci_phy_disable(struct device *dev)
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
         int i;
 
-        if (!IS_ERR(exynos_ohci->phy)) {
-                usb_phy_shutdown(exynos_ohci->phy);
-                return;
-        }
-
         for (i = 0; i < PHY_NUMBER; i++)
-                if (!IS_ERR(exynos_ohci->phy_g[i]))
-                        phy_power_off(exynos_ohci->phy_g[i]);
+                if (!IS_ERR(exynos_ohci->phy[i]))
+                        phy_power_off(exynos_ohci->phy[i]);
 }
 
 static int exynos_ohci_probe(struct platform_device *pdev)
@@ -209,9 +177,6 @@ skip_phy:
                 goto fail_io;
         }
 
-        if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
-
         platform_set_drvdata(pdev, hcd);
 
         err = exynos_ohci_phy_enable(&pdev->dev);
@@ -244,9 +209,6 @@ static int exynos_ohci_remove(struct platform_device *pdev)
 
         usb_remove_hcd(hcd);
 
-        if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
-
         exynos_ohci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
@@ -275,9 +237,6 @@ static int exynos_ohci_suspend(struct device *dev)
         if (rc)
                 return rc;
 
-        if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
-
         exynos_ohci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
@@ -293,9 +252,6 @@ static int exynos_ohci_resume(struct device *dev)
 
         clk_prepare_enable(exynos_ohci->clk);
 
-        if (exynos_ohci->otg)
-                exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
-
         ret = exynos_ohci_phy_enable(dev);
         if (ret) {
                 dev_err(dev, "Failed to enable USB phy\n");
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 46987735a2e3..d664edabf14e 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -632,7 +632,7 @@ retry:
                 return -EOVERFLOW;
         }
 
-        /* use rhsc irqs after khubd is fully initialized */
+        /* use rhsc irqs after hub_wq is allocated */
         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
         hcd->uses_new_polling = 1;
 
@@ -909,8 +909,8 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
                  * choices for RHSC.  Many followed the spec; RHSC triggers
                  * on an edge, like setting and maybe clearing a port status
                  * change bit.  With others it's level-triggered, active
-                 * until khubd clears all the port status change bits.  We'll
-                 * always disable it here and rely on polling until khubd
+                 * until hub_wq clears all the port status change bits.  We'll
+                 * always disable it here and rely on polling until hub_wq
                  * re-enables it.
                  */
                 ohci_writel(ohci, OHCI_INTR_RHSC, &regs->intrdisable);
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 17d32b0ea565..0aa17c937115 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -585,7 +585,7 @@ static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
         if (!(status & RH_PS_CCS))
                 return -ENODEV;
 
-        /* khubd will finish the reset later */
+        /* hub_wq will finish the reset later */
         ohci_writel(ohci, RH_PS_PRS, &ohci->regs->roothub.portstatus [port]);
         return 0;
 }
@@ -610,7 +610,7 @@ static int ohci_start_port_reset (struct usb_hcd *hcd, unsigned port)
 /* wrap-aware logic morphed from <linux/jiffies.h> */
 #define tick_before(t1,t2) ((s16)(((s16)(t1))-((s16)(t2))) < 0)
 
-/* called from some task, normally khubd */
+/* called from some task, normally hub_wq */
 static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
 {
         __hc32 __iomem *portstat = &ohci->regs->roothub.portstatus [port];
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index c923cafcaca7..0231606d47c2 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -180,10 +180,10 @@ static void start_hnp(struct ohci_hcd *ohci)
         unsigned long   flags;
         u32 l;
 
-        otg_start_hnp(hcd->phy->otg);
+        otg_start_hnp(hcd->usb_phy->otg);
 
         local_irq_save(flags);
-        hcd->phy->state = OTG_STATE_A_SUSPEND;
+        hcd->usb_phy->state = OTG_STATE_A_SUSPEND;
         writel (RH_PS_PSS, &ohci->regs->roothub.portstatus [port]);
         l = omap_readl(OTG_CTRL);
         l &= ~OTG_A_BUSREQ;
@@ -220,14 +220,14 @@ static int ohci_omap_reset(struct usb_hcd *hcd)
 
 #ifdef  CONFIG_USB_OTG
         if (need_transceiver) {
-                hcd->phy = usb_get_phy(USB_PHY_TYPE_USB2);
-                if (!IS_ERR_OR_NULL(hcd->phy)) {
-                        int     status = otg_set_host(hcd->phy->otg,
+                hcd->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
+                if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
+                        int     status = otg_set_host(hcd->usb_phy->otg,
                                                 &ohci_to_hcd(ohci)->self);
                         dev_dbg(hcd->self.controller, "init %s phy, status %d\n",
-                                        hcd->phy->label, status);
+                                        hcd->usb_phy->label, status);
                         if (status) {
-                                usb_put_phy(hcd->phy);
+                                usb_put_phy(hcd->usb_phy);
                                 return status;
                         }
                 } else {
@@ -283,7 +283,7 @@ static int ohci_omap_reset(struct usb_hcd *hcd)
                 ohci_to_hcd(ohci)->power_budget = 0;
         }
 
-        /* FIXME khubd hub requests should manage power switching */
+        /* FIXME hub_wq hub requests should manage power switching */
         omap_ohci_transceiver_power(1);
 
         /* board init will have already handled HMC and mux setup.
@@ -399,9 +399,9 @@ 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);
+        if (!IS_ERR_OR_NULL(hcd->usb_phy)) {
+                (void) otg_set_host(hcd->usb_phy->otg, 0);
+                usb_put_phy(hcd->usb_phy);
         }
         if (machine_is_omap_osk())
                 gpio_free(9);
diff --git a/drivers/usb/host/ohci-st.c b/drivers/usb/host/ohci-st.c
new file mode 100644
index 000000000000..df9028e0d9b4
--- /dev/null
+++ b/drivers/usb/host/ohci-st.c
@@ -0,0 +1,349 @@
+/*
+ * ST OHCI driver
+ *
+ * Copyright (C) 2014 STMicroelectronics – All Rights Reserved
+ *
+ * Author: Peter Griffin <peter.griffin@linaro.org>
+ *
+ * Derived from ohci-platform.c
+ *
+ * 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/dma-mapping.h>
+#include <linux/hrtimer.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/reset.h>
+#include <linux/usb/ohci_pdriver.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include "ohci.h"
+
+#define USB_MAX_CLKS 3
+
+struct st_ohci_platform_priv {
+        struct clk *clks[USB_MAX_CLKS];
+        struct clk *clk48;
+        struct reset_control *rst;
+        struct reset_control *pwr;
+        struct phy *phy;
+};
+
+#define DRIVER_DESC "OHCI STMicroelectronics driver"
+
+#define hcd_to_ohci_priv(h) \
+        ((struct st_ohci_platform_priv *)hcd_to_ohci(h)->priv)
+
+static const char hcd_name[] = "ohci-st";
+
+static int st_ohci_platform_power_on(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+        int clk, ret;
+
+        ret = reset_control_deassert(priv->pwr);
+        if (ret)
+                return ret;
+
+        ret = reset_control_deassert(priv->rst);
+        if (ret)
+                goto err_assert_power;
+
+        /* some SoCs don't have a dedicated 48Mhz clock, but those that do
+           need the rate to be explicitly set */
+        if (priv->clk48) {
+                ret = clk_set_rate(priv->clk48, 48000000);
+                if (ret)
+                        goto err_assert_reset;
+        }
+
+        for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++) {
+                ret = clk_prepare_enable(priv->clks[clk]);
+                if (ret)
+                        goto err_disable_clks;
+        }
+
+        ret = phy_init(priv->phy);
+        if (ret)
+                goto err_disable_clks;
+
+        ret = phy_power_on(priv->phy);
+        if (ret)
+                goto err_exit_phy;
+
+        return 0;
+
+err_exit_phy:
+        phy_exit(priv->phy);
+err_disable_clks:
+        while (--clk >= 0)
+                clk_disable_unprepare(priv->clks[clk]);
+err_assert_reset:
+        reset_control_assert(priv->rst);
+err_assert_power:
+        reset_control_assert(priv->pwr);
+
+        return ret;
+}
+
+static void st_ohci_platform_power_off(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+
+        int clk;
+
+        reset_control_assert(priv->pwr);
+
+        reset_control_assert(priv->rst);
+
+        phy_power_off(priv->phy);
+
+        phy_exit(priv->phy);
+
+        for (clk = USB_MAX_CLKS - 1; clk >= 0; clk--)
+                if (priv->clks[clk])
+                        clk_disable_unprepare(priv->clks[clk]);
+}
+
+static struct hc_driver __read_mostly ohci_platform_hc_driver;
+
+static const struct ohci_driver_overrides platform_overrides __initconst = {
+        .product_desc =         "ST OHCI controller",
+        .extra_priv_size =      sizeof(struct st_ohci_platform_priv),
+};
+
+static struct usb_ohci_pdata ohci_platform_defaults = {
+        .power_on =             st_ohci_platform_power_on,
+        .power_suspend =        st_ohci_platform_power_off,
+        .power_off =            st_ohci_platform_power_off,
+};
+
+static int st_ohci_platform_probe(struct platform_device *dev)
+{
+        struct usb_hcd *hcd;
+        struct resource *res_mem;
+        struct usb_ohci_pdata *pdata = &ohci_platform_defaults;
+        struct st_ohci_platform_priv *priv;
+        struct ohci_hcd *ohci;
+        int err, irq, clk = 0;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
+                dev_err(&dev->dev, "no irq provided");
+                return irq;
+        }
+
+        res_mem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res_mem) {
+                dev_err(&dev->dev, "no memory resource provided");
+                return -ENXIO;
+        }
+
+        hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
+                        dev_name(&dev->dev));
+        if (!hcd)
+                return -ENOMEM;
+
+        platform_set_drvdata(dev, hcd);
+        dev->dev.platform_data = pdata;
+        priv = hcd_to_ohci_priv(hcd);
+        ohci = hcd_to_ohci(hcd);
+
+        priv->phy = devm_phy_get(&dev->dev, "usb");
+        if (IS_ERR(priv->phy)) {
+                err = PTR_ERR(priv->phy);
+                goto err_put_hcd;
+        }
+
+        for (clk = 0; clk < USB_MAX_CLKS; clk++) {
+                priv->clks[clk] = of_clk_get(dev->dev.of_node, clk);
+                if (IS_ERR(priv->clks[clk])) {
+                        err = PTR_ERR(priv->clks[clk]);
+                        if (err == -EPROBE_DEFER)
+                                goto err_put_clks;
+                        priv->clks[clk] = NULL;
+                        break;
+                }
+        }
+
+        /* some SoCs don't have a dedicated 48Mhz clock, but those that
+           do need the rate to be explicitly set */
+        priv->clk48 = devm_clk_get(&dev->dev, "clk48");
+        if (IS_ERR(priv->clk48)) {
+                dev_info(&dev->dev, "48MHz clk not found\n");
+                priv->clk48 = NULL;
+        }
+
+        priv->pwr = devm_reset_control_get_optional(&dev->dev, "power");
+        if (IS_ERR(priv->pwr)) {
+                err = PTR_ERR(priv->pwr);
+                goto err_put_clks;
+        }
+
+        priv->rst = devm_reset_control_get_optional(&dev->dev, "softreset");
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                goto err_put_clks;
+        }
+
+        if (pdata->power_on) {
+                err = pdata->power_on(dev);
+                if (err < 0)
+                        goto err_power;
+        }
+
+        hcd->rsrc_start = res_mem->start;
+        hcd->rsrc_len = resource_size(res_mem);
+
+        hcd->regs = devm_ioremap_resource(&dev->dev, res_mem);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
+                goto err_power;
+        }
+        err = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (err)
+                goto err_power;
+
+        device_wakeup_enable(hcd->self.controller);
+
+        platform_set_drvdata(dev, hcd);
+
+        return err;
+
+err_power:
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
+err_put_clks:
+        while (--clk >= 0)
+                clk_put(priv->clks[clk]);
+err_put_hcd:
+        if (pdata == &ohci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        usb_put_hcd(hcd);
+
+        return err;
+}
+
+static int st_ohci_platform_remove(struct platform_device *dev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
+        struct st_ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
+        int clk;
+
+        usb_remove_hcd(hcd);
+
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
+
+        for (clk = 0; clk < USB_MAX_CLKS && priv->clks[clk]; clk++)
+                clk_put(priv->clks[clk]);
+
+        usb_put_hcd(hcd);
+
+        if (pdata == &ohci_platform_defaults)
+                dev->dev.platform_data = NULL;
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+
+static int st_ohci_suspend(struct device *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 ret;
+}
+
+static int st_ohci_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ohci_pdata *pdata = dev_get_platdata(dev);
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+        int err;
+
+        if (pdata->power_on) {
+                err = pdata->power_on(pdev);
+                if (err < 0)
+                        return err;
+        }
+
+        ohci_resume(hcd, false);
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(st_ohci_pm_ops, st_ohci_suspend, st_ohci_resume);
+
+#endif /* CONFIG_PM_SLEEP */
+
+static const struct of_device_id st_ohci_platform_ids[] = {
+        { .compatible = "st,st-ohci-300x", },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, st_ohci_platform_ids);
+
+static struct platform_driver ohci_platform_driver = {
+        .probe          = st_ohci_platform_probe,
+        .remove         = st_ohci_platform_remove,
+        .shutdown       = usb_hcd_platform_shutdown,
+        .driver         = {
+                .name   = "st-ohci",
+#ifdef CONFIG_PM_SLEEP
+                .pm     = &st_ohci_pm_ops,
+#endif
+                .of_match_table = st_ohci_platform_ids,
+        }
+};
+
+static int __init ohci_platform_init(void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
+        ohci_init_driver(&ohci_platform_hc_driver, &platform_overrides);
+        return platform_driver_register(&ohci_platform_driver);
+}
+module_init(ohci_platform_init);
+
+static void __exit ohci_platform_cleanup(void)
+{
+        platform_driver_unregister(&ohci_platform_driver);
+}
+module_exit(ohci_platform_cleanup);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("Peter Griffin <peter.griffin@linaro.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index da5fb0e3c363..4fe79a2d71a9 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -2046,7 +2046,7 @@ static void intr_deschedule(struct oxu_hcd *oxu, struct ehci_qh *qh)
 
         /* simple/paranoid:  always delay, expecting the HC needs to read
          * qh->hw_next or finish a writeback after SPLIT/CSPLIT ... and
-         * expect khubd to clean up after any CSPLITs we won't issue.
+         * expect hub_wq to clean up after any CSPLITs we won't issue.
          * active high speed queues may need bigger delays...
          */
         if (list_empty(&qh->qtd_list)
@@ -2501,7 +2501,7 @@ static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
                                 continue;
 
                         /* start 20 msec resume signaling from this port,
-                         * and make khubd collect PORT_STAT_C_SUSPEND to
+                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.
                          */
                         oxu->reset_done[i] = jiffies + msecs_to_jiffies(20);
@@ -3119,7 +3119,7 @@ static int oxu_hub_status_data(struct usb_hcd *hcd, char *buf)
 
                 /*
                  * Return status information even for ports with OWNER set.
-                 * Otherwise khubd wouldn't see the disconnect event when a
+                 * Otherwise hub_wq wouldn't see the disconnect event when a
                  * high-speed device is switched over to the companion
                  * controller by the user.
                  */
@@ -3194,7 +3194,7 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
 
                 /*
                  * Even if OWNER is set, so the port is owned by the
-                 * companion controller, khubd needs to be able to clear
+                 * companion controller, hub_wq needs to be able to clear
                  * the port-change status bits (especially
                  * USB_PORT_STAT_C_CONNECTION).
                  */
@@ -3336,7 +3336,7 @@ static int oxu_hub_control(struct usb_hcd *hcd, u16 typeReq,
                 }
 
                 /*
-                 * Even if OWNER is set, there's no harm letting khubd
+                 * Even if OWNER is set, there's no harm letting hub_wq
                  * see the wPortStatus values (they should all be 0 except
                  * for PORT_POWER anyway).
                  */
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index a517151867af..ad0c348e68e9 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -674,7 +674,7 @@ retry:
                         sl811->next_periodic = sl811->periodic[index];
         }
 
-        /* khubd manages debouncing and wakeup */
+        /* hub_wq manages debouncing and wakeup */
         if (irqstat & SL11H_INTMASK_INSRMV) {
                 sl811->stat_insrmv++;
 
@@ -714,7 +714,7 @@ retry:
 #endif
 
                 /* port status seems weird until after reset, so
-                 * force the reset and make khubd clean up later.
+                 * force the reset and make hub_wq clean up later.
                  */
                 if (irqstat & SL11H_INTMASK_RD)
                         sl811->port1 &= ~USB_PORT_STAT_CONNECTION;
@@ -1079,7 +1079,7 @@ sl811h_hub_status_data(struct usb_hcd *hcd, char *buf)
         if (!(sl811->port1 & (0xffff << 16)))
                 return 0;
 
-        /* tell khubd port 1 changed */
+        /* tell hub_wq port 1 changed */
         *buf = (1 << 1);
         return 1;
 }
@@ -1196,7 +1196,7 @@ sl811h_timer(unsigned long _sl811)
                 sl811_write(sl811, SL811_EP_A(SL11H_HOSTCTLREG),
                                 SL11H_HCTLMASK_ARM);
 
-                /* khubd provides debounce delay */
+                /* hub_wq provides debounce delay */
         } else {
                 sl811->ctrl1 = 0;
         }
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index eb009a457fb5..bb89175ca6e5 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -594,3 +594,4 @@ void xhci_dbg_trace(struct xhci_hcd *xhci, void (*trace)(struct va_format *),
         trace(&vaf);
         va_end(args);
 }
+EXPORT_SYMBOL_GPL(xhci_dbg_trace);
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 69aece31143a..696160d48ae8 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -319,12 +319,19 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
  */
 void xhci_ring_device(struct xhci_hcd *xhci, int slot_id)
 {
-        int i;
+        int i, s;
+        struct xhci_virt_ep *ep;
+
+        for (i = 0; i < LAST_EP_INDEX + 1; i++) {
+                ep = &xhci->devs[slot_id]->eps[i];
 
-        for (i = 0; i < LAST_EP_INDEX + 1; i++)
-                if (xhci->devs[slot_id]->eps[i].ring &&
-                    xhci->devs[slot_id]->eps[i].ring->dequeue)
+                if (ep->ep_state & EP_HAS_STREAMS) {
+                        for (s = 1; s < ep->stream_info->num_streams; s++)
+                                xhci_ring_ep_doorbell(xhci, slot_id, i, s);
+                } else if (ep->ring && ep->ring->dequeue) {
                         xhci_ring_ep_doorbell(xhci, slot_id, i, 0);
+                }
+        }
 
         return;
 }
@@ -892,7 +899,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         /*
                          * Turn on ports, even if there isn't per-port switching.
                          * HC will report connect events even before this is set.
-                         * However, khubd will ignore the roothub events until
+                         * However, hub_wq will ignore the roothub events until
                          * the roothub is registered.
                          */
                         writel(temp | PORT_POWER, port_array[wIndex]);
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 8936211b161d..5cb3d7a10017 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1904,7 +1904,7 @@ static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
         start_dma = xhci_trb_virt_to_dma(input_seg, start_trb);
         end_dma = xhci_trb_virt_to_dma(input_seg, end_trb);
 
-        seg = trb_in_td(input_seg, start_trb, end_trb, input_dma);
+        seg = trb_in_td(xhci, input_seg, start_trb, end_trb, input_dma, false);
         if (seg != result_seg) {
                 xhci_warn(xhci, "WARN: %s TRB math test %d failed!\n",
                                 test_name, test_number);
@@ -1918,6 +1918,8 @@ static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
                                 end_trb, end_dma);
                 xhci_warn(xhci, "Expected seg %p, got seg %p\n",
                                 result_seg, seg);
+                trb_in_td(xhci, input_seg, start_trb, end_trb, input_dma,
+                          true);
                 return -1;
         }
         return 0;
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index c22a3e15a16e..280dde93abe5 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -40,6 +40,8 @@
 
 static const char hcd_name[] = "xhci_hcd";
 
+static struct hc_driver __read_mostly xhci_pci_hc_driver;
+
 /* called after powerup, by probe or system-pm "wakeup" */
 static int xhci_pci_reinit(struct xhci_hcd *xhci, struct pci_dev *pdev)
 {
@@ -286,7 +288,7 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
          * Systems with the TI redriver that loses port status change events
          * need to have the registers polled during D3, so avoid D3cold.
          */
-        if (xhci_compliance_mode_recovery_timer_quirk_check())
+        if (xhci->quirks & XHCI_COMP_MODE_QUIRK)
                 pdev->no_d3cold = true;
 
         return xhci_suspend(xhci);
@@ -324,68 +326,6 @@ static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
 }
 #endif /* CONFIG_PM */
 
-static const struct hc_driver xhci_pci_hc_driver = {
-        .description =          hcd_name,
-        .product_desc =         "xHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct xhci_hcd *),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  xhci_irq,
-        .flags =                HCD_MEMORY | HCD_USB3 | HCD_SHARED,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                xhci_pci_setup,
-        .start =                xhci_run,
-#ifdef CONFIG_PM
-        .pci_suspend =          xhci_pci_suspend,
-        .pci_resume =           xhci_pci_resume,
-#endif
-        .stop =                 xhci_stop,
-        .shutdown =             xhci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          xhci_urb_enqueue,
-        .urb_dequeue =          xhci_urb_dequeue,
-        .alloc_dev =            xhci_alloc_dev,
-        .free_dev =             xhci_free_dev,
-        .alloc_streams =        xhci_alloc_streams,
-        .free_streams =         xhci_free_streams,
-        .add_endpoint =         xhci_add_endpoint,
-        .drop_endpoint =        xhci_drop_endpoint,
-        .endpoint_reset =       xhci_endpoint_reset,
-        .check_bandwidth =      xhci_check_bandwidth,
-        .reset_bandwidth =      xhci_reset_bandwidth,
-        .address_device =       xhci_address_device,
-        .enable_device =        xhci_enable_device,
-        .update_hub_device =    xhci_update_hub_device,
-        .reset_device =         xhci_discover_or_reset_device,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     xhci_get_frame,
-
-        /* Root hub support */
-        .hub_control =          xhci_hub_control,
-        .hub_status_data =      xhci_hub_status_data,
-        .bus_suspend =          xhci_bus_suspend,
-        .bus_resume =           xhci_bus_resume,
-        /*
-         * call back when device connected and addressed
-         */
-        .update_device =        xhci_update_device,
-        .set_usb2_hw_lpm =      xhci_set_usb2_hardware_lpm,
-        .enable_usb3_lpm_timeout =      xhci_enable_usb3_lpm_timeout,
-        .disable_usb3_lpm_timeout =     xhci_disable_usb3_lpm_timeout,
-        .find_raw_port_number = xhci_find_raw_port_number,
-};
-
 /*-------------------------------------------------------------------------*/
 
 /* PCI driver selection metadata; PCI hotplugging uses this */
@@ -415,12 +355,22 @@ static struct pci_driver xhci_pci_driver = {
 #endif
 };
 
-int __init xhci_register_pci(void)
+static int __init xhci_pci_init(void)
 {
+        xhci_init_driver(&xhci_pci_hc_driver, xhci_pci_setup);
+#ifdef CONFIG_PM
+        xhci_pci_hc_driver.pci_suspend = xhci_pci_suspend;
+        xhci_pci_hc_driver.pci_resume = xhci_pci_resume;
+#endif
         return pci_register_driver(&xhci_pci_driver);
 }
+module_init(xhci_pci_init);
 
-void xhci_unregister_pci(void)
+static void __exit xhci_pci_exit(void)
 {
         pci_unregister_driver(&xhci_pci_driver);
 }
+module_exit(xhci_pci_exit);
+
+MODULE_DESCRIPTION("xHCI PCI Host Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 1a0cf9f31e43..3d78b0cd674b 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -23,6 +23,8 @@
 #include "xhci-mvebu.h"
 #include "xhci-rcar.h"
 
+static struct hc_driver __read_mostly xhci_plat_hc_driver;
+
 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
         /*
@@ -60,59 +62,6 @@ static int xhci_plat_start(struct usb_hcd *hcd)
         return xhci_run(hcd);
 }
 
-static const struct hc_driver xhci_plat_xhci_driver = {
-        .description =          "xhci-hcd",
-        .product_desc =         "xHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct xhci_hcd *),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  xhci_irq,
-        .flags =                HCD_MEMORY | HCD_USB3 | HCD_SHARED,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                xhci_plat_setup,
-        .start =                xhci_plat_start,
-        .stop =                 xhci_stop,
-        .shutdown =             xhci_shutdown,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          xhci_urb_enqueue,
-        .urb_dequeue =          xhci_urb_dequeue,
-        .alloc_dev =            xhci_alloc_dev,
-        .free_dev =             xhci_free_dev,
-        .alloc_streams =        xhci_alloc_streams,
-        .free_streams =         xhci_free_streams,
-        .add_endpoint =         xhci_add_endpoint,
-        .drop_endpoint =        xhci_drop_endpoint,
-        .endpoint_reset =       xhci_endpoint_reset,
-        .check_bandwidth =      xhci_check_bandwidth,
-        .reset_bandwidth =      xhci_reset_bandwidth,
-        .address_device =       xhci_address_device,
-        .enable_device =        xhci_enable_device,
-        .update_hub_device =    xhci_update_hub_device,
-        .reset_device =         xhci_discover_or_reset_device,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     xhci_get_frame,
-
-        /* Root hub support */
-        .hub_control =          xhci_hub_control,
-        .hub_status_data =      xhci_hub_status_data,
-        .bus_suspend =          xhci_bus_suspend,
-        .bus_resume =           xhci_bus_resume,
-
-        .enable_usb3_lpm_timeout =      xhci_enable_usb3_lpm_timeout,
-        .disable_usb3_lpm_timeout =     xhci_disable_usb3_lpm_timeout,
-};
-
 static int xhci_plat_probe(struct platform_device *pdev)
 {
         struct device_node      *node = pdev->dev.of_node;
@@ -128,7 +77,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
         if (usb_disabled())
                 return -ENODEV;
 
-        driver = &xhci_plat_xhci_driver;
+        driver = &xhci_plat_hc_driver;
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
@@ -298,12 +247,19 @@ static struct platform_driver usb_xhci_driver = {
 };
 MODULE_ALIAS("platform:xhci-hcd");
 
-int xhci_register_plat(void)
+static int __init xhci_plat_init(void)
 {
+        xhci_init_driver(&xhci_plat_hc_driver, xhci_plat_setup);
+        xhci_plat_hc_driver.start = xhci_plat_start;
         return platform_driver_register(&usb_xhci_driver);
 }
+module_init(xhci_plat_init);
 
-void xhci_unregister_plat(void)
+static void __exit xhci_plat_exit(void)
 {
         platform_driver_unregister(&usb_xhci_driver);
 }
+module_exit(xhci_plat_exit);
+
+MODULE_DESCRIPTION("xHCI Platform Host Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index abed30b82905..bc6fcbc16f61 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -327,7 +327,6 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
          * We don't want to restart any stream rings if there's a set dequeue
          * pointer command pending because the device can choose to start any
          * stream once the endpoint is on the HW schedule.
-         * FIXME - check all the stream rings for pending cancellations.
          */
         if ((ep_state & EP_HALT_PENDING) || (ep_state & SET_DEQ_PENDING) ||
             (ep_state & EP_HALTED))
@@ -572,40 +571,6 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
         }
 }
 
-static int queue_set_tr_deq(struct xhci_hcd *xhci,
-                struct xhci_command *cmd, int slot_id,
-                unsigned int ep_index, unsigned int stream_id,
-                struct xhci_segment *deq_seg,
-                union xhci_trb *deq_ptr, u32 cycle_state);
-
-void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
-                struct xhci_command *cmd,
-                unsigned int slot_id, unsigned int ep_index,
-                unsigned int stream_id,
-                struct xhci_dequeue_state *deq_state)
-{
-        struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
-
-        xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
-                        "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), "
-                        "new deq ptr = %p (0x%llx dma), new cycle = %u",
-                        deq_state->new_deq_seg,
-                        (unsigned long long)deq_state->new_deq_seg->dma,
-                        deq_state->new_deq_ptr,
-                        (unsigned long long)xhci_trb_virt_to_dma(deq_state->new_deq_seg, deq_state->new_deq_ptr),
-                        deq_state->new_cycle_state);
-        queue_set_tr_deq(xhci, cmd, slot_id, ep_index, stream_id,
-                        deq_state->new_deq_seg,
-                        deq_state->new_deq_ptr,
-                        (u32) deq_state->new_cycle_state);
-        /* Stop the TD queueing code from ringing the doorbell until
-         * this command completes.  The HC won't set the dequeue pointer
-         * if the ring is running, and ringing the doorbell starts the
-         * ring running.
-         */
-        ep->ep_state |= SET_DEQ_PENDING;
-}
-
 static void xhci_stop_watchdog_timer_in_irq(struct xhci_hcd *xhci,
                 struct xhci_virt_ep *ep)
 {
@@ -743,12 +708,8 @@ remove_finished_td:
 
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
-                struct xhci_command *command;
-                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
-                xhci_queue_new_dequeue_state(xhci, command,
-                                slot_id, ep_index,
-                                ep->stopped_td->urb->stream_id,
-                                &deq_state);
+                xhci_queue_new_dequeue_state(xhci, slot_id, ep_index,
+                                ep->stopped_td->urb->stream_id, &deq_state);
                 xhci_ring_cmd_db(xhci);
         } else {
                 /* Otherwise ring the doorbell(s) to restart queued transfers */
@@ -1003,8 +964,7 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
                 xhci_warn(xhci, "WARN Set TR deq ptr command for freed stream ID %u\n",
                                 stream_id);
                 /* XXX: Harmless??? */
-                dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
-                return;
+                goto cleanup;
         }
 
         ep_ctx = xhci_get_ep_ctx(xhci, dev->out_ctx, ep_index);
@@ -1069,6 +1029,7 @@ static void xhci_handle_cmd_set_deq(struct xhci_hcd *xhci, int slot_id,
                 }
         }
 
+cleanup:
         dev->eps[ep_index].ep_state &= ~SET_DEQ_PENDING;
         dev->eps[ep_index].queued_deq_seg = NULL;
         dev->eps[ep_index].queued_deq_ptr = NULL;
@@ -1699,10 +1660,12 @@ cleanup:
  * TRB in this TD, this function returns that TRB's segment.  Otherwise it
  * returns 0.
  */
-struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
+struct xhci_segment *trb_in_td(struct xhci_hcd *xhci,
+                struct xhci_segment *start_seg,
                 union xhci_trb  *start_trb,
                 union xhci_trb  *end_trb,
-                dma_addr_t      suspect_dma)
+                dma_addr_t      suspect_dma,
+                bool            debug)
 {
         dma_addr_t start_dma;
         dma_addr_t end_seg_dma;
@@ -1721,6 +1684,15 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 /* If the end TRB isn't in this segment, this is set to 0 */
                 end_trb_dma = xhci_trb_virt_to_dma(cur_seg, end_trb);
 
+                if (debug)
+                        xhci_warn(xhci,
+                                "Looking for event-dma %016llx trb-start %016llx trb-end %016llx seg-start %016llx seg-end %016llx\n",
+                                (unsigned long long)suspect_dma,
+                                (unsigned long long)start_dma,
+                                (unsigned long long)end_trb_dma,
+                                (unsigned long long)cur_seg->dma,
+                                (unsigned long long)end_seg_dma);
+
                 if (end_trb_dma > 0) {
                         /* The end TRB is in this segment, so suspect should be here */
                         if (start_dma <= end_trb_dma) {
@@ -2453,8 +2425,8 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         td_num--;
 
                 /* Is this a TRB in the currently executing TD? */
-                event_seg = trb_in_td(ep_ring->deq_seg, ep_ring->dequeue,
-                                td->last_trb, event_dma);
+                event_seg = trb_in_td(xhci, ep_ring->deq_seg, ep_ring->dequeue,
+                                td->last_trb, event_dma, false);
 
                 /*
                  * Skip the Force Stopped Event. The event_trb(event_dma) of FSE
@@ -2486,7 +2458,12 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                 /* HC is busted, give up! */
                                 xhci_err(xhci,
                                         "ERROR Transfer event TRB DMA ptr not "
-                                        "part of current TD\n");
+                                        "part of current TD ep_index %d "
+                                        "comp_code %u\n", ep_index,
+                                        trb_comp_code);
+                                trb_in_td(xhci, ep_ring->deq_seg,
+                                          ep_ring->dequeue, td->last_trb,
+                                          event_dma, true);
                                 return -ESHUTDOWN;
                         }
 
@@ -3926,14 +3903,11 @@ int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, struct xhci_command *cmd,
                         trb_slot_id | trb_ep_index | type | trb_suspend, false);
 }
 
-/* Set Transfer Ring Dequeue Pointer command.
- * This should not be used for endpoints that have streams enabled.
- */
-static int queue_set_tr_deq(struct xhci_hcd *xhci, struct xhci_command *cmd,
-                        int slot_id,
-                        unsigned int ep_index, unsigned int stream_id,
-                        struct xhci_segment *deq_seg,
-                        union xhci_trb *deq_ptr, u32 cycle_state)
+/* Set Transfer Ring Dequeue Pointer command */
+void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
+                unsigned int slot_id, unsigned int ep_index,
+                unsigned int stream_id,
+                struct xhci_dequeue_state *deq_state)
 {
         dma_addr_t addr;
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
@@ -3942,28 +3916,59 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, struct xhci_command *cmd,
         u32 trb_sct = 0;
         u32 type = TRB_TYPE(TRB_SET_DEQ);
         struct xhci_virt_ep *ep;
+        struct xhci_command *cmd;
+        int ret;
 
-        addr = xhci_trb_virt_to_dma(deq_seg, deq_ptr);
+        xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
+                "Set TR Deq Ptr cmd, new deq seg = %p (0x%llx dma), new deq ptr = %p (0x%llx dma), new cycle = %u",
+                deq_state->new_deq_seg,
+                (unsigned long long)deq_state->new_deq_seg->dma,
+                deq_state->new_deq_ptr,
+                (unsigned long long)xhci_trb_virt_to_dma(
+                        deq_state->new_deq_seg, deq_state->new_deq_ptr),
+                deq_state->new_cycle_state);
+
+        addr = xhci_trb_virt_to_dma(deq_state->new_deq_seg,
+                                    deq_state->new_deq_ptr);
         if (addr == 0) {
                 xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr\n");
                 xhci_warn(xhci, "WARN deq seg = %p, deq pt = %p\n",
-                                deq_seg, deq_ptr);
-                return 0;
+                          deq_state->new_deq_seg, deq_state->new_deq_ptr);
+                return;
         }
         ep = &xhci->devs[slot_id]->eps[ep_index];
         if ((ep->ep_state & SET_DEQ_PENDING)) {
                 xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr\n");
                 xhci_warn(xhci, "A Set TR Deq Ptr command is pending.\n");
-                return 0;
+                return;
+        }
+
+        /* This function gets called from contexts where it cannot sleep */
+        cmd = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+        if (!cmd) {
+                xhci_warn(xhci, "WARN Cannot submit Set TR Deq Ptr: ENOMEM\n");
+                return;
         }
-        ep->queued_deq_seg = deq_seg;
-        ep->queued_deq_ptr = deq_ptr;
+
+        ep->queued_deq_seg = deq_state->new_deq_seg;
+        ep->queued_deq_ptr = deq_state->new_deq_ptr;
         if (stream_id)
                 trb_sct = SCT_FOR_TRB(SCT_PRI_TR);
-        return queue_command(xhci, cmd,
-                        lower_32_bits(addr) | trb_sct | cycle_state,
-                        upper_32_bits(addr), trb_stream_id,
-                        trb_slot_id | trb_ep_index | type, false);
+        ret = queue_command(xhci, cmd,
+                lower_32_bits(addr) | trb_sct | deq_state->new_cycle_state,
+                upper_32_bits(addr), trb_stream_id,
+                trb_slot_id | trb_ep_index | type, false);
+        if (ret < 0) {
+                xhci_free_command(xhci, cmd);
+                return;
+        }
+
+        /* Stop the TD queueing code from ringing the doorbell until
+         * this command completes.  The HC won't set the dequeue pointer
+         * if the ring is running, and ringing the doorbell starts the
+         * ring running.
+         */
+        ep->ep_state |= SET_DEQ_PENDING;
 }
 
 int xhci_queue_reset_ep(struct xhci_hcd *xhci, struct xhci_command *cmd,
diff --git a/drivers/usb/host/xhci-trace.c b/drivers/usb/host/xhci-trace.c
index 7cf30c83dcf3..367b630bdb3c 100644
--- a/drivers/usb/host/xhci-trace.c
+++ b/drivers/usb/host/xhci-trace.c
@@ -13,3 +13,5 @@
 
 #define CREATE_TRACE_POINTS
 #include "xhci-trace.h"
+
+EXPORT_TRACEPOINT_SYMBOL_GPL(xhci_dbg_quirks);
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index c4a8fca8ae93..2a5d45b4cb15 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -491,7 +491,7 @@ static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci)
  * Systems:
  * Vendor: Hewlett-Packard -> System Models: Z420, Z620 and Z820
  */
-bool xhci_compliance_mode_recovery_timer_quirk_check(void)
+static bool xhci_compliance_mode_recovery_timer_quirk_check(void)
 {
         const char *dmi_product_name, *dmi_sys_vendor;
 
@@ -653,6 +653,7 @@ int xhci_run(struct usb_hcd *hcd)
                         "Finished xhci_run for USB2 roothub");
         return 0;
 }
+EXPORT_SYMBOL_GPL(xhci_run);
 
 static void xhci_only_stop_hcd(struct usb_hcd *hcd)
 {
@@ -871,6 +872,8 @@ int xhci_suspend(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "%s: stopping port polling.\n", __func__);
         clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
         del_timer_sync(&hcd->rh_timer);
+        clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+        del_timer_sync(&xhci->shared_hcd->rh_timer);
 
         spin_lock_irq(&xhci->lock);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
@@ -927,6 +930,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
 
         return rc;
 }
+EXPORT_SYMBOL_GPL(xhci_suspend);
 
 /*
  * start xHC (not bus-specific)
@@ -1075,9 +1079,12 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         xhci_dbg(xhci, "%s: starting port polling.\n", __func__);
         set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
         usb_hcd_poll_rh_status(hcd);
+        set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
+        usb_hcd_poll_rh_status(xhci->shared_hcd);
 
         return retval;
 }
+EXPORT_SYMBOL_GPL(xhci_resume);
 #endif  /* CONFIG_PM */
 
 /*-------------------------------------------------------------------------*/
@@ -2887,14 +2894,9 @@ void xhci_cleanup_stalled_ring(struct xhci_hcd *xhci,
          * issue a configure endpoint command later.
          */
         if (!(xhci->quirks & XHCI_RESET_EP_QUIRK)) {
-                struct xhci_command *command;
-                /* Can't sleep if we're called from cleanup_halted_endpoint() */
-                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
-                if (!command)
-                        return;
                 xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
                                 "Queueing new dequeue state");
-                xhci_queue_new_dequeue_state(xhci, command, udev->slot_id,
+                xhci_queue_new_dequeue_state(xhci, udev->slot_id,
                                 ep_index, ep->stopped_stream, &deq_state);
         } else {
                 /* Better hope no one uses the input context between now and the
@@ -3761,8 +3763,8 @@ disable_slot:
 /*
  * Issue an Address Device command and optionally send a corresponding
  * SetAddress request to 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 should be protected by the usb_address0_mutex in hub_wq's hub_port_init,
+ * so we should only issue and wait on one address command at the same time.
  */
 static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                              enum xhci_setup_dev setup)
@@ -4903,6 +4905,76 @@ error:
         kfree(xhci);
         return retval;
 }
+EXPORT_SYMBOL_GPL(xhci_gen_setup);
+
+static const struct hc_driver xhci_hc_driver = {
+        .description =          "xhci-hcd",
+        .product_desc =         "xHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct xhci_hcd *),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq =                  xhci_irq,
+        .flags =                HCD_MEMORY | HCD_USB3 | HCD_SHARED,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset =                NULL, /* set in xhci_init_driver() */
+        .start =                xhci_run,
+        .stop =                 xhci_stop,
+        .shutdown =             xhci_shutdown,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue =          xhci_urb_enqueue,
+        .urb_dequeue =          xhci_urb_dequeue,
+        .alloc_dev =            xhci_alloc_dev,
+        .free_dev =             xhci_free_dev,
+        .alloc_streams =        xhci_alloc_streams,
+        .free_streams =         xhci_free_streams,
+        .add_endpoint =         xhci_add_endpoint,
+        .drop_endpoint =        xhci_drop_endpoint,
+        .endpoint_reset =       xhci_endpoint_reset,
+        .check_bandwidth =      xhci_check_bandwidth,
+        .reset_bandwidth =      xhci_reset_bandwidth,
+        .address_device =       xhci_address_device,
+        .enable_device =        xhci_enable_device,
+        .update_hub_device =    xhci_update_hub_device,
+        .reset_device =         xhci_discover_or_reset_device,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number =     xhci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_control =          xhci_hub_control,
+        .hub_status_data =      xhci_hub_status_data,
+        .bus_suspend =          xhci_bus_suspend,
+        .bus_resume =           xhci_bus_resume,
+
+        /*
+         * call back when device connected and addressed
+         */
+        .update_device =        xhci_update_device,
+        .set_usb2_hw_lpm =      xhci_set_usb2_hardware_lpm,
+        .enable_usb3_lpm_timeout =      xhci_enable_usb3_lpm_timeout,
+        .disable_usb3_lpm_timeout =     xhci_disable_usb3_lpm_timeout,
+        .find_raw_port_number = xhci_find_raw_port_number,
+};
+
+void xhci_init_driver(struct hc_driver *drv, int (*setup_fn)(struct usb_hcd *))
+{
+        BUG_ON(!setup_fn);
+        *drv = xhci_hc_driver;
+        drv->reset = setup_fn;
+}
+EXPORT_SYMBOL_GPL(xhci_init_driver);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_AUTHOR(DRIVER_AUTHOR);
@@ -4910,18 +4982,6 @@ MODULE_LICENSE("GPL");
 
 static int __init xhci_hcd_init(void)
 {
-        int retval;
-
-        retval = xhci_register_pci();
-        if (retval < 0) {
-                pr_debug("Problem registering PCI driver.\n");
-                return retval;
-        }
-        retval = xhci_register_plat();
-        if (retval < 0) {
-                pr_debug("Problem registering platform driver.\n");
-                goto unreg_pci;
-        }
         /*
          * Check the compiler generated sizes of structures that must be laid
          * out in specific ways for hardware access.
@@ -4940,15 +5000,5 @@ static int __init xhci_hcd_init(void)
         /* xhci_run_regs has eight fields and embeds 128 xhci_intr_regs */
         BUILD_BUG_ON(sizeof(struct xhci_run_regs) != (8+8*128)*32/8);
         return 0;
-unreg_pci:
-        xhci_unregister_pci();
-        return retval;
 }
 module_init(xhci_hcd_init);
-
-static void __exit xhci_hcd_cleanup(void)
-{
-        xhci_unregister_pci();
-        xhci_unregister_plat();
-}
-module_exit(xhci_hcd_cleanup);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index dace5152e179..df76d642e719 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1731,25 +1731,6 @@ void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv);
 void xhci_free_command(struct xhci_hcd *xhci,
                 struct xhci_command *command);
 
-#ifdef CONFIG_PCI
-/* xHCI PCI glue */
-int xhci_register_pci(void);
-void xhci_unregister_pci(void);
-#else
-static inline int xhci_register_pci(void) { return 0; }
-static inline void xhci_unregister_pci(void) {}
-#endif
-
-#if IS_ENABLED(CONFIG_USB_XHCI_PLATFORM)
-int xhci_register_plat(void);
-void xhci_unregister_plat(void);
-#else
-static inline int xhci_register_plat(void)
-{ return 0; }
-static inline void xhci_unregister_plat(void)
-{  }
-#endif
-
 /* xHCI host controller glue */
 typedef void (*xhci_get_quirks_t)(struct device *, struct xhci_hcd *);
 int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
@@ -1762,6 +1743,7 @@ int xhci_run(struct usb_hcd *hcd);
 void xhci_stop(struct usb_hcd *hcd);
 void xhci_shutdown(struct usb_hcd *hcd);
 int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks);
+void xhci_init_driver(struct hc_driver *drv, int (*setup_fn)(struct usb_hcd *));
 
 #ifdef  CONFIG_PM
 int xhci_suspend(struct xhci_hcd *xhci);
@@ -1804,9 +1786,9 @@ void xhci_reset_bandwidth(struct usb_hcd *hcd, struct usb_device *udev);
 
 /* xHCI ring, segment, TRB, and TD functions */
 dma_addr_t xhci_trb_virt_to_dma(struct xhci_segment *seg, union xhci_trb *trb);
-struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
-                union xhci_trb *start_trb, union xhci_trb *end_trb,
-                dma_addr_t suspect_dma);
+struct xhci_segment *trb_in_td(struct xhci_hcd *xhci,
+                struct xhci_segment *start_seg, union xhci_trb *start_trb,
+                union xhci_trb *end_trb, dma_addr_t suspect_dma, bool debug);
 int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code);
 void xhci_ring_cmd_db(struct xhci_hcd *xhci);
 int xhci_queue_slot_control(struct xhci_hcd *xhci, struct xhci_command *cmd,
@@ -1839,7 +1821,6 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int stream_id, struct xhci_td *cur_td,
                 struct xhci_dequeue_state *state);
 void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
-                struct xhci_command *cmd,
                 unsigned int slot_id, unsigned int ep_index,
                 unsigned int stream_id,
                 struct xhci_dequeue_state *deq_state);
@@ -1887,7 +1868,4 @@ struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci,
 struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
 struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int ep_index);
 
-/* xHCI quirks */
-bool xhci_compliance_mode_recovery_timer_quirk_check(void);
-
 #endif /* __LINUX_XHCI_HCD_H */
diff --git a/drivers/usb/misc/lvstest.c b/drivers/usb/misc/lvstest.c
index 7d589c156fb1..62cb8cd08403 100644
--- a/drivers/usb/misc/lvstest.c
+++ b/drivers/usb/misc/lvstest.c
@@ -333,13 +333,13 @@ static void lvs_rh_work(struct work_struct *work)
                                         USB_PORT_STAT_CONNECTION) {
                                 lvs->present = true;
                                 lvs->portnum = i;
-                                if (hcd->phy)
-                                        usb_phy_notify_connect(hcd->phy,
+                                if (hcd->usb_phy)
+                                        usb_phy_notify_connect(hcd->usb_phy,
                                                         USB_SPEED_SUPER);
                         } else {
                                 lvs->present = false;
-                                if (hcd->phy)
-                                        usb_phy_notify_disconnect(hcd->phy,
+                                if (hcd->usb_phy)
+                                        usb_phy_notify_disconnect(hcd->usb_phy,
                                                         USB_SPEED_SUPER);
                         }
                         break;
diff --git a/drivers/usb/misc/usb3503.c b/drivers/usb/misc/usb3503.c
index 47cb143716a1..ae7e1206ca54 100644
--- a/drivers/usb/misc/usb3503.c
+++ b/drivers/usb/misc/usb3503.c
@@ -98,7 +98,7 @@ static int usb3503_connect(struct usb3503 *hub)
                         return err;
                 }
 
-                /* PDS : Disable For Self Powered Operation */
+                /* PDS : Set the ports which are disabled in self-powered mode. */
                 if (hub->port_off_mask) {
                         err = regmap_update_bits(hub->regmap, USB3503_PDS,
                                         hub->port_off_mask,
@@ -109,7 +109,7 @@ static int usb3503_connect(struct usb3503 *hub)
                         }
                 }
 
-                /* CFG1 : SELF_BUS_PWR -> Self-Powerd operation */
+                /* CFG1 : Set SELF_BUS_PWR, this enables self-powered operation. */
                 err = regmap_update_bits(hub->regmap, USB3503_CFG1,
                                          USB3503_SELF_BUS_PWR,
                                          USB3503_SELF_BUS_PWR);
@@ -271,7 +271,7 @@ static int usb3503_probe(struct usb3503 *hub)
                                             "usb3503 intn");
                 if (err) {
                         dev_err(dev,
-                                "unable to request GPIO %d as connect pin (%d)\n",
+                                "unable to request GPIO %d as interrupt pin (%d)\n",
                                 hub->gpio_intn, err);
                         return err;
                 }
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 829f446064ea..0bbafe795a72 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -54,6 +54,7 @@ struct usbtest_info {
         unsigned                autoconf:1;
         unsigned                ctrl_out:1;
         unsigned                iso:1;          /* try iso in/out */
+        unsigned                intr:1;         /* try interrupt in/out */
         int                     alt;
 };
 
@@ -70,7 +71,10 @@ struct usbtest_dev {
         int                     out_pipe;
         int                     in_iso_pipe;
         int                     out_iso_pipe;
+        int                     in_int_pipe;
+        int                     out_int_pipe;
         struct usb_endpoint_descriptor  *iso_in, *iso_out;
+        struct usb_endpoint_descriptor  *int_in, *int_out;
         struct mutex            lock;
 
 #define TBUF_SIZE       256
@@ -101,6 +105,7 @@ get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
         struct usb_host_interface       *alt;
         struct usb_host_endpoint        *in, *out;
         struct usb_host_endpoint        *iso_in, *iso_out;
+        struct usb_host_endpoint        *int_in, *int_out;
         struct usb_device               *udev;
 
         for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
@@ -108,6 +113,7 @@ get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
 
                 in = out = NULL;
                 iso_in = iso_out = NULL;
+                int_in = int_out = NULL;
                 alt = intf->altsetting + tmp;
 
                 if (override_alt >= 0 &&
@@ -124,6 +130,9 @@ get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
                         switch (usb_endpoint_type(&e->desc)) {
                         case USB_ENDPOINT_XFER_BULK:
                                 break;
+                        case USB_ENDPOINT_XFER_INT:
+                                if (dev->info->intr)
+                                        goto try_intr;
                         case USB_ENDPOINT_XFER_ISOC:
                                 if (dev->info->iso)
                                         goto try_iso;
@@ -139,6 +148,15 @@ get_endpoints(struct usbtest_dev *dev, struct usb_interface *intf)
                                         out = e;
                         }
                         continue;
+try_intr:
+                        if (usb_endpoint_dir_in(&e->desc)) {
+                                if (!int_in)
+                                        int_in = e;
+                        } else {
+                                if (!int_out)
+                                        int_out = e;
+                        }
+                        continue;
 try_iso:
                         if (usb_endpoint_dir_in(&e->desc)) {
                                 if (!iso_in)
@@ -148,7 +166,7 @@ try_iso:
                                         iso_out = e;
                         }
                 }
-                if ((in && out)  ||  iso_in || iso_out)
+                if ((in && out)  ||  iso_in || iso_out || int_in || int_out)
                         goto found;
         }
         return -EINVAL;
@@ -183,6 +201,20 @@ found:
                                 iso_out->desc.bEndpointAddress
                                         & USB_ENDPOINT_NUMBER_MASK);
         }
+
+        if (int_in) {
+                dev->int_in = &int_in->desc;
+                dev->in_int_pipe = usb_rcvintpipe(udev,
+                                int_in->desc.bEndpointAddress
+                                        & USB_ENDPOINT_NUMBER_MASK);
+        }
+
+        if (int_out) {
+                dev->int_out = &int_out->desc;
+                dev->out_int_pipe = usb_sndintpipe(udev,
+                                int_out->desc.bEndpointAddress
+                                        & USB_ENDPOINT_NUMBER_MASK);
+        }
         return 0;
 }
 
@@ -205,14 +237,22 @@ static struct urb *usbtest_alloc_urb(
         int                     pipe,
         unsigned long           bytes,
         unsigned                transfer_flags,
-        unsigned                offset)
+        unsigned                offset,
+        u8                      bInterval)
 {
         struct urb              *urb;
 
         urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!urb)
                 return urb;
-        usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, simple_callback, NULL);
+
+        if (bInterval)
+                usb_fill_int_urb(urb, udev, pipe, NULL, bytes, simple_callback,
+                                NULL, bInterval);
+        else
+                usb_fill_bulk_urb(urb, udev, pipe, NULL, bytes, simple_callback,
+                                NULL);
+
         urb->interval = (udev->speed == USB_SPEED_HIGH)
                         ? (INTERRUPT_RATE << 3)
                         : INTERRUPT_RATE;
@@ -251,9 +291,11 @@ static struct urb *usbtest_alloc_urb(
 static struct urb *simple_alloc_urb(
         struct usb_device       *udev,
         int                     pipe,
-        unsigned long           bytes)
+        unsigned long           bytes,
+        u8                      bInterval)
 {
-        return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0);
+        return usbtest_alloc_urb(udev, pipe, bytes, URB_NO_TRANSFER_DMA_MAP, 0,
+                        bInterval);
 }
 
 static unsigned pattern;
@@ -1255,7 +1297,7 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
                         goto cleanup;
                 }
                 req.wLength = cpu_to_le16(len);
-                urb[i] = u = simple_alloc_urb(udev, pipe, len);
+                urb[i] = u = simple_alloc_urb(udev, pipe, len, 0);
                 if (!u)
                         goto cleanup;
 
@@ -1328,7 +1370,7 @@ static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
         int                     retval = 0;
 
         init_completion(&completion);
-        urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size);
+        urb = simple_alloc_urb(testdev_to_usbdev(dev), pipe, size, 0);
         if (!urb)
                 return -ENOMEM;
         urb->context = &completion;
@@ -1616,9 +1658,9 @@ static int halt_simple(struct usbtest_dev *dev)
         struct usb_device       *udev = testdev_to_usbdev(dev);
 
         if (udev->speed == USB_SPEED_SUPER)
-                urb = simple_alloc_urb(udev, 0, 1024);
+                urb = simple_alloc_urb(udev, 0, 1024, 0);
         else
-                urb = simple_alloc_urb(udev, 0, 512);
+                urb = simple_alloc_urb(udev, 0, 512, 0);
         if (urb == NULL)
                 return -ENOMEM;
 
@@ -1962,7 +2004,7 @@ static int test_unaligned_bulk(
 {
         int retval;
         struct urb *urb = usbtest_alloc_urb(
-                testdev_to_usbdev(tdev), pipe, length, transfer_flags, 1);
+                testdev_to_usbdev(tdev), pipe, length, transfer_flags, 1, 0);
 
         if (!urb)
                 return -ENOMEM;
@@ -1989,7 +2031,7 @@ static int test_unaligned_bulk(
  *
  * WARNING:  Because usbfs grabs udev->dev.sem before calling this ioctl(),
  * it locks out usbcore in certain code paths.  Notably, if you disconnect
- * the device-under-test, khubd will wait block forever waiting for the
+ * the device-under-test, hub_wq will wait block forever waiting for the
  * ioctl to complete ... so that usb_disconnect() can abort the pending
  * urbs and then call usbtest_disconnect().  To abort a test, you're best
  * off just killing the userspace task and waiting for it to exit.
@@ -2068,7 +2110,7 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 1:  write %d bytes %u times\n",
                                 param->length, param->iterations);
-                urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
@@ -2083,7 +2125,7 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 2:  read %d bytes %u times\n",
                                 param->length, param->iterations);
-                urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
@@ -2098,7 +2140,7 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 3:  write/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
-                urb = simple_alloc_urb(udev, dev->out_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->out_pipe, param->length, 0);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
@@ -2114,7 +2156,7 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                 dev_info(&intf->dev,
                                 "TEST 4:  read/%d 0..%d bytes %u times\n",
                                 param->vary, param->length, param->iterations);
-                urb = simple_alloc_urb(udev, dev->in_pipe, param->length);
+                urb = simple_alloc_urb(udev, dev->in_pipe, param->length, 0);
                 if (!urb) {
                         retval = -ENOMEM;
                         break;
@@ -2411,6 +2453,39 @@ usbtest_ioctl(struct usb_interface *intf, unsigned int code, void *buf)
                 }
                 break;
 
+        /* Simple non-queued interrupt I/O tests */
+        case 25:
+                if (dev->out_int_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                                "TEST 25: write %d bytes %u times\n",
+                                param->length, param->iterations);
+                urb = simple_alloc_urb(udev, dev->out_int_pipe, param->length,
+                                dev->int_out->bInterval);
+                if (!urb) {
+                        retval = -ENOMEM;
+                        break;
+                }
+                /* FIRMWARE: interrupt sink (maybe accepts short writes) */
+                retval = simple_io(dev, urb, param->iterations, 0, 0, "test25");
+                simple_free_urb(urb);
+                break;
+        case 26:
+                if (dev->in_int_pipe == 0)
+                        break;
+                dev_info(&intf->dev,
+                                "TEST 26: read %d bytes %u times\n",
+                                param->length, param->iterations);
+                urb = simple_alloc_urb(udev, dev->in_int_pipe, param->length,
+                                dev->int_in->bInterval);
+                if (!urb) {
+                        retval = -ENOMEM;
+                        break;
+                }
+                /* FIRMWARE: interrupt source (maybe generates short writes) */
+                retval = simple_io(dev, urb, param->iterations, 0, 0, "test26");
+                simple_free_urb(urb);
+                break;
         }
         do_gettimeofday(&param->duration);
         param->duration.tv_sec -= start.tv_sec;
@@ -2447,6 +2522,7 @@ usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
         struct usbtest_info     *info;
         char                    *rtest, *wtest;
         char                    *irtest, *iwtest;
+        char                    *intrtest, *intwtest;
 
         udev = interface_to_usbdev(intf);
 
@@ -2487,6 +2563,7 @@ usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
          */
         rtest = wtest = "";
         irtest = iwtest = "";
+        intrtest = intwtest = "";
         if (force_interrupt || udev->speed == USB_SPEED_LOW) {
                 if (info->ep_in) {
                         dev->in_pipe = usb_rcvintpipe(udev, info->ep_in);
@@ -2525,15 +2602,20 @@ usbtest_probe(struct usb_interface *intf, const struct usb_device_id *id)
                         irtest = " iso-in";
                 if (dev->out_iso_pipe)
                         iwtest = " iso-out";
+                if (dev->in_int_pipe)
+                        intrtest = " int-in";
+                if (dev->out_int_pipe)
+                        intwtest = " int-out";
         }
 
         usb_set_intfdata(intf, dev);
         dev_info(&intf->dev, "%s\n", info->name);
-        dev_info(&intf->dev, "%s {control%s%s%s%s%s} tests%s\n",
+        dev_info(&intf->dev, "%s {control%s%s%s%s%s%s%s} tests%s\n",
                         usb_speed_string(udev->speed),
                         info->ctrl_out ? " in/out" : "",
                         rtest, wtest,
                         irtest, iwtest,
+                        intrtest, intwtest,
                         info->alt >= 0 ? " (+alt)" : "");
         return 0;
 }
@@ -2607,6 +2689,7 @@ static struct usbtest_info gz_info = {
         .autoconf       = 1,
         .ctrl_out       = 1,
         .iso            = 1,
+        .intr           = 1,
         .alt            = 0,
 };
 
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
index 1472805083de..c3a45da11610 100644
--- a/drivers/usb/misc/yurex.c
+++ b/drivers/usb/misc/yurex.c
@@ -358,7 +358,7 @@ static int yurex_fasync(int fd, struct file *file, int on)
 {
         struct usb_yurex *dev;
 
-        dev = (struct usb_yurex *)file->private_data;
+        dev = file->private_data;
         return fasync_helper(fd, file, on, &dev->async_queue);
 }
 
@@ -401,7 +401,7 @@ static int yurex_release(struct inode *inode, struct file *file)
 {
         struct usb_yurex *dev;
 
-        dev = (struct usb_yurex *)file->private_data;
+        dev = file->private_data;
         if (dev == NULL)
                 return -ENODEV;
 
@@ -418,7 +418,7 @@ static ssize_t yurex_read(struct file *file, char *buffer, size_t count, loff_t
         char in_buffer[20];
         unsigned long flags;
 
-        dev = (struct usb_yurex *)file->private_data;
+        dev = file->private_data;
 
         mutex_lock(&dev->io_mutex);
         if (!dev->interface) {          /* already disconnected */
@@ -455,7 +455,7 @@ static ssize_t yurex_write(struct file *file, const char *user_buffer, size_t co
         DEFINE_WAIT(wait);
 
         count = min(sizeof(buffer), count);
-        dev = (struct usb_yurex *)file->private_data;
+        dev = file->private_data;
 
         /* verify that we actually have some data to write */
         if (count == 0)
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index 0a34dd859555..a2735df24cc6 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -1,3 +1,4 @@
+
 /*
  * Texas Instruments AM35x "glue layer"
  *
diff --git a/drivers/usb/musb/musb_cppi41.c b/drivers/usb/musb/musb_cppi41.c
index 3ee133f675ab..acdfb3e68a90 100644
--- a/drivers/usb/musb/musb_cppi41.c
+++ b/drivers/usb/musb/musb_cppi41.c
@@ -212,7 +212,7 @@ static enum hrtimer_restart cppi41_recheck_tx_req(struct hrtimer *timer)
         if (!list_empty(&controller->early_tx_list)) {
                 ret = HRTIMER_RESTART;
                 hrtimer_forward_now(&controller->early_tx,
-                                ktime_set(0, 50 * NSEC_PER_USEC));
+                                ktime_set(0, 20 * NSEC_PER_USEC));
         }
 
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -290,7 +290,7 @@ static void cppi41_dma_callback(void *private_data)
 
                         hrtimer_start_range_ns(&controller->early_tx,
                                 ktime_set(0, usecs * NSEC_PER_USEC),
-                                40 * NSEC_PER_USEC,
+                                20 * NSEC_PER_USEC,
                                 HRTIMER_MODE_REL);
                 }
         }
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index c791ba5da91a..154bcf1b5dfa 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -870,6 +870,7 @@ static int dsps_suspend(struct device *dev)
         struct musb *musb = platform_get_drvdata(glue->musb);
         void __iomem *mbase = musb->ctrl_base;
 
+        del_timer_sync(&glue->timer);
         glue->context.control = dsps_readl(mbase, wrp->control);
         glue->context.epintr = dsps_readl(mbase, wrp->epintr_set);
         glue->context.coreintr = dsps_readl(mbase, wrp->coreintr_set);
@@ -895,6 +896,7 @@ static int dsps_resume(struct device *dev)
         dsps_writel(mbase, wrp->mode, glue->context.mode);
         dsps_writel(mbase, wrp->tx_mode, glue->context.tx_mode);
         dsps_writel(mbase, wrp->rx_mode, glue->context.rx_mode);
+        setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
 
         return 0;
 }
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index d4aa779339f1..24c8c0219790 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -176,7 +176,7 @@ __acquires(ep->musb->lock)
                                 ep->end_point.name, request,
                                 req->request.actual, req->request.length,
                                 request->status);
-        req->request.complete(&req->ep->end_point, &req->request);
+        usb_gadget_giveback_request(&req->ep->end_point, &req->request);
         spin_lock(&musb->lock);
         ep->busy = busy;
 }
diff --git a/drivers/usb/musb/musb_regs.h b/drivers/usb/musb/musb_regs.h
index b9bcda5e3945..37122a480bc1 100644
--- a/drivers/usb/musb/musb_regs.h
+++ b/drivers/usb/musb/musb_regs.h
@@ -577,7 +577,7 @@ static inline u16 musb_read_hwvers(void __iomem *mbase)
 {
         /*
          * This register is invisible on Blackfin, actually the MUSB
-         * RTL version of Blackfin is 1.9, so just harcode its value.
+         * RTL version of Blackfin is 1.9, so just hardcode its value.
          */
         return MUSB_HWVERS_1900;
 }
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 7dfc6cb732c9..2daa779f1382 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -433,7 +433,7 @@ static void musb_do_idle(unsigned long _musb)
         if (!musb->is_active) {
                 u32     wakeups;
 
-                /* wait until khubd handles port change status */
+                /* wait until hub_wq handles port change status */
                 if (is_host_active(musb) && (musb->port1_status >> 16))
                         goto done;
 
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index e253fa05be68..0cd1f44f0ee8 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -78,22 +78,6 @@ config SAMSUNG_USBPHY
           This driver provides common interface to interact, for Samsung USB 2.0 PHY
           driver and later for Samsung USB 3.0 PHY driver.
 
-config SAMSUNG_USB2PHY
-        tristate "Samsung USB 2.0 PHY controller Driver"
-        select SAMSUNG_USBPHY
-        select USB_PHY
-        help
-          Enable this to support Samsung USB 2.0 (High Speed) PHY controller
-          driver for Samsung SoCs.
-
-config SAMSUNG_USB3PHY
-        tristate "Samsung USB 3.0 PHY controller Driver"
-        select SAMSUNG_USBPHY
-        select USB_PHY
-        help
-          Enable this to support Samsung USB 3.0 (Super Speed) phy controller
-          for samsung SoCs.
-
 config TWL6030_USB
         tristate "TWL6030 USB Transceiver Driver"
         depends on TWL4030_CORE && OMAP_USB2 && USB_MUSB_OMAP2PLUS
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index 24a91332d4ad..75f2bba58c84 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -15,8 +15,6 @@ obj-$(CONFIG_AM335X_CONTROL_USB)	+= phy-am335x-control.o
 obj-$(CONFIG_AM335X_PHY_USB)            += phy-am335x.o
 obj-$(CONFIG_OMAP_OTG)                  += phy-omap-otg.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_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
diff --git a/drivers/usb/phy/phy-fsl-usb.c b/drivers/usb/phy/phy-fsl-usb.c
index 2b0f968d9325..f1ea5990a50a 100644
--- a/drivers/usb/phy/phy-fsl-usb.c
+++ b/drivers/usb/phy/phy-fsl-usb.c
@@ -609,7 +609,7 @@ static int fsl_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
                 otg->host->otg_port = fsl_otg_initdata.otg_port;
                 otg->host->is_b_host = otg_dev->fsm.id;
                 /*
-                 * must leave time for khubd to finish its thing
+                 * must leave time for hub_wq to finish its thing
                  * before yanking the host driver out from under it,
                  * so suspend the host after a short delay.
                  */
diff --git a/drivers/usb/phy/phy-isp1301-omap.c b/drivers/usb/phy/phy-isp1301-omap.c
index 69e49be8866b..8eea56d3ded6 100644
--- a/drivers/usb/phy/phy-isp1301-omap.c
+++ b/drivers/usb/phy/phy-isp1301-omap.c
@@ -1011,7 +1011,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                                 break;
                         case OTG_STATE_A_WAIT_VFALL:
                                 state = OTG_STATE_A_IDLE;
-                                /* khubd may take a while to notice and
+                                /* hub_wq may take a while to notice and
                                  * handle this disconnect, so don't go
                                  * to B_IDLE quite yet.
                                  */
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index afc09087ec36..7843ef7dd0ff 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -281,7 +281,7 @@ static int msm_otg_phy_clk_reset(struct msm_otg *motg)
 {
         int ret = 0;
 
-        if (motg->pdata->phy_clk_reset && motg->phy_reset_clk)
+        if (motg->pdata->phy_clk_reset)
                 ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
         else if (motg->phy_rst)
                 ret = reset_control_reset(motg->phy_rst);
@@ -1394,7 +1394,7 @@ out:
         return status;
 }
 
-const struct file_operations msm_otg_mode_fops = {
+static const struct file_operations msm_otg_mode_fops = {
         .open = msm_otg_mode_open,
         .read = seq_read,
         .write = msm_otg_mode_write,
@@ -1554,11 +1554,14 @@ static int msm_otg_probe(struct platform_device *pdev)
         phy = &motg->phy;
         phy->dev = &pdev->dev;
 
-        motg->phy_reset_clk = devm_clk_get(&pdev->dev,
+        if (motg->pdata->phy_clk_reset) {
+                motg->phy_reset_clk = devm_clk_get(&pdev->dev,
                                            np ? "phy" : "usb_phy_clk");
-        if (IS_ERR(motg->phy_reset_clk)) {
-                dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
-                motg->phy_reset_clk = NULL;
+
+                if (IS_ERR(motg->phy_reset_clk)) {
+                        dev_err(&pdev->dev, "failed to get usb_phy_clk\n");
+                        return PTR_ERR(motg->phy_reset_clk);
+                }
         }
 
         motg->clk = devm_clk_get(&pdev->dev, np ? "core" : "usb_hs_clk");
@@ -1838,7 +1841,6 @@ static struct platform_driver msm_otg_driver = {
         .remove = msm_otg_remove,
         .driver = {
                 .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
                 .pm = &msm_otg_dev_pm_ops,
                 .of_match_table = msm_otg_dt_match,
         },
diff --git a/drivers/usb/phy/phy-mxs-usb.c b/drivers/usb/phy/phy-mxs-usb.c
index 00972eca04e7..0e0c41587a08 100644
--- a/drivers/usb/phy/phy-mxs-usb.c
+++ b/drivers/usb/phy/phy-mxs-usb.c
@@ -125,6 +125,11 @@ static const struct mxs_phy_data imx6sl_phy_data = {
                 MXS_PHY_NEED_IP_FIX,
 };
 
+static const struct mxs_phy_data vf610_phy_data = {
+        .flags = MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS |
+                MXS_PHY_NEED_IP_FIX,
+};
+
 static const struct mxs_phy_data imx6sx_phy_data = {
         .flags = MXS_PHY_DISCONNECT_LINE_WITHOUT_VBUS |
                 MXS_PHY_NEED_IP_FIX,
@@ -135,6 +140,7 @@ static const struct of_device_id mxs_phy_dt_ids[] = {
         { .compatible = "fsl,imx6sl-usbphy", .data = &imx6sl_phy_data, },
         { .compatible = "fsl,imx6q-usbphy", .data = &imx6q_phy_data, },
         { .compatible = "fsl,imx23-usbphy", .data = &imx23_phy_data, },
+        { .compatible = "fsl,vf610-usbphy", .data = &vf610_phy_data, },
         { /* sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, mxs_phy_dt_ids);
diff --git a/drivers/usb/phy/phy-samsung-usb.c b/drivers/usb/phy/phy-samsung-usb.c
deleted file mode 100644
index ac025ca08425..000000000000
--- a/drivers/usb/phy/phy-samsung-usb.c
+++ /dev/null
@@ -1,241 +0,0 @@
-/* linux/drivers/usb/phy/phy-samsung-usb.c
- *
- * Copyright (c) 2012 Samsung Electronics Co., Ltd.
- *              http://www.samsung.com
- *
- * Author: Praveen Paneri <p.paneri@samsung.com>
- *
- * Samsung USB-PHY helper driver with common function calls;
- * interacts with Samsung USB 2.0 PHY controller driver and later
- * with Samsung USB 3.0 PHY driver.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/of.h>
-#include <linux/of_address.h>
-#include <linux/usb/samsung_usb_phy.h>
-
-#include "phy-samsung-usb.h"
-
-int samsung_usbphy_parse_dt(struct samsung_usbphy *sphy)
-{
-        struct device_node *usbphy_sys;
-
-        /* Getting node for system controller interface for usb-phy */
-        usbphy_sys = of_get_child_by_name(sphy->dev->of_node, "usbphy-sys");
-        if (!usbphy_sys) {
-                dev_err(sphy->dev, "No sys-controller interface for usb-phy\n");
-                return -ENODEV;
-        }
-
-        sphy->pmuregs = of_iomap(usbphy_sys, 0);
-
-        if (sphy->pmuregs == NULL) {
-                dev_err(sphy->dev, "Can't get usb-phy pmu control register\n");
-                goto err0;
-        }
-
-        sphy->sysreg = of_iomap(usbphy_sys, 1);
-
-        /*
-         * Not returning error code here, since this situation is not fatal.
-         * Few SoCs may not have this switch available
-         */
-        if (sphy->sysreg == NULL)
-                dev_warn(sphy->dev, "Can't get usb-phy sysreg cfg register\n");
-
-        of_node_put(usbphy_sys);
-
-        return 0;
-
-err0:
-        of_node_put(usbphy_sys);
-        return -ENXIO;
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_parse_dt);
-
-/*
- * Set isolation here for phy.
- * Here 'on = true' would mean USB PHY block is isolated, hence
- * de-activated and vice-versa.
- */
-void samsung_usbphy_set_isolation_4210(struct samsung_usbphy *sphy, bool on)
-{
-        void __iomem *reg = NULL;
-        u32 reg_val;
-        u32 en_mask = 0;
-
-        if (!sphy->pmuregs) {
-                dev_warn(sphy->dev, "Can't set pmu isolation\n");
-                return;
-        }
-
-        if (sphy->phy_type == USB_PHY_TYPE_DEVICE) {
-                reg = sphy->pmuregs + sphy->drv_data->devphy_reg_offset;
-                en_mask = sphy->drv_data->devphy_en_mask;
-        } else if (sphy->phy_type == USB_PHY_TYPE_HOST) {
-                reg = sphy->pmuregs + sphy->drv_data->hostphy_reg_offset;
-                en_mask = sphy->drv_data->hostphy_en_mask;
-        }
-
-        reg_val = readl(reg);
-
-        if (on)
-                reg_val &= ~en_mask;
-        else
-                reg_val |= en_mask;
-
-        writel(reg_val, reg);
-
-        if (sphy->drv_data->cpu_type == TYPE_EXYNOS4X12) {
-                writel(reg_val, sphy->pmuregs + EXYNOS4X12_PHY_HSIC_CTRL0);
-                writel(reg_val, sphy->pmuregs + EXYNOS4X12_PHY_HSIC_CTRL1);
-        }
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_set_isolation_4210);
-
-/*
- * Configure the mode of working of usb-phy here: HOST/DEVICE.
- */
-void samsung_usbphy_cfg_sel(struct samsung_usbphy *sphy)
-{
-        u32 reg;
-
-        if (!sphy->sysreg) {
-                dev_warn(sphy->dev, "Can't configure specified phy mode\n");
-                return;
-        }
-
-        reg = readl(sphy->sysreg);
-
-        if (sphy->phy_type == USB_PHY_TYPE_DEVICE)
-                reg &= ~EXYNOS_USB20PHY_CFG_HOST_LINK;
-        else if (sphy->phy_type == USB_PHY_TYPE_HOST)
-                reg |= EXYNOS_USB20PHY_CFG_HOST_LINK;
-
-        writel(reg, sphy->sysreg);
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_cfg_sel);
-
-/*
- * PHYs are different for USB Device and USB Host.
- * This make sure that correct PHY type is selected before
- * any operation on PHY.
- */
-int samsung_usbphy_set_type(struct usb_phy *phy,
-                                enum samsung_usb_phy_type phy_type)
-{
-        struct samsung_usbphy *sphy = phy_to_sphy(phy);
-
-        sphy->phy_type = phy_type;
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_set_type);
-
-int samsung_usbphy_rate_to_clksel_64xx(struct samsung_usbphy *sphy,
-                                                        unsigned long rate)
-{
-        unsigned int clksel;
-
-        switch (rate) {
-        case 12 * MHZ:
-                clksel = PHYCLK_CLKSEL_12M;
-                break;
-        case 24 * MHZ:
-                clksel = PHYCLK_CLKSEL_24M;
-                break;
-        case 48 * MHZ:
-                clksel = PHYCLK_CLKSEL_48M;
-                break;
-        default:
-                dev_err(sphy->dev,
-                        "Invalid reference clock frequency: %lu\n", rate);
-                return -EINVAL;
-        }
-
-        return clksel;
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_rate_to_clksel_64xx);
-
-int samsung_usbphy_rate_to_clksel_4x12(struct samsung_usbphy *sphy,
-                                                        unsigned long rate)
-{
-        unsigned int clksel;
-
-        switch (rate) {
-        case 9600 * KHZ:
-                clksel = FSEL_CLKSEL_9600K;
-                break;
-        case 10 * MHZ:
-                clksel = FSEL_CLKSEL_10M;
-                break;
-        case 12 * MHZ:
-                clksel = FSEL_CLKSEL_12M;
-                break;
-        case 19200 * KHZ:
-                clksel = FSEL_CLKSEL_19200K;
-                break;
-        case 20 * MHZ:
-                clksel = FSEL_CLKSEL_20M;
-                break;
-        case 24 * MHZ:
-                clksel = FSEL_CLKSEL_24M;
-                break;
-        case 50 * MHZ:
-                clksel = FSEL_CLKSEL_50M;
-                break;
-        default:
-                dev_err(sphy->dev,
-                        "Invalid reference clock frequency: %lu\n", rate);
-                return -EINVAL;
-        }
-
-        return clksel;
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_rate_to_clksel_4x12);
-
-/*
- * Returns reference clock frequency selection value
- */
-int samsung_usbphy_get_refclk_freq(struct samsung_usbphy *sphy)
-{
-        struct clk *ref_clk;
-        unsigned long rate;
-        int refclk_freq;
-
-        /*
-         * In exynos5250 USB host and device PHY use
-         * external crystal clock XXTI
-         */
-        if (sphy->drv_data->cpu_type == TYPE_EXYNOS5250)
-                ref_clk = clk_get(sphy->dev, "ext_xtal");
-        else
-                ref_clk = clk_get(sphy->dev, "xusbxti");
-        if (IS_ERR(ref_clk)) {
-                dev_err(sphy->dev, "Failed to get reference clock\n");
-                return PTR_ERR(ref_clk);
-        }
-
-        rate = clk_get_rate(ref_clk);
-        refclk_freq = sphy->drv_data->rate_to_clksel(sphy, rate);
-
-        clk_put(ref_clk);
-
-        return refclk_freq;
-}
-EXPORT_SYMBOL_GPL(samsung_usbphy_get_refclk_freq);
diff --git a/drivers/usb/phy/phy-samsung-usb.h b/drivers/usb/phy/phy-samsung-usb.h
deleted file mode 100644
index 80eedd45a20a..000000000000
--- a/drivers/usb/phy/phy-samsung-usb.h
+++ /dev/null
@@ -1,349 +0,0 @@
-/* linux/drivers/usb/phy/phy-samsung-usb.h
- *
- * Copyright (c) 2012 Samsung Electronics Co., Ltd.
- *              http://www.samsung.com
- *
- * Samsung USB-PHY transceiver; talks to S3C HS OTG controller, EHCI-S5P and
- * OHCI-EXYNOS controllers.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#include <linux/usb/phy.h>
-
-/* Register definitions */
-
-#define SAMSUNG_PHYPWR                          (0x00)
-
-#define PHYPWR_NORMAL_MASK                      (0x19 << 0)
-#define PHYPWR_OTG_DISABLE                      (0x1 << 4)
-#define PHYPWR_ANALOG_POWERDOWN                 (0x1 << 3)
-#define PHYPWR_FORCE_SUSPEND                    (0x1 << 1)
-/* For Exynos4 */
-#define PHYPWR_NORMAL_MASK_PHY0                 (0x39 << 0)
-#define PHYPWR_SLEEP_PHY0                       (0x1 << 5)
-
-#define SAMSUNG_PHYCLK                          (0x04)
-
-#define PHYCLK_MODE_USB11                       (0x1 << 6)
-#define PHYCLK_EXT_OSC                          (0x1 << 5)
-#define PHYCLK_COMMON_ON_N                      (0x1 << 4)
-#define PHYCLK_ID_PULL                          (0x1 << 2)
-#define PHYCLK_CLKSEL_MASK                      (0x3 << 0)
-#define PHYCLK_CLKSEL_48M                       (0x0 << 0)
-#define PHYCLK_CLKSEL_12M                       (0x2 << 0)
-#define PHYCLK_CLKSEL_24M                       (0x3 << 0)
-
-#define SAMSUNG_RSTCON                          (0x08)
-
-#define RSTCON_PHYLINK_SWRST                    (0x1 << 2)
-#define RSTCON_HLINK_SWRST                      (0x1 << 1)
-#define RSTCON_SWRST                            (0x1 << 0)
-
-/* EXYNOS4X12 */
-#define EXYNOS4X12_PHY_HSIC_CTRL0               (0x04)
-#define EXYNOS4X12_PHY_HSIC_CTRL1               (0x08)
-
-#define PHYPWR_NORMAL_MASK_HSIC1                (0x7 << 12)
-#define PHYPWR_NORMAL_MASK_HSIC0                (0x7 << 9)
-#define PHYPWR_NORMAL_MASK_PHY1                 (0x7 << 6)
-
-#define RSTCON_HOSTPHY_SWRST                    (0xf << 3)
-
-/* EXYNOS5 */
-#define EXYNOS5_PHY_HOST_CTRL0                  (0x00)
-
-#define HOST_CTRL0_PHYSWRSTALL                  (0x1 << 31)
-
-#define HOST_CTRL0_REFCLKSEL_MASK               (0x3 << 19)
-#define HOST_CTRL0_REFCLKSEL_XTAL               (0x0 << 19)
-#define HOST_CTRL0_REFCLKSEL_EXTL               (0x1 << 19)
-#define HOST_CTRL0_REFCLKSEL_CLKCORE            (0x2 << 19)
-
-#define HOST_CTRL0_FSEL_MASK                    (0x7 << 16)
-#define HOST_CTRL0_FSEL(_x)                     ((_x) << 16)
-
-#define FSEL_CLKSEL_50M                         (0x7)
-#define FSEL_CLKSEL_24M                         (0x5)
-#define FSEL_CLKSEL_20M                         (0x4)
-#define FSEL_CLKSEL_19200K                      (0x3)
-#define FSEL_CLKSEL_12M                         (0x2)
-#define FSEL_CLKSEL_10M                         (0x1)
-#define FSEL_CLKSEL_9600K                       (0x0)
-
-#define HOST_CTRL0_TESTBURNIN                   (0x1 << 11)
-#define HOST_CTRL0_RETENABLE                    (0x1 << 10)
-#define HOST_CTRL0_COMMONON_N                   (0x1 << 9)
-#define HOST_CTRL0_SIDDQ                        (0x1 << 6)
-#define HOST_CTRL0_FORCESLEEP                   (0x1 << 5)
-#define HOST_CTRL0_FORCESUSPEND                 (0x1 << 4)
-#define HOST_CTRL0_WORDINTERFACE                (0x1 << 3)
-#define HOST_CTRL0_UTMISWRST                    (0x1 << 2)
-#define HOST_CTRL0_LINKSWRST                    (0x1 << 1)
-#define HOST_CTRL0_PHYSWRST                     (0x1 << 0)
-
-#define EXYNOS5_PHY_HOST_TUNE0                  (0x04)
-
-#define EXYNOS5_PHY_HSIC_CTRL1                  (0x10)
-
-#define EXYNOS5_PHY_HSIC_TUNE1                  (0x14)
-
-#define EXYNOS5_PHY_HSIC_CTRL2                  (0x20)
-
-#define EXYNOS5_PHY_HSIC_TUNE2                  (0x24)
-
-#define HSIC_CTRL_REFCLKSEL_MASK                (0x3 << 23)
-#define HSIC_CTRL_REFCLKSEL                     (0x2 << 23)
-
-#define HSIC_CTRL_REFCLKDIV_MASK                (0x7f << 16)
-#define HSIC_CTRL_REFCLKDIV(_x)                 ((_x) << 16)
-#define HSIC_CTRL_REFCLKDIV_12                  (0x24 << 16)
-#define HSIC_CTRL_REFCLKDIV_15                  (0x1c << 16)
-#define HSIC_CTRL_REFCLKDIV_16                  (0x1a << 16)
-#define HSIC_CTRL_REFCLKDIV_19_2                (0x15 << 16)
-#define HSIC_CTRL_REFCLKDIV_20                  (0x14 << 16)
-
-#define HSIC_CTRL_SIDDQ                         (0x1 << 6)
-#define HSIC_CTRL_FORCESLEEP                    (0x1 << 5)
-#define HSIC_CTRL_FORCESUSPEND                  (0x1 << 4)
-#define HSIC_CTRL_WORDINTERFACE                 (0x1 << 3)
-#define HSIC_CTRL_UTMISWRST                     (0x1 << 2)
-#define HSIC_CTRL_PHYSWRST                      (0x1 << 0)
-
-#define EXYNOS5_PHY_HOST_EHCICTRL               (0x30)
-
-#define HOST_EHCICTRL_ENAINCRXALIGN             (0x1 << 29)
-#define HOST_EHCICTRL_ENAINCR4                  (0x1 << 28)
-#define HOST_EHCICTRL_ENAINCR8                  (0x1 << 27)
-#define HOST_EHCICTRL_ENAINCR16                 (0x1 << 26)
-
-#define EXYNOS5_PHY_HOST_OHCICTRL               (0x34)
-
-#define HOST_OHCICTRL_SUSPLGCY                  (0x1 << 3)
-#define HOST_OHCICTRL_APPSTARTCLK               (0x1 << 2)
-#define HOST_OHCICTRL_CNTSEL                    (0x1 << 1)
-#define HOST_OHCICTRL_CLKCKTRST                 (0x1 << 0)
-
-#define EXYNOS5_PHY_OTG_SYS                     (0x38)
-
-#define OTG_SYS_PHYLINK_SWRESET                 (0x1 << 14)
-#define OTG_SYS_LINKSWRST_UOTG                  (0x1 << 13)
-#define OTG_SYS_PHY0_SWRST                      (0x1 << 12)
-
-#define OTG_SYS_REFCLKSEL_MASK                  (0x3 << 9)
-#define OTG_SYS_REFCLKSEL_XTAL                  (0x0 << 9)
-#define OTG_SYS_REFCLKSEL_EXTL                  (0x1 << 9)
-#define OTG_SYS_REFCLKSEL_CLKCORE               (0x2 << 9)
-
-#define OTG_SYS_IDPULLUP_UOTG                   (0x1 << 8)
-#define OTG_SYS_COMMON_ON                       (0x1 << 7)
-
-#define OTG_SYS_FSEL_MASK                       (0x7 << 4)
-#define OTG_SYS_FSEL(_x)                        ((_x) << 4)
-
-#define OTG_SYS_FORCESLEEP                      (0x1 << 3)
-#define OTG_SYS_OTGDISABLE                      (0x1 << 2)
-#define OTG_SYS_SIDDQ_UOTG                      (0x1 << 1)
-#define OTG_SYS_FORCESUSPEND                    (0x1 << 0)
-
-#define EXYNOS5_PHY_OTG_TUNE                    (0x40)
-
-/* EXYNOS5: USB 3.0 DRD */
-#define EXYNOS5_DRD_LINKSYSTEM                  (0x04)
-
-#define LINKSYSTEM_FLADJ_MASK                   (0x3f << 1)
-#define LINKSYSTEM_FLADJ(_x)                    ((_x) << 1)
-#define LINKSYSTEM_XHCI_VERSION_CONTROL         (0x1 << 27)
-
-#define EXYNOS5_DRD_PHYUTMI                     (0x08)
-
-#define PHYUTMI_OTGDISABLE                      (0x1 << 6)
-#define PHYUTMI_FORCESUSPEND                    (0x1 << 1)
-#define PHYUTMI_FORCESLEEP                      (0x1 << 0)
-
-#define EXYNOS5_DRD_PHYPIPE                     (0x0c)
-
-#define EXYNOS5_DRD_PHYCLKRST                   (0x10)
-
-#define PHYCLKRST_SSC_REFCLKSEL_MASK            (0xff << 23)
-#define PHYCLKRST_SSC_REFCLKSEL(_x)             ((_x) << 23)
-
-#define PHYCLKRST_SSC_RANGE_MASK                (0x03 << 21)
-#define PHYCLKRST_SSC_RANGE(_x)                 ((_x) << 21)
-
-#define PHYCLKRST_SSC_EN                        (0x1 << 20)
-#define PHYCLKRST_REF_SSP_EN                    (0x1 << 19)
-#define PHYCLKRST_REF_CLKDIV2                   (0x1 << 18)
-
-#define PHYCLKRST_MPLL_MULTIPLIER_MASK          (0x7f << 11)
-#define PHYCLKRST_MPLL_MULTIPLIER_100MHZ_REF    (0x19 << 11)
-#define PHYCLKRST_MPLL_MULTIPLIER_50M_REF       (0x02 << 11)
-#define PHYCLKRST_MPLL_MULTIPLIER_24MHZ_REF     (0x68 << 11)
-#define PHYCLKRST_MPLL_MULTIPLIER_20MHZ_REF     (0x7d << 11)
-#define PHYCLKRST_MPLL_MULTIPLIER_19200KHZ_REF  (0x02 << 11)
-
-#define PHYCLKRST_FSEL_MASK                     (0x3f << 5)
-#define PHYCLKRST_FSEL(_x)                      ((_x) << 5)
-#define PHYCLKRST_FSEL_PAD_100MHZ               (0x27 << 5)
-#define PHYCLKRST_FSEL_PAD_24MHZ                (0x2a << 5)
-#define PHYCLKRST_FSEL_PAD_20MHZ                (0x31 << 5)
-#define PHYCLKRST_FSEL_PAD_19_2MHZ              (0x38 << 5)
-
-#define PHYCLKRST_RETENABLEN                    (0x1 << 4)
-
-#define PHYCLKRST_REFCLKSEL_MASK                (0x03 << 2)
-#define PHYCLKRST_REFCLKSEL_PAD_REFCLK          (0x2 << 2)
-#define PHYCLKRST_REFCLKSEL_EXT_REFCLK          (0x3 << 2)
-
-#define PHYCLKRST_PORTRESET                     (0x1 << 1)
-#define PHYCLKRST_COMMONONN                     (0x1 << 0)
-
-#define EXYNOS5_DRD_PHYREG0                     (0x14)
-#define EXYNOS5_DRD_PHYREG1                     (0x18)
-
-#define EXYNOS5_DRD_PHYPARAM0                   (0x1c)
-
-#define PHYPARAM0_REF_USE_PAD                   (0x1 << 31)
-#define PHYPARAM0_REF_LOSLEVEL_MASK             (0x1f << 26)
-#define PHYPARAM0_REF_LOSLEVEL                  (0x9 << 26)
-
-#define EXYNOS5_DRD_PHYPARAM1                   (0x20)
-
-#define PHYPARAM1_PCS_TXDEEMPH_MASK             (0x3f << 0)
-#define PHYPARAM1_PCS_TXDEEMPH                  (0x1c)
-
-#define EXYNOS5_DRD_PHYTERM                     (0x24)
-
-#define EXYNOS5_DRD_PHYTEST                     (0x28)
-
-#define PHYTEST_POWERDOWN_SSP                   (0x1 << 3)
-#define PHYTEST_POWERDOWN_HSP                   (0x1 << 2)
-
-#define EXYNOS5_DRD_PHYADP                      (0x2c)
-
-#define EXYNOS5_DRD_PHYBATCHG                   (0x30)
-
-#define PHYBATCHG_UTMI_CLKSEL                   (0x1 << 2)
-
-#define EXYNOS5_DRD_PHYRESUME                   (0x34)
-#define EXYNOS5_DRD_LINKPORT                    (0x44)
-
-#ifndef MHZ
-#define MHZ (1000*1000)
-#endif
-
-#ifndef KHZ
-#define KHZ (1000)
-#endif
-
-#define EXYNOS_USBHOST_PHY_CTRL_OFFSET          (0x4)
-#define S3C64XX_USBPHY_ENABLE                   (0x1 << 16)
-#define EXYNOS_USBPHY_ENABLE                    (0x1 << 0)
-#define EXYNOS_USB20PHY_CFG_HOST_LINK           (0x1 << 0)
-
-enum samsung_cpu_type {
-        TYPE_S3C64XX,
-        TYPE_EXYNOS4210,
-        TYPE_EXYNOS4X12,
-        TYPE_EXYNOS5250,
-};
-
-struct samsung_usbphy;
-
-/*
- * struct samsung_usbphy_drvdata - driver data for various SoC variants
- * @cpu_type: machine identifier
- * @devphy_en_mask: device phy enable mask for PHY CONTROL register
- * @hostphy_en_mask: host phy enable mask for PHY CONTROL register
- * @devphy_reg_offset: offset to DEVICE PHY CONTROL register from
- *                     mapped address of system controller.
- * @hostphy_reg_offset: offset to HOST PHY CONTROL register from
- *                     mapped address of system controller.
- *
- *      Here we have a separate mask for device type phy.
- *      Having different masks for host and device type phy helps
- *      in setting independent masks in case of SoCs like S5PV210,
- *      in which PHY0 and PHY1 enable bits belong to same register
- *      placed at position 0 and 1 respectively.
- *      Although for newer SoCs like exynos these bits belong to
- *      different registers altogether placed at position 0.
- */
-struct samsung_usbphy_drvdata {
-        int cpu_type;
-        int devphy_en_mask;
-        int hostphy_en_mask;
-        u32 devphy_reg_offset;
-        u32 hostphy_reg_offset;
-        int (*rate_to_clksel)(struct samsung_usbphy *, unsigned long);
-        void (*set_isolation)(struct samsung_usbphy *, bool);
-        void (*phy_enable)(struct samsung_usbphy *);
-        void (*phy_disable)(struct samsung_usbphy *);
-};
-
-/*
- * struct samsung_usbphy - transceiver driver state
- * @phy: transceiver structure
- * @plat: platform data
- * @dev: The parent device supplied to the probe function
- * @clk: usb phy clock
- * @regs: usb phy controller registers memory base
- * @pmuregs: USB device PHY_CONTROL register memory base
- * @sysreg: USB2.0 PHY_CFG register memory base
- * @ref_clk_freq: reference clock frequency selection
- * @drv_data: driver data available for different SoCs
- * @phy_type: Samsung SoCs specific phy types:  #HOST
- *                                              #DEVICE
- * @phy_usage: usage count for phy
- * @lock: lock for phy operations
- */
-struct samsung_usbphy {
-        struct usb_phy  phy;
-        struct samsung_usbphy_data *plat;
-        struct device   *dev;
-        struct clk      *clk;
-        void __iomem    *regs;
-        void __iomem    *pmuregs;
-        void __iomem    *sysreg;
-        int             ref_clk_freq;
-        const struct samsung_usbphy_drvdata *drv_data;
-        enum samsung_usb_phy_type phy_type;
-        atomic_t        phy_usage;
-        spinlock_t      lock;
-};
-
-#define phy_to_sphy(x)          container_of((x), struct samsung_usbphy, phy)
-
-static const struct of_device_id samsung_usbphy_dt_match[];
-
-static inline const struct samsung_usbphy_drvdata
-*samsung_usbphy_get_driver_data(struct platform_device *pdev)
-{
-        if (pdev->dev.of_node) {
-                const struct of_device_id *match;
-                match = of_match_node(samsung_usbphy_dt_match,
-                                                        pdev->dev.of_node);
-                return match->data;
-        }
-
-        return (struct samsung_usbphy_drvdata *)
-                                platform_get_device_id(pdev)->driver_data;
-}
-
-extern int samsung_usbphy_parse_dt(struct samsung_usbphy *sphy);
-extern void samsung_usbphy_set_isolation_4210(struct samsung_usbphy *sphy,
-                                                                bool on);
-extern void samsung_usbphy_cfg_sel(struct samsung_usbphy *sphy);
-extern int samsung_usbphy_set_type(struct usb_phy *phy,
-                                        enum samsung_usb_phy_type phy_type);
-extern int samsung_usbphy_get_refclk_freq(struct samsung_usbphy *sphy);
-extern int samsung_usbphy_rate_to_clksel_64xx(struct samsung_usbphy *sphy,
-                                                        unsigned long rate);
-extern int samsung_usbphy_rate_to_clksel_4x12(struct samsung_usbphy *sphy,
-                                                        unsigned long rate);
diff --git a/drivers/usb/phy/phy-samsung-usb2.c b/drivers/usb/phy/phy-samsung-usb2.c
deleted file mode 100644
index b3ba86627b72..000000000000
--- a/drivers/usb/phy/phy-samsung-usb2.c
+++ /dev/null
@@ -1,541 +0,0 @@
-/* linux/drivers/usb/phy/phy-samsung-usb2.c
- *
- * Copyright (c) 2012 Samsung Electronics Co., Ltd.
- *              http://www.samsung.com
- *
- * Author: Praveen Paneri <p.paneri@samsung.com>
- *
- * Samsung USB2.0 PHY transceiver; talks to S3C HS OTG controller, EHCI-S5P and
- * OHCI-EXYNOS controllers.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/delay.h>
-#include <linux/device.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/of.h>
-#include <linux/usb/otg.h>
-#include <linux/usb/samsung_usb_phy.h>
-#include <linux/platform_data/samsung-usbphy.h>
-
-#include "phy-samsung-usb.h"
-
-static int samsung_usbphy_set_host(struct usb_otg *otg, struct usb_bus *host)
-{
-        if (!otg)
-                return -ENODEV;
-
-        if (!otg->host)
-                otg->host = host;
-
-        return 0;
-}
-
-static bool exynos5_phyhost_is_on(void __iomem *regs)
-{
-        u32 reg;
-
-        reg = readl(regs + EXYNOS5_PHY_HOST_CTRL0);
-
-        return !(reg & HOST_CTRL0_SIDDQ);
-}
-
-static void samsung_exynos5_usb2phy_enable(struct samsung_usbphy *sphy)
-{
-        void __iomem *regs = sphy->regs;
-        u32 phyclk = sphy->ref_clk_freq;
-        u32 phyhost;
-        u32 phyotg;
-        u32 phyhsic;
-        u32 ehcictrl;
-        u32 ohcictrl;
-
-        /*
-         * phy_usage helps in keeping usage count for phy
-         * so that the first consumer enabling the phy is also
-         * the last consumer to disable it.
-         */
-
-        atomic_inc(&sphy->phy_usage);
-
-        if (exynos5_phyhost_is_on(regs)) {
-                dev_info(sphy->dev, "Already power on PHY\n");
-                return;
-        }
-
-        /* Host configuration */
-        phyhost = readl(regs + EXYNOS5_PHY_HOST_CTRL0);
-
-        /* phy reference clock configuration */
-        phyhost &= ~HOST_CTRL0_FSEL_MASK;
-        phyhost |= HOST_CTRL0_FSEL(phyclk);
-
-        /* host phy reset */
-        phyhost &= ~(HOST_CTRL0_PHYSWRST |
-                        HOST_CTRL0_PHYSWRSTALL |
-                        HOST_CTRL0_SIDDQ |
-                        /* Enable normal mode of operation */
-                        HOST_CTRL0_FORCESUSPEND |
-                        HOST_CTRL0_FORCESLEEP);
-
-        /* Link reset */
-        phyhost |= (HOST_CTRL0_LINKSWRST |
-                        HOST_CTRL0_UTMISWRST |
-                        /* COMMON Block configuration during suspend */
-                        HOST_CTRL0_COMMONON_N);
-        writel(phyhost, regs + EXYNOS5_PHY_HOST_CTRL0);
-        udelay(10);
-        phyhost &= ~(HOST_CTRL0_LINKSWRST |
-                        HOST_CTRL0_UTMISWRST);
-        writel(phyhost, regs + EXYNOS5_PHY_HOST_CTRL0);
-
-        /* OTG configuration */
-        phyotg = readl(regs + EXYNOS5_PHY_OTG_SYS);
-
-        /* phy reference clock configuration */
-        phyotg &= ~OTG_SYS_FSEL_MASK;
-        phyotg |= OTG_SYS_FSEL(phyclk);
-
-        /* Enable normal mode of operation */
-        phyotg &= ~(OTG_SYS_FORCESUSPEND |
-                        OTG_SYS_SIDDQ_UOTG |
-                        OTG_SYS_FORCESLEEP |
-                        OTG_SYS_REFCLKSEL_MASK |
-                        /* COMMON Block configuration during suspend */
-                        OTG_SYS_COMMON_ON);
-
-        /* OTG phy & link reset */
-        phyotg |= (OTG_SYS_PHY0_SWRST |
-                        OTG_SYS_LINKSWRST_UOTG |
-                        OTG_SYS_PHYLINK_SWRESET |
-                        OTG_SYS_OTGDISABLE |
-                        /* Set phy refclk */
-                        OTG_SYS_REFCLKSEL_CLKCORE);
-
-        writel(phyotg, regs + EXYNOS5_PHY_OTG_SYS);
-        udelay(10);
-        phyotg &= ~(OTG_SYS_PHY0_SWRST |
-                        OTG_SYS_LINKSWRST_UOTG |
-                        OTG_SYS_PHYLINK_SWRESET);
-        writel(phyotg, regs + EXYNOS5_PHY_OTG_SYS);
-
-        /* HSIC phy configuration */
-        phyhsic = (HSIC_CTRL_REFCLKDIV_12 |
-                        HSIC_CTRL_REFCLKSEL |
-                        HSIC_CTRL_PHYSWRST);
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL1);
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL2);
-        udelay(10);
-        phyhsic &= ~HSIC_CTRL_PHYSWRST;
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL1);
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL2);
-
-        udelay(80);
-
-        /* enable EHCI DMA burst */
-        ehcictrl = readl(regs + EXYNOS5_PHY_HOST_EHCICTRL);
-        ehcictrl |= (HOST_EHCICTRL_ENAINCRXALIGN |
-                                HOST_EHCICTRL_ENAINCR4 |
-                                HOST_EHCICTRL_ENAINCR8 |
-                                HOST_EHCICTRL_ENAINCR16);
-        writel(ehcictrl, regs + EXYNOS5_PHY_HOST_EHCICTRL);
-
-        /* set ohci_suspend_on_n */
-        ohcictrl = readl(regs + EXYNOS5_PHY_HOST_OHCICTRL);
-        ohcictrl |= HOST_OHCICTRL_SUSPLGCY;
-        writel(ohcictrl, regs + EXYNOS5_PHY_HOST_OHCICTRL);
-}
-
-static void samsung_usb2phy_enable(struct samsung_usbphy *sphy)
-{
-        void __iomem *regs = sphy->regs;
-        u32 phypwr;
-        u32 phyclk;
-        u32 rstcon;
-
-        /* set clock frequency for PLL */
-        phyclk = sphy->ref_clk_freq;
-        phypwr = readl(regs + SAMSUNG_PHYPWR);
-        rstcon = readl(regs + SAMSUNG_RSTCON);
-
-        switch (sphy->drv_data->cpu_type) {
-        case TYPE_S3C64XX:
-                phyclk &= ~PHYCLK_COMMON_ON_N;
-                phypwr &= ~PHYPWR_NORMAL_MASK;
-                rstcon |= RSTCON_SWRST;
-                break;
-        case TYPE_EXYNOS4X12:
-                phypwr &= ~(PHYPWR_NORMAL_MASK_HSIC0 |
-                                PHYPWR_NORMAL_MASK_HSIC1 |
-                                PHYPWR_NORMAL_MASK_PHY1);
-                rstcon |= RSTCON_HOSTPHY_SWRST;
-        case TYPE_EXYNOS4210:
-                phypwr &= ~PHYPWR_NORMAL_MASK_PHY0;
-                rstcon |= RSTCON_SWRST;
-        default:
-                break;
-        }
-
-        writel(phyclk, regs + SAMSUNG_PHYCLK);
-        /* Configure PHY0 for normal operation*/
-        writel(phypwr, regs + SAMSUNG_PHYPWR);
-        /* reset all ports of PHY and Link */
-        writel(rstcon, regs + SAMSUNG_RSTCON);
-        udelay(10);
-        if (sphy->drv_data->cpu_type == TYPE_EXYNOS4X12)
-                rstcon &= ~RSTCON_HOSTPHY_SWRST;
-        rstcon &= ~RSTCON_SWRST;
-        writel(rstcon, regs + SAMSUNG_RSTCON);
-}
-
-static void samsung_exynos5_usb2phy_disable(struct samsung_usbphy *sphy)
-{
-        void __iomem *regs = sphy->regs;
-        u32 phyhost;
-        u32 phyotg;
-        u32 phyhsic;
-
-        if (atomic_dec_return(&sphy->phy_usage) > 0) {
-                dev_info(sphy->dev, "still being used\n");
-                return;
-        }
-
-        phyhsic = (HSIC_CTRL_REFCLKDIV_12 |
-                        HSIC_CTRL_REFCLKSEL |
-                        HSIC_CTRL_SIDDQ |
-                        HSIC_CTRL_FORCESLEEP |
-                        HSIC_CTRL_FORCESUSPEND);
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL1);
-        writel(phyhsic, regs + EXYNOS5_PHY_HSIC_CTRL2);
-
-        phyhost = readl(regs + EXYNOS5_PHY_HOST_CTRL0);
-        phyhost |= (HOST_CTRL0_SIDDQ |
-                        HOST_CTRL0_FORCESUSPEND |
-                        HOST_CTRL0_FORCESLEEP |
-                        HOST_CTRL0_PHYSWRST |
-                        HOST_CTRL0_PHYSWRSTALL);
-        writel(phyhost, regs + EXYNOS5_PHY_HOST_CTRL0);
-
-        phyotg = readl(regs + EXYNOS5_PHY_OTG_SYS);
-        phyotg |= (OTG_SYS_FORCESUSPEND |
-                        OTG_SYS_SIDDQ_UOTG |
-                        OTG_SYS_FORCESLEEP);
-        writel(phyotg, regs + EXYNOS5_PHY_OTG_SYS);
-}
-
-static void samsung_usb2phy_disable(struct samsung_usbphy *sphy)
-{
-        void __iomem *regs = sphy->regs;
-        u32 phypwr;
-
-        phypwr = readl(regs + SAMSUNG_PHYPWR);
-
-        switch (sphy->drv_data->cpu_type) {
-        case TYPE_S3C64XX:
-                phypwr |= PHYPWR_NORMAL_MASK;
-                break;
-        case TYPE_EXYNOS4X12:
-                phypwr |= (PHYPWR_NORMAL_MASK_HSIC0 |
-                                PHYPWR_NORMAL_MASK_HSIC1 |
-                                PHYPWR_NORMAL_MASK_PHY1);
-        case TYPE_EXYNOS4210:
-                phypwr |= PHYPWR_NORMAL_MASK_PHY0;
-        default:
-                break;
-        }
-
-        /* Disable analog and otg block power */
-        writel(phypwr, regs + SAMSUNG_PHYPWR);
-}
-
-/*
- * The function passed to the usb driver for phy initialization
- */
-static int samsung_usb2phy_init(struct usb_phy *phy)
-{
-        struct samsung_usbphy *sphy;
-        struct usb_bus *host = NULL;
-        unsigned long flags;
-        int ret = 0;
-
-        sphy = phy_to_sphy(phy);
-
-        host = phy->otg->host;
-
-        /* Enable the phy clock */
-        ret = clk_prepare_enable(sphy->clk);
-        if (ret) {
-                dev_err(sphy->dev, "%s: clk_prepare_enable failed\n", __func__);
-                return ret;
-        }
-
-        spin_lock_irqsave(&sphy->lock, flags);
-
-        if (host) {
-                /* setting default phy-type for USB 2.0 */
-                if (!strstr(dev_name(host->controller), "ehci") ||
-                                !strstr(dev_name(host->controller), "ohci"))
-                        samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_HOST);
-        } else {
-                samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_DEVICE);
-        }
-
-        /* Disable phy isolation */
-        if (sphy->plat && sphy->plat->pmu_isolation)
-                sphy->plat->pmu_isolation(false);
-        else if (sphy->drv_data->set_isolation)
-                sphy->drv_data->set_isolation(sphy, false);
-
-        /* Selecting Host/OTG mode; After reset USB2.0PHY_CFG: HOST */
-        samsung_usbphy_cfg_sel(sphy);
-
-        /* Initialize usb phy registers */
-        sphy->drv_data->phy_enable(sphy);
-
-        spin_unlock_irqrestore(&sphy->lock, flags);
-
-        /* Disable the phy clock */
-        clk_disable_unprepare(sphy->clk);
-
-        return ret;
-}
-
-/*
- * The function passed to the usb driver for phy shutdown
- */
-static void samsung_usb2phy_shutdown(struct usb_phy *phy)
-{
-        struct samsung_usbphy *sphy;
-        struct usb_bus *host = NULL;
-        unsigned long flags;
-
-        sphy = phy_to_sphy(phy);
-
-        host = phy->otg->host;
-
-        if (clk_prepare_enable(sphy->clk)) {
-                dev_err(sphy->dev, "%s: clk_prepare_enable failed\n", __func__);
-                return;
-        }
-
-        spin_lock_irqsave(&sphy->lock, flags);
-
-        if (host) {
-                /* setting default phy-type for USB 2.0 */
-                if (!strstr(dev_name(host->controller), "ehci") ||
-                                !strstr(dev_name(host->controller), "ohci"))
-                        samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_HOST);
-        } else {
-                samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_DEVICE);
-        }
-
-        /* De-initialize usb phy registers */
-        sphy->drv_data->phy_disable(sphy);
-
-        /* Enable phy isolation */
-        if (sphy->plat && sphy->plat->pmu_isolation)
-                sphy->plat->pmu_isolation(true);
-        else if (sphy->drv_data->set_isolation)
-                sphy->drv_data->set_isolation(sphy, true);
-
-        spin_unlock_irqrestore(&sphy->lock, flags);
-
-        clk_disable_unprepare(sphy->clk);
-}
-
-static int samsung_usb2phy_probe(struct platform_device *pdev)
-{
-        struct samsung_usbphy *sphy;
-        struct usb_otg *otg;
-        struct samsung_usbphy_data *pdata = dev_get_platdata(&pdev->dev);
-        const struct samsung_usbphy_drvdata *drv_data;
-        struct device *dev = &pdev->dev;
-        struct resource *phy_mem;
-        void __iomem    *phy_base;
-        struct clk *clk;
-        int ret;
-
-        phy_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        phy_base = devm_ioremap_resource(dev, phy_mem);
-        if (IS_ERR(phy_base))
-                return PTR_ERR(phy_base);
-
-        sphy = devm_kzalloc(dev, sizeof(*sphy), GFP_KERNEL);
-        if (!sphy)
-                return -ENOMEM;
-
-        otg = devm_kzalloc(dev, sizeof(*otg), GFP_KERNEL);
-        if (!otg)
-                return -ENOMEM;
-
-        drv_data = samsung_usbphy_get_driver_data(pdev);
-
-        if (drv_data->cpu_type == TYPE_EXYNOS5250)
-                clk = devm_clk_get(dev, "usbhost");
-        else
-                clk = devm_clk_get(dev, "otg");
-
-        if (IS_ERR(clk)) {
-                dev_err(dev, "Failed to get usbhost/otg clock\n");
-                return PTR_ERR(clk);
-        }
-
-        sphy->dev = dev;
-
-        if (dev->of_node) {
-                ret = samsung_usbphy_parse_dt(sphy);
-                if (ret < 0)
-                        return ret;
-        } else {
-                if (!pdata) {
-                        dev_err(dev, "no platform data specified\n");
-                        return -EINVAL;
-                }
-        }
-
-        sphy->plat              = pdata;
-        sphy->regs              = phy_base;
-        sphy->clk               = clk;
-        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;
-
-        sphy->ref_clk_freq = samsung_usbphy_get_refclk_freq(sphy);
-        if (sphy->ref_clk_freq < 0)
-                return -EINVAL;
-
-        sphy->phy.otg           = otg;
-        sphy->phy.otg->phy      = &sphy->phy;
-        sphy->phy.otg->set_host = samsung_usbphy_set_host;
-
-        spin_lock_init(&sphy->lock);
-
-        platform_set_drvdata(pdev, sphy);
-
-        return usb_add_phy_dev(&sphy->phy);
-}
-
-static int samsung_usb2phy_remove(struct platform_device *pdev)
-{
-        struct samsung_usbphy *sphy = platform_get_drvdata(pdev);
-
-        usb_remove_phy(&sphy->phy);
-
-        if (sphy->pmuregs)
-                iounmap(sphy->pmuregs);
-        if (sphy->sysreg)
-                iounmap(sphy->sysreg);
-
-        return 0;
-}
-
-static const struct samsung_usbphy_drvdata usb2phy_s3c64xx = {
-        .cpu_type               = TYPE_S3C64XX,
-        .devphy_en_mask         = S3C64XX_USBPHY_ENABLE,
-        .rate_to_clksel         = samsung_usbphy_rate_to_clksel_64xx,
-        .set_isolation          = NULL, /* TODO */
-        .phy_enable             = samsung_usb2phy_enable,
-        .phy_disable            = samsung_usb2phy_disable,
-};
-
-static const struct samsung_usbphy_drvdata usb2phy_exynos4 = {
-        .cpu_type               = TYPE_EXYNOS4210,
-        .devphy_en_mask         = EXYNOS_USBPHY_ENABLE,
-        .hostphy_en_mask        = EXYNOS_USBPHY_ENABLE,
-        .rate_to_clksel         = samsung_usbphy_rate_to_clksel_64xx,
-        .set_isolation          = samsung_usbphy_set_isolation_4210,
-        .phy_enable             = samsung_usb2phy_enable,
-        .phy_disable            = samsung_usb2phy_disable,
-};
-
-static const struct samsung_usbphy_drvdata usb2phy_exynos4x12 = {
-        .cpu_type               = TYPE_EXYNOS4X12,
-        .devphy_en_mask         = EXYNOS_USBPHY_ENABLE,
-        .hostphy_en_mask        = EXYNOS_USBPHY_ENABLE,
-        .rate_to_clksel         = samsung_usbphy_rate_to_clksel_4x12,
-        .set_isolation          = samsung_usbphy_set_isolation_4210,
-        .phy_enable             = samsung_usb2phy_enable,
-        .phy_disable            = samsung_usb2phy_disable,
-};
-
-static struct samsung_usbphy_drvdata usb2phy_exynos5 = {
-        .cpu_type               = TYPE_EXYNOS5250,
-        .hostphy_en_mask        = EXYNOS_USBPHY_ENABLE,
-        .hostphy_reg_offset     = EXYNOS_USBHOST_PHY_CTRL_OFFSET,
-        .rate_to_clksel         = samsung_usbphy_rate_to_clksel_4x12,
-        .set_isolation          = samsung_usbphy_set_isolation_4210,
-        .phy_enable             = samsung_exynos5_usb2phy_enable,
-        .phy_disable            = samsung_exynos5_usb2phy_disable,
-};
-
-#ifdef CONFIG_OF
-static const struct of_device_id samsung_usbphy_dt_match[] = {
-        {
-                .compatible = "samsung,s3c64xx-usb2phy",
-                .data = &usb2phy_s3c64xx,
-        }, {
-                .compatible = "samsung,exynos4210-usb2phy",
-                .data = &usb2phy_exynos4,
-        }, {
-                .compatible = "samsung,exynos4x12-usb2phy",
-                .data = &usb2phy_exynos4x12,
-        }, {
-                .compatible = "samsung,exynos5250-usb2phy",
-                .data = &usb2phy_exynos5
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(of, samsung_usbphy_dt_match);
-#endif
-
-static struct platform_device_id samsung_usbphy_driver_ids[] = {
-        {
-                .name           = "s3c64xx-usb2phy",
-                .driver_data    = (unsigned long)&usb2phy_s3c64xx,
-        }, {
-                .name           = "exynos4210-usb2phy",
-                .driver_data    = (unsigned long)&usb2phy_exynos4,
-        }, {
-                .name           = "exynos4x12-usb2phy",
-                .driver_data    = (unsigned long)&usb2phy_exynos4x12,
-        }, {
-                .name           = "exynos5250-usb2phy",
-                .driver_data    = (unsigned long)&usb2phy_exynos5,
-        },
-        {},
-};
-
-MODULE_DEVICE_TABLE(platform, samsung_usbphy_driver_ids);
-
-static struct platform_driver samsung_usb2phy_driver = {
-        .probe          = samsung_usb2phy_probe,
-        .remove         = samsung_usb2phy_remove,
-        .id_table       = samsung_usbphy_driver_ids,
-        .driver         = {
-                .name   = "samsung-usb2phy",
-                .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(samsung_usbphy_dt_match),
-        },
-};
-
-module_platform_driver(samsung_usb2phy_driver);
-
-MODULE_DESCRIPTION("Samsung USB 2.0 phy controller");
-MODULE_AUTHOR("Praveen Paneri <p.paneri@samsung.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:samsung-usb2phy");
diff --git a/drivers/usb/phy/phy-samsung-usb3.c b/drivers/usb/phy/phy-samsung-usb3.c
deleted file mode 100644
index cc0819248acf..000000000000
--- a/drivers/usb/phy/phy-samsung-usb3.c
+++ /dev/null
@@ -1,350 +0,0 @@
-/* linux/drivers/usb/phy/phy-samsung-usb3.c
- *
- * Copyright (c) 2013 Samsung Electronics Co., Ltd.
- *              http://www.samsung.com
- *
- * Author: Vivek Gautam <gautam.vivek@samsung.com>
- *
- * Samsung USB 3.0 PHY transceiver; talks to DWC3 controller.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/clk.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/of.h>
-#include <linux/usb/samsung_usb_phy.h>
-#include <linux/platform_data/samsung-usbphy.h>
-
-#include "phy-samsung-usb.h"
-
-/*
- * Sets the phy clk as EXTREFCLK (XXTI) which is internal clock from clock core.
- */
-static u32 samsung_usb3phy_set_refclk(struct samsung_usbphy *sphy)
-{
-        u32 reg;
-        u32 refclk;
-
-        refclk = sphy->ref_clk_freq;
-
-        reg = PHYCLKRST_REFCLKSEL_EXT_REFCLK |
-                PHYCLKRST_FSEL(refclk);
-
-        switch (refclk) {
-        case FSEL_CLKSEL_50M:
-                reg |= (PHYCLKRST_MPLL_MULTIPLIER_50M_REF |
-                        PHYCLKRST_SSC_REFCLKSEL(0x00));
-                break;
-        case FSEL_CLKSEL_20M:
-                reg |= (PHYCLKRST_MPLL_MULTIPLIER_20MHZ_REF |
-                        PHYCLKRST_SSC_REFCLKSEL(0x00));
-                break;
-        case FSEL_CLKSEL_19200K:
-                reg |= (PHYCLKRST_MPLL_MULTIPLIER_19200KHZ_REF |
-                        PHYCLKRST_SSC_REFCLKSEL(0x88));
-                break;
-        case FSEL_CLKSEL_24M:
-        default:
-                reg |= (PHYCLKRST_MPLL_MULTIPLIER_24MHZ_REF |
-                        PHYCLKRST_SSC_REFCLKSEL(0x88));
-                break;
-        }
-
-        return reg;
-}
-
-static void samsung_exynos5_usb3phy_enable(struct samsung_usbphy *sphy)
-{
-        void __iomem *regs = sphy->regs;
-        u32 phyparam0;
-        u32 phyparam1;
-        u32 linksystem;
-        u32 phybatchg;
-        u32 phytest;
-        u32 phyclkrst;
-
-        /* Reset USB 3.0 PHY */
-        writel(0x0, regs + EXYNOS5_DRD_PHYREG0);
-
-        phyparam0 = readl(regs + EXYNOS5_DRD_PHYPARAM0);
-        /* Select PHY CLK source */
-        phyparam0 &= ~PHYPARAM0_REF_USE_PAD;
-        /* Set Loss-of-Signal Detector sensitivity */
-        phyparam0 &= ~PHYPARAM0_REF_LOSLEVEL_MASK;
-        phyparam0 |= PHYPARAM0_REF_LOSLEVEL;
-        writel(phyparam0, regs + EXYNOS5_DRD_PHYPARAM0);
-
-        writel(0x0, regs + EXYNOS5_DRD_PHYRESUME);
-
-        /*
-         * Setting the Frame length Adj value[6:1] to default 0x20
-         * See xHCI 1.0 spec, 5.2.4
-         */
-        linksystem = LINKSYSTEM_XHCI_VERSION_CONTROL |
-                        LINKSYSTEM_FLADJ(0x20);
-        writel(linksystem, regs + EXYNOS5_DRD_LINKSYSTEM);
-
-        phyparam1 = readl(regs + EXYNOS5_DRD_PHYPARAM1);
-        /* Set Tx De-Emphasis level */
-        phyparam1 &= ~PHYPARAM1_PCS_TXDEEMPH_MASK;
-        phyparam1 |= PHYPARAM1_PCS_TXDEEMPH;
-        writel(phyparam1, regs + EXYNOS5_DRD_PHYPARAM1);
-
-        phybatchg = readl(regs + EXYNOS5_DRD_PHYBATCHG);
-        phybatchg |= PHYBATCHG_UTMI_CLKSEL;
-        writel(phybatchg, regs + EXYNOS5_DRD_PHYBATCHG);
-
-        /* PHYTEST POWERDOWN Control */
-        phytest = readl(regs + EXYNOS5_DRD_PHYTEST);
-        phytest &= ~(PHYTEST_POWERDOWN_SSP |
-                        PHYTEST_POWERDOWN_HSP);
-        writel(phytest, regs + EXYNOS5_DRD_PHYTEST);
-
-        /* UTMI Power Control */
-        writel(PHYUTMI_OTGDISABLE, regs + EXYNOS5_DRD_PHYUTMI);
-
-        phyclkrst = samsung_usb3phy_set_refclk(sphy);
-
-        phyclkrst |= PHYCLKRST_PORTRESET |
-                        /* Digital power supply in normal operating mode */
-                        PHYCLKRST_RETENABLEN |
-                        /* Enable ref clock for SS function */
-                        PHYCLKRST_REF_SSP_EN |
-                        /* Enable spread spectrum */
-                        PHYCLKRST_SSC_EN |
-                        /* Power down HS Bias and PLL blocks in suspend mode */
-                        PHYCLKRST_COMMONONN;
-
-        writel(phyclkrst, regs + EXYNOS5_DRD_PHYCLKRST);
-
-        udelay(10);
-
-        phyclkrst &= ~(PHYCLKRST_PORTRESET);
-        writel(phyclkrst, regs + EXYNOS5_DRD_PHYCLKRST);
-}
-
-static void samsung_exynos5_usb3phy_disable(struct samsung_usbphy *sphy)
-{
-        u32 phyutmi;
-        u32 phyclkrst;
-        u32 phytest;
-        void __iomem *regs = sphy->regs;
-
-        phyutmi = PHYUTMI_OTGDISABLE |
-                        PHYUTMI_FORCESUSPEND |
-                        PHYUTMI_FORCESLEEP;
-        writel(phyutmi, regs + EXYNOS5_DRD_PHYUTMI);
-
-        /* Resetting the PHYCLKRST enable bits to reduce leakage current */
-        phyclkrst = readl(regs + EXYNOS5_DRD_PHYCLKRST);
-        phyclkrst &= ~(PHYCLKRST_REF_SSP_EN |
-                        PHYCLKRST_SSC_EN |
-                        PHYCLKRST_COMMONONN);
-        writel(phyclkrst, regs + EXYNOS5_DRD_PHYCLKRST);
-
-        /* Control PHYTEST to remove leakage current */
-        phytest = readl(regs + EXYNOS5_DRD_PHYTEST);
-        phytest |= (PHYTEST_POWERDOWN_SSP |
-                        PHYTEST_POWERDOWN_HSP);
-        writel(phytest, regs + EXYNOS5_DRD_PHYTEST);
-}
-
-static int samsung_usb3phy_init(struct usb_phy *phy)
-{
-        struct samsung_usbphy *sphy;
-        unsigned long flags;
-        int ret = 0;
-
-        sphy = phy_to_sphy(phy);
-
-        /* Enable the phy clock */
-        ret = clk_prepare_enable(sphy->clk);
-        if (ret) {
-                dev_err(sphy->dev, "%s: clk_prepare_enable failed\n", __func__);
-                return ret;
-        }
-
-        spin_lock_irqsave(&sphy->lock, flags);
-
-        /* setting default phy-type for USB 3.0 */
-        samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_DEVICE);
-
-        /* Disable phy isolation */
-        if (sphy->drv_data->set_isolation)
-                sphy->drv_data->set_isolation(sphy, false);
-
-        /* Initialize usb phy registers */
-        sphy->drv_data->phy_enable(sphy);
-
-        spin_unlock_irqrestore(&sphy->lock, flags);
-
-        /* Disable the phy clock */
-        clk_disable_unprepare(sphy->clk);
-
-        return ret;
-}
-
-/*
- * The function passed to the usb driver for phy shutdown
- */
-static void samsung_usb3phy_shutdown(struct usb_phy *phy)
-{
-        struct samsung_usbphy *sphy;
-        unsigned long flags;
-
-        sphy = phy_to_sphy(phy);
-
-        if (clk_prepare_enable(sphy->clk)) {
-                dev_err(sphy->dev, "%s: clk_prepare_enable failed\n", __func__);
-                return;
-        }
-
-        spin_lock_irqsave(&sphy->lock, flags);
-
-        /* setting default phy-type for USB 3.0 */
-        samsung_usbphy_set_type(&sphy->phy, USB_PHY_TYPE_DEVICE);
-
-        /* De-initialize usb phy registers */
-        sphy->drv_data->phy_disable(sphy);
-
-        /* Enable phy isolation */
-        if (sphy->drv_data->set_isolation)
-                sphy->drv_data->set_isolation(sphy, true);
-
-        spin_unlock_irqrestore(&sphy->lock, flags);
-
-        clk_disable_unprepare(sphy->clk);
-}
-
-static int samsung_usb3phy_probe(struct platform_device *pdev)
-{
-        struct samsung_usbphy *sphy;
-        struct samsung_usbphy_data *pdata = dev_get_platdata(&pdev->dev);
-        struct device *dev = &pdev->dev;
-        struct resource *phy_mem;
-        void __iomem    *phy_base;
-        struct clk *clk;
-        int ret;
-
-        phy_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        phy_base = devm_ioremap_resource(dev, phy_mem);
-        if (IS_ERR(phy_base))
-                return PTR_ERR(phy_base);
-
-        sphy = devm_kzalloc(dev, sizeof(*sphy), GFP_KERNEL);
-        if (!sphy)
-                return -ENOMEM;
-
-        clk = devm_clk_get(dev, "usbdrd30");
-        if (IS_ERR(clk)) {
-                dev_err(dev, "Failed to get device clock\n");
-                return PTR_ERR(clk);
-        }
-
-        sphy->dev = dev;
-
-        if (dev->of_node) {
-                ret = samsung_usbphy_parse_dt(sphy);
-                if (ret < 0)
-                        return ret;
-        } else {
-                if (!pdata) {
-                        dev_err(dev, "no platform data specified\n");
-                        return -EINVAL;
-                }
-        }
-
-        sphy->plat              = pdata;
-        sphy->regs              = phy_base;
-        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);
-
-        sphy->ref_clk_freq = samsung_usbphy_get_refclk_freq(sphy);
-        if (sphy->ref_clk_freq < 0)
-                return -EINVAL;
-
-        spin_lock_init(&sphy->lock);
-
-        platform_set_drvdata(pdev, sphy);
-
-        return usb_add_phy_dev(&sphy->phy);
-}
-
-static int samsung_usb3phy_remove(struct platform_device *pdev)
-{
-        struct samsung_usbphy *sphy = platform_get_drvdata(pdev);
-
-        usb_remove_phy(&sphy->phy);
-
-        if (sphy->pmuregs)
-                iounmap(sphy->pmuregs);
-        if (sphy->sysreg)
-                iounmap(sphy->sysreg);
-
-        return 0;
-}
-
-static struct samsung_usbphy_drvdata usb3phy_exynos5 = {
-        .cpu_type               = TYPE_EXYNOS5250,
-        .devphy_en_mask         = EXYNOS_USBPHY_ENABLE,
-        .rate_to_clksel         = samsung_usbphy_rate_to_clksel_4x12,
-        .set_isolation          = samsung_usbphy_set_isolation_4210,
-        .phy_enable             = samsung_exynos5_usb3phy_enable,
-        .phy_disable            = samsung_exynos5_usb3phy_disable,
-};
-
-#ifdef CONFIG_OF
-static const struct of_device_id samsung_usbphy_dt_match[] = {
-        {
-                .compatible = "samsung,exynos5250-usb3phy",
-                .data = &usb3phy_exynos5
-        },
-        {},
-};
-MODULE_DEVICE_TABLE(of, samsung_usbphy_dt_match);
-#endif
-
-static struct platform_device_id samsung_usbphy_driver_ids[] = {
-        {
-                .name           = "exynos5250-usb3phy",
-                .driver_data    = (unsigned long)&usb3phy_exynos5,
-        },
-        {},
-};
-
-MODULE_DEVICE_TABLE(platform, samsung_usbphy_driver_ids);
-
-static struct platform_driver samsung_usb3phy_driver = {
-        .probe          = samsung_usb3phy_probe,
-        .remove         = samsung_usb3phy_remove,
-        .id_table       = samsung_usbphy_driver_ids,
-        .driver         = {
-                .name   = "samsung-usb3phy",
-                .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(samsung_usbphy_dt_match),
-        },
-};
-
-module_platform_driver(samsung_usb3phy_driver);
-
-MODULE_DESCRIPTION("Samsung USB 3.0 phy controller");
-MODULE_AUTHOR("Vivek Gautam <gautam.vivek@samsung.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:samsung-usb3phy");
diff --git a/drivers/usb/phy/phy-twl6030-usb.c b/drivers/usb/phy/phy-twl6030-usb.c
index 04778cf80d60..44ea082e40dc 100644
--- a/drivers/usb/phy/phy-twl6030-usb.c
+++ b/drivers/usb/phy/phy-twl6030-usb.c
@@ -104,7 +104,6 @@ struct twl6030_usb {
         int                     irq2;
         enum omap_musb_vbus_id_status linkstat;
         u8                      asleep;
-        bool                    irq_enabled;
         bool                    vbus_enable;
         const char              *regulator;
 };
@@ -373,7 +372,6 @@ static int twl6030_usb_probe(struct platform_device *pdev)
 
         INIT_WORK(&twl->set_vbus_work, otg_set_vbus_work);
 
-        twl->irq_enabled = true;
         status = request_threaded_irq(twl->irq1, NULL, twl6030_usbotg_irq,
                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
                         "twl6030_usb", twl);
diff --git a/drivers/usb/renesas_usbhs/Kconfig b/drivers/usb/renesas_usbhs/Kconfig
index 1c4195abc108..de83b9d0cd5c 100644
--- a/drivers/usb/renesas_usbhs/Kconfig
+++ b/drivers/usb/renesas_usbhs/Kconfig
@@ -5,6 +5,7 @@
 config USB_RENESAS_USBHS
         tristate 'Renesas USBHS controller'
         depends on USB_GADGET
+        depends on ARCH_SHMOBILE || SUPERH || COMPILE_TEST
         default n
         help
           Renesas USBHS is a discrete USB host and peripheral controller chip
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
index 1b9bf8d83235..b3b6813ab270 100644
--- a/drivers/usb/renesas_usbhs/common.c
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -18,6 +18,8 @@
 #include <linux/gpio.h>
 #include <linux/io.h>
 #include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
 #include <linux/sysfs.h>
@@ -438,6 +440,43 @@ static int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
 /*
  *              platform functions
  */
+static const struct of_device_id usbhs_of_match[] = {
+        {
+                .compatible = "renesas,usbhs-r8a7790",
+                .data = (void *)USBHS_TYPE_R8A7790,
+        },
+        {
+                .compatible = "renesas,usbhs-r8a7791",
+                .data = (void *)USBHS_TYPE_R8A7791,
+        },
+        { },
+};
+MODULE_DEVICE_TABLE(of, usbhs_of_match);
+
+static struct renesas_usbhs_platform_info *usbhs_parse_dt(struct device *dev)
+{
+        struct renesas_usbhs_platform_info *info;
+        struct renesas_usbhs_driver_param *dparam;
+        const struct of_device_id *of_id = of_match_device(usbhs_of_match, dev);
+        u32 tmp;
+        int gpio;
+
+        info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return NULL;
+
+        dparam = &info->driver_param;
+        dparam->type = of_id ? (u32)of_id->data : 0;
+        if (!of_property_read_u32(dev->of_node, "renesas,buswait", &tmp))
+                dparam->buswait_bwait = tmp;
+        gpio = of_get_named_gpio_flags(dev->of_node, "renesas,enable-gpio", 0,
+                                       NULL);
+        if (gpio > 0)
+                dparam->enable_gpio = gpio;
+
+        return info;
+}
+
 static int usbhs_probe(struct platform_device *pdev)
 {
         struct renesas_usbhs_platform_info *info = dev_get_platdata(&pdev->dev);
@@ -446,6 +485,10 @@ static int usbhs_probe(struct platform_device *pdev)
         struct resource *res, *irq_res;
         int ret;
 
+        /* check device node */
+        if (pdev->dev.of_node)
+                info = pdev->dev.platform_data = usbhs_parse_dt(&pdev->dev);
+
         /* check platform information */
         if (!info) {
                 dev_err(&pdev->dev, "no platform information\n");
@@ -689,6 +732,7 @@ static struct platform_driver renesas_usbhs_driver = {
         .driver         = {
                 .name   = "renesas_usbhs",
                 .pm     = &usbhsc_pm_ops,
+                .of_match_table = of_match_ptr(usbhs_of_match),
         },
         .probe          = usbhs_probe,
         .remove         = usbhs_remove,
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 04e6505777d0..2d17c10a0428 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -129,7 +129,7 @@ static void usbhsg_queue_pop(struct usbhsg_uep *uep,
         dev_dbg(dev, "pipe %d : queue pop\n", usbhs_pipe_number(pipe));
 
         ureq->req.status = status;
-        ureq->req.complete(&uep->ep, &ureq->req);
+        usb_gadget_giveback_request(&uep->ep, &ureq->req);
 }
 
 static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 3ce5c74b29e4..a69f7cd9d0bf 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -58,9 +58,11 @@ config USB_SERIAL_SIMPLE
           handles a wide range of very simple devices, all in one
           driver.  Specifically, it supports:
                 - Suunto ANT+ USB device.
+                - Medtronic CareLink USB device
                 - Fundamental Software dongle.
                 - HP4x calculators
                 - a number of Motorola phones
+                - Novatel Wireless GPS receivers
                 - Siemens USB/MPI adapter.
                 - ViVOtech ViVOpay USB device.
                 - Infineon Modem Flashloader USB interface
@@ -682,14 +684,6 @@ config USB_SERIAL_WISHBONE
           To compile this driver as a module, choose M here: the
           module will be called wishbone-serial.
 
-config USB_SERIAL_ZTE
-        tristate "ZTE USB serial driver"
-        help
-          Say Y here if you want to use a ZTE USB to serial device.
-
-          To compile this driver as a module, choose M here: the
-          module will be called zte.
-
 config USB_SERIAL_SSU100
         tristate "USB Quatech SSU-100 Single Port Serial Driver"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index bfdafd349441..349d9df0895f 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -60,4 +60,3 @@ obj-$(CONFIG_USB_SERIAL_WISHBONE)		+= wishbone-serial.o
 obj-$(CONFIG_USB_SERIAL_WHITEHEAT)              += whiteheat.o
 obj-$(CONFIG_USB_SERIAL_XIRCOM)                 += keyspan_pda.o
 obj-$(CONFIG_USB_SERIAL_XSENS_MT)               += xsens_mt.o
-obj-$(CONFIG_USB_SERIAL_ZTE)                    += zte_ev.o
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index e4bb62225cb9..eca1747ca8c7 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -122,6 +122,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
         { USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
         { USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
+        { USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
         { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
         { USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
@@ -155,6 +156,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */
         { USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */
         { USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
+        { USB_DEVICE(0x1D6F, 0x0010) }, /* Seluxit ApS RF Dongle */
         { USB_DEVICE(0x1E29, 0x0102) }, /* Festo CPX-USB */
         { USB_DEVICE(0x1E29, 0x0501) }, /* Festo CMSP */
         { USB_DEVICE(0x1FB9, 0x0100) }, /* Lake Shore Model 121 Current Source */
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 8a23c53b946e..12b0e67473ba 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -834,7 +834,6 @@ static void digi_set_termios(struct tty_struct *tty,
                         arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS;
                 } else {
                         arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS;
-                        tty->hw_stopped = 0;
                 }
 
                 buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
@@ -1500,15 +1499,11 @@ static int digi_read_oob_callback(struct urb *urb)
                         if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
                                 priv->dp_modem_signals |= TIOCM_CTS;
                                 /* port must be open to use tty struct */
-                                if (rts) {
-                                        tty->hw_stopped = 0;
+                                if (rts)
                                         tty_port_tty_wakeup(&port->port);
-                                }
                         } else {
                                 priv->dp_modem_signals &= ~TIOCM_CTS;
                                 /* port must be open to use tty struct */
-                                if (rts)
-                                        tty->hw_stopped = 1;
                         }
                         if (val & DIGI_READ_INPUT_SIGNALS_DSR)
                                 priv->dp_modem_signals |= TIOCM_DSR;
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index c0a42e9e6777..ddbb8fe1046d 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -1456,12 +1456,8 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
         tty = tty_port_tty_get(&edge_port->port->port);
         /* handle CTS flow control */
         if (tty && C_CRTSCTS(tty)) {
-                if (msr & EDGEPORT_MSR_CTS) {
-                        tty->hw_stopped = 0;
+                if (msr & EDGEPORT_MSR_CTS)
                         tty_wakeup(tty);
-                } else {
-                        tty->hw_stopped = 1;
-                }
         }
         tty_kref_put(tty);
 }
@@ -2177,7 +2173,6 @@ static void change_port_settings(struct tty_struct *tty,
                 dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
         } else {
                 dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
-                tty->hw_stopped = 0;
                 restart_read(edge_port);
         }
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 54a8120897a6..d1a3f6044c8a 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -276,6 +276,7 @@ static void option_instat_callback(struct urb *urb);
 #define ZTE_PRODUCT_MF628                       0x0015
 #define ZTE_PRODUCT_MF626                       0x0031
 #define ZTE_PRODUCT_AC2726                      0xfff1
+#define ZTE_PRODUCT_MG880                       0xfffd
 #define ZTE_PRODUCT_CDMA_TECH                   0xfffe
 #define ZTE_PRODUCT_AC8710T                     0xffff
 #define ZTE_PRODUCT_MC2718                      0xffe8
@@ -1560,7 +1561,15 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff92, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff93, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xff94, 0xff, 0xff, 0xff) },
-
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffec, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xffee, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfff6, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfff7, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfff8, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfff9, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfffb, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0xfffc, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_MG880, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_CDMA_TECH, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC2726, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, ZTE_PRODUCT_AC8710T, 0xff, 0xff, 0xff) },
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index e9bad928039f..0f872e6b2c87 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -162,6 +162,9 @@ static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
                 .max_baud_rate =        1228800,
                 .quirks =               PL2303_QUIRK_LEGACY,
         },
+        [TYPE_HX] = {
+                .max_baud_rate =        12000000,
+        },
 };
 
 static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
@@ -395,16 +398,14 @@ static void pl2303_encode_baud_rate(struct tty_struct *tty,
         if (spriv->type->max_baud_rate)
                 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
         /*
-         * Set baud rate to nearest supported value.
-         *
-         * NOTE: Baud rate 500k can only be set using divisors.
+         * Use direct method for supported baud rates, otherwise use divisors.
          */
         baud_sup = pl2303_get_supported_baud_rate(baud);
 
-        if (baud == 500000)
-                baud = pl2303_encode_baud_rate_divisor(buf, baud);
+        if (baud == baud_sup)
+                baud = pl2303_encode_baud_rate_direct(buf, baud);
         else
-                baud = pl2303_encode_baud_rate_direct(buf, baud_sup);
+                baud = pl2303_encode_baud_rate_divisor(buf, baud);
 
         /* Save resulting baud rate */
         tty_encode_baud_rate(tty, baud, baud);
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 3dd3ff8c50d3..e9da41d9fe7f 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -773,7 +773,6 @@ static void ti_set_termios(struct tty_struct *tty,
                         config->wFlags |= TI_UART_ENABLE_RTS_IN;
                 config->wFlags |= TI_UART_ENABLE_CTS_OUT;
         } else {
-                tty->hw_stopped = 0;
                 ti_restart_read(tport, tty);
         }
 
@@ -1291,12 +1290,8 @@ static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
         /* handle CTS flow control */
         tty = tty_port_tty_get(&tport->tp_port->port);
         if (tty && C_CRTSCTS(tty)) {
-                if (msr & TI_MSR_CTS) {
-                        tty->hw_stopped = 0;
+                if (msr & TI_MSR_CTS)
                         tty_wakeup(tty);
-                } else {
-                        tty->hw_stopped = 1;
-                }
         }
         tty_kref_put(tty);
 }
diff --git a/drivers/usb/serial/usb-serial-simple.c b/drivers/usb/serial/usb-serial-simple.c
index fb79775447b0..7064eb8d6142 100644
--- a/drivers/usb/serial/usb-serial-simple.c
+++ b/drivers/usb/serial/usb-serial-simple.c
@@ -20,7 +20,7 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-#define DEVICE(vendor, IDS)                                     \
+#define DEVICE_N(vendor, IDS, nport)                            \
 static const struct usb_device_id vendor##_id_table[] = {       \
         IDS(),                                                  \
         { },                                                    \
@@ -31,9 +31,15 @@ static struct usb_serial_driver vendor##_device = {		\
                 .name =         #vendor,                        \
         },                                                      \
         .id_table =             vendor##_id_table,              \
-        .num_ports =            1,                              \
+        .num_ports =            nport,                          \
 };
 
+#define DEVICE(vendor, IDS)     DEVICE_N(vendor, IDS, 1)
+
+/* Medtronic CareLink USB driver */
+#define CARELINK_IDS()                  \
+        { USB_DEVICE(0x0a21, 0x8001) }  /* MMT-7305WW */
+DEVICE(carelink, CARELINK_IDS);
 
 /* ZIO Motherboard USB driver */
 #define ZIO_IDS()                       \
@@ -64,6 +70,11 @@ DEVICE(vivopay, VIVOPAY_IDS);
         { USB_DEVICE(0x22b8, 0x2c64) }  /* Motorola V950 phone */
 DEVICE(moto_modem, MOTO_IDS);
 
+/* Novatel Wireless GPS driver */
+#define NOVATEL_IDS()                   \
+        { USB_DEVICE(0x09d7, 0x0100) }  /* NovAtel FlexPack GPS */
+DEVICE_N(novatel_gps, NOVATEL_IDS, 3);
+
 /* HP4x (48/49) Generic Serial driver */
 #define HP4X_IDS()                      \
         { USB_DEVICE(0x03f0, 0x0121) }
@@ -82,11 +93,13 @@ DEVICE(siemens_mpi, SIEMENS_IDS);
 
 /* All of the above structures mushed into two lists */
 static struct usb_serial_driver * const serial_drivers[] = {
+        &carelink_device,
         &zio_device,
         &funsoft_device,
         &flashloader_device,
         &vivopay_device,
         &moto_modem_device,
+        &novatel_gps_device,
         &hp4x_device,
         &suunto_device,
         &siemens_mpi_device,
@@ -94,11 +107,13 @@ static struct usb_serial_driver * const serial_drivers[] = {
 };
 
 static const struct usb_device_id id_table[] = {
+        CARELINK_IDS(),
         ZIO_IDS(),
         FUNSOFT_IDS(),
         FLASHLOADER_IDS(),
         VIVOPAY_IDS(),
         MOTO_IDS(),
+        NOVATEL_IDS(),
         HP4X_IDS(),
         SUUNTO_IDS(),
         SIEMENS_IDS(),
diff --git a/drivers/usb/serial/xsens_mt.c b/drivers/usb/serial/xsens_mt.c
index 4841fb57400c..3837d5113bb2 100644
--- a/drivers/usb/serial/xsens_mt.c
+++ b/drivers/usb/serial/xsens_mt.c
@@ -41,28 +41,13 @@ static const struct usb_device_id id_table[] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static int has_required_endpoints(const struct usb_host_interface *interface)
-{
-        __u8 i;
-        int has_bulk_in = 0;
-        int has_bulk_out = 0;
-
-        for (i = 0; i < interface->desc.bNumEndpoints; ++i) {
-                if (usb_endpoint_is_bulk_in(&interface->endpoint[i].desc))
-                        has_bulk_in = 1;
-                else if (usb_endpoint_is_bulk_out(&interface->endpoint[i].desc))
-                        has_bulk_out = 1;
-        }
-
-        return has_bulk_in && has_bulk_out;
-}
-
 static int xsens_mt_probe(struct usb_serial *serial,
                                         const struct usb_device_id *id)
 {
-        if (!has_required_endpoints(serial->interface->cur_altsetting))
-                return -ENODEV;
-        return 0;
+        if (serial->interface->cur_altsetting->desc.bInterfaceNumber == 1)
+                return 0;
+
+        return -ENODEV;
 }
 
 static struct usb_serial_driver xsens_mt_device = {
@@ -82,4 +67,6 @@ static struct usb_serial_driver * const serial_drivers[] = {
 
 module_usb_serial_driver(serial_drivers, id_table);
 
+MODULE_AUTHOR("Frans Klaver <frans.klaver@xsens.com>");
+MODULE_DESCRIPTION("USB-serial driver for Xsens motion trackers");
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/zte_ev.c b/drivers/usb/serial/zte_ev.c
deleted file mode 100644
index c9bb107d5e5c..000000000000
--- a/drivers/usb/serial/zte_ev.c
+++ /dev/null
@@ -1,305 +0,0 @@
-/*
- * ZTE_EV USB serial driver
- *
- * Copyright (C) 2012 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
- * Copyright (C) 2012 Linux Foundation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This driver is based on code found in a ZTE_ENV patch that modified
- * the usb-serial generic driver.  Comments were left in that I think
- * show the commands used to talk to the device, but I am not sure.
- */
-#include <linux/kernel.h>
-#include <linux/tty.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include <linux/usb/serial.h>
-#include <linux/uaccess.h>
-
-#define  MAX_SETUP_DATA_SIZE    32
-
-static void debug_data(struct device *dev, const char *function, int len,
-                       const unsigned char *data, int result)
-{
-        dev_dbg(dev, "result = %d\n", result);
-        if (result == len)
-                dev_dbg(dev, "%s - length = %d, data = %*ph\n", function,
-                        len, len, data);
-}
-
-static int zte_ev_usb_serial_open(struct tty_struct *tty,
-                                  struct usb_serial_port *port)
-{
-        struct usb_device *udev = port->serial->dev;
-        struct device *dev = &port->dev;
-        int result = 0;
-        int len;
-        unsigned char *buf;
-
-        buf = kmalloc(MAX_SETUP_DATA_SIZE, GFP_KERNEL);
-        if (!buf)
-                return -ENOMEM;
-
-        /* send 1st ctl cmd(CTL    21 22 01 00  00 00 00 00) */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0001, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        /* send 2st cmd and receive data */
-        /*
-         * 16.0  CTL    a1 21 00 00  00 00 07 00   CLASS              25.1.0(5)
-         * 16.0  DI     00 96 00 00  00 00 08
-         */
-        len = 0x0007;
-        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0x21, 0xa1,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 3rd cmd */
-        /*
-         * 16.0 CTL    21 20 00 00  00 00 07 00    CLASS                30.1.0
-         * 16.0 DO     80 25 00 00  00 00 08       .%.....              30.2.0
-         */
-        len = 0x0007;
-        buf[0] = 0x80;
-        buf[1] = 0x25;
-        buf[2] = 0x00;
-        buf[3] = 0x00;
-        buf[4] = 0x00;
-        buf[5] = 0x00;
-        buf[6] = 0x08;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x20, 0x21,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 4th cmd */
-        /*
-         * 16.0 CTL    21 22 03 00  00 00 00 00
-         */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0003, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        /* send 5th cmd */
-        /*
-         * 16.0  CTL    a1 21 00 00  00 00 07 00   CLASS               33.1.0
-         * 16.0  DI     80 25 00 00  00 00 08
-         */
-        len = 0x0007;
-        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0x21, 0xa1,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 6th cmd */
-        /*
-         * 16.0  CTL    21 20 00 00  00 00 07 00    CLASS               34.1.0
-         * 16.0  DO     80 25 00 00  00 00 08
-         */
-        len = 0x0007;
-        buf[0] = 0x80;
-        buf[1] = 0x25;
-        buf[2] = 0x00;
-        buf[3] = 0x00;
-        buf[4] = 0x00;
-        buf[5] = 0x00;
-        buf[6] = 0x08;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x20, 0x21,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-        kfree(buf);
-
-        return usb_serial_generic_open(tty, port);
-}
-
-/*
- *       CTL    21 22 02 00  00 00 00 00         CLASS               338.1.0
- *
- * 16.1  DI     a1 20 00 00  00 00 02 00  02 00  . ........          340.1.0
- * 16.0  CTL    21 22 03 00  00 00 00 00         CLASS               341.1.0
- *
- * 16.0  CTL    a1 21 00 00  00 00 07 00         CLASS               346.1.0(3)
- * 16.0  DI     00 08 07 00  00 00 08            .......             346.2.0
- *
- * 16.0  CTL    21 20 00 00  00 00 07 00         CLASS               349.1.0
- * 16.0  DO     00 c2 01 00  00 00 08            .......             349.2.0
- *
- * 16.0  CTL    21 22 03 00  00 00 00 00         CLASS               350.1.0(2)
- *
- * 16.0  CTL    a1 21 00 00  00 00 07 00         CLASS               352.1.0
- * 16.0  DI     00 c2 01 00  00 00 08            .......             352.2.0
- *
- * 16.1  DI     a1 20 00 00  00 00 02 00  02 00  . ........          353.1.0
- *
- * 16.0  CTL    21 20 00 00  00 00 07 00         CLASS               354.1.0
- * 16.0  DO     00 c2 01 00  00 00 08            .......             354.2.0
- *
- * 16.0  CTL    21 22 03 00  00 00 00 00
-*/
-
-static void zte_ev_usb_serial_close(struct usb_serial_port *port)
-{
-        struct usb_device *udev = port->serial->dev;
-        struct device *dev = &port->dev;
-        int result = 0;
-        int len;
-        unsigned char *buf;
-
-        buf = kmalloc(MAX_SETUP_DATA_SIZE, GFP_KERNEL);
-        if (!buf)
-                return;
-
-        /* send 1st ctl cmd(CTL    21 22 02 00  00 00 00 00) */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0002, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        /* send 2st ctl cmd(CTL    21 22 03 00  00 00 00 00 ) */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0003, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        /* send  3st cmd and recieve data */
-        /*
-         * 16.0  CTL    a1 21 00 00  00 00 07 00      CLASS         25.1.0(5)
-         * 16.0  DI     00 08 07 00  00 00 08
-         */
-        len = 0x0007;
-        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0x21, 0xa1,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 4th cmd */
-        /*
-         * 16.0 CTL    21 20 00 00  00 00 07 00      CLASS            30.1.0
-         * 16.0  DO    00 c2 01 00  00 00 08         .%.....          30.2.0
-         */
-        len = 0x0007;
-        buf[0] = 0x00;
-        buf[1] = 0xc2;
-        buf[2] = 0x01;
-        buf[3] = 0x00;
-        buf[4] = 0x00;
-        buf[5] = 0x00;
-        buf[6] = 0x08;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x20, 0x21,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 5th cmd */
-        /*
-         * 16.0 CTL    21 22 03 00  00 00 00 00
-         */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0003, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        /* send 6th cmd */
-        /*
-         * 16.0  CTL    a1 21 00 00  00 00 07 00        CLASS          33.1.0
-         * 16.0  DI     00 c2 01 00  00 00 08
-         */
-        len = 0x0007;
-        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
-                                 0x21, 0xa1,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 7th cmd */
-        /*
-         * 16.0  CTL    21 20 00 00  00 00 07 00  CLASS               354.1.0
-         * 16.0  DO     00 c2 01 00  00 00 08     .......             354.2.0
-         */
-        len = 0x0007;
-        buf[0] = 0x00;
-        buf[1] = 0xc2;
-        buf[2] = 0x01;
-        buf[3] = 0x00;
-        buf[4] = 0x00;
-        buf[5] = 0x00;
-        buf[6] = 0x08;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x20, 0x21,
-                                 0x0000, 0x0000, buf, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        debug_data(dev, __func__, len, buf, result);
-
-        /* send 8th cmd */
-        /*
-         * 16.0 CTL    21 22 03 00  00 00 00 00
-         */
-        len = 0;
-        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
-                                 0x22, 0x21,
-                                 0x0003, 0x0000, NULL, len,
-                                 USB_CTRL_GET_TIMEOUT);
-        dev_dbg(dev, "result = %d\n", result);
-
-        kfree(buf);
-
-        usb_serial_generic_close(port);
-}
-
-static const struct usb_device_id id_table[] = {
-        { USB_DEVICE(0x19d2, 0xffec) },
-        { USB_DEVICE(0x19d2, 0xffee) },
-        { USB_DEVICE(0x19d2, 0xfff6) },
-        { USB_DEVICE(0x19d2, 0xfff7) },
-        { USB_DEVICE(0x19d2, 0xfff8) },
-        { USB_DEVICE(0x19d2, 0xfff9) },
-        { USB_DEVICE(0x19d2, 0xfffb) },
-        { USB_DEVICE(0x19d2, 0xfffc) },
-        /* MG880 */
-        { USB_DEVICE(0x19d2, 0xfffd) },
-        { },
-};
-MODULE_DEVICE_TABLE(usb, id_table);
-
-static struct usb_serial_driver zio_device = {
-        .driver = {
-                .owner =        THIS_MODULE,
-                .name =         "zte_ev",
-        },
-        .id_table =             id_table,
-        .num_ports =            1,
-        .open =                 zte_ev_usb_serial_open,
-        .close =                zte_ev_usb_serial_close,
-};
-
-static struct usb_serial_driver * const serial_drivers[] = {
-        &zio_device, NULL
-};
-
-module_usb_serial_driver(serial_drivers, id_table);
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/storage/alauda.c b/drivers/usb/storage/alauda.c
index 6636a583da12..62c2d9daa7d6 100644
--- a/drivers/usb/storage/alauda.c
+++ b/drivers/usb/storage/alauda.c
@@ -415,14 +415,11 @@ static int alauda_init_media(struct us_data *us)
         if (alauda_get_media_signature(us, data) != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        usb_stor_dbg(us, "Media signature: %02X %02X %02X %02X\n",
-                     data[0], data[1], data[2], data[3]);
+        usb_stor_dbg(us, "Media signature: %4ph\n", data);
         media_info = alauda_card_find_id(data[1]);
         if (media_info == NULL) {
-                printk(KERN_WARNING
-                        "alauda_init_media: Unrecognised media signature: "
-                        "%02X %02X %02X %02X\n",
-                        data[0], data[1], data[2], data[3]);
+                pr_warn("alauda_init_media: Unrecognised media signature: %4ph\n",
+                        data);
                 return USB_STOR_TRANSPORT_ERROR;
         }
 
@@ -513,7 +510,7 @@ static int alauda_check_status2(struct us_data *us)
         if (rc != USB_STOR_XFER_GOOD)
                 return rc;
 
-        usb_stor_dbg(us, "%02X %02X %02X\n", data[0], data[1], data[2]);
+        usb_stor_dbg(us, "%3ph\n", data);
         if (data[0] & ALAUDA_STATUS_ERROR)
                 return USB_STOR_XFER_ERROR;
 
diff --git a/drivers/usb/storage/initializers.c b/drivers/usb/storage/initializers.c
index 5a8b5ff1e45b..4bc2fc98636e 100644
--- a/drivers/usb/storage/initializers.c
+++ b/drivers/usb/storage/initializers.c
@@ -52,7 +52,7 @@ int usb_stor_euscsi_init(struct us_data *us)
         us->iobuf[0] = 0x1;
         result = usb_stor_control_msg(us, us->send_ctrl_pipe,
                         0x0C, USB_RECIP_INTERFACE | USB_TYPE_VENDOR,
-                        0x01, 0x0, us->iobuf, 0x1, 5000);
+                        0x01, 0x0, us->iobuf, 0x1, USB_CTRL_SET_TIMEOUT);
         usb_stor_dbg(us, "-- result is %d\n", result);
 
         return 0;
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
index 281be56d5648..8591d89a38e6 100644
--- a/drivers/usb/storage/realtek_cr.c
+++ b/drivers/usb/storage/realtek_cr.c
@@ -115,7 +115,7 @@ struct rts51x_chip {
         enum RTS51X_STAT state;
         int support_auto_delink;
 #endif
-        /* used to back up the protocal choosen in probe1 phase */
+        /* used to back up the protocol chosen in probe1 phase */
         proto_cmnd proto_handler_backup;
 };
 
@@ -925,7 +925,7 @@ static int realtek_cr_autosuspend_setup(struct us_data *us)
                         (unsigned long)chip);
         fw5895_init(us);
 
-        /* enable autosuspend funciton of the usb device */
+        /* enable autosuspend function of the usb device */
         usb_enable_autosuspend(us->pusb_dev);
 
         return 0;
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 866b5df36ed1..0e400f382f3a 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -241,7 +241,7 @@ static int slave_configure(struct scsi_device *sdev)
 
                 /* Some USB cardreaders have trouble reading an sdcard's last
                  * sector in a larger then 1 sector read, since the performance
-                 * impact is negible we set this flag for all USB disks */
+                 * impact is negligible we set this flag for all USB disks */
                 sdev->last_sector_bug = 1;
 
                 /* Enable last-sector hacks for single-target devices using
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index 38a4504ce450..3847053d732c 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -1155,8 +1155,7 @@ sddr09_get_cardinfo(struct us_data *us, unsigned char flags) {
                 return NULL;
         }
 
-        sprintf(blurbtxt, "sddr09: Found Flash card, ID = %02X %02X %02X %02X",
-                deviceID[0], deviceID[1], deviceID[2], deviceID[3]);
+        sprintf(blurbtxt, "sddr09: Found Flash card, ID = %4ph", deviceID);
 
         /* Byte 0 is the manufacturer */
         sprintf(blurbtxt + strlen(blurbtxt),
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 3f42785f653c..89b24349269e 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -2,7 +2,7 @@
  * USB Attached SCSI
  * Note that this is not the same as the USB Mass Storage driver
  *
- * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013
+ * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2014
  * Copyright Matthew Wilcox for Intel Corp, 2010
  * Copyright Sarah Sharp for Intel Corp, 2010
  *
@@ -28,20 +28,9 @@
 #include <scsi/scsi_tcq.h>
 
 #include "uas-detect.h"
+#include "scsiglue.h"
 
-/*
- * The r00-r01c specs define this version of the SENSE IU data structure.
- * It's still in use by several different firmware releases.
- */
-struct sense_iu_old {
-        __u8 iu_id;
-        __u8 rsvd1;
-        __be16 tag;
-        __be16 len;
-        __u8 status;
-        __u8 service_response;
-        __u8 sense[SCSI_SENSE_BUFFERSIZE];
-};
+#define MAX_CMNDS 256
 
 struct uas_dev_info {
         struct usb_interface *intf;
@@ -49,18 +38,14 @@ struct uas_dev_info {
         struct usb_anchor cmd_urbs;
         struct usb_anchor sense_urbs;
         struct usb_anchor data_urbs;
+        unsigned long flags;
         int qdepth, resetting;
-        struct response_iu response;
         unsigned cmd_pipe, status_pipe, data_in_pipe, data_out_pipe;
         unsigned use_streams:1;
-        unsigned uas_sense_old:1;
-        unsigned running_task:1;
         unsigned shutdown:1;
-        struct scsi_cmnd *cmnd;
+        struct scsi_cmnd *cmnd[MAX_CMNDS];
         spinlock_t lock;
         struct work_struct work;
-        struct list_head inflight_list;
-        struct list_head dead_list;
 };
 
 enum {
@@ -74,10 +59,8 @@ enum {
         COMMAND_INFLIGHT        = (1 << 8),
         DATA_IN_URB_INFLIGHT    = (1 << 9),
         DATA_OUT_URB_INFLIGHT   = (1 << 10),
-        COMMAND_COMPLETED       = (1 << 11),
-        COMMAND_ABORTED         = (1 << 12),
-        UNLINK_DATA_URBS        = (1 << 13),
-        IS_IN_WORK_LIST         = (1 << 14),
+        COMMAND_ABORTED         = (1 << 11),
+        IS_IN_WORK_LIST         = (1 << 12),
 };
 
 /* Overrides scsi_pointer */
@@ -87,7 +70,6 @@ struct uas_cmd_info {
         struct urb *cmd_urb;
         struct urb *data_in_urb;
         struct urb *data_out_urb;
-        struct list_head list;
 };
 
 /* I hate forward declarations, but I actually have a loop */
@@ -96,43 +78,29 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 static void uas_do_work(struct work_struct *work);
 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller);
 static void uas_free_streams(struct uas_dev_info *devinfo);
-static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller);
-
-/* Must be called with devinfo->lock held, will temporary unlock the lock */
-static void uas_unlink_data_urbs(struct uas_dev_info *devinfo,
-                                 struct uas_cmd_info *cmdinfo,
-                                 unsigned long *lock_flags)
-{
-        /*
-         * The UNLINK_DATA_URBS flag makes sure uas_try_complete
-         * (called by urb completion) doesn't release cmdinfo
-         * underneath us.
-         */
-        cmdinfo->state |= UNLINK_DATA_URBS;
-        spin_unlock_irqrestore(&devinfo->lock, *lock_flags);
-
-        if (cmdinfo->data_in_urb)
-                usb_unlink_urb(cmdinfo->data_in_urb);
-        if (cmdinfo->data_out_urb)
-                usb_unlink_urb(cmdinfo->data_out_urb);
-
-        spin_lock_irqsave(&devinfo->lock, *lock_flags);
-        cmdinfo->state &= ~UNLINK_DATA_URBS;
-}
+static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
+                                int status);
 
 static void uas_do_work(struct work_struct *work)
 {
         struct uas_dev_info *devinfo =
                 container_of(work, struct uas_dev_info, work);
         struct uas_cmd_info *cmdinfo;
+        struct scsi_cmnd *cmnd;
         unsigned long flags;
-        int err;
+        int i, err;
 
         spin_lock_irqsave(&devinfo->lock, flags);
-        list_for_each_entry(cmdinfo, &devinfo->inflight_list, list) {
-                struct scsi_pointer *scp = (void *)cmdinfo;
-                struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd,
-                                                      SCp);
+
+        if (devinfo->resetting)
+                goto out;
+
+        for (i = 0; i < devinfo->qdepth; i++) {
+                if (!devinfo->cmnd[i])
+                        continue;
+
+                cmnd = devinfo->cmnd[i];
+                cmdinfo = (void *)&cmnd->SCp;
 
                 if (!(cmdinfo->state & IS_IN_WORK_LIST))
                         continue;
@@ -143,35 +111,7 @@ static void uas_do_work(struct work_struct *work)
                 else
                         schedule_work(&devinfo->work);
         }
-        spin_unlock_irqrestore(&devinfo->lock, flags);
-}
-
-static void uas_mark_cmd_dead(struct uas_dev_info *devinfo,
-                              struct uas_cmd_info *cmdinfo,
-                              int result, const char *caller)
-{
-        struct scsi_pointer *scp = (void *)cmdinfo;
-        struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp);
-
-        uas_log_cmd_state(cmnd, caller);
-        WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
-        WARN_ON_ONCE(cmdinfo->state & COMMAND_ABORTED);
-        cmdinfo->state |= COMMAND_ABORTED;
-        cmdinfo->state &= ~IS_IN_WORK_LIST;
-        cmnd->result = result << 16;
-        list_move_tail(&cmdinfo->list, &devinfo->dead_list);
-}
-
-static void uas_abort_inflight(struct uas_dev_info *devinfo, int result,
-                               const char *caller)
-{
-        struct uas_cmd_info *cmdinfo;
-        struct uas_cmd_info *temp;
-        unsigned long flags;
-
-        spin_lock_irqsave(&devinfo->lock, flags);
-        list_for_each_entry_safe(cmdinfo, temp, &devinfo->inflight_list, list)
-                uas_mark_cmd_dead(devinfo, cmdinfo, result, caller);
+out:
         spin_unlock_irqrestore(&devinfo->lock, flags);
 }
 
@@ -181,31 +121,32 @@ static void uas_add_work(struct uas_cmd_info *cmdinfo)
         struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd, SCp);
         struct uas_dev_info *devinfo = cmnd->device->hostdata;
 
-        WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
+        lockdep_assert_held(&devinfo->lock);
         cmdinfo->state |= IS_IN_WORK_LIST;
         schedule_work(&devinfo->work);
 }
 
-static void uas_zap_dead(struct uas_dev_info *devinfo)
+static void uas_zap_pending(struct uas_dev_info *devinfo, int result)
 {
         struct uas_cmd_info *cmdinfo;
-        struct uas_cmd_info *temp;
+        struct scsi_cmnd *cmnd;
         unsigned long flags;
+        int i, err;
 
         spin_lock_irqsave(&devinfo->lock, flags);
-        list_for_each_entry_safe(cmdinfo, temp, &devinfo->dead_list, list) {
-                struct scsi_pointer *scp = (void *)cmdinfo;
-                struct scsi_cmnd *cmnd = container_of(scp, struct scsi_cmnd,
-                                                      SCp);
-                uas_log_cmd_state(cmnd, __func__);
-                WARN_ON_ONCE(!(cmdinfo->state & COMMAND_ABORTED));
-                /* all urbs are killed, clear inflight bits */
-                cmdinfo->state &= ~(COMMAND_INFLIGHT |
-                                    DATA_IN_URB_INFLIGHT |
-                                    DATA_OUT_URB_INFLIGHT);
-                uas_try_complete(cmnd, __func__);
+        for (i = 0; i < devinfo->qdepth; i++) {
+                if (!devinfo->cmnd[i])
+                        continue;
+
+                cmnd = devinfo->cmnd[i];
+                cmdinfo = (void *)&cmnd->SCp;
+                uas_log_cmd_state(cmnd, __func__, 0);
+                /* Sense urbs were killed, clear COMMAND_INFLIGHT manually */
+                cmdinfo->state &= ~COMMAND_INFLIGHT;
+                cmnd->result = result << 16;
+                err = uas_try_complete(cmnd, __func__);
+                WARN_ON(err != 0);
         }
-        devinfo->running_task = 0;
         spin_unlock_irqrestore(&devinfo->lock, flags);
 }
 
@@ -232,36 +173,30 @@ static void uas_sense(struct urb *urb, struct scsi_cmnd *cmnd)
         cmnd->result = sense_iu->status;
 }
 
-static void uas_sense_old(struct urb *urb, struct scsi_cmnd *cmnd)
+/*
+ * scsi-tags go from 0 - (nr_tags - 1), uas tags need to match stream-ids,
+ * which go from 1 - nr_streams. And we use 1 for untagged commands.
+ */
+static int uas_get_tag(struct scsi_cmnd *cmnd)
 {
-        struct sense_iu_old *sense_iu = urb->transfer_buffer;
-        struct scsi_device *sdev = cmnd->device;
+        int tag;
 
-        if (urb->actual_length > 8) {
-                unsigned len = be16_to_cpup(&sense_iu->len) - 2;
-                if (len + 8 != urb->actual_length) {
-                        int newlen = min(len + 8, urb->actual_length) - 8;
-                        if (newlen < 0)
-                                newlen = 0;
-                        sdev_printk(KERN_INFO, sdev, "%s: urb length %d "
-                                "disagrees with IU sense data length %d, "
-                                "using %d bytes of sense data\n", __func__,
-                                        urb->actual_length, len, newlen);
-                        len = newlen;
-                }
-                memcpy(cmnd->sense_buffer, sense_iu->sense, len);
-        }
+        if (blk_rq_tagged(cmnd->request))
+                tag = cmnd->request->tag + 2;
+        else
+                tag = 1;
 
-        cmnd->result = sense_iu->status;
+        return tag;
 }
 
-static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller)
+static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *prefix,
+                              int status)
 {
         struct uas_cmd_info *ci = (void *)&cmnd->SCp;
 
-        scmd_printk(KERN_INFO, cmnd, "%s %p tag %d, inflight:"
-                    "%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
-                    caller, cmnd, cmnd->request->tag,
+        scmd_printk(KERN_INFO, cmnd,
+                    "%s %d tag %d inflight:%s%s%s%s%s%s%s%s%s%s%s%s ",
+                    prefix, status, uas_get_tag(cmnd),
                     (ci->state & SUBMIT_STATUS_URB)     ? " s-st"  : "",
                     (ci->state & ALLOC_DATA_IN_URB)     ? " a-in"  : "",
                     (ci->state & SUBMIT_DATA_IN_URB)    ? " s-in"  : "",
@@ -272,10 +207,28 @@ static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller)
                     (ci->state & COMMAND_INFLIGHT)      ? " CMD"   : "",
                     (ci->state & DATA_IN_URB_INFLIGHT)  ? " IN"    : "",
                     (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT"   : "",
-                    (ci->state & COMMAND_COMPLETED)     ? " done"  : "",
                     (ci->state & COMMAND_ABORTED)       ? " abort" : "",
-                    (ci->state & UNLINK_DATA_URBS)      ? " unlink": "",
                     (ci->state & IS_IN_WORK_LIST)       ? " work"  : "");
+        scsi_print_command(cmnd);
+}
+
+static void uas_free_unsubmitted_urbs(struct scsi_cmnd *cmnd)
+{
+        struct uas_cmd_info *cmdinfo;
+
+        if (!cmnd)
+                return;
+
+        cmdinfo = (void *)&cmnd->SCp;
+
+        if (cmdinfo->state & SUBMIT_CMD_URB)
+                usb_free_urb(cmdinfo->cmd_urb);
+
+        /* data urbs may have never gotten their submit flag set */
+        if (!(cmdinfo->state & DATA_IN_URB_INFLIGHT))
+                usb_free_urb(cmdinfo->data_in_urb);
+        if (!(cmdinfo->state & DATA_OUT_URB_INFLIGHT))
+                usb_free_urb(cmdinfo->data_out_urb);
 }
 
 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
@@ -283,19 +236,14 @@ static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
 
-        WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
+        lockdep_assert_held(&devinfo->lock);
         if (cmdinfo->state & (COMMAND_INFLIGHT |
                               DATA_IN_URB_INFLIGHT |
                               DATA_OUT_URB_INFLIGHT |
-                              UNLINK_DATA_URBS))
+                              COMMAND_ABORTED))
                 return -EBUSY;
-        WARN_ON_ONCE(cmdinfo->state & COMMAND_COMPLETED);
-        cmdinfo->state |= COMMAND_COMPLETED;
-        usb_free_urb(cmdinfo->data_in_urb);
-        usb_free_urb(cmdinfo->data_out_urb);
-        if (cmdinfo->state & COMMAND_ABORTED)
-                scmd_printk(KERN_INFO, cmnd, "abort completed\n");
-        list_del(&cmdinfo->list);
+        devinfo->cmnd[uas_get_tag(cmnd) - 1] = NULL;
+        uas_free_unsubmitted_urbs(cmnd);
         cmnd->scsi_done(cmnd);
         return 0;
 }
@@ -318,63 +266,48 @@ static void uas_stat_cmplt(struct urb *urb)
         struct iu *iu = urb->transfer_buffer;
         struct Scsi_Host *shost = urb->context;
         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
+        struct urb *data_in_urb = NULL;
+        struct urb *data_out_urb = NULL;
         struct scsi_cmnd *cmnd;
         struct uas_cmd_info *cmdinfo;
         unsigned long flags;
-        u16 tag;
+        unsigned int idx;
+
+        spin_lock_irqsave(&devinfo->lock, flags);
+
+        if (devinfo->resetting)
+                goto out;
 
         if (urb->status) {
-                if (urb->status == -ENOENT) {
-                        dev_err(&urb->dev->dev, "stat urb: killed, stream %d\n",
-                                urb->stream_id);
-                } else {
+                if (urb->status != -ENOENT && urb->status != -ECONNRESET) {
                         dev_err(&urb->dev->dev, "stat urb: status %d\n",
                                 urb->status);
                 }
-                usb_free_urb(urb);
-                return;
+                goto out;
         }
 
-        if (devinfo->resetting) {
-                usb_free_urb(urb);
-                return;
+        idx = be16_to_cpup(&iu->tag) - 1;
+        if (idx >= MAX_CMNDS || !devinfo->cmnd[idx]) {
+                dev_err(&urb->dev->dev,
+                        "stat urb: no pending cmd for tag %d\n", idx + 1);
+                goto out;
         }
 
-        spin_lock_irqsave(&devinfo->lock, flags);
-        tag = be16_to_cpup(&iu->tag) - 1;
-        if (tag == 0)
-                cmnd = devinfo->cmnd;
-        else
-                cmnd = scsi_host_find_tag(shost, tag - 1);
-
-        if (!cmnd) {
-                if (iu->iu_id == IU_ID_RESPONSE) {
-                        if (!devinfo->running_task)
-                                dev_warn(&urb->dev->dev,
-                                    "stat urb: recv unexpected response iu\n");
-                        /* store results for uas_eh_task_mgmt() */
-                        memcpy(&devinfo->response, iu, sizeof(devinfo->response));
-                }
-                usb_free_urb(urb);
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                return;
+        cmnd = devinfo->cmnd[idx];
+        cmdinfo = (void *)&cmnd->SCp;
+
+        if (!(cmdinfo->state & COMMAND_INFLIGHT)) {
+                uas_log_cmd_state(cmnd, "unexpected status cmplt", 0);
+                goto out;
         }
 
-        cmdinfo = (void *)&cmnd->SCp;
         switch (iu->iu_id) {
         case IU_ID_STATUS:
-                if (devinfo->cmnd == cmnd)
-                        devinfo->cmnd = NULL;
-
-                if (urb->actual_length < 16)
-                        devinfo->uas_sense_old = 1;
-                if (devinfo->uas_sense_old)
-                        uas_sense_old(urb, cmnd);
-                else
-                        uas_sense(urb, cmnd);
+                uas_sense(urb, cmnd);
                 if (cmnd->result != 0) {
                         /* cancel data transfers on error */
-                        uas_unlink_data_urbs(devinfo, cmdinfo, &flags);
+                        data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
+                        data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
                 }
                 cmdinfo->state &= ~COMMAND_INFLIGHT;
                 uas_try_complete(cmnd, __func__);
@@ -382,7 +315,7 @@ static void uas_stat_cmplt(struct urb *urb)
         case IU_ID_READ_READY:
                 if (!cmdinfo->data_in_urb ||
                                 (cmdinfo->state & DATA_IN_URB_INFLIGHT)) {
-                        scmd_printk(KERN_ERR, cmnd, "unexpected read rdy\n");
+                        uas_log_cmd_state(cmnd, "unexpected read rdy", 0);
                         break;
                 }
                 uas_xfer_data(urb, cmnd, SUBMIT_DATA_IN_URB);
@@ -390,17 +323,37 @@ static void uas_stat_cmplt(struct urb *urb)
         case IU_ID_WRITE_READY:
                 if (!cmdinfo->data_out_urb ||
                                 (cmdinfo->state & DATA_OUT_URB_INFLIGHT)) {
-                        scmd_printk(KERN_ERR, cmnd, "unexpected write rdy\n");
+                        uas_log_cmd_state(cmnd, "unexpected write rdy", 0);
                         break;
                 }
                 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
                 break;
+        case IU_ID_RESPONSE:
+                uas_log_cmd_state(cmnd, "unexpected response iu",
+                                  ((struct response_iu *)iu)->response_code);
+                /* Error, cancel data transfers */
+                data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
+                data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
+                cmdinfo->state &= ~COMMAND_INFLIGHT;
+                cmnd->result = DID_ERROR << 16;
+                uas_try_complete(cmnd, __func__);
+                break;
         default:
-                scmd_printk(KERN_ERR, cmnd,
-                        "Bogus IU (%d) received on status pipe\n", iu->iu_id);
+                uas_log_cmd_state(cmnd, "bogus IU", iu->iu_id);
         }
+out:
         usb_free_urb(urb);
         spin_unlock_irqrestore(&devinfo->lock, flags);
+
+        /* Unlinking of data urbs must be done without holding the lock */
+        if (data_in_urb) {
+                usb_unlink_urb(data_in_urb);
+                usb_put_urb(data_in_urb);
+        }
+        if (data_out_urb) {
+                usb_unlink_urb(data_out_urb);
+                usb_put_urb(data_out_urb);
+        }
 }
 
 static void uas_data_cmplt(struct urb *urb)
@@ -412,57 +365,69 @@ static void uas_data_cmplt(struct urb *urb)
         unsigned long flags;
 
         spin_lock_irqsave(&devinfo->lock, flags);
+
         if (cmdinfo->data_in_urb == urb) {
                 sdb = scsi_in(cmnd);
                 cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
+                cmdinfo->data_in_urb = NULL;
         } else if (cmdinfo->data_out_urb == urb) {
                 sdb = scsi_out(cmnd);
                 cmdinfo->state &= ~DATA_OUT_URB_INFLIGHT;
+                cmdinfo->data_out_urb = NULL;
         }
         if (sdb == NULL) {
                 WARN_ON_ONCE(1);
-        } else if (urb->status) {
-                if (urb->status != -ECONNRESET) {
-                        uas_log_cmd_state(cmnd, __func__);
-                        scmd_printk(KERN_ERR, cmnd,
-                                "data cmplt err %d stream %d\n",
-                                urb->status, urb->stream_id);
-                }
+                goto out;
+        }
+
+        if (devinfo->resetting)
+                goto out;
+
+        /* Data urbs should not complete before the cmd urb is submitted */
+        if (cmdinfo->state & SUBMIT_CMD_URB) {
+                uas_log_cmd_state(cmnd, "unexpected data cmplt", 0);
+                goto out;
+        }
+
+        if (urb->status) {
+                if (urb->status != -ENOENT && urb->status != -ECONNRESET)
+                        uas_log_cmd_state(cmnd, "data cmplt err", urb->status);
                 /* error: no data transfered */
                 sdb->resid = sdb->length;
         } else {
                 sdb->resid = sdb->length - urb->actual_length;
         }
         uas_try_complete(cmnd, __func__);
+out:
+        usb_free_urb(urb);
         spin_unlock_irqrestore(&devinfo->lock, flags);
 }
 
 static void uas_cmd_cmplt(struct urb *urb)
 {
-        struct scsi_cmnd *cmnd = urb->context;
+        if (urb->status)
+                dev_err(&urb->dev->dev, "cmd cmplt err %d\n", urb->status);
 
-        if (urb->status) {
-                uas_log_cmd_state(cmnd, __func__);
-                scmd_printk(KERN_ERR, cmnd, "cmd cmplt err %d\n", urb->status);
-        }
         usb_free_urb(urb);
 }
 
 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
-                                      unsigned int pipe, u16 stream_id,
                                       struct scsi_cmnd *cmnd,
                                       enum dma_data_direction dir)
 {
         struct usb_device *udev = devinfo->udev;
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         struct urb *urb = usb_alloc_urb(0, gfp);
         struct scsi_data_buffer *sdb = (dir == DMA_FROM_DEVICE)
                 ? scsi_in(cmnd) : scsi_out(cmnd);
+        unsigned int pipe = (dir == DMA_FROM_DEVICE)
+                ? devinfo->data_in_pipe : devinfo->data_out_pipe;
 
         if (!urb)
                 goto out;
         usb_fill_bulk_urb(urb, udev, pipe, NULL, sdb->length,
                           uas_data_cmplt, cmnd);
-        urb->stream_id = stream_id;
+        urb->stream_id = cmdinfo->stream;
         urb->num_sgs = udev->bus->sg_tablesize ? sdb->table.nents : 0;
         urb->sg = sdb->table.sgl;
  out:
@@ -470,9 +435,10 @@ static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
 }
 
 static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
-                                       struct Scsi_Host *shost, u16 stream_id)
+                                       struct scsi_cmnd *cmnd)
 {
         struct usb_device *udev = devinfo->udev;
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         struct urb *urb = usb_alloc_urb(0, gfp);
         struct sense_iu *iu;
 
@@ -484,8 +450,8 @@ static struct urb *uas_alloc_sense_urb(struct uas_dev_info *devinfo, gfp_t gfp,
                 goto free;
 
         usb_fill_bulk_urb(urb, udev, devinfo->status_pipe, iu, sizeof(*iu),
-                                                uas_stat_cmplt, shost);
-        urb->stream_id = stream_id;
+                          uas_stat_cmplt, cmnd->device->host);
+        urb->stream_id = cmdinfo->stream;
         urb->transfer_flags |= URB_FREE_BUFFER;
  out:
         return urb;
@@ -515,17 +481,14 @@ static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
                 goto free;
 
         iu->iu_id = IU_ID_COMMAND;
-        if (blk_rq_tagged(cmnd->request))
-                iu->tag = cpu_to_be16(cmnd->request->tag + 2);
-        else
-                iu->tag = cpu_to_be16(1);
+        iu->tag = cpu_to_be16(uas_get_tag(cmnd));
         iu->prio_attr = UAS_SIMPLE_TAG;
         iu->len = len;
         int_to_scsilun(sdev->lun, &iu->lun);
         memcpy(iu->cdb, cmnd->cmnd, cmnd->cmd_len);
 
         usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu) + len,
-                                                        uas_cmd_cmplt, cmnd);
+                                                        uas_cmd_cmplt, NULL);
         urb->transfer_flags |= URB_FREE_BUFFER;
  out:
         return urb;
@@ -534,81 +497,26 @@ static struct urb *uas_alloc_cmd_urb(struct uas_dev_info *devinfo, gfp_t gfp,
         return NULL;
 }
 
-static int uas_submit_task_urb(struct scsi_cmnd *cmnd, gfp_t gfp,
-                               u8 function, u16 stream_id)
-{
-        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
-        struct usb_device *udev = devinfo->udev;
-        struct urb *urb = usb_alloc_urb(0, gfp);
-        struct task_mgmt_iu *iu;
-        int err = -ENOMEM;
-
-        if (!urb)
-                goto err;
-
-        iu = kzalloc(sizeof(*iu), gfp);
-        if (!iu)
-                goto err;
-
-        iu->iu_id = IU_ID_TASK_MGMT;
-        iu->tag = cpu_to_be16(stream_id);
-        int_to_scsilun(cmnd->device->lun, &iu->lun);
-
-        iu->function = function;
-        switch (function) {
-        case TMF_ABORT_TASK:
-                if (blk_rq_tagged(cmnd->request))
-                        iu->task_tag = cpu_to_be16(cmnd->request->tag + 2);
-                else
-                        iu->task_tag = cpu_to_be16(1);
-                break;
-        }
-
-        usb_fill_bulk_urb(urb, udev, devinfo->cmd_pipe, iu, sizeof(*iu),
-                          uas_cmd_cmplt, cmnd);
-        urb->transfer_flags |= URB_FREE_BUFFER;
-
-        usb_anchor_urb(urb, &devinfo->cmd_urbs);
-        err = usb_submit_urb(urb, gfp);
-        if (err) {
-                usb_unanchor_urb(urb);
-                uas_log_cmd_state(cmnd, __func__);
-                scmd_printk(KERN_ERR, cmnd, "task submission err %d\n", err);
-                goto err;
-        }
-
-        return 0;
-
-err:
-        usb_free_urb(urb);
-        return err;
-}
-
 /*
  * Why should I request the Status IU before sending the Command IU?  Spec
  * says to, but also says the device may receive them in any order.  Seems
  * daft to me.
  */
 
-static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd,
-                                        gfp_t gfp, unsigned int stream)
+static struct urb *uas_submit_sense_urb(struct scsi_cmnd *cmnd, gfp_t gfp)
 {
-        struct Scsi_Host *shost = cmnd->device->host;
-        struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
+        struct uas_dev_info *devinfo = cmnd->device->hostdata;
         struct urb *urb;
         int err;
 
-        urb = uas_alloc_sense_urb(devinfo, gfp, shost, stream);
+        urb = uas_alloc_sense_urb(devinfo, gfp, cmnd);
         if (!urb)
                 return NULL;
         usb_anchor_urb(urb, &devinfo->sense_urbs);
         err = usb_submit_urb(urb, gfp);
         if (err) {
                 usb_unanchor_urb(urb);
-                uas_log_cmd_state(cmnd, __func__);
-                shost_printk(KERN_INFO, shost,
-                             "sense urb submission error %d stream %d\n",
-                             err, stream);
+                uas_log_cmd_state(cmnd, "sense submit err", err);
                 usb_free_urb(urb);
                 return NULL;
         }
@@ -622,9 +530,9 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
         struct urb *urb;
         int err;
 
-        WARN_ON_ONCE(!spin_is_locked(&devinfo->lock));
+        lockdep_assert_held(&devinfo->lock);
         if (cmdinfo->state & SUBMIT_STATUS_URB) {
-                urb = uas_submit_sense_urb(cmnd, gfp, cmdinfo->stream);
+                urb = uas_submit_sense_urb(cmnd, gfp);
                 if (!urb)
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 cmdinfo->state &= ~SUBMIT_STATUS_URB;
@@ -632,8 +540,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 
         if (cmdinfo->state & ALLOC_DATA_IN_URB) {
                 cmdinfo->data_in_urb = uas_alloc_data_urb(devinfo, gfp,
-                                        devinfo->data_in_pipe, cmdinfo->stream,
-                                        cmnd, DMA_FROM_DEVICE);
+                                                        cmnd, DMA_FROM_DEVICE);
                 if (!cmdinfo->data_in_urb)
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 cmdinfo->state &= ~ALLOC_DATA_IN_URB;
@@ -644,10 +551,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
                 err = usb_submit_urb(cmdinfo->data_in_urb, gfp);
                 if (err) {
                         usb_unanchor_urb(cmdinfo->data_in_urb);
-                        uas_log_cmd_state(cmnd, __func__);
-                        scmd_printk(KERN_INFO, cmnd,
-                                "data in urb submission error %d stream %d\n",
-                                err, cmdinfo->data_in_urb->stream_id);
+                        uas_log_cmd_state(cmnd, "data in submit err", err);
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
                 cmdinfo->state &= ~SUBMIT_DATA_IN_URB;
@@ -656,8 +560,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 
         if (cmdinfo->state & ALLOC_DATA_OUT_URB) {
                 cmdinfo->data_out_urb = uas_alloc_data_urb(devinfo, gfp,
-                                        devinfo->data_out_pipe, cmdinfo->stream,
-                                        cmnd, DMA_TO_DEVICE);
+                                                        cmnd, DMA_TO_DEVICE);
                 if (!cmdinfo->data_out_urb)
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 cmdinfo->state &= ~ALLOC_DATA_OUT_URB;
@@ -668,10 +571,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
                 err = usb_submit_urb(cmdinfo->data_out_urb, gfp);
                 if (err) {
                         usb_unanchor_urb(cmdinfo->data_out_urb);
-                        uas_log_cmd_state(cmnd, __func__);
-                        scmd_printk(KERN_INFO, cmnd,
-                                "data out urb submission error %d stream %d\n",
-                                err, cmdinfo->data_out_urb->stream_id);
+                        uas_log_cmd_state(cmnd, "data out submit err", err);
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
                 cmdinfo->state &= ~SUBMIT_DATA_OUT_URB;
@@ -690,9 +590,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
                 err = usb_submit_urb(cmdinfo->cmd_urb, gfp);
                 if (err) {
                         usb_unanchor_urb(cmdinfo->cmd_urb);
-                        uas_log_cmd_state(cmnd, __func__);
-                        scmd_printk(KERN_INFO, cmnd,
-                                    "cmd urb submission error %d\n", err);
+                        uas_log_cmd_state(cmnd, "cmd submit err", err);
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
                 cmdinfo->cmd_urb = NULL;
@@ -710,10 +608,24 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
         struct uas_dev_info *devinfo = sdev->hostdata;
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         unsigned long flags;
+        unsigned int stream;
         int err;
 
         BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
 
+        /* Re-check scsi_block_requests now that we've the host-lock */
+        if (cmnd->device->host->host_self_blocked)
+                return SCSI_MLQUEUE_DEVICE_BUSY;
+
+        if ((devinfo->flags & US_FL_NO_ATA_1X) &&
+                        (cmnd->cmnd[0] == ATA_12 || cmnd->cmnd[0] == ATA_16)) {
+                memcpy(cmnd->sense_buffer, usb_stor_sense_invalidCDB,
+                       sizeof(usb_stor_sense_invalidCDB));
+                cmnd->result = SAM_STAT_CHECK_CONDITION;
+                cmnd->scsi_done(cmnd);
+                return 0;
+        }
+
         spin_lock_irqsave(&devinfo->lock, flags);
 
         if (devinfo->resetting) {
@@ -723,24 +635,17 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
                 return 0;
         }
 
-        if (devinfo->cmnd) {
+        stream = uas_get_tag(cmnd);
+        if (devinfo->cmnd[stream - 1]) {
                 spin_unlock_irqrestore(&devinfo->lock, flags);
                 return SCSI_MLQUEUE_DEVICE_BUSY;
         }
 
-        memset(cmdinfo, 0, sizeof(*cmdinfo));
-
-        if (blk_rq_tagged(cmnd->request)) {
-                cmdinfo->stream = cmnd->request->tag + 2;
-        } else {
-                devinfo->cmnd = cmnd;
-                cmdinfo->stream = 1;
-        }
-
         cmnd->scsi_done = done;
 
-        cmdinfo->state = SUBMIT_STATUS_URB |
-                        ALLOC_CMD_URB | SUBMIT_CMD_URB;
+        memset(cmdinfo, 0, sizeof(*cmdinfo));
+        cmdinfo->stream = stream;
+        cmdinfo->state = SUBMIT_STATUS_URB | ALLOC_CMD_URB | SUBMIT_CMD_URB;
 
         switch (cmnd->sc_data_direction) {
         case DMA_FROM_DEVICE:
@@ -769,123 +674,54 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
                 uas_add_work(cmdinfo);
         }
 
-        list_add_tail(&cmdinfo->list, &devinfo->inflight_list);
+        devinfo->cmnd[stream - 1] = cmnd;
         spin_unlock_irqrestore(&devinfo->lock, flags);
         return 0;
 }
 
 static DEF_SCSI_QCMD(uas_queuecommand)
 
-static int uas_eh_task_mgmt(struct scsi_cmnd *cmnd,
-                            const char *fname, u8 function)
+/*
+ * For now we do not support actually sending an abort to the device, so
+ * this eh always fails. Still we must define it to make sure that we've
+ * dropped all references to the cmnd in question once this function exits.
+ */
+static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
 {
-        struct Scsi_Host *shost = cmnd->device->host;
-        struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
-        u16 tag = devinfo->qdepth;
+        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
+        struct urb *data_in_urb = NULL;
+        struct urb *data_out_urb = NULL;
         unsigned long flags;
-        struct urb *sense_urb;
-        int result = SUCCESS;
 
         spin_lock_irqsave(&devinfo->lock, flags);
 
-        if (devinfo->resetting) {
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                return FAILED;
-        }
+        uas_log_cmd_state(cmnd, __func__, 0);
 
-        if (devinfo->running_task) {
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s: error already running a task\n",
-                             __func__, fname);
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                return FAILED;
-        }
+        /* Ensure that try_complete does not call scsi_done */
+        cmdinfo->state |= COMMAND_ABORTED;
 
-        devinfo->running_task = 1;
-        memset(&devinfo->response, 0, sizeof(devinfo->response));
-        sense_urb = uas_submit_sense_urb(cmnd, GFP_ATOMIC,
-                                         devinfo->use_streams ? tag : 0);
-        if (!sense_urb) {
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s: submit sense urb failed\n",
-                             __func__, fname);
-                devinfo->running_task = 0;
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                return FAILED;
-        }
-        if (uas_submit_task_urb(cmnd, GFP_ATOMIC, function, tag)) {
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s: submit task mgmt urb failed\n",
-                             __func__, fname);
-                devinfo->running_task = 0;
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                usb_kill_urb(sense_urb);
-                return FAILED;
-        }
-        spin_unlock_irqrestore(&devinfo->lock, flags);
+        /* Drop all refs to this cmnd, kill data urbs to break their ref */
+        devinfo->cmnd[uas_get_tag(cmnd) - 1] = NULL;
+        if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
+                data_in_urb = usb_get_urb(cmdinfo->data_in_urb);
+        if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
+                data_out_urb = usb_get_urb(cmdinfo->data_out_urb);
 
-        if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 3000) == 0) {
-                /*
-                 * Note we deliberately do not clear running_task here. If we
-                 * allow new tasks to be submitted, there is no way to figure
-                 * out if a received response_iu is for the failed task or for
-                 * the new one. A bus-reset will eventually clear running_task.
-                 */
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s timed out\n", __func__, fname);
-                return FAILED;
-        }
+        uas_free_unsubmitted_urbs(cmnd);
 
-        spin_lock_irqsave(&devinfo->lock, flags);
-        devinfo->running_task = 0;
-        if (be16_to_cpu(devinfo->response.tag) != tag) {
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s failed (wrong tag %d/%d)\n", __func__,
-                             fname, be16_to_cpu(devinfo->response.tag), tag);
-                result = FAILED;
-        } else if (devinfo->response.response_code != RC_TMF_COMPLETE) {
-                shost_printk(KERN_INFO, shost,
-                             "%s: %s failed (rc 0x%x)\n", __func__,
-                             fname, devinfo->response.response_code);
-                result = FAILED;
-        }
         spin_unlock_irqrestore(&devinfo->lock, flags);
 
-        return result;
-}
-
-static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
-{
-        struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
-        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
-        unsigned long flags;
-        int ret;
-
-        spin_lock_irqsave(&devinfo->lock, flags);
-
-        if (devinfo->resetting) {
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                return FAILED;
+        if (data_in_urb) {
+                usb_kill_urb(data_in_urb);
+                usb_put_urb(data_in_urb);
         }
-
-        uas_mark_cmd_dead(devinfo, cmdinfo, DID_ABORT, __func__);
-        if (cmdinfo->state & COMMAND_INFLIGHT) {
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                ret = uas_eh_task_mgmt(cmnd, "ABORT TASK", TMF_ABORT_TASK);
-        } else {
-                uas_unlink_data_urbs(devinfo, cmdinfo, &flags);
-                uas_try_complete(cmnd, __func__);
-                spin_unlock_irqrestore(&devinfo->lock, flags);
-                ret = SUCCESS;
+        if (data_out_urb) {
+                usb_kill_urb(data_out_urb);
+                usb_put_urb(data_out_urb);
         }
-        return ret;
-}
 
-static int uas_eh_device_reset_handler(struct scsi_cmnd *cmnd)
-{
-        sdev_printk(KERN_INFO, cmnd->device, "%s\n", __func__);
-        return uas_eh_task_mgmt(cmnd, "LOGICAL UNIT RESET",
-                                TMF_LOGICAL_UNIT_RESET);
+        return FAILED;
 }
 
 static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
@@ -893,6 +729,7 @@ static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
         struct scsi_device *sdev = cmnd->device;
         struct uas_dev_info *devinfo = sdev->hostdata;
         struct usb_device *udev = devinfo->udev;
+        unsigned long flags;
         int err;
 
         err = usb_lock_device_for_reset(udev, devinfo->intf);
@@ -903,19 +740,27 @@ static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
         }
 
         shost_printk(KERN_INFO, sdev->host, "%s start\n", __func__);
+
+        spin_lock_irqsave(&devinfo->lock, flags);
         devinfo->resetting = 1;
-        uas_abort_inflight(devinfo, DID_RESET, __func__);
+        spin_unlock_irqrestore(&devinfo->lock, flags);
+
         usb_kill_anchored_urbs(&devinfo->cmd_urbs);
         usb_kill_anchored_urbs(&devinfo->sense_urbs);
         usb_kill_anchored_urbs(&devinfo->data_urbs);
-        uas_zap_dead(devinfo);
+        uas_zap_pending(devinfo, DID_RESET);
+
         err = usb_reset_device(udev);
+
+        spin_lock_irqsave(&devinfo->lock, flags);
         devinfo->resetting = 0;
+        spin_unlock_irqrestore(&devinfo->lock, flags);
 
         usb_unlock_device(udev);
 
         if (err) {
-                shost_printk(KERN_INFO, sdev->host, "%s FAILED\n", __func__);
+                shost_printk(KERN_INFO, sdev->host, "%s FAILED err %d\n",
+                             __func__, err);
                 return FAILED;
         }
 
@@ -950,6 +795,10 @@ static int uas_slave_alloc(struct scsi_device *sdev)
 static int uas_slave_configure(struct scsi_device *sdev)
 {
         struct uas_dev_info *devinfo = sdev->hostdata;
+
+        if (devinfo->flags & US_FL_NO_REPORT_OPCODES)
+                sdev->no_report_opcodes = 1;
+
         scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
         scsi_activate_tcq(sdev, devinfo->qdepth - 2);
         return 0;
@@ -962,7 +811,6 @@ static struct scsi_host_template uas_host_template = {
         .slave_alloc = uas_slave_alloc,
         .slave_configure = uas_slave_configure,
         .eh_abort_handler = uas_eh_abort_handler,
-        .eh_device_reset_handler = uas_eh_device_reset_handler,
         .eh_bus_reset_handler = uas_eh_bus_reset_handler,
         .can_queue = 65536,     /* Is there a limit on the _host_ ? */
         .this_id = -1,
@@ -970,6 +818,13 @@ static struct scsi_host_template uas_host_template = {
         .cmd_per_lun = 1,       /* until we override it */
         .skip_settle_delay = 1,
         .ordered_tag = 1,
+
+        /*
+         * The uas drivers expects tags not to be bigger than the maximum
+         * per-device queue depth, which is not true with the blk-mq tag
+         * allocator.
+         */
+        .disable_blk_mq = true,
 };
 
 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
@@ -982,8 +837,6 @@ static struct usb_device_id uas_usb_ids[] = {
 #       include "unusual_uas.h"
         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_BULK) },
         { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, USB_PR_UAS) },
-        /* 0xaa is a prototype device I happen to have access to */
-        { USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, USB_SC_SCSI, 0xaa) },
         { }
 };
 MODULE_DEVICE_TABLE(usb, uas_usb_ids);
@@ -1009,9 +862,6 @@ static int uas_configure_endpoints(struct uas_dev_info *devinfo)
         struct usb_device *udev = devinfo->udev;
         int r;
 
-        devinfo->uas_sense_old = 0;
-        devinfo->cmnd = NULL;
-
         r = uas_find_endpoints(devinfo->intf->cur_altsetting, eps);
         if (r)
                 return r;
@@ -1025,12 +875,12 @@ static int uas_configure_endpoints(struct uas_dev_info *devinfo)
         devinfo->data_out_pipe = usb_sndbulkpipe(udev,
                                             usb_endpoint_num(&eps[3]->desc));
 
-        if (udev->speed != USB_SPEED_SUPER) {
+        if (udev->speed < USB_SPEED_SUPER) {
                 devinfo->qdepth = 32;
                 devinfo->use_streams = 0;
         } else {
                 devinfo->qdepth = usb_alloc_streams(devinfo->intf, eps + 1,
-                                                    3, 256, GFP_NOIO);
+                                                    3, MAX_CMNDS, GFP_NOIO);
                 if (devinfo->qdepth < 0)
                         return devinfo->qdepth;
                 devinfo->use_streams = 1;
@@ -1078,15 +928,14 @@ static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
         devinfo->intf = intf;
         devinfo->udev = udev;
         devinfo->resetting = 0;
-        devinfo->running_task = 0;
         devinfo->shutdown = 0;
+        devinfo->flags = id->driver_info;
+        usb_stor_adjust_quirks(udev, &devinfo->flags);
         init_usb_anchor(&devinfo->cmd_urbs);
         init_usb_anchor(&devinfo->sense_urbs);
         init_usb_anchor(&devinfo->data_urbs);
         spin_lock_init(&devinfo->lock);
         INIT_WORK(&devinfo->work, uas_do_work);
-        INIT_LIST_HEAD(&devinfo->inflight_list);
-        INIT_LIST_HEAD(&devinfo->dead_list);
 
         result = uas_configure_endpoints(devinfo);
         if (result)
@@ -1114,6 +963,54 @@ set_alt0:
         return result;
 }
 
+static int uas_cmnd_list_empty(struct uas_dev_info *devinfo)
+{
+        unsigned long flags;
+        int i, r = 1;
+
+        spin_lock_irqsave(&devinfo->lock, flags);
+
+        for (i = 0; i < devinfo->qdepth; i++) {
+                if (devinfo->cmnd[i]) {
+                        r = 0; /* Not empty */
+                        break;
+                }
+        }
+
+        spin_unlock_irqrestore(&devinfo->lock, flags);
+
+        return r;
+}
+
+/*
+ * Wait for any pending cmnds to complete, on usb-2 sense_urbs may temporarily
+ * get empty while there still is more work to do due to sense-urbs completing
+ * with a READ/WRITE_READY iu code, so keep waiting until the list gets empty.
+ */
+static int uas_wait_for_pending_cmnds(struct uas_dev_info *devinfo)
+{
+        unsigned long start_time;
+        int r;
+
+        start_time = jiffies;
+        do {
+                flush_work(&devinfo->work);
+
+                r = usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000);
+                if (r == 0)
+                        return -ETIME;
+
+                r = usb_wait_anchor_empty_timeout(&devinfo->data_urbs, 500);
+                if (r == 0)
+                        return -ETIME;
+
+                if (time_after(jiffies, start_time + 5 * HZ))
+                        return -ETIME;
+        } while (!uas_cmnd_list_empty(devinfo));
+
+        return 0;
+}
+
 static int uas_pre_reset(struct usb_interface *intf)
 {
         struct Scsi_Host *shost = usb_get_intfdata(intf);
@@ -1128,10 +1025,9 @@ static int uas_pre_reset(struct usb_interface *intf)
         scsi_block_requests(shost);
         spin_unlock_irqrestore(shost->host_lock, flags);
 
-        /* Wait for any pending requests to complete */
-        flush_work(&devinfo->work);
-        if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) {
+        if (uas_wait_for_pending_cmnds(devinfo) != 0) {
                 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
+                scsi_unblock_requests(shost);
                 return 1;
         }
 
@@ -1145,13 +1041,16 @@ static int uas_post_reset(struct usb_interface *intf)
         struct Scsi_Host *shost = usb_get_intfdata(intf);
         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
         unsigned long flags;
+        int err;
 
         if (devinfo->shutdown)
                 return 0;
 
-        if (uas_configure_endpoints(devinfo) != 0) {
+        err = uas_configure_endpoints(devinfo);
+        if (err) {
                 shost_printk(KERN_ERR, shost,
-                             "%s: alloc streams error after reset", __func__);
+                             "%s: alloc streams error %d after reset",
+                             __func__, err);
                 return 1;
         }
 
@@ -1169,9 +1068,7 @@ static int uas_suspend(struct usb_interface *intf, pm_message_t message)
         struct Scsi_Host *shost = usb_get_intfdata(intf);
         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
 
-        /* Wait for any pending requests to complete */
-        flush_work(&devinfo->work);
-        if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 5000) == 0) {
+        if (uas_wait_for_pending_cmnds(devinfo) != 0) {
                 shost_printk(KERN_ERR, shost, "%s: timed out\n", __func__);
                 return -ETIME;
         }
@@ -1189,10 +1086,13 @@ static int uas_reset_resume(struct usb_interface *intf)
         struct Scsi_Host *shost = usb_get_intfdata(intf);
         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
         unsigned long flags;
+        int err;
 
-        if (uas_configure_endpoints(devinfo) != 0) {
+        err = uas_configure_endpoints(devinfo);
+        if (err) {
                 shost_printk(KERN_ERR, shost,
-                             "%s: alloc streams error after reset", __func__);
+                             "%s: alloc streams error %d after reset",
+                             __func__, err);
                 return -EIO;
         }
 
@@ -1207,14 +1107,18 @@ static void uas_disconnect(struct usb_interface *intf)
 {
         struct Scsi_Host *shost = usb_get_intfdata(intf);
         struct uas_dev_info *devinfo = (struct uas_dev_info *)shost->hostdata;
+        unsigned long flags;
 
+        spin_lock_irqsave(&devinfo->lock, flags);
         devinfo->resetting = 1;
+        spin_unlock_irqrestore(&devinfo->lock, flags);
+
         cancel_work_sync(&devinfo->work);
-        uas_abort_inflight(devinfo, DID_NO_CONNECT, __func__);
         usb_kill_anchored_urbs(&devinfo->cmd_urbs);
         usb_kill_anchored_urbs(&devinfo->sense_urbs);
         usb_kill_anchored_urbs(&devinfo->data_urbs);
-        uas_zap_dead(devinfo);
+        uas_zap_pending(devinfo, DID_NO_CONNECT);
+
         scsi_remove_host(shost);
         uas_free_streams(devinfo);
         scsi_host_put(shost);
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 4a5c68a47e46..11c7a9676441 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -492,18 +492,24 @@ UNUSUAL_DEV(  0x04e6, 0x000a, 0x0200, 0x0200,
                 "eUSB CompactFlash Adapter",
                 USB_SC_8020, USB_PR_CB, NULL, 0),
 
-UNUSUAL_DEV(  0x04e6, 0x000B, 0x0100, 0x0100,
+UNUSUAL_DEV(  0x04e6, 0x000b, 0x0100, 0x0100,
                 "Shuttle",
                 "eUSCSI Bridge",
                 USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ), 
 
-UNUSUAL_DEV(  0x04e6, 0x000C, 0x0100, 0x0100,
+UNUSUAL_DEV(  0x04e6, 0x000c, 0x0100, 0x0100,
                 "Shuttle",
                 "eUSCSI Bridge",
                 USB_SC_SCSI, USB_PR_BULK, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ),
 
+UNUSUAL_DEV(  0x04e6, 0x000f, 0x0000, 0x9999,
+                "SCM Microsystems",
+                "eUSB SCSI Adapter (Bus Powered)",
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
+                US_FL_SCM_MULT_TARG ),
+
 UNUSUAL_DEV(  0x04e6, 0x0101, 0x0200, 0x0200,
                 "Shuttle",
                 "CD-RW Device",
@@ -1099,6 +1105,13 @@ UNUSUAL_DEV( 0x0840, 0x0085, 0x0001, 0x0001,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY),
 
+/* Supplied with some Castlewood ORB removable drives */
+UNUSUAL_DEV(  0x084b, 0xa001, 0x0000, 0x9999,
+                "Castlewood Systems",
+                "USB to SCSI cable",
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
+                US_FL_SCM_MULT_TARG ),
+
 /* Entry and supporting patch by Theodore Kilgore <kilgota@auburn.edu>.
  * Flag will support Bulk devices which use a standards-violating 32-byte
  * Command Block Wrapper. Here, the "DC2MEGA" cameras (several brands) with
@@ -2063,6 +2076,13 @@ UNUSUAL_DEV( 0x1e74, 0x4621, 0x0000, 0x0000,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_BULK_IGNORE_TAG | US_FL_MAX_SECTORS_64 ),
 
+/* Supplied with some Castlewood ORB removable drives */
+UNUSUAL_DEV(  0x2027, 0xa001, 0x0000, 0x9999,
+                "Double-H Technology",
+                "USB to SCSI Intelligent Cable",
+                USB_SC_DEVICE, USB_PR_DEVICE, usb_stor_euscsi_init,
+                US_FL_SCM_MULT_TARG ),
+
 UNUSUAL_DEV( 0x2116, 0x0320, 0x0001, 0x0001,
                 "ST",
                 "2A",
diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h
index 7244444df8ee..8511b54a65d9 100644
--- a/drivers/usb/storage/unusual_uas.h
+++ b/drivers/usb/storage/unusual_uas.h
@@ -40,13 +40,38 @@
  * and don't forget to CC: the USB development list <linux-usb@vger.kernel.org>
  */
 
-/*
- * This is an example entry for the US_FL_IGNORE_UAS flag. Once we have an
- * actual entry using US_FL_IGNORE_UAS this entry should be removed.
- *
- * UNUSUAL_DEV(  0xabcd, 0x1234, 0x0100, 0x0100,
- *              "Example",
- *              "Storage with broken UAS",
- *              USB_SC_DEVICE, USB_PR_DEVICE, NULL,
- *              US_FL_IGNORE_UAS),
- */
+/* https://bugzilla.kernel.org/show_bug.cgi?id=79511 */
+UNUSUAL_DEV(0x0bc2, 0x2312, 0x0000, 0x9999,
+                "Seagate",
+                "Expansion Desk",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_ATA_1X),
+
+/* https://bbs.archlinux.org/viewtopic.php?id=183190 */
+UNUSUAL_DEV(0x0bc2, 0x3312, 0x0000, 0x9999,
+                "Seagate",
+                "Expansion Desk",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_ATA_1X),
+
+/* https://bbs.archlinux.org/viewtopic.php?id=183190 */
+UNUSUAL_DEV(0x0bc2, 0xab20, 0x0000, 0x9999,
+                "Seagate",
+                "Backup+ BK",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_ATA_1X),
+
+/* Reported-by: Claudio Bizzarri <claudio.bizzarri@gmail.com> */
+UNUSUAL_DEV(0x152d, 0x0567, 0x0000, 0x9999,
+                "JMicron",
+                "JMS567",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_REPORT_OPCODES),
+
+/* Most ASM1051 based devices have issues with uas, blacklist them all */
+/* Reported-by: Hans de Goede <hdegoede@redhat.com> */
+UNUSUAL_DEV(0x174c, 0x5106, 0x0000, 0x9999,
+                "ASMedia",
+                "ASM1051",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_IGNORE_UAS),
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index cedb29252a92..9d66ce62542e 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -98,7 +98,7 @@ MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
 /* The vendor name should be kept at eight characters or less, and
  * the product name should be kept at 16 characters or less. If a device
  * has the US_FL_FIX_INQUIRY flag, then the vendor and product names
- * normally generated by a device thorugh the INQUIRY response will be
+ * normally generated by a device through the INQUIRY response will be
  * taken from this list, and this is the reason for the above size
  * restriction. However, if the flag is not present, then you
  * are free to use as many characters as you like.
@@ -478,7 +478,8 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
                         US_FL_CAPACITY_OK | US_FL_IGNORE_RESIDUE |
                         US_FL_SINGLE_LUN | US_FL_NO_WP_DETECT |
                         US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
-                        US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE);
+                        US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE |
+                        US_FL_NO_ATA_1X | US_FL_NO_REPORT_OPCODES);
 
         p = quirks;
         while (*p) {
@@ -516,6 +517,9 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
                 case 'e':
                         f |= US_FL_NO_READ_CAPACITY_16;
                         break;
+                case 'f':
+                        f |= US_FL_NO_REPORT_OPCODES;
+                        break;
                 case 'h':
                         f |= US_FL_CAPACITY_HEURISTICS;
                         break;
@@ -543,6 +547,9 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
                 case 's':
                         f |= US_FL_SINGLE_LUN;
                         break;
+                case 't':
+                        f |= US_FL_NO_ATA_1X;
+                        break;
                 case 'u':
                         f |= US_FL_IGNORE_UAS;
                         break;
@@ -983,6 +990,14 @@ int usb_stor_probe2(struct us_data *us)
         if (!(us->fflags & US_FL_SCM_MULT_TARG))
                 us_to_host(us)->max_id = 1;
 
+        /*
+         * Like Windows, we won't store the LUN bits in CDB[1] for SCSI-2
+         * devices using the Bulk-Only transport (even though this violates
+         * the SCSI spec).
+         */
+        if (us->transport == usb_stor_Bulk_transport)
+                us_to_host(us)->no_scsi2_lun_in_cdb = 1;
+
         /* Find the endpoints and calculate pipe values */
         result = get_pipes(us);
         if (result)
diff --git a/drivers/usb/wusbcore/Kconfig b/drivers/usb/wusbcore/Kconfig
index 0e17b966e1b4..348de1d6726e 100644
--- a/drivers/usb/wusbcore/Kconfig
+++ b/drivers/usb/wusbcore/Kconfig
@@ -3,7 +3,6 @@
 #
 config USB_WUSB
         tristate "Enable Wireless USB extensions"
-        depends on PCI
         depends on UWB
         select CRYPTO
         select CRYPTO_BLKCIPHER
@@ -18,6 +17,7 @@ config USB_WUSB
 
 config USB_WUSB_CBAF
         tristate "Support WUSB Cable Based Association (CBA)"
+        depends on USB
         help
           Some WUSB devices support Cable Based Association. It's used to
           enable the secure communication between the host and the
diff --git a/drivers/usb/wusbcore/crypto.c b/drivers/usb/wusbcore/crypto.c
index 9a95b2dc6d1b..50ce80d604f3 100644
--- a/drivers/usb/wusbcore/crypto.c
+++ b/drivers/usb/wusbcore/crypto.c
@@ -222,8 +222,6 @@ static int wusb_ccm_mac(struct crypto_blkcipher *tfm_cbc,
         WARN_ON(sizeof(ax) != sizeof(struct aes_ccm_block));
 
         result = -ENOMEM;
-        zero_padding = sizeof(struct aes_ccm_block)
-                - blen % sizeof(struct aes_ccm_block);
         zero_padding = blen % sizeof(struct aes_ccm_block);
         if (zero_padding)
                 zero_padding = sizeof(struct aes_ccm_block) - zero_padding;
diff --git a/drivers/usb/wusbcore/devconnect.c b/drivers/usb/wusbcore/devconnect.c
index 0677139c6065..3f4f5fbded55 100644
--- a/drivers/usb/wusbcore/devconnect.c
+++ b/drivers/usb/wusbcore/devconnect.c
@@ -329,7 +329,7 @@ void wusbhc_devconnect_ack(struct wusbhc *wusbhc, struct wusb_dn_connect *dnc,
         port->wusb_dev = wusb_dev;
         port->status |= USB_PORT_STAT_CONNECTION;
         port->change |= USB_PORT_STAT_C_CONNECTION;
-        /* Now the port status changed to connected; khubd will
+        /* Now the port status changed to connected; hub_wq will
          * pick the change up and try to reset the port to bring it to
          * the enabled state--so this process returns up to the stack
          * and it calls back into wusbhc_rh_port_reset().
@@ -343,7 +343,7 @@ error_unlock:
 /*
  * Disconnect a Wireless USB device from its fake port
  *
- * Marks the port as disconnected so that khubd can pick up the change
+ * Marks the port as disconnected so that hub_wq can pick up the change
  * and drops our knowledge about the device.
  *
  * Assumes there is a device connected
@@ -379,7 +379,7 @@ static void __wusbhc_dev_disconnect(struct wusbhc *wusbhc,
                 wusbhc_gtk_rekey(wusbhc);
 
         /* The Wireless USB part has forgotten about the device already; now
-         * khubd's timer will pick up the disconnection and remove the USB
+         * hub_wq's timer will pick up the disconnection and remove the USB
          * device from the system
          */
 }
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index 95be9953cd47..cc74d669c802 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -33,6 +33,20 @@ static void wusbhc_gtk_rekey_work(struct work_struct *work);
 
 int wusbhc_sec_create(struct wusbhc *wusbhc)
 {
+        /*
+         * WQ is singlethread because we need to serialize rekey operations.
+         * Use a separate workqueue for security operations instead of the
+         * wusbd workqueue because security operations may need to communicate
+         * directly with downstream wireless devices using synchronous URBs.
+         * If a device is not responding, this could block other host
+         * controller operations.
+         */
+        wusbhc->wq_security = create_singlethread_workqueue("wusbd_security");
+        if (wusbhc->wq_security == NULL) {
+                pr_err("WUSB-core: Cannot create wusbd_security workqueue\n");
+                return -ENOMEM;
+        }
+
         wusbhc->gtk.descr.bLength = sizeof(wusbhc->gtk.descr) +
                 sizeof(wusbhc->gtk.data);
         wusbhc->gtk.descr.bDescriptorType = USB_DT_KEY;
@@ -48,6 +62,7 @@ int wusbhc_sec_create(struct wusbhc *wusbhc)
 /* Called when the HC is destroyed */
 void wusbhc_sec_destroy(struct wusbhc *wusbhc)
 {
+        destroy_workqueue(wusbhc->wq_security);
 }
 
 
@@ -596,5 +611,5 @@ void wusbhc_gtk_rekey(struct wusbhc *wusbhc)
          * and will cause a deadlock.  Instead, queue a work item to do
          * it when the lock is not held
          */
-        queue_work(wusbd, &wusbhc->gtk_rekey_work);
+        queue_work(wusbhc->wq_security, &wusbhc->gtk_rekey_work);
 }
diff --git a/drivers/usb/wusbcore/wa-hc.h b/drivers/usb/wusbcore/wa-hc.h
index f2a8d29e17b9..edc7267157f3 100644
--- a/drivers/usb/wusbcore/wa-hc.h
+++ b/drivers/usb/wusbcore/wa-hc.h
@@ -64,7 +64,7 @@
  *
  * Note much of the activity is difficult to follow. For example a
  * device connect goes to devconnect, which will cause the "fake" root
- * hub port to show a connect and stop there. Then khubd will notice
+ * hub port to show a connect and stop there. Then hub_wq will notice
  * and call into the rh.c:hwahc_rc_port_reset() code to authenticate
  * the device (and this might require user intervention) and enable
  * the port.
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index e279015be466..69af4fd9e072 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -459,14 +459,25 @@ static void __wa_xfer_abort_cb(struct urb *urb)
                         __func__, urb->status);
                 if (xfer) {
                         unsigned long flags;
-                        int done;
+                        int done, seg_index = 0;
                         struct wa_rpipe *rpipe = xfer->ep->hcpriv;
 
                         dev_err(dev, "%s: cleaning up xfer %p ID 0x%08X.\n",
                                 __func__, xfer, wa_xfer_id(xfer));
                         spin_lock_irqsave(&xfer->lock, flags);
-                        /* mark all segs as aborted. */
-                        wa_complete_remaining_xfer_segs(xfer, 0,
+                        /* skip done segs. */
+                        while (seg_index < xfer->segs) {
+                                struct wa_seg *seg = xfer->seg[seg_index];
+
+                                if ((seg->status == WA_SEG_DONE) ||
+                                        (seg->status == WA_SEG_ERROR)) {
+                                        ++seg_index;
+                                } else {
+                                        break;
+                                }
+                        }
+                        /* mark remaining segs as aborted. */
+                        wa_complete_remaining_xfer_segs(xfer, seg_index,
                                 WA_SEG_ABORTED);
                         done = __wa_xfer_is_done(xfer);
                         spin_unlock_irqrestore(&xfer->lock, flags);
diff --git a/drivers/usb/wusbcore/wusbhc.h b/drivers/usb/wusbcore/wusbhc.h
index 2384add45371..41838db7f85c 100644
--- a/drivers/usb/wusbcore/wusbhc.h
+++ b/drivers/usb/wusbcore/wusbhc.h
@@ -295,6 +295,9 @@ struct wusbhc {
         } __attribute__((packed)) gtk;
         u8 gtk_index;
         u32 gtk_tkid;
+
+        /* workqueue for WUSB security related tasks. */
+        struct workqueue_struct *wq_security;
         struct work_struct gtk_rekey_work;
 
         struct usb_encryption_descriptor *ccm1_etd;