Merge tag 'usb-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb into next

Pull USB driver updates from Greg KH:
 "Here is the big USB driver pull request for 3.16-rc1.

  Nothing huge here, but lots of little things in the USB core, and in
  lots of drivers.  Hopefully the USB power management will be work
  better now that it has been reworked to do per-port power control
  dynamically.  There's also a raft of gadget driver updates and fixes,
  CONFIG_USB_DEBUG is finally gone now that everything has been
  converted over to the dynamic debug inteface, the last hold-out
  drivers were cleaned up and the config option removed.  There were
  also other minor things all through the drivers/usb/ tree, the
  shortlog shows this pretty well.

  All have been in linux-next, including the very last patch, which came
  from linux-next to fix a build issue on some platforms"

* tag 'usb-3.16-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/usb: (314 commits)
  usb: hub_handle_remote_wakeup() only exists for CONFIG_PM=y
  USB: orinoco_usb: remove CONFIG_USB_DEBUG support
  USB: media: lirc: igorplugusb: remove CONFIG_USB_DEBUG support
  USB: media: streamzap: remove CONFIG_USB_DEBUG
  USB: media: redrat3: remove CONFIG_USB_DEBUG usage
  USB: media: redrat3: remove unneeded tracing macro
  usb: qcserial: add additional Sierra Wireless QMI devices
  usb: host: max3421-hcd: Use module_spi_driver
  usb: host: max3421-hcd: Allow platform-data to specify Vbus polarity
  usb: host: max3421-hcd: fix "spi_rd8" uses dynamic stack allocation warning
  usb: host: max3421-hcd: Fix missing unlock in max3421_urb_enqueue()
  usb: qcserial: add Netgear AirCard 341U
  Documentation: dt-bindings: update xhci-platform DT binding for R-Car H2 and M2
  usb: host: xhci-plat: add xhci_plat_start()
  usb: host: max3421-hcd: Fix potential NULL urb dereference
  Revert "usb: gadget: net2280: Add support for PLX USB338X"
  USB: usbip: remove CONFIG_USB_DEBUG reference
  USB: remove CONFIG_USB_DEBUG from defconfig files
  usb: resume child device when port is powered on
  usb: hub_handle_remote_wakeup() depends on CONFIG_PM_RUNTIME=y
  ...

291 files changed, 14364 insertions, 6800 deletions

diff --git a/Documentation/ABI/testing/configfs-usb-gadget b/Documentation/ABI/testing/configfs-usb-gadget
index 37559a06393b..95a36589a66b 100644
--- a/Documentation/ABI/testing/configfs-usb-gadget
+++ b/Documentation/ABI/testing/configfs-usb-gadget
@@ -62,6 +62,40 @@ KernelVersion:	3.11
 Description:
                 This group contains functions available to this USB gadget.
 
+What:           /config/usb-gadget/gadget/functions/<func>.<inst>/interface.<n>
+Date:           May 2014
+KernelVersion:  3.16
+Description:
+                This group contains "Feature Descriptors" specific for one
+                gadget's USB interface or one interface group described
+                by an IAD.
+
+                The attributes:
+
+                compatible_id           - 8-byte string for "Compatible ID"
+                sub_compatible_id       - 8-byte string for "Sub Compatible ID"
+
+What:           /config/usb-gadget/gadget/functions/<func>.<inst>/interface.<n>/<property>
+Date:           May 2014
+KernelVersion:  3.16
+Description:
+                This group contains "Extended Property Descriptors" specific for one
+                gadget's USB interface or one interface group described
+                by an IAD.
+
+                The attributes:
+
+                type            - value 1..7 for interpreting the data
+                                1: unicode string
+                                2: unicode string with environment variable
+                                3: binary
+                                4: little-endian 32-bit
+                                5: big-endian 32-bit
+                                6: unicode string with a symbolic link
+                                7: multiple unicode strings
+                data            - blob of data to be interpreted depending on
+                                type
+
 What:           /config/usb-gadget/gadget/strings
 Date:           Jun 2013
 KernelVersion:  3.11
@@ -79,3 +113,14 @@ Description:
                 product         - gadget's product description
                 manufacturer    - gadget's manufacturer description
 
+What:           /config/usb-gadget/gadget/os_desc
+Date:           May 2014
+KernelVersion:  3.16
+Description:
+                This group contains "OS String" extension handling attributes.
+
+                use             - flag turning "OS Desctiptors" support on/off
+                b_vendor_code   - one-byte value used for custom per-device and
+                                per-interface requests
+                qw_sign         - an identifier to be reported as "OS String"
+                                proper
diff --git a/Documentation/ABI/testing/sysfs-platform-chipidea-usb-otg b/Documentation/ABI/testing/sysfs-platform-chipidea-usb-otg
new file mode 100644
index 000000000000..151c59578db4
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-platform-chipidea-usb-otg
@@ -0,0 +1,56 @@
+What:           /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_req
+Date:           Feb 2014
+Contact:        Li Jun <b47624@freescale.com>
+Description:
+                Can be set and read.
+                Set a_bus_req(A-device bus request) input to be 1 if
+                the application running on the A-device wants to use the bus,
+                and to be 0 when the application no longer wants to use
+                the bus(or wants to work as peripheral). a_bus_req can also
+                be set to 1 by kernel in response to remote wakeup signaling
+                from the B-device, the A-device should decide to resume the bus.
+
+                Valid values are "1" and "0".
+
+                Reading: returns 1 if the application running on the A-device
+                is using the bus as host role, otherwise 0.
+
+What:           /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_drop
+Date:           Feb 2014
+Contact:        Li Jun <b47624@freescale.com>
+Description:
+                Can be set and read
+                The a_bus_drop(A-device bus drop) input is 1 when the
+                application running on the A-device wants to power down
+                the bus, and is 0 otherwise, When a_bus_drop is 1, then
+                the a_bus_req shall be 0.
+
+                Valid values are "1" and "0".
+
+                Reading: returns 1 if the bus is off(vbus is turned off) by
+                         A-device, otherwise 0.
+
+What:           /sys/bus/platform/devices/ci_hdrc.0/inputs/b_bus_req
+Date:           Feb 2014
+Contact:        Li Jun <b47624@freescale.com>
+Description:
+                Can be set and read.
+                The b_bus_req(B-device bus request) input is 1 during the time
+                that the application running on the B-device wants to use the
+                bus as host, and is 0 when the application no longer wants to
+                work as host and decides to switch back to be peripheral.
+
+                Valid values are "1" and "0".
+
+                Reading: returns if the application running on the B device
+                is using the bus as host role, otherwise 0.
+
+What:           /sys/bus/platform/devices/ci_hdrc.0/inputs/a_clr_err
+Date:           Feb 2014
+Contact:        Li Jun <b47624@freescale.com>
+Description:
+                Only can be set.
+                The a_clr_err(A-device Vbus error clear) input is used to clear
+                vbus error, then A-device will power down the bus.
+
+                Valid value is "1"
diff --git a/Documentation/DocBook/Makefile b/Documentation/DocBook/Makefile
index b444f2e8fe32..bec06659e0eb 100644
--- a/Documentation/DocBook/Makefile
+++ b/Documentation/DocBook/Makefile
@@ -14,7 +14,8 @@ DOCBOOKS := z8530book.xml device-drivers.xml \
             genericirq.xml s390-drivers.xml uio-howto.xml scsi.xml \
             80211.xml debugobjects.xml sh.xml regulator.xml \
             alsa-driver-api.xml writing-an-alsa-driver.xml \
-            tracepoint.xml drm.xml media_api.xml w1.xml
+            tracepoint.xml drm.xml media_api.xml w1.xml \
+            writing_musb_glue_layer.xml
 
 include Documentation/DocBook/media/Makefile
 
diff --git a/Documentation/DocBook/writing_musb_glue_layer.tmpl b/Documentation/DocBook/writing_musb_glue_layer.tmpl
new file mode 100644
index 000000000000..837eca77f274
--- /dev/null
+++ b/Documentation/DocBook/writing_musb_glue_layer.tmpl
@@ -0,0 +1,873 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"
+        "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" []>
+
+<book id="Writing-MUSB-Glue-Layer">
+ <bookinfo>
+  <title>Writing an MUSB Glue Layer</title>
+
+  <authorgroup>
+   <author>
+    <firstname>Apelete</firstname>
+    <surname>Seketeli</surname>
+    <affiliation>
+     <address>
+      <email>apelete at seketeli.net</email>
+     </address>
+    </affiliation>
+   </author>
+  </authorgroup>
+
+  <copyright>
+   <year>2014</year>
+   <holder>Apelete Seketeli</holder>
+  </copyright>
+
+  <legalnotice>
+   <para>
+     This documentation 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.
+   </para>
+
+   <para>
+     This documentation 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.
+   </para>
+
+   <para>
+     You should have received a copy of the GNU General Public License
+     along with this documentation; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+     02111-1307 USA
+   </para>
+
+   <para>
+     For more details see the file COPYING in the Linux kernel source
+     tree.
+   </para>
+  </legalnotice>
+ </bookinfo>
+
+<toc></toc>
+
+  <chapter id="introduction">
+    <title>Introduction</title>
+    <para>
+      The Linux MUSB subsystem is part of the larger Linux USB
+      subsystem. It provides support for embedded USB Device Controllers
+      (UDC) that do not use Universal Host Controller Interface (UHCI)
+      or Open Host Controller Interface (OHCI).
+    </para>
+    <para>
+      Instead, these embedded UDC rely on the USB On-the-Go (OTG)
+      specification which they implement at least partially. The silicon
+      reference design used in most cases is the Multipoint USB
+      Highspeed Dual-Role Controller (MUSB HDRC) found in the Mentor
+      Graphics Inventra™ design.
+    </para>
+    <para>
+      As a self-taught exercise I have written an MUSB glue layer for
+      the Ingenic JZ4740 SoC, modelled after the many MUSB glue layers
+      in the kernel source tree. This layer can be found at
+      drivers/usb/musb/jz4740.c. In this documentation I will walk
+      through the basics of the jz4740.c glue layer, explaining the
+      different pieces and what needs to be done in order to write your
+      own device glue layer.
+    </para>
+  </chapter>
+
+  <chapter id="linux-musb-basics">
+    <title>Linux MUSB Basics</title>
+    <para>
+      To get started on the topic, please read USB On-the-Go Basics (see
+      Resources) which provides an introduction of USB OTG operation at
+      the hardware level. A couple of wiki pages by Texas Instruments
+      and Analog Devices also provide an overview of the Linux kernel
+      MUSB configuration, albeit focused on some specific devices
+      provided by these companies. Finally, getting acquainted with the
+      USB specification at USB home page may come in handy, with
+      practical instance provided through the Writing USB Device Drivers
+      documentation (again, see Resources).
+    </para>
+    <para>
+      Linux USB stack is a layered architecture in which the MUSB
+      controller hardware sits at the lowest. The MUSB controller driver
+      abstract the MUSB controller hardware to the Linux USB stack.
+    </para>
+    <programlisting>
+      ------------------------
+      |                      | &lt;------- drivers/usb/gadget
+      | Linux USB Core Stack | &lt;------- drivers/usb/host
+      |                      | &lt;------- drivers/usb/core
+      ------------------------
+                 ⬍
+     --------------------------
+     |                        | &lt;------ drivers/usb/musb/musb_gadget.c
+     | MUSB Controller driver | &lt;------ drivers/usb/musb/musb_host.c
+     |                        | &lt;------ drivers/usb/musb/musb_core.c
+     --------------------------
+                 ⬍
+  ---------------------------------
+  | MUSB Platform Specific Driver |
+  |                               | &lt;-- drivers/usb/musb/jz4740.c
+  |       aka &quot;Glue Layer&quot;        |
+  ---------------------------------
+                 ⬍
+  ---------------------------------
+  |   MUSB Controller Hardware    |
+  ---------------------------------
+    </programlisting>
+    <para>
+      As outlined above, the glue layer is actually the platform
+      specific code sitting in between the controller driver and the
+      controller hardware.
+    </para>
+    <para>
+      Just like a Linux USB driver needs to register itself with the
+      Linux USB subsystem, the MUSB glue layer needs first to register
+      itself with the MUSB controller driver. This will allow the
+      controller driver to know about which device the glue layer
+      supports and which functions to call when a supported device is
+      detected or released; remember we are talking about an embedded
+      controller chip here, so no insertion or removal at run-time.
+    </para>
+    <para>
+      All of this information is passed to the MUSB controller driver
+      through a platform_driver structure defined in the glue layer as:
+    </para>
+    <programlisting linenumbering="numbered">
+static struct platform_driver jz4740_driver = {
+        .probe          = jz4740_probe,
+        .remove         = jz4740_remove,
+        .driver         = {
+                .name   = "musb-jz4740",
+        },
+};
+    </programlisting>
+    <para>
+      The probe and remove function pointers are called when a matching
+      device is detected and, respectively, released. The name string
+      describes the device supported by this glue layer. In the current
+      case it matches a platform_device structure declared in
+      arch/mips/jz4740/platform.c. Note that we are not using device
+      tree bindings here.
+    </para>
+    <para>
+      In order to register itself to the controller driver, the glue
+      layer goes through a few steps, basically allocating the
+      controller hardware resources and initialising a couple of
+      circuits. To do so, it needs to keep track of the information used
+      throughout these steps. This is done by defining a private
+      jz4740_glue structure:
+    </para>
+    <programlisting linenumbering="numbered">
+struct jz4740_glue {
+        struct device           *dev;
+        struct platform_device  *musb;
+        struct clk              *clk;
+};
+    </programlisting>
+    <para>
+      The dev and musb members are both device structure variables. The
+      first one holds generic information about the device, since it's
+      the basic device structure, and the latter holds information more
+      closely related to the subsystem the device is registered to. The
+      clk variable keeps information related to the device clock
+      operation.
+    </para>
+    <para>
+      Let's go through the steps of the probe function that leads the
+      glue layer to register itself to the controller driver.
+    </para>
+    <para>
+      N.B.: For the sake of readability each function will be split in
+      logical parts, each part being shown as if it was independent from
+      the others.
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_probe(struct platform_device *pdev)
+{
+        struct platform_device          *musb;
+        struct jz4740_glue              *glue;
+        struct clk                      *clk;
+        int                             ret;
+
+        glue = devm_kzalloc(&amp;pdev->dev, sizeof(*glue), GFP_KERNEL);
+        if (!glue)
+                return -ENOMEM;
+
+        musb = platform_device_alloc("musb-hdrc", PLATFORM_DEVID_AUTO);
+        if (!musb) {
+                dev_err(&amp;pdev->dev, "failed to allocate musb device\n");
+                return -ENOMEM;
+        }
+
+        clk = devm_clk_get(&amp;pdev->dev, "udc");
+        if (IS_ERR(clk)) {
+                dev_err(&amp;pdev->dev, "failed to get clock\n");
+                ret = PTR_ERR(clk);
+                goto err_platform_device_put;
+        }
+
+        ret = clk_prepare_enable(clk);
+        if (ret) {
+                dev_err(&amp;pdev->dev, "failed to enable clock\n");
+                goto err_platform_device_put;
+        }
+
+        musb->dev.parent                = &amp;pdev->dev;
+
+        glue->dev                       = &amp;pdev->dev;
+        glue->musb                      = musb;
+        glue->clk                       = clk;
+
+        return 0;
+
+err_platform_device_put:
+        platform_device_put(musb);
+        return ret;
+}
+    </programlisting>
+    <para>
+      The first few lines of the probe function allocate and assign the
+      glue, musb and clk variables. The GFP_KERNEL flag (line 8) allows
+      the allocation process to sleep and wait for memory, thus being
+      usable in a blocking situation. The PLATFORM_DEVID_AUTO flag (line
+      12) allows automatic allocation and management of device IDs in
+      order to avoid device namespace collisions with explicit IDs. With
+      devm_clk_get() (line 18) the glue layer allocates the clock -- the
+      <literal>devm_</literal> prefix indicates that clk_get() is
+      managed: it automatically frees the allocated clock resource data
+      when the device is released -- and enable it.
+    </para>
+    <para>
+      Then comes the registration steps:
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_probe(struct platform_device *pdev)
+{
+        struct musb_hdrc_platform_data  *pdata = &amp;jz4740_musb_platform_data;
+
+        pdata->platform_ops             = &amp;jz4740_musb_ops;
+
+        platform_set_drvdata(pdev, glue);
+
+        ret = platform_device_add_resources(musb, pdev->resource,
+                                            pdev->num_resources);
+        if (ret) {
+                dev_err(&amp;pdev->dev, "failed to add resources\n");
+                goto err_clk_disable;
+        }
+
+        ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
+        if (ret) {
+                dev_err(&amp;pdev->dev, "failed to add platform_data\n");
+                goto err_clk_disable;
+        }
+
+        return 0;
+
+err_clk_disable:
+        clk_disable_unprepare(clk);
+err_platform_device_put:
+        platform_device_put(musb);
+        return ret;
+}
+    </programlisting>
+    <para>
+      The first step is to pass the device data privately held by the
+      glue layer on to the controller driver through
+      platform_set_drvdata() (line 7). Next is passing on the device
+      resources information, also privately held at that point, through
+      platform_device_add_resources() (line 9).
+    </para>
+    <para>
+      Finally comes passing on the platform specific data to the
+      controller driver (line 16). Platform data will be discussed in
+      <link linkend="device-platform-data">Chapter 4</link>, but here
+      we are looking at the platform_ops function pointer (line 5) in
+      musb_hdrc_platform_data structure (line 3).  This function
+      pointer allows the MUSB controller driver to know which function
+      to call for device operation:
+    </para>
+    <programlisting linenumbering="numbered">
+static const struct musb_platform_ops jz4740_musb_ops = {
+        .init           = jz4740_musb_init,
+        .exit           = jz4740_musb_exit,
+};
+    </programlisting>
+    <para>
+      Here we have the minimal case where only init and exit functions
+      are called by the controller driver when needed. Fact is the
+      JZ4740 MUSB controller is a basic controller, lacking some
+      features found in other controllers, otherwise we may also have
+      pointers to a few other functions like a power management function
+      or a function to switch between OTG and non-OTG modes, for
+      instance.
+    </para>
+    <para>
+      At that point of the registration process, the controller driver
+      actually calls the init function:
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_musb_init(struct musb *musb)
+{
+        musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
+        if (!musb->xceiv) {
+                pr_err("HS UDC: no transceiver configured\n");
+                return -ENODEV;
+        }
+
+        /* Silicon does not implement ConfigData register.
+         * Set dyn_fifo to avoid reading EP config from hardware.
+         */
+        musb->dyn_fifo = true;
+
+        musb->isr = jz4740_musb_interrupt;
+
+        return 0;
+}
+    </programlisting>
+    <para>
+      The goal of jz4740_musb_init() is to get hold of the transceiver
+      driver data of the MUSB controller hardware and pass it on to the
+      MUSB controller driver, as usual. The transceiver is the circuitry
+      inside the controller hardware responsible for sending/receiving
+      the USB data. Since it is an implementation of the physical layer
+      of the OSI model, the transceiver is also referred to as PHY.
+    </para>
+    <para>
+      Getting hold of the MUSB PHY driver data is done with
+      usb_get_phy() which returns a pointer to the structure
+      containing the driver instance data. The next couple of
+      instructions (line 12 and 14) are used as a quirk and to setup
+      IRQ handling respectively. Quirks and IRQ handling will be
+      discussed later in <link linkend="device-quirks">Chapter
+      5</link> and <link linkend="handling-irqs">Chapter 3</link>.
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_musb_exit(struct musb *musb)
+{
+        usb_put_phy(musb->xceiv);
+
+        return 0;
+}
+    </programlisting>
+    <para>
+      Acting as the counterpart of init, the exit function releases the
+      MUSB PHY driver when the controller hardware itself is about to be
+      released.
+    </para>
+    <para>
+      Again, note that init and exit are fairly simple in this case due
+      to the basic set of features of the JZ4740 controller hardware.
+      When writing an musb glue layer for a more complex controller
+      hardware, you might need to take care of more processing in those
+      two functions.
+    </para>
+    <para>
+      Returning from the init function, the MUSB controller driver jumps
+      back into the probe function:
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_probe(struct platform_device *pdev)
+{
+        ret = platform_device_add(musb);
+        if (ret) {
+                dev_err(&amp;pdev->dev, "failed to register musb device\n");
+                goto err_clk_disable;
+        }
+
+        return 0;
+
+err_clk_disable:
+        clk_disable_unprepare(clk);
+err_platform_device_put:
+        platform_device_put(musb);
+        return ret;
+}
+    </programlisting>
+    <para>
+      This is the last part of the device registration process where the
+      glue layer adds the controller hardware device to Linux kernel
+      device hierarchy: at this stage, all known information about the
+      device is passed on to the Linux USB core stack.
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_remove(struct platform_device *pdev)
+{
+        struct jz4740_glue      *glue = platform_get_drvdata(pdev);
+
+        platform_device_unregister(glue->musb);
+        clk_disable_unprepare(glue->clk);
+
+        return 0;
+}
+    </programlisting>
+    <para>
+      Acting as the counterpart of probe, the remove function unregister
+      the MUSB controller hardware (line 5) and disable the clock (line
+      6), allowing it to be gated.
+    </para>
+  </chapter>
+
+  <chapter id="handling-irqs">
+    <title>Handling IRQs</title>
+    <para>
+      Additionally to the MUSB controller hardware basic setup and
+      registration, the glue layer is also responsible for handling the
+      IRQs:
+    </para>
+    <programlisting linenumbering="numbered">
+static irqreturn_t jz4740_musb_interrupt(int irq, void *__hci)
+{
+        unsigned long   flags;
+        irqreturn_t     retval = IRQ_NONE;
+        struct musb     *musb = __hci;
+
+        spin_lock_irqsave(&amp;musb->lock, flags);
+
+        musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
+        musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
+        musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
+
+        /*
+         * The controller is gadget only, the state of the host mode IRQ bits is
+         * undefined. Mask them to make sure that the musb driver core will
+         * never see them set
+         */
+        musb->int_usb &amp;= MUSB_INTR_SUSPEND | MUSB_INTR_RESUME |
+            MUSB_INTR_RESET | MUSB_INTR_SOF;
+
+        if (musb->int_usb || musb->int_tx || musb->int_rx)
+                retval = musb_interrupt(musb);
+
+        spin_unlock_irqrestore(&amp;musb->lock, flags);
+
+        return retval;
+}
+    </programlisting>
+    <para>
+      Here the glue layer mostly has to read the relevant hardware
+      registers and pass their values on to the controller driver which
+      will handle the actual event that triggered the IRQ.
+    </para>
+    <para>
+      The interrupt handler critical section is protected by the
+      spin_lock_irqsave() and counterpart spin_unlock_irqrestore()
+      functions (line 7 and 24 respectively), which prevent the
+      interrupt handler code to be run by two different threads at the
+      same time.
+    </para>
+    <para>
+      Then the relevant interrupt registers are read (line 9 to 11):
+    </para>
+    <itemizedlist>
+      <listitem>
+        <para>
+          MUSB_INTRUSB: indicates which USB interrupts are currently
+          active,
+        </para>
+      </listitem>
+      <listitem>
+        <para>
+          MUSB_INTRTX: indicates which of the interrupts for TX
+          endpoints are currently active,
+        </para>
+      </listitem>
+      <listitem>
+        <para>
+          MUSB_INTRRX: indicates which of the interrupts for TX
+          endpoints are currently active.
+        </para>
+      </listitem>
+    </itemizedlist>
+    <para>
+      Note that musb_readb() is used to read 8-bit registers at most,
+      while musb_readw() allows us to read at most 16-bit registers.
+      There are other functions that can be used depending on the size
+      of your device registers. See musb_io.h for more information.
+    </para>
+    <para>
+      Instruction on line 18 is another quirk specific to the JZ4740
+      USB device controller, which will be discussed later in <link
+      linkend="device-quirks">Chapter 5</link>.
+    </para>
+    <para>
+      The glue layer still needs to register the IRQ handler though.
+      Remember the instruction on line 14 of the init function:
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_musb_init(struct musb *musb)
+{
+        musb->isr = jz4740_musb_interrupt;
+
+        return 0;
+}
+    </programlisting>
+    <para>
+      This instruction sets a pointer to the glue layer IRQ handler
+      function, in order for the controller hardware to call the handler
+      back when an IRQ comes from the controller hardware. The interrupt
+      handler is now implemented and registered.
+    </para>
+  </chapter>
+
+  <chapter id="device-platform-data">
+    <title>Device Platform Data</title>
+    <para>
+      In order to write an MUSB glue layer, you need to have some data
+      describing the hardware capabilities of your controller hardware,
+      which is called the platform data.
+    </para>
+    <para>
+      Platform data is specific to your hardware, though it may cover a
+      broad range of devices, and is generally found somewhere in the
+      arch/ directory, depending on your device architecture.
+    </para>
+    <para>
+      For instance, platform data for the JZ4740 SoC is found in
+      arch/mips/jz4740/platform.c. In the platform.c file each device of
+      the JZ4740 SoC is described through a set of structures.
+    </para>
+    <para>
+      Here is the part of arch/mips/jz4740/platform.c that covers the
+      USB Device Controller (UDC):
+    </para>
+    <programlisting linenumbering="numbered">
+/* USB Device Controller */
+struct platform_device jz4740_udc_xceiv_device = {
+        .name = "usb_phy_gen_xceiv",
+        .id   = 0,
+};
+
+static struct resource jz4740_udc_resources[] = {
+        [0] = {
+                .start = JZ4740_UDC_BASE_ADDR,
+                .end   = JZ4740_UDC_BASE_ADDR + 0x10000 - 1,
+                .flags = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start = JZ4740_IRQ_UDC,
+                .end   = JZ4740_IRQ_UDC,
+                .flags = IORESOURCE_IRQ,
+                .name  = "mc",
+        },
+};
+
+struct platform_device jz4740_udc_device = {
+        .name = "musb-jz4740",
+        .id   = -1,
+        .dev  = {
+                .dma_mask          = &amp;jz4740_udc_device.dev.coherent_dma_mask,
+                .coherent_dma_mask = DMA_BIT_MASK(32),
+        },
+        .num_resources = ARRAY_SIZE(jz4740_udc_resources),
+        .resource      = jz4740_udc_resources,
+};
+    </programlisting>
+    <para>
+      The jz4740_udc_xceiv_device platform device structure (line 2)
+      describes the UDC transceiver with a name and id number.
+    </para>
+    <para>
+      At the time of this writing, note that
+      &quot;usb_phy_gen_xceiv&quot; is the specific name to be used for
+      all transceivers that are either built-in with reference USB IP or
+      autonomous and doesn't require any PHY programming. You will need
+      to set CONFIG_NOP_USB_XCEIV=y in the kernel configuration to make
+      use of the corresponding transceiver driver. The id field could be
+      set to -1 (equivalent to PLATFORM_DEVID_NONE), -2 (equivalent to
+      PLATFORM_DEVID_AUTO) or start with 0 for the first device of this
+      kind if we want a specific id number.
+    </para>
+    <para>
+      The jz4740_udc_resources resource structure (line 7) defines the
+      UDC registers base addresses.
+    </para>
+    <para>
+      The first array (line 9 to 11) defines the UDC registers base
+      memory addresses: start points to the first register memory
+      address, end points to the last register memory address and the
+      flags member defines the type of resource we are dealing with. So
+      IORESOURCE_MEM is used to define the registers memory addresses.
+      The second array (line 14 to 17) defines the UDC IRQ registers
+      addresses. Since there is only one IRQ register available for the
+      JZ4740 UDC, start and end point at the same address. The
+      IORESOURCE_IRQ flag tells that we are dealing with IRQ resources,
+      and the name &quot;mc&quot; is in fact hard-coded in the MUSB core
+      in order for the controller driver to retrieve this IRQ resource
+      by querying it by its name.
+    </para>
+    <para>
+      Finally, the jz4740_udc_device platform device structure (line 21)
+      describes the UDC itself.
+    </para>
+    <para>
+      The &quot;musb-jz4740&quot; name (line 22) defines the MUSB
+      driver that is used for this device; remember this is in fact
+      the name that we used in the jz4740_driver platform driver
+      structure in <link linkend="linux-musb-basics">Chapter
+      2</link>. The id field (line 23) is set to -1 (equivalent to
+      PLATFORM_DEVID_NONE) since we do not need an id for the device:
+      the MUSB controller driver was already set to allocate an
+      automatic id in <link linkend="linux-musb-basics">Chapter
+      2</link>. In the dev field we care for DMA related information
+      here. The dma_mask field (line 25) defines the width of the DMA
+      mask that is going to be used, and coherent_dma_mask (line 26)
+      has the same purpose but for the alloc_coherent DMA mappings: in
+      both cases we are using a 32 bits mask. Then the resource field
+      (line 29) is simply a pointer to the resource structure defined
+      before, while the num_resources field (line 28) keeps track of
+      the number of arrays defined in the resource structure (in this
+      case there were two resource arrays defined before).
+    </para>
+    <para>
+      With this quick overview of the UDC platform data at the arch/
+      level now done, let's get back to the MUSB glue layer specific
+      platform data in drivers/usb/musb/jz4740.c:
+    </para>
+    <programlisting linenumbering="numbered">
+static struct musb_hdrc_config jz4740_musb_config = {
+        /* Silicon does not implement USB OTG. */
+        .multipoint = 0,
+        /* Max EPs scanned, driver will decide which EP can be used. */
+        .num_eps    = 4,
+        /* RAMbits needed to configure EPs from table */
+        .ram_bits   = 9,
+        .fifo_cfg = jz4740_musb_fifo_cfg,
+        .fifo_cfg_size = ARRAY_SIZE(jz4740_musb_fifo_cfg),
+};
+
+static struct musb_hdrc_platform_data jz4740_musb_platform_data = {
+        .mode   = MUSB_PERIPHERAL,
+        .config = &amp;jz4740_musb_config,
+};
+    </programlisting>
+    <para>
+      First the glue layer configures some aspects of the controller
+      driver operation related to the controller hardware specifics.
+      This is done through the jz4740_musb_config musb_hdrc_config
+      structure.
+    </para>
+    <para>
+      Defining the OTG capability of the controller hardware, the
+      multipoint member (line 3) is set to 0 (equivalent to false)
+      since the JZ4740 UDC is not OTG compatible. Then num_eps (line
+      5) defines the number of USB endpoints of the controller
+      hardware, including endpoint 0: here we have 3 endpoints +
+      endpoint 0. Next is ram_bits (line 7) which is the width of the
+      RAM address bus for the MUSB controller hardware. This
+      information is needed when the controller driver cannot
+      automatically configure endpoints by reading the relevant
+      controller hardware registers. This issue will be discussed when
+      we get to device quirks in <link linkend="device-quirks">Chapter
+      5</link>. Last two fields (line 8 and 9) are also about device
+      quirks: fifo_cfg points to the USB endpoints configuration table
+      and fifo_cfg_size keeps track of the size of the number of
+      entries in that configuration table. More on that later in <link
+      linkend="device-quirks">Chapter 5</link>.
+    </para>
+    <para>
+      Then this configuration is embedded inside
+      jz4740_musb_platform_data musb_hdrc_platform_data structure (line
+      11): config is a pointer to the configuration structure itself,
+      and mode tells the controller driver if the controller hardware
+      may be used as MUSB_HOST only, MUSB_PERIPHERAL only or MUSB_OTG
+      which is a dual mode.
+    </para>
+    <para>
+      Remember that jz4740_musb_platform_data is then used to convey
+      platform data information as we have seen in the probe function
+      in <link linkend="linux-musb-basics">Chapter 2</link>
+    </para>
+  </chapter>
+
+  <chapter id="device-quirks">
+    <title>Device Quirks</title>
+    <para>
+      Completing the platform data specific to your device, you may also
+      need to write some code in the glue layer to work around some
+      device specific limitations. These quirks may be due to some
+      hardware bugs, or simply be the result of an incomplete
+      implementation of the USB On-the-Go specification.
+    </para>
+    <para>
+      The JZ4740 UDC exhibits such quirks, some of which we will discuss
+      here for the sake of insight even though these might not be found
+      in the controller hardware you are working on.
+    </para>
+    <para>
+      Let's get back to the init function first:
+    </para>
+    <programlisting linenumbering="numbered">
+static int jz4740_musb_init(struct musb *musb)
+{
+        musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
+        if (!musb->xceiv) {
+                pr_err("HS UDC: no transceiver configured\n");
+                return -ENODEV;
+        }
+
+        /* Silicon does not implement ConfigData register.
+         * Set dyn_fifo to avoid reading EP config from hardware.
+         */
+        musb->dyn_fifo = true;
+
+        musb->isr = jz4740_musb_interrupt;
+
+        return 0;
+}
+    </programlisting>
+    <para>
+      Instruction on line 12 helps the MUSB controller driver to work
+      around the fact that the controller hardware is missing registers
+      that are used for USB endpoints configuration.
+    </para>
+    <para>
+      Without these registers, the controller driver is unable to read
+      the endpoints configuration from the hardware, so we use line 12
+      instruction to bypass reading the configuration from silicon, and
+      rely on a hard-coded table that describes the endpoints
+      configuration instead:
+    </para>
+    <programlisting linenumbering="numbered">
+static struct musb_fifo_cfg jz4740_musb_fifo_cfg[] = {
+{ .hw_ep_num = 1, .style = FIFO_TX, .maxpacket = 512, },
+{ .hw_ep_num = 1, .style = FIFO_RX, .maxpacket = 512, },
+{ .hw_ep_num = 2, .style = FIFO_TX, .maxpacket = 64, },
+};
+    </programlisting>
+    <para>
+      Looking at the configuration table above, we see that each
+      endpoints is described by three fields: hw_ep_num is the endpoint
+      number, style is its direction (either FIFO_TX for the controller
+      driver to send packets in the controller hardware, or FIFO_RX to
+      receive packets from hardware), and maxpacket defines the maximum
+      size of each data packet that can be transmitted over that
+      endpoint. Reading from the table, the controller driver knows that
+      endpoint 1 can be used to send and receive USB data packets of 512
+      bytes at once (this is in fact a bulk in/out endpoint), and
+      endpoint 2 can be used to send data packets of 64 bytes at once
+      (this is in fact an interrupt endpoint).
+    </para>
+    <para>
+      Note that there is no information about endpoint 0 here: that one
+      is implemented by default in every silicon design, with a
+      predefined configuration according to the USB specification. For
+      more examples of endpoint configuration tables, see musb_core.c.
+    </para>
+    <para>
+      Let's now get back to the interrupt handler function:
+    </para>
+    <programlisting linenumbering="numbered">
+static irqreturn_t jz4740_musb_interrupt(int irq, void *__hci)
+{
+        unsigned long   flags;
+        irqreturn_t     retval = IRQ_NONE;
+        struct musb     *musb = __hci;
+
+        spin_lock_irqsave(&amp;musb->lock, flags);
+
+        musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
+        musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
+        musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
+
+        /*
+         * The controller is gadget only, the state of the host mode IRQ bits is
+         * undefined. Mask them to make sure that the musb driver core will
+         * never see them set
+         */
+        musb->int_usb &amp;= MUSB_INTR_SUSPEND | MUSB_INTR_RESUME |
+            MUSB_INTR_RESET | MUSB_INTR_SOF;
+
+        if (musb->int_usb || musb->int_tx || musb->int_rx)
+                retval = musb_interrupt(musb);
+
+        spin_unlock_irqrestore(&amp;musb->lock, flags);
+
+        return retval;
+}
+    </programlisting>
+    <para>
+      Instruction on line 18 above is a way for the controller driver to
+      work around the fact that some interrupt bits used for USB host
+      mode operation are missing in the MUSB_INTRUSB register, thus left
+      in an undefined hardware state, since this MUSB controller
+      hardware is used in peripheral mode only. As a consequence, the
+      glue layer masks these missing bits out to avoid parasite
+      interrupts by doing a logical AND operation between the value read
+      from MUSB_INTRUSB and the bits that are actually implemented in
+      the register.
+    </para>
+    <para>
+      These are only a couple of the quirks found in the JZ4740 USB
+      device controller. Some others were directly addressed in the MUSB
+      core since the fixes were generic enough to provide a better
+      handling of the issues for others controller hardware eventually.
+    </para>
+  </chapter>
+
+  <chapter id="conclusion">
+    <title>Conclusion</title>
+    <para>
+      Writing a Linux MUSB glue layer should be a more accessible task,
+      as this documentation tries to show the ins and outs of this
+      exercise.
+    </para>
+    <para>
+      The JZ4740 USB device controller being fairly simple, I hope its
+      glue layer serves as a good example for the curious mind. Used
+      with the current MUSB glue layers, this documentation should
+      provide enough guidance to get started; should anything gets out
+      of hand, the linux-usb mailing list archive is another helpful
+      resource to browse through.
+    </para>
+  </chapter>
+
+  <chapter id="acknowledgements">
+    <title>Acknowledgements</title>
+    <para>
+      Many thanks to Lars-Peter Clausen and Maarten ter Huurne for
+      answering my questions while I was writing the JZ4740 glue layer
+      and for helping me out getting the code in good shape.
+    </para>
+    <para>
+      I would also like to thank the Qi-Hardware community at large for
+      its cheerful guidance and support.
+    </para>
+  </chapter>
+
+  <chapter id="resources">
+    <title>Resources</title>
+    <para>
+      USB Home Page:
+      <ulink url="http://www.usb.org">http://www.usb.org</ulink>
+    </para>
+    <para>
+      linux-usb Mailing List Archives:
+      <ulink url="http://marc.info/?l=linux-usb">http://marc.info/?l=linux-usb</ulink>
+    </para>
+    <para>
+      USB On-the-Go Basics:
+      <ulink url="http://www.maximintegrated.com/app-notes/index.mvp/id/1822">http://www.maximintegrated.com/app-notes/index.mvp/id/1822</ulink>
+    </para>
+    <para>
+      Writing USB Device Drivers:
+      <ulink url="https://www.kernel.org/doc/htmldocs/writing_usb_driver/index.html">https://www.kernel.org/doc/htmldocs/writing_usb_driver/index.html</ulink>
+    </para>
+    <para>
+      Texas Instruments USB Configuration Wiki Page:
+      <ulink url="http://processors.wiki.ti.com/index.php/Usbgeneralpage">http://processors.wiki.ti.com/index.php/Usbgeneralpage</ulink>
+    </para>
+    <para>
+      Analog Devices Blackfin MUSB Configuration:
+      <ulink url="http://docs.blackfin.uclinux.org/doku.php?id=linux-kernel:drivers:musb">http://docs.blackfin.uclinux.org/doku.php?id=linux-kernel:drivers:musb</ulink>
+    </para>
+  </chapter>
+
+</book>
diff --git a/Documentation/devicetree/bindings/phy/samsung-phy.txt b/Documentation/devicetree/bindings/phy/samsung-phy.txt
index b422e38946d7..2049261d8c31 100644
--- a/Documentation/devicetree/bindings/phy/samsung-phy.txt
+++ b/Documentation/devicetree/bindings/phy/samsung-phy.txt
@@ -114,3 +114,50 @@ Example:
                 compatible = "samsung,exynos-sataphy-i2c";
                 reg = <0x38>;
         };
+
+Samsung Exynos5 SoC series USB DRD PHY controller
+--------------------------------------------------
+
+Required properties:
+- compatible : Should be set to one of the following supported values:
+        - "samsung,exynos5250-usbdrd-phy" - for exynos5250 SoC,
+        - "samsung,exynos5420-usbdrd-phy" - for exynos5420 SoC.
+- reg : Register offset and length of USB DRD PHY register set;
+- clocks: Clock IDs array as required by the controller
+- clock-names: names of clocks correseponding to IDs in the clock property;
+               Required clocks:
+        - phy: main PHY clock (same as USB DRD controller i.e. DWC3 IP clock),
+               used for register access.
+        - ref: PHY's reference clock (usually crystal clock), used for
+               PHY operations, associated by phy name. It is used to
+               determine bit values for clock settings register.
+               For Exynos5420 this is given as 'sclk_usbphy30' in CMU.
+- samsung,pmu-syscon: phandle for PMU system controller interface, used to
+                      control pmu registers for power isolation.
+- #phy-cells : from the generic PHY bindings, must be 1;
+
+For "samsung,exynos5250-usbdrd-phy" and "samsung,exynos5420-usbdrd-phy"
+compatible PHYs, the second cell in the PHY specifier identifies the
+PHY id, which is interpreted as follows:
+  0 - UTMI+ type phy,
+  1 - PIPE3 type phy,
+
+Example:
+        usbdrd_phy: usbphy@12100000 {
+                compatible = "samsung,exynos5250-usbdrd-phy";
+                reg = <0x12100000 0x100>;
+                clocks = <&clock 286>, <&clock 1>;
+                clock-names = "phy", "ref";
+                samsung,pmu-syscon = <&pmu_system_controller>;
+                #phy-cells = <1>;
+        };
+
+- aliases: For SoCs like Exynos5420 having multiple USB 3.0 DRD PHY controllers,
+           'usbdrd_phy' nodes should have numbered alias in the aliases node,
+           in the form of usbdrdphyN, N = 0, 1... (depending on number of
+           controllers).
+Example:
+        aliases {
+                usbdrdphy0 = &usb3_phy0;
+                usbdrdphy1 = &usb3_phy1;
+        };
diff --git a/Documentation/devicetree/bindings/phy/sun4i-usb-phy.txt b/Documentation/devicetree/bindings/phy/sun4i-usb-phy.txt
index a82361b62015..16528b9eb561 100644
--- a/Documentation/devicetree/bindings/phy/sun4i-usb-phy.txt
+++ b/Documentation/devicetree/bindings/phy/sun4i-usb-phy.txt
@@ -2,15 +2,26 @@ Allwinner sun4i USB PHY
 -----------------------
 
 Required properties:
-- compatible : should be one of "allwinner,sun4i-a10-usb-phy",
-  "allwinner,sun5i-a13-usb-phy" or "allwinner,sun7i-a20-usb-phy"
+- compatible : should be one of
+  * allwinner,sun4i-a10-usb-phy
+  * allwinner,sun5i-a13-usb-phy
+  * allwinner,sun6i-a31-usb-phy
+  * allwinner,sun7i-a20-usb-phy
 - reg : a list of offset + length pairs
-- reg-names : "phy_ctrl", "pmu1" and for sun4i or sun7i "pmu2"
+- reg-names :
+  * "phy_ctrl"
+  * "pmu1"
+  * "pmu2" for sun4i, sun6i or sun7i
 - #phy-cells : from the generic phy bindings, must be 1
-- clocks : phandle + clock specifier for the phy clock
-- clock-names : "usb_phy"
+- clocks : phandle + clock specifier for the phy clocks
+- clock-names :
+  * "usb_phy" for sun4i, sun5i or sun7i
+  * "usb0_phy", "usb1_phy" and "usb2_phy" for sun6i
 - resets : a list of phandle + reset specifier pairs
-- reset-names : "usb0_reset", "usb1_reset" and for sun4i or sun7i "usb2_reset"
+- reset-names :
+  * "usb0_reset"
+  * "usb1_reset"
+  * "usb2_reset" for sun4i, sun6i or sun7i
 
 Example:
         usbphy: phy@0x01c13400 {
diff --git a/Documentation/devicetree/bindings/phy/ti-phy.txt b/Documentation/devicetree/bindings/phy/ti-phy.txt
index 788fb0fa3762..9ce458f32945 100644
--- a/Documentation/devicetree/bindings/phy/ti-phy.txt
+++ b/Documentation/devicetree/bindings/phy/ti-phy.txt
@@ -32,6 +32,11 @@ Required properties:
  - reg : Address and length of the register set for the device.
  - #phy-cells: determine the number of cells that should be given in the
    phandle while referencing this phy.
+ - clocks: a list of phandles and clock-specifier pairs, one for each entry in
+   clock-names.
+ - clock-names: should include:
+   * "wkupclk" - wakeup clock.
+   * "refclk" - reference clock (optional).
 
 Optional properties:
  - ctrl-module : phandle of the control module used by PHY driver to power on
@@ -44,6 +49,8 @@ usb2phy@4a0ad080 {
         reg = <0x4a0ad080 0x58>;
         ctrl-module = <&omap_control_usb>;
         #phy-cells = <0>;
+        clocks = <&usb_phy_cm_clk32k>, <&usb_otg_ss_refclk960m>;
+        clock-names = "wkupclk", "refclk";
 };
 
 TI PIPE3 PHY
diff --git a/Documentation/devicetree/bindings/usb/ci-hdrc-qcom.txt b/Documentation/devicetree/bindings/usb/ci-hdrc-qcom.txt
new file mode 100644
index 000000000000..f2899b550939
--- /dev/null
+++ b/Documentation/devicetree/bindings/usb/ci-hdrc-qcom.txt
@@ -0,0 +1,17 @@
+Qualcomm CI13xxx (Chipidea) USB controllers
+
+Required properties:
+- compatible:   should contain "qcom,ci-hdrc"
+- reg:          offset and length of the register set in the memory map
+- interrupts:   interrupt-specifier for the controller interrupt.
+- usb-phy:      phandle for the PHY device
+- dr_mode:      Should be "peripheral"
+
+Examples:
+        gadget@f9a55000 {
+                compatible = "qcom,ci-hdrc";
+                reg = <0xf9a55000 0x400>;
+                dr_mode = "peripheral";
+                interrupts = <0 134 0>;
+                usb-phy = <&usbphy0>;
+        };
diff --git a/Documentation/devicetree/bindings/usb/ehci-orion.txt b/Documentation/devicetree/bindings/usb/ehci-orion.txt
index 6bc09ec14c4d..17c3bc858b86 100644
--- a/Documentation/devicetree/bindings/usb/ehci-orion.txt
+++ b/Documentation/devicetree/bindings/usb/ehci-orion.txt
@@ -6,6 +6,11 @@ Required properties:
   region.
 - interrupts: The EHCI interrupt
 
+Optional properties:
+- clocks: reference to the clock
+- phys: reference to the USB PHY
+- phy-names: name of the USB PHY, should be "usb"
+
 Example:
 
         ehci@50000 {
diff --git a/Documentation/devicetree/bindings/usb/exynos-usb.txt b/Documentation/devicetree/bindings/usb/exynos-usb.txt
index d967ba16de60..a3b5990d0f2c 100644
--- a/Documentation/devicetree/bindings/usb/exynos-usb.txt
+++ b/Documentation/devicetree/bindings/usb/exynos-usb.txt
@@ -12,6 +12,13 @@ Required properties:
  - interrupts: interrupt number to the cpu.
  - clocks: from common clock binding: handle to usb clock.
  - clock-names: from common clock binding: Shall be "usbhost".
+ - port: if in the SoC there are EHCI phys, they should be listed here.
+   One phy per port. Each port should have following entries:
+        - reg: port number on EHCI controller, e.g
+               On Exynos5250, port 0 is USB2.0 otg phy
+                              port 1 is HSIC phy0
+                              port 2 is HSIC phy1
+        - phys: from the *Generic PHY* bindings; specifying phy used by port.
 
 Optional properties:
  - samsung,vbus-gpio:  if present, specifies the GPIO that
@@ -27,6 +34,14 @@ Example:
 
                 clocks = <&clock 285>;
                 clock-names = "usbhost";
+
+                #address-cells = <1>;
+                #size-cells = <0>;
+                port@0 {
+                    reg = <0>;
+                    phys = <&usb2phy 1>;
+                    status = "disabled";
+                };
         };
 
 OHCI
@@ -38,6 +53,13 @@ Required properties:
  - interrupts: interrupt number to the cpu.
  - clocks: from common clock binding: handle to usb clock.
  - clock-names: from common clock binding: Shall be "usbhost".
+ - port: if in the SoC there are OHCI phys, they should be listed here.
+   One phy per port. Each port should have following entries:
+        - reg: port number on OHCI controller, e.g
+               On Exynos5250, port 0 is USB2.0 otg phy
+                              port 1 is HSIC phy0
+                              port 2 is HSIC phy1
+        - phys: from the *Generic PHY* bindings, specifying phy used by port.
 
 Example:
         usb@12120000 {
@@ -47,6 +69,15 @@ Example:
 
                 clocks = <&clock 285>;
                 clock-names = "usbhost";
+
+                #address-cells = <1>;
+                #size-cells = <0>;
+                port@0 {
+                    reg = <0>;
+                    phys = <&usb2phy 1>;
+                    status = "disabled";
+                };
+
         };
 
 DWC3
diff --git a/Documentation/devicetree/bindings/usb/gr-udc.txt b/Documentation/devicetree/bindings/usb/gr-udc.txt
index 0c5118f7a916..e9445224fabd 100644
--- a/Documentation/devicetree/bindings/usb/gr-udc.txt
+++ b/Documentation/devicetree/bindings/usb/gr-udc.txt
@@ -12,17 +12,23 @@ Required properties:
 
 - reg : Address and length of the register set for the device
 
-- interrupts : Interrupt numbers for this device
+- interrupts : Interrupt numbers for this device. Either one interrupt number
+        for all interrupts, or one for status related interrupts, one for IN
+        endpoint related interrupts and one for OUT endpoint related interrupts.
 
 Optional properties:
 
-- epobufsizes : An array of buffer sizes for OUT endpoints. If the property is
-        not present, or for endpoints outside of the array, 1024 is assumed by
-        the driver.
-
-- epibufsizes : An array of buffer sizes for IN endpoints. If the property is
-        not present, or for endpoints outside of the array, 1024 is assumed by
-        the driver.
+- epobufsizes : Array of buffer sizes for OUT endpoints when they differ
+        from the default size of 1024. The array is indexed by the OUT endpoint
+        number. If the property is present it typically contains one entry for
+        each OUT endpoint of the core. Fewer entries overrides the default sizes
+        only for as many endpoints as the array contains.
+
+- epibufsizes : Array of buffer sizes for IN endpoints when they differ
+        from the default size of 1024. The array is indexed by the IN endpoint
+        number. If the property is present it typically contains one entry for
+        each IN endpoint of the core. Fewer entries overrides the default sizes
+        only for as many endpoints as the array contains.
 
 For further information look in the documentation for the GLIB IP core library:
 http://www.gaisler.com/products/grlib/grip.pdf
diff --git a/Documentation/devicetree/bindings/usb/msm-hsusb.txt b/Documentation/devicetree/bindings/usb/msm-hsusb.txt
index 5ea26c631e3a..2826f2af503a 100644
--- a/Documentation/devicetree/bindings/usb/msm-hsusb.txt
+++ b/Documentation/devicetree/bindings/usb/msm-hsusb.txt
@@ -15,3 +15,81 @@ Example EHCI controller device node:
                 usb-phy = <&usb_otg>;
         };
 
+USB PHY with optional OTG:
+
+Required properties:
+- compatible:   Should contain:
+  "qcom,usb-otg-ci" for chipsets with ChipIdea 45nm PHY
+  "qcom,usb-otg-snps" for chipsets with Synopsys 28nm PHY
+
+- regs:         Offset and length of the register set in the memory map
+- interrupts:   interrupt-specifier for the OTG interrupt.
+
+- clocks:       A list of phandle + clock-specifier pairs for the
+                clocks listed in clock-names
+- clock-names:  Should contain the following:
+  "phy"         USB PHY reference clock
+  "core"        Protocol engine clock
+  "iface"       Interface bus clock
+  "alt_core"    Protocol engine clock for targets with asynchronous
+                reset methodology. (optional)
+
+- vdccx-supply: phandle to the regulator for the vdd supply for
+                digital circuit operation.
+- v1p8-supply:  phandle to the regulator for the 1.8V supply
+- v3p3-supply:  phandle to the regulator for the 3.3V supply
+
+- resets:       A list of phandle + reset-specifier pairs for the
+                resets listed in reset-names
+- reset-names:  Should contain the following:
+  "phy"         USB PHY controller reset
+  "link"        USB LINK controller reset
+
+- qcom,otg-control: OTG control (VBUS and ID notifications) can be one of
+                1 - PHY control
+                2 - PMIC control
+
+Optional properties:
+- dr_mode:      One of "host", "peripheral" or "otg". Defaults to "otg"
+
+- qcom,phy-init-sequence: PHY configuration sequence values. This is related to Device
+                Mode Eye Diagram test. Start address at which these values will be
+                written is ULPI_EXT_VENDOR_SPECIFIC. Value of -1 is reserved as
+                "do not overwrite default value at this address".
+                For example: qcom,phy-init-sequence = < -1 0x63 >;
+                Will update only value at address ULPI_EXT_VENDOR_SPECIFIC + 1.
+
+- qcom,phy-num: Select number of pyco-phy to use, can be one of
+                0 - PHY one, default
+                1 - Second PHY
+                Some platforms may have configuration to allow USB
+                controller work with any of the two HSPHYs present.
+
+- qcom,vdd-levels: This property must be a list of three integer values
+                (no, min, max) where each value represents either a voltage
+                in microvolts or a value corresponding to voltage corner.
+
+Example HSUSB OTG controller device node:
+
+    usb@f9a55000 {
+        compatible = "qcom,usb-otg-snps";
+        reg = <0xf9a55000 0x400>;
+        interrupts = <0 134 0>;
+        dr_mode = "peripheral";
+
+        clocks = <&gcc GCC_XO_CLK>, <&gcc GCC_USB_HS_SYSTEM_CLK>,
+                <&gcc GCC_USB_HS_AHB_CLK>;
+
+        clock-names = "phy", "core", "iface";
+
+        vddcx-supply = <&pm8841_s2_corner>;
+        v1p8-supply = <&pm8941_l6>;
+        v3p3-supply = <&pm8941_l24>;
+
+        resets = <&gcc GCC_USB2A_PHY_BCR>, <&gcc GCC_USB_HS_BCR>;
+        reset-names = "phy", "link";
+
+        qcom,otg-control = <1>;
+        qcom,phy-init-sequence = < -1 0x63 >;
+        qcom,vdd-levels = <1 5 7>;
+        };
diff --git a/Documentation/devicetree/bindings/usb/usb-ehci.txt b/Documentation/devicetree/bindings/usb/usb-ehci.txt
index ff151ec084c4..43c1a4e06767 100644
--- a/Documentation/devicetree/bindings/usb/usb-ehci.txt
+++ b/Documentation/devicetree/bindings/usb/usb-ehci.txt
@@ -15,6 +15,7 @@ Optional properties:
  - clocks : a list of phandle + clock specifier pairs
  - phys : phandle + phy specifier pair
  - phy-names : "usb"
+ - resets : phandle + reset specifier pair
 
 Example (Sequoia 440EPx):
     ehci@e0000300 {
diff --git a/Documentation/devicetree/bindings/usb/usb-ohci.txt b/Documentation/devicetree/bindings/usb/usb-ohci.txt
index 45f67d91e888..b968a1aea995 100644
--- a/Documentation/devicetree/bindings/usb/usb-ohci.txt
+++ b/Documentation/devicetree/bindings/usb/usb-ohci.txt
@@ -12,6 +12,7 @@ Optional properties:
 - clocks : a list of phandle + clock specifier pairs
 - phys : phandle + phy specifier pair
 - phy-names : "usb"
+- resets : phandle + reset specifier pair
 
 Example:
 
diff --git a/Documentation/devicetree/bindings/usb/usb-xhci.txt b/Documentation/devicetree/bindings/usb/usb-xhci.txt
index 90f8f607d125..5a79377c6a96 100644
--- a/Documentation/devicetree/bindings/usb/usb-xhci.txt
+++ b/Documentation/devicetree/bindings/usb/usb-xhci.txt
@@ -1,11 +1,17 @@
 USB xHCI controllers
 
 Required properties:
-  - compatible: should be "generic-xhci" (deprecated: "xhci-platform").
+  - compatible: should be one of "generic-xhci",
+    "marvell,armada-375-xhci", "marvell,armada-380-xhci",
+    "renesas,xhci-r8a7790", "renesas,xhci-r8a7791" (deprecated:
+    "xhci-platform").
   - reg: should contain address and length of the standard XHCI
     register set for the device.
   - interrupts: one XHCI interrupt should be described here.
 
+Optional property:
+  - clocks: reference to a clock
+
 Example:
         usb@f0931000 {
                 compatible = "generic-xhci";
diff --git a/Documentation/devicetree/bindings/usb/usb3503.txt b/Documentation/devicetree/bindings/usb/usb3503.txt
index a018da4a7ad7..221ac0dbc678 100644
--- a/Documentation/devicetree/bindings/usb/usb3503.txt
+++ b/Documentation/devicetree/bindings/usb/usb3503.txt
@@ -15,6 +15,14 @@ Optional properties:
 - reset-gpios: Should specify GPIO for reset.
 - initial-mode: Should specify initial mode.
                 (1 for HUB mode, 2 for STANDBY mode)
+- refclk: Clock used for driving REFCLK signal (optional, if not provided
+        the driver assumes that clock signal is always available, its
+        rate is specified by REF_SEL pins and a value from the primary
+        reference clock frequencies table is used)
+- refclk-frequency: Frequency of the REFCLK signal as defined by REF_SEL
+        pins (optional, if not provided, driver will not set rate of the
+        REFCLK signal and assume that a value from the primary reference
+        clock frequencies table is used)
 
 Examples:
         usb3503@08 {
diff --git a/Documentation/usb/chipidea.txt b/Documentation/usb/chipidea.txt
new file mode 100644
index 000000000000..995c8bca40e2
--- /dev/null
+++ b/Documentation/usb/chipidea.txt
@@ -0,0 +1,71 @@
+1. How to test OTG FSM(HNP and SRP)
+-----------------------------------
+To show how to demo OTG HNP and SRP functions via sys input files
+with 2 Freescale i.MX6Q sabre SD boards.
+
+1.1 How to enable OTG FSM in menuconfig
+---------------------------------------
+Select CONFIG_USB_OTG_FSM, rebuild kernel Image and modules.
+If you want to check some internal variables for otg fsm,
+select CONFIG_USB_CHIPIDEA_DEBUG, there are 2 files which
+can show otg fsm variables and some controller registers value:
+cat /sys/kernel/debug/ci_hdrc.0/otg
+cat /sys/kernel/debug/ci_hdrc.0/registers
+
+1.2 Test operations
+-------------------
+1) Power up 2 Freescale i.MX6Q sabre SD boards with gadget class driver loaded
+   (e.g. g_mass_storage).
+
+2) Connect 2 boards with usb cable with one end is micro A plug, the other end
+   is micro B plug.
+
+   The A-device(with micro A plug inserted) should enumrate B-device.
+
+3) Role switch
+   On B-device:
+   echo 1 > /sys/bus/platform/devices/ci_hdrc.0/inputs/b_bus_req
+
+   if HNP polling is not supported, also need:
+   On A-device:
+   echo 0 > /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_req
+
+   B-device should take host role and enumrate A-device.
+
+4) A-device switch back to host.
+   On B-device:
+   echo 0 > /sys/bus/platform/devices/ci_hdrc.0/inputs/b_bus_req
+
+   A-device should switch back to host and enumrate B-device.
+
+5) Remove B-device(unplug micro B plug) and insert again in 10 seconds,
+   A-device should enumrate B-device again.
+
+6) Remove B-device(unplug micro B plug) and insert again after 10 seconds,
+   A-device should NOT enumrate B-device.
+
+   if A-device wants to use bus:
+   On A-device:
+   echo 0 > /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_drop
+   echo 1 > /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_req
+
+   if B-device wants to use bus:
+   On B-device:
+   echo 1 > /sys/bus/platform/devices/ci_hdrc.0/inputs/b_bus_req
+
+7) A-device power down the bus.
+   On A-device:
+   echo 1 > /sys/bus/platform/devices/ci_hdrc.0/inputs/a_bus_drop
+
+   A-device should disconnect with B-device and power down the bus.
+
+8) B-device does data pulse for SRP.
+   On B-device:
+   echo 1 > /sys/bus/platform/devices/ci_hdrc.0/inputs/b_bus_req
+
+   A-device should resume usb bus and enumrate B-device.
+
+1.3 Reference document
+----------------------
+"On-The-Go and Embedded Host Supplement to the USB Revision 2.0 Specification
+July 27, 2012 Revision 2.0 version 1.1a"
diff --git a/arch/arm/configs/badge4_defconfig b/arch/arm/configs/badge4_defconfig
index 5b54abbeb0b3..0494c8f229a2 100644
--- a/arch/arm/configs/badge4_defconfig
+++ b/arch/arm/configs/badge4_defconfig
@@ -73,8 +73,6 @@ CONFIG_SA1100_WATCHDOG=m
 CONFIG_SOUND=y
 CONFIG_SOUND_PRIME=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_ACM=m
 CONFIG_USB_PRINTER=m
diff --git a/arch/arm/configs/cm_x2xx_defconfig b/arch/arm/configs/cm_x2xx_defconfig
index a93ff8da5bab..dc01c049a520 100644
--- a/arch/arm/configs/cm_x2xx_defconfig
+++ b/arch/arm/configs/cm_x2xx_defconfig
@@ -144,7 +144,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/cm_x300_defconfig b/arch/arm/configs/cm_x300_defconfig
index f4b767256f95..7df040e91c1c 100644
--- a/arch/arm/configs/cm_x300_defconfig
+++ b/arch/arm/configs/cm_x300_defconfig
@@ -129,7 +129,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_THRUSTMASTER=y
 CONFIG_HID_ZEROPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/colibri_pxa270_defconfig b/arch/arm/configs/colibri_pxa270_defconfig
index 2ef2c5e8aaec..18c311ae1113 100644
--- a/arch/arm/configs/colibri_pxa270_defconfig
+++ b/arch/arm/configs/colibri_pxa270_defconfig
@@ -124,7 +124,6 @@ CONFIG_FONT_8x16=y
 CONFIG_LOGO=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_SERIAL=m
 CONFIG_USB_GADGET=m
diff --git a/arch/arm/configs/colibri_pxa300_defconfig b/arch/arm/configs/colibri_pxa300_defconfig
index b985334e42dd..be02fe2b14cb 100644
--- a/arch/arm/configs/colibri_pxa300_defconfig
+++ b/arch/arm/configs/colibri_pxa300_defconfig
@@ -47,9 +47,7 @@ CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_LOGO=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_STORAGE=y
 CONFIG_MMC=y
diff --git a/arch/arm/configs/corgi_defconfig b/arch/arm/configs/corgi_defconfig
index 1fd1d1de3220..c1470a00f55a 100644
--- a/arch/arm/configs/corgi_defconfig
+++ b/arch/arm/configs/corgi_defconfig
@@ -172,7 +172,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_SL811_HCD=m
 CONFIG_USB_SL811_CS=m
diff --git a/arch/arm/configs/davinci_all_defconfig b/arch/arm/configs/davinci_all_defconfig
index 2f8ff65e3ef1..f95f72d62db7 100644
--- a/arch/arm/configs/davinci_all_defconfig
+++ b/arch/arm/configs/davinci_all_defconfig
@@ -157,7 +157,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_MUSB_HDRC=m
 CONFIG_USB_GADGET_MUSB_HDRC=y
diff --git a/arch/arm/configs/em_x270_defconfig b/arch/arm/configs/em_x270_defconfig
index 60a21e01eb70..4560c9ca6636 100644
--- a/arch/arm/configs/em_x270_defconfig
+++ b/arch/arm/configs/em_x270_defconfig
@@ -144,7 +144,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/ep93xx_defconfig b/arch/arm/configs/ep93xx_defconfig
index 6ac5ea73bd0a..1b650c85bdd0 100644
--- a/arch/arm/configs/ep93xx_defconfig
+++ b/arch/arm/configs/ep93xx_defconfig
@@ -80,7 +80,6 @@ CONFIG_I2C_DEBUG_BUS=y
 CONFIG_WATCHDOG=y
 CONFIG_EP93XX_WATCHDOG=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_DYNAMIC_MINORS=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_HCD_PLATFORM=y
diff --git a/arch/arm/configs/footbridge_defconfig b/arch/arm/configs/footbridge_defconfig
index 038518ab39a8..87e020f303ab 100644
--- a/arch/arm/configs/footbridge_defconfig
+++ b/arch/arm/configs/footbridge_defconfig
@@ -100,8 +100,6 @@ CONFIG_FB_CYBER2000=y
 CONFIG_SOUND=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=m
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_PRINTER=m
 CONFIG_EXT2_FS=y
diff --git a/arch/arm/configs/ixp4xx_defconfig b/arch/arm/configs/ixp4xx_defconfig
index 063e2ab2c8f1..1af665e847d1 100644
--- a/arch/arm/configs/ixp4xx_defconfig
+++ b/arch/arm/configs/ixp4xx_defconfig
@@ -169,7 +169,6 @@ CONFIG_SENSORS_W83781D=y
 CONFIG_WATCHDOG=y
 CONFIG_IXP4XX_WATCHDOG=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/keystone_defconfig b/arch/arm/configs/keystone_defconfig
index ec9a41d50680..095bb52671f6 100644
--- a/arch/arm/configs/keystone_defconfig
+++ b/arch/arm/configs/keystone_defconfig
@@ -135,7 +135,6 @@ CONFIG_WATCHDOG=y
 CONFIG_WATCHDOG_CORE=y
 CONFIG_DAVINCI_WATCHDOG=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_MON=y
 CONFIG_USB_XHCI_HCD=y
diff --git a/arch/arm/configs/kzm9g_defconfig b/arch/arm/configs/kzm9g_defconfig
index 12bd1f63c399..bd097d455f87 100644
--- a/arch/arm/configs/kzm9g_defconfig
+++ b/arch/arm/configs/kzm9g_defconfig
@@ -106,7 +106,6 @@ CONFIG_SND_SOC=y
 CONFIG_SND_SOC_SH4_FSI=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_R8A66597_HCD=y
 CONFIG_USB_RENESAS_USBHS=y
 CONFIG_USB_STORAGE=y
diff --git a/arch/arm/configs/mini2440_defconfig b/arch/arm/configs/mini2440_defconfig
index a07948a87caa..9c93f5655248 100644
--- a/arch/arm/configs/mini2440_defconfig
+++ b/arch/arm/configs/mini2440_defconfig
@@ -217,7 +217,6 @@ CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_HID_TOPSEED=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_ACM=m
diff --git a/arch/arm/configs/mv78xx0_defconfig b/arch/arm/configs/mv78xx0_defconfig
index 1f08219c1b3c..0dae1c1f007a 100644
--- a/arch/arm/configs/mv78xx0_defconfig
+++ b/arch/arm/configs/mv78xx0_defconfig
@@ -80,7 +80,6 @@ CONFIG_I2C=y
 CONFIG_I2C_CHARDEV=y
 CONFIG_I2C_MV64XXX=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_ROOT_HUB_TT=y
 CONFIG_USB_EHCI_TT_NEWSCHED=y
diff --git a/arch/arm/configs/neponset_defconfig b/arch/arm/configs/neponset_defconfig
index d7dc9922cfff..460dca4a4f98 100644
--- a/arch/arm/configs/neponset_defconfig
+++ b/arch/arm/configs/neponset_defconfig
@@ -68,8 +68,6 @@ CONFIG_SOUND=y
 CONFIG_SOUND_PRIME=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=m
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_OHCI_HCD=m
 CONFIG_USB_STORAGE=m
diff --git a/arch/arm/configs/omap1_defconfig b/arch/arm/configs/omap1_defconfig
index d74edbad18fc..ce541bb3c2de 100644
--- a/arch/arm/configs/omap1_defconfig
+++ b/arch/arm/configs/omap1_defconfig
@@ -197,8 +197,6 @@ CONFIG_SND_OMAP_SOC=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
 CONFIG_USB_PHY=y
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/omap2plus_defconfig b/arch/arm/configs/omap2plus_defconfig
index 28f3b6e3b589..59066cf0271a 100644
--- a/arch/arm/configs/omap2plus_defconfig
+++ b/arch/arm/configs/omap2plus_defconfig
@@ -224,7 +224,6 @@ CONFIG_SND_OMAP_SOC_OMAP_TWL4030=m
 CONFIG_SND_OMAP_SOC_OMAP_ABE_TWL6040=m
 CONFIG_SND_OMAP_SOC_OMAP3_PANDORA=m
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_MON=y
 CONFIG_USB_WDM=y
diff --git a/arch/arm/configs/pcm027_defconfig b/arch/arm/configs/pcm027_defconfig
index 2f136c30a989..0a847d04ddc1 100644
--- a/arch/arm/configs/pcm027_defconfig
+++ b/arch/arm/configs/pcm027_defconfig
@@ -76,7 +76,6 @@ CONFIG_SND_PCM_OSS=y
 CONFIG_SND_PXA2XX_AC97=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_STORAGE=y
 CONFIG_MMC=y
diff --git a/arch/arm/configs/raumfeld_defconfig b/arch/arm/configs/raumfeld_defconfig
index f7caa909b40d..3d833aea545a 100644
--- a/arch/arm/configs/raumfeld_defconfig
+++ b/arch/arm/configs/raumfeld_defconfig
@@ -122,7 +122,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_THRUSTMASTER=y
 CONFIG_HID_ZEROPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/s3c2410_defconfig b/arch/arm/configs/s3c2410_defconfig
index 193448f31284..eb4d204bff47 100644
--- a/arch/arm/configs/s3c2410_defconfig
+++ b/arch/arm/configs/s3c2410_defconfig
@@ -324,7 +324,6 @@ CONFIG_SND_USB_CAIAQ=m
 CONFIG_SND_SOC=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_ACM=m
diff --git a/arch/arm/configs/s3c6400_defconfig b/arch/arm/configs/s3c6400_defconfig
index 3a186d653dac..e2f9fa5bb54b 100644
--- a/arch/arm/configs/s3c6400_defconfig
+++ b/arch/arm/configs/s3c6400_defconfig
@@ -56,7 +56,6 @@ CONFIG_SND_S3C24XX_SOC=m
 CONFIG_SND_SOC_SMDK_WM9713=m
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_ACM=m
 CONFIG_USB_PRINTER=m
diff --git a/arch/arm/configs/spitz_defconfig b/arch/arm/configs/spitz_defconfig
index 2e0419d1b964..a1ede1966baf 100644
--- a/arch/arm/configs/spitz_defconfig
+++ b/arch/arm/configs/spitz_defconfig
@@ -166,7 +166,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_OHCI_HCD=m
 CONFIG_USB_SL811_HCD=m
diff --git a/arch/arm/configs/tct_hammer_defconfig b/arch/arm/configs/tct_hammer_defconfig
index 71277a1591ba..7209a2caefcf 100644
--- a/arch/arm/configs/tct_hammer_defconfig
+++ b/arch/arm/configs/tct_hammer_defconfig
@@ -47,7 +47,6 @@ CONFIG_BLK_DEV_RAM_SIZE=10240
 # CONFIG_VGA_CONSOLE is not set
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/arm/configs/trizeps4_defconfig b/arch/arm/configs/trizeps4_defconfig
index 3162173fa75a..932ee4e4a13a 100644
--- a/arch/arm/configs/trizeps4_defconfig
+++ b/arch/arm/configs/trizeps4_defconfig
@@ -165,7 +165,6 @@ CONFIG_SND_PXA2XX_AC97=y
 CONFIG_SND_USB_AUDIO=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_STORAGE=m
diff --git a/arch/arm/configs/viper_defconfig b/arch/arm/configs/viper_defconfig
index d36e0d3c86ec..0d717a5eff29 100644
--- a/arch/arm/configs/viper_defconfig
+++ b/arch/arm/configs/viper_defconfig
@@ -127,7 +127,6 @@ CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
 CONFIG_SND_PXA2XX_AC97=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_ISP116X_HCD=m
 CONFIG_USB_SL811_HCD=m
 CONFIG_USB_R8A66597_HCD=m
diff --git a/arch/arm/configs/zeus_defconfig b/arch/arm/configs/zeus_defconfig
index 731d4f985310..cd11da8b5123 100644
--- a/arch/arm/configs/zeus_defconfig
+++ b/arch/arm/configs/zeus_defconfig
@@ -132,7 +132,6 @@ CONFIG_SND_SOC=m
 CONFIG_SND_PXA2XX_SOC=m
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OHCI_HCD=m
 CONFIG_USB_ACM=m
 CONFIG_USB_STORAGE=m
diff --git a/arch/arm/mach-msm/board-msm7x30.c b/arch/arm/mach-msm/board-msm7x30.c
index 46de789ad3ae..0c4c200e1221 100644
--- a/arch/arm/mach-msm/board-msm7x30.c
+++ b/arch/arm/mach-msm/board-msm7x30.c
@@ -95,7 +95,7 @@ static int hsusb_phy_clk_reset(struct clk *phy_clk)
 
 static struct msm_otg_platform_data msm_otg_pdata = {
         .phy_init_seq           = hsusb_phy_init_seq,
-        .mode                   = USB_PERIPHERAL,
+        .mode                   = USB_DR_MODE_PERIPHERAL,
         .otg_control            = OTG_PHY_CONTROL,
         .link_clk_reset         = hsusb_link_clk_reset,
         .phy_clk_reset          = hsusb_phy_clk_reset,
diff --git a/arch/arm/mach-msm/board-qsd8x50.c b/arch/arm/mach-msm/board-qsd8x50.c
index 9169ec324a43..4c748616ef47 100644
--- a/arch/arm/mach-msm/board-qsd8x50.c
+++ b/arch/arm/mach-msm/board-qsd8x50.c
@@ -116,7 +116,7 @@ static int hsusb_phy_clk_reset(struct clk *phy_clk)
 
 static struct msm_otg_platform_data msm_otg_pdata = {
         .phy_init_seq           = hsusb_phy_init_seq,
-        .mode                   = USB_PERIPHERAL,
+        .mode                   = USB_DR_MODE_PERIPHERAL,
         .otg_control            = OTG_PHY_CONTROL,
         .link_clk_reset         = hsusb_link_clk_reset,
         .phy_clk_reset          = hsusb_phy_clk_reset,
diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index d6ed819ff15c..660bfc5a70d7 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -33,7 +33,6 @@
 #include <linux/mtd/nand.h>
 #include <linux/mmc/host.h>
 #include <linux/usb/phy.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
 
 #include <linux/regulator/machine.h>
 #include <linux/i2c/twl.h>
diff --git a/arch/arm/mach-omap2/usb-host.c b/arch/arm/mach-omap2/usb-host.c
index 10855eb4ccc1..745367c0c2bb 100644
--- a/arch/arm/mach-omap2/usb-host.c
+++ b/arch/arm/mach-omap2/usb-host.c
@@ -28,7 +28,7 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 #include <linux/usb/phy.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include "soc.h"
 #include "omap_device.h"
@@ -349,7 +349,7 @@ static struct fixed_voltage_config hsusb_reg_config = {
         /* .init_data filled later */
 };
 
-static const char *nop_name = "usb_phy_gen_xceiv"; /* NOP PHY driver */
+static const char *nop_name = "usb_phy_generic"; /* NOP PHY driver */
 static const char *reg_name = "reg-fixed-voltage"; /* Regulator driver */
 
 /**
@@ -435,7 +435,7 @@ int usbhs_init_phys(struct usbhs_phy_data *phy, int num_phys)
         struct platform_device *pdev;
         char *phy_id;
         struct platform_device_info pdevinfo;
-        struct usb_phy_gen_xceiv_platform_data nop_pdata;
+        struct usb_phy_generic_platform_data nop_pdata;
 
         for (i = 0; i < num_phys; i++) {
 
@@ -469,8 +469,8 @@ int usbhs_init_phys(struct usbhs_phy_data *phy, int num_phys)
                 pdevinfo.id = phy->port;
                 pdevinfo.data = &nop_pdata;
                 pdevinfo.size_data =
-                        sizeof(struct usb_phy_gen_xceiv_platform_data);
-                scnprintf(phy_id, MAX_STR, "usb_phy_gen_xceiv.%d",
+                        sizeof(struct usb_phy_generic_platform_data);
+                scnprintf(phy_id, MAX_STR, "usb_phy_generic.%d",
                                         phy->port);
                 pdev = platform_device_register_full(&pdevinfo);
                 if (IS_ERR(pdev)) {
diff --git a/arch/arm/mach-pxa/zeus.c b/arch/arm/mach-pxa/zeus.c
index b19d1c361cab..205f9bf3821e 100644
--- a/arch/arm/mach-pxa/zeus.c
+++ b/arch/arm/mach-pxa/zeus.c
@@ -413,7 +413,7 @@ static struct fixed_voltage_config can_regulator_pdata = {
 
 static struct platform_device can_regulator_device = {
         .name   = "reg-fixed-volage",
-        .id     = -1,
+        .id     = 0,
         .dev    = {
                 .platform_data  = &can_regulator_pdata,
         },
@@ -510,18 +510,6 @@ struct platform_device zeus_max6369_device = {
         .num_resources  = 1,
 };
 
-static struct platform_device *zeus_devices[] __initdata = {
-        &zeus_serial_device,
-        &zeus_mtd_devices[0],
-        &zeus_dm9k0_device,
-        &zeus_dm9k1_device,
-        &zeus_sram_device,
-        &zeus_leds_device,
-        &zeus_pcmcia_device,
-        &zeus_max6369_device,
-        &can_regulator_device,
-};
-
 /* AC'97 */
 static pxa2xx_audio_ops_t zeus_ac97_info = {
         .reset_gpio = 95,
@@ -532,44 +520,50 @@ static pxa2xx_audio_ops_t zeus_ac97_info = {
  * USB host
  */
 
-static int zeus_ohci_init(struct device *dev)
-{
-        int err;
-
-        /* Switch on port 2. */
-        if ((err = gpio_request(ZEUS_USB2_PWREN_GPIO, "USB2_PWREN"))) {
-                dev_err(dev, "Can't request USB2_PWREN\n");
-                return err;
-        }
-
-        if ((err = gpio_direction_output(ZEUS_USB2_PWREN_GPIO, 1))) {
-                gpio_free(ZEUS_USB2_PWREN_GPIO);
-                dev_err(dev, "Can't enable USB2_PWREN\n");
-                return err;
-        }
+static struct regulator_consumer_supply zeus_ohci_regulator_supplies[] = {
+        REGULATOR_SUPPLY("vbus2", "pxa27x-ohci"),
+};
 
-        /* Port 2 is shared between host and client interface. */
-        UP2OCR = UP2OCR_HXOE | UP2OCR_HXS | UP2OCR_DMPDE | UP2OCR_DPPDE;
+static struct regulator_init_data zeus_ohci_regulator_data = {
+        .constraints = {
+                .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies  = ARRAY_SIZE(zeus_ohci_regulator_supplies),
+        .consumer_supplies      = zeus_ohci_regulator_supplies,
+};
 
-        return 0;
-}
+static struct fixed_voltage_config zeus_ohci_regulator_config = {
+        .supply_name            = "vbus2",
+        .microvolts             = 5000000, /* 5.0V */
+        .gpio                   = ZEUS_USB2_PWREN_GPIO,
+        .enable_high            = 1,
+        .startup_delay          = 0,
+        .init_data              = &zeus_ohci_regulator_data,
+};
 
-static void zeus_ohci_exit(struct device *dev)
-{
-        /* Power-off port 2 */
-        gpio_direction_output(ZEUS_USB2_PWREN_GPIO, 0);
-        gpio_free(ZEUS_USB2_PWREN_GPIO);
-}
+static struct platform_device zeus_ohci_regulator_device = {
+        .name           = "reg-fixed-voltage",
+        .id             = 1,
+        .dev = {
+                .platform_data = &zeus_ohci_regulator_config,
+        },
+};
 
 static struct pxaohci_platform_data zeus_ohci_platform_data = {
         .port_mode      = PMM_NPS_MODE,
         /* Clear Power Control Polarity Low and set Power Sense
          * Polarity Low. Supply power to USB ports. */
         .flags          = ENABLE_PORT_ALL | POWER_SENSE_LOW,
-        .init           = zeus_ohci_init,
-        .exit           = zeus_ohci_exit,
 };
 
+static void zeus_register_ohci(void)
+{
+        /* Port 2 is shared between host and client interface. */
+        UP2OCR = UP2OCR_HXOE | UP2OCR_HXS | UP2OCR_DMPDE | UP2OCR_DPPDE;
+
+        pxa_set_ohci_info(&zeus_ohci_platform_data);
+}
+
 /*
  * Flat Panel
  */
@@ -677,6 +671,19 @@ static struct pxa2xx_udc_mach_info zeus_udc_info = {
         .udc_command = zeus_udc_command,
 };
 
+static struct platform_device *zeus_devices[] __initdata = {
+        &zeus_serial_device,
+        &zeus_mtd_devices[0],
+        &zeus_dm9k0_device,
+        &zeus_dm9k1_device,
+        &zeus_sram_device,
+        &zeus_leds_device,
+        &zeus_pcmcia_device,
+        &zeus_max6369_device,
+        &can_regulator_device,
+        &zeus_ohci_regulator_device,
+};
+
 #ifdef CONFIG_PM
 static void zeus_power_off(void)
 {
@@ -847,7 +854,7 @@ static void __init zeus_init(void)
 
         platform_add_devices(zeus_devices, ARRAY_SIZE(zeus_devices));
 
-        pxa_set_ohci_info(&zeus_ohci_platform_data);
+        zeus_register_ohci();
 
         if (zeus_setup_fb_gpios())
                 pr_err("Failed to setup fb gpios\n");
diff --git a/arch/avr32/configs/hammerhead_defconfig b/arch/avr32/configs/hammerhead_defconfig
index 18db853386c8..4912f0aadaa1 100644
--- a/arch/avr32/configs/hammerhead_defconfig
+++ b/arch/avr32/configs/hammerhead_defconfig
@@ -117,7 +117,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=m
 CONFIG_USB_ISP116X_HCD=m
diff --git a/arch/blackfin/configs/BF526-EZBRD_defconfig b/arch/blackfin/configs/BF526-EZBRD_defconfig
index 2f2c6acf210c..1759fad54017 100644
--- a/arch/blackfin/configs/BF526-EZBRD_defconfig
+++ b/arch/blackfin/configs/BF526-EZBRD_defconfig
@@ -123,7 +123,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_BLACKLIST_HUB=y
 CONFIG_USB_MON=y
diff --git a/arch/blackfin/configs/BF527-EZKIT-V2_defconfig b/arch/blackfin/configs/BF527-EZKIT-V2_defconfig
index 91535c38e7f2..357729682c00 100644
--- a/arch/blackfin/configs/BF527-EZKIT-V2_defconfig
+++ b/arch/blackfin/configs/BF527-EZKIT-V2_defconfig
@@ -147,7 +147,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_BLACKLIST_HUB=y
 CONFIG_USB_MON=y
diff --git a/arch/blackfin/configs/BF527-EZKIT_defconfig b/arch/blackfin/configs/BF527-EZKIT_defconfig
index af2738c7441b..2e73a5d33da8 100644
--- a/arch/blackfin/configs/BF527-EZKIT_defconfig
+++ b/arch/blackfin/configs/BF527-EZKIT_defconfig
@@ -141,7 +141,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_BLACKLIST_HUB=y
 CONFIG_USB_MON=y
diff --git a/arch/blackfin/configs/BF548-EZKIT_defconfig b/arch/blackfin/configs/BF548-EZKIT_defconfig
index e716fdfd2cf2..f0a2ddf5de46 100644
--- a/arch/blackfin/configs/BF548-EZKIT_defconfig
+++ b/arch/blackfin/configs/BF548-EZKIT_defconfig
@@ -159,7 +159,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_BLACKLIST_HUB=y
 CONFIG_USB_MON=y
diff --git a/arch/blackfin/configs/CM-BF527_defconfig b/arch/blackfin/configs/CM-BF527_defconfig
index f59c80ee78e3..05108b85ab12 100644
--- a/arch/blackfin/configs/CM-BF527_defconfig
+++ b/arch/blackfin/configs/CM-BF527_defconfig
@@ -95,7 +95,6 @@ CONFIG_WATCHDOG=y
 CONFIG_BFIN_WDT=y
 CONFIG_USB=m
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_BLACKLIST_HUB=y
 CONFIG_USB_MON=m
diff --git a/arch/blackfin/configs/CM-BF548_defconfig b/arch/blackfin/configs/CM-BF548_defconfig
index b9af4fa69984..9ff79df6825c 100644
--- a/arch/blackfin/configs/CM-BF548_defconfig
+++ b/arch/blackfin/configs/CM-BF548_defconfig
@@ -94,7 +94,6 @@ CONFIG_WATCHDOG=y
 CONFIG_BFIN_WDT=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=m
 CONFIG_USB_MUSB_HDRC=m
diff --git a/arch/blackfin/configs/IP0X_defconfig b/arch/blackfin/configs/IP0X_defconfig
index 629516578760..5adf0da58499 100644
--- a/arch/blackfin/configs/IP0X_defconfig
+++ b/arch/blackfin/configs/IP0X_defconfig
@@ -73,7 +73,6 @@ CONFIG_SPI_BFIN5XX=y
 # CONFIG_HWMON is not set
 CONFIG_WATCHDOG=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OTG_WHITELIST=y
 CONFIG_USB_MON=y
 CONFIG_USB_ISP1362_HCD=y
diff --git a/arch/ia64/configs/bigsur_defconfig b/arch/ia64/configs/bigsur_defconfig
index cf5993f05d4f..4c4ac163c600 100644
--- a/arch/ia64/configs/bigsur_defconfig
+++ b/arch/ia64/configs/bigsur_defconfig
@@ -75,7 +75,6 @@ CONFIG_SND_PCM_OSS=m
 CONFIG_SND_CS4281=m
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_UHCI_HCD=m
 CONFIG_USB_ACM=m
diff --git a/arch/ia64/configs/generic_defconfig b/arch/ia64/configs/generic_defconfig
index b4efaf2bc13e..e8ed3ae70aae 100644
--- a/arch/ia64/configs/generic_defconfig
+++ b/arch/ia64/configs/generic_defconfig
@@ -143,7 +143,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_OHCI_HCD=m
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
index f64980dd20c3..d663efd1e4db 100644
--- a/arch/ia64/configs/gensparse_defconfig
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -126,7 +126,6 @@ CONFIG_SND_CS46XX=m
 CONFIG_SND_EMU10K1=m
 CONFIG_SND_FM801=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_OHCI_HCD=m
diff --git a/arch/ia64/configs/tiger_defconfig b/arch/ia64/configs/tiger_defconfig
index 0fed9ae5a42a..c8a3f40e77f6 100644
--- a/arch/ia64/configs/tiger_defconfig
+++ b/arch/ia64/configs/tiger_defconfig
@@ -102,7 +102,6 @@ CONFIG_DRM_RADEON=m
 CONFIG_DRM_MGA=m
 CONFIG_DRM_SIS=m
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_OHCI_HCD=m
 CONFIG_USB_UHCI_HCD=y
diff --git a/arch/mips/configs/fuloong2e_defconfig b/arch/mips/configs/fuloong2e_defconfig
index e5b73de08fc5..002680648dcb 100644
--- a/arch/mips/configs/fuloong2e_defconfig
+++ b/arch/mips/configs/fuloong2e_defconfig
@@ -188,7 +188,6 @@ CONFIG_USB_KBD=y
 CONFIG_USB_MOUSE=y
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OTG_WHITELIST=y
 CONFIG_USB_WUSB_CBAF=m
diff --git a/arch/mips/configs/lemote2f_defconfig b/arch/mips/configs/lemote2f_defconfig
index 343bebc4b63b..227a9de32246 100644
--- a/arch/mips/configs/lemote2f_defconfig
+++ b/arch/mips/configs/lemote2f_defconfig
@@ -297,7 +297,6 @@ CONFIG_HID_WACOM=m
 CONFIG_HID_ZEROPLUS=m
 CONFIG_ZEROPLUS_FF=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_DYNAMIC_MINORS=y
 CONFIG_USB_OTG_WHITELIST=y
diff --git a/arch/mips/configs/mpc30x_defconfig b/arch/mips/configs/mpc30x_defconfig
index c16de9812920..7a346605c498 100644
--- a/arch/mips/configs/mpc30x_defconfig
+++ b/arch/mips/configs/mpc30x_defconfig
@@ -47,7 +47,6 @@ CONFIG_GPIO_VR41XX=y
 # CONFIG_VGA_CONSOLE is not set
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OHCI_HCD=m
 CONFIG_RTC_CLASS=y
 CONFIG_RTC_DRV_VR41XX=y
diff --git a/arch/mips/configs/msp71xx_defconfig b/arch/mips/configs/msp71xx_defconfig
index d1142e9cd9a1..201edfb2637d 100644
--- a/arch/mips/configs/msp71xx_defconfig
+++ b/arch/mips/configs/msp71xx_defconfig
@@ -67,7 +67,6 @@ CONFIG_I2C_CHARDEV=y
 CONFIG_I2C_PMCMSP=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_ROOT_HUB_TT=y
diff --git a/arch/mips/configs/mtx1_defconfig b/arch/mips/configs/mtx1_defconfig
index 593946afc483..d269a5326a30 100644
--- a/arch/mips/configs/mtx1_defconfig
+++ b/arch/mips/configs/mtx1_defconfig
@@ -575,7 +575,6 @@ CONFIG_USB_HIDDEV=y
 CONFIG_USB_KBD=m
 CONFIG_USB_MOUSE=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_EHCI_ROOT_HUB_TT=y
diff --git a/arch/mips/configs/rm200_defconfig b/arch/mips/configs/rm200_defconfig
index 59d9d2fdcd48..73e7bf49461c 100644
--- a/arch/mips/configs/rm200_defconfig
+++ b/arch/mips/configs/rm200_defconfig
@@ -301,7 +301,6 @@ CONFIG_USB_HIDDEV=y
 CONFIG_USB_KBD=m
 CONFIG_USB_MOUSE=m
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
diff --git a/arch/mips/configs/sb1250_swarm_defconfig b/arch/mips/configs/sb1250_swarm_defconfig
index 5b0463ef9389..51bab13ef6f8 100644
--- a/arch/mips/configs/sb1250_swarm_defconfig
+++ b/arch/mips/configs/sb1250_swarm_defconfig
@@ -72,7 +72,6 @@ CONFIG_SERIO_RAW=m
 # CONFIG_HW_RANDOM is not set
 # CONFIG_HWMON is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_EXT2_FS=y
diff --git a/arch/mips/configs/tb0219_defconfig b/arch/mips/configs/tb0219_defconfig
index 30036b4cbeb1..11f51505d562 100644
--- a/arch/mips/configs/tb0219_defconfig
+++ b/arch/mips/configs/tb0219_defconfig
@@ -72,7 +72,6 @@ CONFIG_GPIO_TB0219=y
 # CONFIG_VGA_CONSOLE is not set
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
diff --git a/arch/mips/configs/tb0226_defconfig b/arch/mips/configs/tb0226_defconfig
index 81bfa1d4d8e3..d99b1905a1ba 100644
--- a/arch/mips/configs/tb0226_defconfig
+++ b/arch/mips/configs/tb0226_defconfig
@@ -69,7 +69,6 @@ CONFIG_SERIAL_VR41XX_CONSOLE=y
 # CONFIG_VGA_CONSOLE is not set
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/parisc/configs/c3000_defconfig b/arch/parisc/configs/c3000_defconfig
index acacd348df89..fb92b8920785 100644
--- a/arch/parisc/configs/c3000_defconfig
+++ b/arch/parisc/configs/c3000_defconfig
@@ -127,8 +127,6 @@ CONFIG_SND_SEQUENCER_OSS=y
 CONFIG_SND_AD1889=y
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_PRINTER=m
 CONFIG_USB_STORAGE=m
diff --git a/arch/parisc/configs/default_defconfig b/arch/parisc/configs/default_defconfig
index ba61495e1fa4..4d8127e8428a 100644
--- a/arch/parisc/configs/default_defconfig
+++ b/arch/parisc/configs/default_defconfig
@@ -145,7 +145,6 @@ CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_HID_TOPSEED=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_UHCI_HCD=y
diff --git a/arch/parisc/configs/generic-64bit_defconfig b/arch/parisc/configs/generic-64bit_defconfig
index 28c1b5de044e..dc0d7ce71ea7 100644
--- a/arch/parisc/configs/generic-64bit_defconfig
+++ b/arch/parisc/configs/generic-64bit_defconfig
@@ -219,7 +219,6 @@ CONFIG_HIDRAW=y
 CONFIG_HID_PID=y
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_DYNAMIC_MINORS=y
 CONFIG_USB_MON=m
diff --git a/arch/powerpc/configs/40x/ep405_defconfig b/arch/powerpc/configs/40x/ep405_defconfig
index cf06d42f2c03..e9d84b5d0ab6 100644
--- a/arch/powerpc/configs/40x/ep405_defconfig
+++ b/arch/powerpc/configs/40x/ep405_defconfig
@@ -57,7 +57,6 @@ CONFIG_SERIAL_OF_PLATFORM=y
 CONFIG_THERMAL=y
 CONFIG_VIDEO_OUTPUT_CONTROL=m
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_HCD_PPC_OF_BE=y
diff --git a/arch/powerpc/configs/44x/canyonlands_defconfig b/arch/powerpc/configs/44x/canyonlands_defconfig
index 7b8abd1b88b0..9919a91add12 100644
--- a/arch/powerpc/configs/44x/canyonlands_defconfig
+++ b/arch/powerpc/configs/44x/canyonlands_defconfig
@@ -71,7 +71,6 @@ CONFIG_I2C_IBM_IIC=y
 CONFIG_SENSORS_AD7414=y
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/44x/currituck_defconfig b/arch/powerpc/configs/44x/currituck_defconfig
index 4192322f8a7f..47de68261443 100644
--- a/arch/powerpc/configs/44x/currituck_defconfig
+++ b/arch/powerpc/configs/44x/currituck_defconfig
@@ -71,7 +71,6 @@ CONFIG_I2C_IBM_IIC=y
 # CONFIG_HWMON is not set
 CONFIG_THERMAL=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_RTC_CLASS=y
diff --git a/arch/powerpc/configs/44x/sam440ep_defconfig b/arch/powerpc/configs/44x/sam440ep_defconfig
index ca088cd581af..9622eb2a3e37 100644
--- a/arch/powerpc/configs/44x/sam440ep_defconfig
+++ b/arch/powerpc/configs/44x/sam440ep_defconfig
@@ -83,7 +83,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_EHCI_HCD=m
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/52xx/cm5200_defconfig b/arch/powerpc/configs/52xx/cm5200_defconfig
index 4f84a0b2fbf3..0dc99e141035 100644
--- a/arch/powerpc/configs/52xx/cm5200_defconfig
+++ b/arch/powerpc/configs/52xx/cm5200_defconfig
@@ -64,7 +64,6 @@ CONFIG_I2C_MPC=y
 # CONFIG_HWMON is not set
 CONFIG_WATCHDOG=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_HCD_PPC_OF_BE=y
diff --git a/arch/powerpc/configs/52xx/pcm030_defconfig b/arch/powerpc/configs/52xx/pcm030_defconfig
index 2401e2554329..1d03c35540c7 100644
--- a/arch/powerpc/configs/52xx/pcm030_defconfig
+++ b/arch/powerpc/configs/52xx/pcm030_defconfig
@@ -76,7 +76,6 @@ CONFIG_I2C_CHARDEV=y
 CONFIG_I2C_MPC=y
 # CONFIG_HWMON is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_OHCI_HCD=m
 # CONFIG_USB_OHCI_HCD_PPC_SOC is not set
diff --git a/arch/powerpc/configs/52xx/tqm5200_defconfig b/arch/powerpc/configs/52xx/tqm5200_defconfig
index 21c841e0f482..ca83ec88b114 100644
--- a/arch/powerpc/configs/52xx/tqm5200_defconfig
+++ b/arch/powerpc/configs/52xx/tqm5200_defconfig
@@ -75,7 +75,6 @@ CONFIG_FB_FOREIGN_ENDIAN=y
 CONFIG_FB_SM501=y
 CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig b/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
index 0b73b7f9d112..4b4a2a9133a5 100644
--- a/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
+++ b/arch/powerpc/configs/83xx/mpc8313_rdb_defconfig
@@ -74,7 +74,6 @@ CONFIG_WATCHDOG=y
 CONFIG_VIDEO_OUTPUT_CONTROL=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
diff --git a/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig b/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
index 97ac3b993cb6..5871395573c5 100644
--- a/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
+++ b/arch/powerpc/configs/83xx/mpc8315_rdb_defconfig
@@ -71,7 +71,6 @@ CONFIG_WATCHDOG=y
 CONFIG_VIDEO_OUTPUT_CONTROL=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
diff --git a/arch/powerpc/configs/83xx/mpc832x_rdb_defconfig b/arch/powerpc/configs/83xx/mpc832x_rdb_defconfig
index b4da1a7e6449..5adc4cea42d3 100644
--- a/arch/powerpc/configs/83xx/mpc832x_rdb_defconfig
+++ b/arch/powerpc/configs/83xx/mpc832x_rdb_defconfig
@@ -61,7 +61,6 @@ CONFIG_WATCHDOG=y
 CONFIG_VIDEO_OUTPUT_CONTROL=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/83xx/mpc834x_itx_defconfig b/arch/powerpc/configs/83xx/mpc834x_itx_defconfig
index 291f8221d5a6..82b6b6c88d6a 100644
--- a/arch/powerpc/configs/83xx/mpc834x_itx_defconfig
+++ b/arch/powerpc/configs/83xx/mpc834x_itx_defconfig
@@ -71,7 +71,6 @@ CONFIG_SPI_BITBANG=y
 CONFIG_WATCHDOG=y
 CONFIG_VIDEO_OUTPUT_CONTROL=m
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
diff --git a/arch/powerpc/configs/83xx/sbc834x_defconfig b/arch/powerpc/configs/83xx/sbc834x_defconfig
index a3bcda67d2d9..4ae385894c64 100644
--- a/arch/powerpc/configs/83xx/sbc834x_defconfig
+++ b/arch/powerpc/configs/83xx/sbc834x_defconfig
@@ -70,7 +70,6 @@ CONFIG_I2C_MPC=y
 CONFIG_WATCHDOG=y
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_FSL=y
diff --git a/arch/powerpc/configs/85xx/ge_imp3a_defconfig b/arch/powerpc/configs/85xx/ge_imp3a_defconfig
index c9765b54dd1a..dc939de9b5b0 100644
--- a/arch/powerpc/configs/85xx/ge_imp3a_defconfig
+++ b/arch/powerpc/configs/85xx/ge_imp3a_defconfig
@@ -158,7 +158,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_THRUSTMASTER=y
 CONFIG_HID_ZEROPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
 CONFIG_USB_EHCI_FSL=y
diff --git a/arch/powerpc/configs/85xx/socrates_defconfig b/arch/powerpc/configs/85xx/socrates_defconfig
index e5147488c000..435fd408eef1 100644
--- a/arch/powerpc/configs/85xx/socrates_defconfig
+++ b/arch/powerpc/configs/85xx/socrates_defconfig
@@ -86,7 +86,6 @@ CONFIG_FONTS=y
 CONFIG_FONT_8x16=y
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/85xx/xes_mpc85xx_defconfig b/arch/powerpc/configs/85xx/xes_mpc85xx_defconfig
index 07bb81df27e0..72df8ab8449e 100644
--- a/arch/powerpc/configs/85xx/xes_mpc85xx_defconfig
+++ b/arch/powerpc/configs/85xx/xes_mpc85xx_defconfig
@@ -125,7 +125,6 @@ CONFIG_SENSORS_LM90=y
 CONFIG_WATCHDOG=y
 CONFIG_VIDEO_OUTPUT_CONTROL=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_ISP1760_HCD=y
diff --git a/arch/powerpc/configs/86xx/mpc8641_hpcn_defconfig b/arch/powerpc/configs/86xx/mpc8641_hpcn_defconfig
index f51c7ebc181e..76f43df3dec7 100644
--- a/arch/powerpc/configs/86xx/mpc8641_hpcn_defconfig
+++ b/arch/powerpc/configs/86xx/mpc8641_hpcn_defconfig
@@ -123,7 +123,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/amigaone_defconfig b/arch/powerpc/configs/amigaone_defconfig
index b6d49da9c82c..8c66b13e59fc 100644
--- a/arch/powerpc/configs/amigaone_defconfig
+++ b/arch/powerpc/configs/amigaone_defconfig
@@ -108,7 +108,6 @@ CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_HID_TOPSEED=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_UHCI_HCD=y
diff --git a/arch/powerpc/configs/c2k_defconfig b/arch/powerpc/configs/c2k_defconfig
index c69f61620908..5e2aa43562b5 100644
--- a/arch/powerpc/configs/c2k_defconfig
+++ b/arch/powerpc/configs/c2k_defconfig
@@ -261,7 +261,6 @@ CONFIG_USBPCWATCHDOG=m
 # CONFIG_VGA_CONSOLE is not set
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
diff --git a/arch/powerpc/configs/cell_defconfig b/arch/powerpc/configs/cell_defconfig
index 22a403d78d34..4bee1a6d41d0 100644
--- a/arch/powerpc/configs/cell_defconfig
+++ b/arch/powerpc/configs/cell_defconfig
@@ -179,7 +179,6 @@ CONFIG_VIDEO_OUTPUT_CONTROL=m
 CONFIG_HID=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=m
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=m
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_HCD_PPC_OF is not set
diff --git a/arch/powerpc/configs/celleb_defconfig b/arch/powerpc/configs/celleb_defconfig
index 895449ed971e..6d7b22f41b50 100644
--- a/arch/powerpc/configs/celleb_defconfig
+++ b/arch/powerpc/configs/celleb_defconfig
@@ -87,7 +87,6 @@ CONFIG_WATCHDOG=y
 # CONFIG_VGA_CONSOLE is not set
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
diff --git a/arch/powerpc/configs/chrp32_defconfig b/arch/powerpc/configs/chrp32_defconfig
index b20554efddcc..db5b30857e1c 100644
--- a/arch/powerpc/configs/chrp32_defconfig
+++ b/arch/powerpc/configs/chrp32_defconfig
@@ -111,7 +111,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_HCD_PPC_OF is not set
diff --git a/arch/powerpc/configs/g5_defconfig b/arch/powerpc/configs/g5_defconfig
index 1ea22fc24ea8..3c72fa615bd9 100644
--- a/arch/powerpc/configs/g5_defconfig
+++ b/arch/powerpc/configs/g5_defconfig
@@ -175,7 +175,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_HCD_PPC_OF is not set
diff --git a/arch/powerpc/configs/linkstation_defconfig b/arch/powerpc/configs/linkstation_defconfig
index 353435256f4c..b5e684640fdf 100644
--- a/arch/powerpc/configs/linkstation_defconfig
+++ b/arch/powerpc/configs/linkstation_defconfig
@@ -111,7 +111,6 @@ CONFIG_VIDEO_OUTPUT_CONTROL=m
 CONFIG_HID=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/maple_defconfig b/arch/powerpc/configs/maple_defconfig
index 2a5afac29861..95e545d9f25c 100644
--- a/arch/powerpc/configs/maple_defconfig
+++ b/arch/powerpc/configs/maple_defconfig
@@ -79,7 +79,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_ROOT_HUB_TT=y
diff --git a/arch/powerpc/configs/mpc5200_defconfig b/arch/powerpc/configs/mpc5200_defconfig
index 8b682d1cf4d6..530601e8ccfe 100644
--- a/arch/powerpc/configs/mpc5200_defconfig
+++ b/arch/powerpc/configs/mpc5200_defconfig
@@ -113,7 +113,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_THRUSTMASTER=y
 CONFIG_HID_ZEROPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/mpc86xx_defconfig b/arch/powerpc/configs/mpc86xx_defconfig
index a1cc8179e9fd..35595ea74ff4 100644
--- a/arch/powerpc/configs/mpc86xx_defconfig
+++ b/arch/powerpc/configs/mpc86xx_defconfig
@@ -126,7 +126,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
diff --git a/arch/powerpc/configs/pmac32_defconfig b/arch/powerpc/configs/pmac32_defconfig
index a73626b09051..553e66278010 100644
--- a/arch/powerpc/configs/pmac32_defconfig
+++ b/arch/powerpc/configs/pmac32_defconfig
@@ -279,7 +279,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_HID_TOPSEED=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_DYNAMIC_MINORS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
diff --git a/arch/powerpc/configs/ppc6xx_defconfig b/arch/powerpc/configs/ppc6xx_defconfig
index 175a8b99c196..c91066944842 100644
--- a/arch/powerpc/configs/ppc6xx_defconfig
+++ b/arch/powerpc/configs/ppc6xx_defconfig
@@ -964,9 +964,7 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
diff --git a/arch/powerpc/configs/storcenter_defconfig b/arch/powerpc/configs/storcenter_defconfig
index ba39c785445d..60ad2c08caa6 100644
--- a/arch/powerpc/configs/storcenter_defconfig
+++ b/arch/powerpc/configs/storcenter_defconfig
@@ -72,7 +72,6 @@ CONFIG_I2C_CHARDEV=y
 CONFIG_I2C_MPC=y
 # CONFIG_HWMON is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_STORAGE=y
diff --git a/arch/sh/configs/apsh4ad0a_defconfig b/arch/sh/configs/apsh4ad0a_defconfig
index 95ae23fcfdd6..ec70475da890 100644
--- a/arch/sh/configs/apsh4ad0a_defconfig
+++ b/arch/sh/configs/apsh4ad0a_defconfig
@@ -93,7 +93,6 @@ CONFIG_FONT_8x8=y
 CONFIG_FONT_8x16=y
 CONFIG_LOGO=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_STORAGE=y
diff --git a/arch/sh/configs/ecovec24_defconfig b/arch/sh/configs/ecovec24_defconfig
index c6c2becdc8ab..0b364e3b0ff8 100644
--- a/arch/sh/configs/ecovec24_defconfig
+++ b/arch/sh/configs/ecovec24_defconfig
@@ -107,7 +107,6 @@ CONFIG_SND_SOC=y
 CONFIG_SND_SOC_SH4_FSI=y
 CONFIG_SND_FSI_DA7210=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_R8A66597_HCD=y
 CONFIG_USB_STORAGE=y
diff --git a/arch/sh/configs/landisk_defconfig b/arch/sh/configs/landisk_defconfig
index 3670e937f2b7..6783f31315c7 100644
--- a/arch/sh/configs/landisk_defconfig
+++ b/arch/sh/configs/landisk_defconfig
@@ -80,7 +80,6 @@ CONFIG_HID_SAMSUNG=m
 CONFIG_HID_SONY=m
 CONFIG_HID_SUNPLUS=m
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
diff --git a/arch/sh/configs/rsk7203_defconfig b/arch/sh/configs/rsk7203_defconfig
index 47236573db83..3c4f6f4d52b0 100644
--- a/arch/sh/configs/rsk7203_defconfig
+++ b/arch/sh/configs/rsk7203_defconfig
@@ -100,7 +100,6 @@ CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_R8A66597_HCD=y
 CONFIG_NEW_LEDS=y
diff --git a/arch/sh/configs/rsk7264_defconfig b/arch/sh/configs/rsk7264_defconfig
index 1600426224c2..eecdf65bb789 100644
--- a/arch/sh/configs/rsk7264_defconfig
+++ b/arch/sh/configs/rsk7264_defconfig
@@ -60,7 +60,6 @@ CONFIG_SERIAL_SH_SCI_NR_UARTS=8
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
 # CONFIG_HWMON is not set
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_R8A66597_HCD=y
diff --git a/arch/sh/configs/rsk7269_defconfig b/arch/sh/configs/rsk7269_defconfig
index 9f062b5837d7..8370b10df357 100644
--- a/arch/sh/configs/rsk7269_defconfig
+++ b/arch/sh/configs/rsk7269_defconfig
@@ -43,7 +43,6 @@ CONFIG_SERIAL_SH_SCI_NR_UARTS=8
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
 # CONFIG_HWMON is not set
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_R8A66597_HCD=y
diff --git a/arch/sh/configs/sdk7780_defconfig b/arch/sh/configs/sdk7780_defconfig
index ae1115849dda..6a96b9a2f7a5 100644
--- a/arch/sh/configs/sdk7780_defconfig
+++ b/arch/sh/configs/sdk7780_defconfig
@@ -100,8 +100,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
diff --git a/arch/sh/configs/se7343_defconfig b/arch/sh/configs/se7343_defconfig
index be9c474197b3..201acb4652f7 100644
--- a/arch/sh/configs/se7343_defconfig
+++ b/arch/sh/configs/se7343_defconfig
@@ -92,9 +92,7 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_ISP116X_HCD=y
 CONFIG_UIO=y
 CONFIG_EXT2_FS=y
diff --git a/arch/sh/configs/se7780_defconfig b/arch/sh/configs/se7780_defconfig
index c8c5e7f7a68d..b0ef63ce525a 100644
--- a/arch/sh/configs/se7780_defconfig
+++ b/arch/sh/configs/se7780_defconfig
@@ -94,7 +94,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
diff --git a/arch/sh/configs/sh2007_defconfig b/arch/sh/configs/sh2007_defconfig
index 0d2f41472a19..0c08d9244c97 100644
--- a/arch/sh/configs/sh2007_defconfig
+++ b/arch/sh/configs/sh2007_defconfig
@@ -97,7 +97,6 @@ CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_LOGO=y
 # CONFIG_HID_SUPPORT is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 CONFIG_USB_MON=y
 CONFIG_NEW_LEDS=y
diff --git a/arch/sh/configs/sh7785lcr_defconfig b/arch/sh/configs/sh7785lcr_defconfig
index 51561f5677d8..d29da4a0f6c2 100644
--- a/arch/sh/configs/sh7785lcr_defconfig
+++ b/arch/sh/configs/sh7785lcr_defconfig
@@ -88,7 +88,6 @@ CONFIG_HID_SAMSUNG=y
 CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
diff --git a/arch/sh/configs/titan_defconfig b/arch/sh/configs/titan_defconfig
index e2cbd92d520b..a77b778c745b 100644
--- a/arch/sh/configs/titan_defconfig
+++ b/arch/sh/configs/titan_defconfig
@@ -215,7 +215,6 @@ CONFIG_WATCHDOG=y
 CONFIG_SH_WDT=m
 # CONFIG_USB_HID is not set
 CONFIG_USB=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
 CONFIG_USB_EHCI_ROOT_HUB_TT=y
diff --git a/arch/sh/configs/urquell_defconfig b/arch/sh/configs/urquell_defconfig
index d7f89be9f474..1e843dbed5f0 100644
--- a/arch/sh/configs/urquell_defconfig
+++ b/arch/sh/configs/urquell_defconfig
@@ -117,7 +117,6 @@ CONFIG_HID_SONY=y
 CONFIG_HID_SUNPLUS=y
 CONFIG_USB=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
-CONFIG_USB_DEVICEFS=y
 CONFIG_USB_MON=y
 CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_STORAGE=y
diff --git a/arch/unicore32/configs/unicore32_defconfig b/arch/unicore32/configs/unicore32_defconfig
index c9dd3198b6f7..45f47f88d86a 100644
--- a/arch/unicore32/configs/unicore32_defconfig
+++ b/arch/unicore32/configs/unicore32_defconfig
@@ -149,7 +149,6 @@ CONFIG_SND_PCM_OSS=m
 #       USB support
 CONFIG_USB_ARCH_HAS_HCD=n
 CONFIG_USB=n
-CONFIG_USB_DEVICEFS=n
 CONFIG_USB_PRINTER=n
 CONFIG_USB_STORAGE=n
 #       Inventra Highspeed Dual Role Controller
diff --git a/arch/x86/configs/i386_defconfig b/arch/x86/configs/i386_defconfig
index 619e7f7426c6..32d2e7056c87 100644
--- a/arch/x86/configs/i386_defconfig
+++ b/arch/x86/configs/i386_defconfig
@@ -244,7 +244,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_PID=y
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
diff --git a/arch/x86/configs/x86_64_defconfig b/arch/x86/configs/x86_64_defconfig
index 6181c69b786b..a481dd4755d5 100644
--- a/arch/x86/configs/x86_64_defconfig
+++ b/arch/x86/configs/x86_64_defconfig
@@ -239,7 +239,6 @@ CONFIG_HID_TOPSEED=y
 CONFIG_HID_PID=y
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
-CONFIG_USB_DEBUG=y
 CONFIG_USB_ANNOUNCE_NEW_DEVICES=y
 CONFIG_USB_MON=y
 CONFIG_USB_EHCI_HCD=y
diff --git a/drivers/gpu/drm/udl/udl_main.c b/drivers/gpu/drm/udl/udl_main.c
index f5ae57406f34..afdf383f630a 100644
--- a/drivers/gpu/drm/udl/udl_main.c
+++ b/drivers/gpu/drm/udl/udl_main.c
@@ -283,7 +283,7 @@ int udl_submit_urb(struct drm_device *dev, struct urb *urb, size_t len)
 int udl_driver_load(struct drm_device *dev, unsigned long flags)
 {
         struct udl_device *udl;
-        int ret;
+        int ret = -ENOMEM;
 
         DRM_DEBUG("\n");
         udl = kzalloc(sizeof(struct udl_device), GFP_KERNEL);
@@ -299,7 +299,6 @@ int udl_driver_load(struct drm_device *dev, unsigned long flags)
         }
 
         if (!udl_alloc_urb_list(dev, WRITES_IN_FLIGHT, MAX_TRANSFER)) {
-                ret = -ENOMEM;
                 DRM_ERROR("udl_alloc_urb_list failed\n");
                 goto err;
         }
diff --git a/drivers/media/rc/redrat3.c b/drivers/media/rc/redrat3.c
index 47cd373e2295..79abbc8d9600 100644
--- a/drivers/media/rc/redrat3.c
+++ b/drivers/media/rc/redrat3.c
@@ -60,28 +60,6 @@
 #define DRIVER_DESC "RedRat3 USB IR Transceiver Driver"
 #define DRIVER_NAME "redrat3"
 
-/* module parameters */
-#ifdef CONFIG_USB_DEBUG
-static int debug = 1;
-#else
-static int debug;
-#endif
-
-#define RR3_DEBUG_STANDARD              0x1
-#define RR3_DEBUG_FUNCTION_TRACE        0x2
-
-#define rr3_dbg(dev, fmt, ...)                                  \
-        do {                                                    \
-                if (debug & RR3_DEBUG_STANDARD)                 \
-                        dev_info(dev, fmt, ## __VA_ARGS__);     \
-        } while (0)
-
-#define rr3_ftr(dev, fmt, ...)                                  \
-        do {                                                    \
-                if (debug & RR3_DEBUG_FUNCTION_TRACE)           \
-                        dev_info(dev, fmt, ## __VA_ARGS__);     \
-        } while (0)
-
 /* bulk data transfer types */
 #define RR3_ERROR               0x01
 #define RR3_MOD_SIGNAL_IN       0x20
@@ -237,13 +215,11 @@ static void redrat3_issue_async(struct redrat3_dev *rr3)
 {
         int res;
 
-        rr3_ftr(rr3->dev, "Entering %s\n", __func__);
-
         res = usb_submit_urb(rr3->read_urb, GFP_ATOMIC);
         if (res)
-                rr3_dbg(rr3->dev, "%s: receive request FAILED! "
-                        "(res %d, len %d)\n", __func__, res,
-                        rr3->read_urb->transfer_buffer_length);
+                dev_dbg(rr3->dev,
+                        "%s: receive request FAILED! (res %d, len %d)\n",
+                        __func__, res, rr3->read_urb->transfer_buffer_length);
 }
 
 static void redrat3_dump_fw_error(struct redrat3_dev *rr3, int code)
@@ -359,7 +335,7 @@ static void redrat3_rx_timeout(unsigned long data)
 {
         struct redrat3_dev *rr3 = (struct redrat3_dev *)data;
 
-        rr3_dbg(rr3->dev, "calling ir_raw_event_reset\n");
+        dev_dbg(rr3->dev, "calling ir_raw_event_reset\n");
         ir_raw_event_reset(rr3->rc);
 }
 
@@ -377,8 +353,6 @@ static void redrat3_process_ir_data(struct redrat3_dev *rr3)
                 return;
         }
 
-        rr3_ftr(rr3->dev, "Entered %s\n", __func__);
-
         dev = rr3->dev;
 
         /* Make sure we reset the IR kfifo after a bit of inactivity */
@@ -386,7 +360,7 @@ static void redrat3_process_ir_data(struct redrat3_dev *rr3)
         mod_timer(&rr3->rx_timeout, jiffies + delay);
 
         mod_freq = redrat3_val_to_mod_freq(&rr3->irdata);
-        rr3_dbg(dev, "Got mod_freq of %u\n", mod_freq);
+        dev_dbg(dev, "Got mod_freq of %u\n", mod_freq);
 
         /* process each rr3 encoded byte into an int */
         sig_size = be16_to_cpu(rr3->irdata.sig_size);
@@ -408,7 +382,7 @@ static void redrat3_process_ir_data(struct redrat3_dev *rr3)
                 /* cap the value to IR_MAX_DURATION */
                 rawir.duration &= IR_MAX_DURATION;
 
-                rr3_dbg(dev, "storing %s with duration %d (i: %d)\n",
+                dev_dbg(dev, "storing %s with duration %d (i: %d)\n",
                         rawir.pulse ? "pulse" : "space", rawir.duration, i);
                 ir_raw_event_store_with_filter(rr3->rc, &rawir);
         }
@@ -421,12 +395,12 @@ static void redrat3_process_ir_data(struct redrat3_dev *rr3)
                         rawir.duration = US_TO_NS(2800);
                 else
                         rawir.duration = trailer;
-                rr3_dbg(dev, "storing trailing space with duration %d\n",
+                dev_dbg(dev, "storing trailing space with duration %d\n",
                         rawir.duration);
                 ir_raw_event_store_with_filter(rr3->rc, &rawir);
         }
 
-        rr3_dbg(dev, "calling ir_raw_event_handle\n");
+        dev_dbg(dev, "calling ir_raw_event_handle\n");
         ir_raw_event_handle(rr3->rc);
 }
 
@@ -464,8 +438,6 @@ static int redrat3_enable_detector(struct redrat3_dev *rr3)
         struct device *dev = rr3->dev;
         u8 ret;
 
-        rr3_ftr(dev, "Entering %s\n", __func__);
-
         ret = redrat3_send_cmd(RR3_RC_DET_ENABLE, rr3);
         if (ret != 0)
                 dev_dbg(dev, "%s: unexpected ret of %d\n",
@@ -486,7 +458,6 @@ static int redrat3_enable_detector(struct redrat3_dev *rr3)
 static inline void redrat3_delete(struct redrat3_dev *rr3,
                                   struct usb_device *udev)
 {
-        rr3_ftr(rr3->dev, "%s cleaning up\n", __func__);
         usb_kill_urb(rr3->read_urb);
         usb_kill_urb(rr3->flash_urb);
         usb_free_urb(rr3->read_urb);
@@ -519,7 +490,7 @@ static u32 redrat3_get_timeout(struct redrat3_dev *rr3)
         else {
                 timeout = redrat3_len_to_us(be32_to_cpup(tmp));
 
-                rr3_dbg(rr3->dev, "Got timeout of %d ms\n", timeout / 1000);
+                dev_dbg(rr3->dev, "Got timeout of %d ms\n", timeout / 1000);
         }
 
         kfree(tmp);
@@ -535,8 +506,6 @@ static void redrat3_reset(struct redrat3_dev *rr3)
         u8 *val;
         int len = sizeof(u8);
 
-        rr3_ftr(dev, "Entering %s\n", __func__);
-
         rxpipe = usb_rcvctrlpipe(udev, 0);
         txpipe = usb_sndctrlpipe(udev, 0);
 
@@ -550,19 +519,19 @@ static void redrat3_reset(struct redrat3_dev *rr3)
         rc = usb_control_msg(udev, rxpipe, RR3_RESET,
                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
                              RR3_CPUCS_REG_ADDR, 0, val, len, HZ * 25);
-        rr3_dbg(dev, "reset returned 0x%02x\n", rc);
+        dev_dbg(dev, "reset returned 0x%02x\n", rc);
 
         *val = 5;
         rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM,
                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
                              RR3_IR_IO_LENGTH_FUZZ, 0, val, len, HZ * 25);
-        rr3_dbg(dev, "set ir parm len fuzz %d rc 0x%02x\n", *val, rc);
+        dev_dbg(dev, "set ir parm len fuzz %d rc 0x%02x\n", *val, rc);
 
         *val = RR3_DRIVER_MAXLENS;
         rc = usb_control_msg(udev, txpipe, RR3_SET_IR_PARAM,
                              USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
                              RR3_IR_IO_MAX_LENGTHS, 0, val, len, HZ * 25);
-        rr3_dbg(dev, "set ir parm max lens %d rc 0x%02x\n", *val, rc);
+        dev_dbg(dev, "set ir parm max lens %d rc 0x%02x\n", *val, rc);
 
         kfree(val);
 }
@@ -572,8 +541,6 @@ static void redrat3_get_firmware_rev(struct redrat3_dev *rr3)
         int rc = 0;
         char *buffer;
 
-        rr3_ftr(rr3->dev, "Entering %s\n", __func__);
-
         buffer = kzalloc(sizeof(char) * (RR3_FW_VERSION_LEN + 1), GFP_KERNEL);
         if (!buffer) {
                 dev_err(rr3->dev, "Memory allocation failure\n");
@@ -591,7 +558,6 @@ static void redrat3_get_firmware_rev(struct redrat3_dev *rr3)
                 dev_err(rr3->dev, "Problem fetching firmware ID\n");
 
         kfree(buffer);
-        rr3_ftr(rr3->dev, "Exiting %s\n", __func__);
 }
 
 static void redrat3_read_packet_start(struct redrat3_dev *rr3, unsigned len)
@@ -599,8 +565,6 @@ static void redrat3_read_packet_start(struct redrat3_dev *rr3, unsigned len)
         struct redrat3_header *header = rr3->bulk_in_buf;
         unsigned pktlen, pkttype;
 
-        rr3_ftr(rr3->dev, "Entering %s\n", __func__);
-
         /* grab the Length and type of transfer */
         pktlen = be16_to_cpu(header->length);
         pkttype = be16_to_cpu(header->transfer_type);
@@ -622,12 +586,12 @@ static void redrat3_read_packet_start(struct redrat3_dev *rr3, unsigned len)
         case RR3_MOD_SIGNAL_IN:
                 memcpy(&rr3->irdata, rr3->bulk_in_buf, len);
                 rr3->bytes_read = len;
-                rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d\n",
+                dev_dbg(rr3->dev, "bytes_read %d, pktlen %d\n",
                         rr3->bytes_read, pktlen);
                 break;
 
         default:
-                rr3_dbg(rr3->dev, "ignoring packet with type 0x%02x, len of %d, 0x%02x\n",
+                dev_dbg(rr3->dev, "ignoring packet with type 0x%02x, len of %d, 0x%02x\n",
                                                 pkttype, len, pktlen);
                 break;
         }
@@ -637,8 +601,6 @@ static void redrat3_read_packet_continue(struct redrat3_dev *rr3, unsigned len)
 {
         void *irdata = &rr3->irdata;
 
-        rr3_ftr(rr3->dev, "Entering %s\n", __func__);
-
         if (len + rr3->bytes_read > sizeof(rr3->irdata)) {
                 dev_warn(rr3->dev, "too much data for packet\n");
                 rr3->bytes_read = 0;
@@ -648,7 +610,7 @@ static void redrat3_read_packet_continue(struct redrat3_dev *rr3, unsigned len)
         memcpy(irdata + rr3->bytes_read, rr3->bulk_in_buf, len);
 
         rr3->bytes_read += len;
-        rr3_dbg(rr3->dev, "bytes_read %d, pktlen %d\n", rr3->bytes_read,
+        dev_dbg(rr3->dev, "bytes_read %d, pktlen %d\n", rr3->bytes_read,
                                  be16_to_cpu(rr3->irdata.header.length));
 }
 
@@ -659,8 +621,6 @@ static int redrat3_get_ir_data(struct redrat3_dev *rr3, unsigned len)
         unsigned pkttype;
         int ret = 0;
 
-        rr3_ftr(dev, "Entering %s\n", __func__);
-
         if (rr3->bytes_read == 0 && len >= sizeof(struct redrat3_header)) {
                 redrat3_read_packet_start(rr3, len);
         } else if (rr3->bytes_read != 0) {
@@ -681,7 +641,7 @@ static int redrat3_get_ir_data(struct redrat3_dev *rr3, unsigned len)
         if (pkttype == RR3_MOD_SIGNAL_IN)
                 redrat3_process_ir_data(rr3);
         else
-                rr3_dbg(dev, "discarding non-signal data packet (type 0x%02x)\n",
+                dev_dbg(dev, "discarding non-signal data packet (type 0x%02x)\n",
                                                                 pkttype);
 
 out:
@@ -705,8 +665,6 @@ static void redrat3_handle_async(struct urb *urb)
                 return;
         }
 
-        rr3_ftr(rr3->dev, "Entering %s\n", __func__);
-
         switch (urb->status) {
         case 0:
                 ret = redrat3_get_ir_data(rr3, urb->actual_length);
@@ -743,7 +701,7 @@ static int redrat3_set_tx_carrier(struct rc_dev *rcdev, u32 carrier)
         struct redrat3_dev *rr3 = rcdev->priv;
         struct device *dev = rr3->dev;
 
-        rr3_dbg(dev, "Setting modulation frequency to %u", carrier);
+        dev_dbg(dev, "Setting modulation frequency to %u", carrier);
         if (carrier == 0)
                 return -EINVAL;
 
@@ -764,8 +722,6 @@ static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf,
         u8 curlencheck = 0;
         unsigned i, sendbuf_len;
 
-        rr3_ftr(dev, "Entering %s\n", __func__);
-
         if (rr3->transmitting) {
                 dev_warn(dev, "%s: transmitter already in use\n", __func__);
                 return -EAGAIN;
@@ -801,7 +757,7 @@ static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf,
                                 break;
                 }
                 if (lencheck == curlencheck) {
-                        rr3_dbg(dev, "txbuf[%d]=%u, pos %d, enc %u\n",
+                        dev_dbg(dev, "txbuf[%d]=%u, pos %d, enc %u\n",
                                 i, txbuf[i], curlencheck, cur_sample_len);
                         if (curlencheck < RR3_DRIVER_MAXLENS) {
                                 /* now convert the value to a proper
@@ -835,7 +791,7 @@ static int redrat3_transmit_ir(struct rc_dev *rcdev, unsigned *txbuf,
         pipe = usb_sndbulkpipe(rr3->udev, rr3->ep_out->bEndpointAddress);
         ret = usb_bulk_msg(rr3->udev, pipe, irdata,
                             sendbuf_len, &ret_len, 10 * HZ);
-        rr3_dbg(dev, "sent %d bytes, (ret %d)\n", ret_len, ret);
+        dev_dbg(dev, "sent %d bytes, (ret %d)\n", ret_len, ret);
 
         /* now tell the hardware to transmit what we sent it */
         pipe = usb_rcvctrlpipe(rr3->udev, 0);
@@ -957,8 +913,6 @@ static int redrat3_dev_probe(struct usb_interface *intf,
         int pipe, i;
         int retval = -ENOMEM;
 
-        rr3_ftr(dev, "%s called\n", __func__);
-
         uhi = intf->cur_altsetting;
 
         /* find our bulk-in and bulk-out endpoints */
@@ -971,7 +925,7 @@ static int redrat3_dev_probe(struct usb_interface *intf,
                     ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) &&
                     ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==
                      USB_ENDPOINT_XFER_BULK)) {
-                        rr3_dbg(dev, "found bulk-in endpoint at 0x%02x\n",
+                        dev_dbg(dev, "found bulk-in endpoint at 0x%02x\n",
                                 ep->bEndpointAddress);
                         /* data comes in on 0x82, 0x81 is for other data... */
                         if (ep->bEndpointAddress == RR3_BULK_IN_EP_ADDR)
@@ -982,7 +936,7 @@ static int redrat3_dev_probe(struct usb_interface *intf,
                     ((addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) &&
                     ((attrs & USB_ENDPOINT_XFERTYPE_MASK) ==
                      USB_ENDPOINT_XFER_BULK)) {
-                        rr3_dbg(dev, "found bulk-out endpoint at 0x%02x\n",
+                        dev_dbg(dev, "found bulk-out endpoint at 0x%02x\n",
                                 ep->bEndpointAddress);
                         ep_out = ep;
                 }
@@ -1074,7 +1028,6 @@ static int redrat3_dev_probe(struct usb_interface *intf,
         /* we can register the device now, as it is ready */
         usb_set_intfdata(intf, rr3);
 
-        rr3_ftr(dev, "Exiting %s\n", __func__);
         return 0;
 
 led_free_error:
@@ -1093,8 +1046,6 @@ static void redrat3_dev_disconnect(struct usb_interface *intf)
         struct usb_device *udev = interface_to_usbdev(intf);
         struct redrat3_dev *rr3 = usb_get_intfdata(intf);
 
-        rr3_ftr(&intf->dev, "Entering %s\n", __func__);
-
         if (!rr3)
                 return;
 
@@ -1103,14 +1054,12 @@ static void redrat3_dev_disconnect(struct usb_interface *intf)
         led_classdev_unregister(&rr3->led);
         del_timer_sync(&rr3->rx_timeout);
         redrat3_delete(rr3, udev);
-
-        rr3_ftr(&intf->dev, "RedRat3 IR Transceiver now disconnected\n");
 }
 
 static int redrat3_dev_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct redrat3_dev *rr3 = usb_get_intfdata(intf);
-        rr3_ftr(rr3->dev, "suspend\n");
+
         led_classdev_suspend(&rr3->led);
         usb_kill_urb(rr3->read_urb);
         usb_kill_urb(rr3->flash_urb);
@@ -1120,7 +1069,7 @@ static int redrat3_dev_suspend(struct usb_interface *intf, pm_message_t message)
 static int redrat3_dev_resume(struct usb_interface *intf)
 {
         struct redrat3_dev *rr3 = usb_get_intfdata(intf);
-        rr3_ftr(rr3->dev, "resume\n");
+
         if (usb_submit_urb(rr3->read_urb, GFP_ATOMIC))
                 return -EIO;
         led_classdev_resume(&rr3->led);
@@ -1144,8 +1093,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_AUTHOR(DRIVER_AUTHOR2);
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(usb, redrat3_dev_table);
-
-module_param(debug, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable module debug spew. 0 = no debugging (default) "
-                 "0x1 = standard debug messages, 0x2 = function tracing debug. "
-                 "Flag bits are addative (i.e., 0x3 for both debug types).");
diff --git a/drivers/media/rc/streamzap.c b/drivers/media/rc/streamzap.c
index f4e0bc3d382c..bd5e4ff9e0ba 100644
--- a/drivers/media/rc/streamzap.c
+++ b/drivers/media/rc/streamzap.c
@@ -42,12 +42,6 @@
 #define DRIVER_NAME     "streamzap"
 #define DRIVER_DESC     "Streamzap Remote Control driver"
 
-#ifdef CONFIG_USB_DEBUG
-static bool debug = 1;
-#else
-static bool debug;
-#endif
-
 #define USB_STREAMZAP_VENDOR_ID         0x0e9c
 #define USB_STREAMZAP_PRODUCT_ID        0x0000
 
@@ -528,6 +522,3 @@ module_usb_driver(streamzap_driver);
 MODULE_AUTHOR("Jarod Wilson <jarod@wilsonet.com>");
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable debugging messages");
diff --git a/drivers/net/wireless/orinoco/orinoco_usb.c b/drivers/net/wireless/orinoco/orinoco_usb.c
index f9805c9353d2..3ac71339d040 100644
--- a/drivers/net/wireless/orinoco/orinoco_usb.c
+++ b/drivers/net/wireless/orinoco/orinoco_usb.c
@@ -100,25 +100,11 @@ static struct ez_usb_fw firmware = {
         .code = NULL,
 };
 
-#ifdef CONFIG_USB_DEBUG
-static int debug = 1;
-#else
-static int debug;
-#endif
-
 /* Debugging macros */
-#undef dbg
-#define dbg(format, arg...) \
-        do { if (debug) printk(KERN_DEBUG PFX "%s: " format "\n", \
-                               __func__ , ## arg); } while (0)
 #undef err
 #define err(format, arg...) \
         do { printk(KERN_ERR PFX format "\n", ## arg); } while (0)
 
-/* Module paramaters */
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
 MODULE_FIRMWARE("orinoco_ezusb_fw");
 
 /*
@@ -341,7 +327,7 @@ static void ezusb_request_timerfn(u_long _ctx)
                 ctx->state = EZUSB_CTX_REQ_TIMEOUT;
         } else {
                 ctx->state = EZUSB_CTX_RESP_TIMEOUT;
-                dbg("couldn't unlink");
+                dev_dbg(&ctx->outurb->dev->dev, "couldn't unlink\n");
                 atomic_inc(&ctx->refcount);
                 ctx->killed = 1;
                 ezusb_ctx_complete(ctx);
@@ -634,9 +620,9 @@ static void ezusb_request_in_callback(struct ezusb_priv *upriv,
                                 ctx = c;
                                 break;
                         }
-                        dbg("Skipped (0x%x/0x%x) (%d/%d)",
-                            le16_to_cpu(ans->hermes_rid),
-                            c->in_rid, ans->ans_reply_count, reply_count);
+                        netdev_dbg(upriv->dev, "Skipped (0x%x/0x%x) (%d/%d)\n",
+                                   le16_to_cpu(ans->hermes_rid), c->in_rid,
+                                   ans->ans_reply_count, reply_count);
                 }
         }
 
@@ -768,7 +754,7 @@ static int ezusb_submit_in_urb(struct ezusb_priv *upriv)
         void *cur_buf = upriv->read_urb->transfer_buffer;
 
         if (upriv->read_urb->status == -EINPROGRESS) {
-                dbg("urb busy, not resubmiting");
+                netdev_dbg(upriv->dev, "urb busy, not resubmiting\n");
                 retval = -EBUSY;
                 goto exit;
         }
@@ -838,8 +824,9 @@ static int ezusb_firmware_download(struct ezusb_priv *upriv,
                 memcpy(fw_buffer, &fw->code[addr], FW_BUF_SIZE);
                 if (variant_offset >= addr &&
                     variant_offset < addr + FW_BUF_SIZE) {
-                        dbg("Patching card_variant byte at 0x%04X",
-                            variant_offset);
+                        netdev_dbg(upriv->dev,
+                                   "Patching card_variant byte at 0x%04X\n",
+                                   variant_offset);
                         fw_buffer[variant_offset - addr] = FW_VAR_VALUE;
                 }
                 retval = usb_control_msg(upriv->udev,
@@ -879,7 +866,6 @@ static int ezusb_access_ltv(struct ezusb_priv *upriv,
         BUG_ON(in_irq());
 
         if (!upriv->udev) {
-                dbg("Device disconnected");
                 retval = -ENODEV;
                 goto exit;
         }
@@ -1023,8 +1009,9 @@ static int ezusb_doicmd_wait(struct hermes *hw, u16 cmd, u16 parm0, u16 parm1,
                 cpu_to_le16(parm1),
                 cpu_to_le16(parm2),
         };
-        dbg("0x%04X, parm0 0x%04X, parm1 0x%04X, parm2 0x%04X",
-            cmd, parm0, parm1, parm2);
+        netdev_dbg(upriv->dev,
+                   "0x%04X, parm0 0x%04X, parm1 0x%04X, parm2 0x%04X\n", cmd,
+                   parm0, parm1, parm2);
         ctx = ezusb_alloc_ctx(upriv, EZUSB_RID_DOCMD, EZUSB_RID_ACK);
         if (!ctx)
                 return -ENOMEM;
@@ -1045,7 +1032,7 @@ static int ezusb_docmd_wait(struct hermes *hw, u16 cmd, u16 parm0,
                 0,
                 0,
         };
-        dbg("0x%04X, parm0 0x%04X", cmd, parm0);
+        netdev_dbg(upriv->dev, "0x%04X, parm0 0x%04X\n", cmd, parm0);
         ctx = ezusb_alloc_ctx(upriv, EZUSB_RID_DOCMD, EZUSB_RID_ACK);
         if (!ctx)
                 return -ENOMEM;
@@ -1332,7 +1319,7 @@ static int ezusb_hard_reset(struct orinoco_private *priv)
                 return retval;
         }
 
-        dbg("sending control message");
+        netdev_dbg(upriv->dev, "sending control message\n");
         retval = usb_control_msg(upriv->udev,
                                  usb_sndctrlpipe(upriv->udev, 0),
                                  EZUSB_REQUEST_TRIGER,
@@ -1401,10 +1388,8 @@ static void ezusb_bulk_in_callback(struct urb *urb)
         u16 crc;
         u16 hermes_rid;
 
-        if (upriv->udev == NULL) {
-                dbg("disconnected");
+        if (upriv->udev == NULL)
                 return;
-        }
 
         if (urb->status == -ETIMEDOUT) {
                 /* When a device gets unplugged we get this every time
@@ -1421,12 +1406,13 @@ static void ezusb_bulk_in_callback(struct urb *urb)
         if ((urb->status == -EILSEQ)
             || (urb->status == -ENOENT)
             || (urb->status == -ECONNRESET)) {
-                dbg("status %d, not resubmiting", urb->status);
+                netdev_dbg(upriv->dev, "status %d, not resubmiting\n",
+                           urb->status);
                 return;
         }
         if (urb->status)
-                dbg("status: %d length: %d",
-                    urb->status, urb->actual_length);
+                netdev_dbg(upriv->dev, "status: %d length: %d\n",
+                           urb->status, urb->actual_length);
         if (urb->actual_length < sizeof(*ans)) {
                 err("%s: short read, ignoring", __func__);
                 goto resubmit;
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index 4906c27fa3bd..16a2f067c242 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -89,8 +89,8 @@ config PHY_EXYNOS_DP_VIDEO
 
 config BCM_KONA_USB2_PHY
         tristate "Broadcom Kona USB2 PHY Driver"
-        depends on GENERIC_PHY
         depends on HAS_IOMEM
+        select GENERIC_PHY
         help
           Enable this to support the Broadcom Kona USB 2.0 PHY.
 
@@ -160,6 +160,17 @@ config PHY_EXYNOS5250_USB2
           particular SoC is compiled in the driver. In case of Exynos 5250 four
           phys are available - device, host, HSIC0 and HSIC.
 
+config PHY_EXYNOS5_USBDRD
+        tristate "Exynos5 SoC series USB DRD PHY driver"
+        depends on ARCH_EXYNOS5 && OF
+        depends on HAS_IOMEM
+        select GENERIC_PHY
+        select MFD_SYSCON
+        help
+          Enable USB DRD PHY support for Exynos 5 SoC series.
+          This driver provides PHY interface for USB 3.0 DRD controller
+          present on Exynos5 SoC series.
+
 config PHY_XGENE
         tristate "APM X-Gene 15Gbps PHY support"
         depends on HAS_IOMEM && OF && (ARM64 || COMPILE_TEST)
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index 7728518572a4..b4f1d5770601 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -18,4 +18,5 @@ phy-exynos-usb2-y			+= phy-samsung-usb2.o
 phy-exynos-usb2-$(CONFIG_PHY_EXYNOS4210_USB2)   += phy-exynos4210-usb2.o
 phy-exynos-usb2-$(CONFIG_PHY_EXYNOS4X12_USB2)   += phy-exynos4x12-usb2.o
 phy-exynos-usb2-$(CONFIG_PHY_EXYNOS5250_USB2)   += phy-exynos5250-usb2.o
+obj-$(CONFIG_PHY_EXYNOS5_USBDRD)        += phy-exynos5-usbdrd.o
 obj-$(CONFIG_PHY_XGENE)                 += phy-xgene.o
diff --git a/drivers/phy/phy-exynos-mipi-video.c b/drivers/phy/phy-exynos-mipi-video.c
index 7f139326a642..ff026689358c 100644
--- a/drivers/phy/phy-exynos-mipi-video.c
+++ b/drivers/phy/phy-exynos-mipi-video.c
@@ -101,7 +101,7 @@ static struct phy *exynos_mipi_video_phy_xlate(struct device *dev,
 {
         struct exynos_mipi_video_phy *state = dev_get_drvdata(dev);
 
-        if (WARN_ON(args->args[0] > EXYNOS_MIPI_PHYS_NUM))
+        if (WARN_ON(args->args[0] >= EXYNOS_MIPI_PHYS_NUM))
                 return ERR_PTR(-ENODEV);
 
         return state->phys[args->args[0]].phy;
diff --git a/drivers/phy/phy-exynos5-usbdrd.c b/drivers/phy/phy-exynos5-usbdrd.c
new file mode 100644
index 000000000000..76d862b2202f
--- /dev/null
+++ b/drivers/phy/phy-exynos5-usbdrd.c
@@ -0,0 +1,676 @@
+/*
+ * Samsung EXYNOS5 SoC series USB DRD PHY driver
+ *
+ * Phy provider for USB 3.0 DRD controller on Exynos5 SoC series
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd.
+ * Author: Vivek Gautam <gautam.vivek@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.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/mfd/syscon.h>
+#include <linux/mfd/syscon/exynos5-pmu.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+
+/* Exynos USB PHY registers */
+#define EXYNOS5_FSEL_9MHZ6              0x0
+#define EXYNOS5_FSEL_10MHZ              0x1
+#define EXYNOS5_FSEL_12MHZ              0x2
+#define EXYNOS5_FSEL_19MHZ2             0x3
+#define EXYNOS5_FSEL_20MHZ              0x4
+#define EXYNOS5_FSEL_24MHZ              0x5
+#define EXYNOS5_FSEL_50MHZ              0x7
+
+/* EXYNOS5: USB 3.0 DRD PHY registers */
+#define EXYNOS5_DRD_LINKSYSTEM                  0x04
+
+#define LINKSYSTEM_FLADJ_MASK                   (0x3f << 1)
+#define LINKSYSTEM_FLADJ(_x)                    ((_x) << 1)
+#define LINKSYSTEM_XHCI_VERSION_CONTROL         BIT(27)
+
+#define EXYNOS5_DRD_PHYUTMI                     0x08
+
+#define PHYUTMI_OTGDISABLE                      BIT(6)
+#define PHYUTMI_FORCESUSPEND                    BIT(1)
+#define PHYUTMI_FORCESLEEP                      BIT(0)
+
+#define EXYNOS5_DRD_PHYPIPE                     0x0c
+
+#define EXYNOS5_DRD_PHYCLKRST                   0x10
+
+#define PHYCLKRST_EN_UTMISUSPEND                BIT(31)
+
+#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                        BIT(20)
+#define PHYCLKRST_REF_SSP_EN                    BIT(19)
+#define PHYCLKRST_REF_CLKDIV2                   BIT(18)
+
+#define PHYCLKRST_MPLL_MULTIPLIER_MASK          (0x7f << 11)
+#define PHYCLKRST_MPLL_MULTIPLIER_100MHZ_REF    (0x19 << 11)
+#define PHYCLKRST_MPLL_MULTIPLIER_50M_REF       (0x32 << 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_UTMI_MASK                (0x7 << 5)
+#define PHYCLKRST_FSEL_PIPE_MASK                (0x7 << 8)
+#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                    BIT(4)
+
+#define PHYCLKRST_REFCLKSEL_MASK                (0x03 << 2)
+#define PHYCLKRST_REFCLKSEL_PAD_REFCLK          (0x2 << 2)
+#define PHYCLKRST_REFCLKSEL_EXT_REFCLK          (0x3 << 2)
+
+#define PHYCLKRST_PORTRESET                     BIT(1)
+#define PHYCLKRST_COMMONONN                     BIT(0)
+
+#define EXYNOS5_DRD_PHYREG0                     0x14
+#define EXYNOS5_DRD_PHYREG1                     0x18
+
+#define EXYNOS5_DRD_PHYPARAM0                   0x1c
+
+#define PHYPARAM0_REF_USE_PAD                   BIT(31)
+#define PHYPARAM0_REF_LOSLEVEL_MASK             (0x1f << 26)
+#define PHYPARAM0_REF_LOSLEVEL                  (0x9 << 26)
+
+#define EXYNOS5_DRD_PHYPARAM1                   0x20
+
+#define PHYPARAM1_PCS_TXDEEMPH_MASK             (0x1f << 0)
+#define PHYPARAM1_PCS_TXDEEMPH                  (0x1c)
+
+#define EXYNOS5_DRD_PHYTERM                     0x24
+
+#define EXYNOS5_DRD_PHYTEST                     0x28
+
+#define PHYTEST_POWERDOWN_SSP                   BIT(3)
+#define PHYTEST_POWERDOWN_HSP                   BIT(2)
+
+#define EXYNOS5_DRD_PHYADP                      0x2c
+
+#define EXYNOS5_DRD_PHYUTMICLKSEL               0x30
+
+#define PHYUTMICLKSEL_UTMI_CLKSEL               BIT(2)
+
+#define EXYNOS5_DRD_PHYRESUME                   0x34
+#define EXYNOS5_DRD_LINKPORT                    0x44
+
+#define KHZ     1000
+#define MHZ     (KHZ * KHZ)
+
+enum exynos5_usbdrd_phy_id {
+        EXYNOS5_DRDPHY_UTMI,
+        EXYNOS5_DRDPHY_PIPE3,
+        EXYNOS5_DRDPHYS_NUM,
+};
+
+struct phy_usb_instance;
+struct exynos5_usbdrd_phy;
+
+struct exynos5_usbdrd_phy_config {
+        u32 id;
+        void (*phy_isol)(struct phy_usb_instance *inst, u32 on);
+        void (*phy_init)(struct exynos5_usbdrd_phy *phy_drd);
+        unsigned int (*set_refclk)(struct phy_usb_instance *inst);
+};
+
+struct exynos5_usbdrd_phy_drvdata {
+        const struct exynos5_usbdrd_phy_config *phy_cfg;
+        u32 pmu_offset_usbdrd0_phy;
+        u32 pmu_offset_usbdrd1_phy;
+};
+
+/**
+ * struct exynos5_usbdrd_phy - driver data for USB 3.0 PHY
+ * @dev: pointer to device instance of this platform device
+ * @reg_phy: usb phy controller register memory base
+ * @clk: phy clock for register access
+ * @drv_data: pointer to SoC level driver data structure
+ * @phys[]: array for 'EXYNOS5_DRDPHYS_NUM' number of PHY
+ *          instances each with its 'phy' and 'phy_cfg'.
+ * @extrefclk: frequency select settings when using 'separate
+ *             reference clocks' for SS and HS operations
+ * @ref_clk: reference clock to PHY block from which PHY's
+ *           operational clocks are derived
+ * @ref_rate: rate of above reference clock
+ */
+struct exynos5_usbdrd_phy {
+        struct device *dev;
+        void __iomem *reg_phy;
+        struct clk *clk;
+        const struct exynos5_usbdrd_phy_drvdata *drv_data;
+        struct phy_usb_instance {
+                struct phy *phy;
+                u32 index;
+                struct regmap *reg_pmu;
+                u32 pmu_offset;
+                const struct exynos5_usbdrd_phy_config *phy_cfg;
+        } phys[EXYNOS5_DRDPHYS_NUM];
+        u32 extrefclk;
+        struct clk *ref_clk;
+        struct regulator *vbus;
+};
+
+static inline
+struct exynos5_usbdrd_phy *to_usbdrd_phy(struct phy_usb_instance *inst)
+{
+        return container_of((inst), struct exynos5_usbdrd_phy,
+                            phys[(inst)->index]);
+}
+
+/*
+ * exynos5_rate_to_clk() converts the supplied clock rate to the value that
+ * can be written to the phy register.
+ */
+static unsigned int exynos5_rate_to_clk(unsigned long rate, u32 *reg)
+{
+        /* EXYNOS5_FSEL_MASK */
+
+        switch (rate) {
+        case 9600 * KHZ:
+                *reg = EXYNOS5_FSEL_9MHZ6;
+                break;
+        case 10 * MHZ:
+                *reg = EXYNOS5_FSEL_10MHZ;
+                break;
+        case 12 * MHZ:
+                *reg = EXYNOS5_FSEL_12MHZ;
+                break;
+        case 19200 * KHZ:
+                *reg = EXYNOS5_FSEL_19MHZ2;
+                break;
+        case 20 * MHZ:
+                *reg = EXYNOS5_FSEL_20MHZ;
+                break;
+        case 24 * MHZ:
+                *reg = EXYNOS5_FSEL_24MHZ;
+                break;
+        case 50 * MHZ:
+                *reg = EXYNOS5_FSEL_50MHZ;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void exynos5_usbdrd_phy_isol(struct phy_usb_instance *inst,
+                                                unsigned int on)
+{
+        unsigned int val;
+
+        if (!inst->reg_pmu)
+                return;
+
+        val = on ? 0 : EXYNOS5_PHY_ENABLE;
+
+        regmap_update_bits(inst->reg_pmu, inst->pmu_offset,
+                           EXYNOS5_PHY_ENABLE, val);
+}
+
+/*
+ * Sets the pipe3 phy's clk as EXTREFCLK (XXTI) which is internal clock
+ * from clock core. Further sets multiplier values and spread spectrum
+ * clock settings for SuperSpeed operations.
+ */
+static unsigned int
+exynos5_usbdrd_pipe3_set_refclk(struct phy_usb_instance *inst)
+{
+        static u32 reg;
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        /* restore any previous reference clock settings */
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+
+        /* Use EXTREFCLK as ref clock */
+        reg &= ~PHYCLKRST_REFCLKSEL_MASK;
+        reg |=  PHYCLKRST_REFCLKSEL_EXT_REFCLK;
+
+        /* FSEL settings corresponding to reference clock */
+        reg &= ~PHYCLKRST_FSEL_PIPE_MASK |
+                PHYCLKRST_MPLL_MULTIPLIER_MASK |
+                PHYCLKRST_SSC_REFCLKSEL_MASK;
+        switch (phy_drd->extrefclk) {
+        case EXYNOS5_FSEL_50MHZ:
+                reg |= (PHYCLKRST_MPLL_MULTIPLIER_50M_REF |
+                        PHYCLKRST_SSC_REFCLKSEL(0x00));
+                break;
+        case EXYNOS5_FSEL_24MHZ:
+                reg |= (PHYCLKRST_MPLL_MULTIPLIER_24MHZ_REF |
+                        PHYCLKRST_SSC_REFCLKSEL(0x88));
+                break;
+        case EXYNOS5_FSEL_20MHZ:
+                reg |= (PHYCLKRST_MPLL_MULTIPLIER_20MHZ_REF |
+                        PHYCLKRST_SSC_REFCLKSEL(0x00));
+                break;
+        case EXYNOS5_FSEL_19MHZ2:
+                reg |= (PHYCLKRST_MPLL_MULTIPLIER_19200KHZ_REF |
+                        PHYCLKRST_SSC_REFCLKSEL(0x88));
+                break;
+        default:
+                dev_dbg(phy_drd->dev, "unsupported ref clk\n");
+                break;
+        }
+
+        return reg;
+}
+
+/*
+ * Sets the utmi phy's clk as EXTREFCLK (XXTI) which is internal clock
+ * from clock core. Further sets the FSEL values for HighSpeed operations.
+ */
+static unsigned int
+exynos5_usbdrd_utmi_set_refclk(struct phy_usb_instance *inst)
+{
+        static u32 reg;
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        /* restore any previous reference clock settings */
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+
+        reg &= ~PHYCLKRST_REFCLKSEL_MASK;
+        reg |=  PHYCLKRST_REFCLKSEL_EXT_REFCLK;
+
+        reg &= ~PHYCLKRST_FSEL_UTMI_MASK |
+                PHYCLKRST_MPLL_MULTIPLIER_MASK |
+                PHYCLKRST_SSC_REFCLKSEL_MASK;
+        reg |= PHYCLKRST_FSEL(phy_drd->extrefclk);
+
+        return reg;
+}
+
+static void exynos5_usbdrd_pipe3_init(struct exynos5_usbdrd_phy *phy_drd)
+{
+        u32 reg;
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM1);
+        /* Set Tx De-Emphasis level */
+        reg &= ~PHYPARAM1_PCS_TXDEEMPH_MASK;
+        reg |=  PHYPARAM1_PCS_TXDEEMPH;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM1);
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+        reg &= ~PHYTEST_POWERDOWN_SSP;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+}
+
+static void exynos5_usbdrd_utmi_init(struct exynos5_usbdrd_phy *phy_drd)
+{
+        u32 reg;
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM0);
+        /* Set Loss-of-Signal Detector sensitivity */
+        reg &= ~PHYPARAM0_REF_LOSLEVEL_MASK;
+        reg |=  PHYPARAM0_REF_LOSLEVEL;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM0);
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM1);
+        /* Set Tx De-Emphasis level */
+        reg &= ~PHYPARAM1_PCS_TXDEEMPH_MASK;
+        reg |=  PHYPARAM1_PCS_TXDEEMPH;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM1);
+
+        /* UTMI Power Control */
+        writel(PHYUTMI_OTGDISABLE, phy_drd->reg_phy + EXYNOS5_DRD_PHYUTMI);
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+        reg &= ~PHYTEST_POWERDOWN_HSP;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+}
+
+static int exynos5_usbdrd_phy_init(struct phy *phy)
+{
+        int ret;
+        u32 reg;
+        struct phy_usb_instance *inst = phy_get_drvdata(phy);
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        ret = clk_prepare_enable(phy_drd->clk);
+        if (ret)
+                return ret;
+
+        /* Reset USB 3.0 PHY */
+        writel(0x0, phy_drd->reg_phy + EXYNOS5_DRD_PHYREG0);
+        writel(0x0, phy_drd->reg_phy + EXYNOS5_DRD_PHYRESUME);
+
+        /*
+         * Setting the Frame length Adj value[6:1] to default 0x20
+         * See xHCI 1.0 spec, 5.2.4
+         */
+        reg =   LINKSYSTEM_XHCI_VERSION_CONTROL |
+                LINKSYSTEM_FLADJ(0x20);
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_LINKSYSTEM);
+
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM0);
+        /* Select PHY CLK source */
+        reg &= ~PHYPARAM0_REF_USE_PAD;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYPARAM0);
+
+        /* This bit must be set for both HS and SS operations */
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYUTMICLKSEL);
+        reg |= PHYUTMICLKSEL_UTMI_CLKSEL;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYUTMICLKSEL);
+
+        /* UTMI or PIPE3 specific init */
+        inst->phy_cfg->phy_init(phy_drd);
+
+        /* reference clock settings */
+        reg = inst->phy_cfg->set_refclk(inst);
+
+                /* Digital power supply in normal operating mode */
+        reg |=  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 |
+                /* Reset the port */
+                PHYCLKRST_PORTRESET;
+
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+
+        udelay(10);
+
+        reg &= ~PHYCLKRST_PORTRESET;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+
+        clk_disable_unprepare(phy_drd->clk);
+
+        return 0;
+}
+
+static int exynos5_usbdrd_phy_exit(struct phy *phy)
+{
+        int ret;
+        u32 reg;
+        struct phy_usb_instance *inst = phy_get_drvdata(phy);
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        ret = clk_prepare_enable(phy_drd->clk);
+        if (ret)
+                return ret;
+
+        reg =   PHYUTMI_OTGDISABLE |
+                PHYUTMI_FORCESUSPEND |
+                PHYUTMI_FORCESLEEP;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYUTMI);
+
+        /* Resetting the PHYCLKRST enable bits to reduce leakage current */
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+        reg &= ~(PHYCLKRST_REF_SSP_EN |
+                 PHYCLKRST_SSC_EN |
+                 PHYCLKRST_COMMONONN);
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYCLKRST);
+
+        /* Control PHYTEST to remove leakage current */
+        reg = readl(phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+        reg |=  PHYTEST_POWERDOWN_SSP |
+                PHYTEST_POWERDOWN_HSP;
+        writel(reg, phy_drd->reg_phy + EXYNOS5_DRD_PHYTEST);
+
+        clk_disable_unprepare(phy_drd->clk);
+
+        return 0;
+}
+
+static int exynos5_usbdrd_phy_power_on(struct phy *phy)
+{
+        int ret;
+        struct phy_usb_instance *inst = phy_get_drvdata(phy);
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        dev_dbg(phy_drd->dev, "Request to power_on usbdrd_phy phy\n");
+
+        clk_prepare_enable(phy_drd->ref_clk);
+
+        /* Enable VBUS supply */
+        if (phy_drd->vbus) {
+                ret = regulator_enable(phy_drd->vbus);
+                if (ret) {
+                        dev_err(phy_drd->dev, "Failed to enable VBUS supply\n");
+                        goto fail_vbus;
+                }
+        }
+
+        /* Power-on PHY*/
+        inst->phy_cfg->phy_isol(inst, 0);
+
+        return 0;
+
+fail_vbus:
+        clk_disable_unprepare(phy_drd->ref_clk);
+
+        return ret;
+}
+
+static int exynos5_usbdrd_phy_power_off(struct phy *phy)
+{
+        struct phy_usb_instance *inst = phy_get_drvdata(phy);
+        struct exynos5_usbdrd_phy *phy_drd = to_usbdrd_phy(inst);
+
+        dev_dbg(phy_drd->dev, "Request to power_off usbdrd_phy phy\n");
+
+        /* Power-off the PHY */
+        inst->phy_cfg->phy_isol(inst, 1);
+
+        /* Disable VBUS supply */
+        if (phy_drd->vbus)
+                regulator_disable(phy_drd->vbus);
+
+        clk_disable_unprepare(phy_drd->ref_clk);
+
+        return 0;
+}
+
+static struct phy *exynos5_usbdrd_phy_xlate(struct device *dev,
+                                        struct of_phandle_args *args)
+{
+        struct exynos5_usbdrd_phy *phy_drd = dev_get_drvdata(dev);
+
+        if (WARN_ON(args->args[0] > EXYNOS5_DRDPHYS_NUM))
+                return ERR_PTR(-ENODEV);
+
+        return phy_drd->phys[args->args[0]].phy;
+}
+
+static struct phy_ops exynos5_usbdrd_phy_ops = {
+        .init           = exynos5_usbdrd_phy_init,
+        .exit           = exynos5_usbdrd_phy_exit,
+        .power_on       = exynos5_usbdrd_phy_power_on,
+        .power_off      = exynos5_usbdrd_phy_power_off,
+        .owner          = THIS_MODULE,
+};
+
+const struct exynos5_usbdrd_phy_config phy_cfg_exynos5[] = {
+        {
+                .id             = EXYNOS5_DRDPHY_UTMI,
+                .phy_isol       = exynos5_usbdrd_phy_isol,
+                .phy_init       = exynos5_usbdrd_utmi_init,
+                .set_refclk     = exynos5_usbdrd_utmi_set_refclk,
+        },
+        {
+                .id             = EXYNOS5_DRDPHY_PIPE3,
+                .phy_isol       = exynos5_usbdrd_phy_isol,
+                .phy_init       = exynos5_usbdrd_pipe3_init,
+                .set_refclk     = exynos5_usbdrd_pipe3_set_refclk,
+        },
+};
+
+const struct exynos5_usbdrd_phy_drvdata exynos5420_usbdrd_phy = {
+        .phy_cfg                = phy_cfg_exynos5,
+        .pmu_offset_usbdrd0_phy = EXYNOS5_USBDRD_PHY_CONTROL,
+        .pmu_offset_usbdrd1_phy = EXYNOS5420_USBDRD1_PHY_CONTROL,
+};
+
+const struct exynos5_usbdrd_phy_drvdata exynos5250_usbdrd_phy = {
+        .phy_cfg                = phy_cfg_exynos5,
+        .pmu_offset_usbdrd0_phy = EXYNOS5_USBDRD_PHY_CONTROL,
+};
+
+static const struct of_device_id exynos5_usbdrd_phy_of_match[] = {
+        {
+                .compatible = "samsung,exynos5250-usbdrd-phy",
+                .data = &exynos5250_usbdrd_phy
+        }, {
+                .compatible = "samsung,exynos5420-usbdrd-phy",
+                .data = &exynos5420_usbdrd_phy
+        },
+        { },
+};
+
+static int exynos5_usbdrd_phy_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct device_node *node = dev->of_node;
+        struct exynos5_usbdrd_phy *phy_drd;
+        struct phy_provider *phy_provider;
+        struct resource *res;
+        const struct of_device_id *match;
+        const struct exynos5_usbdrd_phy_drvdata *drv_data;
+        struct regmap *reg_pmu;
+        u32 pmu_offset;
+        unsigned long ref_rate;
+        int i, ret;
+        int channel;
+
+        phy_drd = devm_kzalloc(dev, sizeof(*phy_drd), GFP_KERNEL);
+        if (!phy_drd)
+                return -ENOMEM;
+
+        dev_set_drvdata(dev, phy_drd);
+        phy_drd->dev = dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        phy_drd->reg_phy = devm_ioremap_resource(dev, res);
+        if (IS_ERR(phy_drd->reg_phy))
+                return PTR_ERR(phy_drd->reg_phy);
+
+        match = of_match_node(exynos5_usbdrd_phy_of_match, pdev->dev.of_node);
+
+        drv_data = match->data;
+        phy_drd->drv_data = drv_data;
+
+        phy_drd->clk = devm_clk_get(dev, "phy");
+        if (IS_ERR(phy_drd->clk)) {
+                dev_err(dev, "Failed to get clock of phy controller\n");
+                return PTR_ERR(phy_drd->clk);
+        }
+
+        phy_drd->ref_clk = devm_clk_get(dev, "ref");
+        if (IS_ERR(phy_drd->ref_clk)) {
+                dev_err(dev, "Failed to get reference clock of usbdrd phy\n");
+                return PTR_ERR(phy_drd->ref_clk);
+        }
+        ref_rate = clk_get_rate(phy_drd->ref_clk);
+
+        ret = exynos5_rate_to_clk(ref_rate, &phy_drd->extrefclk);
+        if (ret) {
+                dev_err(phy_drd->dev, "Clock rate (%ld) not supported\n",
+                        ref_rate);
+                return ret;
+        }
+
+        reg_pmu = syscon_regmap_lookup_by_phandle(dev->of_node,
+                                                   "samsung,pmu-syscon");
+        if (IS_ERR(reg_pmu)) {
+                dev_err(dev, "Failed to lookup PMU regmap\n");
+                return PTR_ERR(reg_pmu);
+        }
+
+        /*
+         * Exynos5420 SoC has multiple channels for USB 3.0 PHY, with
+         * each having separate power control registers.
+         * 'channel' facilitates to set such registers.
+         */
+        channel = of_alias_get_id(node, "usbdrdphy");
+        if (channel < 0)
+                dev_dbg(dev, "Not a multi-controller usbdrd phy\n");
+
+        switch (channel) {
+        case 1:
+                pmu_offset = phy_drd->drv_data->pmu_offset_usbdrd1_phy;
+                break;
+        case 0:
+        default:
+                pmu_offset = phy_drd->drv_data->pmu_offset_usbdrd0_phy;
+                break;
+        }
+
+        /* Get Vbus regulator */
+        phy_drd->vbus = devm_regulator_get(dev, "vbus");
+        if (IS_ERR(phy_drd->vbus)) {
+                ret = PTR_ERR(phy_drd->vbus);
+                if (ret == -EPROBE_DEFER)
+                        return ret;
+
+                dev_warn(dev, "Failed to get VBUS supply regulator\n");
+                phy_drd->vbus = NULL;
+        }
+
+        dev_vdbg(dev, "Creating usbdrd_phy phy\n");
+
+        for (i = 0; i < EXYNOS5_DRDPHYS_NUM; i++) {
+                struct phy *phy = devm_phy_create(dev, &exynos5_usbdrd_phy_ops,
+                                                  NULL);
+                if (IS_ERR(phy)) {
+                        dev_err(dev, "Failed to create usbdrd_phy phy\n");
+                        return PTR_ERR(phy);
+                }
+
+                phy_drd->phys[i].phy = phy;
+                phy_drd->phys[i].index = i;
+                phy_drd->phys[i].reg_pmu = reg_pmu;
+                phy_drd->phys[i].pmu_offset = pmu_offset;
+                phy_drd->phys[i].phy_cfg = &drv_data->phy_cfg[i];
+                phy_set_drvdata(phy, &phy_drd->phys[i]);
+        }
+
+        phy_provider = devm_of_phy_provider_register(dev,
+                                                     exynos5_usbdrd_phy_xlate);
+        if (IS_ERR(phy_provider)) {
+                dev_err(phy_drd->dev, "Failed to register phy provider\n");
+                return PTR_ERR(phy_provider);
+        }
+
+        return 0;
+}
+
+static struct platform_driver exynos5_usb3drd_phy = {
+        .probe  = exynos5_usbdrd_phy_probe,
+        .driver = {
+                .of_match_table = exynos5_usbdrd_phy_of_match,
+                .name           = "exynos5_usb3drd_phy",
+                .owner          = THIS_MODULE,
+        }
+};
+
+module_platform_driver(exynos5_usb3drd_phy);
+MODULE_DESCRIPTION("Samsung EXYNOS5 SoCs USB 3.0 DRD controller PHY driver");
+MODULE_AUTHOR("Vivek Gautam <gautam.vivek@samsung.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:exynos5_usb3drd_phy");
diff --git a/drivers/phy/phy-exynos5250-sata.c b/drivers/phy/phy-exynos5250-sata.c
index c9361b731fa6..05689450f93b 100644
--- a/drivers/phy/phy-exynos5250-sata.c
+++ b/drivers/phy/phy-exynos5250-sata.c
@@ -246,6 +246,6 @@ static struct platform_driver exynos_sata_phy_driver = {
 module_platform_driver(exynos_sata_phy_driver);
 
 MODULE_DESCRIPTION("Samsung SerDes PHY driver");
-MODULE_LICENSE("GPL V2");
+MODULE_LICENSE("GPL v2");
 MODULE_AUTHOR("Girish K S <ks.giri@samsung.com>");
 MODULE_AUTHOR("Yuvaraj C D <yuvaraj.cd@samsung.com>");
diff --git a/drivers/phy/phy-omap-usb2.c b/drivers/phy/phy-omap-usb2.c
index a2205a841e5e..7007c11fe07d 100644
--- a/drivers/phy/phy-omap-usb2.c
+++ b/drivers/phy/phy-omap-usb2.c
@@ -275,18 +275,34 @@ static int omap_usb2_probe(struct platform_device *pdev)
         if (IS_ERR(phy_provider))
                 return PTR_ERR(phy_provider);
 
-        phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
+        phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
         if (IS_ERR(phy->wkupclk)) {
-                dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
-                return PTR_ERR(phy->wkupclk);
+                dev_warn(&pdev->dev, "unable to get wkupclk, trying old name\n");
+                phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
+                if (IS_ERR(phy->wkupclk)) {
+                        dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
+                        return PTR_ERR(phy->wkupclk);
+                } else {
+                        dev_warn(&pdev->dev,
+                                 "found usb_phy_cm_clk32k, please fix DTS\n");
+                }
         }
         clk_prepare(phy->wkupclk);
 
-        phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
-        if (IS_ERR(phy->optclk))
-                dev_vdbg(&pdev->dev, "unable to get refclk960m\n");
-        else
+        phy->optclk = devm_clk_get(phy->dev, "refclk");
+        if (IS_ERR(phy->optclk)) {
+                dev_dbg(&pdev->dev, "unable to get refclk, trying old name\n");
+                phy->optclk = devm_clk_get(phy->dev, "usb_otg_ss_refclk960m");
+                if (IS_ERR(phy->optclk)) {
+                        dev_dbg(&pdev->dev,
+                                "unable to get usb_otg_ss_refclk960m\n");
+                } else {
+                        dev_warn(&pdev->dev,
+                                 "found usb_otg_ss_refclk960m, please fix DTS\n");
+                }
+        } else {
                 clk_prepare(phy->optclk);
+        }
 
         usb_add_phy_dev(&phy->phy);
 
diff --git a/drivers/phy/phy-sun4i-usb.c b/drivers/phy/phy-sun4i-usb.c
index e6e6c4ba7145..115d8d5190d5 100644
--- a/drivers/phy/phy-sun4i-usb.c
+++ b/drivers/phy/phy-sun4i-usb.c
@@ -61,7 +61,6 @@
 #define MAX_PHYS                        3
 
 struct sun4i_usb_phy_data {
-        struct clk *clk;
         void __iomem *base;
         struct mutex mutex;
         int num_phys;
@@ -71,6 +70,7 @@ struct sun4i_usb_phy_data {
                 void __iomem *pmu;
                 struct regulator *vbus;
                 struct reset_control *reset;
+                struct clk *clk;
                 int index;
         } phys[MAX_PHYS];
 };
@@ -146,13 +146,13 @@ static int sun4i_usb_phy_init(struct phy *_phy)
         struct sun4i_usb_phy_data *data = to_sun4i_usb_phy_data(phy);
         int ret;
 
-        ret = clk_prepare_enable(data->clk);
+        ret = clk_prepare_enable(phy->clk);
         if (ret)
                 return ret;
 
         ret = reset_control_deassert(phy->reset);
         if (ret) {
-                clk_disable_unprepare(data->clk);
+                clk_disable_unprepare(phy->clk);
                 return ret;
         }
 
@@ -170,11 +170,10 @@ static int sun4i_usb_phy_init(struct phy *_phy)
 static int sun4i_usb_phy_exit(struct phy *_phy)
 {
         struct sun4i_usb_phy *phy = phy_get_drvdata(_phy);
-        struct sun4i_usb_phy_data *data = to_sun4i_usb_phy_data(phy);
 
         sun4i_usb_phy_passby(phy, 0);
         reset_control_assert(phy->reset);
-        clk_disable_unprepare(data->clk);
+        clk_disable_unprepare(phy->clk);
 
         return 0;
 }
@@ -224,13 +223,9 @@ static int sun4i_usb_phy_probe(struct platform_device *pdev)
         struct sun4i_usb_phy_data *data;
         struct device *dev = &pdev->dev;
         struct device_node *np = dev->of_node;
-        void __iomem *pmu = NULL;
         struct phy_provider *phy_provider;
-        struct reset_control *reset;
-        struct regulator *vbus;
+        bool dedicated_clocks;
         struct resource *res;
-        struct phy *phy;
-        char name[16];
         int i;
 
         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
@@ -249,55 +244,64 @@ static int sun4i_usb_phy_probe(struct platform_device *pdev)
         else
                 data->disc_thresh = 2;
 
+        if (of_device_is_compatible(np, "allwinner,sun6i-a31-usb-phy"))
+                dedicated_clocks = true;
+        else
+                dedicated_clocks = false;
+
         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "phy_ctrl");
         data->base = devm_ioremap_resource(dev, res);
         if (IS_ERR(data->base))
                 return PTR_ERR(data->base);
 
-        data->clk = devm_clk_get(dev, "usb_phy");
-        if (IS_ERR(data->clk)) {
-                dev_err(dev, "could not get usb_phy clock\n");
-                return PTR_ERR(data->clk);
-        }
-
         /* Skip 0, 0 is the phy for otg which is not yet supported. */
         for (i = 1; i < data->num_phys; i++) {
+                struct sun4i_usb_phy *phy = data->phys + i;
+                char name[16];
+
                 snprintf(name, sizeof(name), "usb%d_vbus", i);
-                vbus = devm_regulator_get_optional(dev, name);
-                if (IS_ERR(vbus)) {
-                        if (PTR_ERR(vbus) == -EPROBE_DEFER)
+                phy->vbus = devm_regulator_get_optional(dev, name);
+                if (IS_ERR(phy->vbus)) {
+                        if (PTR_ERR(phy->vbus) == -EPROBE_DEFER)
                                 return -EPROBE_DEFER;
-                        vbus = NULL;
+                        phy->vbus = NULL;
+                }
+
+                if (dedicated_clocks)
+                        snprintf(name, sizeof(name), "usb%d_phy", i);
+                else
+                        strlcpy(name, "usb_phy", sizeof(name));
+
+                phy->clk = devm_clk_get(dev, name);
+                if (IS_ERR(phy->clk)) {
+                        dev_err(dev, "failed to get clock %s\n", name);
+                        return PTR_ERR(phy->clk);
                 }
 
                 snprintf(name, sizeof(name), "usb%d_reset", i);
-                reset = devm_reset_control_get(dev, name);
-                if (IS_ERR(reset)) {
+                phy->reset = devm_reset_control_get(dev, name);
+                if (IS_ERR(phy->reset)) {
                         dev_err(dev, "failed to get reset %s\n", name);
-                        return PTR_ERR(reset);
+                        return PTR_ERR(phy->reset);
                 }
 
                 if (i) { /* No pmu for usbc0 */
                         snprintf(name, sizeof(name), "pmu%d", i);
                         res = platform_get_resource_byname(pdev,
                                                         IORESOURCE_MEM, name);
-                        pmu = devm_ioremap_resource(dev, res);
-                        if (IS_ERR(pmu))
-                                return PTR_ERR(pmu);
+                        phy->pmu = devm_ioremap_resource(dev, res);
+                        if (IS_ERR(phy->pmu))
+                                return PTR_ERR(phy->pmu);
                 }
 
-                phy = devm_phy_create(dev, &sun4i_usb_phy_ops, NULL);
-                if (IS_ERR(phy)) {
+                phy->phy = devm_phy_create(dev, &sun4i_usb_phy_ops, NULL);
+                if (IS_ERR(phy->phy)) {
                         dev_err(dev, "failed to create PHY %d\n", i);
-                        return PTR_ERR(phy);
+                        return PTR_ERR(phy->phy);
                 }
 
-                data->phys[i].phy = phy;
-                data->phys[i].pmu = pmu;
-                data->phys[i].vbus = vbus;
-                data->phys[i].reset = reset;
-                data->phys[i].index = i;
-                phy_set_drvdata(phy, &data->phys[i]);
+                phy->index = i;
+                phy_set_drvdata(phy->phy, &data->phys[i]);
         }
 
         dev_set_drvdata(dev, data);
@@ -311,6 +315,7 @@ static int sun4i_usb_phy_probe(struct platform_device *pdev)
 static const struct of_device_id sun4i_usb_phy_of_match[] = {
         { .compatible = "allwinner,sun4i-a10-usb-phy" },
         { .compatible = "allwinner,sun5i-a13-usb-phy" },
+        { .compatible = "allwinner,sun6i-a31-usb-phy" },
         { .compatible = "allwinner,sun7i-a20-usb-phy" },
         { },
 };
diff --git a/drivers/staging/media/lirc/lirc_igorplugusb.c b/drivers/staging/media/lirc/lirc_igorplugusb.c
index f508a1372ad8..44b0d0766084 100644
--- a/drivers/staging/media/lirc/lirc_igorplugusb.c
+++ b/drivers/staging/media/lirc/lirc_igorplugusb.c
@@ -60,19 +60,6 @@
 #define DRIVER_DESC             "Igorplug USB remote driver for LIRC"
 #define DRIVER_NAME             "lirc_igorplugusb"
 
-/* debugging support */
-#ifdef CONFIG_USB_DEBUG
-static bool debug = true;
-#else
-static bool debug;
-#endif
-
-#define dprintk(fmt, args...)                                   \
-        do {                                                    \
-                if (debug)                                      \
-                        printk(KERN_DEBUG fmt, ## args);        \
-        } while (0)
-
 /* One mode2 pulse/space has 4 bytes. */
 #define CODE_LENGTH          sizeof(int)
 
@@ -237,7 +224,7 @@ static int unregister_from_lirc(struct igorplug *ir)
                 return -EINVAL;
         }
 
-        dprintk(DRIVER_NAME "[%d]: calling lirc_unregister_driver\n", devnum);
+        dev_dbg(&ir->usbdev->dev, "calling lirc_unregister_driver\n");
         lirc_unregister_driver(d->minor);
 
         return devnum;
@@ -252,7 +239,7 @@ static int set_use_inc(void *data)
                 return -EIO;
         }
 
-        dprintk(DRIVER_NAME "[%d]: set use inc\n", ir->devnum);
+        dev_dbg(&ir->usbdev->dev, "set use inc\n");
 
         if (!ir->usbdev)
                 return -ENODEV;
@@ -269,7 +256,7 @@ static void set_use_dec(void *data)
                 return;
         }
 
-        dprintk(DRIVER_NAME "[%d]: set use dec\n", ir->devnum);
+        dev_dbg(&ir->usbdev->dev, "set use dec\n");
 }
 
 static void send_fragment(struct igorplug *ir, struct lirc_buffer *buf,
@@ -321,7 +308,7 @@ static int igorplugusb_remote_poll(void *data, struct lirc_buffer *buf)
                 if (ret < DEVICE_HEADERLEN)
                         return -ENODATA;
 
-                dprintk(DRIVER_NAME ": Got %d bytes. Header: %*ph\n",
+                dev_dbg(&ir->usbdev->dev, "Got %d bytes. Header: %*ph\n",
                         ret, 3, ir->buf_in);
 
                 do_gettimeofday(&now);
@@ -385,7 +372,7 @@ static int igorplugusb_remote_probe(struct usb_interface *intf,
         char buf[63], name[128] = "";
         int ret;
 
-        dprintk(DRIVER_NAME ": usb probe called.\n");
+        dev_dbg(&intf->dev, "%s: usb probe called.\n", __func__);
 
         dev = interface_to_usbdev(intf);
 
@@ -405,8 +392,8 @@ static int igorplugusb_remote_probe(struct usb_interface *intf,
         devnum = dev->devnum;
         maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
 
-        dprintk(DRIVER_NAME "[%d]: bytes_in_key=%zu maxp=%d\n",
-                devnum, CODE_LENGTH, maxp);
+        dev_dbg(&intf->dev, "%s: bytes_in_key=%zu maxp=%d\n",
+                __func__, CODE_LENGTH, maxp);
 
         ir = devm_kzalloc(&intf->dev, sizeof(*ir), GFP_KERNEL);
         if (!ir)
@@ -525,6 +512,3 @@ MODULE_DEVICE_TABLE(usb, igorplugusb_remote_id_table);
 
 module_param(sample_rate, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(sample_rate, "Sampling rate in Hz (default: 100)");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/staging/usbip/userspace/README b/drivers/staging/usbip/userspace/README
index f528ba462b5f..831f49fea3ce 100644
--- a/drivers/staging/usbip/userspace/README
+++ b/drivers/staging/usbip/userspace/README
@@ -195,7 +195,6 @@ Detach the imported device:
     - Shutdown firewall.
         - usbip now uses TCP port 3240.
     - Disable SELinux.
-    - If possible, compile your kernel with CONFIG_USB_DEBUG flag and try again.
     - Check the kernel and daemon messages.
 
 
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index 1ae2bf39d84b..3cba892b83a2 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -28,6 +28,7 @@ obj-$(CONFIG_USB_IMX21_HCD)	+= host/
 obj-$(CONFIG_USB_FSL_MPH_DR_OF) += host/
 obj-$(CONFIG_USB_FUSBH200_HCD)  += host/
 obj-$(CONFIG_USB_FOTG210_HCD)   += host/
+obj-$(CONFIG_USB_MAX3421_HCD)   += host/
 
 obj-$(CONFIG_USB_C67X00_HCD)    += c67x00/
 
@@ -58,4 +59,4 @@ obj-$(CONFIG_USB_CHIPIDEA)	+= chipidea/
 obj-$(CONFIG_USB_RENESAS_USBHS) += renesas_usbhs/
 obj-$(CONFIG_USB_GADGET)        += gadget/
 
-obj-$(CONFIG_USB_COMMON)        += usb-common.o
+obj-$(CONFIG_USB_COMMON)        += common/
diff --git a/drivers/usb/chipidea/Makefile b/drivers/usb/chipidea/Makefile
index 480bd4d5710a..2f099c7df7b5 100644
--- a/drivers/usb/chipidea/Makefile
+++ b/drivers/usb/chipidea/Makefile
@@ -6,6 +6,7 @@ ci_hdrc-y				:= core.o otg.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_UDC)      += udc.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_HOST)     += host.o
 ci_hdrc-$(CONFIG_USB_CHIPIDEA_DEBUG)    += debug.o
+ci_hdrc-$(CONFIG_USB_OTG_FSM)           += otg_fsm.o
 
 # Glue/Bridge layers go here
 
diff --git a/drivers/usb/chipidea/bits.h b/drivers/usb/chipidea/bits.h
index 83d06c1455b7..ca57e3dcd3d5 100644
--- a/drivers/usb/chipidea/bits.h
+++ b/drivers/usb/chipidea/bits.h
@@ -44,9 +44,14 @@
 #define DEVICEADDR_USBADR     (0x7FUL << 25)
 
 /* PORTSC */
+#define PORTSC_CCS            BIT(0)
+#define PORTSC_CSC            BIT(1)
+#define PORTSC_PEC            BIT(3)
+#define PORTSC_OCC            BIT(5)
 #define PORTSC_FPR            BIT(6)
 #define PORTSC_SUSP           BIT(7)
 #define PORTSC_HSP            BIT(9)
+#define PORTSC_PP             BIT(12)
 #define PORTSC_PTC            (0x0FUL << 16)
 #define PORTSC_PHCD(d)        ((d) ? BIT(22) : BIT(23))
 /* PTS and PTW for non lpm version only */
@@ -56,6 +61,9 @@
 #define PORTSC_PTW            BIT(28)
 #define PORTSC_STS            BIT(29)
 
+#define PORTSC_W1C_BITS                                         \
+        (PORTSC_CSC | PORTSC_PEC | PORTSC_OCC)
+
 /* DEVLC */
 #define DEVLC_PFSC            BIT(23)
 #define DEVLC_PSPD            (0x03UL << 25)
@@ -72,6 +80,8 @@
 
 /* OTGSC */
 #define OTGSC_IDPU            BIT(5)
+#define OTGSC_HADP            BIT(6)
+#define OTGSC_HABA            BIT(7)
 #define OTGSC_ID              BIT(8)
 #define OTGSC_AVV             BIT(9)
 #define OTGSC_ASV             BIT(10)
diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
index e206406ae1d9..9563cb56d564 100644
--- a/drivers/usb/chipidea/ci.h
+++ b/drivers/usb/chipidea/ci.h
@@ -17,6 +17,7 @@
 #include <linux/irqreturn.h>
 #include <linux/usb.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg-fsm.h>
 
 /******************************************************************************
  * DEFINE
@@ -139,6 +140,8 @@ struct hw_bank {
  * @roles: array of supported roles for this controller
  * @role: current role
  * @is_otg: if the device is otg-capable
+ * @fsm: otg finite state machine
+ * @fsm_timer: pointer to timer list of otg fsm
  * @work: work for role changing
  * @wq: workqueue thread
  * @qh_pool: allocation pool for queue heads
@@ -174,6 +177,8 @@ struct ci_hdrc {
         struct ci_role_driver           *roles[CI_ROLE_END];
         enum ci_role                    role;
         bool                            is_otg;
+        struct otg_fsm                  fsm;
+        struct ci_otg_fsm_timer_list    *fsm_timer;
         struct work_struct              work;
         struct workqueue_struct         *wq;
 
@@ -319,6 +324,24 @@ static inline u32 hw_test_and_write(struct ci_hdrc *ci, enum ci_hw_regs reg,
         return (val & mask) >> __ffs(mask);
 }
 
+/**
+ * ci_otg_is_fsm_mode: runtime check if otg controller
+ * is in otg fsm mode.
+ */
+static inline bool ci_otg_is_fsm_mode(struct ci_hdrc *ci)
+{
+#ifdef CONFIG_USB_OTG_FSM
+        return ci->is_otg && ci->roles[CI_ROLE_HOST] &&
+                                        ci->roles[CI_ROLE_GADGET];
+#else
+        return false;
+#endif
+}
+
+u32 hw_read_intr_enable(struct ci_hdrc *ci);
+
+u32 hw_read_intr_status(struct ci_hdrc *ci);
+
 int hw_device_reset(struct ci_hdrc *ci, u32 mode);
 
 int hw_port_test_set(struct ci_hdrc *ci, u8 mode);
diff --git a/drivers/usb/chipidea/ci_hdrc_msm.c b/drivers/usb/chipidea/ci_hdrc_msm.c
index 2d51d852b474..d72b9d2de2c5 100644
--- a/drivers/usb/chipidea/ci_hdrc_msm.c
+++ b/drivers/usb/chipidea/ci_hdrc_msm.c
@@ -47,6 +47,7 @@ static void ci_hdrc_msm_notify_event(struct ci_hdrc *ci, unsigned event)
 
 static struct ci_hdrc_platform_data ci_hdrc_msm_platdata = {
         .name                   = "ci_hdrc_msm",
+        .capoffset              = DEF_CAPOFFSET,
         .flags                  = CI_HDRC_REGS_SHARED |
                                   CI_HDRC_REQUIRE_TRANSCEIVER |
                                   CI_HDRC_DISABLE_STREAMING,
@@ -57,9 +58,21 @@ static struct ci_hdrc_platform_data ci_hdrc_msm_platdata = {
 static int ci_hdrc_msm_probe(struct platform_device *pdev)
 {
         struct platform_device *plat_ci;
+        struct usb_phy *phy;
 
         dev_dbg(&pdev->dev, "ci_hdrc_msm_probe\n");
 
+        /*
+         * OTG(PHY) driver takes care of PHY initialization, clock management,
+         * powering up VBUS, mapping of registers address space and power
+         * management.
+         */
+        phy = devm_usb_get_phy_by_phandle(&pdev->dev, "usb-phy", 0);
+        if (IS_ERR(phy))
+                return PTR_ERR(phy);
+
+        ci_hdrc_msm_platdata.phy = phy;
+
         plat_ci = ci_hdrc_add_device(&pdev->dev,
                                 pdev->resource, pdev->num_resources,
                                 &ci_hdrc_msm_platdata);
@@ -86,10 +99,19 @@ static int ci_hdrc_msm_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id msm_ci_dt_match[] = {
+        { .compatible = "qcom,ci-hdrc", },
+        { }
+};
+MODULE_DEVICE_TABLE(of, msm_ci_dt_match);
+
 static struct platform_driver ci_hdrc_msm_driver = {
         .probe = ci_hdrc_msm_probe,
         .remove = ci_hdrc_msm_remove,
-        .driver = { .name = "msm_hsusb", },
+        .driver = {
+                .name = "msm_hsusb",
+                .of_match_table = msm_ci_dt_match,
+        },
 };
 
 module_platform_driver(ci_hdrc_msm_driver);
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 1cd5d0ba587c..619d13e29995 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -23,7 +23,7 @@
  * - BUS:    bus glue code, bus abstraction layer
  *
  * Compile Options
- * - CONFIG_USB_GADGET_DEBUG_FILES: enable debug facilities
+ * - CONFIG_USB_CHIPIDEA_DEBUG: enable debug facilities
  * - STALL_IN:  non-empty bulk-in pipes cannot be halted
  *              if defined mass storage compliance succeeds but with warnings
  *              => case 4: Hi >  Dn
@@ -42,10 +42,6 @@
  * - Not Supported: 15 & 16 (ISO)
  *
  * TODO List
- * - OTG
- * - Interrupt Traffic
- * - GET_STATUS(device) - always reports 0
- * - Gadget API (majority of optional features)
  * - Suspend & Remote Wakeup
  */
 #include <linux/delay.h>
@@ -74,6 +70,7 @@
 #include "host.h"
 #include "debug.h"
 #include "otg.h"
+#include "otg_fsm.h"
 
 /* Controller register map */
 static const u8 ci_regs_nolpm[] = {
@@ -140,6 +137,26 @@ static int hw_alloc_regmap(struct ci_hdrc *ci, bool is_lpm)
 }
 
 /**
+ * hw_read_intr_enable: returns interrupt enable register
+ *
+ * This function returns register data
+ */
+u32 hw_read_intr_enable(struct ci_hdrc *ci)
+{
+        return hw_read(ci, OP_USBINTR, ~0);
+}
+
+/**
+ * hw_read_intr_status: returns interrupt status register
+ *
+ * This function returns register data
+ */
+u32 hw_read_intr_status(struct ci_hdrc *ci)
+{
+        return hw_read(ci, OP_USBSTS, ~0);
+}
+
+/**
  * hw_port_test_set: writes port test mode (execute without interruption)
  * @mode: new value
  *
@@ -179,11 +196,10 @@ static void ci_hdrc_enter_lpm(struct ci_hdrc *ci, bool enable)
                 hw_write(ci, reg, PORTSC_PHCD(ci->hw_bank.lpm),
                                 0);
                 /* 
-                 * The controller needs at least 1ms to reflect
-                 * PHY's status, the PHY also needs some time (less
+                 * the PHY needs some time (less
                  * than 1ms) to leave low power mode.
                  */
-                usleep_range(1500, 2000);
+                usleep_range(1000, 1100);
         }
 }
 
@@ -392,8 +408,14 @@ static irqreturn_t ci_irq(int irq, void *data)
         irqreturn_t ret = IRQ_NONE;
         u32 otgsc = 0;
 
-        if (ci->is_otg)
-                otgsc = hw_read(ci, OP_OTGSC, ~0);
+        if (ci->is_otg) {
+                otgsc = hw_read_otgsc(ci, ~0);
+                if (ci_otg_is_fsm_mode(ci)) {
+                        ret = ci_otg_fsm_irq(ci);
+                        if (ret == IRQ_HANDLED)
+                                return ret;
+                }
+        }
 
         /*
          * Handle id change interrupt, it indicates device/host function
@@ -401,9 +423,9 @@ static irqreturn_t ci_irq(int irq, void *data)
          */
         if (ci->is_otg && (otgsc & OTGSC_IDIE) && (otgsc & OTGSC_IDIS)) {
                 ci->id_event = true;
-                ci_clear_otg_interrupt(ci, OTGSC_IDIS);
-                disable_irq_nosync(ci->irq);
-                queue_work(ci->wq, &ci->work);
+                /* Clear ID change irq status */
+                hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS);
+                ci_otg_queue_work(ci);
                 return IRQ_HANDLED;
         }
 
@@ -413,9 +435,9 @@ static irqreturn_t ci_irq(int irq, void *data)
          */
         if (ci->is_otg && (otgsc & OTGSC_BSVIE) && (otgsc & OTGSC_BSVIS)) {
                 ci->b_sess_valid_event = true;
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                disable_irq_nosync(ci->irq);
-                queue_work(ci->wq, &ci->work);
+                /* Clear BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS);
+                ci_otg_queue_work(ci);
                 return IRQ_HANDLED;
         }
 
@@ -533,11 +555,8 @@ static void ci_get_otg_capable(struct ci_hdrc *ci)
                 ci->is_otg = (hw_read(ci, CAP_DCCPARAMS,
                                 DCCPARAMS_DC | DCCPARAMS_HC)
                                         == (DCCPARAMS_DC | DCCPARAMS_HC));
-        if (ci->is_otg) {
+        if (ci->is_otg)
                 dev_dbg(ci->dev, "It is OTG capable controller\n");
-                ci_disable_otg_interrupt(ci, OTGSC_INT_EN_BITS);
-                ci_clear_otg_interrupt(ci, OTGSC_INT_STATUS_BITS);
-        }
 }
 
 static int ci_hdrc_probe(struct platform_device *pdev)
@@ -599,6 +618,13 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ret) {
                 dev_err(dev, "unable to init phy: %d\n", ret);
                 return ret;
+        } else {
+                /* 
+                 * The delay to sync PHY's status, the maximum delay is
+                 * 2ms since the otgsc uses 1ms timer to debounce the
+                 * PHY's input
+                 */
+                usleep_range(2000, 2500);
         }
 
         ci->hw_bank.phys = res->start;
@@ -633,6 +659,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         }
 
         if (ci->is_otg) {
+                /* Disable and clear all OTG irq */
+                hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
+                                                        OTGSC_INT_STATUS_BITS);
                 ret = ci_hdrc_otg_init(ci);
                 if (ret) {
                         dev_err(dev, "init otg fails, ret = %d\n", ret);
@@ -642,13 +671,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
 
         if (ci->roles[CI_ROLE_HOST] && ci->roles[CI_ROLE_GADGET]) {
                 if (ci->is_otg) {
-                        /*
-                         * ID pin needs 1ms debouce time,
-                         * we delay 2ms for safe.
-                         */
-                        mdelay(2);
                         ci->role = ci_otg_role(ci);
-                        ci_enable_otg_interrupt(ci, OTGSC_IDIE);
+                        /* Enable ID change irq */
+                        hw_write_otgsc(ci, OTGSC_IDIE, OTGSC_IDIE);
                 } else {
                         /*
                          * If the controller is not OTG capable, but support
@@ -667,10 +692,13 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ci->role == CI_ROLE_GADGET)
                 ci_handle_vbus_change(ci);
 
-        ret = ci_role_start(ci, ci->role);
-        if (ret) {
-                dev_err(dev, "can't start %s role\n", ci_role(ci)->name);
-                goto stop;
+        if (!ci_otg_is_fsm_mode(ci)) {
+                ret = ci_role_start(ci, ci->role);
+                if (ret) {
+                        dev_err(dev, "can't start %s role\n",
+                                                ci_role(ci)->name);
+                        goto stop;
+                }
         }
 
         platform_set_drvdata(pdev, ci);
@@ -679,6 +707,9 @@ static int ci_hdrc_probe(struct platform_device *pdev)
         if (ret)
                 goto stop;
 
+        if (ci_otg_is_fsm_mode(ci))
+                ci_hdrc_otg_fsm_start(ci);
+
         ret = dbg_create_files(ci);
         if (!ret)
                 return 0;
@@ -711,6 +742,7 @@ static struct platform_driver ci_hdrc_driver = {
         .remove = ci_hdrc_remove,
         .driver = {
                 .name   = "ci_hdrc",
+                .owner  = THIS_MODULE,
         },
 };
 
diff --git a/drivers/usb/chipidea/debug.c b/drivers/usb/chipidea/debug.c
index 96d899aee473..7cccab6ff308 100644
--- a/drivers/usb/chipidea/debug.c
+++ b/drivers/usb/chipidea/debug.c
@@ -7,11 +7,15 @@
 #include <linux/uaccess.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/phy.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/otg-fsm.h>
 
 #include "ci.h"
 #include "udc.h"
 #include "bits.h"
 #include "debug.h"
+#include "otg.h"
 
 /**
  * ci_device_show: prints information about device capabilities and status
@@ -204,6 +208,80 @@ static const struct file_operations ci_requests_fops = {
         .release        = single_release,
 };
 
+int ci_otg_show(struct seq_file *s, void *unused)
+{
+        struct ci_hdrc *ci = s->private;
+        struct otg_fsm *fsm;
+
+        if (!ci || !ci_otg_is_fsm_mode(ci))
+                return 0;
+
+        fsm = &ci->fsm;
+
+        /* ------ State ----- */
+        seq_printf(s, "OTG state: %s\n\n",
+                usb_otg_state_string(ci->transceiver->state));
+
+        /* ------ State Machine Variables ----- */
+        seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop);
+
+        seq_printf(s, "a_bus_req: %d\n", fsm->a_bus_req);
+
+        seq_printf(s, "a_srp_det: %d\n", fsm->a_srp_det);
+
+        seq_printf(s, "a_vbus_vld: %d\n", fsm->a_vbus_vld);
+
+        seq_printf(s, "b_conn: %d\n", fsm->b_conn);
+
+        seq_printf(s, "adp_change: %d\n", fsm->adp_change);
+
+        seq_printf(s, "power_up: %d\n", fsm->power_up);
+
+        seq_printf(s, "a_bus_resume: %d\n", fsm->a_bus_resume);
+
+        seq_printf(s, "a_bus_suspend: %d\n", fsm->a_bus_suspend);
+
+        seq_printf(s, "a_conn: %d\n", fsm->a_conn);
+
+        seq_printf(s, "b_bus_req: %d\n", fsm->b_bus_req);
+
+        seq_printf(s, "b_bus_suspend: %d\n", fsm->b_bus_suspend);
+
+        seq_printf(s, "b_se0_srp: %d\n", fsm->b_se0_srp);
+
+        seq_printf(s, "b_ssend_srp: %d\n", fsm->b_ssend_srp);
+
+        seq_printf(s, "b_sess_vld: %d\n", fsm->b_sess_vld);
+
+        seq_printf(s, "b_srp_done: %d\n", fsm->b_srp_done);
+
+        seq_printf(s, "drv_vbus: %d\n", fsm->drv_vbus);
+
+        seq_printf(s, "loc_conn: %d\n", fsm->loc_conn);
+
+        seq_printf(s, "loc_sof: %d\n", fsm->loc_sof);
+
+        seq_printf(s, "adp_prb: %d\n", fsm->adp_prb);
+
+        seq_printf(s, "id: %d\n", fsm->id);
+
+        seq_printf(s, "protocol: %d\n", fsm->protocol);
+
+        return 0;
+}
+
+static int ci_otg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ci_otg_show, inode->i_private);
+}
+
+static const struct file_operations ci_otg_fops = {
+        .open                   = ci_otg_open,
+        .read                   = seq_read,
+        .llseek                 = seq_lseek,
+        .release                = single_release,
+};
+
 static int ci_role_show(struct seq_file *s, void *data)
 {
         struct ci_hdrc *ci = s->private;
@@ -253,6 +331,50 @@ static const struct file_operations ci_role_fops = {
         .release        = single_release,
 };
 
+int ci_registers_show(struct seq_file *s, void *unused)
+{
+        struct ci_hdrc *ci = s->private;
+        u32 tmp_reg;
+
+        if (!ci)
+                return 0;
+
+        /* ------ Registers ----- */
+        tmp_reg = hw_read_intr_enable(ci);
+        seq_printf(s, "USBINTR reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read_intr_status(ci);
+        seq_printf(s, "USBSTS reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_USBMODE, ~0);
+        seq_printf(s, "USBMODE reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_USBCMD, ~0);
+        seq_printf(s, "USBCMD reg: %08x\n", tmp_reg);
+
+        tmp_reg = hw_read(ci, OP_PORTSC, ~0);
+        seq_printf(s, "PORTSC reg: %08x\n", tmp_reg);
+
+        if (ci->is_otg) {
+                tmp_reg = hw_read_otgsc(ci, ~0);
+                seq_printf(s, "OTGSC reg: %08x\n", tmp_reg);
+        }
+
+        return 0;
+}
+
+static int ci_registers_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ci_registers_show, inode->i_private);
+}
+
+static const struct file_operations ci_registers_fops = {
+        .open                   = ci_registers_open,
+        .read                   = seq_read,
+        .llseek                 = seq_lseek,
+        .release                = single_release,
+};
+
 /**
  * dbg_create_files: initializes the attribute interface
  * @ci: device
@@ -287,8 +409,21 @@ int dbg_create_files(struct ci_hdrc *ci)
         if (!dent)
                 goto err;
 
+        if (ci_otg_is_fsm_mode(ci)) {
+                dent = debugfs_create_file("otg", S_IRUGO, ci->debugfs, ci,
+                                        &ci_otg_fops);
+                if (!dent)
+                        goto err;
+        }
+
         dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
                                    &ci_role_fops);
+        if (!dent)
+                goto err;
+
+        dent = debugfs_create_file("registers", S_IRUGO, ci->debugfs, ci,
+                                &ci_registers_fops);
+
         if (dent)
                 return 0;
 err:
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index a8ac6c16dac9..a93d950e9468 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -67,7 +67,11 @@ static int host_start(struct ci_hdrc *ci)
         ehci->has_tdi_phy_lpm = ci->hw_bank.lpm;
         ehci->imx28_write_fix = ci->imx28_write_fix;
 
-        if (ci->platdata->reg_vbus) {
+        /*
+         * vbus is always on if host is not in OTG FSM mode,
+         * otherwise should be controlled by OTG FSM
+         */
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci)) {
                 ret = regulator_enable(ci->platdata->reg_vbus);
                 if (ret) {
                         dev_err(ci->dev,
@@ -78,10 +82,17 @@ static int host_start(struct ci_hdrc *ci)
         }
 
         ret = usb_add_hcd(hcd, 0, 0);
-        if (ret)
+        if (ret) {
                 goto disable_reg;
-        else
+        } else {
+                struct usb_otg *otg = ci->transceiver->otg;
+
                 ci->hcd = hcd;
+                if (otg) {
+                        otg->host = &hcd->self;
+                        hcd->self.otg_port = 1;
+                }
+        }
 
         if (ci->platdata->flags & CI_HDRC_DISABLE_STREAMING)
                 hw_write(ci, OP_USBMODE, USBMODE_CI_SDIS, USBMODE_CI_SDIS);
@@ -89,7 +100,7 @@ static int host_start(struct ci_hdrc *ci)
         return ret;
 
 disable_reg:
-        if (ci->platdata->reg_vbus)
+        if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci))
                 regulator_disable(ci->platdata->reg_vbus);
 
 put_hcd:
@@ -105,7 +116,7 @@ static void host_stop(struct ci_hdrc *ci)
         if (hcd) {
                 usb_remove_hcd(hcd);
                 usb_put_hcd(hcd);
-                if (ci->platdata->reg_vbus)
+                if (ci->platdata->reg_vbus && !ci_otg_is_fsm_mode(ci))
                         regulator_disable(ci->platdata->reg_vbus);
         }
 }
diff --git a/drivers/usb/chipidea/otg.c b/drivers/usb/chipidea/otg.c
index 39bd7ec8bf75..a048b08b9d4d 100644
--- a/drivers/usb/chipidea/otg.c
+++ b/drivers/usb/chipidea/otg.c
@@ -11,8 +11,8 @@
  */
 
 /*
- * This file mainly handles otgsc register, it may include OTG operation
- * in the future.
+ * This file mainly handles otgsc register, OTG fsm operations for HNP and SRP
+ * are also included.
  */
 
 #include <linux/usb/otg.h>
@@ -22,6 +22,26 @@
 #include "ci.h"
 #include "bits.h"
 #include "otg.h"
+#include "otg_fsm.h"
+
+/**
+ * hw_read_otgsc returns otgsc register bits value.
+ * @mask: bitfield mask
+ */
+u32 hw_read_otgsc(struct ci_hdrc *ci, u32 mask)
+{
+        return hw_read(ci, OP_OTGSC, mask);
+}
+
+/**
+ * hw_write_otgsc updates target bits of OTGSC register.
+ * @mask: bitfield mask
+ * @data: to be written
+ */
+void hw_write_otgsc(struct ci_hdrc *ci, u32 mask, u32 data)
+{
+        hw_write(ci, OP_OTGSC, mask | OTGSC_INT_STATUS_BITS, data);
+}
 
 /**
  * ci_otg_role - pick role based on ID pin state
@@ -29,8 +49,7 @@
  */
 enum ci_role ci_otg_role(struct ci_hdrc *ci)
 {
-        u32 sts = hw_read(ci, OP_OTGSC, ~0);
-        enum ci_role role = sts & OTGSC_ID
+        enum ci_role role = hw_read_otgsc(ci, OTGSC_ID)
                 ? CI_ROLE_GADGET
                 : CI_ROLE_HOST;
 
@@ -39,14 +58,10 @@ enum ci_role ci_otg_role(struct ci_hdrc *ci)
 
 void ci_handle_vbus_change(struct ci_hdrc *ci)
 {
-        u32 otgsc;
-
         if (!ci->is_otg)
                 return;
 
-        otgsc = hw_read(ci, OP_OTGSC, ~0);
-
-        if (otgsc & OTGSC_BSV)
+        if (hw_read_otgsc(ci, OTGSC_BSV))
                 usb_gadget_vbus_connect(&ci->gadget);
         else
                 usb_gadget_vbus_disconnect(&ci->gadget);
@@ -76,6 +91,11 @@ static void ci_otg_work(struct work_struct *work)
 {
         struct ci_hdrc *ci = container_of(work, struct ci_hdrc, work);
 
+        if (ci_otg_is_fsm_mode(ci) && !ci_otg_fsm_work(ci)) {
+                enable_irq(ci->irq);
+                return;
+        }
+
         if (ci->id_event) {
                 ci->id_event = false;
                 ci_handle_id_switch(ci);
@@ -102,6 +122,9 @@ int ci_hdrc_otg_init(struct ci_hdrc *ci)
                 return -ENODEV;
         }
 
+        if (ci_otg_is_fsm_mode(ci))
+                return ci_hdrc_otg_fsm_init(ci);
+
         return 0;
 }
 
@@ -115,6 +138,9 @@ void ci_hdrc_otg_destroy(struct ci_hdrc *ci)
                 flush_workqueue(ci->wq);
                 destroy_workqueue(ci->wq);
         }
-        ci_disable_otg_interrupt(ci, OTGSC_INT_EN_BITS);
-        ci_clear_otg_interrupt(ci, OTGSC_INT_STATUS_BITS);
+        /* Disable all OTG irq and clear status */
+        hw_write_otgsc(ci, OTGSC_INT_EN_BITS | OTGSC_INT_STATUS_BITS,
+                                                OTGSC_INT_STATUS_BITS);
+        if (ci_otg_is_fsm_mode(ci))
+                ci_hdrc_otg_fsm_remove(ci);
 }
diff --git a/drivers/usb/chipidea/otg.h b/drivers/usb/chipidea/otg.h
index 449bee07f4fe..9ecb598e48f0 100644
--- a/drivers/usb/chipidea/otg.h
+++ b/drivers/usb/chipidea/otg.h
@@ -11,25 +11,16 @@
 #ifndef __DRIVERS_USB_CHIPIDEA_OTG_H
 #define __DRIVERS_USB_CHIPIDEA_OTG_H
 
-static inline void ci_clear_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        /* Only clear request bits */
-        hw_write(ci, OP_OTGSC, OTGSC_INT_STATUS_BITS, bits);
-}
-
-static inline void ci_enable_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        hw_write(ci, OP_OTGSC, bits | OTGSC_INT_STATUS_BITS, bits);
-}
-
-static inline void ci_disable_otg_interrupt(struct ci_hdrc *ci, u32 bits)
-{
-        hw_write(ci, OP_OTGSC, bits | OTGSC_INT_STATUS_BITS, 0);
-}
-
+u32 hw_read_otgsc(struct ci_hdrc *ci, u32 mask);
+void hw_write_otgsc(struct ci_hdrc *ci, u32 mask, u32 data);
 int ci_hdrc_otg_init(struct ci_hdrc *ci);
 void ci_hdrc_otg_destroy(struct ci_hdrc *ci);
 enum ci_role ci_otg_role(struct ci_hdrc *ci);
 void ci_handle_vbus_change(struct ci_hdrc *ci);
+static inline void ci_otg_queue_work(struct ci_hdrc *ci)
+{
+        disable_irq_nosync(ci->irq);
+        queue_work(ci->wq, &ci->work);
+}
 
 #endif /* __DRIVERS_USB_CHIPIDEA_OTG_H */
diff --git a/drivers/usb/chipidea/otg_fsm.c b/drivers/usb/chipidea/otg_fsm.c
new file mode 100644
index 000000000000..caaabc58021e
--- /dev/null
+++ b/drivers/usb/chipidea/otg_fsm.c
@@ -0,0 +1,842 @@
+/*
+ * otg_fsm.c - ChipIdea USB IP core OTG FSM driver
+ *
+ * Copyright (C) 2014 Freescale Semiconductor, Inc.
+ *
+ * Author: Jun Li
+ *
+ * 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 file mainly handles OTG fsm, it includes OTG fsm operations
+ * for HNP and SRP.
+ *
+ * TODO List
+ * - ADP
+ * - OTG test device
+ */
+
+#include <linux/usb/otg.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/hcd.h>
+#include <linux/usb/chipidea.h>
+#include <linux/regulator/consumer.h>
+
+#include "ci.h"
+#include "bits.h"
+#include "otg.h"
+#include "otg_fsm.h"
+
+static struct ci_otg_fsm_timer *otg_timer_initializer
+(struct ci_hdrc *ci, void (*function)(void *, unsigned long),
+                        unsigned long expires, unsigned long data)
+{
+        struct ci_otg_fsm_timer *timer;
+
+        timer = devm_kzalloc(ci->dev, sizeof(struct ci_otg_fsm_timer),
+                                                                GFP_KERNEL);
+        if (!timer)
+                return NULL;
+        timer->function = function;
+        timer->expires = expires;
+        timer->data = data;
+        return timer;
+}
+
+/* Add for otg: interact with user space app */
+static ssize_t
+get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_req(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0') {
+                ci->fsm.a_bus_req = 0;
+        } else if (buf[0] == '1') {
+                /* If a_bus_drop is TRUE, a_bus_req can't be set */
+                if (ci->fsm.a_bus_drop) {
+                        mutex_unlock(&ci->fsm.lock);
+                        return count;
+                }
+                ci->fsm.a_bus_req = 1;
+        }
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
+
+static ssize_t
+get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_drop);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_a_bus_drop(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0') {
+                ci->fsm.a_bus_drop = 0;
+        } else if (buf[0] == '1') {
+                ci->fsm.a_bus_drop = 1;
+                ci->fsm.a_bus_req = 0;
+        }
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop,
+                                                set_a_bus_drop);
+
+static ssize_t
+get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        char            *next;
+        unsigned        size, t;
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        next = buf;
+        size = PAGE_SIZE;
+        t = scnprintf(next, size, "%d\n", ci->fsm.b_bus_req);
+        size -= t;
+        next += t;
+
+        return PAGE_SIZE - size;
+}
+
+static ssize_t
+set_b_bus_req(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '0')
+                ci->fsm.b_bus_req = 0;
+        else if (buf[0] == '1')
+                ci->fsm.b_bus_req = 1;
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
+
+static ssize_t
+set_a_clr_err(struct device *dev, struct device_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct ci_hdrc  *ci = dev_get_drvdata(dev);
+
+        if (count > 2)
+                return -1;
+
+        mutex_lock(&ci->fsm.lock);
+        if (buf[0] == '1')
+                ci->fsm.a_clr_err = 1;
+
+        ci_otg_queue_work(ci);
+        mutex_unlock(&ci->fsm.lock);
+
+        return count;
+}
+static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
+
+static struct attribute *inputs_attrs[] = {
+        &dev_attr_a_bus_req.attr,
+        &dev_attr_a_bus_drop.attr,
+        &dev_attr_b_bus_req.attr,
+        &dev_attr_a_clr_err.attr,
+        NULL,
+};
+
+static struct attribute_group inputs_attr_group = {
+        .name = "inputs",
+        .attrs = inputs_attrs,
+};
+
+/*
+ * Add timer to active timer list
+ */
+static void ci_otg_add_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+{
+        struct ci_otg_fsm_timer *tmp_timer;
+        struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+
+        if (t >= NUM_CI_OTG_FSM_TIMERS)
+                return;
+
+        /*
+         * Check if the timer is already in the active list,
+         * if so update timer count
+         */
+        list_for_each_entry(tmp_timer, active_timers, list)
+                if (tmp_timer == timer) {
+                        timer->count = timer->expires;
+                        return;
+                }
+
+        timer->count = timer->expires;
+        list_add_tail(&timer->list, active_timers);
+
+        /* Enable 1ms irq */
+        if (!(hw_read_otgsc(ci, OTGSC_1MSIE)))
+                hw_write_otgsc(ci, OTGSC_1MSIE, OTGSC_1MSIE);
+}
+
+/*
+ * Remove timer from active timer list
+ */
+static void ci_otg_del_timer(struct ci_hdrc *ci, enum ci_otg_fsm_timer_index t)
+{
+        struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
+        struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+
+        if (t >= NUM_CI_OTG_FSM_TIMERS)
+                return;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list)
+                if (tmp_timer == timer)
+                        list_del(&timer->list);
+
+        /* Disable 1ms irq if there is no any active timer */
+        if (list_empty(active_timers))
+                hw_write_otgsc(ci, OTGSC_1MSIE, 0);
+}
+
+/*
+ * Reduce timer count by 1, and find timeout conditions.
+ * Called by otg 1ms timer interrupt
+ */
+static inline int ci_otg_tick_timer(struct ci_hdrc *ci)
+{
+        struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
+        struct list_head *active_timers = &ci->fsm_timer->active_timers;
+        int expired = 0;
+
+        list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list) {
+                tmp_timer->count--;
+                /* check if timer expires */
+                if (!tmp_timer->count) {
+                        list_del(&tmp_timer->list);
+                        tmp_timer->function(ci, tmp_timer->data);
+                        expired = 1;
+                }
+        }
+
+        /* disable 1ms irq if there is no any timer active */
+        if ((expired == 1) && list_empty(active_timers))
+                hw_write_otgsc(ci, OTGSC_1MSIE, 0);
+
+        return expired;
+}
+
+/* The timeout callback function to set time out bit */
+static void set_tmout(void *ptr, unsigned long indicator)
+{
+        *(int *)indicator = 1;
+}
+
+static void set_tmout_and_fsm(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+
+        ci_otg_queue_work(ci);
+}
+
+static void a_wait_vfall_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+        /* Disable port power */
+        hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP, 0);
+        /* Clear exsiting DP irq */
+        hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
+        /* Enable data pulse irq */
+        hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE);
+        ci_otg_queue_work(ci);
+}
+
+static void b_ase0_brst_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+        if (!hw_read_otgsc(ci, OTGSC_BSV))
+                ci->fsm.b_sess_vld = 0;
+
+        ci_otg_queue_work(ci);
+}
+
+static void b_ssend_srp_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        set_tmout(ci, indicator);
+
+        /* only vbus fall below B_sess_vld in b_idle state */
+        if (ci->transceiver->state == OTG_STATE_B_IDLE)
+                ci_otg_queue_work(ci);
+}
+
+static void b_sess_vld_tmout_func(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        /* Check if A detached */
+        if (!(hw_read_otgsc(ci, OTGSC_BSV))) {
+                ci->fsm.b_sess_vld = 0;
+                ci_otg_add_timer(ci, B_SSEND_SRP);
+                ci_otg_queue_work(ci);
+        }
+}
+
+static void b_data_pulse_end(void *ptr, unsigned long indicator)
+{
+        struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
+
+        ci->fsm.b_srp_done = 1;
+        ci->fsm.b_bus_req = 0;
+        if (ci->fsm.power_up)
+                ci->fsm.power_up = 0;
+
+        hw_write_otgsc(ci, OTGSC_HABA, 0);
+
+        ci_otg_queue_work(ci);
+}
+
+/* Initialize timers */
+static int ci_otg_init_timers(struct ci_hdrc *ci)
+{
+        struct otg_fsm *fsm = &ci->fsm;
+
+        /* FSM used timers */
+        ci->fsm_timer->timer_list[A_WAIT_VRISE] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_VRISE,
+                        (unsigned long)&fsm->a_wait_vrise_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_VRISE] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_WAIT_VFALL] =
+                otg_timer_initializer(ci, &a_wait_vfall_tmout_func,
+                TA_WAIT_VFALL, (unsigned long)&fsm->a_wait_vfall_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_VFALL] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_WAIT_BCON] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_BCON,
+                                (unsigned long)&fsm->a_wait_bcon_tmout);
+        if (ci->fsm_timer->timer_list[A_WAIT_BCON] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_AIDL_BDIS] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_AIDL_BDIS,
+                                (unsigned long)&fsm->a_aidl_bdis_tmout);
+        if (ci->fsm_timer->timer_list[A_AIDL_BDIS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[A_BIDL_ADIS] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TA_BIDL_ADIS,
+                                (unsigned long)&fsm->a_bidl_adis_tmout);
+        if (ci->fsm_timer->timer_list[A_BIDL_ADIS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_ASE0_BRST] =
+                otg_timer_initializer(ci, &b_ase0_brst_tmout_func, TB_ASE0_BRST,
+                                        (unsigned long)&fsm->b_ase0_brst_tmout);
+        if (ci->fsm_timer->timer_list[B_ASE0_BRST] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SE0_SRP] =
+                otg_timer_initializer(ci, &set_tmout_and_fsm, TB_SE0_SRP,
+                                        (unsigned long)&fsm->b_se0_srp);
+        if (ci->fsm_timer->timer_list[B_SE0_SRP] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SSEND_SRP] =
+                otg_timer_initializer(ci, &b_ssend_srp_tmout_func, TB_SSEND_SRP,
+                                        (unsigned long)&fsm->b_ssend_srp);
+        if (ci->fsm_timer->timer_list[B_SSEND_SRP] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SRP_FAIL] =
+                otg_timer_initializer(ci, &set_tmout, TB_SRP_FAIL,
+                                (unsigned long)&fsm->b_srp_done);
+        if (ci->fsm_timer->timer_list[B_SRP_FAIL] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_DATA_PLS] =
+                otg_timer_initializer(ci, &b_data_pulse_end, TB_DATA_PLS, 0);
+        if (ci->fsm_timer->timer_list[B_DATA_PLS] == NULL)
+                return -ENOMEM;
+
+        ci->fsm_timer->timer_list[B_SESS_VLD] = otg_timer_initializer(ci,
+                                        &b_sess_vld_tmout_func, TB_SESS_VLD, 0);
+        if (ci->fsm_timer->timer_list[B_SESS_VLD] == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
+/* -------------------------------------------------------------*/
+/* Operations that will be called from OTG Finite State Machine */
+/* -------------------------------------------------------------*/
+static void ci_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (t < NUM_OTG_FSM_TIMERS)
+                ci_otg_add_timer(ci, t);
+        return;
+}
+
+static void ci_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (t < NUM_OTG_FSM_TIMERS)
+                ci_otg_del_timer(ci, t);
+        return;
+}
+
+/*
+ * A-device drive vbus: turn on vbus regulator and enable port power
+ * Data pulse irq should be disabled while vbus is on.
+ */
+static void ci_otg_drv_vbus(struct otg_fsm *fsm, int on)
+{
+        int ret;
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on) {
+                /* Enable power power */
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP,
+                                                        PORTSC_PP);
+                if (ci->platdata->reg_vbus) {
+                        ret = regulator_enable(ci->platdata->reg_vbus);
+                        if (ret) {
+                                dev_err(ci->dev,
+                                "Failed to enable vbus regulator, ret=%d\n",
+                                ret);
+                                return;
+                        }
+                }
+                /* Disable data pulse irq */
+                hw_write_otgsc(ci, OTGSC_DPIE, 0);
+
+                fsm->a_srp_det = 0;
+                fsm->power_up = 0;
+        } else {
+                if (ci->platdata->reg_vbus)
+                        regulator_disable(ci->platdata->reg_vbus);
+
+                fsm->a_bus_drop = 1;
+                fsm->a_bus_req = 0;
+        }
+}
+
+/*
+ * Control data line by Run Stop bit.
+ */
+static void ci_otg_loc_conn(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on)
+                hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
+        else
+                hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
+}
+
+/*
+ * Generate SOF by host.
+ * This is controlled through suspend/resume the port.
+ * In host mode, controller will automatically send SOF.
+ * Suspend will block the data on the port.
+ */
+static void ci_otg_loc_sof(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        if (on)
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_FPR,
+                                                        PORTSC_FPR);
+        else
+                hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_SUSP,
+                                                        PORTSC_SUSP);
+}
+
+/*
+ * Start SRP pulsing by data-line pulsing,
+ * no v-bus pulsing followed
+ */
+static void ci_otg_start_pulse(struct otg_fsm *fsm)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        /* Hardware Assistant Data pulse */
+        hw_write_otgsc(ci, OTGSC_HADP, OTGSC_HADP);
+
+        ci_otg_add_timer(ci, B_DATA_PLS);
+}
+
+static int ci_otg_start_host(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        mutex_unlock(&fsm->lock);
+        if (on) {
+                ci_role_stop(ci);
+                ci_role_start(ci, CI_ROLE_HOST);
+        } else {
+                ci_role_stop(ci);
+                hw_device_reset(ci, USBMODE_CM_DC);
+                ci_role_start(ci, CI_ROLE_GADGET);
+        }
+        mutex_lock(&fsm->lock);
+        return 0;
+}
+
+static int ci_otg_start_gadget(struct otg_fsm *fsm, int on)
+{
+        struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
+
+        mutex_unlock(&fsm->lock);
+        if (on)
+                usb_gadget_vbus_connect(&ci->gadget);
+        else
+                usb_gadget_vbus_disconnect(&ci->gadget);
+        mutex_lock(&fsm->lock);
+
+        return 0;
+}
+
+static struct otg_fsm_ops ci_otg_ops = {
+        .drv_vbus = ci_otg_drv_vbus,
+        .loc_conn = ci_otg_loc_conn,
+        .loc_sof = ci_otg_loc_sof,
+        .start_pulse = ci_otg_start_pulse,
+        .add_timer = ci_otg_fsm_add_timer,
+        .del_timer = ci_otg_fsm_del_timer,
+        .start_host = ci_otg_start_host,
+        .start_gadget = ci_otg_start_gadget,
+};
+
+int ci_otg_fsm_work(struct ci_hdrc *ci)
+{
+        /*
+         * Don't do fsm transition for B device
+         * when there is no gadget class driver
+         */
+        if (ci->fsm.id && !(ci->driver) &&
+                ci->transceiver->state < OTG_STATE_A_IDLE)
+                return 0;
+
+        if (otg_statemachine(&ci->fsm)) {
+                if (ci->transceiver->state == OTG_STATE_A_IDLE) {
+                        /*
+                         * Further state change for cases:
+                         * a_idle to b_idle; or
+                         * a_idle to a_wait_vrise due to ID change(1->0), so
+                         * B-dev becomes A-dev can try to start new session
+                         * consequently; or
+                         * a_idle to a_wait_vrise when power up
+                         */
+                        if ((ci->fsm.id) || (ci->id_event) ||
+                                                (ci->fsm.power_up))
+                                ci_otg_queue_work(ci);
+                        if (ci->id_event)
+                                ci->id_event = false;
+                } else if (ci->transceiver->state == OTG_STATE_B_IDLE) {
+                        if (ci->fsm.b_sess_vld) {
+                                ci->fsm.power_up = 0;
+                                /*
+                                 * Further transite to b_periphearl state
+                                 * when register gadget driver with vbus on
+                                 */
+                                ci_otg_queue_work(ci);
+                        }
+                }
+        }
+        return 0;
+}
+
+/*
+ * Update fsm variables in each state if catching expected interrupts,
+ * called by otg fsm isr.
+ */
+static void ci_otg_fsm_event(struct ci_hdrc *ci)
+{
+        u32 intr_sts, otg_bsess_vld, port_conn;
+        struct otg_fsm *fsm = &ci->fsm;
+
+        intr_sts = hw_read_intr_status(ci);
+        otg_bsess_vld = hw_read_otgsc(ci, OTGSC_BSV);
+        port_conn = hw_read(ci, OP_PORTSC, PORTSC_CCS);
+
+        switch (ci->transceiver->state) {
+        case OTG_STATE_A_WAIT_BCON:
+                if (port_conn) {
+                        fsm->b_conn = 1;
+                        fsm->a_bus_req = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_IDLE:
+                if (otg_bsess_vld && (intr_sts & USBi_PCI) && port_conn) {
+                        fsm->b_sess_vld = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_PERIPHERAL:
+                if ((intr_sts & USBi_SLI) && port_conn && otg_bsess_vld) {
+                        fsm->a_bus_suspend = 1;
+                        ci_otg_queue_work(ci);
+                } else if (intr_sts & USBi_PCI) {
+                        if (fsm->a_bus_suspend == 1)
+                                fsm->a_bus_suspend = 0;
+                }
+                break;
+        case OTG_STATE_B_HOST:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->a_conn = 0;
+                        fsm->b_bus_req = 0;
+                        ci_otg_queue_work(ci);
+                        ci_otg_add_timer(ci, B_SESS_VLD);
+                }
+                break;
+        case OTG_STATE_A_PERIPHERAL:
+                if (intr_sts & USBi_SLI) {
+                         fsm->b_bus_suspend = 1;
+                        /*
+                         * Init a timer to know how long this suspend
+                         * will contine, if time out, indicates B no longer
+                         * wants to be host role
+                         */
+                         ci_otg_add_timer(ci, A_BIDL_ADIS);
+                }
+
+                if (intr_sts & USBi_URI)
+                        ci_otg_del_timer(ci, A_BIDL_ADIS);
+
+                if (intr_sts & USBi_PCI) {
+                        if (fsm->b_bus_suspend == 1) {
+                                ci_otg_del_timer(ci, A_BIDL_ADIS);
+                                fsm->b_bus_suspend = 0;
+                        }
+                }
+                break;
+        case OTG_STATE_A_SUSPEND:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->b_conn = 0;
+
+                        /* if gadget driver is binded */
+                        if (ci->driver) {
+                                /* A device to be peripheral mode */
+                                ci->gadget.is_a_peripheral = 1;
+                        }
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_A_HOST:
+                if ((intr_sts & USBi_PCI) && !port_conn) {
+                        fsm->b_conn = 0;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        case OTG_STATE_B_WAIT_ACON:
+                if ((intr_sts & USBi_PCI) && port_conn) {
+                        fsm->a_conn = 1;
+                        ci_otg_queue_work(ci);
+                }
+                break;
+        default:
+                break;
+        }
+}
+
+/*
+ * ci_otg_irq - otg fsm related irq handling
+ * and also update otg fsm variable by monitoring usb host and udc
+ * state change interrupts.
+ * @ci: ci_hdrc
+ */
+irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
+{
+        irqreturn_t retval =  IRQ_NONE;
+        u32 otgsc, otg_int_src = 0;
+        struct otg_fsm *fsm = &ci->fsm;
+
+        otgsc = hw_read_otgsc(ci, ~0);
+        otg_int_src = otgsc & OTGSC_INT_STATUS_BITS & (otgsc >> 8);
+        fsm->id = (otgsc & OTGSC_ID) ? 1 : 0;
+
+        if (otg_int_src) {
+                if (otg_int_src & OTGSC_1MSIS) {
+                        hw_write_otgsc(ci, OTGSC_1MSIS, OTGSC_1MSIS);
+                        retval = ci_otg_tick_timer(ci);
+                        return IRQ_HANDLED;
+                } else if (otg_int_src & OTGSC_DPIS) {
+                        hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
+                        fsm->a_srp_det = 1;
+                        fsm->a_bus_drop = 0;
+                } else if (otg_int_src & OTGSC_IDIS) {
+                        hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS);
+                        if (fsm->id == 0) {
+                                fsm->a_bus_drop = 0;
+                                fsm->a_bus_req = 1;
+                                ci->id_event = true;
+                        }
+                } else if (otg_int_src & OTGSC_BSVIS) {
+                        hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS);
+                        if (otgsc & OTGSC_BSV) {
+                                fsm->b_sess_vld = 1;
+                                ci_otg_del_timer(ci, B_SSEND_SRP);
+                                ci_otg_del_timer(ci, B_SRP_FAIL);
+                                fsm->b_ssend_srp = 0;
+                        } else {
+                                fsm->b_sess_vld = 0;
+                                if (fsm->id)
+                                        ci_otg_add_timer(ci, B_SSEND_SRP);
+                        }
+                } else if (otg_int_src & OTGSC_AVVIS) {
+                        hw_write_otgsc(ci, OTGSC_AVVIS, OTGSC_AVVIS);
+                        if (otgsc & OTGSC_AVV) {
+                                fsm->a_vbus_vld = 1;
+                        } else {
+                                fsm->a_vbus_vld = 0;
+                                fsm->b_conn = 0;
+                        }
+                }
+                ci_otg_queue_work(ci);
+                return IRQ_HANDLED;
+        }
+
+        ci_otg_fsm_event(ci);
+
+        return retval;
+}
+
+void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
+{
+        ci_otg_queue_work(ci);
+}
+
+int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
+{
+        int retval = 0;
+        struct usb_otg *otg;
+
+        otg = devm_kzalloc(ci->dev,
+                        sizeof(struct usb_otg), GFP_KERNEL);
+        if (!otg) {
+                dev_err(ci->dev,
+                "Failed to allocate usb_otg structure for ci hdrc otg!\n");
+                return -ENOMEM;
+        }
+
+        otg->phy = ci->transceiver;
+        otg->gadget = &ci->gadget;
+        ci->fsm.otg = otg;
+        ci->transceiver->otg = ci->fsm.otg;
+        ci->fsm.power_up = 1;
+        ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0;
+        ci->transceiver->state = OTG_STATE_UNDEFINED;
+        ci->fsm.ops = &ci_otg_ops;
+
+        mutex_init(&ci->fsm.lock);
+
+        ci->fsm_timer = devm_kzalloc(ci->dev,
+                        sizeof(struct ci_otg_fsm_timer_list), GFP_KERNEL);
+        if (!ci->fsm_timer) {
+                dev_err(ci->dev,
+                "Failed to allocate timer structure for ci hdrc otg!\n");
+                return -ENOMEM;
+        }
+
+        INIT_LIST_HEAD(&ci->fsm_timer->active_timers);
+        retval = ci_otg_init_timers(ci);
+        if (retval) {
+                dev_err(ci->dev, "Couldn't init OTG timers\n");
+                return retval;
+        }
+
+        retval = sysfs_create_group(&ci->dev->kobj, &inputs_attr_group);
+        if (retval < 0) {
+                dev_dbg(ci->dev,
+                        "Can't register sysfs attr group: %d\n", retval);
+                return retval;
+        }
+
+        /* Enable A vbus valid irq */
+        hw_write_otgsc(ci, OTGSC_AVVIE, OTGSC_AVVIE);
+
+        if (ci->fsm.id) {
+                ci->fsm.b_ssend_srp =
+                        hw_read_otgsc(ci, OTGSC_BSV) ? 0 : 1;
+                ci->fsm.b_sess_vld =
+                        hw_read_otgsc(ci, OTGSC_BSV) ? 1 : 0;
+                /* Enable BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIE, OTGSC_BSVIE);
+        }
+
+        return 0;
+}
+
+void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
+{
+        sysfs_remove_group(&ci->dev->kobj, &inputs_attr_group);
+}
diff --git a/drivers/usb/chipidea/otg_fsm.h b/drivers/usb/chipidea/otg_fsm.h
new file mode 100644
index 000000000000..94c085f456a9
--- /dev/null
+++ b/drivers/usb/chipidea/otg_fsm.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (C) 2014 Freescale Semiconductor, Inc.
+ *
+ * Author: Jun Li
+ *
+ * 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 __DRIVERS_USB_CHIPIDEA_OTG_FSM_H
+#define __DRIVERS_USB_CHIPIDEA_OTG_FSM_H
+
+#include <linux/usb/otg-fsm.h>
+
+/*
+ *  A-DEVICE timing  constants
+ */
+
+/* Wait for VBUS Rise  */
+#define TA_WAIT_VRISE        (100)      /* a_wait_vrise: section 7.1.2
+                                         * a_wait_vrise_tmr: section 7.4.5.1
+                                         * TA_VBUS_RISE <= 100ms, section 4.4
+                                         * Table 4-1: Electrical Characteristics
+                                         * ->DC Electrical Timing
+                                         */
+/* Wait for VBUS Fall  */
+#define TA_WAIT_VFALL        (1000)     /* a_wait_vfall: section 7.1.7
+                                         * a_wait_vfall_tmr: section: 7.4.5.2
+                                         */
+/* Wait for B-Connect */
+#define TA_WAIT_BCON         (10000)    /* a_wait_bcon: section 7.1.3
+                                         * TA_WAIT_BCON: should be between 1100
+                                         * and 30000 ms, section 5.5, Table 5-1
+                                         */
+/* A-Idle to B-Disconnect */
+#define TA_AIDL_BDIS         (5000)     /* a_suspend min 200 ms, section 5.2.1
+                                         * TA_AIDL_BDIS: section 5.5, Table 5-1
+                                         */
+/* B-Idle to A-Disconnect */
+#define TA_BIDL_ADIS         (500)      /* TA_BIDL_ADIS: section 5.2.1
+                                         * 500ms is used for B switch to host
+                                         * for safe
+                                         */
+
+/*
+ * B-device timing constants
+ */
+
+/* Data-Line Pulse Time*/
+#define TB_DATA_PLS          (10)       /* b_srp_init,continue 5~10ms
+                                         * section:5.1.3
+                                         */
+/* SRP Fail Time  */
+#define TB_SRP_FAIL          (6000)     /* b_srp_init,fail time 5~6s
+                                         * section:5.1.6
+                                         */
+/* A-SE0 to B-Reset  */
+#define TB_ASE0_BRST         (155)      /* minimum 155 ms, section:5.3.1 */
+/* SE0 Time Before SRP */
+#define TB_SE0_SRP           (1000)     /* b_idle,minimum 1s, section:5.1.2 */
+/* SSEND time before SRP */
+#define TB_SSEND_SRP         (1500)     /* minimum 1.5 sec, section:5.1.2 */
+
+#define TB_SESS_VLD          (1000)
+
+enum ci_otg_fsm_timer_index {
+        /*
+         * CI specific timers, start from the end
+         * of standard and auxiliary OTG timers
+         */
+        B_DATA_PLS = NUM_OTG_FSM_TIMERS,
+        B_SSEND_SRP,
+        B_SESS_VLD,
+
+        NUM_CI_OTG_FSM_TIMERS,
+};
+
+struct ci_otg_fsm_timer {
+        unsigned long expires;  /* Number of count increase to timeout */
+        unsigned long count;    /* Tick counter */
+        void (*function)(void *, unsigned long);        /* Timeout function */
+        unsigned long data;     /* Data passed to function */
+        struct list_head list;
+};
+
+struct ci_otg_fsm_timer_list {
+        struct ci_otg_fsm_timer *timer_list[NUM_CI_OTG_FSM_TIMERS];
+        struct list_head active_timers;
+};
+
+#ifdef CONFIG_USB_OTG_FSM
+
+int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci);
+int ci_otg_fsm_work(struct ci_hdrc *ci);
+irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci);
+void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci);
+void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci);
+
+#else
+
+static inline int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
+{
+        return 0;
+}
+
+static inline int ci_otg_fsm_work(struct ci_hdrc *ci)
+{
+        return -ENXIO;
+}
+
+static inline irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
+{
+        return IRQ_NONE;
+}
+
+static inline void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
+{
+
+}
+
+static inline void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
+{
+
+}
+
+#endif
+
+#endif /* __DRIVERS_USB_CHIPIDEA_OTG_FSM_H */
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index 7739c64ef259..69425b3cb6b7 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -20,6 +20,7 @@
 #include <linux/pm_runtime.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/usb/otg-fsm.h>
 #include <linux/usb/chipidea.h>
 
 #include "ci.h"
@@ -27,6 +28,7 @@
 #include "bits.h"
 #include "debug.h"
 #include "otg.h"
+#include "otg_fsm.h"
 
 /* control endpoint description */
 static const struct usb_endpoint_descriptor
@@ -242,26 +244,6 @@ static int hw_port_is_high_speed(struct ci_hdrc *ci)
 }
 
 /**
- * hw_read_intr_enable: returns interrupt enable register
- *
- * This function returns register data
- */
-static u32 hw_read_intr_enable(struct ci_hdrc *ci)
-{
-        return hw_read(ci, OP_USBINTR, ~0);
-}
-
-/**
- * hw_read_intr_status: returns interrupt status register
- *
- * This function returns register data
- */
-static u32 hw_read_intr_status(struct ci_hdrc *ci)
-{
-        return hw_read(ci, OP_USBSTS, ~0);
-}
-
-/**
  * hw_test_and_clear_complete: test & clear complete status (execute without
  *                             interruption)
  * @n: endpoint number
@@ -727,6 +709,8 @@ __acquires(ci->lock)
         if (ci->status == NULL)
                 retval = -ENOMEM;
 
+        usb_gadget_set_state(&ci->gadget, USB_STATE_DEFAULT);
+
 done:
         spin_lock(&ci->lock);
 
@@ -841,7 +825,6 @@ __acquires(hwep->lock)
         if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
                 /* Assume that device is bus powered for now. */
                 *(u16 *)req->buf = ci->remote_wakeup << 1;
-                retval = 0;
         } else if ((setup->bRequestType & USB_RECIP_MASK) \
                    == USB_RECIP_ENDPOINT) {
                 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
@@ -883,6 +866,8 @@ isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
         if (ci->setaddr) {
                 hw_usb_set_address(ci, ci->address);
                 ci->setaddr = false;
+                if (ci->address)
+                        usb_gadget_set_state(&ci->gadget, USB_STATE_ADDRESS);
         }
 
         spin_lock_irqsave(&ci->lock, flags);
@@ -1072,6 +1057,14 @@ __acquires(ci->lock)
                                 default:
                                         break;
                                 }
+                                break;
+                        case USB_DEVICE_B_HNP_ENABLE:
+                                if (ci_otg_is_fsm_mode(ci)) {
+                                        ci->gadget.b_hnp_enable = 1;
+                                        err = isr_setup_status_phase(
+                                                        ci);
+                                }
+                                break;
                         default:
                                 goto delegate;
                         }
@@ -1477,7 +1470,7 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                         pm_runtime_get_sync(&_gadget->dev);
                         hw_device_reset(ci, USBMODE_CM_DC);
                         hw_device_state(ci, ci->ep0out->qh.dma);
-                        dev_dbg(ci->dev, "Connected to host\n");
+                        usb_gadget_set_state(_gadget, USB_STATE_POWERED);
                 } else {
                         if (ci->driver)
                                 ci->driver->disconnect(&ci->gadget);
@@ -1487,7 +1480,7 @@ static int ci_udc_vbus_session(struct usb_gadget *_gadget, int is_active)
                                 CI_HDRC_CONTROLLER_STOPPED_EVENT);
                         _gadget_stop_activity(&ci->gadget);
                         pm_runtime_put_sync(&_gadget->dev);
-                        dev_dbg(ci->dev, "Disconnected from host\n");
+                        usb_gadget_set_state(_gadget, USB_STATE_NOTATTACHED);
                 }
         }
 
@@ -1655,6 +1648,13 @@ static int ci_udc_start(struct usb_gadget *gadget,
                 return retval;
 
         ci->driver = driver;
+
+        /* Start otg fsm for B-device */
+        if (ci_otg_is_fsm_mode(ci) && ci->fsm.id) {
+                ci_hdrc_otg_fsm_start(ci);
+                return retval;
+        }
+
         pm_runtime_get_sync(&ci->gadget.dev);
         if (ci->vbus_active) {
                 spin_lock_irqsave(&ci->lock, flags);
@@ -1753,6 +1753,8 @@ static irqreturn_t udc_irq(struct ci_hdrc *ci)
                                 ci->suspended = 1;
                                 spin_unlock(&ci->lock);
                                 ci->driver->suspend(&ci->gadget);
+                                usb_gadget_set_state(&ci->gadget,
+                                                USB_STATE_SUSPENDED);
                                 spin_lock(&ci->lock);
                         }
                 }
@@ -1779,7 +1781,7 @@ static int udc_start(struct ci_hdrc *ci)
         ci->gadget.ops          = &usb_gadget_ops;
         ci->gadget.speed        = USB_SPEED_UNKNOWN;
         ci->gadget.max_speed    = USB_SPEED_HIGH;
-        ci->gadget.is_otg       = 0;
+        ci->gadget.is_otg       = ci->is_otg ? 1 : 0;
         ci->gadget.name         = ci->platdata->name;
 
         INIT_LIST_HEAD(&ci->gadget.ep_list);
@@ -1843,21 +1845,22 @@ void ci_hdrc_gadget_destroy(struct ci_hdrc *ci)
 
 static int udc_id_switch_for_device(struct ci_hdrc *ci)
 {
-        if (ci->is_otg) {
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                ci_enable_otg_interrupt(ci, OTGSC_BSVIE);
-        }
+        if (ci->is_otg)
+                /* Clear and enable BSV irq */
+                hw_write_otgsc(ci, OTGSC_BSVIS | OTGSC_BSVIE,
+                                        OTGSC_BSVIS | OTGSC_BSVIE);
 
         return 0;
 }
 
 static void udc_id_switch_for_host(struct ci_hdrc *ci)
 {
-        if (ci->is_otg) {
-                /* host doesn't care B_SESSION_VALID event */
-                ci_clear_otg_interrupt(ci, OTGSC_BSVIS);
-                ci_disable_otg_interrupt(ci, OTGSC_BSVIE);
-        }
+        /*
+         * host doesn't care B_SESSION_VALID event
+         * so clear and disbale BSV irq
+         */
+        if (ci->is_otg)
+                hw_write_otgsc(ci, OTGSC_BSVIE | OTGSC_BSVIS, OTGSC_BSVIS);
 }
 
 /**
diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbmisc_imx.c
index cd061abe3507..85293b8b1df9 100644
--- a/drivers/usb/chipidea/usbmisc_imx.c
+++ b/drivers/usb/chipidea/usbmisc_imx.c
@@ -21,16 +21,39 @@
 #define MX25_USB_PHY_CTRL_OFFSET        0x08
 #define MX25_BM_EXTERNAL_VBUS_DIVIDER   BIT(23)
 
+#define MX25_EHCI_INTERFACE_SINGLE_UNI  (2 << 0)
+#define MX25_EHCI_INTERFACE_DIFF_UNI    (0 << 0)
+#define MX25_EHCI_INTERFACE_MASK        (0xf)
+
+#define MX25_OTG_SIC_SHIFT              29
+#define MX25_OTG_SIC_MASK               (0x3 << MX25_OTG_SIC_SHIFT)
+#define MX25_OTG_PM_BIT                 BIT(24)
+#define MX25_OTG_PP_BIT                 BIT(11)
+#define MX25_OTG_OCPOL_BIT              BIT(3)
+
+#define MX25_H1_SIC_SHIFT               21
+#define MX25_H1_SIC_MASK                (0x3 << MX25_H1_SIC_SHIFT)
+#define MX25_H1_PP_BIT                  BIT(18)
+#define MX25_H1_PM_BIT                  BIT(16)
+#define MX25_H1_IPPUE_UP_BIT            BIT(7)
+#define MX25_H1_IPPUE_DOWN_BIT          BIT(6)
+#define MX25_H1_TLL_BIT                 BIT(5)
+#define MX25_H1_USBTE_BIT               BIT(4)
+#define MX25_H1_OCPOL_BIT               BIT(2)
+
 #define MX27_H1_PM_BIT                  BIT(8)
 #define MX27_H2_PM_BIT                  BIT(16)
 #define MX27_OTG_PM_BIT                 BIT(24)
 
 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
+#define MX53_USB_OTG_PHY_CTRL_1_OFFSET  0x0c
 #define MX53_USB_UH2_CTRL_OFFSET        0x14
 #define MX53_USB_UH3_CTRL_OFFSET        0x18
 #define MX53_BM_OVER_CUR_DIS_H1         BIT(5)
 #define MX53_BM_OVER_CUR_DIS_OTG        BIT(8)
 #define MX53_BM_OVER_CUR_DIS_UHx        BIT(30)
+#define MX53_USB_PHYCTRL1_PLLDIV_MASK   0x3
+#define MX53_USB_PLL_DIV_24_MHZ         0x01
 
 #define MX6_BM_OVER_CUR_DIS             BIT(7)
 
@@ -50,6 +73,39 @@ struct imx_usbmisc {
 
 static struct imx_usbmisc *usbmisc;
 
+static int usbmisc_imx25_init(struct imx_usbmisc_data *data)
+{
+        unsigned long flags;
+        u32 val = 0;
+
+        if (data->index > 1)
+                return -EINVAL;
+
+        spin_lock_irqsave(&usbmisc->lock, flags);
+        switch (data->index) {
+        case 0:
+                val = readl(usbmisc->base);
+                val &= ~(MX25_OTG_SIC_MASK | MX25_OTG_PP_BIT);
+                val |= (MX25_EHCI_INTERFACE_DIFF_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_OTG_SIC_SHIFT;
+                val |= (MX25_OTG_PM_BIT | MX25_OTG_OCPOL_BIT);
+                writel(val, usbmisc->base);
+                break;
+        case 1:
+                val = readl(usbmisc->base);
+                val &= ~(MX25_H1_SIC_MASK | MX25_H1_PP_BIT |  MX25_H1_IPPUE_UP_BIT);
+                val |= (MX25_EHCI_INTERFACE_SINGLE_UNI & MX25_EHCI_INTERFACE_MASK) << MX25_H1_SIC_SHIFT;
+                val |= (MX25_H1_PM_BIT | MX25_H1_OCPOL_BIT | MX25_H1_TLL_BIT |
+                        MX25_H1_USBTE_BIT | MX25_H1_IPPUE_DOWN_BIT);
+
+                writel(val, usbmisc->base);
+
+                break;
+        }
+        spin_unlock_irqrestore(&usbmisc->lock, flags);
+
+        return 0;
+}
+
 static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
 {
         void __iomem *reg;
@@ -111,6 +167,13 @@ static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
         if (data->index > 3)
                 return -EINVAL;
 
+        /* Select a 24 MHz reference clock for the PHY  */
+        reg = usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET;
+        val = readl(reg);
+        val &= ~MX53_USB_PHYCTRL1_PLLDIV_MASK;
+        val |= MX53_USB_PLL_DIV_24_MHZ;
+        writel(val, usbmisc->base + MX53_USB_OTG_PHY_CTRL_1_OFFSET);
+
         if (data->disable_oc) {
                 spin_lock_irqsave(&usbmisc->lock, flags);
                 switch (data->index) {
@@ -159,6 +222,7 @@ static int usbmisc_imx6q_init(struct imx_usbmisc_data *data)
 }
 
 static const struct usbmisc_ops imx25_usbmisc_ops = {
+        .init = usbmisc_imx25_init,
         .post = usbmisc_imx25_post,
 };
 
@@ -200,6 +264,10 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = {
                 .data = &imx25_usbmisc_ops,
         },
         {
+                .compatible = "fsl,imx35-usbmisc",
+                .data = &imx25_usbmisc_ops,
+        },
+        {
                 .compatible = "fsl,imx27-usbmisc",
                 .data = &imx27_usbmisc_ops,
         },
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 904efb6035b0..e934e19f49f5 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -122,13 +122,23 @@ static void acm_release_minor(struct acm *acm)
 static int acm_ctrl_msg(struct acm *acm, int request, int value,
                                                         void *buf, int len)
 {
-        int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
+        int retval;
+
+        retval = usb_autopm_get_interface(acm->control);
+        if (retval)
+                return retval;
+
+        retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
                 request, USB_RT_ACM, value,
                 acm->control->altsetting[0].desc.bInterfaceNumber,
                 buf, len, 5000);
+
         dev_dbg(&acm->control->dev,
                         "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
                         __func__, request, value, len, retval);
+
+        usb_autopm_put_interface(acm->control);
+
         return retval < 0 ? retval : 0;
 }
 
@@ -406,19 +416,21 @@ static void acm_read_bulk_callback(struct urb *urb)
                 dev_dbg(&acm->data->dev, "%s - disconnected\n", __func__);
                 return;
         }
-        usb_mark_last_busy(acm->dev);
 
         if (urb->status) {
                 dev_dbg(&acm->data->dev, "%s - non-zero urb status: %d\n",
                                                         __func__, urb->status);
                 return;
         }
+
+        usb_mark_last_busy(acm->dev);
+
         acm_process_read_urb(acm, urb);
 
         /* throttle device if requested by tty */
         spin_lock_irqsave(&acm->read_lock, flags);
         acm->throttled = acm->throttle_req;
-        if (!acm->throttled && !acm->susp_count) {
+        if (!acm->throttled) {
                 spin_unlock_irqrestore(&acm->read_lock, flags);
                 acm_submit_read_urb(acm, rb->index, GFP_ATOMIC);
         } else {
@@ -492,10 +504,30 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         return tty_port_open(&acm->port, tty, filp);
 }
 
+static void acm_port_dtr_rts(struct tty_port *port, int raise)
+{
+        struct acm *acm = container_of(port, struct acm, port);
+        int val;
+        int res;
+
+        if (raise)
+                val = ACM_CTRL_DTR | ACM_CTRL_RTS;
+        else
+                val = 0;
+
+        /* FIXME: add missing ctrlout locking throughout driver */
+        acm->ctrlout = val;
+
+        res = acm_set_control(acm, val);
+        if (res && (acm->ctrl_caps & USB_CDC_CAP_LINE))
+                dev_err(&acm->control->dev, "failed to set dtr/rts\n");
+}
+
 static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
 {
         struct acm *acm = container_of(port, struct acm, port);
         int retval = -ENODEV;
+        int i;
 
         dev_dbg(&acm->control->dev, "%s\n", __func__);
 
@@ -515,22 +547,13 @@ static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
         acm->control->needs_remote_wakeup = 1;
 
         acm->ctrlurb->dev = acm->dev;
-        if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
+        retval = usb_submit_urb(acm->ctrlurb, GFP_KERNEL);
+        if (retval) {
                 dev_err(&acm->control->dev,
                         "%s - usb_submit_urb(ctrl irq) failed\n", __func__);
-                usb_autopm_put_interface(acm->control);
                 goto error_submit_urb;
         }
 
-        acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS;
-        if (acm_set_control(acm, acm->ctrlout) < 0 &&
-            (acm->ctrl_caps & USB_CDC_CAP_LINE)) {
-                usb_autopm_put_interface(acm->control);
-                goto error_set_control;
-        }
-
-        usb_autopm_put_interface(acm->control);
-
         /*
          * Unthrottle device in case the TTY was closed while throttled.
          */
@@ -539,23 +562,27 @@ static int acm_port_activate(struct tty_port *port, struct tty_struct *tty)
         acm->throttle_req = 0;
         spin_unlock_irq(&acm->read_lock);
 
-        if (acm_submit_read_urbs(acm, GFP_KERNEL))
+        retval = acm_submit_read_urbs(acm, GFP_KERNEL);
+        if (retval)
                 goto error_submit_read_urbs;
 
+        usb_autopm_put_interface(acm->control);
+
         mutex_unlock(&acm->mutex);
 
         return 0;
 
 error_submit_read_urbs:
-        acm->ctrlout = 0;
-        acm_set_control(acm, acm->ctrlout);
-error_set_control:
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_kill_urb(acm->read_urbs[i]);
         usb_kill_urb(acm->ctrlurb);
 error_submit_urb:
+        usb_autopm_put_interface(acm->control);
 error_get_interface:
 disconnected:
         mutex_unlock(&acm->mutex);
-        return retval;
+
+        return usb_translate_errors(retval);
 }
 
 static void acm_port_destruct(struct tty_port *port)
@@ -573,23 +600,37 @@ static void acm_port_destruct(struct tty_port *port)
 static void acm_port_shutdown(struct tty_port *port)
 {
         struct acm *acm = container_of(port, struct acm, port);
+        struct urb *urb;
+        struct acm_wb *wb;
         int i;
 
         dev_dbg(&acm->control->dev, "%s\n", __func__);
 
-        mutex_lock(&acm->mutex);
-        if (!acm->disconnected) {
-                usb_autopm_get_interface(acm->control);
-                acm_set_control(acm, acm->ctrlout = 0);
-                usb_kill_urb(acm->ctrlurb);
-                for (i = 0; i < ACM_NW; i++)
-                        usb_kill_urb(acm->wb[i].urb);
-                for (i = 0; i < acm->rx_buflimit; i++)
-                        usb_kill_urb(acm->read_urbs[i]);
-                acm->control->needs_remote_wakeup = 0;
-                usb_autopm_put_interface(acm->control);
+        /*
+         * Need to grab write_lock to prevent race with resume, but no need to
+         * hold it due to the tty-port initialised flag.
+         */
+        spin_lock_irq(&acm->write_lock);
+        spin_unlock_irq(&acm->write_lock);
+
+        usb_autopm_get_interface_no_resume(acm->control);
+        acm->control->needs_remote_wakeup = 0;
+        usb_autopm_put_interface(acm->control);
+
+        for (;;) {
+                urb = usb_get_from_anchor(&acm->delayed);
+                if (!urb)
+                        break;
+                wb = urb->context;
+                wb->use = 0;
+                usb_autopm_put_interface_async(acm->control);
         }
-        mutex_unlock(&acm->mutex);
+
+        usb_kill_urb(acm->ctrlurb);
+        for (i = 0; i < ACM_NW; i++)
+                usb_kill_urb(acm->wb[i].urb);
+        for (i = 0; i < acm->rx_buflimit; i++)
+                usb_kill_urb(acm->read_urbs[i]);
 }
 
 static void acm_tty_cleanup(struct tty_struct *tty)
@@ -646,16 +687,18 @@ static int acm_tty_write(struct tty_struct *tty,
         memcpy(wb->buf, buf, count);
         wb->len = count;
 
-        usb_autopm_get_interface_async(acm->control);
+        stat = usb_autopm_get_interface_async(acm->control);
+        if (stat) {
+                wb->use = 0;
+                spin_unlock_irqrestore(&acm->write_lock, flags);
+                return stat;
+        }
+
         if (acm->susp_count) {
-                if (!acm->delayed_wb)
-                        acm->delayed_wb = wb;
-                else
-                        usb_autopm_put_interface_async(acm->control);
+                usb_anchor_urb(wb->urb, &acm->delayed);
                 spin_unlock_irqrestore(&acm->write_lock, flags);
-                return count;   /* A white lie */
+                return count;
         }
-        usb_mark_last_busy(acm->dev);
 
         stat = acm_start_wb(acm, wb);
         spin_unlock_irqrestore(&acm->write_lock, flags);
@@ -958,6 +1001,7 @@ static void acm_tty_set_termios(struct tty_struct *tty,
 }
 
 static const struct tty_port_operations acm_port_ops = {
+        .dtr_rts = acm_port_dtr_rts,
         .shutdown = acm_port_shutdown,
         .activate = acm_port_activate,
         .destruct = acm_port_destruct,
@@ -1269,6 +1313,7 @@ made_compressed_probe:
                 acm->bInterval = epread->bInterval;
         tty_port_init(&acm->port);
         acm->port.ops = &acm_port_ops;
+        init_usb_anchor(&acm->delayed);
 
         buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
@@ -1394,8 +1439,6 @@ skip_countries:
 
         dev_info(&intf->dev, "ttyACM%d: USB ACM device\n", minor);
 
-        acm_set_control(acm, acm->ctrlout);
-
         acm->line.dwDTERate = cpu_to_le32(9600);
         acm->line.bDataBits = 8;
         acm_set_line(acm, &acm->line);
@@ -1514,27 +1557,20 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         struct acm *acm = usb_get_intfdata(intf);
         int cnt;
 
+        spin_lock_irq(&acm->write_lock);
         if (PMSG_IS_AUTO(message)) {
-                int b;
-
-                spin_lock_irq(&acm->write_lock);
-                b = acm->transmitting;
-                spin_unlock_irq(&acm->write_lock);
-                if (b)
+                if (acm->transmitting) {
+                        spin_unlock_irq(&acm->write_lock);
                         return -EBUSY;
+                }
         }
-
-        spin_lock_irq(&acm->read_lock);
-        spin_lock(&acm->write_lock);
         cnt = acm->susp_count++;
-        spin_unlock(&acm->write_lock);
-        spin_unlock_irq(&acm->read_lock);
+        spin_unlock_irq(&acm->write_lock);
 
         if (cnt)
                 return 0;
 
-        if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags))
-                stop_data_traffic(acm);
+        stop_data_traffic(acm);
 
         return 0;
 }
@@ -1542,29 +1578,23 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
 static int acm_resume(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
-        struct acm_wb *wb;
+        struct urb *urb;
         int rv = 0;
-        int cnt;
 
-        spin_lock_irq(&acm->read_lock);
-        acm->susp_count -= 1;
-        cnt = acm->susp_count;
-        spin_unlock_irq(&acm->read_lock);
+        spin_lock_irq(&acm->write_lock);
 
-        if (cnt)
-                return 0;
+        if (--acm->susp_count)
+                goto out;
 
         if (test_bit(ASYNCB_INITIALIZED, &acm->port.flags)) {
-                rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
+                rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC);
 
-                spin_lock_irq(&acm->write_lock);
-                if (acm->delayed_wb) {
-                        wb = acm->delayed_wb;
-                        acm->delayed_wb = NULL;
-                        spin_unlock_irq(&acm->write_lock);
-                        acm_start_wb(acm, wb);
-                } else {
-                        spin_unlock_irq(&acm->write_lock);
+                for (;;) {
+                        urb = usb_get_from_anchor(&acm->delayed);
+                        if (!urb)
+                                break;
+
+                        acm_start_wb(acm, urb->context);
                 }
 
                 /*
@@ -1572,12 +1602,13 @@ static int acm_resume(struct usb_interface *intf)
                  * do the write path at all cost
                  */
                 if (rv < 0)
-                        goto err_out;
+                        goto out;
 
-                rv = acm_submit_read_urbs(acm, GFP_NOIO);
+                rv = acm_submit_read_urbs(acm, GFP_ATOMIC);
         }
+out:
+        spin_unlock_irq(&acm->write_lock);
 
-err_out:
         return rv;
 }
 
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index e38dc785808f..fc75651afe1c 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -120,15 +120,15 @@ struct acm {
         unsigned int throttled:1;                       /* actually throttled */
         unsigned int throttle_req:1;                    /* throttle requested */
         u8 bInterval;
-        struct acm_wb *delayed_wb;                      /* write queued for a device about to be woken */
+        struct usb_anchor delayed;                      /* writes queued for a device about to be woken */
 };
 
 #define CDC_DATA_INTERFACE_TYPE 0x0a
 
 /* constants describing various quirks and errors */
-#define NO_UNION_NORMAL                 1
-#define SINGLE_RX_URB                   2
-#define NO_CAP_LINE                     4
-#define NOT_A_MODEM                     8
-#define NO_DATA_INTERFACE               16
-#define IGNORE_DEVICE                   32
+#define NO_UNION_NORMAL                 BIT(0)
+#define SINGLE_RX_URB                   BIT(1)
+#define NO_CAP_LINE                     BIT(2)
+#define NOT_A_MODEM                     BIT(3)
+#define NO_DATA_INTERFACE               BIT(4)
+#define IGNORE_DEVICE                   BIT(5)
diff --git a/drivers/usb/class/usbtmc.c b/drivers/usb/class/usbtmc.c
index cfbec9c7e09e..103a6e9ee49d 100644
--- a/drivers/usb/class/usbtmc.c
+++ b/drivers/usb/class/usbtmc.c
@@ -383,9 +383,12 @@ exit:
 static int send_request_dev_dep_msg_in(struct usbtmc_device_data *data, size_t transfer_size)
 {
         int retval;
-        u8 buffer[USBTMC_HEADER_SIZE];
+        u8 *buffer;
         int actual;
 
+        buffer = kmalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
         /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message
          * Refer to class specs for details
          */
@@ -417,6 +420,7 @@ static int send_request_dev_dep_msg_in(struct usbtmc_device_data *data, size_t t
         if (!data->bTag)
                 data->bTag++;
 
+        kfree(buffer);
         if (retval < 0) {
                 dev_err(&data->intf->dev, "usb_bulk_msg in send_request_dev_dep_msg_in() returned %d\n", retval);
                 return retval;
diff --git a/drivers/usb/common/Makefile b/drivers/usb/common/Makefile
new file mode 100644
index 000000000000..752646167e1e
--- /dev/null
+++ b/drivers/usb/common/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for the usb common parts.
+#
+
+obj-$(CONFIG_USB_COMMON) += usb-common.o
+obj-$(CONFIG_USB_OTG_FSM) += usb-otg-fsm.o
diff --git a/drivers/usb/usb-common.c b/drivers/usb/common/usb-common.c
index 6dfd30a863c7..6dfd30a863c7 100644
--- a/drivers/usb/usb-common.c
+++ b/drivers/usb/common/usb-common.c
diff --git a/drivers/usb/phy/phy-fsm-usb.c b/drivers/usb/common/usb-otg-fsm.c
index d03fadd2629f..98e8340a5bb1 100644
--- a/drivers/usb/phy/phy-fsm-usb.c
+++ b/drivers/usb/common/usb-otg-fsm.c
@@ -364,3 +364,4 @@ int otg_statemachine(struct otg_fsm *fsm)
         VDBG("quit statemachine, changed = %d\n", state_changed);
         return state_changed;
 }
+EXPORT_SYMBOL_GPL(otg_statemachine);
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index cb8e99156f5a..1060657ca1b0 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -1,13 +1,6 @@
 #
 # USB Core configuration
 #
-config USB_DEBUG
-        bool "USB verbose debug messages"
-        help
-          Say Y here if you want the USB core & hub drivers to produce a bunch
-          of debug messages to the system log. Select this if you are having a
-          problem with USB support and want to see more of what is going on.
-
 config USB_ANNOUNCE_NEW_DEVICES
         bool "USB announce new devices"
         help
@@ -88,3 +81,12 @@ config USB_OTG_BLACKLIST_HUB
           and software costs by not supporting external hubs.  So
           are "Embedded Hosts" that don't offer OTG support.
 
+config USB_OTG_FSM
+        tristate "USB 2.0 OTG FSM implementation"
+        depends on USB
+        select USB_OTG
+        select USB_PHY
+        help
+          Implements OTG Finite State Machine as specified in On-The-Go
+          and Embedded Host Supplement to the USB Revision 2.0 Specification.
+
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 1f02e65fe305..82044b5d6113 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -192,7 +192,6 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (pci_enable_device(dev) < 0)
                 return -ENODEV;
-        dev->current_state = PCI_D0;
 
         /*
          * The xHCI driver has its own irq management
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 9c4e2922b04d..bec31e2efb88 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -918,6 +918,7 @@ static void usb_bus_init (struct usb_bus *bus)
         bus->bandwidth_allocated = 0;
         bus->bandwidth_int_reqs  = 0;
         bus->bandwidth_isoc_reqs = 0;
+        mutex_init(&bus->usb_address0_mutex);
 
         INIT_LIST_HEAD (&bus->bus_list);
 }
@@ -1502,6 +1503,9 @@ int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
                                         ret = -EAGAIN;
                                 else
                                         urb->transfer_flags |= URB_DMA_MAP_PAGE;
+                        } else if (is_vmalloc_addr(urb->transfer_buffer)) {
+                                WARN_ONCE(1, "transfer buffer not dma capable\n");
+                                ret = -EAGAIN;
                         } else {
                                 urb->transfer_dma = dma_map_single(
                                                 hcd->self.controller,
@@ -2263,9 +2267,7 @@ static void hcd_resume_work(struct work_struct *work)
         struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
         struct usb_device *udev = hcd->self.root_hub;
 
-        usb_lock_device(udev);
         usb_remote_wakeup(udev);
-        usb_unlock_device(udev);
 }
 
 /**
@@ -2454,11 +2456,13 @@ struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
                 mutex_init(hcd->bandwidth_mutex);
                 dev_set_drvdata(dev, hcd);
         } else {
+                mutex_lock(&usb_port_peer_mutex);
                 hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
                 hcd->primary_hcd = primary_hcd;
                 primary_hcd->primary_hcd = primary_hcd;
                 hcd->shared_hcd = primary_hcd;
                 primary_hcd->shared_hcd = hcd;
+                mutex_unlock(&usb_port_peer_mutex);
         }
 
         kref_init(&hcd->kref);
@@ -2510,18 +2514,25 @@ EXPORT_SYMBOL_GPL(usb_create_hcd);
  * deallocated.
  *
  * Make sure to only deallocate the bandwidth_mutex when the primary HCD is
- * freed.  When hcd_release() is called for the non-primary HCD, set the
- * primary_hcd's shared_hcd pointer to null (since the non-primary HCD will be
- * freed shortly).
+ * freed.  When hcd_release() is called for either hcd in a peer set
+ * invalidate the peer's ->shared_hcd and ->primary_hcd pointers to
+ * block new peering attempts
  */
-static void hcd_release (struct kref *kref)
+static void hcd_release(struct kref *kref)
 {
         struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
 
+        mutex_lock(&usb_port_peer_mutex);
         if (usb_hcd_is_primary_hcd(hcd))
                 kfree(hcd->bandwidth_mutex);
-        else
-                hcd->shared_hcd->shared_hcd = NULL;
+        if (hcd->shared_hcd) {
+                struct usb_hcd *peer = hcd->shared_hcd;
+
+                peer->shared_hcd = NULL;
+                if (peer->primary_hcd == hcd)
+                        peer->primary_hcd = NULL;
+        }
+        mutex_unlock(&usb_port_peer_mutex);
         kfree(hcd);
 }
 
@@ -2589,6 +2600,21 @@ static int usb_hcd_request_irqs(struct usb_hcd *hcd,
         return 0;
 }
 
+/*
+ * Before we free this root hub, flush in-flight peering attempts
+ * and disable peer lookups
+ */
+static void usb_put_invalidate_rhdev(struct usb_hcd *hcd)
+{
+        struct usb_device *rhdev;
+
+        mutex_lock(&usb_port_peer_mutex);
+        rhdev = hcd->self.root_hub;
+        hcd->self.root_hub = NULL;
+        mutex_unlock(&usb_port_peer_mutex);
+        usb_put_dev(rhdev);
+}
+
 /**
  * usb_add_hcd - finish generic HCD structure initialization and register
  * @hcd: the usb_hcd structure to initialize
@@ -2649,7 +2675,9 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 retval = -ENOMEM;
                 goto err_allocate_root_hub;
         }
+        mutex_lock(&usb_port_peer_mutex);
         hcd->self.root_hub = rhdev;
+        mutex_unlock(&usb_port_peer_mutex);
 
         switch (hcd->speed) {
         case HCD_USB11:
@@ -2758,7 +2786,7 @@ err_hcd_driver_start:
 err_request_irq:
 err_hcd_driver_setup:
 err_set_rh_speed:
-        usb_put_dev(hcd->self.root_hub);
+        usb_put_invalidate_rhdev(hcd);
 err_allocate_root_hub:
         usb_deregister_bus(&hcd->self);
 err_register_bus:
@@ -2838,7 +2866,6 @@ void usb_remove_hcd(struct usb_hcd *hcd)
                         free_irq(hcd->irq, hcd);
         }
 
-        usb_put_dev(hcd->self.root_hub);
         usb_deregister_bus(&hcd->self);
         hcd_buffer_destroy(hcd);
         if (hcd->remove_phy && hcd->phy) {
@@ -2846,6 +2873,8 @@ void usb_remove_hcd(struct usb_hcd *hcd)
                 usb_put_phy(hcd->phy);
                 hcd->phy = NULL;
         }
+
+        usb_put_invalidate_rhdev(hcd);
 }
 EXPORT_SYMBOL_GPL(usb_remove_hcd);
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 090469ebfcff..db6287025c06 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -36,11 +36,6 @@
 #define USB_VENDOR_GENESYS_LOGIC                0x05e3
 #define HUB_QUIRK_CHECK_PORT_AUTOSUSPEND        0x01
 
-static inline int hub_is_superspeed(struct usb_device *hdev)
-{
-        return (hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS);
-}
-
 /* Protect struct usb_device->state and ->children members
  * Note: Both are also protected by ->dev.sem, except that ->state can
  * change to USB_STATE_NOTATTACHED even when the semaphore isn't held. */
@@ -55,6 +50,9 @@ static DECLARE_WAIT_QUEUE_HEAD(khubd_wait);
 
 static struct task_struct *khubd_task;
 
+/* synchronize hub-port add/remove and peering operations */
+DEFINE_MUTEX(usb_port_peer_mutex);
+
 /* cycle leds on hubs that aren't blinking for attention */
 static bool blinkenlights = 0;
 module_param (blinkenlights, bool, S_IRUGO);
@@ -412,30 +410,35 @@ static int set_port_feature(struct usb_device *hdev, int port1, int feature)
                 NULL, 0, 1000);
 }
 
+static char *to_led_name(int selector)
+{
+        switch (selector) {
+        case HUB_LED_AMBER:
+                return "amber";
+        case HUB_LED_GREEN:
+                return "green";
+        case HUB_LED_OFF:
+                return "off";
+        case HUB_LED_AUTO:
+                return "auto";
+        default:
+                return "??";
+        }
+}
+
 /*
  * USB 2.0 spec Section 11.24.2.7.1.10 and table 11-7
  * for info about using port indicators
  */
-static void set_port_led(
-        struct usb_hub *hub,
-        int port1,
-        int selector
-)
+static void set_port_led(struct usb_hub *hub, int port1, int selector)
 {
-        int status = set_port_feature(hub->hdev, (selector << 8) | port1,
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        int status;
+
+        status = set_port_feature(hub->hdev, (selector << 8) | port1,
                         USB_PORT_FEAT_INDICATOR);
-        if (status < 0)
-                dev_dbg (hub->intfdev,
-                        "port %d indicator %s status %d\n",
-                        port1,
-                        ({ char *s; switch (selector) {
-                        case HUB_LED_AMBER: s = "amber"; break;
-                        case HUB_LED_GREEN: s = "green"; break;
-                        case HUB_LED_OFF: s = "off"; break;
-                        case HUB_LED_AUTO: s = "auto"; break;
-                        default: s = "??"; break;
-                        } s; }),
-                        status);
+        dev_dbg(&port_dev->dev, "indicator %s status %d\n",
+                to_led_name(selector), status);
 }
 
 #define LED_CYCLE_PERIOD        ((2*HZ)/3)
@@ -743,16 +746,20 @@ int usb_hub_set_port_power(struct usb_device *hdev, struct usb_hub *hub,
                            int port1, bool set)
 {
         int ret;
-        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         if (set)
                 ret = set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
         else
                 ret = usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
-        if (!ret)
-                port_dev->power_is_on = set;
-        return ret;
+        if (ret)
+                return ret;
+
+        if (set)
+                set_bit(port1, hub->power_bits);
+        else
+                clear_bit(port1, hub->power_bits);
+        return 0;
 }
 
 /**
@@ -810,16 +817,9 @@ int usb_hub_clear_tt_buffer(struct urb *urb)
 }
 EXPORT_SYMBOL_GPL(usb_hub_clear_tt_buffer);
 
-/* If do_delay is false, return the number of milliseconds the caller
- * needs to delay.
- */
-static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
+static void hub_power_on(struct usb_hub *hub, bool do_delay)
 {
         int port1;
-        unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
-        unsigned delay;
-        u16 wHubCharacteristics =
-                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
         /* Enable power on each port.  Some hubs have reserved values
          * of LPSM (> 2) in their descriptors, even though they are
@@ -827,23 +827,19 @@ static unsigned hub_power_on(struct usb_hub *hub, bool do_delay)
          * but only emulate it.  In all cases, the ports won't work
          * unless we send these messages to the hub.
          */
-        if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2)
+        if (hub_is_port_power_switchable(hub))
                 dev_dbg(hub->intfdev, "enabling power on all ports\n");
         else
                 dev_dbg(hub->intfdev, "trying to enable port power on "
                                 "non-switchable hub\n");
         for (port1 = 1; port1 <= hub->hdev->maxchild; port1++)
-                if (hub->ports[port1 - 1]->power_is_on)
+                if (test_bit(port1, hub->power_bits))
                         set_port_feature(hub->hdev, port1, USB_PORT_FEAT_POWER);
                 else
                         usb_clear_port_feature(hub->hdev, port1,
                                                 USB_PORT_FEAT_POWER);
-
-        /* Wait at least 100 msec for power to become stable */
-        delay = max(pgood_delay, (unsigned) 100);
         if (do_delay)
-                msleep(delay);
-        return delay;
+                msleep(hub_power_on_good_delay(hub));
 }
 
 static int hub_hub_status(struct usb_hub *hub,
@@ -911,20 +907,20 @@ static int hub_usb3_port_disable(struct usb_hub *hub, int port1)
                 msleep(HUB_DEBOUNCE_STEP);
         }
         if (total_time >= HUB_DEBOUNCE_TIMEOUT)
-                dev_warn(hub->intfdev, "Could not disable port %d after %d ms\n",
-                                port1, total_time);
+                dev_warn(&hub->ports[port1 - 1]->dev,
+                                "Could not disable after %d ms\n", total_time);
 
         return hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_RX_DETECT);
 }
 
 static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
 {
+        struct usb_port *port_dev = hub->ports[port1 - 1];
         struct usb_device *hdev = hub->hdev;
         int ret = 0;
 
-        if (hub->ports[port1 - 1]->child && set_state)
-                usb_set_device_state(hub->ports[port1 - 1]->child,
-                                USB_STATE_NOTATTACHED);
+        if (port_dev->child && set_state)
+                usb_set_device_state(port_dev->child, USB_STATE_NOTATTACHED);
         if (!hub->error) {
                 if (hub_is_superspeed(hub->hdev))
                         ret = hub_usb3_port_disable(hub, port1);
@@ -933,8 +929,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
                                         USB_PORT_FEAT_ENABLE);
         }
         if (ret && ret != -ENODEV)
-                dev_err(hub->intfdev, "cannot disable port %d (err = %d)\n",
-                                port1, ret);
+                dev_err(&port_dev->dev, "cannot disable (err = %d)\n", ret);
         return ret;
 }
 
@@ -945,7 +940,7 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
  */
 static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
 {
-        dev_dbg(hub->intfdev, "logical disconnect on port %d\n", port1);
+        dev_dbg(&hub->ports[port1 - 1]->dev, "logical disconnect\n");
         hub_port_disable(hub, port1, 1);
 
         /* FIXME let caller ask to power down the port:
@@ -1048,7 +1043,9 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                  * for HUB_POST_RESET, but it's easier not to.
                  */
                 if (type == HUB_INIT) {
-                        delay = hub_power_on(hub, false);
+                        unsigned delay = hub_power_on_good_delay(hub);
+
+                        hub_power_on(hub, false);
                         INIT_DELAYED_WORK(&hub->init_work, hub_init_func2);
                         queue_delayed_work(system_power_efficient_wq,
                                         &hub->init_work,
@@ -1083,21 +1080,23 @@ 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 khubd know
          * which ports need attention.
          */
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device *udev = hub->ports[port1 - 1]->child;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
                 u16 portstatus, portchange;
 
                 portstatus = portchange = 0;
                 status = hub_port_status(hub, port1, &portstatus, &portchange);
                 if (udev || (portstatus & USB_PORT_STAT_CONNECTION))
-                        dev_dbg(hub->intfdev,
-                                        "port %d: status %04x change %04x\n",
-                                        port1, portstatus, portchange);
+                        dev_dbg(&port_dev->dev, "status %04x change %04x\n",
+                                        portstatus, portchange);
 
-                /* After anything other than HUB_RESUME (i.e., initialization
+                /*
+                 * After anything other than HUB_RESUME (i.e., initialization
                  * or any sort of reset), every port should be disabled.
                  * Unconnected ports should likewise be disabled (paranoia),
                  * and so should ports for which we have no usb_device.
@@ -1173,15 +1172,13 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
                                 set_bit(port1, hub->change_bits);
 
                 } else if (udev->persist_enabled) {
-                        struct usb_port *port_dev = hub->ports[port1 - 1];
-
 #ifdef CONFIG_PM
                         udev->reset_resume = 1;
 #endif
                         /* Don't set the change_bits when the device
                          * was powered off.
                          */
-                        if (port_dev->power_is_on)
+                        if (test_bit(port1, hub->power_bits))
                                 set_bit(port1, hub->change_bits);
 
                 } else {
@@ -1276,12 +1273,22 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
                 flush_work(&hub->tt.clear_work);
 }
 
+static void hub_pm_barrier_for_all_ports(struct usb_hub *hub)
+{
+        int i;
+
+        for (i = 0; i < hub->hdev->maxchild; ++i)
+                pm_runtime_barrier(&hub->ports[i]->dev);
+}
+
 /* caller has locked the hub device */
 static int hub_pre_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
         hub_quiesce(hub, HUB_PRE_RESET);
+        hub->in_reset = 1;
+        hub_pm_barrier_for_all_ports(hub);
         return 0;
 }
 
@@ -1290,6 +1297,8 @@ static int hub_post_reset(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
 
+        hub->in_reset = 0;
+        hub_pm_barrier_for_all_ports(hub);
         hub_activate(hub, HUB_POST_RESET);
         return 0;
 }
@@ -1307,6 +1316,7 @@ static int hub_configure(struct usb_hub *hub,
         char *message = "out of memory";
         unsigned unit_load;
         unsigned full_load;
+        unsigned maxchild;
 
         hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
         if (!hub->buffer) {
@@ -1345,12 +1355,11 @@ static int hub_configure(struct usb_hub *hub,
                 goto fail;
         }
 
-        hdev->maxchild = hub->descriptor->bNbrPorts;
-        dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
-                (hdev->maxchild == 1) ? "" : "s");
+        maxchild = hub->descriptor->bNbrPorts;
+        dev_info(hub_dev, "%d port%s detected\n", maxchild,
+                        (maxchild == 1) ? "" : "s");
 
-        hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
-                             GFP_KERNEL);
+        hub->ports = kzalloc(maxchild * sizeof(struct usb_port *), GFP_KERNEL);
         if (!hub->ports) {
                 ret = -ENOMEM;
                 goto fail;
@@ -1371,11 +1380,11 @@ static int hub_configure(struct usb_hub *hub,
                 int     i;
                 char    portstr[USB_MAXCHILDREN + 1];
 
-                for (i = 0; i < hdev->maxchild; i++)
+                for (i = 0; i < maxchild; i++)
                         portstr[i] = hub->descriptor->u.hs.DeviceRemovable
                                     [((i + 1) / 8)] & (1 << ((i + 1) % 8))
                                 ? 'F' : 'R';
-                portstr[hdev->maxchild] = 0;
+                portstr[maxchild] = 0;
                 dev_dbg(hub_dev, "compound device; port removable status: %s\n", portstr);
         } else
                 dev_dbg(hub_dev, "standalone hub\n");
@@ -1487,7 +1496,7 @@ static int hub_configure(struct usb_hub *hub,
                 if (hcd->power_budget > 0)
                         hdev->bus_mA = hcd->power_budget;
                 else
-                        hdev->bus_mA = full_load * hdev->maxchild;
+                        hdev->bus_mA = full_load * maxchild;
                 if (hdev->bus_mA >= full_load)
                         hub->mA_per_port = full_load;
                 else {
@@ -1502,7 +1511,7 @@ static int hub_configure(struct usb_hub *hub,
                         hub->descriptor->bHubContrCurrent);
                 hub->limited_power = 1;
 
-                if (remaining < hdev->maxchild * unit_load)
+                if (remaining < maxchild * unit_load)
                         dev_warn(hub_dev,
                                         "insufficient power available "
                                         "to use all downstream ports\n");
@@ -1570,15 +1579,19 @@ static int hub_configure(struct usb_hub *hub,
         if (hub->has_indicators && blinkenlights)
                 hub->indicator[0] = INDICATOR_CYCLE;
 
-        for (i = 0; i < hdev->maxchild; i++) {
+        mutex_lock(&usb_port_peer_mutex);
+        for (i = 0; i < maxchild; i++) {
                 ret = usb_hub_create_port_device(hub, i + 1);
                 if (ret < 0) {
                         dev_err(hub->intfdev,
                                 "couldn't create port%d device.\n", i + 1);
-                        hdev->maxchild = i;
-                        goto fail_keep_maxchild;
+                        break;
                 }
         }
+        hdev->maxchild = i;
+        mutex_unlock(&usb_port_peer_mutex);
+        if (ret < 0)
+                goto fail;
 
         usb_hub_adjust_deviceremovable(hdev, hub->descriptor);
 
@@ -1586,8 +1599,6 @@ static int hub_configure(struct usb_hub *hub,
         return 0;
 
 fail:
-        hdev->maxchild = 0;
-fail_keep_maxchild:
         dev_err (hub_dev, "config failed, %s (err %d)\n",
                         message, ret);
         /* hub_disconnect() frees urb and descriptor */
@@ -1623,6 +1634,8 @@ static void hub_disconnect(struct usb_interface *intf)
         hub->error = 0;
         hub_quiesce(hub, HUB_DISCONNECT);
 
+        mutex_lock(&usb_port_peer_mutex);
+
         /* Avoid races with recursively_mark_NOTATTACHED() */
         spin_lock_irq(&device_state_lock);
         port1 = hdev->maxchild;
@@ -1633,6 +1646,8 @@ static void hub_disconnect(struct usb_interface *intf)
         for (; port1 > 0; --port1)
                 usb_hub_remove_port_device(hub, port1);
 
+        mutex_unlock(&usb_port_peer_mutex);
+
         if (hub->hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
@@ -2024,6 +2039,18 @@ static void hub_free_dev(struct usb_device *udev)
                 hcd->driver->free_dev(hcd, udev);
 }
 
+static void hub_disconnect_children(struct usb_device *udev)
+{
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev);
+        int i;
+
+        /* Free up all the children before we remove this device */
+        for (i = 0; i < udev->maxchild; i++) {
+                if (hub->ports[i]->child)
+                        usb_disconnect(&hub->ports[i]->child);
+        }
+}
+
 /**
  * usb_disconnect - disconnect a device (usbcore-internal)
  * @pdev: pointer to device being disconnected
@@ -2042,9 +2069,10 @@ static void hub_free_dev(struct usb_device *udev)
  */
 void usb_disconnect(struct usb_device **pdev)
 {
-        struct usb_device       *udev = *pdev;
-        struct usb_hub          *hub = usb_hub_to_struct_hub(udev);
-        int                     i;
+        struct usb_port *port_dev = NULL;
+        struct usb_device *udev = *pdev;
+        struct usb_hub *hub;
+        int port1;
 
         /* mark the device as inactive, so any further urb submissions for
          * this device (and any of its children) will fail immediately.
@@ -2056,11 +2084,7 @@ void usb_disconnect(struct usb_device **pdev)
 
         usb_lock_device(udev);
 
-        /* Free up all the children before we remove this device */
-        for (i = 0; i < udev->maxchild; i++) {
-                if (hub->ports[i]->child)
-                        usb_disconnect(&hub->ports[i]->child);
-        }
+        hub_disconnect_children(udev);
 
         /* deallocate hcd/hardware state ... nuking all pending urbs and
          * cleaning up all state associated with the current configuration
@@ -2071,16 +2095,19 @@ void usb_disconnect(struct usb_device **pdev)
         usb_hcd_synchronize_unlinks(udev);
 
         if (udev->parent) {
-                struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
-                struct usb_port *port_dev = hub->ports[udev->portnum - 1];
+                port1 = udev->portnum;
+                hub = usb_hub_to_struct_hub(udev->parent);
+                port_dev = hub->ports[port1 - 1];
 
                 sysfs_remove_link(&udev->dev.kobj, "port");
                 sysfs_remove_link(&port_dev->dev.kobj, "device");
 
-                if (!port_dev->did_runtime_put)
-                        pm_runtime_put(&port_dev->dev);
-                else
-                        port_dev->did_runtime_put = false;
+                /*
+                 * As usb_port_runtime_resume() de-references udev, make
+                 * sure no resumes occur during removal
+                 */
+                if (!test_and_set_bit(port1, hub->child_usage_bits))
+                        pm_runtime_get_sync(&port_dev->dev);
         }
 
         usb_remove_ep_devs(&udev->ep0);
@@ -2102,6 +2129,9 @@ void usb_disconnect(struct usb_device **pdev)
         *pdev = NULL;
         spin_unlock_irq(&device_state_lock);
 
+        if (port_dev && test_and_clear_bit(port1, hub->child_usage_bits))
+                pm_runtime_put(&port_dev->dev);
+
         hub_free_dev(udev);
 
         put_device(&udev->dev);
@@ -2289,6 +2319,22 @@ static void set_usb_port_removable(struct usb_device *udev)
                 udev->removable = USB_DEVICE_REMOVABLE;
         else
                 udev->removable = USB_DEVICE_FIXED;
+
+        /*
+         * Platform firmware may have populated an alternative value for
+         * removable.  If the parent port has a known connect_type use
+         * that instead.
+         */
+        switch (hub->ports[udev->portnum - 1]->connect_type) {
+        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
+                udev->removable = USB_DEVICE_REMOVABLE;
+                break;
+        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
+                udev->removable = USB_DEVICE_FIXED;
+                break;
+        default: /* use what was set above */
+                break;
+        }
 }
 
 /**
@@ -2358,11 +2404,7 @@ int usb_new_device(struct usb_device *udev)
 
         device_enable_async_suspend(&udev->dev);
 
-        /*
-         * check whether the hub marks this port as non-removable. Do it
-         * now so that platform-specific data can override it in
-         * device_add()
-         */
+        /* check whether the hub or firmware marks this port as non-removable */
         if (udev->parent)
                 set_usb_port_removable(udev);
 
@@ -2379,7 +2421,8 @@ int usb_new_device(struct usb_device *udev)
         /* Create link files between child device and usb port device. */
         if (udev->parent) {
                 struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
-                struct usb_port *port_dev = hub->ports[udev->portnum - 1];
+                int port1 = udev->portnum;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
 
                 err = sysfs_create_link(&udev->dev.kobj,
                                 &port_dev->dev.kobj, "port");
@@ -2393,7 +2436,8 @@ int usb_new_device(struct usb_device *udev)
                         goto fail;
                 }
 
-                pm_runtime_get_sync(&port_dev->dev);
+                if (!test_and_set_bit(port1, hub->child_usage_bits))
+                        pm_runtime_get_sync(&port_dev->dev);
         }
 
         (void) usb_create_ep_devs(&udev->dev, &udev->ep0, udev);
@@ -2561,9 +2605,9 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                 if (delay_time >= 2 * HUB_SHORT_RESET_TIME)
                         delay = HUB_LONG_RESET_TIME;
 
-                dev_dbg (hub->intfdev,
-                        "port %d not %sreset yet, waiting %dms\n",
-                        port1, warm ? "warm " : "", delay);
+                dev_dbg(&hub->ports[port1 - 1]->dev,
+                                "not %sreset yet, waiting %dms\n",
+                                warm ? "warm " : "", delay);
         }
 
         if ((portstatus & USB_PORT_STAT_RESET))
@@ -2647,6 +2691,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
 {
         int i, status;
         u16 portchange, portstatus;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         if (!hub_is_superspeed(hub->hdev)) {
                 if (warm) {
@@ -2680,9 +2725,9 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                 if (status == -ENODEV) {
                         ;       /* The hub is gone */
                 } else if (status) {
-                        dev_err(hub->intfdev,
-                                        "cannot %sreset port %d (err = %d)\n",
-                                        warm ? "warm " : "", port1, status);
+                        dev_err(&port_dev->dev,
+                                        "cannot %sreset (err = %d)\n",
+                                        warm ? "warm " : "", status);
                 } else {
                         status = hub_port_wait_reset(hub, port1, udev, delay,
                                                                 warm);
@@ -2715,21 +2760,19 @@ static int hub_port_reset(struct usb_hub *hub, int port1,
                          * hot or warm reset failed.  Try another warm reset.
                          */
                         if (!warm) {
-                                dev_dbg(hub->intfdev, "hot reset failed, warm reset port %d\n",
-                                                port1);
+                                dev_dbg(&port_dev->dev,
+                                                "hot reset failed, warm reset\n");
                                 warm = true;
                         }
                 }
 
-                dev_dbg (hub->intfdev,
-                        "port %d not enabled, trying %sreset again...\n",
-                        port1, warm ? "warm " : "");
+                dev_dbg(&port_dev->dev,
+                                "not enabled, trying %sreset again...\n",
+                                warm ? "warm " : "");
                 delay = HUB_LONG_RESET_TIME;
         }
 
-        dev_err (hub->intfdev,
-                "Cannot enable port %i.  Maybe the USB cable is bad?\n",
-                port1);
+        dev_err(&port_dev->dev, "Cannot enable. Maybe the USB cable is bad?\n");
 
 done:
         if (!hub_is_superspeed(hub->hdev))
@@ -2754,6 +2797,20 @@ static int port_is_power_on(struct usb_hub *hub, unsigned portstatus)
         return ret;
 }
 
+static void usb_lock_port(struct usb_port *port_dev)
+                __acquires(&port_dev->status_lock)
+{
+        mutex_lock(&port_dev->status_lock);
+        __acquire(&port_dev->status_lock);
+}
+
+static void usb_unlock_port(struct usb_port *port_dev)
+                __releases(&port_dev->status_lock)
+{
+        mutex_unlock(&port_dev->status_lock);
+        __release(&port_dev->status_lock);
+}
+
 #ifdef  CONFIG_PM
 
 /* Check if a port is suspended(USB2.0 port) or in U3 state(USB3.0 port) */
@@ -2780,6 +2837,8 @@ static int check_port_resume_type(struct usb_device *udev,
                 struct usb_hub *hub, int port1,
                 int status, unsigned portchange, unsigned portstatus)
 {
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+
         /* Is the device still present? */
         if (status || port_is_suspended(hub, portstatus) ||
                         !port_is_power_on(hub, portstatus) ||
@@ -2799,9 +2858,8 @@ static int check_port_resume_type(struct usb_device *udev,
         }
 
         if (status) {
-                dev_dbg(hub->intfdev,
-                                "port %d status %04x.%04x after resume, %d\n",
-                                port1, portchange, portstatus, status);
+                dev_dbg(&port_dev->dev, "status %04x.%04x after resume, %d\n",
+                                portchange, portstatus, status);
         } else if (udev->reset_resume) {
 
                 /* Late port handoff can set status-change bits */
@@ -2975,6 +3033,8 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
         int             status;
         bool            really_suspend = true;
 
+        usb_lock_port(port_dev);
+
         /* enable remote wakeup when appropriate; this lets the device
          * wake up the upstream hub (including maybe the root hub).
          *
@@ -3032,8 +3092,7 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 status = 0;
         }
         if (status) {
-                dev_dbg(hub->intfdev, "can't suspend port %d, status %d\n",
-                                port1, status);
+                dev_dbg(&port_dev->dev, "can't suspend, status %d\n", status);
 
                 /* Try to enable USB3 LPM and LTM again */
                 usb_unlocked_enable_lpm(udev);
@@ -3064,12 +3123,13 @@ int usb_port_suspend(struct usb_device *udev, pm_message_t msg)
                 usb_set_device_state(udev, USB_STATE_SUSPENDED);
         }
 
-        if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled) {
+        if (status == 0 && !udev->do_remote_wakeup && udev->persist_enabled
+                        && test_and_clear_bit(port1, hub->child_usage_bits))
                 pm_runtime_put_sync(&port_dev->dev);
-                port_dev->did_runtime_put = true;
-        }
 
         usb_mark_last_busy(hub->hdev);
+
+        usb_unlock_port(port_dev);
         return status;
 }
 
@@ -3209,9 +3269,8 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         int             status;
         u16             portchange, portstatus;
 
-        if (port_dev->did_runtime_put) {
+        if (!test_and_set_bit(port1, hub->child_usage_bits)) {
                 status = pm_runtime_get_sync(&port_dev->dev);
-                port_dev->did_runtime_put = false;
                 if (status < 0) {
                         dev_dbg(&udev->dev, "can't resume usb port, status %d\n",
                                         status);
@@ -3219,15 +3278,13 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
+        usb_lock_port(port_dev);
+
         /* Skip the initial Clear-Suspend step for a remote wakeup */
         status = hub_port_status(hub, port1, &portstatus, &portchange);
         if (status == 0 && !port_is_suspended(hub, portstatus))
                 goto SuspendCleared;
 
-        /* dev_dbg(hub->intfdev, "resume port %d\n", port1); */
-
-        set_bit(port1, hub->busy_bits);
-
         /* see 7.1.7.7; affects power usage, but not budgeting */
         if (hub_is_superspeed(hub->hdev))
                 status = hub_set_port_link_state(hub, port1, USB_SS_PORT_LS_U0);
@@ -3235,8 +3292,7 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 status = usb_clear_port_feature(hub->hdev,
                                 port1, USB_PORT_FEAT_SUSPEND);
         if (status) {
-                dev_dbg(hub->intfdev, "can't resume port %d, status %d\n",
-                                port1, status);
+                dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
         } else {
                 /* drive resume for at least 20 msec */
                 dev_dbg(&udev->dev, "usb %sresume\n",
@@ -3267,8 +3323,6 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 }
         }
 
-        clear_bit(port1, hub->busy_bits);
-
         status = check_port_resume_type(udev,
                         hub, port1, status, portchange, portstatus);
         if (status == 0)
@@ -3286,16 +3340,18 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
                 usb_unlocked_enable_lpm(udev);
         }
 
+        usb_unlock_port(port_dev);
+
         return status;
 }
 
 #ifdef  CONFIG_PM_RUNTIME
 
-/* caller has locked udev */
 int usb_remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
+        usb_lock_device(udev);
         if (udev->state == USB_STATE_SUSPENDED) {
                 dev_dbg(&udev->dev, "usb %sresume\n", "wakeup-");
                 status = usb_autoresume_device(udev);
@@ -3304,9 +3360,59 @@ int usb_remote_wakeup(struct usb_device *udev)
                         usb_autosuspend_device(udev);
                 }
         }
+        usb_unlock_device(udev);
         return status;
 }
 
+/* Returns 1 if there was a remote wakeup and a connect status change. */
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+                __must_hold(&port_dev->status_lock)
+{
+        struct usb_port *port_dev = hub->ports[port - 1];
+        struct usb_device *hdev;
+        struct usb_device *udev;
+        int connect_change = 0;
+        int ret;
+
+        hdev = hub->hdev;
+        udev = port_dev->child;
+        if (!hub_is_superspeed(hdev)) {
+                if (!(portchange & USB_PORT_STAT_C_SUSPEND))
+                        return 0;
+                usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
+        } else {
+                if (!udev || udev->state != USB_STATE_SUSPENDED ||
+                                 (portstatus & USB_PORT_STAT_LINK_STATE) !=
+                                 USB_SS_PORT_LS_U0)
+                        return 0;
+        }
+
+        if (udev) {
+                /* TRSMRCY = 10 msec */
+                msleep(10);
+
+                usb_unlock_port(port_dev);
+                ret = usb_remote_wakeup(udev);
+                usb_lock_port(port_dev);
+                if (ret < 0)
+                        connect_change = 1;
+        } else {
+                ret = -ENODEV;
+                hub_port_disable(hub, port, 1);
+        }
+        dev_dbg(&port_dev->dev, "resume, status %d\n", ret);
+        return connect_change;
+}
+
+#else
+
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+{
+        return 0;
+}
+
 #endif
 
 static int check_ports_changed(struct usb_hub *hub)
@@ -3337,12 +3443,11 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
          */
         hub->wakeup_enabled_descendants = 0;
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
-                struct usb_device       *udev;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
 
-                udev = hub->ports[port1 - 1]->child;
                 if (udev && udev->can_submit) {
-                        dev_warn(&intf->dev, "port %d not suspended yet\n",
-                                        port1);
+                        dev_warn(&port_dev->dev, "not suspended yet\n");
                         if (PMSG_IS_AUTO(msg))
                                 return -EBUSY;
                 }
@@ -3861,6 +3966,12 @@ EXPORT_SYMBOL_GPL(usb_disable_ltm);
 void usb_enable_ltm(struct usb_device *udev) { }
 EXPORT_SYMBOL_GPL(usb_enable_ltm);
 
+static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
+                u16 portstatus, u16 portchange)
+{
+        return 0;
+}
+
 #endif  /* CONFIG_PM */
 
 
@@ -3882,9 +3993,10 @@ EXPORT_SYMBOL_GPL(usb_enable_ltm);
 int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
 {
         int ret;
-        int total_time, stable_time = 0;
         u16 portchange, portstatus;
         unsigned connection = 0xffff;
+        int total_time, stable_time = 0;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
 
         for (total_time = 0; ; total_time += HUB_DEBOUNCE_STEP) {
                 ret = hub_port_status(hub, port1, &portstatus, &portchange);
@@ -3913,9 +4025,8 @@ int hub_port_debounce(struct usb_hub *hub, int port1, bool must_be_connected)
                 msleep(HUB_DEBOUNCE_STEP);
         }
 
-        dev_dbg (hub->intfdev,
-                "debounce: port %d: total %dms stable %dms status 0x%x\n",
-                port1, total_time, stable_time, portstatus);
+        dev_dbg(&port_dev->dev, "debounce total %dms stable %dms status 0x%x\n",
+                        total_time, stable_time, portstatus);
 
         if (stable_time < HUB_DEBOUNCE_STABLE)
                 return -ETIMEDOUT;
@@ -3974,13 +4085,14 @@ static int hub_set_address(struct usb_device *udev, int devnum)
  */
 static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
 {
-        int connect_type;
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
+        int connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
 
         if (!udev->usb2_hw_lpm_capable)
                 return;
 
-        connect_type = usb_get_hub_port_connect_type(udev->parent,
-                        udev->portnum);
+        if (hub)
+                connect_type = hub->ports[udev->portnum - 1]->connect_type;
 
         if ((udev->bos->ext_cap->bmAttributes & cpu_to_le32(USB_BESL_SUPPORT)) ||
                         connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
@@ -4008,16 +4120,15 @@ static int hub_enable_device(struct usb_device *udev)
  * Returns device in USB_STATE_ADDRESS, except on error.
  *
  * If this is called for an already-existing device (as part of
- * usb_reset_and_verify_device), the caller must own the device lock.  For a
- * newly detected device that is not accessible through any global
- * pointers, it's not necessary to lock the device.
+ * usb_reset_and_verify_device), the caller must own the device lock and
+ * the port lock.  For a newly detected device that is not accessible
+ * through any global pointers, it's not necessary to lock the device,
+ * but it is still necessary to lock the port.
  */
 static int
 hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                 int retry_counter)
 {
-        static DEFINE_MUTEX(usb_address0_mutex);
-
         struct usb_device       *hdev = hub->hdev;
         struct usb_hcd          *hcd = bus_to_hcd(hdev->bus);
         int                     i, j, retval;
@@ -4040,7 +4151,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
         if (oldspeed == USB_SPEED_LOW)
                 delay = HUB_LONG_RESET_TIME;
 
-        mutex_lock(&usb_address0_mutex);
+        mutex_lock(&hdev->bus->usb_address0_mutex);
 
         /* Reset the device; full speed may morph to high speed */
         /* FIXME a USB 2.0 device may morph into SuperSpeed on reset. */
@@ -4317,7 +4428,7 @@ fail:
                 hub_port_disable(hub, port1, 0);
                 update_devnum(udev, devnum);    /* for disconnect processing */
         }
-        mutex_unlock(&usb_address0_mutex);
+        mutex_unlock(&hdev->bus->usb_address0_mutex);
         return retval;
 }
 
@@ -4358,9 +4469,10 @@ hub_power_remaining (struct usb_hub *hub)
 
         remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device       *udev = hub->ports[port1 - 1]->child;
-                int                     delta;
-                unsigned                unit_load;
+                struct usb_port *port_dev = hub->ports[port1 - 1];
+                struct usb_device *udev = port_dev->child;
+                unsigned unit_load;
+                int delta;
 
                 if (!udev)
                         continue;
@@ -4380,9 +4492,8 @@ hub_power_remaining (struct usb_hub *hub)
                 else
                         delta = 8;
                 if (delta > hub->mA_per_port)
-                        dev_warn(&udev->dev,
-                                 "%dmA is over %umA budget for port %d!\n",
-                                 delta, hub->mA_per_port, port1);
+                        dev_warn(&port_dev->dev, "%dmA is over %umA budget!\n",
+                                        delta, hub->mA_per_port);
                 remaining -= delta;
         }
         if (remaining < 0) {
@@ -4393,78 +4504,23 @@ hub_power_remaining (struct usb_hub *hub)
         return remaining;
 }
 
-/* Handle physical or logical connection change events.
- * This routine is called when:
- *      a port connection-change occurs;
- *      a port enable-change occurs (often caused by EMI);
- *      usb_reset_and_verify_device() encounters changed descriptors (as from
- *              a firmware download)
- * caller already locked the hub
- */
-static void hub_port_connect_change(struct usb_hub *hub, int port1,
-                                        u16 portstatus, u16 portchange)
+static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
+                u16 portchange)
 {
-        struct usb_device *hdev = hub->hdev;
-        struct device *hub_dev = hub->intfdev;
-        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
-        unsigned wHubCharacteristics =
-                        le16_to_cpu(hub->descriptor->wHubCharacteristics);
-        struct usb_device *udev;
         int status, i;
         unsigned unit_load;
-
-        dev_dbg (hub_dev,
-                "port %d, status %04x, change %04x, %s\n",
-                port1, portstatus, portchange, portspeed(hub, portstatus));
-
-        if (hub->has_indicators) {
-                set_port_led(hub, port1, HUB_LED_AUTO);
-                hub->indicator[port1-1] = INDICATOR_AUTO;
-        }
-
-#ifdef  CONFIG_USB_OTG
-        /* during HNP, don't repeat the debounce */
-        if (hdev->bus->is_b_host)
-                portchange &= ~(USB_PORT_STAT_C_CONNECTION |
-                                USB_PORT_STAT_C_ENABLE);
-#endif
-
-        /* Try to resuscitate an existing device */
-        udev = hub->ports[port1 - 1]->child;
-        if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
-                        udev->state != USB_STATE_NOTATTACHED) {
-                usb_lock_device(udev);
-                if (portstatus & USB_PORT_STAT_ENABLE) {
-                        status = 0;             /* Nothing to do */
-
-#ifdef CONFIG_PM_RUNTIME
-                } else if (udev->state == USB_STATE_SUSPENDED &&
-                                udev->persist_enabled) {
-                        /* For a suspended device, treat this as a
-                         * remote wakeup event.
-                         */
-                        status = usb_remote_wakeup(udev);
-#endif
-
-                } else {
-                        status = -ENODEV;       /* Don't resuscitate */
-                }
-                usb_unlock_device(udev);
-
-                if (status == 0) {
-                        clear_bit(port1, hub->change_bits);
-                        return;
-                }
-        }
+        struct usb_device *hdev = hub->hdev;
+        struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
 
         /* Disconnect any existing devices under this port */
         if (udev) {
                 if (hcd->phy && !hdev->parent &&
                                 !(portstatus & USB_PORT_STAT_CONNECTION))
                         usb_phy_notify_disconnect(hcd->phy, udev->speed);
-                usb_disconnect(&hub->ports[port1 - 1]->child);
+                usb_disconnect(&port_dev->child);
         }
-        clear_bit(port1, hub->change_bits);
 
         /* We can forget about a "removed" device when there's a physical
          * disconnect or the connect status changes.
@@ -4478,8 +4534,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 status = hub_port_debounce_be_stable(hub, port1);
                 if (status < 0) {
                         if (status != -ENODEV && printk_ratelimit())
-                                dev_err(hub_dev, "connect-debounce failed, "
-                                                "port %d disabled\n", port1);
+                                dev_err(&port_dev->dev,
+                                                "connect-debounce failed\n");
                         portstatus &= ~USB_PORT_STAT_CONNECTION;
                 } else {
                         portstatus = status;
@@ -4493,7 +4549,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         test_bit(port1, hub->removed_bits)) {
 
                 /* maybe switch power back on (e.g. root hub was reset) */
-                if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
+                if (hub_is_port_power_switchable(hub)
                                 && !port_is_power_on(hub, portstatus))
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
 
@@ -4514,9 +4570,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                  */
                 udev = usb_alloc_dev(hdev, hdev->bus, port1);
                 if (!udev) {
-                        dev_err (hub_dev,
-                                "couldn't allocate port %d usb_device\n",
-                                port1);
+                        dev_err(&port_dev->dev,
+                                        "couldn't allocate usb_device\n");
                         goto done;
                 }
 
@@ -4538,7 +4593,9 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 }
 
                 /* reset (non-USB 3.0 devices) and get descriptor */
+                usb_lock_port(port_dev);
                 status = hub_port_init(hub, udev, port1, i);
+                usb_unlock_port(port_dev);
                 if (status < 0)
                         goto loop;
 
@@ -4590,6 +4647,8 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                  */
                 status = 0;
 
+                mutex_lock(&usb_port_peer_mutex);
+
                 /* We mustn't add new devices if the parent hub has
                  * been disconnected; we would race with the
                  * recursively_mark_NOTATTACHED() routine.
@@ -4598,16 +4657,19 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 if (hdev->state == USB_STATE_NOTATTACHED)
                         status = -ENOTCONN;
                 else
-                        hub->ports[port1 - 1]->child = udev;
+                        port_dev->child = udev;
                 spin_unlock_irq(&device_state_lock);
+                mutex_unlock(&usb_port_peer_mutex);
 
                 /* Run it through the hoops (find a driver, etc) */
                 if (!status) {
                         status = usb_new_device(udev);
                         if (status) {
+                                mutex_lock(&usb_port_peer_mutex);
                                 spin_lock_irq(&device_state_lock);
-                                hub->ports[port1 - 1]->child = NULL;
+                                port_dev->child = NULL;
                                 spin_unlock_irq(&device_state_lock);
+                                mutex_unlock(&usb_port_peer_mutex);
                         }
                 }
 
@@ -4616,7 +4678,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
                 status = hub_power_remaining(hub);
                 if (status)
-                        dev_dbg(hub_dev, "%dmA power budget left\n", status);
+                        dev_dbg(hub->intfdev, "%dmA power budget left\n", status);
 
                 return;
 
@@ -4634,56 +4696,200 @@ loop:
                         !hcd->driver->port_handed_over ||
                         !(hcd->driver->port_handed_over)(hcd, port1)) {
                 if (status != -ENOTCONN && status != -ENODEV)
-                        dev_err(hub_dev, "unable to enumerate USB device on port %d\n",
-                                        port1);
+                        dev_err(&port_dev->dev,
+                                        "unable to enumerate USB device\n");
         }
 
 done:
         hub_port_disable(hub, port1, 1);
         if (hcd->driver->relinquish_port && !hub->hdev->parent)
                 hcd->driver->relinquish_port(hcd, port1);
+
 }
 
-/* Returns 1 if there was a remote wakeup and a connect status change. */
-static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
-                u16 portstatus, u16 portchange)
+/* Handle physical or logical connection change events.
+ * This routine is called when:
+ *      a port connection-change occurs;
+ *      a port enable-change occurs (often caused by EMI);
+ *      usb_reset_and_verify_device() encounters changed descriptors (as from
+ *              a firmware download)
+ * caller already locked the hub
+ */
+static void hub_port_connect_change(struct usb_hub *hub, int port1,
+                                        u16 portstatus, u16 portchange)
+                __must_hold(&port_dev->status_lock)
 {
-        struct usb_device *hdev;
-        struct usb_device *udev;
-        int connect_change = 0;
-        int ret;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
+        int status = -ENODEV;
 
-        hdev = hub->hdev;
-        udev = hub->ports[port - 1]->child;
-        if (!hub_is_superspeed(hdev)) {
-                if (!(portchange & USB_PORT_STAT_C_SUSPEND))
-                        return 0;
-                usb_clear_port_feature(hdev, port, USB_PORT_FEAT_C_SUSPEND);
-        } else {
-                if (!udev || udev->state != USB_STATE_SUSPENDED ||
-                                 (portstatus & USB_PORT_STAT_LINK_STATE) !=
-                                 USB_SS_PORT_LS_U0)
-                        return 0;
+        dev_dbg(&port_dev->dev, "status %04x, change %04x, %s\n", portstatus,
+                        portchange, portspeed(hub, portstatus));
+
+        if (hub->has_indicators) {
+                set_port_led(hub, port1, HUB_LED_AUTO);
+                hub->indicator[port1-1] = INDICATOR_AUTO;
         }
 
-        if (udev) {
-                /* TRSMRCY = 10 msec */
-                msleep(10);
+#ifdef  CONFIG_USB_OTG
+        /* during HNP, don't repeat the debounce */
+        if (hub->hdev->bus->is_b_host)
+                portchange &= ~(USB_PORT_STAT_C_CONNECTION |
+                                USB_PORT_STAT_C_ENABLE);
+#endif
+
+        /* Try to resuscitate an existing device */
+        if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
+                        udev->state != USB_STATE_NOTATTACHED) {
+                if (portstatus & USB_PORT_STAT_ENABLE) {
+                        status = 0;             /* Nothing to do */
+#ifdef CONFIG_PM_RUNTIME
+                } else if (udev->state == USB_STATE_SUSPENDED &&
+                                udev->persist_enabled) {
+                        /* For a suspended device, treat this as a
+                         * remote wakeup event.
+                         */
+                        usb_unlock_port(port_dev);
+                        status = usb_remote_wakeup(udev);
+                        usb_lock_port(port_dev);
+#endif
+                } else {
+                        /* Don't resuscitate */;
+                }
+        }
+        clear_bit(port1, hub->change_bits);
+
+        /* successfully revalidated the connection */
+        if (status == 0)
+                return;
+
+        usb_unlock_port(port_dev);
+        hub_port_connect(hub, port1, portstatus, portchange);
+        usb_lock_port(port_dev);
+}
+
+static void port_event(struct usb_hub *hub, int port1)
+                __must_hold(&port_dev->status_lock)
+{
+        int connect_change, reset_device = 0;
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_device *udev = port_dev->child;
+        struct usb_device *hdev = hub->hdev;
+        u16 portstatus, portchange;
+
+        connect_change = test_bit(port1, hub->change_bits);
+        clear_bit(port1, hub->event_bits);
+        clear_bit(port1, hub->wakeup_bits);
+
+        if (hub_port_status(hub, port1, &portstatus, &portchange) < 0)
+                return;
+
+        if (portchange & USB_PORT_STAT_C_CONNECTION) {
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
+                connect_change = 1;
+        }
+
+        if (portchange & USB_PORT_STAT_C_ENABLE) {
+                if (!connect_change)
+                        dev_dbg(&port_dev->dev, "enable change, status %08x\n",
+                                        portstatus);
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
+
+                /*
+                 * EM interference sometimes causes badly shielded USB devices
+                 * to be shutdown by the hub, this hack enables them again.
+                 * Works at least with mouse driver.
+                 */
+                if (!(portstatus & USB_PORT_STAT_ENABLE)
+                    && !connect_change && udev) {
+                        dev_err(&port_dev->dev, "disabled by hub (EMI?), re-enabling...\n");
+                        connect_change = 1;
+                }
+        }
+
+        if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
+                u16 status = 0, unused;
+
+                dev_dbg(&port_dev->dev, "over-current change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_OVER_CURRENT);
+                msleep(100);    /* Cool down */
+                hub_power_on(hub, true);
+                hub_port_status(hub, port1, &status, &unused);
+                if (status & USB_PORT_STAT_OVERCURRENT)
+                        dev_err(&port_dev->dev, "over-current condition\n");
+        }
+
+        if (portchange & USB_PORT_STAT_C_RESET) {
+                dev_dbg(&port_dev->dev, "reset change\n");
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_RESET);
+        }
+        if ((portchange & USB_PORT_STAT_C_BH_RESET)
+            && hub_is_superspeed(hdev)) {
+                dev_dbg(&port_dev->dev, "warm reset change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_BH_PORT_RESET);
+        }
+        if (portchange & USB_PORT_STAT_C_LINK_STATE) {
+                dev_dbg(&port_dev->dev, "link state change\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_PORT_LINK_STATE);
+        }
+        if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
+                dev_warn(&port_dev->dev, "config error\n");
+                usb_clear_port_feature(hdev, port1,
+                                USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
+        }
+
+        /* skip port actions that require the port to be powered on */
+        if (!pm_runtime_active(&port_dev->dev))
+                return;
 
+        if (hub_handle_remote_wakeup(hub, port1, portstatus, portchange))
+                connect_change = 1;
+
+        /*
+         * Warm reset a USB3 protocol port if it's in
+         * SS.Inactive state.
+         */
+        if (hub_port_warm_reset_required(hub, portstatus)) {
+                dev_dbg(&port_dev->dev, "do warm reset\n");
+                if (!udev || !(portstatus & USB_PORT_STAT_CONNECTION)
+                                || udev->state == USB_STATE_NOTATTACHED) {
+                        if (hub_port_reset(hub, port1, NULL,
+                                        HUB_BH_RESET_TIME, true) < 0)
+                                hub_port_disable(hub, port1, 1);
+                } else
+                        reset_device = 1;
+        }
+
+        /*
+         * 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
+         * device may be an unknown state.
+         *
+         * If the port went through SS.Inactive without khubd
+         * seeing it the C_LINK_STATE change flag will be set,
+         * and we reset the dev to put it in a known state.
+         */
+        if (reset_device || (udev && hub_is_superspeed(hub->hdev)
+                                && (portchange & USB_PORT_STAT_C_LINK_STATE)
+                                && (portstatus & USB_PORT_STAT_CONNECTION))) {
+                usb_unlock_port(port_dev);
                 usb_lock_device(udev);
-                ret = usb_remote_wakeup(udev);
+                usb_reset_device(udev);
                 usb_unlock_device(udev);
-                if (ret < 0)
-                        connect_change = 1;
-        } else {
-                ret = -ENODEV;
-                hub_port_disable(hub, port, 1);
+                usb_lock_port(port_dev);
+                connect_change = 0;
         }
-        dev_dbg(hub->intfdev, "resume on port %d, status %d\n",
-                        port, ret);
-        return connect_change;
+
+        if (connect_change)
+                hub_port_connect_change(hub, port1, portstatus, portchange);
 }
 
+
 static void hub_events(void)
 {
         struct list_head *tmp;
@@ -4693,10 +4899,7 @@ static void hub_events(void)
         struct device *hub_dev;
         u16 hubstatus;
         u16 hubchange;
-        u16 portstatus;
-        u16 portchange;
         int i, ret;
-        int connect_change, wakeup_change;
 
         /*
          *  We restart the list every time to avoid a deadlock with
@@ -4770,146 +4973,28 @@ static void hub_events(void)
 
                 /* deal with port status changes */
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        struct usb_device *udev = hub->ports[i - 1]->child;
-
-                        if (test_bit(i, hub->busy_bits))
-                                continue;
-                        connect_change = test_bit(i, hub->change_bits);
-                        wakeup_change = test_and_clear_bit(i, hub->wakeup_bits);
-                        if (!test_and_clear_bit(i, hub->event_bits) &&
-                                        !connect_change && !wakeup_change)
-                                continue;
-
-                        ret = hub_port_status(hub, i,
-                                        &portstatus, &portchange);
-                        if (ret < 0)
-                                continue;
-
-                        if (portchange & USB_PORT_STAT_C_CONNECTION) {
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_CONNECTION);
-                                connect_change = 1;
-                        }
-
-                        if (portchange & USB_PORT_STAT_C_ENABLE) {
-                                if (!connect_change)
-                                        dev_dbg (hub_dev,
-                                                "port %d enable change, "
-                                                "status %08x\n",
-                                                i, portstatus);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_ENABLE);
+                        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)) {
                                 /*
-                                 * EM interference sometimes causes badly
-                                 * shielded USB devices to be shutdown by
-                                 * the hub, this hack enables them again.
-                                 * Works at least with mouse driver.
+                                 * 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.
                                  */
-                                if (!(portstatus & USB_PORT_STAT_ENABLE)
-                                    && !connect_change
-                                    && hub->ports[i - 1]->child) {
-                                        dev_err (hub_dev,
-                                            "port %i "
-                                            "disabled by hub (EMI?), "
-                                            "re-enabling...\n",
-                                                i);
-                                        connect_change = 1;
-                                }
-                        }
-
-                        if (hub_handle_remote_wakeup(hub, i,
-                                                portstatus, portchange))
-                                connect_change = 1;
-
-                        if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
-                                u16 status = 0;
-                                u16 unused;
-
-                                dev_dbg(hub_dev, "over-current change on port "
-                                        "%d\n", i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_OVER_CURRENT);
-                                msleep(100);    /* Cool down */
-                                hub_power_on(hub, true);
-                                hub_port_status(hub, i, &status, &unused);
-                                if (status & USB_PORT_STAT_OVERCURRENT)
-                                        dev_err(hub_dev, "over-current "
-                                                "condition on port %d\n", i);
-                        }
-
-                        if (portchange & USB_PORT_STAT_C_RESET) {
-                                dev_dbg (hub_dev,
-                                        "reset change on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_RESET);
-                        }
-                        if ((portchange & USB_PORT_STAT_C_BH_RESET) &&
-                                        hub_is_superspeed(hub->hdev)) {
-                                dev_dbg(hub_dev,
-                                        "warm reset change on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hdev, i,
-                                        USB_PORT_FEAT_C_BH_PORT_RESET);
-                        }
-                        if (portchange & USB_PORT_STAT_C_LINK_STATE) {
-                                usb_clear_port_feature(hub->hdev, i,
-                                                USB_PORT_FEAT_C_PORT_LINK_STATE);
-                        }
-                        if (portchange & USB_PORT_STAT_C_CONFIG_ERROR) {
-                                dev_warn(hub_dev,
-                                        "config error on port %d\n",
-                                        i);
-                                usb_clear_port_feature(hub->hdev, i,
-                                                USB_PORT_FEAT_C_PORT_CONFIG_ERROR);
+                                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);
                         }
-
-                        /* Warm reset a USB3 protocol port if it's in
-                         * SS.Inactive state.
-                         */
-                        if (hub_port_warm_reset_required(hub, portstatus)) {
-                                int status;
-
-                                dev_dbg(hub_dev, "warm reset port %d\n", i);
-                                if (!udev ||
-                                    !(portstatus & USB_PORT_STAT_CONNECTION) ||
-                                    udev->state == USB_STATE_NOTATTACHED) {
-                                        status = hub_port_reset(hub, i,
-                                                        NULL, HUB_BH_RESET_TIME,
-                                                        true);
-                                        if (status < 0)
-                                                hub_port_disable(hub, i, 1);
-                                } else {
-                                        usb_lock_device(udev);
-                                        status = usb_reset_device(udev);
-                                        usb_unlock_device(udev);
-                                        connect_change = 0;
-                                }
-                        /*
-                         * 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
-                         * device may be an unknown state.
-                         *
-                         * If the port went through SS.Inactive without khubd
-                         * seeing it the C_LINK_STATE change flag will be set,
-                         * and we reset the dev to put it in a known state.
-                         */
-                        } else if (udev && hub_is_superspeed(hub->hdev) &&
-                                   (portchange & USB_PORT_STAT_C_LINK_STATE) &&
-                                   (portstatus & USB_PORT_STAT_CONNECTION)) {
-                                usb_lock_device(udev);
-                                usb_reset_device(udev);
-                                usb_unlock_device(udev);
-                                connect_change = 0;
-                        }
-
-                        if (connect_change)
-                                hub_port_connect_change(hub, i,
-                                                portstatus, portchange);
-                } /* end for i */
+                }
 
                 /* deal with hub status changes */
                 if (test_and_clear_bit(0, hub->event_bits) == 0)
@@ -5144,15 +5229,18 @@ static int descriptors_changed(struct usb_device *udev,
  * if the reset wasn't even attempted.
  *
  * Note:
- * The caller must own the device lock.  For example, it's safe to use
- * this from a driver probe() routine after downloading new firmware.
- * For calls that might not occur during probe(), drivers should lock
- * the device using usb_lock_device_for_reset().
+ * The caller must own the device lock and the port lock, the latter is
+ * taken by usb_reset_device().  For example, it's safe to use
+ * usb_reset_device() from a driver probe() routine after downloading
+ * new firmware.  For calls that might not occur during probe(), drivers
+ * should lock the device using usb_lock_device_for_reset().
  *
  * Locking exception: This routine may also be called from within an
  * autoresume handler.  Such usage won't conflict with other tasks
  * holding the device lock because these tasks should always call
- * usb_autopm_resume_device(), thereby preventing any unwanted autoresume.
+ * usb_autopm_resume_device(), thereby preventing any unwanted
+ * autoresume.  The autoresume handler is expected to have already
+ * acquired the port lock before calling this routine.
  */
 static int usb_reset_and_verify_device(struct usb_device *udev)
 {
@@ -5171,11 +5259,9 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 return -EINVAL;
         }
 
-        if (!parent_hdev) {
-                /* this requires hcd-specific logic; see ohci_restart() */
-                dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
+        if (!parent_hdev)
                 return -EISDIR;
-        }
+
         parent_hub = usb_hub_to_struct_hub(parent_hdev);
 
         /* Disable USB2 hardware LPM.
@@ -5204,7 +5290,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 goto re_enumerate;
         }
 
-        set_bit(port1, parent_hub->busy_bits);
         for (i = 0; i < SET_CONFIG_TRIES; ++i) {
 
                 /* ep0 maxpacket size may change; let the HCD know about it.
@@ -5214,7 +5299,6 @@ static int usb_reset_and_verify_device(struct usb_device *udev)
                 if (ret >= 0 || ret == -ENOTCONN || ret == -ENODEV)
                         break;
         }
-        clear_bit(port1, parent_hub->busy_bits);
 
         if (ret < 0)
                 goto re_enumerate;
@@ -5335,7 +5419,9 @@ int usb_reset_device(struct usb_device *udev)
         int ret;
         int i;
         unsigned int noio_flag;
+        struct usb_port *port_dev;
         struct usb_host_config *config = udev->actconfig;
+        struct usb_hub *hub = usb_hub_to_struct_hub(udev->parent);
 
         if (udev->state == USB_STATE_NOTATTACHED ||
                         udev->state == USB_STATE_SUSPENDED) {
@@ -5344,6 +5430,14 @@ int usb_reset_device(struct usb_device *udev)
                 return -EINVAL;
         }
 
+        if (!udev->parent) {
+                /* this requires hcd-specific logic; see ohci_restart() */
+                dev_dbg(&udev->dev, "%s for root hub!\n", __func__);
+                return -EISDIR;
+        }
+
+        port_dev = hub->ports[udev->portnum - 1];
+
         /*
          * Don't allocate memory with GFP_KERNEL in current
          * context to avoid possible deadlock if usb mass
@@ -5377,7 +5471,9 @@ int usb_reset_device(struct usb_device *udev)
                 }
         }
 
+        usb_lock_port(port_dev);
         ret = usb_reset_and_verify_device(udev);
+        usb_unlock_port(port_dev);
 
         if (config) {
                 for (i = config->desc.bNumInterfaces - 1; i >= 0; --i) {
@@ -5472,56 +5568,26 @@ struct usb_device *usb_hub_find_child(struct usb_device *hdev,
 }
 EXPORT_SYMBOL_GPL(usb_hub_find_child);
 
-/**
- * usb_set_hub_port_connect_type - set hub port connect type.
- * @hdev: USB device belonging to the usb hub
- * @port1: port num of the port
- * @type: connect type of the port
- */
-void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
-        enum usb_port_connect_type type)
-{
-        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
-
-        if (hub)
-                hub->ports[port1 - 1]->connect_type = type;
-}
-
-/**
- * usb_get_hub_port_connect_type - Get the port's connect type
- * @hdev: USB device belonging to the usb hub
- * @port1: port num of the port
- *
- * Return: The connect type of the port if successful. Or
- * USB_PORT_CONNECT_TYPE_UNKNOWN if input params are invalid.
- */
-enum usb_port_connect_type
-usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
-{
-        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
-
-        if (!hub)
-                return USB_PORT_CONNECT_TYPE_UNKNOWN;
-
-        return hub->ports[port1 - 1]->connect_type;
-}
-
 void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 struct usb_hub_descriptor *desc)
 {
+        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
         enum usb_port_connect_type connect_type;
         int i;
 
+        if (!hub)
+                return;
+
         if (!hub_is_superspeed(hdev)) {
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        connect_type = usb_get_hub_port_connect_type(hdev, i);
+                        struct usb_port *port_dev = hub->ports[i - 1];
 
+                        connect_type = port_dev->connect_type;
                         if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
                                 u8 mask = 1 << (i%8);
 
                                 if (!(desc->u.hs.DeviceRemovable[i/8] & mask)) {
-                                        dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
-                                                i);
+                                        dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
                                         desc->u.hs.DeviceRemovable[i/8] |= mask;
                                 }
                         }
@@ -5530,14 +5596,14 @@ void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 u16 port_removable = le16_to_cpu(desc->u.ss.DeviceRemovable);
 
                 for (i = 1; i <= hdev->maxchild; i++) {
-                        connect_type = usb_get_hub_port_connect_type(hdev, i);
+                        struct usb_port *port_dev = hub->ports[i - 1];
 
+                        connect_type = port_dev->connect_type;
                         if (connect_type == USB_PORT_CONNECT_TYPE_HARD_WIRED) {
                                 u16 mask = 1 << i;
 
                                 if (!(port_removable & mask)) {
-                                        dev_dbg(&hdev->dev, "usb port%d's DeviceRemovable is changed to 1 according to platform information.\n",
-                                                i);
+                                        dev_dbg(&port_dev->dev, "DeviceRemovable is changed to 1 according to platform information.\n");
                                         port_removable |= mask;
                                 }
                         }
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index 33bcb2c6f90a..0a7cdc0ef0a9 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -45,12 +45,13 @@ struct usb_hub {
         unsigned long           event_bits[1];  /* status change bitmask */
         unsigned long           change_bits[1]; /* ports with logical connect
                                                         status change */
-        unsigned long           busy_bits[1];   /* ports being reset or
-                                                        resumed */
         unsigned long           removed_bits[1]; /* ports with a "removed"
                                                         device present */
         unsigned long           wakeup_bits[1]; /* ports that have signaled
                                                         remote wakeup */
+        unsigned long           power_bits[1]; /* ports that are powered */
+        unsigned long           child_usage_bits[1]; /* ports powered on for
+                                                        children */
 #if USB_MAXCHILDREN > 31 /* 8*sizeof(unsigned long) - 1 */
 #error event_bits[] is too short!
 #endif
@@ -66,6 +67,7 @@ struct usb_hub {
         unsigned                limited_power:1;
         unsigned                quiescing:1;
         unsigned                disconnected:1;
+        unsigned                in_reset:1;
 
         unsigned                quirk_check_port_auto_suspend:1;
 
@@ -81,19 +83,23 @@ struct usb_hub {
  * @child: usb device attached to the port
  * @dev: generic device interface
  * @port_owner: port's owner
+ * @peer: related usb2 and usb3 ports (share the same connector)
  * @connect_type: port's connect type
+ * @location: opaque representation of platform connector location
+ * @status_lock: synchronize port_event() vs usb_port_{suspend|resume}
  * @portnum: port index num based one
- * @power_is_on: port's power state
- * @did_runtime_put: port has done pm_runtime_put().
+ * @is_superspeed cache super-speed status
  */
 struct usb_port {
         struct usb_device *child;
         struct device dev;
         struct usb_dev_state *port_owner;
+        struct usb_port *peer;
         enum usb_port_connect_type connect_type;
+        usb_port_location_t location;
+        struct mutex status_lock;
         u8 portnum;
-        unsigned power_is_on:1;
-        unsigned did_runtime_put:1;
+        unsigned int is_superspeed:1;
 };
 
 #define to_usb_port(_dev) \
@@ -111,6 +117,29 @@ extern int hub_port_debounce(struct usb_hub *hub, int port1,
 extern int usb_clear_port_feature(struct usb_device *hdev,
                 int port1, int feature);
 
+static inline bool hub_is_port_power_switchable(struct usb_hub *hub)
+{
+        __le16 hcs;
+
+        if (!hub)
+                return false;
+        hcs = hub->descriptor->wHubCharacteristics;
+        return (le16_to_cpu(hcs) & HUB_CHAR_LPSM) < HUB_CHAR_NO_LPSM;
+}
+
+static inline int hub_is_superspeed(struct usb_device *hdev)
+{
+        return hdev->descriptor.bDeviceProtocol == USB_HUB_PR_SS;
+}
+
+static inline unsigned hub_power_on_good_delay(struct usb_hub *hub)
+{
+        unsigned delay = hub->descriptor->bPwrOn2PwrGood * 2;
+
+        /* Wait at least 100 msec for power to become stable */
+        return max(delay, 100U);
+}
+
 static inline int hub_port_debounce_be_connected(struct usb_hub *hub,
                 int port1)
 {
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index 51542f852393..62036faf56c0 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -76,17 +76,29 @@ static int usb_port_runtime_resume(struct device *dev)
         struct usb_device *hdev = to_usb_device(dev->parent->parent);
         struct usb_interface *intf = to_usb_interface(dev->parent);
         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_device *udev = port_dev->child;
+        struct usb_port *peer = port_dev->peer;
         int port1 = port_dev->portnum;
         int retval;
 
         if (!hub)
                 return -EINVAL;
+        if (hub->in_reset) {
+                set_bit(port1, hub->power_bits);
+                return 0;
+        }
 
-        usb_autopm_get_interface(intf);
-        set_bit(port1, hub->busy_bits);
+        /*
+         * Power on our usb3 peer before this usb2 port to prevent a usb3
+         * device from degrading to its usb2 connection
+         */
+        if (!port_dev->is_superspeed && peer)
+                pm_runtime_get_sync(&peer->dev);
 
+        usb_autopm_get_interface(intf);
         retval = usb_hub_set_port_power(hdev, hub, port1, true);
-        if (port_dev->child && !retval) {
+        msleep(hub_power_on_good_delay(hub));
+        if (udev && !retval) {
                 /*
                  * Attempt to wait for usb hub port to be reconnected in order
                  * to make the resume procedure successful.  The device may have
@@ -97,12 +109,17 @@ static int usb_port_runtime_resume(struct device *dev)
                 if (retval < 0)
                         dev_dbg(&port_dev->dev, "can't get reconnection after setting port  power on, status %d\n",
                                         retval);
-                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
                 retval = 0;
+
+                /* Force the child awake to revalidate after the power loss. */
+                if (!test_and_set_bit(port1, hub->child_usage_bits)) {
+                        pm_runtime_get_noresume(&port_dev->dev);
+                        pm_request_resume(&udev->dev);
+                }
         }
 
-        clear_bit(port1, hub->busy_bits);
         usb_autopm_put_interface(intf);
+
         return retval;
 }
 
@@ -112,23 +129,34 @@ static int usb_port_runtime_suspend(struct device *dev)
         struct usb_device *hdev = to_usb_device(dev->parent->parent);
         struct usb_interface *intf = to_usb_interface(dev->parent);
         struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_port *peer = port_dev->peer;
         int port1 = port_dev->portnum;
         int retval;
 
         if (!hub)
                 return -EINVAL;
+        if (hub->in_reset)
+                return -EBUSY;
 
         if (dev_pm_qos_flags(&port_dev->dev, PM_QOS_FLAG_NO_POWER_OFF)
                         == PM_QOS_FLAGS_ALL)
                 return -EAGAIN;
 
         usb_autopm_get_interface(intf);
-        set_bit(port1, hub->busy_bits);
         retval = usb_hub_set_port_power(hdev, hub, port1, false);
         usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_CONNECTION);
-        usb_clear_port_feature(hdev, port1,     USB_PORT_FEAT_C_ENABLE);
-        clear_bit(port1, hub->busy_bits);
+        if (!port_dev->is_superspeed)
+                usb_clear_port_feature(hdev, port1, USB_PORT_FEAT_C_ENABLE);
         usb_autopm_put_interface(intf);
+
+        /*
+         * Our peer usb3 port may now be able to suspend, so
+         * asynchronously queue a suspend request to observe that this
+         * usb2 port is now off.
+         */
+        if (!port_dev->is_superspeed && peer)
+                pm_runtime_put(&peer->dev);
+
         return retval;
 }
 #endif
@@ -146,9 +174,215 @@ struct device_type usb_port_device_type = {
         .pm =           &usb_port_pm_ops,
 };
 
+static struct device_driver usb_port_driver = {
+        .name = "usb",
+        .owner = THIS_MODULE,
+};
+
+static int link_peers(struct usb_port *left, struct usb_port *right)
+{
+        struct usb_port *ss_port, *hs_port;
+        int rc;
+
+        if (left->peer == right && right->peer == left)
+                return 0;
+
+        if (left->peer || right->peer) {
+                struct usb_port *lpeer = left->peer;
+                struct usb_port *rpeer = right->peer;
+
+                WARN(1, "failed to peer %s and %s (%s -> %p) (%s -> %p)\n",
+                        dev_name(&left->dev), dev_name(&right->dev),
+                        dev_name(&left->dev), lpeer,
+                        dev_name(&right->dev), rpeer);
+                return -EBUSY;
+        }
+
+        rc = sysfs_create_link(&left->dev.kobj, &right->dev.kobj, "peer");
+        if (rc)
+                return rc;
+        rc = sysfs_create_link(&right->dev.kobj, &left->dev.kobj, "peer");
+        if (rc) {
+                sysfs_remove_link(&left->dev.kobj, "peer");
+                return rc;
+        }
+
+        /*
+         * We need to wake the HiSpeed port to make sure we don't race
+         * setting ->peer with usb_port_runtime_suspend().  Otherwise we
+         * may miss a suspend event for the SuperSpeed port.
+         */
+        if (left->is_superspeed) {
+                ss_port = left;
+                WARN_ON(right->is_superspeed);
+                hs_port = right;
+        } else {
+                ss_port = right;
+                WARN_ON(!right->is_superspeed);
+                hs_port = left;
+        }
+        pm_runtime_get_sync(&hs_port->dev);
+
+        left->peer = right;
+        right->peer = left;
+
+        /*
+         * The SuperSpeed reference is dropped when the HiSpeed port in
+         * this relationship suspends, i.e. when it is safe to allow a
+         * SuperSpeed connection to drop since there is no risk of a
+         * device degrading to its powered-off HiSpeed connection.
+         *
+         * Also, drop the HiSpeed ref taken above.
+         */
+        pm_runtime_get_sync(&ss_port->dev);
+        pm_runtime_put(&hs_port->dev);
+
+        return 0;
+}
+
+static void link_peers_report(struct usb_port *left, struct usb_port *right)
+{
+        int rc;
+
+        rc = link_peers(left, right);
+        if (rc == 0) {
+                dev_dbg(&left->dev, "peered to %s\n", dev_name(&right->dev));
+        } else {
+                dev_warn(&left->dev, "failed to peer to %s (%d)\n",
+                                dev_name(&right->dev), rc);
+                pr_warn_once("usb: port power management may be unreliable\n");
+        }
+}
+
+static void unlink_peers(struct usb_port *left, struct usb_port *right)
+{
+        struct usb_port *ss_port, *hs_port;
+
+        WARN(right->peer != left || left->peer != right,
+                        "%s and %s are not peers?\n",
+                        dev_name(&left->dev), dev_name(&right->dev));
+
+        /*
+         * We wake the HiSpeed port to make sure we don't race its
+         * usb_port_runtime_resume() event which takes a SuperSpeed ref
+         * when ->peer is !NULL.
+         */
+        if (left->is_superspeed) {
+                ss_port = left;
+                hs_port = right;
+        } else {
+                ss_port = right;
+                hs_port = left;
+        }
+
+        pm_runtime_get_sync(&hs_port->dev);
+
+        sysfs_remove_link(&left->dev.kobj, "peer");
+        right->peer = NULL;
+        sysfs_remove_link(&right->dev.kobj, "peer");
+        left->peer = NULL;
+
+        /* Drop the SuperSpeed ref held on behalf of the active HiSpeed port */
+        pm_runtime_put(&ss_port->dev);
+
+        /* Drop the ref taken above */
+        pm_runtime_put(&hs_port->dev);
+}
+
+/*
+ * For each usb hub device in the system check to see if it is in the
+ * peer domain of the given port_dev, and if it is check to see if it
+ * has a port that matches the given port by location
+ */
+static int match_location(struct usb_device *peer_hdev, void *p)
+{
+        int port1;
+        struct usb_hcd *hcd, *peer_hcd;
+        struct usb_port *port_dev = p, *peer;
+        struct usb_hub *peer_hub = usb_hub_to_struct_hub(peer_hdev);
+        struct usb_device *hdev = to_usb_device(port_dev->dev.parent->parent);
+
+        if (!peer_hub)
+                return 0;
+
+        hcd = bus_to_hcd(hdev->bus);
+        peer_hcd = bus_to_hcd(peer_hdev->bus);
+        /* peer_hcd is provisional until we verify it against the known peer */
+        if (peer_hcd != hcd->shared_hcd)
+                return 0;
+
+        for (port1 = 1; port1 <= peer_hdev->maxchild; port1++) {
+                peer = peer_hub->ports[port1 - 1];
+                if (peer && peer->location == port_dev->location) {
+                        link_peers_report(port_dev, peer);
+                        return 1; /* done */
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * Find the peer port either via explicit platform firmware "location"
+ * data, the peer hcd for root hubs, or the upstream peer relationship
+ * for all other hubs.
+ */
+static void find_and_link_peer(struct usb_hub *hub, int port1)
+{
+        struct usb_port *port_dev = hub->ports[port1 - 1], *peer;
+        struct usb_device *hdev = hub->hdev;
+        struct usb_device *peer_hdev;
+        struct usb_hub *peer_hub;
+
+        /*
+         * If location data is available then we can only peer this port
+         * by a location match, not the default peer (lest we create a
+         * situation where we need to go back and undo a default peering
+         * when the port is later peered by location data)
+         */
+        if (port_dev->location) {
+                /* we link the peer in match_location() if found */
+                usb_for_each_dev(port_dev, match_location);
+                return;
+        } else if (!hdev->parent) {
+                struct usb_hcd *hcd = bus_to_hcd(hdev->bus);
+                struct usb_hcd *peer_hcd = hcd->shared_hcd;
+
+                if (!peer_hcd)
+                        return;
+
+                peer_hdev = peer_hcd->self.root_hub;
+        } else {
+                struct usb_port *upstream;
+                struct usb_device *parent = hdev->parent;
+                struct usb_hub *parent_hub = usb_hub_to_struct_hub(parent);
+
+                if (!parent_hub)
+                        return;
+
+                upstream = parent_hub->ports[hdev->portnum - 1];
+                if (!upstream || !upstream->peer)
+                        return;
+
+                peer_hdev = upstream->peer->child;
+        }
+
+        peer_hub = usb_hub_to_struct_hub(peer_hdev);
+        if (!peer_hub || port1 > peer_hdev->maxchild)
+                return;
+
+        /*
+         * we found a valid default peer, last check is to make sure it
+         * does not have location data
+         */
+        peer = peer_hub->ports[port1 - 1];
+        if (peer && peer->location == 0)
+                link_peers_report(port_dev, peer);
+}
+
 int usb_hub_create_port_device(struct usb_hub *hub, int port1)
 {
-        struct usb_port *port_dev = NULL;
+        struct usb_port *port_dev;
         int retval;
 
         port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
@@ -159,24 +393,33 @@ int usb_hub_create_port_device(struct usb_hub *hub, int port1)
 
         hub->ports[port1 - 1] = port_dev;
         port_dev->portnum = port1;
-        port_dev->power_is_on = true;
+        set_bit(port1, hub->power_bits);
         port_dev->dev.parent = hub->intfdev;
         port_dev->dev.groups = port_dev_group;
         port_dev->dev.type = &usb_port_device_type;
-        dev_set_name(&port_dev->dev, "port%d", port1);
-
+        port_dev->dev.driver = &usb_port_driver;
+        if (hub_is_superspeed(hub->hdev))
+                port_dev->is_superspeed = 1;
+        dev_set_name(&port_dev->dev, "%s-port%d", dev_name(&hub->hdev->dev),
+                        port1);
+        mutex_init(&port_dev->status_lock);
         retval = device_register(&port_dev->dev);
         if (retval)
                 goto error_register;
 
+        find_and_link_peer(hub, port1);
+
         pm_runtime_set_active(&port_dev->dev);
 
-        /* It would be dangerous if user space couldn't
-         * prevent usb device from being powered off. So don't
-         * enable port runtime pm if failed to expose port's pm qos.
+        /*
+         * Do not enable port runtime pm if the hub does not support
+         * power switching.  Also, userspace must have final say of
+         * whether a port is permitted to power-off.  Do not enable
+         * runtime pm if we fail to expose pm_qos_no_power_off.
          */
-        if (!dev_pm_qos_expose_flags(&port_dev->dev,
-                        PM_QOS_FLAG_NO_POWER_OFF))
+        if (hub_is_port_power_switchable(hub)
+                        && dev_pm_qos_expose_flags(&port_dev->dev,
+                        PM_QOS_FLAG_NO_POWER_OFF) == 0)
                 pm_runtime_enable(&port_dev->dev);
 
         device_enable_async_suspend(&port_dev->dev);
@@ -188,9 +431,13 @@ exit:
         return retval;
 }
 
-void usb_hub_remove_port_device(struct usb_hub *hub,
-                                       int port1)
+void usb_hub_remove_port_device(struct usb_hub *hub, int port1)
 {
-        device_unregister(&hub->ports[port1 - 1]->dev);
-}
+        struct usb_port *port_dev = hub->ports[port1 - 1];
+        struct usb_port *peer;
 
+        peer = port_dev->peer;
+        if (peer)
+                unlink_peers(port_dev, peer);
+        device_unregister(&port_dev->dev);
+}
diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
index 5ca4070b1f38..2776cfe64c09 100644
--- a/drivers/usb/core/usb-acpi.c
+++ b/drivers/usb/core/usb-acpi.c
@@ -17,7 +17,7 @@
 #include <linux/pci.h>
 #include <linux/usb/hcd.h>
 
-#include "usb.h"
+#include "hub.h"
 
 /**
  * usb_acpi_power_manageable - check whether usb port has
@@ -55,13 +55,18 @@ EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
  */
 int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 {
+        struct usb_hub *hub = usb_hub_to_struct_hub(hdev);
+        struct usb_port *port_dev;
         acpi_handle port_handle;
         unsigned char state;
         int port1 = index + 1;
         int error = -EINVAL;
 
-        port_handle = (acpi_handle)usb_get_hub_port_acpi_handle(hdev,
-                port1);
+        if (!hub)
+                return -ENODEV;
+        port_dev = hub->ports[port1 - 1];
+
+        port_handle = (acpi_handle) usb_get_hub_port_acpi_handle(hdev, port1);
         if (!port_handle)
                 return error;
 
@@ -72,23 +77,21 @@ int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
 
         error = acpi_bus_set_power(port_handle, state);
         if (!error)
-                dev_dbg(&hdev->dev, "The power of hub port %d was set to %d\n",
-                        port1, enable);
+                dev_dbg(&port_dev->dev, "acpi: power was set to %d\n", enable);
         else
-                dev_dbg(&hdev->dev, "The power of hub port failed to be set\n");
+                dev_dbg(&port_dev->dev, "acpi: power failed to be set\n");
 
         return error;
 }
 EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
 
-static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
-        acpi_handle handle, int port1)
+static enum usb_port_connect_type usb_acpi_get_connect_type(acpi_handle handle,
+                struct acpi_pld_info *pld)
 {
-        acpi_status status;
+        enum usb_port_connect_type connect_type = USB_PORT_CONNECT_TYPE_UNKNOWN;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *upc;
-        struct acpi_pld_info *pld;
-        int ret = 0;
+        acpi_status status;
 
         /*
          * According to ACPI Spec 9.13. PLD indicates whether usb port is
@@ -98,39 +101,37 @@ static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
          * a usb device is directly hard-wired to the port. If no visible and
          * no connectable, the port would be not used.
          */
-        status = acpi_get_physical_device_location(handle, &pld);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
         status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
         upc = buffer.pointer;
         if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
                 || upc->package.count != 4) {
-                ret = -EINVAL;
                 goto out;
         }
 
         if (upc->package.elements[0].integer.value)
                 if (pld->user_visible)
-                        usb_set_hub_port_connect_type(hdev, port1,
-                                USB_PORT_CONNECT_TYPE_HOT_PLUG);
+                        connect_type = USB_PORT_CONNECT_TYPE_HOT_PLUG;
                 else
-                        usb_set_hub_port_connect_type(hdev, port1,
-                                USB_PORT_CONNECT_TYPE_HARD_WIRED);
+                        connect_type = USB_PORT_CONNECT_TYPE_HARD_WIRED;
         else if (!pld->user_visible)
-                usb_set_hub_port_connect_type(hdev, port1, USB_PORT_NOT_USED);
-
+                connect_type = USB_PORT_NOT_USED;
 out:
-        ACPI_FREE(pld);
         kfree(upc);
-        return ret;
+        return connect_type;
 }
 
+
+/*
+ * Private to usb-acpi, all the core needs to know is that
+ * port_dev->location is non-zero when it has been set by the firmware.
+ */
+#define USB_ACPI_LOCATION_VALID (1 << 31)
+
 static struct acpi_device *usb_acpi_find_companion(struct device *dev)
 {
         struct usb_device *udev;
+        struct acpi_device *adev;
         acpi_handle *parent_handle;
-        int port_num;
 
         /*
          * In the ACPI DSDT table, only usb root hub and usb ports are
@@ -147,37 +148,19 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
          */
         if (is_usb_device(dev)) {
                 udev = to_usb_device(dev);
-                if (udev->parent) {
-                        enum usb_port_connect_type type;
-
-                        /*
-                         * According usb port's connect type to set usb device's
-                         * removability.
-                         */
-                        type = usb_get_hub_port_connect_type(udev->parent,
-                                udev->portnum);
-                        switch (type) {
-                        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
-                                udev->removable = USB_DEVICE_REMOVABLE;
-                                break;
-                        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
-                                udev->removable = USB_DEVICE_FIXED;
-                                break;
-                        default:
-                                udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
-                                break;
-                        }
-
+                if (udev->parent)
                         return NULL;
-                }
 
-                /* root hub's parent is the usb hcd. */
-                return acpi_find_child_device(ACPI_COMPANION(dev->parent),
-                                              udev->portnum, false);
+                /* root hub is only child (_ADR=0) under its parent, the HC */
+                adev = ACPI_COMPANION(dev->parent);
+                return acpi_find_child_device(adev, 0, false);
         } else if (is_usb_port(dev)) {
-                struct acpi_device *adev = NULL;
+                struct usb_port *port_dev = to_usb_port(dev);
+                int port1 = port_dev->portnum;
+                struct acpi_pld_info *pld;
+                acpi_handle *handle;
+                acpi_status status;
 
-                sscanf(dev_name(dev), "port%d", &port_num);
                 /* Get the struct usb_device point of port's hub */
                 udev = to_usb_device(dev->parent->parent);
 
@@ -188,12 +171,11 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
                  */
                 if (!udev->parent) {
                         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
-                        int raw_port_num;
+                        int raw;
 
-                        raw_port_num = usb_hcd_find_raw_port_number(hcd,
-                                port_num);
+                        raw = usb_hcd_find_raw_port_number(hcd, port1);
                         adev = acpi_find_child_device(ACPI_COMPANION(&udev->dev),
-                                                      raw_port_num, false);
+                                        raw, false);
                         if (!adev)
                                 return NULL;
                 } else {
@@ -204,11 +186,20 @@ static struct acpi_device *usb_acpi_find_companion(struct device *dev)
                                 return NULL;
 
                         acpi_bus_get_device(parent_handle, &adev);
-                        adev = acpi_find_child_device(adev, port_num, false);
+                        adev = acpi_find_child_device(adev, port1, false);
                         if (!adev)
                                 return NULL;
                 }
-                usb_acpi_check_port_connect_type(udev, adev->handle, port_num);
+                handle = adev->handle;
+                status = acpi_get_physical_device_location(handle, &pld);
+                if (ACPI_FAILURE(status) || !pld)
+                        return adev;
+
+                port_dev->location = USB_ACPI_LOCATION_VALID
+                        | pld->group_token << 8 | pld->group_position;
+                port_dev->connect_type = usb_acpi_get_connect_type(handle, pld);
+                ACPI_FREE(pld);
+
                 return adev;
         }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index 75bf649da82d..d9d08720c386 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -107,11 +107,6 @@ static inline int usb_autoresume_device(struct usb_device *udev)
         return 0;
 }
 
-static inline int usb_remote_wakeup(struct usb_device *udev)
-{
-        return 0;
-}
-
 static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 {
         return 0;
@@ -119,6 +114,7 @@ static inline int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
 #endif
 
 extern struct bus_type usb_bus_type;
+extern struct mutex usb_port_peer_mutex;
 extern struct device_type usb_device_type;
 extern struct device_type usb_if_device_type;
 extern struct device_type usb_ep_device_type;
@@ -170,15 +166,17 @@ extern void usbfs_conn_disc_event(void);
 extern int usb_devio_init(void);
 extern void usb_devio_cleanup(void);
 
+/*
+ * Firmware specific cookie identifying a port's location. '0' == no location
+ * data available
+ */
+typedef u32 usb_port_location_t;
+
 /* internal notify stuff */
 extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);
 extern void usb_notify_add_bus(struct usb_bus *ubus);
 extern void usb_notify_remove_bus(struct usb_bus *ubus);
-extern enum usb_port_connect_type
-        usb_get_hub_port_connect_type(struct usb_device *hdev, int port1);
-extern void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
-        enum usb_port_connect_type type);
 extern void usb_hub_adjust_deviceremovable(struct usb_device *hdev,
                 struct usb_hub_descriptor *desc);
 
diff --git a/drivers/usb/dwc2/Kconfig b/drivers/usb/dwc2/Kconfig
index be947d673844..f93807b3631a 100644
--- a/drivers/usb/dwc2/Kconfig
+++ b/drivers/usb/dwc2/Kconfig
@@ -1,25 +1,58 @@
 config USB_DWC2
-        tristate "DesignWare USB2 DRD Core Support"
+        bool "DesignWare USB2 DRD Core Support"
         depends on USB
         help
-          Say Y or M here if your system has a Dual Role HighSpeed
-          USB controller based on the DesignWare HSOTG IP Core.
+          Say Y here if your system has a Dual Role Hi-Speed USB
+          controller based on the DesignWare HSOTG IP Core.
 
-          If you choose to build this driver as dynamically linked
-          modules, the core module will be called dwc2.ko, the
-          PCI bus interface module (if you have a PCI bus system)
-          will be called dwc2_pci.ko and the platform interface module
-          (for controllers directly connected to the CPU) will be called
-          dwc2_platform.ko.
+          For host mode, if you choose to build the driver as dynamically
+          linked modules, the core module will be called dwc2.ko, the PCI
+          bus interface module (if you have a PCI bus system) will be
+          called dwc2_pci.ko, and the platform interface module (for
+          controllers directly connected to the CPU) will be called
+          dwc2_platform.ko. For gadget mode, there will be a single
+          module called dwc2_gadget.ko.
 
-          NOTE: This driver at present only implements the Host mode
-          of the controller. The existing s3c-hsotg driver supports
-          Peripheral mode, but only for the Samsung S3C platforms.
-          There are plans to merge the s3c-hsotg driver with this
-          driver in the near future to create a dual-role driver.
+          NOTE: The s3c-hsotg driver is now renamed to dwc2_gadget. The
+          host and gadget drivers are still currently separate drivers.
+          There are plans to merge the dwc2_gadget driver with the dwc2
+          host driver in the near future to create a dual-role driver.
 
 if USB_DWC2
 
+config USB_DWC2_HOST
+        tristate "Host only mode"
+        depends on USB
+        help
+          The Designware USB2.0 high-speed host controller
+          integrated into many SoCs.
+
+config USB_DWC2_PLATFORM
+        bool "DWC2 Platform"
+        depends on USB_DWC2_HOST
+        default USB_DWC2_HOST
+        help
+          The Designware USB2.0 platform interface module for
+          controllers directly connected to the CPU. This is only
+          used for host mode.
+
+config USB_DWC2_PCI
+        bool "DWC2 PCI"
+        depends on USB_DWC2_HOST && PCI
+        default USB_DWC2_HOST
+        help
+          The Designware USB2.0 PCI interface module for controllers
+          connected to a PCI bus. This is only used for host mode.
+
+comment "Gadget mode requires USB Gadget support to be enabled"
+
+config USB_DWC2_PERIPHERAL
+        tristate "Gadget only mode"
+        depends on USB_GADGET
+        help
+          The Designware USB2.0 high-speed gadget controller
+          integrated into many SoCs.
+
 config USB_DWC2_DEBUG
         bool "Enable Debugging Messages"
         help
diff --git a/drivers/usb/dwc2/Makefile b/drivers/usb/dwc2/Makefile
index 11529d3439b0..b73d2a527970 100644
--- a/drivers/usb/dwc2/Makefile
+++ b/drivers/usb/dwc2/Makefile
@@ -1,25 +1,28 @@
 ccflags-$(CONFIG_USB_DWC2_DEBUG)        += -DDEBUG
 ccflags-$(CONFIG_USB_DWC2_VERBOSE)      += -DVERBOSE_DEBUG
 
-obj-$(CONFIG_USB_DWC2)                  += dwc2.o
-
-dwc2-y                                  += core.o core_intr.o
-
-# NOTE: This driver at present only implements the Host mode
-# of the controller. The existing s3c-hsotg driver supports
-# Peripheral mode, but only for the Samsung S3C platforms.
-# There are plans to merge the s3c-hsotg driver with this
-# driver in the near future to create a dual-role driver. Once
-# that is done, Host mode will become an optional feature that
-# is selected with a config option.
-
+obj-$(CONFIG_USB_DWC2_HOST)             += dwc2.o
+dwc2-y                                  := core.o core_intr.o
 dwc2-y                                  += hcd.o hcd_intr.o
 dwc2-y                                  += hcd_queue.o hcd_ddma.o
 
-ifneq ($(CONFIG_PCI),)
-        obj-$(CONFIG_USB_DWC2)          += dwc2_pci.o
+# NOTE: The previous s3c-hsotg peripheral mode only driver has been moved to
+# this location and renamed gadget.c. When building for dynamically linked
+# modules, dwc2_gadget.ko will get built for peripheral mode. For host mode,
+# the core module will be dwc2.ko, the PCI bus interface module will called
+# dwc2_pci.ko and the platform interface module will be called dwc2_platform.ko.
+# At present the host and gadget driver will be separate drivers, but there
+# are plans in the near future to create a dual-role driver.
+
+ifneq ($(CONFIG_USB_DWC2_PCI),)
+        obj-$(CONFIG_USB_DWC2_HOST)     += dwc2_pci.o
+        dwc2_pci-y                      := pci.o
+endif
+
+ifneq ($(CONFIG_USB_DWC2_PLATFORM),)
+        obj-$(CONFIG_USB_DWC2_HOST)     += dwc2_platform.o
+        dwc2_platform-y                 := platform.o
 endif
-obj-$(CONFIG_USB_DWC2)                  += dwc2_platform.o
 
-dwc2_pci-y                              += pci.o
-dwc2_platform-y                         += platform.o
+obj-$(CONFIG_USB_DWC2_PERIPHERAL)       += dwc2_gadget.o
+dwc2_gadget-y                           := gadget.o
diff --git a/drivers/usb/dwc2/core.c b/drivers/usb/dwc2/core.c
index 1d129884cc39..27d2c9b8a034 100644
--- a/drivers/usb/dwc2/core.c
+++ b/drivers/usb/dwc2/core.c
@@ -507,6 +507,72 @@ void dwc2_disable_host_interrupts(struct dwc2_hsotg *hsotg)
         writel(intmsk, hsotg->regs + GINTMSK);
 }
 
+/*
+ * dwc2_calculate_dynamic_fifo() - Calculates the default fifo size
+ * For system that have a total fifo depth that is smaller than the default
+ * RX + TX fifo size.
+ *
+ * @hsotg: Programming view of DWC_otg controller
+ */
+static void dwc2_calculate_dynamic_fifo(struct dwc2_hsotg *hsotg)
+{
+        struct dwc2_core_params *params = hsotg->core_params;
+        struct dwc2_hw_params *hw = &hsotg->hw_params;
+        u32 rxfsiz, nptxfsiz, ptxfsiz, total_fifo_size;
+
+        total_fifo_size = hw->total_fifo_size;
+        rxfsiz = params->host_rx_fifo_size;
+        nptxfsiz = params->host_nperio_tx_fifo_size;
+        ptxfsiz = params->host_perio_tx_fifo_size;
+
+        /*
+         * Will use Method 2 defined in the DWC2 spec: minimum FIFO depth
+         * allocation with support for high bandwidth endpoints. Synopsys
+         * defines MPS(Max Packet size) for a periodic EP=1024, and for
+         * non-periodic as 512.
+         */
+        if (total_fifo_size < (rxfsiz + nptxfsiz + ptxfsiz)) {
+                /*
+                 * For Buffer DMA mode/Scatter Gather DMA mode
+                 * 2 * ((Largest Packet size / 4) + 1 + 1) + n
+                 * with n = number of host channel.
+                 * 2 * ((1024/4) + 2) = 516
+                 */
+                rxfsiz = 516 + hw->host_channels;
+
+                /*
+                 * min non-periodic tx fifo depth
+                 * 2 * (largest non-periodic USB packet used / 4)
+                 * 2 * (512/4) = 256
+                 */
+                nptxfsiz = 256;
+
+                /*
+                 * min periodic tx fifo depth
+                 * (largest packet size*MC)/4
+                 * (1024 * 3)/4 = 768
+                 */
+                ptxfsiz = 768;
+
+                params->host_rx_fifo_size = rxfsiz;
+                params->host_nperio_tx_fifo_size = nptxfsiz;
+                params->host_perio_tx_fifo_size = ptxfsiz;
+        }
+
+        /*
+         * If the summation of RX, NPTX and PTX fifo sizes is still
+         * bigger than the total_fifo_size, then we have a problem.
+         *
+         * We won't be able to allocate as many endpoints. Right now,
+         * we're just printing an error message, but ideally this FIFO
+         * allocation algorithm would be improved in the future.
+         *
+         * FIXME improve this FIFO allocation algorithm.
+         */
+        if (unlikely(total_fifo_size < (rxfsiz + nptxfsiz + ptxfsiz)))
+                dev_err(hsotg->dev, "invalid fifo sizes\n");
+}
+
 static void dwc2_config_fifos(struct dwc2_hsotg *hsotg)
 {
         struct dwc2_core_params *params = hsotg->core_params;
@@ -515,6 +581,8 @@ static void dwc2_config_fifos(struct dwc2_hsotg *hsotg)
         if (!params->enable_dynamic_fifo)
                 return;
 
+        dwc2_calculate_dynamic_fifo(hsotg);
+
         /* Rx FIFO */
         grxfsiz = readl(hsotg->regs + GRXFSIZ);
         dev_dbg(hsotg->dev, "initial grxfsiz=%08x\n", grxfsiz);
diff --git a/drivers/usb/dwc2/core.h b/drivers/usb/dwc2/core.h
index 648519c024b5..1efd10cc9629 100644
--- a/drivers/usb/dwc2/core.h
+++ b/drivers/usb/dwc2/core.h
@@ -37,6 +37,10 @@
 #ifndef __DWC2_CORE_H__
 #define __DWC2_CORE_H__
 
+#include <linux/phy/phy.h>
+#include <linux/regulator/consumer.h>
+#include <linux/usb/gadget.h>
+#include <linux/usb/otg.h>
 #include <linux/usb/phy.h>
 #include "hw.h"
 
@@ -54,6 +58,184 @@ static inline void do_write(u32 value, void *addr)
 /* Maximum number of Endpoints/HostChannels */
 #define MAX_EPS_CHANNELS        16
 
+/* s3c-hsotg declarations */
+static const char * const s3c_hsotg_supply_names[] = {
+        "vusb_d",               /* digital USB supply, 1.2V */
+        "vusb_a",               /* analog USB supply, 1.1V */
+};
+
+/*
+ * EP0_MPS_LIMIT
+ *
+ * Unfortunately there seems to be a limit of the amount of data that can
+ * be transferred by IN transactions on EP0. This is either 127 bytes or 3
+ * packets (which practically means 1 packet and 63 bytes of data) when the
+ * MPS is set to 64.
+ *
+ * This means if we are wanting to move >127 bytes of data, we need to
+ * split the transactions up, but just doing one packet at a time does
+ * not work (this may be an implicit DATA0 PID on first packet of the
+ * transaction) and doing 2 packets is outside the controller's limits.
+ *
+ * If we try to lower the MPS size for EP0, then no transfers work properly
+ * for EP0, and the system will fail basic enumeration. As no cause for this
+ * has currently been found, we cannot support any large IN transfers for
+ * EP0.
+ */
+#define EP0_MPS_LIMIT   64
+
+struct s3c_hsotg;
+struct s3c_hsotg_req;
+
+/**
+ * struct s3c_hsotg_ep - driver endpoint definition.
+ * @ep: The gadget layer representation of the endpoint.
+ * @name: The driver generated name for the endpoint.
+ * @queue: Queue of requests for this endpoint.
+ * @parent: Reference back to the parent device structure.
+ * @req: The current request that the endpoint is processing. This is
+ *       used to indicate an request has been loaded onto the endpoint
+ *       and has yet to be completed (maybe due to data move, or simply
+ *       awaiting an ack from the core all the data has been completed).
+ * @debugfs: File entry for debugfs file for this endpoint.
+ * @lock: State lock to protect contents of endpoint.
+ * @dir_in: Set to true if this endpoint is of the IN direction, which
+ *          means that it is sending data to the Host.
+ * @index: The index for the endpoint registers.
+ * @mc: Multi Count - number of transactions per microframe
+ * @interval - Interval for periodic endpoints
+ * @name: The name array passed to the USB core.
+ * @halted: Set if the endpoint has been halted.
+ * @periodic: Set if this is a periodic ep, such as Interrupt
+ * @isochronous: Set if this is a isochronous ep
+ * @sent_zlp: Set if we've sent a zero-length packet.
+ * @total_data: The total number of data bytes done.
+ * @fifo_size: The size of the FIFO (for periodic IN endpoints)
+ * @fifo_load: The amount of data loaded into the FIFO (periodic IN)
+ * @last_load: The offset of data for the last start of request.
+ * @size_loaded: The last loaded size for DxEPTSIZE for periodic IN
+ *
+ * This is the driver's state for each registered enpoint, allowing it
+ * to keep track of transactions that need doing. Each endpoint has a
+ * lock to protect the state, to try and avoid using an overall lock
+ * for the host controller as much as possible.
+ *
+ * For periodic IN endpoints, we have fifo_size and fifo_load to try
+ * and keep track of the amount of data in the periodic FIFO for each
+ * of these as we don't have a status register that tells us how much
+ * is in each of them. (note, this may actually be useless information
+ * as in shared-fifo mode periodic in acts like a single-frame packet
+ * buffer than a fifo)
+ */
+struct s3c_hsotg_ep {
+        struct usb_ep           ep;
+        struct list_head        queue;
+        struct s3c_hsotg        *parent;
+        struct s3c_hsotg_req    *req;
+        struct dentry           *debugfs;
+
+        unsigned long           total_data;
+        unsigned int            size_loaded;
+        unsigned int            last_load;
+        unsigned int            fifo_load;
+        unsigned short          fifo_size;
+
+        unsigned char           dir_in;
+        unsigned char           index;
+        unsigned char           mc;
+        unsigned char           interval;
+
+        unsigned int            halted:1;
+        unsigned int            periodic:1;
+        unsigned int            isochronous:1;
+        unsigned int            sent_zlp:1;
+
+        char                    name[10];
+};
+
+/**
+ * struct s3c_hsotg - driver state.
+ * @dev: The parent device supplied to the probe function
+ * @driver: USB gadget driver
+ * @phy: The otg phy transceiver structure for phy control.
+ * @uphy: The otg phy transceiver structure for old USB phy control.
+ * @plat: The platform specific configuration data. This can be removed once
+ * all SoCs support usb transceiver.
+ * @regs: The memory area mapped for accessing registers.
+ * @irq: The IRQ number we are using
+ * @supplies: Definition of USB power supplies
+ * @phyif: PHY interface width
+ * @dedicated_fifos: Set if the hardware has dedicated IN-EP fifos.
+ * @num_of_eps: Number of available EPs (excluding EP0)
+ * @debug_root: root directrory for debugfs.
+ * @debug_file: main status file for debugfs.
+ * @debug_fifo: FIFO status file for debugfs.
+ * @ep0_reply: Request used for ep0 reply.
+ * @ep0_buff: Buffer for EP0 reply data, if needed.
+ * @ctrl_buff: Buffer for EP0 control requests.
+ * @ctrl_req: Request for EP0 control packets.
+ * @setup: NAK management for EP0 SETUP
+ * @last_rst: Time of last reset
+ * @eps: The endpoints being supplied to the gadget framework
+ */
+struct s3c_hsotg {
+        struct device            *dev;
+        struct usb_gadget_driver *driver;
+        struct phy               *phy;
+        struct usb_phy           *uphy;
+        struct s3c_hsotg_plat    *plat;
+
+        spinlock_t              lock;
+
+        void __iomem            *regs;
+        int                     irq;
+        struct clk              *clk;
+
+        struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
+
+        u32                     phyif;
+        unsigned int            dedicated_fifos:1;
+        unsigned char           num_of_eps;
+
+        struct dentry           *debug_root;
+        struct dentry           *debug_file;
+        struct dentry           *debug_fifo;
+
+        struct usb_request      *ep0_reply;
+        struct usb_request      *ctrl_req;
+        u8                      ep0_buff[8];
+        u8                      ctrl_buff[8];
+
+        struct usb_gadget       gadget;
+        unsigned int            setup;
+        unsigned long           last_rst;
+        struct s3c_hsotg_ep     *eps;
+};
+
+/**
+ * struct s3c_hsotg_req - data transfer request
+ * @req: The USB gadget request
+ * @queue: The list of requests for the endpoint this is queued for.
+ * @in_progress: Has already had size/packets written to core
+ * @mapped: DMA buffer for this request has been mapped via dma_map_single().
+ */
+struct s3c_hsotg_req {
+        struct usb_request      req;
+        struct list_head        queue;
+        unsigned char           in_progress;
+        unsigned char           mapped;
+};
+
+#define call_gadget(_hs, _entry) \
+do { \
+        if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
+                (_hs)->driver && (_hs)->driver->_entry) { \
+                spin_unlock(&_hs->lock); \
+                (_hs)->driver->_entry(&(_hs)->gadget); \
+                spin_lock(&_hs->lock); \
+        } \
+} while (0)
+
 struct dwc2_hsotg;
 struct dwc2_host_chan;
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/dwc2/gadget.c
index 2a9cb674926a..f3c56a2fed5b 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -37,175 +37,7 @@
 #include <linux/usb/phy.h>
 #include <linux/platform_data/s3c-hsotg.h>
 
-#include "s3c-hsotg.h"
-
-static const char * const s3c_hsotg_supply_names[] = {
-        "vusb_d",               /* digital USB supply, 1.2V */
-        "vusb_a",               /* analog USB supply, 1.1V */
-};
-
-/*
- * EP0_MPS_LIMIT
- *
- * Unfortunately there seems to be a limit of the amount of data that can
- * be transferred by IN transactions on EP0. This is either 127 bytes or 3
- * packets (which practically means 1 packet and 63 bytes of data) when the
- * MPS is set to 64.
- *
- * This means if we are wanting to move >127 bytes of data, we need to
- * split the transactions up, but just doing one packet at a time does
- * not work (this may be an implicit DATA0 PID on first packet of the
- * transaction) and doing 2 packets is outside the controller's limits.
- *
- * If we try to lower the MPS size for EP0, then no transfers work properly
- * for EP0, and the system will fail basic enumeration. As no cause for this
- * has currently been found, we cannot support any large IN transfers for
- * EP0.
- */
-#define EP0_MPS_LIMIT   64
-
-struct s3c_hsotg;
-struct s3c_hsotg_req;
-
-/**
- * struct s3c_hsotg_ep - driver endpoint definition.
- * @ep: The gadget layer representation of the endpoint.
- * @name: The driver generated name for the endpoint.
- * @queue: Queue of requests for this endpoint.
- * @parent: Reference back to the parent device structure.
- * @req: The current request that the endpoint is processing. This is
- *       used to indicate an request has been loaded onto the endpoint
- *       and has yet to be completed (maybe due to data move, or simply
- *       awaiting an ack from the core all the data has been completed).
- * @debugfs: File entry for debugfs file for this endpoint.
- * @lock: State lock to protect contents of endpoint.
- * @dir_in: Set to true if this endpoint is of the IN direction, which
- *          means that it is sending data to the Host.
- * @index: The index for the endpoint registers.
- * @mc: Multi Count - number of transactions per microframe
- * @interval - Interval for periodic endpoints
- * @name: The name array passed to the USB core.
- * @halted: Set if the endpoint has been halted.
- * @periodic: Set if this is a periodic ep, such as Interrupt
- * @isochronous: Set if this is a isochronous ep
- * @sent_zlp: Set if we've sent a zero-length packet.
- * @total_data: The total number of data bytes done.
- * @fifo_size: The size of the FIFO (for periodic IN endpoints)
- * @fifo_load: The amount of data loaded into the FIFO (periodic IN)
- * @last_load: The offset of data for the last start of request.
- * @size_loaded: The last loaded size for DxEPTSIZE for periodic IN
- *
- * This is the driver's state for each registered enpoint, allowing it
- * to keep track of transactions that need doing. Each endpoint has a
- * lock to protect the state, to try and avoid using an overall lock
- * for the host controller as much as possible.
- *
- * For periodic IN endpoints, we have fifo_size and fifo_load to try
- * and keep track of the amount of data in the periodic FIFO for each
- * of these as we don't have a status register that tells us how much
- * is in each of them. (note, this may actually be useless information
- * as in shared-fifo mode periodic in acts like a single-frame packet
- * buffer than a fifo)
- */
-struct s3c_hsotg_ep {
-        struct usb_ep           ep;
-        struct list_head        queue;
-        struct s3c_hsotg        *parent;
-        struct s3c_hsotg_req    *req;
-        struct dentry           *debugfs;
-
-
-        unsigned long           total_data;
-        unsigned int            size_loaded;
-        unsigned int            last_load;
-        unsigned int            fifo_load;
-        unsigned short          fifo_size;
-
-        unsigned char           dir_in;
-        unsigned char           index;
-        unsigned char           mc;
-        unsigned char           interval;
-
-        unsigned int            halted:1;
-        unsigned int            periodic:1;
-        unsigned int            isochronous:1;
-        unsigned int            sent_zlp:1;
-
-        char                    name[10];
-};
-
-/**
- * struct s3c_hsotg - driver state.
- * @dev: The parent device supplied to the probe function
- * @driver: USB gadget driver
- * @phy: The otg phy transceiver structure for phy control.
- * @uphy: The otg phy transceiver structure for old USB phy control.
- * @plat: The platform specific configuration data. This can be removed once
- * all SoCs support usb transceiver.
- * @regs: The memory area mapped for accessing registers.
- * @irq: The IRQ number we are using
- * @supplies: Definition of USB power supplies
- * @phyif: PHY interface width
- * @dedicated_fifos: Set if the hardware has dedicated IN-EP fifos.
- * @num_of_eps: Number of available EPs (excluding EP0)
- * @debug_root: root directrory for debugfs.
- * @debug_file: main status file for debugfs.
- * @debug_fifo: FIFO status file for debugfs.
- * @ep0_reply: Request used for ep0 reply.
- * @ep0_buff: Buffer for EP0 reply data, if needed.
- * @ctrl_buff: Buffer for EP0 control requests.
- * @ctrl_req: Request for EP0 control packets.
- * @setup: NAK management for EP0 SETUP
- * @last_rst: Time of last reset
- * @eps: The endpoints being supplied to the gadget framework
- */
-struct s3c_hsotg {
-        struct device            *dev;
-        struct usb_gadget_driver *driver;
-        struct phy               *phy;
-        struct usb_phy           *uphy;
-        struct s3c_hsotg_plat    *plat;
-
-        spinlock_t              lock;
-
-        void __iomem            *regs;
-        int                     irq;
-        struct clk              *clk;
-
-        struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsotg_supply_names)];
-
-        u32                     phyif;
-        unsigned int            dedicated_fifos:1;
-        unsigned char           num_of_eps;
-
-        struct dentry           *debug_root;
-        struct dentry           *debug_file;
-        struct dentry           *debug_fifo;
-
-        struct usb_request      *ep0_reply;
-        struct usb_request      *ctrl_req;
-        u8                      ep0_buff[8];
-        u8                      ctrl_buff[8];
-
-        struct usb_gadget       gadget;
-        unsigned int            setup;
-        unsigned long           last_rst;
-        struct s3c_hsotg_ep     *eps;
-};
-
-/**
- * struct s3c_hsotg_req - data transfer request
- * @req: The USB gadget request
- * @queue: The list of requests for the endpoint this is queued for.
- * @in_progress: Has already had size/packets written to core
- * @mapped: DMA buffer for this request has been mapped via dma_map_single().
- */
-struct s3c_hsotg_req {
-        struct usb_request      req;
-        struct list_head        queue;
-        unsigned char           in_progress;
-        unsigned char           mapped;
-};
+#include "core.h"
 
 /* conversion functions */
 static inline struct s3c_hsotg_req *our_req(struct usb_request *req)
@@ -340,9 +172,8 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
         /* set FIFO sizes to 2048/1024 */
 
         writel(2048, hsotg->regs + GRXFSIZ);
-        writel(GNPTXFSIZ_NPTxFStAddr(2048) |
-               GNPTXFSIZ_NPTxFDep(1024),
-               hsotg->regs + GNPTXFSIZ);
+        writel((2048 << FIFOSIZE_STARTADDR_SHIFT) |
+                (1024 << FIFOSIZE_DEPTH_SHIFT), hsotg->regs + GNPTXFSIZ);
 
         /*
          * arange all the rest of the TX FIFOs, as some versions of this
@@ -362,10 +193,10 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
 
         for (ep = 1; ep <= 15; ep++) {
                 val = addr;
-                val |= size << DPTXFSIZn_DPTxFSize_SHIFT;
+                val |= size << FIFOSIZE_DEPTH_SHIFT;
                 addr += size;
 
-                writel(val, hsotg->regs + DPTXFSIZn(ep));
+                writel(val, hsotg->regs + DPTXFSIZN(ep));
         }
 
         /*
@@ -373,15 +204,15 @@ static void s3c_hsotg_init_fifo(struct s3c_hsotg *hsotg)
          * all fifos are flushed before continuing
          */
 
-        writel(GRSTCTL_TxFNum(0x10) | GRSTCTL_TxFFlsh |
-               GRSTCTL_RxFFlsh, hsotg->regs + GRSTCTL);
+        writel(GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH |
+               GRSTCTL_RXFFLSH, hsotg->regs + GRSTCTL);
 
         /* wait until the fifos are both flushed */
         timeout = 100;
         while (1) {
                 val = readl(hsotg->regs + GRSTCTL);
 
-                if ((val & (GRSTCTL_TxFFlsh | GRSTCTL_RxFFlsh)) == 0)
+                if ((val & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) == 0)
                         break;
 
                 if (--timeout == 0) {
@@ -495,14 +326,14 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                  * how much data is left in the fifo.
                  */
 
-                size_left = DxEPTSIZ_XferSize_GET(epsize);
+                size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
 
                 /*
                  * if shared fifo, we cannot write anything until the
                  * previous data has been completely sent.
                  */
                 if (hs_ep->fifo_load != 0) {
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                         return -ENOSPC;
                 }
 
@@ -523,7 +354,7 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                         __func__, can_write);
 
                 if (can_write <= 0) {
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
                         return -ENOSPC;
                 }
         } else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
@@ -532,16 +363,16 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 can_write &= 0xffff;
                 can_write *= 4;
         } else {
-                if (GNPTXSTS_NPTxQSpcAvail_GET(gnptxsts) == 0) {
+                if (GNPTXSTS_NP_TXQ_SPC_AVAIL_GET(gnptxsts) == 0) {
                         dev_dbg(hsotg->dev,
                                 "%s: no queue slots available (0x%08x)\n",
                                 __func__, gnptxsts);
 
-                        s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTxFEmp);
+                        s3c_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
                         return -ENOSPC;
                 }
 
-                can_write = GNPTXSTS_NPTxFSpcAvail_GET(gnptxsts);
+                can_write = GNPTXSTS_NP_TXF_SPC_AVAIL_GET(gnptxsts);
                 can_write *= 4; /* fifo size is in 32bit quantities. */
         }
 
@@ -569,8 +400,8 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 /* it's needed only when we do not use dedicated fifos */
                 if (!hsotg->dedicated_fifos)
                         s3c_hsotg_en_gsint(hsotg,
-                                           periodic ? GINTSTS_PTxFEmp :
-                                           GINTSTS_NPTxFEmp);
+                                           periodic ? GINTSTS_PTXFEMP :
+                                           GINTSTS_NPTXFEMP);
         }
 
         /* see if we can write data */
@@ -598,8 +429,8 @@ static int s3c_hsotg_write_fifo(struct s3c_hsotg *hsotg,
                 /* it's needed only when we do not use dedicated fifos */
                 if (!hsotg->dedicated_fifos)
                         s3c_hsotg_en_gsint(hsotg,
-                                           periodic ? GINTSTS_PTxFEmp :
-                                           GINTSTS_NPTxFEmp);
+                                           periodic ? GINTSTS_PTXFEMP :
+                                           GINTSTS_NPTXFEMP);
         }
 
         dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
@@ -636,12 +467,12 @@ static unsigned get_ep_limit(struct s3c_hsotg_ep *hs_ep)
         unsigned maxpkt;
 
         if (index != 0) {
-                maxsize = DxEPTSIZ_XferSize_LIMIT + 1;
-                maxpkt = DxEPTSIZ_PktCnt_LIMIT + 1;
+                maxsize = DXEPTSIZ_XFERSIZE_LIMIT + 1;
+                maxpkt = DXEPTSIZ_PKTCNT_LIMIT + 1;
         } else {
                 maxsize = 64+64;
                 if (hs_ep->dir_in)
-                        maxpkt = DIEPTSIZ0_PktCnt_LIMIT + 1;
+                        maxpkt = DIEPTSIZ0_PKTCNT_LIMIT + 1;
                 else
                         maxpkt = 2;
         }
@@ -710,7 +541,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         /* If endpoint is stalled, we will restart request later */
         ctrl = readl(hsotg->regs + epctrl_reg);
 
-        if (ctrl & DxEPCTL_Stall) {
+        if (ctrl & DXEPCTL_STALL) {
                 dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
                 return;
         }
@@ -720,7 +551,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 ureq->length, ureq->actual);
         if (0)
                 dev_dbg(hsotg->dev,
-                        "REQ buf %p len %d dma 0x%pad noi=%d zp=%d snok=%d\n",
+                        "REQ buf %p len %d dma %pad noi=%d zp=%d snok=%d\n",
                         ureq->buf, length, &ureq->dma,
                         ureq->no_interrupt, ureq->zero, ureq->short_not_ok);
 
@@ -750,9 +581,9 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
 
         if (dir_in && index != 0)
                 if (hs_ep->isochronous)
-                        epsize = DxEPTSIZ_MC(packets);
+                        epsize = DXEPTSIZ_MC(packets);
                 else
-                        epsize = DxEPTSIZ_MC(1);
+                        epsize = DXEPTSIZ_MC(1);
         else
                 epsize = 0;
 
@@ -766,8 +597,8 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                         packets++;
         }
 
-        epsize |= DxEPTSIZ_PktCnt(packets);
-        epsize |= DxEPTSIZ_XferSize(length);
+        epsize |= DXEPTSIZ_PKTCNT(packets);
+        epsize |= DXEPTSIZ_XFERSIZE(length);
 
         dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n",
                 __func__, packets, length, ureq->length, epsize, epsize_reg);
@@ -789,12 +620,12 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
                 dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
                 writel(ureq->dma, hsotg->regs + dma_reg);
 
-                dev_dbg(hsotg->dev, "%s: 0x%pad => 0x%08x\n",
+                dev_dbg(hsotg->dev, "%s: %pad => 0x%08x\n",
                         __func__, &ureq->dma, dma_reg);
         }
 
-        ctrl |= DxEPCTL_EPEna;  /* ensure ep enabled */
-        ctrl |= DxEPCTL_USBActEp;
+        ctrl |= DXEPCTL_EPENA;  /* ensure ep enabled */
+        ctrl |= DXEPCTL_USBACTEP;
 
         dev_dbg(hsotg->dev, "setup req:%d\n", hsotg->setup);
 
@@ -802,7 +633,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
         if (hsotg->setup && index == 0)
                 hsotg->setup = 0;
         else
-                ctrl |= DxEPCTL_CNAK;   /* clear NAK set by core */
+                ctrl |= DXEPCTL_CNAK;   /* clear NAK set by core */
 
 
         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
@@ -828,7 +659,7 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
          * to debugging to see what is going on.
          */
         if (dir_in)
-                writel(DIEPMSK_INTknTXFEmpMsk,
+                writel(DIEPMSK_INTKNTXFEMPMSK,
                        hsotg->regs + DIEPINT(index));
 
         /*
@@ -837,12 +668,12 @@ static void s3c_hsotg_start_req(struct s3c_hsotg *hsotg,
          */
 
         /* check ep is enabled */
-        if (!(readl(hsotg->regs + epctrl_reg) & DxEPCTL_EPEna))
+        if (!(readl(hsotg->regs + epctrl_reg) & DXEPCTL_EPENA))
                 dev_warn(hsotg->dev,
-                         "ep%d: failed to become enabled (DxEPCTL=0x%08x)?\n",
+                         "ep%d: failed to become enabled (DXEPCTL=0x%08x)?\n",
                          index, readl(hsotg->regs + epctrl_reg));
 
-        dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n",
+        dev_dbg(hsotg->dev, "%s: DXEPCTL=0x%08x\n",
                 __func__, readl(hsotg->regs + epctrl_reg));
 
         /* enable ep interrupts */
@@ -1205,12 +1036,12 @@ static void s3c_hsotg_stall_ep0(struct s3c_hsotg *hsotg) {
          */
 
         ctrl = readl(hsotg->regs + reg);
-        ctrl |= DxEPCTL_Stall;
-        ctrl |= DxEPCTL_CNAK;
+        ctrl |= DXEPCTL_STALL;
+        ctrl |= DXEPCTL_CNAK;
         writel(ctrl, hsotg->regs + reg);
 
         dev_dbg(hsotg->dev,
-                "written DxEPCTL=0x%08x to %08x (DxEPCTL=0x%08x)\n",
+                "written DXEPCTL=0x%08x to %08x (DXEPCTL=0x%08x)\n",
                 ctrl, reg, readl(hsotg->regs + reg));
 
          /*
@@ -1262,8 +1093,9 @@ static void s3c_hsotg_process_control(struct s3c_hsotg *hsotg,
                 case USB_REQ_SET_ADDRESS:
                         s3c_hsotg_disconnect(hsotg);
                         dcfg = readl(hsotg->regs + DCFG);
-                        dcfg &= ~DCFG_DevAddr_MASK;
-                        dcfg |= ctrl->wValue << DCFG_DevAddr_SHIFT;
+                        dcfg &= ~DCFG_DEVADDR_MASK;
+                        dcfg |= (le16_to_cpu(ctrl->wValue) <<
+                                 DCFG_DEVADDR_SHIFT) & DCFG_DEVADDR_MASK;
                         writel(dcfg, hsotg->regs + DCFG);
 
                         dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
@@ -1458,7 +1290,7 @@ static void s3c_hsotg_rx_data(struct s3c_hsotg *hsotg, int ep_idx, int size)
                 int ptr;
 
                 dev_warn(hsotg->dev,
-                         "%s: FIFO %d bytes on ep%d but no req (DxEPCTl=0x%08x)\n",
+                         "%s: FIFO %d bytes on ep%d but no req (DXEPCTl=0x%08x)\n",
                          __func__, size, ep_idx, epctl);
 
                 /* dump the data from the FIFO, we've nothing we can do */
@@ -1530,13 +1362,13 @@ static void s3c_hsotg_send_zlp(struct s3c_hsotg *hsotg,
         dev_dbg(hsotg->dev, "sending zero-length packet\n");
 
         /* issue a zero-sized packet to terminate this */
-        writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
-               DxEPTSIZ_XferSize(0), hsotg->regs + DIEPTSIZ(0));
+        writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
+               DXEPTSIZ_XFERSIZE(0), hsotg->regs + DIEPTSIZ(0));
 
         ctrl = readl(hsotg->regs + DIEPCTL0);
-        ctrl |= DxEPCTL_CNAK;  /* clear NAK set by core */
-        ctrl |= DxEPCTL_EPEna; /* ensure ep enabled */
-        ctrl |= DxEPCTL_USBActEp;
+        ctrl |= DXEPCTL_CNAK;  /* clear NAK set by core */
+        ctrl |= DXEPCTL_EPENA; /* ensure ep enabled */
+        ctrl |= DXEPCTL_USBACTEP;
         writel(ctrl, hsotg->regs + DIEPCTL0);
 }
 
@@ -1557,7 +1389,7 @@ static void s3c_hsotg_handle_outdone(struct s3c_hsotg *hsotg,
         struct s3c_hsotg_ep *hs_ep = &hsotg->eps[epnum];
         struct s3c_hsotg_req *hs_req = hs_ep->req;
         struct usb_request *req = &hs_req->req;
-        unsigned size_left = DxEPTSIZ_XferSize_GET(epsize);
+        unsigned size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
         int result = 0;
 
         if (!hs_req) {
@@ -1657,24 +1489,22 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
 
         WARN_ON(using_dma(hsotg));
 
-        epnum = grxstsr & GRXSTS_EPNum_MASK;
-        status = grxstsr & GRXSTS_PktSts_MASK;
+        epnum = grxstsr & GRXSTS_EPNUM_MASK;
+        status = grxstsr & GRXSTS_PKTSTS_MASK;
 
-        size = grxstsr & GRXSTS_ByteCnt_MASK;
-        size >>= GRXSTS_ByteCnt_SHIFT;
+        size = grxstsr & GRXSTS_BYTECNT_MASK;
+        size >>= GRXSTS_BYTECNT_SHIFT;
 
         if (1)
                 dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n",
                         __func__, grxstsr, size, epnum);
 
-#define __status(x) ((x) >> GRXSTS_PktSts_SHIFT)
-
-        switch (status >> GRXSTS_PktSts_SHIFT) {
-        case __status(GRXSTS_PktSts_GlobalOutNAK):
-                dev_dbg(hsotg->dev, "GlobalOutNAK\n");
+        switch ((status & GRXSTS_PKTSTS_MASK) >> GRXSTS_PKTSTS_SHIFT) {
+        case GRXSTS_PKTSTS_GLOBALOUTNAK:
+                dev_dbg(hsotg->dev, "GLOBALOUTNAK\n");
                 break;
 
-        case __status(GRXSTS_PktSts_OutDone):
+        case GRXSTS_PKTSTS_OUTDONE:
                 dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg));
 
@@ -1682,7 +1512,7 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
                         s3c_hsotg_handle_outdone(hsotg, epnum, false);
                 break;
 
-        case __status(GRXSTS_PktSts_SetupDone):
+        case GRXSTS_PKTSTS_SETUPDONE:
                 dev_dbg(hsotg->dev,
                         "SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg),
@@ -1691,11 +1521,11 @@ static void s3c_hsotg_handle_rx(struct s3c_hsotg *hsotg)
                 s3c_hsotg_handle_outdone(hsotg, epnum, true);
                 break;
 
-        case __status(GRXSTS_PktSts_OutRX):
+        case GRXSTS_PKTSTS_OUTRX:
                 s3c_hsotg_rx_data(hsotg, epnum, size);
                 break;
 
-        case __status(GRXSTS_PktSts_SetupRX):
+        case GRXSTS_PKTSTS_SETUPRX:
                 dev_dbg(hsotg->dev,
                         "SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
                         s3c_hsotg_read_frameno(hsotg),
@@ -1761,7 +1591,7 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
                 hs_ep->ep.maxpacket = mps;
                 hs_ep->mc = 1;
         } else {
-                mpsval = mps & DxEPCTL_MPS_MASK;
+                mpsval = mps & DXEPCTL_MPS_MASK;
                 if (mpsval > 1024)
                         goto bad_mps;
                 mcval = ((mps >> 11) & 0x3) + 1;
@@ -1777,13 +1607,13 @@ static void s3c_hsotg_set_ep_maxpacket(struct s3c_hsotg *hsotg,
          */
 
         reg = readl(regs + DIEPCTL(ep));
-        reg &= ~DxEPCTL_MPS_MASK;
+        reg &= ~DXEPCTL_MPS_MASK;
         reg |= mpsval;
         writel(reg, regs + DIEPCTL(ep));
 
         if (ep) {
                 reg = readl(regs + DOEPCTL(ep));
-                reg &= ~DxEPCTL_MPS_MASK;
+                reg &= ~DXEPCTL_MPS_MASK;
                 reg |= mpsval;
                 writel(reg, regs + DOEPCTL(ep));
         }
@@ -1804,7 +1634,7 @@ static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
         int timeout;
         int val;
 
-        writel(GRSTCTL_TxFNum(idx) | GRSTCTL_TxFFlsh,
+        writel(GRSTCTL_TXFNUM(idx) | GRSTCTL_TXFFLSH,
                 hsotg->regs + GRSTCTL);
 
         /* wait until the fifo is flushed */
@@ -1813,7 +1643,7 @@ static void s3c_hsotg_txfifo_flush(struct s3c_hsotg *hsotg, unsigned int idx)
         while (1) {
                 val = readl(hsotg->regs + GRSTCTL);
 
-                if ((val & (GRSTCTL_TxFFlsh)) == 0)
+                if ((val & (GRSTCTL_TXFFLSH)) == 0)
                         break;
 
                 if (--timeout == 0) {
@@ -1896,7 +1726,7 @@ static void s3c_hsotg_complete_in(struct s3c_hsotg *hsotg,
          * aligned).
          */
 
-        size_left = DxEPTSIZ_XferSize_GET(epsize);
+        size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
 
         size_done = hs_ep->size_loaded - size_left;
         size_done += hs_ep->last_load;
@@ -1963,17 +1793,17 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
         dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
                 __func__, idx, dir_in ? "in" : "out", ints);
 
-        if (ints & DxEPINT_XferCompl) {
+        if (ints & DXEPINT_XFERCOMPL) {
                 if (hs_ep->isochronous && hs_ep->interval == 1) {
-                        if (ctrl & DxEPCTL_EOFrNum)
-                                ctrl |= DxEPCTL_SetEvenFr;
+                        if (ctrl & DXEPCTL_EOFRNUM)
+                                ctrl |= DXEPCTL_SETEVENFR;
                         else
-                                ctrl |= DxEPCTL_SetOddFr;
+                                ctrl |= DXEPCTL_SETODDFR;
                         writel(ctrl, hsotg->regs + epctl_reg);
                 }
 
                 dev_dbg(hsotg->dev,
-                        "%s: XferCompl: DxEPCTL=0x%08x, DxEPTSIZ=%08x\n",
+                        "%s: XferCompl: DxEPCTL=0x%08x, DXEPTSIZ=%08x\n",
                         __func__, readl(hsotg->regs + epctl_reg),
                         readl(hsotg->regs + epsiz_reg));
 
@@ -1996,7 +1826,7 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 }
         }
 
-        if (ints & DxEPINT_EPDisbld) {
+        if (ints & DXEPINT_EPDISBLD) {
                 dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
 
                 if (dir_in) {
@@ -2004,20 +1834,20 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
 
                         s3c_hsotg_txfifo_flush(hsotg, idx);
 
-                        if ((epctl & DxEPCTL_Stall) &&
-                                (epctl & DxEPCTL_EPType_Bulk)) {
+                        if ((epctl & DXEPCTL_STALL) &&
+                                (epctl & DXEPCTL_EPTYPE_BULK)) {
                                 int dctl = readl(hsotg->regs + DCTL);
 
-                                dctl |= DCTL_CGNPInNAK;
+                                dctl |= DCTL_CGNPINNAK;
                                 writel(dctl, hsotg->regs + DCTL);
                         }
                 }
         }
 
-        if (ints & DxEPINT_AHBErr)
+        if (ints & DXEPINT_AHBERR)
                 dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
 
-        if (ints & DxEPINT_Setup) {  /* Setup or Timeout */
+        if (ints & DXEPINT_SETUP) {  /* Setup or Timeout */
                 dev_dbg(hsotg->dev, "%s: Setup/Timeout\n",  __func__);
 
                 if (using_dma(hsotg) && idx == 0) {
@@ -2035,25 +1865,25 @@ static void s3c_hsotg_epint(struct s3c_hsotg *hsotg, unsigned int idx,
                 }
         }
 
-        if (ints & DxEPINT_Back2BackSetup)
+        if (ints & DXEPINT_BACK2BACKSETUP)
                 dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
 
         if (dir_in && !hs_ep->isochronous) {
                 /* not sure if this is important, but we'll clear it anyway */
-                if (ints & DIEPMSK_INTknTXFEmpMsk) {
+                if (ints & DIEPMSK_INTKNTXFEMPMSK) {
                         dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
                                 __func__, idx);
                 }
 
                 /* this probably means something bad is happening */
-                if (ints & DIEPMSK_INTknEPMisMsk) {
+                if (ints & DIEPMSK_INTKNEPMISMSK) {
                         dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
                                  __func__, idx);
                 }
 
                 /* FIFO has space or is empty (see GAHBCFG) */
                 if (hsotg->dedicated_fifos &&
-                    ints & DIEPMSK_TxFIFOEmpty) {
+                    ints & DIEPMSK_TXFIFOEMPTY) {
                         dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
                                 __func__, idx);
                         if (!using_dma(hsotg))
@@ -2089,21 +1919,21 @@ static void s3c_hsotg_irq_enumdone(struct s3c_hsotg *hsotg)
          */
 
         /* catch both EnumSpd_FS and EnumSpd_FS48 */
-        switch (dsts & DSTS_EnumSpd_MASK) {
-        case DSTS_EnumSpd_FS:
-        case DSTS_EnumSpd_FS48:
+        switch (dsts & DSTS_ENUMSPD_MASK) {
+        case DSTS_ENUMSPD_FS:
+        case DSTS_ENUMSPD_FS48:
                 hsotg->gadget.speed = USB_SPEED_FULL;
                 ep0_mps = EP0_MPS_LIMIT;
                 ep_mps = 1023;
                 break;
 
-        case DSTS_EnumSpd_HS:
+        case DSTS_ENUMSPD_HS:
                 hsotg->gadget.speed = USB_SPEED_HIGH;
                 ep0_mps = EP0_MPS_LIMIT;
                 ep_mps = 1024;
                 break;
 
-        case DSTS_EnumSpd_LS:
+        case DSTS_ENUMSPD_LS:
                 hsotg->gadget.speed = USB_SPEED_LOW;
                 /*
                  * note, we don't actually support LS in this driver at the
@@ -2169,16 +1999,6 @@ static void kill_all_requests(struct s3c_hsotg *hsotg,
                         s3c_hsotg_txfifo_flush(hsotg, ep->index);
 }
 
-#define call_gadget(_hs, _entry) \
-do { \
-        if ((_hs)->gadget.speed != USB_SPEED_UNKNOWN && \
-            (_hs)->driver && (_hs)->driver->_entry) { \
-                spin_unlock(&_hs->lock); \
-                (_hs)->driver->_entry(&(_hs)->gadget); \
-                spin_lock(&_hs->lock); \
-        } \
-} while (0)
-
 /**
  * s3c_hsotg_disconnect - disconnect service
  * @hsotg: The device state.
@@ -2226,9 +2046,9 @@ static void s3c_hsotg_irq_fifoempty(struct s3c_hsotg *hsotg, bool periodic)
 }
 
 /* IRQ flags which will trigger a retry around the IRQ loop */
-#define IRQ_RETRY_MASK (GINTSTS_NPTxFEmp | \
-                        GINTSTS_PTxFEmp |  \
-                        GINTSTS_RxFLvl)
+#define IRQ_RETRY_MASK (GINTSTS_NPTXFEMP | \
+                        GINTSTS_PTXFEMP |  \
+                        GINTSTS_RXFLVL)
 
 /**
  * s3c_hsotg_corereset - issue softreset to the core
@@ -2244,14 +2064,14 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
         dev_dbg(hsotg->dev, "resetting core\n");
 
         /* issue soft reset */
-        writel(GRSTCTL_CSftRst, hsotg->regs + GRSTCTL);
+        writel(GRSTCTL_CSFTRST, hsotg->regs + GRSTCTL);
 
         timeout = 10000;
         do {
                 grstctl = readl(hsotg->regs + GRSTCTL);
-        } while ((grstctl & GRSTCTL_CSftRst) && timeout-- > 0);
+        } while ((grstctl & GRSTCTL_CSFTRST) && timeout-- > 0);
 
-        if (grstctl & GRSTCTL_CSftRst) {
+        if (grstctl & GRSTCTL_CSFTRST) {
                 dev_err(hsotg->dev, "Failed to get CSftRst asserted\n");
                 return -EINVAL;
         }
@@ -2268,7 +2088,7 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                         return -ETIMEDOUT;
                 }
 
-                if (!(grstctl & GRSTCTL_AHBIdle))
+                if (!(grstctl & GRSTCTL_AHBIDLE))
                         continue;
 
                 break;          /* reset done */
@@ -2294,14 +2114,14 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          */
 
         /* set the PLL on, remove the HNP/SRP and set the PHY */
-        writel(hsotg->phyif | GUSBCFG_TOutCal(7) |
+        writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
                (0x5 << 10), hsotg->regs + GUSBCFG);
 
         s3c_hsotg_init_fifo(hsotg);
 
-        __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 
-        writel(1 << 18 | DCFG_DevSpd_HS,  hsotg->regs + DCFG);
+        writel(1 << 18 | DCFG_DEVSPD_HS,  hsotg->regs + DCFG);
 
         /* Clear any pending OTG interrupts */
         writel(0xffffffff, hsotg->regs + GOTGINT);
@@ -2309,21 +2129,21 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
         /* Clear any pending interrupts */
         writel(0xffffffff, hsotg->regs + GINTSTS);
 
-        writel(GINTSTS_ErlySusp | GINTSTS_SessReqInt |
-               GINTSTS_GOUTNakEff | GINTSTS_GINNakEff |
-               GINTSTS_ConIDStsChng | GINTSTS_USBRst |
-               GINTSTS_EnumDone | GINTSTS_OTGInt |
-               GINTSTS_USBSusp | GINTSTS_WkUpInt,
-               hsotg->regs + GINTMSK);
+        writel(GINTSTS_ERLYSUSP | GINTSTS_SESSREQINT |
+                GINTSTS_GOUTNAKEFF | GINTSTS_GINNAKEFF |
+                GINTSTS_CONIDSTSCHNG | GINTSTS_USBRST |
+                GINTSTS_ENUMDONE | GINTSTS_OTGINT |
+                GINTSTS_USBSUSP | GINTSTS_WKUPINT,
+                hsotg->regs + GINTMSK);
 
         if (using_dma(hsotg))
-                writel(GAHBCFG_GlblIntrEn | GAHBCFG_DMAEn |
-                       GAHBCFG_HBstLen_Incr4,
+                writel(GAHBCFG_GLBL_INTR_EN | GAHBCFG_DMA_EN |
+                       GAHBCFG_HBSTLEN_INCR4,
                        hsotg->regs + GAHBCFG);
         else
-                writel(((hsotg->dedicated_fifos) ? (GAHBCFG_NPTxFEmpLvl |
-                                                    GAHBCFG_PTxFEmpLvl) : 0) |
-                       GAHBCFG_GlblIntrEn,
+                writel(((hsotg->dedicated_fifos) ? (GAHBCFG_NP_TXF_EMP_LVL |
+                                                    GAHBCFG_P_TXF_EMP_LVL) : 0) |
+                       GAHBCFG_GLBL_INTR_EN,
                        hsotg->regs + GAHBCFG);
 
         /*
@@ -2332,22 +2152,22 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          * interrupts.
          */
 
-        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TxFIFOEmpty |
-               DIEPMSK_INTknTXFEmpMsk : 0) |
-               DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk |
-               DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
-               DIEPMSK_INTknEPMisMsk,
-               hsotg->regs + DIEPMSK);
+        writel(((hsotg->dedicated_fifos) ? DIEPMSK_TXFIFOEMPTY |
+                DIEPMSK_INTKNTXFEMPMSK : 0) |
+                DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK |
+                DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
+                DIEPMSK_INTKNEPMISMSK,
+                hsotg->regs + DIEPMSK);
 
         /*
          * don't need XferCompl, we get that from RXFIFO in slave mode. In
          * DMA mode we may need this.
          */
-        writel((using_dma(hsotg) ? (DIEPMSK_XferComplMsk |
-                                    DIEPMSK_TimeOUTMsk) : 0) |
-               DOEPMSK_EPDisbldMsk | DOEPMSK_AHBErrMsk |
-               DOEPMSK_SetupMsk,
-               hsotg->regs + DOEPMSK);
+        writel((using_dma(hsotg) ? (DIEPMSK_XFERCOMPLMSK |
+                                    DIEPMSK_TIMEOUTMSK) : 0) |
+                DOEPMSK_EPDISBLDMSK | DOEPMSK_AHBERRMSK |
+                DOEPMSK_SETUPMSK,
+                hsotg->regs + DOEPMSK);
 
         writel(0, hsotg->regs + DAINTMSK);
 
@@ -2356,7 +2176,7 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
                 readl(hsotg->regs + DOEPCTL0));
 
         /* enable in and out endpoint interrupts */
-        s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPInt | GINTSTS_IEPInt);
+        s3c_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
 
         /*
          * Enable the RXFIFO when in slave mode, as this is how we collect
@@ -2364,15 +2184,15 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          * things we cannot process, so do not use it.
          */
         if (!using_dma(hsotg))
-                s3c_hsotg_en_gsint(hsotg, GINTSTS_RxFLvl);
+                s3c_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
 
         /* Enable interrupts for EP0 in and out */
         s3c_hsotg_ctrl_epint(hsotg, 0, 0, 1);
         s3c_hsotg_ctrl_epint(hsotg, 0, 1, 1);
 
-        __orr32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
+        __orr32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
         udelay(10);  /* see openiboot */
-        __bic32(hsotg->regs + DCTL, DCTL_PWROnPrgDone);
+        __bic32(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
 
         dev_dbg(hsotg->dev, "DCTL=0x%08x\n", readl(hsotg->regs + DCTL));
 
@@ -2382,17 +2202,17 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
          */
 
         /* set to read 1 8byte packet */
-        writel(DxEPTSIZ_MC(1) | DxEPTSIZ_PktCnt(1) |
-               DxEPTSIZ_XferSize(8), hsotg->regs + DOEPTSIZ0);
+        writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
+               DXEPTSIZ_XFERSIZE(8), hsotg->regs + DOEPTSIZ0);
 
         writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
-               DxEPCTL_CNAK | DxEPCTL_EPEna |
-               DxEPCTL_USBActEp,
+               DXEPCTL_CNAK | DXEPCTL_EPENA |
+               DXEPCTL_USBACTEP,
                hsotg->regs + DOEPCTL0);
 
         /* enable, but don't activate EP0in */
         writel(s3c_hsotg_ep0_mps(hsotg->eps[0].ep.maxpacket) |
-               DxEPCTL_USBActEp, hsotg->regs + DIEPCTL0);
+               DXEPCTL_USBACTEP, hsotg->regs + DIEPCTL0);
 
         s3c_hsotg_enqueue_setup(hsotg);
 
@@ -2401,14 +2221,14 @@ static void s3c_hsotg_core_init(struct s3c_hsotg *hsotg)
                 readl(hsotg->regs + DOEPCTL0));
 
         /* clear global NAKs */
-        writel(DCTL_CGOUTNak | DCTL_CGNPInNAK,
+        writel(DCTL_CGOUTNAK | DCTL_CGNPINNAK,
                hsotg->regs + DCTL);
 
         /* must be at-least 3ms to allow bus to see disconnect */
         mdelay(3);
 
         /* remove the soft-disconnect and let's go */
-        __bic32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __bic32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 }
 
 /**
@@ -2433,7 +2253,7 @@ irq_retry:
 
         gintsts &= gintmsk;
 
-        if (gintsts & GINTSTS_OTGInt) {
+        if (gintsts & GINTSTS_OTGINT) {
                 u32 otgint = readl(hsotg->regs + GOTGINT);
 
                 dev_info(hsotg->dev, "OTGInt: %08x\n", otgint);
@@ -2441,34 +2261,34 @@ irq_retry:
                 writel(otgint, hsotg->regs + GOTGINT);
         }
 
-        if (gintsts & GINTSTS_SessReqInt) {
+        if (gintsts & GINTSTS_SESSREQINT) {
                 dev_dbg(hsotg->dev, "%s: SessReqInt\n", __func__);
-                writel(GINTSTS_SessReqInt, hsotg->regs + GINTSTS);
+                writel(GINTSTS_SESSREQINT, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & GINTSTS_EnumDone) {
-                writel(GINTSTS_EnumDone, hsotg->regs + GINTSTS);
+        if (gintsts & GINTSTS_ENUMDONE) {
+                writel(GINTSTS_ENUMDONE, hsotg->regs + GINTSTS);
 
                 s3c_hsotg_irq_enumdone(hsotg);
         }
 
-        if (gintsts & GINTSTS_ConIDStsChng) {
+        if (gintsts & GINTSTS_CONIDSTSCHNG) {
                 dev_dbg(hsotg->dev, "ConIDStsChg (DSTS=0x%08x, GOTCTL=%08x)\n",
                         readl(hsotg->regs + DSTS),
                         readl(hsotg->regs + GOTGCTL));
 
-                writel(GINTSTS_ConIDStsChng, hsotg->regs + GINTSTS);
+                writel(GINTSTS_CONIDSTSCHNG, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & (GINTSTS_OEPInt | GINTSTS_IEPInt)) {
+        if (gintsts & (GINTSTS_OEPINT | GINTSTS_IEPINT)) {
                 u32 daint = readl(hsotg->regs + DAINT);
                 u32 daintmsk = readl(hsotg->regs + DAINTMSK);
                 u32 daint_out, daint_in;
                 int ep;
 
                 daint &= daintmsk;
-                daint_out = daint >> DAINT_OutEP_SHIFT;
-                daint_in = daint & ~(daint_out << DAINT_OutEP_SHIFT);
+                daint_out = daint >> DAINT_OUTEP_SHIFT;
+                daint_in = daint & ~(daint_out << DAINT_OUTEP_SHIFT);
 
                 dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
 
@@ -2483,7 +2303,7 @@ irq_retry:
                 }
         }
 
-        if (gintsts & GINTSTS_USBRst) {
+        if (gintsts & GINTSTS_USBRST) {
 
                 u32 usb_status = readl(hsotg->regs + GOTGCTL);
 
@@ -2491,7 +2311,7 @@ irq_retry:
                 dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
                         readl(hsotg->regs + GNPTXSTS));
 
-                writel(GINTSTS_USBRst, hsotg->regs + GINTSTS);
+                writel(GINTSTS_USBRST, hsotg->regs + GINTSTS);
 
                 if (usb_status & GOTGCTL_BSESVLD) {
                         if (time_after(jiffies, hsotg->last_rst +
@@ -2508,7 +2328,7 @@ irq_retry:
 
         /* check both FIFOs */
 
-        if (gintsts & GINTSTS_NPTxFEmp) {
+        if (gintsts & GINTSTS_NPTXFEMP) {
                 dev_dbg(hsotg->dev, "NPTxFEmp\n");
 
                 /*
@@ -2517,20 +2337,20 @@ irq_retry:
                  * it needs re-enabling
                  */
 
-                s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTxFEmp);
+                s3c_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
                 s3c_hsotg_irq_fifoempty(hsotg, false);
         }
 
-        if (gintsts & GINTSTS_PTxFEmp) {
+        if (gintsts & GINTSTS_PTXFEMP) {
                 dev_dbg(hsotg->dev, "PTxFEmp\n");
 
                 /* See note in GINTSTS_NPTxFEmp */
 
-                s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTxFEmp);
+                s3c_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
                 s3c_hsotg_irq_fifoempty(hsotg, true);
         }
 
-        if (gintsts & GINTSTS_RxFLvl) {
+        if (gintsts & GINTSTS_RXFLVL) {
                 /*
                  * note, since GINTSTS_RxFLvl doubles as FIFO-not-empty,
                  * we need to retry s3c_hsotg_handle_rx if this is still
@@ -2540,28 +2360,28 @@ irq_retry:
                 s3c_hsotg_handle_rx(hsotg);
         }
 
-        if (gintsts & GINTSTS_ModeMis) {
+        if (gintsts & GINTSTS_MODEMIS) {
                 dev_warn(hsotg->dev, "warning, mode mismatch triggered\n");
-                writel(GINTSTS_ModeMis, hsotg->regs + GINTSTS);
+                writel(GINTSTS_MODEMIS, hsotg->regs + GINTSTS);
         }
 
-        if (gintsts & GINTSTS_USBSusp) {
+        if (gintsts & GINTSTS_USBSUSP) {
                 dev_info(hsotg->dev, "GINTSTS_USBSusp\n");
-                writel(GINTSTS_USBSusp, hsotg->regs + GINTSTS);
+                writel(GINTSTS_USBSUSP, hsotg->regs + GINTSTS);
 
                 call_gadget(hsotg, suspend);
         }
 
-        if (gintsts & GINTSTS_WkUpInt) {
+        if (gintsts & GINTSTS_WKUPINT) {
                 dev_info(hsotg->dev, "GINTSTS_WkUpIn\n");
-                writel(GINTSTS_WkUpInt, hsotg->regs + GINTSTS);
+                writel(GINTSTS_WKUPINT, hsotg->regs + GINTSTS);
 
                 call_gadget(hsotg, resume);
         }
 
-        if (gintsts & GINTSTS_ErlySusp) {
+        if (gintsts & GINTSTS_ERLYSUSP) {
                 dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
-                writel(GINTSTS_ErlySusp, hsotg->regs + GINTSTS);
+                writel(GINTSTS_ERLYSUSP, hsotg->regs + GINTSTS);
         }
 
         /*
@@ -2570,18 +2390,18 @@ irq_retry:
          * the occurrence.
          */
 
-        if (gintsts & GINTSTS_GOUTNakEff) {
+        if (gintsts & GINTSTS_GOUTNAKEFF) {
                 dev_info(hsotg->dev, "GOUTNakEff triggered\n");
 
-                writel(DCTL_CGOUTNak, hsotg->regs + DCTL);
+                writel(DCTL_CGOUTNAK, hsotg->regs + DCTL);
 
                 s3c_hsotg_dump(hsotg);
         }
 
-        if (gintsts & GINTSTS_GINNakEff) {
+        if (gintsts & GINTSTS_GINNAKEFF) {
                 dev_info(hsotg->dev, "GINNakEff triggered\n");
 
-                writel(DCTL_CGNPInNAK, hsotg->regs + DCTL);
+                writel(DCTL_CGNPINNAK, hsotg->regs + DCTL);
 
                 s3c_hsotg_dump(hsotg);
         }
@@ -2645,14 +2465,14 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
 
         spin_lock_irqsave(&hsotg->lock, flags);
 
-        epctrl &= ~(DxEPCTL_EPType_MASK | DxEPCTL_MPS_MASK);
-        epctrl |= DxEPCTL_MPS(mps);
+        epctrl &= ~(DXEPCTL_EPTYPE_MASK | DXEPCTL_MPS_MASK);
+        epctrl |= DXEPCTL_MPS(mps);
 
         /*
          * mark the endpoint as active, otherwise the core may ignore
          * transactions entirely for this endpoint
          */
-        epctrl |= DxEPCTL_USBActEp;
+        epctrl |= DXEPCTL_USBACTEP;
 
         /*
          * set the NAK status on the endpoint, otherwise we might try and
@@ -2661,7 +2481,7 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
          * size register hasn't been set.
          */
 
-        epctrl |= DxEPCTL_SNAK;
+        epctrl |= DXEPCTL_SNAK;
 
         /* update the endpoint state */
         s3c_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps);
@@ -2677,15 +2497,15 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
 
         switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
         case USB_ENDPOINT_XFER_ISOC:
-                epctrl |= DxEPCTL_EPType_Iso;
-                epctrl |= DxEPCTL_SetEvenFr;
+                epctrl |= DXEPCTL_EPTYPE_ISO;
+                epctrl |= DXEPCTL_SETEVENFR;
                 hs_ep->isochronous = 1;
                 if (dir_in)
                         hs_ep->periodic = 1;
                 break;
 
         case USB_ENDPOINT_XFER_BULK:
-                epctrl |= DxEPCTL_EPType_Bulk;
+                epctrl |= DXEPCTL_EPTYPE_BULK;
                 break;
 
         case USB_ENDPOINT_XFER_INT:
@@ -2698,14 +2518,14 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
                          */
 
                         hs_ep->periodic = 1;
-                        epctrl |= DxEPCTL_TxFNum(index);
+                        epctrl |= DXEPCTL_TXFNUM(index);
                 }
 
-                epctrl |= DxEPCTL_EPType_Intterupt;
+                epctrl |= DXEPCTL_EPTYPE_INTERRUPT;
                 break;
 
         case USB_ENDPOINT_XFER_CONTROL:
-                epctrl |= DxEPCTL_EPType_Control;
+                epctrl |= DXEPCTL_EPTYPE_CONTROL;
                 break;
         }
 
@@ -2714,11 +2534,11 @@ static int s3c_hsotg_ep_enable(struct usb_ep *ep,
          * a unique tx-fifo even if it is non-periodic.
          */
         if (dir_in && hsotg->dedicated_fifos)
-                epctrl |= DxEPCTL_TxFNum(index);
+                epctrl |= DXEPCTL_TXFNUM(index);
 
         /* for non control endpoints, set PID to D0 */
         if (index)
-                epctrl |= DxEPCTL_SetD0PID;
+                epctrl |= DXEPCTL_SETD0PID;
 
         dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n",
                 __func__, epctrl);
@@ -2763,9 +2583,9 @@ static int s3c_hsotg_ep_disable(struct usb_ep *ep)
 
 
         ctrl = readl(hsotg->regs + epctrl_reg);
-        ctrl &= ~DxEPCTL_EPEna;
-        ctrl &= ~DxEPCTL_USBActEp;
-        ctrl |= DxEPCTL_SNAK;
+        ctrl &= ~DXEPCTL_EPENA;
+        ctrl &= ~DXEPCTL_USBACTEP;
+        ctrl |= DXEPCTL_SNAK;
 
         dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
         writel(ctrl, hsotg->regs + epctrl_reg);
@@ -2852,15 +2672,15 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epctl = readl(hs->regs + epreg);
 
         if (value) {
-                epctl |= DxEPCTL_Stall + DxEPCTL_SNAK;
-                if (epctl & DxEPCTL_EPEna)
-                        epctl |= DxEPCTL_EPDis;
+                epctl |= DXEPCTL_STALL + DXEPCTL_SNAK;
+                if (epctl & DXEPCTL_EPENA)
+                        epctl |= DXEPCTL_EPDIS;
         } else {
-                epctl &= ~DxEPCTL_Stall;
-                xfertype = epctl & DxEPCTL_EPType_MASK;
-                if (xfertype == DxEPCTL_EPType_Bulk ||
-                        xfertype == DxEPCTL_EPType_Intterupt)
-                                epctl |= DxEPCTL_SetD0PID;
+                epctl &= ~DXEPCTL_STALL;
+                xfertype = epctl & DXEPCTL_EPTYPE_MASK;
+                if (xfertype == DXEPCTL_EPTYPE_BULK ||
+                        xfertype == DXEPCTL_EPTYPE_INTERRUPT)
+                                epctl |= DXEPCTL_SETD0PID;
         }
 
         writel(epctl, hs->regs + epreg);
@@ -2869,13 +2689,13 @@ static int s3c_hsotg_ep_sethalt(struct usb_ep *ep, int value)
         epctl = readl(hs->regs + epreg);
 
         if (value)
-                epctl |= DxEPCTL_Stall;
+                epctl |= DXEPCTL_STALL;
         else {
-                epctl &= ~DxEPCTL_Stall;
-                xfertype = epctl & DxEPCTL_EPType_MASK;
-                if (xfertype == DxEPCTL_EPType_Bulk ||
-                        xfertype == DxEPCTL_EPType_Intterupt)
-                                epctl |= DxEPCTL_SetD0PID;
+                epctl &= ~DXEPCTL_STALL;
+                xfertype = epctl & DXEPCTL_EPTYPE_MASK;
+                if (xfertype == DXEPCTL_EPTYPE_BULK ||
+                        xfertype == DXEPCTL_EPTYPE_INTERRUPT)
+                                epctl |= DXEPCTL_SETD0PID;
         }
 
         writel(epctl, hs->regs + epreg);
@@ -2965,22 +2785,22 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
 {
         /* unmask subset of endpoint interrupts */
 
-        writel(DIEPMSK_TimeOUTMsk | DIEPMSK_AHBErrMsk |
-               DIEPMSK_EPDisbldMsk | DIEPMSK_XferComplMsk,
-               hsotg->regs + DIEPMSK);
+        writel(DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
+                DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK,
+                hsotg->regs + DIEPMSK);
 
-        writel(DOEPMSK_SetupMsk | DOEPMSK_AHBErrMsk |
-               DOEPMSK_EPDisbldMsk | DOEPMSK_XferComplMsk,
-               hsotg->regs + DOEPMSK);
+        writel(DOEPMSK_SETUPMSK | DOEPMSK_AHBERRMSK |
+                DOEPMSK_EPDISBLDMSK | DOEPMSK_XFERCOMPLMSK,
+                hsotg->regs + DOEPMSK);
 
         writel(0, hsotg->regs + DAINTMSK);
 
         /* Be in disconnected state until gadget is registered */
-        __orr32(hsotg->regs + DCTL, DCTL_SftDiscon);
+        __orr32(hsotg->regs + DCTL, DCTL_SFTDISCON);
 
         if (0) {
                 /* post global nak until we're ready */
-                writel(DCTL_SGNPInNAK | DCTL_SGOUTNak,
+                writel(DCTL_SGNPINNAK | DCTL_SGOUTNAK,
                        hsotg->regs + DCTL);
         }
 
@@ -2993,10 +2813,10 @@ static void s3c_hsotg_init(struct s3c_hsotg *hsotg)
         s3c_hsotg_init_fifo(hsotg);
 
         /* set the PLL on, remove the HNP/SRP and set the PHY */
-        writel(GUSBCFG_PHYIf16 | GUSBCFG_TOutCal(7) | (0x5 << 10),
+        writel(GUSBCFG_PHYIF16 | GUSBCFG_TOUTCAL(7) | (0x5 << 10),
                hsotg->regs + GUSBCFG);
 
-        writel(using_dma(hsotg) ? GAHBCFG_DMAEn : 0x0,
+        writel(using_dma(hsotg) ? GAHBCFG_DMA_EN : 0x0,
                hsotg->regs + GAHBCFG);
 }
 
@@ -3187,8 +3007,8 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
          * code is changed to make each endpoint's direction changeable.
          */
 
-        ptxfifo = readl(hsotg->regs + DPTXFSIZn(epnum));
-        hs_ep->fifo_size = DPTXFSIZn_DPTxFSize_GET(ptxfifo) * 4;
+        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
@@ -3196,7 +3016,7 @@ static void s3c_hsotg_initep(struct s3c_hsotg *hsotg,
          */
 
         if (using_dma(hsotg)) {
-                u32 next = DxEPCTL_NextEp((epnum + 1) % 15);
+                u32 next = DXEPCTL_NEXTEP((epnum + 1) % 15);
                 writel(next, hsotg->regs + DIEPCTL(epnum));
                 writel(next, hsotg->regs + DOEPCTL(epnum));
         }
@@ -3250,10 +3070,10 @@ static void s3c_hsotg_dump(struct s3c_hsotg *hsotg)
         /* show periodic fifo settings */
 
         for (idx = 1; idx <= 15; idx++) {
-                val = readl(regs + DPTXFSIZn(idx));
+                val = readl(regs + DPTXFSIZN(idx));
                 dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx,
-                         val >> DPTXFSIZn_DPTxFSize_SHIFT,
-                         val & DPTXFSIZn_DPTxFStAddr_MASK);
+                         val >> FIFOSIZE_DEPTH_SHIFT,
+                         val & FIFOSIZE_STARTADDR_MASK);
         }
 
         for (idx = 0; idx < 15; idx++) {
@@ -3368,17 +3188,17 @@ static int fifo_show(struct seq_file *seq, void *v)
 
         val = readl(regs + GNPTXFSIZ);
         seq_printf(seq, "NPTXFIFO: Size %d, Start 0x%08x\n",
-                   val >> GNPTXFSIZ_NPTxFDep_SHIFT,
-                   val & GNPTXFSIZ_NPTxFStAddr_MASK);
+                   val >> FIFOSIZE_DEPTH_SHIFT,
+                   val & FIFOSIZE_DEPTH_MASK);
 
         seq_puts(seq, "\nPeriodic TXFIFOs:\n");
 
         for (idx = 1; idx <= 15; idx++) {
-                val = readl(regs + DPTXFSIZn(idx));
+                val = readl(regs + DPTXFSIZN(idx));
 
                 seq_printf(seq, "\tDPTXFIFO%2d: Size %d, Start 0x%08x\n", idx,
-                           val >> DPTXFSIZn_DPTxFSize_SHIFT,
-                           val & DPTXFSIZn_DPTxFStAddr_MASK);
+                           val >> FIFOSIZE_DEPTH_SHIFT,
+                           val & FIFOSIZE_STARTADDR_MASK);
         }
 
         return 0;
@@ -3662,14 +3482,14 @@ static int s3c_hsotg_probe(struct platform_device *pdev)
         }
 
         /* Set default UTMI width */
-        hsotg->phyif = GUSBCFG_PHYIf16;
+        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;
+                hsotg->phyif = GUSBCFG_PHYIF8;
 
         if (hsotg->phy)
                 phy_init(hsotg->phy);
diff --git a/drivers/usb/dwc2/hw.h b/drivers/usb/dwc2/hw.h
index 9c92a3c7588a..51248b935493 100644
--- a/drivers/usb/dwc2/hw.h
+++ b/drivers/usb/dwc2/hw.h
@@ -109,6 +109,7 @@
 #define GUSBCFG_FSINTF                  (1 << 5)
 #define GUSBCFG_ULPI_UTMI_SEL           (1 << 4)
 #define GUSBCFG_PHYIF16                 (1 << 3)
+#define GUSBCFG_PHYIF8                  (0 << 3)
 #define GUSBCFG_TOUTCAL_MASK            (0x7 << 0)
 #define GUSBCFG_TOUTCAL_SHIFT           0
 #define GUSBCFG_TOUTCAL_LIMIT           0x7
@@ -403,6 +404,7 @@
 #define FIFOSIZE_DEPTH_SHIFT            16
 #define FIFOSIZE_STARTADDR_MASK         (0xffff << 0)
 #define FIFOSIZE_STARTADDR_SHIFT        0
+#define FIFOSIZE_DEPTH_GET(_x)          (((_x) >> 16) & 0xffff)
 
 /* Device mode registers */
 
@@ -519,11 +521,11 @@
 #define DXEPCTL_STALL                   (1 << 21)
 #define DXEPCTL_SNP                     (1 << 20)
 #define DXEPCTL_EPTYPE_MASK             (0x3 << 18)
-#define DXEPCTL_EPTYPE_SHIFT            18
-#define DXEPCTL_EPTYPE_CONTROL          0
-#define DXEPCTL_EPTYPE_ISO              1
-#define DXEPCTL_EPTYPE_BULK             2
-#define DXEPCTL_EPTYPE_INTTERUPT        3
+#define DXEPCTL_EPTYPE_CONTROL          (0x0 << 18)
+#define DXEPCTL_EPTYPE_ISO              (0x1 << 18)
+#define DXEPCTL_EPTYPE_BULK             (0x2 << 18)
+#define DXEPCTL_EPTYPE_INTERRUPT        (0x3 << 18)
+
 #define DXEPCTL_NAKSTS                  (1 << 17)
 #define DXEPCTL_DPID                    (1 << 16)
 #define DXEPCTL_EOFRNUM                 (1 << 16)
diff --git a/drivers/usb/dwc2/platform.c b/drivers/usb/dwc2/platform.c
index eaba547ce26b..a10e7a353576 100644
--- a/drivers/usb/dwc2/platform.c
+++ b/drivers/usb/dwc2/platform.c
@@ -134,6 +134,12 @@ static int dwc2_driver_probe(struct platform_device *dev)
                 /* Default all params to autodetect */
                 dwc2_set_all_params(&defparams, -1);
                 params = &defparams;
+
+                /*
+                 * Disable descriptor dma mode by default as the HW can support
+                 * it, but does not support it for SPLIT transactions.
+                 */
+                defparams.dma_desc_enable = 0;
         }
 
         hsotg = devm_kzalloc(&dev->dev, sizeof(*hsotg), GFP_KERNEL);
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index e2c730fc9a90..8eb996e4f058 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -44,7 +44,7 @@ comment "Platform Glue Driver Support"
 
 config USB_DWC3_OMAP
         tristate "Texas Instruments OMAP5 and similar Platforms"
-        depends on EXTCON
+        depends on EXTCON && (ARCH_OMAP2PLUS || COMPILE_TEST)
         default USB_DWC3
         help
           Some platforms from Texas Instruments like OMAP5, DRA7xxx and
@@ -54,6 +54,7 @@ config USB_DWC3_OMAP
 
 config USB_DWC3_EXYNOS
         tristate "Samsung Exynos Platform"
+        depends on ARCH_EXYNOS || COMPILE_TEST
         default USB_DWC3
         help
           Recent Exynos5 SoCs ship with one DesignWare Core USB3 IP inside,
@@ -72,6 +73,7 @@ config USB_DWC3_PCI
 
 config USB_DWC3_KEYSTONE
         tristate "Texas Instruments Keystone2 Platforms"
+        depends on ARCH_KEYSTONE || COMPILE_TEST
         default USB_DWC3
         help
           Support of USB2/3 functionality in TI Keystone2 platforms.
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 10aaaae9af25..eb69eb9f06c8 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -486,70 +486,20 @@ static void dwc3_core_exit(struct dwc3 *dwc)
         phy_exit(dwc->usb3_generic_phy);
 }
 
-#define DWC3_ALIGN_MASK         (16 - 1)
-
-static int dwc3_probe(struct platform_device *pdev)
+static int dwc3_core_get_phy(struct dwc3 *dwc)
 {
-        struct device           *dev = &pdev->dev;
-        struct dwc3_platform_data *pdata = dev_get_platdata(dev);
+        struct device           *dev = dwc->dev;
         struct device_node      *node = dev->of_node;
-        struct resource         *res;
-        struct dwc3             *dwc;
-
-        int                     ret = -ENOMEM;
-
-        void __iomem            *regs;
-        void                    *mem;
-
-        mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
-        if (!mem) {
-                dev_err(dev, "not enough memory\n");
-                return -ENOMEM;
-        }
-        dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
-        dwc->mem = mem;
-
-        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
-        if (!res) {
-                dev_err(dev, "missing IRQ\n");
-                return -ENODEV;
-        }
-        dwc->xhci_resources[1].start = res->start;
-        dwc->xhci_resources[1].end = res->end;
-        dwc->xhci_resources[1].flags = res->flags;
-        dwc->xhci_resources[1].name = res->name;
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(dev, "missing memory resource\n");
-                return -ENODEV;
-        }
+        int ret;
 
         if (node) {
-                dwc->maximum_speed = of_usb_get_maximum_speed(node);
-
                 dwc->usb2_phy = devm_usb_get_phy_by_phandle(dev, "usb-phy", 0);
                 dwc->usb3_phy = devm_usb_get_phy_by_phandle(dev, "usb-phy", 1);
-
-                dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize");
-                dwc->dr_mode = of_usb_get_dr_mode(node);
-        } else if (pdata) {
-                dwc->maximum_speed = pdata->maximum_speed;
-
-                dwc->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
-                dwc->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
-
-                dwc->needs_fifo_resize = pdata->tx_fifo_resize;
-                dwc->dr_mode = pdata->dr_mode;
         } else {
                 dwc->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
                 dwc->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
         }
 
-        /* default to superspeed if no maximum_speed passed */
-        if (dwc->maximum_speed == USB_SPEED_UNKNOWN)
-                dwc->maximum_speed = USB_SPEED_SUPER;
-
         if (IS_ERR(dwc->usb2_phy)) {
                 ret = PTR_ERR(dwc->usb2_phy);
                 if (ret == -ENXIO || ret == -ENODEV) {
@@ -600,6 +550,132 @@ static int dwc3_probe(struct platform_device *pdev)
                 }
         }
 
+        return 0;
+}
+
+static int dwc3_core_init_mode(struct dwc3 *dwc)
+{
+        struct device *dev = dwc->dev;
+        int ret;
+
+        switch (dwc->dr_mode) {
+        case USB_DR_MODE_PERIPHERAL:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
+                ret = dwc3_gadget_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize gadget\n");
+                        return ret;
+                }
+                break;
+        case USB_DR_MODE_HOST:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
+                ret = dwc3_host_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize host\n");
+                        return ret;
+                }
+                break;
+        case USB_DR_MODE_OTG:
+                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
+                ret = dwc3_host_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize host\n");
+                        return ret;
+                }
+
+                ret = dwc3_gadget_init(dwc);
+                if (ret) {
+                        dev_err(dev, "failed to initialize gadget\n");
+                        return ret;
+                }
+                break;
+        default:
+                dev_err(dev, "Unsupported mode of operation %d\n", dwc->dr_mode);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static void dwc3_core_exit_mode(struct dwc3 *dwc)
+{
+        switch (dwc->dr_mode) {
+        case USB_DR_MODE_PERIPHERAL:
+                dwc3_gadget_exit(dwc);
+                break;
+        case USB_DR_MODE_HOST:
+                dwc3_host_exit(dwc);
+                break;
+        case USB_DR_MODE_OTG:
+                dwc3_host_exit(dwc);
+                dwc3_gadget_exit(dwc);
+                break;
+        default:
+                /* do nothing */
+                break;
+        }
+}
+
+#define DWC3_ALIGN_MASK         (16 - 1)
+
+static int dwc3_probe(struct platform_device *pdev)
+{
+        struct device           *dev = &pdev->dev;
+        struct dwc3_platform_data *pdata = dev_get_platdata(dev);
+        struct device_node      *node = dev->of_node;
+        struct resource         *res;
+        struct dwc3             *dwc;
+
+        int                     ret;
+
+        void __iomem            *regs;
+        void                    *mem;
+
+        mem = devm_kzalloc(dev, sizeof(*dwc) + DWC3_ALIGN_MASK, GFP_KERNEL);
+        if (!mem) {
+                dev_err(dev, "not enough memory\n");
+                return -ENOMEM;
+        }
+        dwc = PTR_ALIGN(mem, DWC3_ALIGN_MASK + 1);
+        dwc->mem = mem;
+        dwc->dev = dev;
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!res) {
+                dev_err(dev, "missing IRQ\n");
+                return -ENODEV;
+        }
+        dwc->xhci_resources[1].start = res->start;
+        dwc->xhci_resources[1].end = res->end;
+        dwc->xhci_resources[1].flags = res->flags;
+        dwc->xhci_resources[1].name = res->name;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "missing memory resource\n");
+                return -ENODEV;
+        }
+
+        if (node) {
+                dwc->maximum_speed = of_usb_get_maximum_speed(node);
+
+                dwc->needs_fifo_resize = of_property_read_bool(node, "tx-fifo-resize");
+                dwc->dr_mode = of_usb_get_dr_mode(node);
+        } else if (pdata) {
+                dwc->maximum_speed = pdata->maximum_speed;
+
+                dwc->needs_fifo_resize = pdata->tx_fifo_resize;
+                dwc->dr_mode = pdata->dr_mode;
+        }
+
+        /* default to superspeed if no maximum_speed passed */
+        if (dwc->maximum_speed == USB_SPEED_UNKNOWN)
+                dwc->maximum_speed = USB_SPEED_SUPER;
+
+        ret = dwc3_core_get_phy(dwc);
+        if (ret)
+                return ret;
+
         dwc->xhci_resources[0].start = res->start;
         dwc->xhci_resources[0].end = dwc->xhci_resources[0].start +
                                         DWC3_XHCI_REGS_END;
@@ -621,7 +697,6 @@ static int dwc3_probe(struct platform_device *pdev)
 
         dwc->regs       = regs;
         dwc->regs_size  = resource_size(res);
-        dwc->dev        = dev;
 
         dev->dma_mask   = dev->parent->dma_mask;
         dev->dma_parms  = dev->parent->dma_parms;
@@ -670,41 +745,9 @@ static int dwc3_probe(struct platform_device *pdev)
                 goto err_usb3phy_power;
         }
 
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_DEVICE);
-                ret = dwc3_gadget_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize gadget\n");
-                        goto err2;
-                }
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_HOST);
-                ret = dwc3_host_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize host\n");
-                        goto err2;
-                }
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_set_mode(dwc, DWC3_GCTL_PRTCAP_OTG);
-                ret = dwc3_host_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize host\n");
-                        goto err2;
-                }
-
-                ret = dwc3_gadget_init(dwc);
-                if (ret) {
-                        dev_err(dev, "failed to initialize gadget\n");
-                        goto err2;
-                }
-                break;
-        default:
-                dev_err(dev, "Unsupported mode of operation %d\n", dwc->dr_mode);
+        ret = dwc3_core_init_mode(dwc);
+        if (ret)
                 goto err2;
-        }
 
         ret = dwc3_debugfs_init(dwc);
         if (ret) {
@@ -717,21 +760,7 @@ static int dwc3_probe(struct platform_device *pdev)
         return 0;
 
 err3:
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_gadget_exit(dwc);
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_host_exit(dwc);
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_host_exit(dwc);
-                dwc3_gadget_exit(dwc);
-                break;
-        default:
-                /* do nothing */
-                break;
-        }
+        dwc3_core_exit_mode(dwc);
 
 err2:
         dwc3_event_buffers_cleanup(dwc);
@@ -766,23 +795,7 @@ static int dwc3_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
 
         dwc3_debugfs_exit(dwc);
-
-        switch (dwc->dr_mode) {
-        case USB_DR_MODE_PERIPHERAL:
-                dwc3_gadget_exit(dwc);
-                break;
-        case USB_DR_MODE_HOST:
-                dwc3_host_exit(dwc);
-                break;
-        case USB_DR_MODE_OTG:
-                dwc3_host_exit(dwc);
-                dwc3_gadget_exit(dwc);
-                break;
-        default:
-                /* do nothing */
-                break;
-        }
-
+        dwc3_core_exit_mode(dwc);
         dwc3_event_buffers_cleanup(dwc);
         dwc3_free_event_buffers(dwc);
         dwc3_core_exit(dwc);
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index 28c8ad79f5e6..f9fb8adb785b 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -24,9 +24,10 @@
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/regulator/consumer.h>
 
 struct dwc3_exynos {
         struct platform_device  *usb2_phy;
@@ -34,17 +35,19 @@ struct dwc3_exynos {
         struct device           *dev;
 
         struct clk              *clk;
+        struct regulator        *vdd33;
+        struct regulator        *vdd10;
 };
 
 static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
 {
-        struct usb_phy_gen_xceiv_platform_data pdata;
+        struct usb_phy_generic_platform_data pdata;
         struct platform_device  *pdev;
         int                     ret;
 
         memset(&pdata, 0x00, sizeof(pdata));
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", PLATFORM_DEVID_AUTO);
+        pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
         if (!pdev)
                 return -ENOMEM;
 
@@ -56,7 +59,7 @@ static int dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
         if (ret)
                 goto err1;
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", PLATFORM_DEVID_AUTO);
+        pdev = platform_device_alloc("usb_phy_generic", PLATFORM_DEVID_AUTO);
         if (!pdev) {
                 ret = -ENOMEM;
                 goto err1;
@@ -107,12 +110,12 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
         struct device           *dev = &pdev->dev;
         struct device_node      *node = dev->of_node;
 
-        int                     ret = -ENOMEM;
+        int                     ret;
 
         exynos = devm_kzalloc(dev, sizeof(*exynos), GFP_KERNEL);
         if (!exynos) {
                 dev_err(dev, "not enough memory\n");
-                goto err1;
+                return -ENOMEM;
         }
 
         /*
@@ -122,21 +125,20 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
          */
         ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
         if (ret)
-                goto err1;
+                return ret;
 
         platform_set_drvdata(pdev, exynos);
 
         ret = dwc3_exynos_register_phys(exynos);
         if (ret) {
                 dev_err(dev, "couldn't register PHYs\n");
-                goto err1;
+                return ret;
         }
 
         clk = devm_clk_get(dev, "usbdrd30");
         if (IS_ERR(clk)) {
                 dev_err(dev, "couldn't get clock\n");
-                ret = -EINVAL;
-                goto err1;
+                return -EINVAL;
         }
 
         exynos->dev     = dev;
@@ -144,23 +146,48 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
 
         clk_prepare_enable(exynos->clk);
 
+        exynos->vdd33 = devm_regulator_get(dev, "vdd33");
+        if (IS_ERR(exynos->vdd33)) {
+                ret = PTR_ERR(exynos->vdd33);
+                goto err2;
+        }
+        ret = regulator_enable(exynos->vdd33);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD33 supply\n");
+                goto err2;
+        }
+
+        exynos->vdd10 = devm_regulator_get(dev, "vdd10");
+        if (IS_ERR(exynos->vdd10)) {
+                ret = PTR_ERR(exynos->vdd10);
+                goto err3;
+        }
+        ret = regulator_enable(exynos->vdd10);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD10 supply\n");
+                goto err3;
+        }
+
         if (node) {
                 ret = of_platform_populate(node, NULL, NULL, dev);
                 if (ret) {
                         dev_err(dev, "failed to add dwc3 core\n");
-                        goto err2;
+                        goto err4;
                 }
         } else {
                 dev_err(dev, "no device node, failed to add dwc3 core\n");
                 ret = -ENODEV;
-                goto err2;
+                goto err4;
         }
 
         return 0;
 
+err4:
+        regulator_disable(exynos->vdd10);
+err3:
+        regulator_disable(exynos->vdd33);
 err2:
         clk_disable_unprepare(clk);
-err1:
         return ret;
 }
 
@@ -174,6 +201,9 @@ static int dwc3_exynos_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(exynos->clk);
 
+        regulator_disable(exynos->vdd33);
+        regulator_disable(exynos->vdd10);
+
         return 0;
 }
 
@@ -192,12 +222,27 @@ static int dwc3_exynos_suspend(struct device *dev)
 
         clk_disable(exynos->clk);
 
+        regulator_disable(exynos->vdd33);
+        regulator_disable(exynos->vdd10);
+
         return 0;
 }
 
 static int dwc3_exynos_resume(struct device *dev)
 {
         struct dwc3_exynos *exynos = dev_get_drvdata(dev);
+        int ret;
+
+        ret = regulator_enable(exynos->vdd33);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD33 supply\n");
+                return ret;
+        }
+        ret = regulator_enable(exynos->vdd10);
+        if (ret) {
+                dev_err(dev, "Failed to enable VDD10 supply\n");
+                return ret;
+        }
 
         clk_enable(exynos->clk);
 
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 1160ff41bed4..4af4c3567656 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -393,7 +393,7 @@ static int dwc3_omap_probe(struct platform_device *pdev)
         struct extcon_dev       *edev;
         struct regulator        *vbus_reg = NULL;
 
-        int                     ret = -ENOMEM;
+        int                     ret;
         int                     irq;
 
         int                     utmi_mode = 0;
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index f393c183cc69..a60bab7dfa0a 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -23,7 +23,7 @@
 #include <linux/platform_device.h>
 
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 /* FIXME define these in <linux/pci_ids.h> */
 #define PCI_VENDOR_ID_SYNOPSYS          0x16c3
@@ -40,13 +40,13 @@ struct dwc3_pci {
 
 static int dwc3_pci_register_phys(struct dwc3_pci *glue)
 {
-        struct usb_phy_gen_xceiv_platform_data pdata;
+        struct usb_phy_generic_platform_data pdata;
         struct platform_device  *pdev;
         int                     ret;
 
         memset(&pdata, 0x00, sizeof(pdata));
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", 0);
+        pdev = platform_device_alloc("usb_phy_generic", 0);
         if (!pdev)
                 return -ENOMEM;
 
@@ -58,7 +58,7 @@ static int dwc3_pci_register_phys(struct dwc3_pci *glue)
         if (ret)
                 goto err1;
 
-        pdev = platform_device_alloc("usb_phy_gen_xceiv", 1);
+        pdev = platform_device_alloc("usb_phy_generic", 1);
         if (!pdev) {
                 ret = -ENOMEM;
                 goto err1;
@@ -99,7 +99,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         struct resource         res[2];
         struct platform_device  *dwc3;
         struct dwc3_pci         *glue;
-        int                     ret = -ENOMEM;
+        int                     ret;
         struct device           *dev = &pci->dev;
 
         glue = devm_kzalloc(dev, sizeof(*glue), GFP_KERNEL);
@@ -110,7 +110,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
 
         glue->dev = dev;
 
-        ret = pci_enable_device(pci);
+        ret = pcim_enable_device(pci);
         if (ret) {
                 dev_err(dev, "failed to enable pci device\n");
                 return -ENODEV;
@@ -127,8 +127,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         dwc3 = platform_device_alloc("dwc3", PLATFORM_DEVID_AUTO);
         if (!dwc3) {
                 dev_err(dev, "couldn't allocate dwc3 device\n");
-                ret = -ENOMEM;
-                goto err1;
+                return -ENOMEM;
         }
 
         memset(res, 0x00, sizeof(struct resource) * ARRAY_SIZE(res));
@@ -145,7 +144,7 @@ static int dwc3_pci_probe(struct pci_dev *pci,
         ret = platform_device_add_resources(dwc3, res, ARRAY_SIZE(res));
         if (ret) {
                 dev_err(dev, "couldn't add resources to dwc3 device\n");
-                goto err1;
+                return ret;
         }
 
         pci_set_drvdata(pci, glue);
@@ -167,9 +166,6 @@ static int dwc3_pci_probe(struct pci_dev *pci,
 
 err3:
         platform_device_put(dwc3);
-err1:
-        pci_disable_device(pci);
-
         return ret;
 }
 
@@ -180,7 +176,6 @@ static void dwc3_pci_remove(struct pci_dev *pci)
         platform_device_unregister(glue->dwc3);
         platform_device_unregister(glue->usb2_phy);
         platform_device_unregister(glue->usb3_phy);
-        pci_disable_device(pci);
 }
 
 static const struct pci_device_id dwc3_pci_id_table[] = {
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 70715eeededd..9d64dd02c57e 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -298,11 +298,76 @@ static const char *dwc3_gadget_ep_cmd_string(u8 cmd)
         }
 }
 
+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)
 {
         u32             timeout = 500;
         u32             reg;
 
+        dev_vdbg(dwc->dev, "generic cmd '%s' [%d] param %08x\n",
+                        dwc3_gadget_generic_cmd_string(cmd), cmd, param);
+
         dwc3_writel(dwc->regs, DWC3_DGCMDPAR, param);
         dwc3_writel(dwc->regs, DWC3_DGCMD, cmd | DWC3_DGCMD_CMDACT);
 
@@ -332,9 +397,9 @@ int dwc3_send_gadget_ep_cmd(struct dwc3 *dwc, unsigned ep,
         u32                     timeout = 500;
         u32                     reg;
 
-        dev_vdbg(dwc->dev, "%s: cmd '%s' params %08x %08x %08x\n",
+        dev_vdbg(dwc->dev, "%s: cmd '%s' [%d] params %08x %08x %08x\n",
                         dep->name,
-                        dwc3_gadget_ep_cmd_string(cmd), params->param0,
+                        dwc3_gadget_ep_cmd_string(cmd), cmd, params->param0,
                         params->param1, params->param2);
 
         dwc3_writel(dwc->regs, DWC3_DEPCMDPAR0(ep), params->param0);
@@ -515,7 +580,7 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
 {
         struct dwc3             *dwc = dep->dwc;
         u32                     reg;
-        int                     ret = -ENOMEM;
+        int                     ret;
 
         dev_vdbg(dwc->dev, "Enabling %s\n", dep->name);
 
@@ -604,6 +669,10 @@ static int __dwc3_gadget_ep_disable(struct dwc3_ep *dep)
 
         dwc3_remove_requests(dwc, dep);
 
+        /* make sure HW endpoint isn't stalled */
+        if (dep->flags & DWC3_EP_STALL)
+                __dwc3_gadget_ep_set_halt(dep, 0);
+
         reg = dwc3_readl(dwc->regs, DWC3_DALEPENA);
         reg &= ~DWC3_DALEPENA_EP(dep->number);
         dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
@@ -2441,8 +2510,6 @@ static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
                 }
         }
 
-        dwc->link_state = next;
-
         switch (next) {
         case DWC3_LINK_STATE_U1:
                 if (dwc->speed == USB_SPEED_SUPER)
@@ -2460,7 +2527,11 @@ static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
                 break;
         }
 
-        dev_vdbg(dwc->dev, "%s link %d\n", __func__, dwc->link_state);
+        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;
 }
 
 static void dwc3_gadget_hibernation_interrupt(struct dwc3 *dwc,
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 3557c7e5040d..ba18e9c110cc 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -157,7 +157,7 @@ config USB_AT91
 
 config USB_LPC32XX
         tristate "LPC32XX USB Peripheral Controller"
-        depends on ARCH_LPC32XX
+        depends on ARCH_LPC32XX && I2C
         select USB_ISP1301
         help
            This option selects the USB device controller in the LPC32xx SoC.
@@ -226,7 +226,7 @@ config USB_GR_UDC
 config USB_OMAP
         tristate "OMAP USB Device Controller"
         depends on ARCH_OMAP1
-        select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
+        depends on ISP1301_OMAP || !(MACH_OMAP_H2 || MACH_OMAP_H3)
         help
            Many Texas Instruments OMAP processors have flexible full
            speed USB device controllers, with support for up to 30
@@ -300,12 +300,6 @@ config USB_PXA27X
            dynamically linked module called "pxa27x_udc" and force all
            gadget drivers to also be dynamically linked.
 
-config USB_S3C_HSOTG
-        tristate "Designware/S3C HS/OtG USB Device controller"
-        help
-          The Designware USB2.0 high-speed gadget controller
-          integrated into many SoCs.
-
 config USB_S3C2410
         tristate "S3C2410 USB Device Controller"
         depends on ARCH_S3C24XX
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 5f150bc1b4bc..49514ea60a98 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -26,7 +26,6 @@ fsl_usb2_udc-$(CONFIG_ARCH_MXC)	+= fsl_mxc_udc.o
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
 obj-$(CONFIG_USB_R8A66597)      += r8a66597-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
-obj-$(CONFIG_USB_S3C_HSOTG)     += s3c-hsotg.o
 obj-$(CONFIG_USB_S3C_HSUDC)     += s3c-hsudc.o
 obj-$(CONFIG_USB_LPC32XX)       += lpc32xx_udc.o
 obj-$(CONFIG_USB_EG20T)         += pch_udc.o
diff --git a/drivers/usb/gadget/atmel_usba_udc.c b/drivers/usb/gadget/atmel_usba_udc.c
index 9f65324f9ae0..76023ce449a3 100644
--- a/drivers/usb/gadget/atmel_usba_udc.c
+++ b/drivers/usb/gadget/atmel_usba_udc.c
@@ -1686,7 +1686,7 @@ static irqreturn_t usba_udc_irq(int irq, void *devid)
                 reset_all_endpoints(udc);
 
                 if (udc->gadget.speed != USB_SPEED_UNKNOWN
-                                && udc->driver->disconnect) {
+                                && udc->driver && udc->driver->disconnect) {
                         udc->gadget.speed = USB_SPEED_UNKNOWN;
                         spin_unlock(&udc->lock);
                         udc->driver->disconnect(&udc->gadget);
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index fab906429b80..f80151932053 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -21,6 +21,24 @@
 #include <linux/usb/composite.h>
 #include <asm/unaligned.h>
 
+#include "u_os_desc.h"
+
+/**
+ * struct usb_os_string - represents OS String to be reported by a gadget
+ * @bLength: total length of the entire descritor, always 0x12
+ * @bDescriptorType: USB_DT_STRING
+ * @qwSignature: the OS String proper
+ * @bMS_VendorCode: code used by the host for subsequent requests
+ * @bPad: not used, must be zero
+ */
+struct usb_os_string {
+        __u8    bLength;
+        __u8    bDescriptorType;
+        __u8    qwSignature[OS_STRING_QW_SIGN_LEN];
+        __u8    bMS_VendorCode;
+        __u8    bPad;
+} __packed;
+
 /*
  * The code in this file is utility code, used to build a gadget driver
  * from one or more "function" drivers, one or more "configuration"
@@ -422,6 +440,7 @@ static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 {
         struct usb_gadget               *gadget = cdev->gadget;
         struct usb_configuration        *c;
+        struct list_head                *pos;
         u8                              type = w_value >> 8;
         enum usb_device_speed           speed = USB_SPEED_UNKNOWN;
 
@@ -440,7 +459,20 @@ static int config_desc(struct usb_composite_dev *cdev, unsigned w_value)
 
         /* This is a lookup by config *INDEX* */
         w_value &= 0xff;
-        list_for_each_entry(c, &cdev->configs, list) {
+
+        pos = &cdev->configs;
+        c = cdev->os_desc_config;
+        if (c)
+                goto check_config;
+
+        while ((pos = pos->next) !=  &cdev->configs) {
+                c = list_entry(pos, typeof(*c), list);
+
+                /* skip OS Descriptors config which is handled separately */
+                if (c == cdev->os_desc_config)
+                        continue;
+
+check_config:
                 /* ignore configs that won't work at this speed */
                 switch (speed) {
                 case USB_SPEED_SUPER:
@@ -634,6 +666,7 @@ static int set_config(struct usb_composite_dev *cdev,
         if (!c)
                 goto done;
 
+        usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
         cdev->config = c;
 
         /* Initialize all interfaces by setting them to altsetting zero. */
@@ -960,6 +993,19 @@ static int get_string(struct usb_composite_dev *cdev,
                 return s->bLength;
         }
 
+        if (cdev->use_os_string && language == 0 && id == OS_STRING_IDX) {
+                struct usb_os_string *b = buf;
+                b->bLength = sizeof(*b);
+                b->bDescriptorType = USB_DT_STRING;
+                compiletime_assert(
+                        sizeof(b->qwSignature) == sizeof(cdev->qw_sign),
+                        "qwSignature size must be equal to qw_sign");
+                memcpy(&b->qwSignature, cdev->qw_sign, sizeof(b->qwSignature));
+                b->bMS_VendorCode = cdev->b_vendor_code;
+                b->bPad = 0;
+                return sizeof(*b);
+        }
+
         list_for_each_entry(uc, &cdev->gstrings, list) {
                 struct usb_gadget_strings **sp;
 
@@ -1206,6 +1252,156 @@ static void composite_setup_complete(struct usb_ep *ep, struct usb_request *req)
                                 req->status, req->actual, req->length);
 }
 
+static int count_ext_compat(struct usb_configuration *c)
+{
+        int i, res;
+
+        res = 0;
+        for (i = 0; i < c->next_interface_id; ++i) {
+                struct usb_function *f;
+                int j;
+
+                f = c->interface[i];
+                for (j = 0; j < f->os_desc_n; ++j) {
+                        struct usb_os_desc *d;
+
+                        if (i != f->os_desc_table[j].if_id)
+                                continue;
+                        d = f->os_desc_table[j].os_desc;
+                        if (d && d->ext_compat_id)
+                                ++res;
+                }
+        }
+        BUG_ON(res > 255);
+        return res;
+}
+
+static void fill_ext_compat(struct usb_configuration *c, u8 *buf)
+{
+        int i, count;
+
+        count = 16;
+        for (i = 0; i < c->next_interface_id; ++i) {
+                struct usb_function *f;
+                int j;
+
+                f = c->interface[i];
+                for (j = 0; j < f->os_desc_n; ++j) {
+                        struct usb_os_desc *d;
+
+                        if (i != f->os_desc_table[j].if_id)
+                                continue;
+                        d = f->os_desc_table[j].os_desc;
+                        if (d && d->ext_compat_id) {
+                                *buf++ = i;
+                                *buf++ = 0x01;
+                                memcpy(buf, d->ext_compat_id, 16);
+                                buf += 22;
+                        } else {
+                                ++buf;
+                                *buf = 0x01;
+                                buf += 23;
+                        }
+                        count += 24;
+                        if (count >= 4096)
+                                return;
+                }
+        }
+}
+
+static int count_ext_prop(struct usb_configuration *c, int interface)
+{
+        struct usb_function *f;
+        int j;
+
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                struct usb_os_desc *d;
+
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d && d->ext_compat_id)
+                        return d->ext_prop_count;
+        }
+        return 0;
+}
+
+static int len_ext_prop(struct usb_configuration *c, int interface)
+{
+        struct usb_function *f;
+        struct usb_os_desc *d;
+        int j, res;
+
+        res = 10; /* header length */
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d)
+                        return min(res + d->ext_prop_len, 4096);
+        }
+        return res;
+}
+
+static int fill_ext_prop(struct usb_configuration *c, int interface, u8 *buf)
+{
+        struct usb_function *f;
+        struct usb_os_desc *d;
+        struct usb_os_desc_ext_prop *ext_prop;
+        int j, count, n, ret;
+        u8 *start = buf;
+
+        f = c->interface[interface];
+        for (j = 0; j < f->os_desc_n; ++j) {
+                if (interface != f->os_desc_table[j].if_id)
+                        continue;
+                d = f->os_desc_table[j].os_desc;
+                if (d)
+                        list_for_each_entry(ext_prop, &d->ext_prop, entry) {
+                                /* 4kB minus header length */
+                                n = buf - start;
+                                if (n >= 4086)
+                                        return 0;
+
+                                count = ext_prop->data_len +
+                                        ext_prop->name_len + 14;
+                                if (count > 4086 - n)
+                                        return -EINVAL;
+                                usb_ext_prop_put_size(buf, count);
+                                usb_ext_prop_put_type(buf, ext_prop->type);
+                                ret = usb_ext_prop_put_name(buf, ext_prop->name,
+                                                            ext_prop->name_len);
+                                if (ret < 0)
+                                        return ret;
+                                switch (ext_prop->type) {
+                                case USB_EXT_PROP_UNICODE:
+                                case USB_EXT_PROP_UNICODE_ENV:
+                                case USB_EXT_PROP_UNICODE_LINK:
+                                        usb_ext_prop_put_unicode(buf, ret,
+                                                         ext_prop->data,
+                                                         ext_prop->data_len);
+                                        break;
+                                case USB_EXT_PROP_BINARY:
+                                        usb_ext_prop_put_binary(buf, ret,
+                                                        ext_prop->data,
+                                                        ext_prop->data_len);
+                                        break;
+                                case USB_EXT_PROP_LE32:
+                                        /* not implemented */
+                                case USB_EXT_PROP_BE32:
+                                        /* not implemented */
+                                default:
+                                        return -EINVAL;
+                                }
+                                buf += count;
+                        }
+        }
+
+        return 0;
+}
+
 /*
  * The setup() callback implements all the ep0 functionality that's
  * not handled lower down, in hardware or the hardware driver(like
@@ -1415,6 +1611,91 @@ composite_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 break;
         default:
 unknown:
+                /*
+                 * OS descriptors handling
+                 */
+                if (cdev->use_os_string && cdev->os_desc_config &&
+                    (ctrl->bRequest & USB_TYPE_VENDOR) &&
+                    ctrl->bRequest == cdev->b_vendor_code) {
+                        struct usb_request              *req;
+                        struct usb_configuration        *os_desc_cfg;
+                        u8                              *buf;
+                        int                             interface;
+                        int                             count = 0;
+
+                        req = cdev->os_desc_req;
+                        req->complete = composite_setup_complete;
+                        buf = req->buf;
+                        os_desc_cfg = cdev->os_desc_config;
+                        memset(buf, 0, w_length);
+                        buf[5] = 0x01;
+                        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+                        case USB_RECIP_DEVICE:
+                                if (w_index != 0x4 || (w_value >> 8))
+                                        break;
+                                buf[6] = w_index;
+                                if (w_length == 0x10) {
+                                        /* Number of ext compat interfaces */
+                                        count = count_ext_compat(os_desc_cfg);
+                                        buf[8] = count;
+                                        count *= 24; /* 24 B/ext compat desc */
+                                        count += 16; /* header */
+                                        put_unaligned_le32(count, buf);
+                                        value = w_length;
+                                } else {
+                                        /* "extended compatibility ID"s */
+                                        count = count_ext_compat(os_desc_cfg);
+                                        buf[8] = count;
+                                        count *= 24; /* 24 B/ext compat desc */
+                                        count += 16; /* header */
+                                        put_unaligned_le32(count, buf);
+                                        buf += 16;
+                                        fill_ext_compat(os_desc_cfg, buf);
+                                        value = w_length;
+                                }
+                                break;
+                        case USB_RECIP_INTERFACE:
+                                if (w_index != 0x5 || (w_value >> 8))
+                                        break;
+                                interface = w_value & 0xFF;
+                                buf[6] = w_index;
+                                if (w_length == 0x0A) {
+                                        count = count_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le16(count, buf + 8);
+                                        count = len_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le32(count, buf);
+
+                                        value = w_length;
+                                } else {
+                                        count = count_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le16(count, buf + 8);
+                                        count = len_ext_prop(os_desc_cfg,
+                                                interface);
+                                        put_unaligned_le32(count, buf);
+                                        buf += 10;
+                                        value = fill_ext_prop(os_desc_cfg,
+                                                              interface, buf);
+                                        if (value < 0)
+                                                return value;
+
+                                        value = w_length;
+                                }
+                                break;
+                        }
+                        req->length = value;
+                        req->zero = value < w_length;
+                        value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
+                        if (value < 0) {
+                                DBG(cdev, "ep_queue --> %d\n", value);
+                                req->status = 0;
+                                composite_setup_complete(gadget->ep0, req);
+                        }
+                        return value;
+                }
+
                 VDBG(cdev,
                         "non-core control req%02x.%02x v%04x i%04x l%d\n",
                         ctrl->bRequestType, ctrl->bRequest,
@@ -1638,6 +1919,29 @@ fail:
         return ret;
 }
 
+int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
+                                  struct usb_ep *ep0)
+{
+        int ret = 0;
+
+        cdev->os_desc_req = usb_ep_alloc_request(ep0, GFP_KERNEL);
+        if (!cdev->os_desc_req) {
+                ret = PTR_ERR(cdev->os_desc_req);
+                goto end;
+        }
+
+        /* OS feature descriptor length <= 4kB */
+        cdev->os_desc_req->buf = kmalloc(4096, GFP_KERNEL);
+        if (!cdev->os_desc_req->buf) {
+                ret = PTR_ERR(cdev->os_desc_req->buf);
+                kfree(cdev->os_desc_req);
+                goto end;
+        }
+        cdev->os_desc_req->complete = composite_setup_complete;
+end:
+        return ret;
+}
+
 void composite_dev_cleanup(struct usb_composite_dev *cdev)
 {
         struct usb_gadget_string_container *uc, *tmp;
@@ -1646,6 +1950,10 @@ void composite_dev_cleanup(struct usb_composite_dev *cdev)
                 list_del(&uc->list);
                 kfree(uc);
         }
+        if (cdev->os_desc_req) {
+                kfree(cdev->os_desc_req->buf);
+                usb_ep_free_request(cdev->gadget->ep0, cdev->os_desc_req);
+        }
         if (cdev->req) {
                 kfree(cdev->req->buf);
                 usb_ep_free_request(cdev->gadget->ep0, cdev->req);
@@ -1683,6 +1991,12 @@ static int composite_bind(struct usb_gadget *gadget,
         if (status < 0)
                 goto fail;
 
+        if (cdev->use_os_string) {
+                status = composite_os_desc_req_prepare(cdev, gadget->ep0);
+                if (status)
+                        goto fail;
+        }
+
         update_unchanged_dev_desc(&cdev->desc, composite->dev);
 
         /* has userspace failed to provide a serial number? */
diff --git a/drivers/usb/gadget/configfs.c b/drivers/usb/gadget/configfs.c
index 7d1cc01796b6..2ddcd635ca2a 100644
--- a/drivers/usb/gadget/configfs.c
+++ b/drivers/usb/gadget/configfs.c
@@ -2,9 +2,12 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/device.h>
+#include <linux/nls.h>
 #include <linux/usb/composite.h>
 #include <linux/usb/gadget_configfs.h>
 #include "configfs.h"
+#include "u_f.h"
+#include "u_os_desc.h"
 
 int check_user_usb_string(const char *name,
                 struct usb_gadget_strings *stringtab_dev)
@@ -43,7 +46,8 @@ struct gadget_info {
         struct config_group functions_group;
         struct config_group configs_group;
         struct config_group strings_group;
-        struct config_group *default_groups[4];
+        struct config_group os_desc_group;
+        struct config_group *default_groups[5];
 
         struct mutex lock;
         struct usb_gadget_strings *gstrings[MAX_USB_STRING_LANGS + 1];
@@ -56,6 +60,9 @@ struct gadget_info {
 #endif
         struct usb_composite_driver composite;
         struct usb_composite_dev cdev;
+        bool use_os_desc;
+        char b_vendor_code;
+        char qw_sign[OS_STRING_QW_SIGN_LEN];
 };
 
 struct config_usb_cfg {
@@ -79,6 +86,10 @@ struct gadget_strings {
         struct list_head list;
 };
 
+struct os_desc {
+        struct config_group group;
+};
+
 struct gadget_config_name {
         struct usb_gadget_strings stringtab_dev;
         struct usb_string strings;
@@ -736,6 +747,525 @@ static void gadget_strings_attr_release(struct config_item *item)
 USB_CONFIG_STRING_RW_OPS(gadget_strings);
 USB_CONFIG_STRINGS_LANG(gadget_strings, gadget_info);
 
+static inline struct os_desc *to_os_desc(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct os_desc, group);
+}
+
+CONFIGFS_ATTR_STRUCT(os_desc);
+CONFIGFS_ATTR_OPS(os_desc);
+
+static ssize_t os_desc_use_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        return sprintf(page, "%d", gi->use_os_desc);
+}
+
+static ssize_t os_desc_use_store(struct os_desc *os_desc, const char *page,
+                                 size_t len)
+{
+        struct gadget_info *gi;
+        int ret;
+        bool use;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        mutex_lock(&gi->lock);
+        ret = strtobool(page, &use);
+        if (!ret) {
+                gi->use_os_desc = use;
+                ret = len;
+        }
+        mutex_unlock(&gi->lock);
+
+        return ret;
+}
+
+static struct os_desc_attribute os_desc_use =
+        __CONFIGFS_ATTR(use, S_IRUGO | S_IWUSR,
+                        os_desc_use_show,
+                        os_desc_use_store);
+
+static ssize_t os_desc_b_vendor_code_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        return sprintf(page, "%d", gi->b_vendor_code);
+}
+
+static ssize_t os_desc_b_vendor_code_store(struct os_desc *os_desc,
+                                           const char *page, size_t len)
+{
+        struct gadget_info *gi;
+        int ret;
+        u8 b_vendor_code;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        mutex_lock(&gi->lock);
+        ret = kstrtou8(page, 0, &b_vendor_code);
+        if (!ret) {
+                gi->b_vendor_code = b_vendor_code;
+                ret = len;
+        }
+        mutex_unlock(&gi->lock);
+
+        return ret;
+}
+
+static struct os_desc_attribute os_desc_b_vendor_code =
+        __CONFIGFS_ATTR(b_vendor_code, S_IRUGO | S_IWUSR,
+                        os_desc_b_vendor_code_show,
+                        os_desc_b_vendor_code_store);
+
+static ssize_t os_desc_qw_sign_show(struct os_desc *os_desc, char *page)
+{
+        struct gadget_info *gi;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+
+        memcpy(page, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
+
+        return OS_STRING_QW_SIGN_LEN;
+}
+
+static ssize_t os_desc_qw_sign_store(struct os_desc *os_desc, const char *page,
+                                     size_t len)
+{
+        struct gadget_info *gi;
+        int res, l;
+
+        gi = to_gadget_info(os_desc->group.cg_item.ci_parent);
+        l = min((int)len, OS_STRING_QW_SIGN_LEN >> 1);
+        if (page[l - 1] == '\n')
+                --l;
+
+        mutex_lock(&gi->lock);
+        res = utf8s_to_utf16s(page, l,
+                              UTF16_LITTLE_ENDIAN, (wchar_t *) gi->qw_sign,
+                              OS_STRING_QW_SIGN_LEN);
+        if (res > 0)
+                res = len;
+        mutex_unlock(&gi->lock);
+
+        return res;
+}
+
+static struct os_desc_attribute os_desc_qw_sign =
+        __CONFIGFS_ATTR(qw_sign, S_IRUGO | S_IWUSR,
+                        os_desc_qw_sign_show,
+                        os_desc_qw_sign_store);
+
+static struct configfs_attribute *os_desc_attrs[] = {
+        &os_desc_use.attr,
+        &os_desc_b_vendor_code.attr,
+        &os_desc_qw_sign.attr,
+        NULL,
+};
+
+static void os_desc_attr_release(struct config_item *item)
+{
+        struct os_desc *os_desc = to_os_desc(item);
+        kfree(os_desc);
+}
+
+static int os_desc_link(struct config_item *os_desc_ci,
+                        struct config_item *usb_cfg_ci)
+{
+        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
+                                        struct gadget_info, os_desc_group);
+        struct usb_composite_dev *cdev = &gi->cdev;
+        struct config_usb_cfg *c_target =
+                container_of(to_config_group(usb_cfg_ci),
+                             struct config_usb_cfg, group);
+        struct usb_configuration *c;
+        int ret;
+
+        mutex_lock(&gi->lock);
+        list_for_each_entry(c, &cdev->configs, list) {
+                if (c == &c_target->c)
+                        break;
+        }
+        if (c != &c_target->c) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (cdev->os_desc_config) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        cdev->os_desc_config = &c_target->c;
+        ret = 0;
+
+out:
+        mutex_unlock(&gi->lock);
+        return ret;
+}
+
+static int os_desc_unlink(struct config_item *os_desc_ci,
+                          struct config_item *usb_cfg_ci)
+{
+        struct gadget_info *gi = container_of(to_config_group(os_desc_ci),
+                                        struct gadget_info, os_desc_group);
+        struct usb_composite_dev *cdev = &gi->cdev;
+
+        mutex_lock(&gi->lock);
+        if (gi->udc_name)
+                unregister_gadget(gi);
+        cdev->os_desc_config = NULL;
+        WARN_ON(gi->udc_name);
+        mutex_unlock(&gi->lock);
+        return 0;
+}
+
+static struct configfs_item_operations os_desc_ops = {
+        .release                = os_desc_attr_release,
+        .show_attribute         = os_desc_attr_show,
+        .store_attribute        = os_desc_attr_store,
+        .allow_link             = os_desc_link,
+        .drop_link              = os_desc_unlink,
+};
+
+static struct config_item_type os_desc_type = {
+        .ct_item_ops    = &os_desc_ops,
+        .ct_attrs       = os_desc_attrs,
+        .ct_owner       = THIS_MODULE,
+};
+
+CONFIGFS_ATTR_STRUCT(usb_os_desc);
+CONFIGFS_ATTR_OPS(usb_os_desc);
+
+
+static inline struct usb_os_desc_ext_prop
+*to_usb_os_desc_ext_prop(struct config_item *item)
+{
+        return container_of(item, struct usb_os_desc_ext_prop, item);
+}
+
+CONFIGFS_ATTR_STRUCT(usb_os_desc_ext_prop);
+CONFIGFS_ATTR_OPS(usb_os_desc_ext_prop);
+
+static ssize_t ext_prop_type_show(struct usb_os_desc_ext_prop *ext_prop,
+                                  char *page)
+{
+        return sprintf(page, "%d", ext_prop->type);
+}
+
+static ssize_t ext_prop_type_store(struct usb_os_desc_ext_prop *ext_prop,
+                                   const char *page, size_t len)
+{
+        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
+        u8 type;
+        int ret;
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        ret = kstrtou8(page, 0, &type);
+        if (ret)
+                goto end;
+        if (type < USB_EXT_PROP_UNICODE || type > USB_EXT_PROP_UNICODE_MULTI) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        if ((ext_prop->type == USB_EXT_PROP_BINARY ||
+            ext_prop->type == USB_EXT_PROP_LE32 ||
+            ext_prop->type == USB_EXT_PROP_BE32) &&
+            (type == USB_EXT_PROP_UNICODE ||
+            type == USB_EXT_PROP_UNICODE_ENV ||
+            type == USB_EXT_PROP_UNICODE_LINK))
+                ext_prop->data_len <<= 1;
+        else if ((ext_prop->type == USB_EXT_PROP_UNICODE ||
+                   ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+                   ext_prop->type == USB_EXT_PROP_UNICODE_LINK) &&
+                   (type == USB_EXT_PROP_BINARY ||
+                   type == USB_EXT_PROP_LE32 ||
+                   type == USB_EXT_PROP_BE32))
+                ext_prop->data_len >>= 1;
+        ext_prop->type = type;
+        ret = len;
+
+end:
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        return ret;
+}
+
+static ssize_t ext_prop_data_show(struct usb_os_desc_ext_prop *ext_prop,
+                                  char *page)
+{
+        int len = ext_prop->data_len;
+
+        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_LINK)
+                len >>= 1;
+        memcpy(page, ext_prop->data, len);
+
+        return len;
+}
+
+static ssize_t ext_prop_data_store(struct usb_os_desc_ext_prop *ext_prop,
+                                   const char *page, size_t len)
+{
+        struct usb_os_desc *desc = to_usb_os_desc(ext_prop->item.ci_parent);
+        char *new_data;
+        size_t ret_len = len;
+
+        if (page[len - 1] == '\n' || page[len - 1] == '\0')
+                --len;
+        new_data = kzalloc(len, GFP_KERNEL);
+        if (!new_data)
+                return -ENOMEM;
+
+        memcpy(new_data, page, len);
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        kfree(ext_prop->data);
+        ext_prop->data = new_data;
+        desc->ext_prop_len -= ext_prop->data_len;
+        ext_prop->data_len = len;
+        desc->ext_prop_len += ext_prop->data_len;
+        if (ext_prop->type == USB_EXT_PROP_UNICODE ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_ENV ||
+            ext_prop->type == USB_EXT_PROP_UNICODE_LINK) {
+                desc->ext_prop_len -= ext_prop->data_len;
+                ext_prop->data_len <<= 1;
+                ext_prop->data_len += 2;
+                desc->ext_prop_len += ext_prop->data_len;
+        }
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        return ret_len;
+}
+
+static struct usb_os_desc_ext_prop_attribute ext_prop_type =
+        __CONFIGFS_ATTR(type, S_IRUGO | S_IWUSR,
+                        ext_prop_type_show, ext_prop_type_store);
+
+static struct usb_os_desc_ext_prop_attribute ext_prop_data =
+        __CONFIGFS_ATTR(data, S_IRUGO | S_IWUSR,
+                        ext_prop_data_show, ext_prop_data_store);
+
+static struct configfs_attribute *ext_prop_attrs[] = {
+        &ext_prop_type.attr,
+        &ext_prop_data.attr,
+        NULL,
+};
+
+static void usb_os_desc_ext_prop_release(struct config_item *item)
+{
+        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
+
+        kfree(ext_prop); /* frees a whole chunk */
+}
+
+static struct configfs_item_operations ext_prop_ops = {
+        .release                = usb_os_desc_ext_prop_release,
+        .show_attribute         = usb_os_desc_ext_prop_attr_show,
+        .store_attribute        = usb_os_desc_ext_prop_attr_store,
+};
+
+static struct config_item *ext_prop_make(
+                struct config_group *group,
+                const char *name)
+{
+        struct usb_os_desc_ext_prop *ext_prop;
+        struct config_item_type *ext_prop_type;
+        struct usb_os_desc *desc;
+        char *vlabuf;
+
+        vla_group(data_chunk);
+        vla_item(data_chunk, struct usb_os_desc_ext_prop, ext_prop, 1);
+        vla_item(data_chunk, struct config_item_type, ext_prop_type, 1);
+
+        vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
+        if (!vlabuf)
+                return ERR_PTR(-ENOMEM);
+
+        ext_prop = vla_ptr(vlabuf, data_chunk, ext_prop);
+        ext_prop_type = vla_ptr(vlabuf, data_chunk, ext_prop_type);
+
+        desc = container_of(group, struct usb_os_desc, group);
+        ext_prop_type->ct_item_ops = &ext_prop_ops;
+        ext_prop_type->ct_attrs = ext_prop_attrs;
+        ext_prop_type->ct_owner = desc->owner;
+
+        config_item_init_type_name(&ext_prop->item, name, ext_prop_type);
+
+        ext_prop->name = kstrdup(name, GFP_KERNEL);
+        if (!ext_prop->name) {
+                kfree(vlabuf);
+                return ERR_PTR(-ENOMEM);
+        }
+        desc->ext_prop_len += 14;
+        ext_prop->name_len = 2 * strlen(ext_prop->name) + 2;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        desc->ext_prop_len += ext_prop->name_len;
+        list_add_tail(&ext_prop->entry, &desc->ext_prop);
+        ++desc->ext_prop_count;
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return &ext_prop->item;
+}
+
+static void ext_prop_drop(struct config_group *group, struct config_item *item)
+{
+        struct usb_os_desc_ext_prop *ext_prop = to_usb_os_desc_ext_prop(item);
+        struct usb_os_desc *desc = to_usb_os_desc(&group->cg_item);
+
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        list_del(&ext_prop->entry);
+        --desc->ext_prop_count;
+        kfree(ext_prop->name);
+        desc->ext_prop_len -= (ext_prop->name_len + ext_prop->data_len + 14);
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+        config_item_put(item);
+}
+
+static struct configfs_group_operations interf_grp_ops = {
+        .make_item      = &ext_prop_make,
+        .drop_item      = &ext_prop_drop,
+};
+
+static struct configfs_item_operations interf_item_ops = {
+        .show_attribute         = usb_os_desc_attr_show,
+        .store_attribute        = usb_os_desc_attr_store,
+};
+
+static ssize_t rndis_grp_compatible_id_show(struct usb_os_desc *desc,
+                                            char *page)
+{
+        memcpy(page, desc->ext_compat_id, 8);
+        return 8;
+}
+
+static ssize_t rndis_grp_compatible_id_store(struct usb_os_desc *desc,
+                                             const char *page, size_t len)
+{
+        int l;
+
+        l = min_t(int, 8, len);
+        if (page[l - 1] == '\n')
+                --l;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        memcpy(desc->ext_compat_id, page, l);
+        desc->ext_compat_id[l] = '\0';
+
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return len;
+}
+
+static struct usb_os_desc_attribute rndis_grp_attr_compatible_id =
+        __CONFIGFS_ATTR(compatible_id, S_IRUGO | S_IWUSR,
+                        rndis_grp_compatible_id_show,
+                        rndis_grp_compatible_id_store);
+
+static ssize_t rndis_grp_sub_compatible_id_show(struct usb_os_desc *desc,
+                                                char *page)
+{
+        memcpy(page, desc->ext_compat_id + 8, 8);
+        return 8;
+}
+
+static ssize_t rndis_grp_sub_compatible_id_store(struct usb_os_desc *desc,
+                                                 const char *page, size_t len)
+{
+        int l;
+
+        l = min_t(int, 8, len);
+        if (page[l - 1] == '\n')
+                --l;
+        if (desc->opts_mutex)
+                mutex_lock(desc->opts_mutex);
+        memcpy(desc->ext_compat_id + 8, page, l);
+        desc->ext_compat_id[l + 8] = '\0';
+
+        if (desc->opts_mutex)
+                mutex_unlock(desc->opts_mutex);
+
+        return len;
+}
+
+static struct usb_os_desc_attribute rndis_grp_attr_sub_compatible_id =
+        __CONFIGFS_ATTR(sub_compatible_id, S_IRUGO | S_IWUSR,
+                        rndis_grp_sub_compatible_id_show,
+                        rndis_grp_sub_compatible_id_store);
+
+static struct configfs_attribute *interf_grp_attrs[] = {
+        &rndis_grp_attr_compatible_id.attr,
+        &rndis_grp_attr_sub_compatible_id.attr,
+        NULL
+};
+
+int usb_os_desc_prepare_interf_dir(struct config_group *parent,
+                                   int n_interf,
+                                   struct usb_os_desc **desc,
+                                   struct module *owner)
+{
+        struct config_group **f_default_groups, *os_desc_group,
+                                **interface_groups;
+        struct config_item_type *os_desc_type, *interface_type;
+
+        vla_group(data_chunk);
+        vla_item(data_chunk, struct config_group *, f_default_groups, 2);
+        vla_item(data_chunk, struct config_group, os_desc_group, 1);
+        vla_item(data_chunk, struct config_group *, interface_groups,
+                 n_interf + 1);
+        vla_item(data_chunk, struct config_item_type, os_desc_type, 1);
+        vla_item(data_chunk, struct config_item_type, interface_type, 1);
+
+        char *vlabuf = kzalloc(vla_group_size(data_chunk), GFP_KERNEL);
+        if (!vlabuf)
+                return -ENOMEM;
+
+        f_default_groups = vla_ptr(vlabuf, data_chunk, f_default_groups);
+        os_desc_group = vla_ptr(vlabuf, data_chunk, os_desc_group);
+        os_desc_type = vla_ptr(vlabuf, data_chunk, os_desc_type);
+        interface_groups = vla_ptr(vlabuf, data_chunk, interface_groups);
+        interface_type = vla_ptr(vlabuf, data_chunk, interface_type);
+
+        parent->default_groups = f_default_groups;
+        os_desc_type->ct_owner = owner;
+        config_group_init_type_name(os_desc_group, "os_desc", os_desc_type);
+        f_default_groups[0] = os_desc_group;
+
+        os_desc_group->default_groups = interface_groups;
+        interface_type->ct_item_ops = &interf_item_ops;
+        interface_type->ct_group_ops = &interf_grp_ops;
+        interface_type->ct_attrs = interf_grp_attrs;
+        interface_type->ct_owner = owner;
+
+        while (n_interf--) {
+                struct usb_os_desc *d;
+
+                d = desc[n_interf];
+                d->owner = owner;
+                config_group_init_type_name(&d->group, "", interface_type);
+                config_item_set_name(&d->group.cg_item, "interface.%d",
+                                     n_interf);
+                interface_groups[n_interf] = &d->group;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(usb_os_desc_prepare_interf_dir);
+
 static int configfs_do_nothing(struct usb_composite_dev *cdev)
 {
         WARN_ON(1);
@@ -745,6 +1275,9 @@ static int configfs_do_nothing(struct usb_composite_dev *cdev)
 int composite_dev_prepare(struct usb_composite_driver *composite,
                 struct usb_composite_dev *dev);
 
+int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
+                                  struct usb_ep *ep0);
+
 static void purge_configs_funcs(struct gadget_info *gi)
 {
         struct usb_configuration        *c;
@@ -793,7 +1326,7 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
         ret = -EINVAL;
 
         if (list_empty(&gi->cdev.configs)) {
-                pr_err("Need atleast one configuration in %s.\n",
+                pr_err("Need at least one configuration in %s.\n",
                                 gi->composite.name);
                 goto err_comp_cleanup;
         }
@@ -804,7 +1337,7 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
 
                 cfg = container_of(c, struct config_usb_cfg, c);
                 if (list_empty(&cfg->func_list)) {
-                        pr_err("Config %s/%d of %s needs atleast one function.\n",
+                        pr_err("Config %s/%d of %s needs at least one function.\n",
                               c->label, c->bConfigurationValue,
                               gi->composite.name);
                         goto err_comp_cleanup;
@@ -839,6 +1372,12 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
                 gi->cdev.desc.iSerialNumber = s[USB_GADGET_SERIAL_IDX].id;
         }
 
+        if (gi->use_os_desc) {
+                cdev->use_os_string = true;
+                cdev->b_vendor_code = gi->b_vendor_code;
+                memcpy(cdev->qw_sign, gi->qw_sign, OS_STRING_QW_SIGN_LEN);
+        }
+
         /* Go through all configs, attach all functions */
         list_for_each_entry(c, &gi->cdev.configs, list) {
                 struct config_usb_cfg *cfg;
@@ -874,6 +1413,12 @@ static int configfs_composite_bind(struct usb_gadget *gadget,
                 }
                 usb_ep_autoconfig_reset(cdev->gadget);
         }
+        if (cdev->use_os_string) {
+                ret = composite_os_desc_req_prepare(cdev, gadget->ep0);
+                if (ret)
+                        goto err_purge_funcs;
+        }
+
         usb_ep_autoconfig_reset(cdev->gadget);
         return 0;
 
@@ -929,6 +1474,7 @@ static struct config_group *gadgets_make(
         gi->group.default_groups[0] = &gi->functions_group;
         gi->group.default_groups[1] = &gi->configs_group;
         gi->group.default_groups[2] = &gi->strings_group;
+        gi->group.default_groups[3] = &gi->os_desc_group;
 
         config_group_init_type_name(&gi->functions_group, "functions",
                         &functions_type);
@@ -936,6 +1482,8 @@ static struct config_group *gadgets_make(
                         &config_desc_type);
         config_group_init_type_name(&gi->strings_group, "strings",
                         &gadget_strings_strings_type);
+        config_group_init_type_name(&gi->os_desc_group, "os_desc",
+                        &os_desc_type);
 
         gi->composite.bind = configfs_do_nothing;
         gi->composite.unbind = configfs_do_nothing;
@@ -1005,7 +1553,7 @@ void unregister_gadget_item(struct config_item *item)
 
         unregister_gadget(gi);
 }
-EXPORT_SYMBOL(unregister_gadget_item);
+EXPORT_SYMBOL_GPL(unregister_gadget_item);
 
 static int __init gadget_cfs_init(void)
 {
diff --git a/drivers/usb/gadget/configfs.h b/drivers/usb/gadget/configfs.h
index a7b564a913d1..a14ac792c698 100644
--- a/drivers/usb/gadget/configfs.h
+++ b/drivers/usb/gadget/configfs.h
@@ -1,6 +1,18 @@
 #ifndef USB__GADGET__CONFIGFS__H
 #define USB__GADGET__CONFIGFS__H
 
+#include <linux/configfs.h>
+
 void unregister_gadget_item(struct config_item *item);
 
+int usb_os_desc_prepare_interf_dir(struct config_group *parent,
+                                   int n_interf,
+                                   struct usb_os_desc **desc,
+                                   struct module *owner);
+
+static inline struct usb_os_desc *to_usb_os_desc(struct config_item *item)
+{
+        return container_of(to_config_group(item), struct usb_os_desc, group);
+}
+
 #endif /*  USB__GADGET__CONFIGFS__H */
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 8c06430dcc47..2b54955d3166 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -561,7 +561,6 @@ static int dummy_disable(struct usb_ep *_ep)
         struct dummy_ep         *ep;
         struct dummy            *dum;
         unsigned long           flags;
-        int                     retval;
 
         ep = usb_ep_to_dummy_ep(_ep);
         if (!_ep || !ep->desc || _ep->name == ep0name)
@@ -571,12 +570,11 @@ static int dummy_disable(struct usb_ep *_ep)
         spin_lock_irqsave(&dum->lock, flags);
         ep->desc = NULL;
         ep->stream_en = 0;
-        retval = 0;
         nuke(dum, ep);
         spin_unlock_irqrestore(&dum->lock, flags);
 
         dev_dbg(udc_dev(dum), "disabled %s\n", _ep->name);
-        return retval;
+        return 0;
 }
 
 static struct usb_request *dummy_alloc_request(struct usb_ep *_ep,
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 1e12b3ee56fd..74202d67f911 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -33,36 +33,11 @@
 #include <linux/poll.h>
 
 #include "u_fs.h"
+#include "u_f.h"
 #include "configfs.h"
 
 #define FUNCTIONFS_MAGIC        0xa647361 /* Chosen by a honest dice roll ;) */
 
-/* Variable Length Array Macros **********************************************/
-#define vla_group(groupname) size_t groupname##__next = 0
-#define vla_group_size(groupname) groupname##__next
-
-#define vla_item(groupname, type, name, n) \
-        size_t groupname##_##name##__offset = ({                               \
-                size_t align_mask = __alignof__(type) - 1;                     \
-                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
-                size_t size = (n) * sizeof(type);                              \
-                groupname##__next = offset + size;                             \
-                offset;                                                        \
-        })
-
-#define vla_item_with_sz(groupname, type, name, n) \
-        size_t groupname##_##name##__sz = (n) * sizeof(type);                  \
-        size_t groupname##_##name##__offset = ({                               \
-                size_t align_mask = __alignof__(type) - 1;                     \
-                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
-                size_t size = groupname##_##name##__sz;                        \
-                groupname##__next = offset + size;                             \
-                offset;                                                        \
-        })
-
-#define vla_ptr(ptr, groupname, name) \
-        ((void *) ((char *)ptr + groupname##_##name##__offset))
-
 /* Reference counter handling */
 static void ffs_data_get(struct ffs_data *ffs);
 static void ffs_data_put(struct ffs_data *ffs);
@@ -190,7 +165,7 @@ ffs_sb_create_file(struct super_block *sb, const char *name, void *data,
 /* Devices management *******************************************************/
 
 DEFINE_MUTEX(ffs_lock);
-EXPORT_SYMBOL(ffs_lock);
+EXPORT_SYMBOL_GPL(ffs_lock);
 
 static struct ffs_dev *_ffs_find_dev(const char *name);
 static struct ffs_dev *_ffs_alloc_dev(void);
@@ -2883,7 +2858,7 @@ int ffs_name_dev(struct ffs_dev *dev, const char *name)
 
         return ret;
 }
-EXPORT_SYMBOL(ffs_name_dev);
+EXPORT_SYMBOL_GPL(ffs_name_dev);
 
 int ffs_single_dev(struct ffs_dev *dev)
 {
@@ -2900,7 +2875,7 @@ int ffs_single_dev(struct ffs_dev *dev)
         ffs_dev_unlock();
         return ret;
 }
-EXPORT_SYMBOL(ffs_single_dev);
+EXPORT_SYMBOL_GPL(ffs_single_dev);
 
 /*
  * ffs_lock must be taken by the caller of this function
diff --git a/drivers/usb/gadget/f_rndis.c b/drivers/usb/gadget/f_rndis.c
index 9a4f49dc6ac4..eed3ad878047 100644
--- a/drivers/usb/gadget/f_rndis.c
+++ b/drivers/usb/gadget/f_rndis.c
@@ -27,6 +27,7 @@
 #include "u_ether_configfs.h"
 #include "u_rndis.h"
 #include "rndis.h"
+#include "configfs.h"
 
 /*
  * This function is an RNDIS Ethernet port -- a Microsoft protocol that's
@@ -682,6 +683,15 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
 
         rndis_opts = container_of(f->fi, struct f_rndis_opts, func_inst);
 
+        if (cdev->use_os_string) {
+                f->os_desc_table = kzalloc(sizeof(*f->os_desc_table),
+                                           GFP_KERNEL);
+                if (!f->os_desc_table)
+                        return PTR_ERR(f->os_desc_table);
+                f->os_desc_n = 1;
+                f->os_desc_table[0].os_desc = &rndis_opts->rndis_os_desc;
+        }
+
         /*
          * in drivers/usb/gadget/configfs.c:configfs_composite_bind()
          * configurations are bound in sequence with list_for_each_entry,
@@ -693,14 +703,16 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
                 gether_set_gadget(rndis_opts->net, cdev->gadget);
                 status = gether_register_netdev(rndis_opts->net);
                 if (status)
-                        return status;
+                        goto fail;
                 rndis_opts->bound = true;
         }
 
         us = usb_gstrings_attach(cdev, rndis_strings,
                                  ARRAY_SIZE(rndis_string_defs));
-        if (IS_ERR(us))
-                return PTR_ERR(us);
+        if (IS_ERR(us)) {
+                status = PTR_ERR(us);
+                goto fail;
+        }
         rndis_control_intf.iInterface = us[0].id;
         rndis_data_intf.iInterface = us[1].id;
         rndis_iad_descriptor.iFunction = us[2].id;
@@ -802,6 +814,8 @@ rndis_bind(struct usb_configuration *c, struct usb_function *f)
         return 0;
 
 fail:
+        kfree(f->os_desc_table);
+        f->os_desc_n = 0;
         usb_free_all_descriptors(f);
 
         if (rndis->notify_req) {
@@ -834,7 +848,7 @@ void rndis_borrow_net(struct usb_function_instance *f, struct net_device *net)
         opts->borrowed_net = opts->bound = true;
         opts->net = net;
 }
-EXPORT_SYMBOL(rndis_borrow_net);
+EXPORT_SYMBOL_GPL(rndis_borrow_net);
 
 static inline struct f_rndis_opts *to_f_rndis_opts(struct config_item *item)
 {
@@ -882,16 +896,21 @@ static void rndis_free_inst(struct usb_function_instance *f)
                 else
                         free_netdev(opts->net);
         }
+
+        kfree(opts->rndis_os_desc.group.default_groups); /* single VLA chunk */
         kfree(opts);
 }
 
 static struct usb_function_instance *rndis_alloc_inst(void)
 {
         struct f_rndis_opts *opts;
+        struct usb_os_desc *descs[1];
 
         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
         if (!opts)
                 return ERR_PTR(-ENOMEM);
+        opts->rndis_os_desc.ext_compat_id = opts->rndis_ext_compat_id;
+
         mutex_init(&opts->lock);
         opts->func_inst.free_func_inst = rndis_free_inst;
         opts->net = gether_setup_default();
@@ -900,7 +919,11 @@ static struct usb_function_instance *rndis_alloc_inst(void)
                 kfree(opts);
                 return ERR_CAST(net);
         }
+        INIT_LIST_HEAD(&opts->rndis_os_desc.ext_prop);
 
+        descs[0] = &opts->rndis_os_desc;
+        usb_os_desc_prepare_interf_dir(&opts->func_inst.group, 1, descs,
+                                       THIS_MODULE);
         config_group_init_type_name(&opts->func_inst.group, "",
                                     &rndis_func_type);
 
@@ -925,6 +948,8 @@ static void rndis_unbind(struct usb_configuration *c, struct usb_function *f)
 {
         struct f_rndis          *rndis = func_to_rndis(f);
 
+        kfree(f->os_desc_table);
+        f->os_desc_n = 0;
         usb_free_all_descriptors(f);
 
         kfree(rndis->notify_req->buf);
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index df4a0dcbc993..1ea8baf33333 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -276,7 +276,7 @@ static int geth_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         }
 
         net = gether_connect(&geth->port);
-        return PTR_RET(net);
+        return PTR_ERR_OR_ZERO(net);
 }
 
 static void geth_disable(struct usb_function *f)
diff --git a/drivers/usb/gadget/f_uac2.c b/drivers/usb/gadget/f_uac2.c
index bc23040c7790..6261db4a9910 100644
--- a/drivers/usb/gadget/f_uac2.c
+++ b/drivers/usb/gadget/f_uac2.c
@@ -196,7 +196,7 @@ agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
         struct snd_uac2_chip *uac2 = prm->uac2;
 
         /* i/f shutting down */
-        if (!prm->ep_enabled)
+        if (!prm->ep_enabled || req->status == -ESHUTDOWN)
                 return;
 
         /*
@@ -974,8 +974,6 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
         if (!prm->rbuf) {
                 prm->max_psize = 0;
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
 
@@ -984,8 +982,6 @@ afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
         if (!prm->rbuf) {
                 prm->max_psize = 0;
-                dev_err(&uac2->pdev.dev,
-                        "%s:%d Error!\n", __func__, __LINE__);
                 goto err;
         }
 
@@ -1298,10 +1294,8 @@ static int audio_bind_config(struct usb_configuration *cfg)
         int res;
 
         agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL);
-        if (agdev_g == NULL) {
-                printk(KERN_ERR "Unable to allocate audio gadget\n");
+        if (agdev_g == NULL)
                 return -ENOMEM;
-        }
 
         res = usb_string_ids_tab(cfg->cdev, strings_fn);
         if (res)
diff --git a/drivers/usb/gadget/fotg210-udc.c b/drivers/usb/gadget/fotg210-udc.c
index 2d0305280e8c..e143d69f6017 100644
--- a/drivers/usb/gadget/fotg210-udc.c
+++ b/drivers/usb/gadget/fotg210-udc.c
@@ -1112,17 +1112,13 @@ static int fotg210_udc_probe(struct platform_device *pdev)
 
         /* initialize udc */
         fotg210 = kzalloc(sizeof(struct fotg210_udc), GFP_KERNEL);
-        if (fotg210 == NULL) {
-                pr_err("kzalloc error\n");
+        if (fotg210 == NULL)
                 goto err_alloc;
-        }
 
         for (i = 0; i < FOTG210_MAX_NUM_EP; i++) {
                 _ep[i] = kzalloc(sizeof(struct fotg210_ep), GFP_KERNEL);
-                if (_ep[i] == NULL) {
-                        pr_err("_ep kzalloc error\n");
+                if (_ep[i] == NULL)
                         goto err_alloc;
-                }
                 fotg210->ep[i] = _ep[i];
         }
 
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index a2f26cdb56fe..28e4fc957026 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -2256,10 +2256,8 @@ static int __init struct_udc_setup(struct fsl_udc *udc,
         udc->phy_mode = pdata->phy_mode;
 
         udc->eps = kzalloc(sizeof(struct fsl_ep) * udc->max_ep, GFP_KERNEL);
-        if (!udc->eps) {
-                ERR("malloc fsl_ep failed\n");
+        if (!udc->eps)
                 return -1;
-        }
 
         /* initialized QHs, take care of alignment */
         size = udc->max_ep * sizeof(struct ep_queue_head);
@@ -2342,10 +2340,8 @@ static int __init fsl_udc_probe(struct platform_device *pdev)
         u32 dccparams;
 
         udc_controller = kzalloc(sizeof(struct fsl_udc), GFP_KERNEL);
-        if (udc_controller == NULL) {
-                ERR("malloc udc failed\n");
+        if (udc_controller == NULL)
                 return -ENOMEM;
-        }
 
         pdata = dev_get_platdata(&pdev->dev);
         udc_controller->pdata = pdata;
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index 6423f1840ed9..3deb4e938071 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -1400,17 +1400,13 @@ static int __init fusb300_probe(struct platform_device *pdev)
 
         /* initialize udc */
         fusb300 = kzalloc(sizeof(struct fusb300), GFP_KERNEL);
-        if (fusb300 == NULL) {
-                pr_err("kzalloc error\n");
+        if (fusb300 == NULL)
                 goto clean_up;
-        }
 
         for (i = 0; i < FUSB300_MAX_NUM_EP; i++) {
                 _ep[i] = kzalloc(sizeof(struct fusb300_ep), GFP_KERNEL);
-                if (_ep[i] == NULL) {
-                        pr_err("_ep kzalloc error\n");
+                if (_ep[i] == NULL)
                         goto clean_up;
-                }
                 fusb300->ep[i] = _ep[i];
         }
 
diff --git a/drivers/usb/gadget/gr_udc.c b/drivers/usb/gadget/gr_udc.c
index f984ee75324d..99a37ed03e27 100644
--- a/drivers/usb/gadget/gr_udc.c
+++ b/drivers/usb/gadget/gr_udc.c
@@ -143,6 +143,7 @@ static void gr_seq_ep_show(struct seq_file *seq, struct gr_ep *ep)
         seq_printf(seq, "  wedged = %d\n", ep->wedged);
         seq_printf(seq, "  callback = %d\n", ep->callback);
         seq_printf(seq, "  maxpacket = %d\n", ep->ep.maxpacket);
+        seq_printf(seq, "  maxpacket_limit = %d\n", ep->ep.maxpacket_limit);
         seq_printf(seq, "  bytes_per_buffer = %d\n", ep->bytes_per_buffer);
         if (mode == 1 || mode == 3)
                 seq_printf(seq, "  nt = %d\n",
@@ -1541,6 +1542,10 @@ static int gr_ep_enable(struct usb_ep *_ep,
         } else if (max == 0) {
                 dev_err(dev->dev, "Max payload cannot be set to 0\n");
                 return -EINVAL;
+        } else if (max > ep->ep.maxpacket_limit) {
+                dev_err(dev->dev, "Requested max payload %d > limit %d\n",
+                        max, ep->ep.maxpacket_limit);
+                return -EINVAL;
         }
 
         spin_lock(&ep->dev->lock);
@@ -1679,7 +1684,7 @@ static int gr_queue_ext(struct usb_ep *_ep, struct usb_request *_req,
         if (ep->is_in)
                 gr_dbgprint_request("EXTERN", ep, req);
 
-        ret = gr_queue(ep, req, gfp_flags);
+        ret = gr_queue(ep, req, GFP_ATOMIC);
 
         spin_unlock(&ep->dev->lock);
 
@@ -1985,8 +1990,8 @@ static int gr_ep_init(struct gr_udc *dev, int num, int is_in, u32 maxplimit)
         INIT_LIST_HEAD(&ep->queue);
 
         if (num == 0) {
-                _req = gr_alloc_request(&ep->ep, GFP_KERNEL);
-                buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_KERNEL);
+                _req = gr_alloc_request(&ep->ep, GFP_ATOMIC);
+                buf = devm_kzalloc(dev->dev, PAGE_SIZE, GFP_DMA | GFP_ATOMIC);
                 if (!_req || !buf) {
                         /* possible _req freed by gr_probe via gr_remove */
                         return -ENOMEM;
@@ -2020,9 +2025,7 @@ static int gr_udc_init(struct gr_udc *dev)
         u32 dmactrl_val;
         int i;
         int ret = 0;
-        u32 *bufsizes;
         u32 bufsize;
-        int len;
 
         gr_set_address(dev, 0);
 
@@ -2033,19 +2036,17 @@ static int gr_udc_init(struct gr_udc *dev)
         INIT_LIST_HEAD(&dev->ep_list);
         gr_set_ep0state(dev, GR_EP0_DISCONNECT);
 
-        bufsizes = (u32 *)of_get_property(np, "epobufsizes", &len);
-        len /= sizeof(u32);
         for (i = 0; i < dev->nepo; i++) {
-                bufsize = (bufsizes && i < len) ? bufsizes[i] : 1024;
+                if (of_property_read_u32_index(np, "epobufsizes", i, &bufsize))
+                        bufsize = 1024;
                 ret = gr_ep_init(dev, i, 0, bufsize);
                 if (ret)
                         return ret;
         }
 
-        bufsizes = (u32 *)of_get_property(np, "epibufsizes", &len);
-        len /= sizeof(u32);
         for (i = 0; i < dev->nepi; i++) {
-                bufsize = (bufsizes && i < len) ? bufsizes[i] : 1024;
+                if (of_property_read_u32_index(np, "epibufsizes", i, &bufsize))
+                        bufsize = 1024;
                 ret = gr_ep_init(dev, i, 1, bufsize);
                 if (ret)
                         return ret;
@@ -2065,9 +2066,9 @@ static int gr_udc_init(struct gr_udc *dev)
         return 0;
 }
 
-static int gr_remove(struct platform_device *ofdev)
+static int gr_remove(struct platform_device *pdev)
 {
-        struct gr_udc *dev = dev_get_drvdata(&ofdev->dev);
+        struct gr_udc *dev = platform_get_drvdata(pdev);
 
         if (dev->added)
                 usb_del_gadget_udc(&dev->gadget); /* Shuts everything down */
@@ -2077,7 +2078,7 @@ static int gr_remove(struct platform_device *ofdev)
         gr_dfs_delete(dev);
         if (dev->desc_pool)
                 dma_pool_destroy(dev->desc_pool);
-        dev_set_drvdata(&ofdev->dev, NULL);
+        platform_set_drvdata(pdev, NULL);
 
         gr_free_request(&dev->epi[0].ep, &dev->ep0reqi->req);
         gr_free_request(&dev->epo[0].ep, &dev->ep0reqo->req);
@@ -2090,7 +2091,7 @@ static int gr_request_irq(struct gr_udc *dev, int irq)
                                          IRQF_SHARED, driver_name, dev);
 }
 
-static int gr_probe(struct platform_device *ofdev)
+static int gr_probe(struct platform_device *pdev)
 {
         struct gr_udc *dev;
         struct resource *res;
@@ -2098,30 +2099,32 @@ static int gr_probe(struct platform_device *ofdev)
         int retval;
         u32 status;
 
-        dev = devm_kzalloc(&ofdev->dev, sizeof(*dev), GFP_KERNEL);
+        dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
         if (!dev)
                 return -ENOMEM;
-        dev->dev = &ofdev->dev;
+        dev->dev = &pdev->dev;
 
-        res = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         regs = devm_ioremap_resource(dev->dev, res);
         if (IS_ERR(regs))
                 return PTR_ERR(regs);
 
-        dev->irq = irq_of_parse_and_map(dev->dev->of_node, 0);
-        if (!dev->irq) {
+        dev->irq = platform_get_irq(pdev, 0);
+        if (dev->irq <= 0) {
                 dev_err(dev->dev, "No irq found\n");
                 return -ENODEV;
         }
 
         /* Some core configurations has separate irqs for IN and OUT events */
-        dev->irqi = irq_of_parse_and_map(dev->dev->of_node, 1);
-        if (dev->irqi) {
-                dev->irqo = irq_of_parse_and_map(dev->dev->of_node, 2);
-                if (!dev->irqo) {
+        dev->irqi = platform_get_irq(pdev, 1);
+        if (dev->irqi > 0) {
+                dev->irqo = platform_get_irq(pdev, 2);
+                if (dev->irqo <= 0) {
                         dev_err(dev->dev, "Found irqi but not irqo\n");
                         return -ENODEV;
                 }
+        } else {
+                dev->irqi = 0;
         }
 
         dev->gadget.name = driver_name;
@@ -2132,7 +2135,7 @@ static int gr_probe(struct platform_device *ofdev)
         spin_lock_init(&dev->lock);
         dev->regs = regs;
 
-        dev_set_drvdata(&ofdev->dev, dev);
+        platform_set_drvdata(pdev, dev);
 
         /* Determine number of endpoints and data interface mode */
         status = gr_read32(&dev->regs->status);
@@ -2204,7 +2207,7 @@ out:
         spin_unlock(&dev->lock);
 
         if (retval)
-                gr_remove(ofdev);
+                gr_remove(pdev);
 
         return retval;
 }
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index a925d0cbcd41..ee6c16416c30 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -1494,6 +1494,7 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                  */
                 if (value == 0) {
                         INFO (dev, "configuration #%d\n", dev->current_config);
+                        usb_gadget_set_state(gadget, USB_STATE_CONFIGURED);
                         if (dev->usermode_setup) {
                                 dev->setup_can_stall = 0;
                                 goto delegate;
@@ -1501,7 +1502,7 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                 }
                 break;
 
-#ifndef CONFIG_USB_GADGET_PXA25X
+#ifndef CONFIG_USB_PXA25X
         /* PXA automagically handles this request too */
         case USB_REQ_GET_CONFIGURATION:
                 if (ctrl->bRequestType != 0x80)
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 8cae01d88597..0d17174b86f8 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1594,7 +1594,6 @@ static int __init m66592_probe(struct platform_device *pdev)
         m66592 = kzalloc(sizeof(struct m66592), GFP_KERNEL);
         if (m66592 == NULL) {
                 ret = -ENOMEM;
-                pr_err("kzalloc error\n");
                 goto clean_up;
         }
 
diff --git a/drivers/usb/gadget/mv_u3d_core.c b/drivers/usb/gadget/mv_u3d_core.c
index d2ca59e7b477..16248711c152 100644
--- a/drivers/usb/gadget/mv_u3d_core.c
+++ b/drivers/usb/gadget/mv_u3d_core.c
@@ -297,10 +297,8 @@ static struct mv_u3d_trb *mv_u3d_build_trb_one(struct mv_u3d_req *req,
         u3d = req->ep->u3d;
 
         trb = kzalloc(sizeof(*trb), GFP_ATOMIC);
-        if (!trb) {
-                dev_err(u3d->dev, "%s, trb alloc fail\n", __func__);
+        if (!trb)
                 return NULL;
-        }
 
         /*
          * Be careful that no _GFP_HIGHMEM is set,
@@ -446,17 +444,12 @@ static int mv_u3d_req_to_trb(struct mv_u3d_req *req)
                         trb_num++;
 
                 trb = kcalloc(trb_num, sizeof(*trb), GFP_ATOMIC);
-                if (!trb) {
-                        dev_err(u3d->dev,
-                                        "%s, trb alloc fail\n", __func__);
+                if (!trb)
                         return -ENOMEM;
-                }
 
                 trb_hw = kcalloc(trb_num, sizeof(*trb_hw), GFP_ATOMIC);
                 if (!trb_hw) {
                         kfree(trb);
-                        dev_err(u3d->dev,
-                                        "%s, trb_hw alloc fail\n", __func__);
                         return -ENOMEM;
                 }
 
@@ -1811,7 +1804,6 @@ static int mv_u3d_probe(struct platform_device *dev)
 
         u3d = kzalloc(sizeof(*u3d), GFP_KERNEL);
         if (!u3d) {
-                dev_err(&dev->dev, "failed to allocate memory for u3d\n");
                 retval = -ENOMEM;
                 goto err_alloc_private;
         }
@@ -1905,7 +1897,6 @@ static int mv_u3d_probe(struct platform_device *dev)
         size = u3d->max_eps * sizeof(struct mv_u3d_ep) * 2;
         u3d->eps = kzalloc(size, GFP_KERNEL);
         if (!u3d->eps) {
-                dev_err(&dev->dev, "allocate ep memory failed\n");
                 retval = -ENOMEM;
                 goto err_alloc_eps;
         }
@@ -1913,7 +1904,6 @@ static int mv_u3d_probe(struct platform_device *dev)
         /* initialize ep0 status request structure */
         u3d->status_req = kzalloc(sizeof(struct mv_u3d_req) + 8, GFP_KERNEL);
         if (!u3d->status_req) {
-                dev_err(&dev->dev, "allocate status_req memory failed\n");
                 retval = -ENOMEM;
                 goto err_alloc_status_req;
         }
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index 43e5e2f9888f..300b3a71383b 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -1972,7 +1972,9 @@ static int net2280_stop(struct usb_gadget *_gadget,
         device_remove_file (&dev->pdev->dev, &dev_attr_function);
         device_remove_file (&dev->pdev->dev, &dev_attr_queues);
 
-        DEBUG (dev, "unregistered driver '%s'\n", driver->driver.name);
+        DEBUG(dev, "unregistered driver '%s'\n",
+                        driver ? driver->driver.name : "");
+
         return 0;
 }
 
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index aff0a6718bc6..b698a490cc7d 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -1904,7 +1904,6 @@ static int __init r8a66597_probe(struct platform_device *pdev)
         r8a66597 = kzalloc(sizeof(struct r8a66597), GFP_KERNEL);
         if (r8a66597 == NULL) {
                 ret = -ENOMEM;
-                dev_err(&pdev->dev, "kzalloc error\n");
                 goto clean_up;
         }
 
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index 7ed452d90f4d..95d2324f6977 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -761,7 +761,7 @@ int rndis_signal_connect(int configNr)
         return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_CONNECT);
 }
-EXPORT_SYMBOL(rndis_signal_connect);
+EXPORT_SYMBOL_GPL(rndis_signal_connect);
 
 int rndis_signal_disconnect(int configNr)
 {
@@ -770,7 +770,7 @@ int rndis_signal_disconnect(int configNr)
         return rndis_indicate_status_msg(configNr,
                                           RNDIS_STATUS_MEDIA_DISCONNECT);
 }
-EXPORT_SYMBOL(rndis_signal_disconnect);
+EXPORT_SYMBOL_GPL(rndis_signal_disconnect);
 
 void rndis_uninit(int configNr)
 {
@@ -785,13 +785,13 @@ void rndis_uninit(int configNr)
         while ((buf = rndis_get_next_response(configNr, &length)))
                 rndis_free_response(configNr, buf);
 }
-EXPORT_SYMBOL(rndis_uninit);
+EXPORT_SYMBOL_GPL(rndis_uninit);
 
 void rndis_set_host_mac(int configNr, const u8 *addr)
 {
         rndis_per_dev_params[configNr].host_mac = addr;
 }
-EXPORT_SYMBOL(rndis_set_host_mac);
+EXPORT_SYMBOL_GPL(rndis_set_host_mac);
 
 /*
  * Message Parser
@@ -874,7 +874,7 @@ int rndis_msg_parser(u8 configNr, u8 *buf)
 
         return -ENOTSUPP;
 }
-EXPORT_SYMBOL(rndis_msg_parser);
+EXPORT_SYMBOL_GPL(rndis_msg_parser);
 
 int rndis_register(void (*resp_avail)(void *v), void *v)
 {
@@ -896,7 +896,7 @@ int rndis_register(void (*resp_avail)(void *v), void *v)
 
         return -ENODEV;
 }
-EXPORT_SYMBOL(rndis_register);
+EXPORT_SYMBOL_GPL(rndis_register);
 
 void rndis_deregister(int configNr)
 {
@@ -905,7 +905,7 @@ void rndis_deregister(int configNr)
         if (configNr >= RNDIS_MAX_CONFIGS) return;
         rndis_per_dev_params[configNr].used = 0;
 }
-EXPORT_SYMBOL(rndis_deregister);
+EXPORT_SYMBOL_GPL(rndis_deregister);
 
 int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
 {
@@ -919,7 +919,7 @@ int rndis_set_param_dev(u8 configNr, struct net_device *dev, u16 *cdc_filter)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_dev);
+EXPORT_SYMBOL_GPL(rndis_set_param_dev);
 
 int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
 {
@@ -932,7 +932,7 @@ int rndis_set_param_vendor(u8 configNr, u32 vendorID, const char *vendorDescr)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_vendor);
+EXPORT_SYMBOL_GPL(rndis_set_param_vendor);
 
 int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
 {
@@ -944,7 +944,7 @@ int rndis_set_param_medium(u8 configNr, u32 medium, u32 speed)
 
         return 0;
 }
-EXPORT_SYMBOL(rndis_set_param_medium);
+EXPORT_SYMBOL_GPL(rndis_set_param_medium);
 
 void rndis_add_hdr(struct sk_buff *skb)
 {
@@ -959,7 +959,7 @@ void rndis_add_hdr(struct sk_buff *skb)
         header->DataOffset = cpu_to_le32(36);
         header->DataLength = cpu_to_le32(skb->len - sizeof(*header));
 }
-EXPORT_SYMBOL(rndis_add_hdr);
+EXPORT_SYMBOL_GPL(rndis_add_hdr);
 
 void rndis_free_response(int configNr, u8 *buf)
 {
@@ -976,7 +976,7 @@ void rndis_free_response(int configNr, u8 *buf)
                 }
         }
 }
-EXPORT_SYMBOL(rndis_free_response);
+EXPORT_SYMBOL_GPL(rndis_free_response);
 
 u8 *rndis_get_next_response(int configNr, u32 *length)
 {
@@ -998,7 +998,7 @@ u8 *rndis_get_next_response(int configNr, u32 *length)
 
         return NULL;
 }
-EXPORT_SYMBOL(rndis_get_next_response);
+EXPORT_SYMBOL_GPL(rndis_get_next_response);
 
 static rndis_resp_t *rndis_add_response(int configNr, u32 length)
 {
@@ -1042,7 +1042,7 @@ int rndis_rm_hdr(struct gether *port,
         skb_queue_tail(list, skb);
         return 0;
 }
-EXPORT_SYMBOL(rndis_rm_hdr);
+EXPORT_SYMBOL_GPL(rndis_rm_hdr);
 
 #ifdef CONFIG_USB_GADGET_DEBUG_FILES
 
diff --git a/drivers/usb/gadget/s3c-hsotg.h b/drivers/usb/gadget/s3c-hsotg.h
deleted file mode 100644
index 85f549ff8c1f..000000000000
--- a/drivers/usb/gadget/s3c-hsotg.h
+++ /dev/null
@@ -1,378 +0,0 @@
-/* drivers/usb/gadget/s3c-hsotg.h
- *
- * Copyright 2008 Openmoko, Inc.
- * Copyright 2008 Simtec Electronics
- *      http://armlinux.simtec.co.uk/
- *      Ben Dooks <ben@simtec.co.uk>
- *
- * USB2.0 Highspeed/OtG Synopsis DWC2 device block registers
- *
- * 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 __REGS_USB_HSOTG_H
-#define __REGS_USB_HSOTG_H __FILE__
-
-#define HSOTG_REG(x) (x)
-
-#define GOTGCTL                         HSOTG_REG(0x000)
-#define GOTGCTL_BSESVLD                 (1 << 19)
-#define GOTGCTL_ASESVLD                 (1 << 18)
-#define GOTGCTL_DBNC_SHORT                      (1 << 17)
-#define GOTGCTL_CONID_B                 (1 << 16)
-#define GOTGCTL_DEVHNPEN                        (1 << 11)
-#define GOTGCTL_HSSETHNPEN                      (1 << 10)
-#define GOTGCTL_HNPREQ                          (1 << 9)
-#define GOTGCTL_HSTNEGSCS                       (1 << 8)
-#define GOTGCTL_SESREQ                          (1 << 1)
-#define GOTGCTL_SESREQSCS                       (1 << 0)
-
-#define GOTGINT                         HSOTG_REG(0x004)
-#define GOTGINT_DbnceDone                       (1 << 19)
-#define GOTGINT_ADevTOUTChg                     (1 << 18)
-#define GOTGINT_HstNegDet                       (1 << 17)
-#define GOTGINT_HstnegSucStsChng                (1 << 9)
-#define GOTGINT_SesReqSucStsChng                (1 << 8)
-#define GOTGINT_SesEndDet                       (1 << 2)
-
-#define GAHBCFG                         HSOTG_REG(0x008)
-#define GAHBCFG_PTxFEmpLvl                      (1 << 8)
-#define GAHBCFG_NPTxFEmpLvl                     (1 << 7)
-#define GAHBCFG_DMAEn                           (1 << 5)
-#define GAHBCFG_HBstLen_MASK                    (0xf << 1)
-#define GAHBCFG_HBstLen_SHIFT                   (1)
-#define GAHBCFG_HBstLen_Single                  (0x0 << 1)
-#define GAHBCFG_HBstLen_Incr                    (0x1 << 1)
-#define GAHBCFG_HBstLen_Incr4                   (0x3 << 1)
-#define GAHBCFG_HBstLen_Incr8                   (0x5 << 1)
-#define GAHBCFG_HBstLen_Incr16                  (0x7 << 1)
-#define GAHBCFG_GlblIntrEn                      (1 << 0)
-
-#define GUSBCFG                         HSOTG_REG(0x00C)
-#define GUSBCFG_PHYLPClkSel                     (1 << 15)
-#define GUSBCFG_HNPCap                          (1 << 9)
-#define GUSBCFG_SRPCap                          (1 << 8)
-#define GUSBCFG_PHYIf16                 (1 << 3)
-#define GUSBCFG_PHYIf8                          (0 << 3)
-#define GUSBCFG_TOutCal_MASK                    (0x7 << 0)
-#define GUSBCFG_TOutCal_SHIFT                   (0)
-#define GUSBCFG_TOutCal_LIMIT                   (0x7)
-#define GUSBCFG_TOutCal(_x)                     ((_x) << 0)
-
-#define GRSTCTL                         HSOTG_REG(0x010)
-
-#define GRSTCTL_AHBIdle                 (1 << 31)
-#define GRSTCTL_DMAReq                          (1 << 30)
-#define GRSTCTL_TxFNum_MASK                     (0x1f << 6)
-#define GRSTCTL_TxFNum_SHIFT                    (6)
-#define GRSTCTL_TxFNum_LIMIT                    (0x1f)
-#define GRSTCTL_TxFNum(_x)                      ((_x) << 6)
-#define GRSTCTL_TxFFlsh                 (1 << 5)
-#define GRSTCTL_RxFFlsh                 (1 << 4)
-#define GRSTCTL_INTknQFlsh                      (1 << 3)
-#define GRSTCTL_FrmCntrRst                      (1 << 2)
-#define GRSTCTL_HSftRst                 (1 << 1)
-#define GRSTCTL_CSftRst                 (1 << 0)
-
-#define GINTSTS                         HSOTG_REG(0x014)
-#define GINTMSK                         HSOTG_REG(0x018)
-
-#define GINTSTS_WkUpInt                 (1 << 31)
-#define GINTSTS_SessReqInt                      (1 << 30)
-#define GINTSTS_DisconnInt                      (1 << 29)
-#define GINTSTS_ConIDStsChng                    (1 << 28)
-#define GINTSTS_PTxFEmp                 (1 << 26)
-#define GINTSTS_HChInt                          (1 << 25)
-#define GINTSTS_PrtInt                          (1 << 24)
-#define GINTSTS_FetSusp                 (1 << 22)
-#define GINTSTS_incompIP                        (1 << 21)
-#define GINTSTS_IncomplSOIN                     (1 << 20)
-#define GINTSTS_OEPInt                          (1 << 19)
-#define GINTSTS_IEPInt                          (1 << 18)
-#define GINTSTS_EPMis                           (1 << 17)
-#define GINTSTS_EOPF                            (1 << 15)
-#define GINTSTS_ISOutDrop                       (1 << 14)
-#define GINTSTS_EnumDone                        (1 << 13)
-#define GINTSTS_USBRst                          (1 << 12)
-#define GINTSTS_USBSusp                 (1 << 11)
-#define GINTSTS_ErlySusp                        (1 << 10)
-#define GINTSTS_GOUTNakEff                      (1 << 7)
-#define GINTSTS_GINNakEff                       (1 << 6)
-#define GINTSTS_NPTxFEmp                        (1 << 5)
-#define GINTSTS_RxFLvl                          (1 << 4)
-#define GINTSTS_SOF                             (1 << 3)
-#define GINTSTS_OTGInt                          (1 << 2)
-#define GINTSTS_ModeMis                 (1 << 1)
-#define GINTSTS_CurMod_Host                     (1 << 0)
-
-#define GRXSTSR                         HSOTG_REG(0x01C)
-#define GRXSTSP                         HSOTG_REG(0x020)
-
-#define GRXSTS_FN_MASK                          (0x7f << 25)
-#define GRXSTS_FN_SHIFT                 (25)
-
-#define GRXSTS_PktSts_MASK                      (0xf << 17)
-#define GRXSTS_PktSts_SHIFT                     (17)
-#define GRXSTS_PktSts_GlobalOutNAK              (0x1 << 17)
-#define GRXSTS_PktSts_OutRX                     (0x2 << 17)
-#define GRXSTS_PktSts_OutDone                   (0x3 << 17)
-#define GRXSTS_PktSts_SetupDone         (0x4 << 17)
-#define GRXSTS_PktSts_SetupRX                   (0x6 << 17)
-
-#define GRXSTS_DPID_MASK                        (0x3 << 15)
-#define GRXSTS_DPID_SHIFT                       (15)
-#define GRXSTS_ByteCnt_MASK                     (0x7ff << 4)
-#define GRXSTS_ByteCnt_SHIFT                    (4)
-#define GRXSTS_EPNum_MASK                       (0xf << 0)
-#define GRXSTS_EPNum_SHIFT                      (0)
-
-#define GRXFSIZ                         HSOTG_REG(0x024)
-
-#define GNPTXFSIZ                               HSOTG_REG(0x028)
-
-#define GNPTXFSIZ_NPTxFDep_MASK         (0xffff << 16)
-#define GNPTXFSIZ_NPTxFDep_SHIFT                (16)
-#define GNPTXFSIZ_NPTxFDep_LIMIT                (0xffff)
-#define GNPTXFSIZ_NPTxFDep(_x)                  ((_x) << 16)
-#define GNPTXFSIZ_NPTxFStAddr_MASK              (0xffff << 0)
-#define GNPTXFSIZ_NPTxFStAddr_SHIFT             (0)
-#define GNPTXFSIZ_NPTxFStAddr_LIMIT             (0xffff)
-#define GNPTXFSIZ_NPTxFStAddr(_x)               ((_x) << 0)
-
-#define GNPTXSTS                                HSOTG_REG(0x02C)
-
-#define GNPTXSTS_NPtxQTop_MASK                  (0x7f << 24)
-#define GNPTXSTS_NPtxQTop_SHIFT         (24)
-
-#define GNPTXSTS_NPTxQSpcAvail_MASK             (0xff << 16)
-#define GNPTXSTS_NPTxQSpcAvail_SHIFT            (16)
-#define GNPTXSTS_NPTxQSpcAvail_GET(_v)          (((_v) >> 16) & 0xff)
-
-#define GNPTXSTS_NPTxFSpcAvail_MASK             (0xffff << 0)
-#define GNPTXSTS_NPTxFSpcAvail_SHIFT            (0)
-#define GNPTXSTS_NPTxFSpcAvail_GET(_v)          (((_v) >> 0) & 0xffff)
-
-
-#define HPTXFSIZ                                HSOTG_REG(0x100)
-
-#define DPTXFSIZn(_a)           HSOTG_REG(0x104 + (((_a) - 1) * 4))
-
-#define DPTXFSIZn_DPTxFSize_MASK                (0xffff << 16)
-#define DPTXFSIZn_DPTxFSize_SHIFT               (16)
-#define DPTXFSIZn_DPTxFSize_GET(_v)             (((_v) >> 16) & 0xffff)
-#define DPTXFSIZn_DPTxFSize_LIMIT               (0xffff)
-#define DPTXFSIZn_DPTxFSize(_x)         ((_x) << 16)
-
-#define DPTXFSIZn_DPTxFStAddr_MASK              (0xffff << 0)
-#define DPTXFSIZn_DPTxFStAddr_SHIFT             (0)
-
-/* Device mode registers */
-#define DCFG                                    HSOTG_REG(0x800)
-
-#define DCFG_EPMisCnt_MASK                      (0x1f << 18)
-#define DCFG_EPMisCnt_SHIFT                     (18)
-#define DCFG_EPMisCnt_LIMIT                     (0x1f)
-#define DCFG_EPMisCnt(_x)                       ((_x) << 18)
-
-#define DCFG_PerFrInt_MASK                      (0x3 << 11)
-#define DCFG_PerFrInt_SHIFT                     (11)
-#define DCFG_PerFrInt_LIMIT                     (0x3)
-#define DCFG_PerFrInt(_x)                       ((_x) << 11)
-
-#define DCFG_DevAddr_MASK                       (0x7f << 4)
-#define DCFG_DevAddr_SHIFT                      (4)
-#define DCFG_DevAddr_LIMIT                      (0x7f)
-#define DCFG_DevAddr(_x)                        ((_x) << 4)
-
-#define DCFG_NZStsOUTHShk                       (1 << 2)
-
-#define DCFG_DevSpd_MASK                        (0x3 << 0)
-#define DCFG_DevSpd_SHIFT                       (0)
-#define DCFG_DevSpd_HS                          (0x0 << 0)
-#define DCFG_DevSpd_FS                          (0x1 << 0)
-#define DCFG_DevSpd_LS                          (0x2 << 0)
-#define DCFG_DevSpd_FS48                        (0x3 << 0)
-
-#define DCTL                                    HSOTG_REG(0x804)
-
-#define DCTL_PWROnPrgDone                       (1 << 11)
-#define DCTL_CGOUTNak                           (1 << 10)
-#define DCTL_SGOUTNak                           (1 << 9)
-#define DCTL_CGNPInNAK                          (1 << 8)
-#define DCTL_SGNPInNAK                          (1 << 7)
-#define DCTL_TstCtl_MASK                        (0x7 << 4)
-#define DCTL_TstCtl_SHIFT                       (4)
-#define DCTL_GOUTNakSts                 (1 << 3)
-#define DCTL_GNPINNakSts                        (1 << 2)
-#define DCTL_SftDiscon                          (1 << 1)
-#define DCTL_RmtWkUpSig                 (1 << 0)
-
-#define DSTS                                    HSOTG_REG(0x808)
-
-#define DSTS_SOFFN_MASK                 (0x3fff << 8)
-#define DSTS_SOFFN_SHIFT                        (8)
-#define DSTS_SOFFN_LIMIT                        (0x3fff)
-#define DSTS_SOFFN(_x)                          ((_x) << 8)
-#define DSTS_ErraticErr                 (1 << 3)
-#define DSTS_EnumSpd_MASK                       (0x3 << 1)
-#define DSTS_EnumSpd_SHIFT                      (1)
-#define DSTS_EnumSpd_HS                 (0x0 << 1)
-#define DSTS_EnumSpd_FS                 (0x1 << 1)
-#define DSTS_EnumSpd_LS                 (0x2 << 1)
-#define DSTS_EnumSpd_FS48                       (0x3 << 1)
-
-#define DSTS_SuspSts                            (1 << 0)
-
-#define DIEPMSK                         HSOTG_REG(0x810)
-
-#define DIEPMSK_TxFIFOEmpty                     (1 << 7)
-#define DIEPMSK_INEPNakEffMsk                   (1 << 6)
-#define DIEPMSK_INTknEPMisMsk                   (1 << 5)
-#define DIEPMSK_INTknTXFEmpMsk                  (1 << 4)
-#define DIEPMSK_TimeOUTMsk                      (1 << 3)
-#define DIEPMSK_AHBErrMsk                       (1 << 2)
-#define DIEPMSK_EPDisbldMsk                     (1 << 1)
-#define DIEPMSK_XferComplMsk                    (1 << 0)
-
-#define DOEPMSK                         HSOTG_REG(0x814)
-
-#define DOEPMSK_Back2BackSetup                  (1 << 6)
-#define DOEPMSK_OUTTknEPdisMsk                  (1 << 4)
-#define DOEPMSK_SetupMsk                        (1 << 3)
-#define DOEPMSK_AHBErrMsk                       (1 << 2)
-#define DOEPMSK_EPDisbldMsk                     (1 << 1)
-#define DOEPMSK_XferComplMsk                    (1 << 0)
-
-#define DAINT                                   HSOTG_REG(0x818)
-#define DAINTMSK                                HSOTG_REG(0x81C)
-
-#define DAINT_OutEP_SHIFT                       (16)
-#define DAINT_OutEP(x)                          (1 << ((x) + 16))
-#define DAINT_InEP(x)                           (1 << (x))
-
-#define DTKNQR1                         HSOTG_REG(0x820)
-#define DTKNQR2                         HSOTG_REG(0x824)
-#define DTKNQR3                         HSOTG_REG(0x830)
-#define DTKNQR4                         HSOTG_REG(0x834)
-
-#define DVBUSDIS                                HSOTG_REG(0x828)
-#define DVBUSPULSE                              HSOTG_REG(0x82C)
-
-#define DIEPCTL0                                HSOTG_REG(0x900)
-#define DOEPCTL0                                HSOTG_REG(0xB00)
-#define DIEPCTL(_a)                     HSOTG_REG(0x900 + ((_a) * 0x20))
-#define DOEPCTL(_a)                     HSOTG_REG(0xB00 + ((_a) * 0x20))
-
-/* EP0 specialness:
- * bits[29..28] - reserved (no SetD0PID, SetD1PID)
- * bits[25..22] - should always be zero, this isn't a periodic endpoint
- * bits[10..0] - MPS setting differenct for EP0
- */
-#define D0EPCTL_MPS_MASK                        (0x3 << 0)
-#define D0EPCTL_MPS_SHIFT                       (0)
-#define D0EPCTL_MPS_64                          (0x0 << 0)
-#define D0EPCTL_MPS_32                          (0x1 << 0)
-#define D0EPCTL_MPS_16                          (0x2 << 0)
-#define D0EPCTL_MPS_8                           (0x3 << 0)
-
-#define DxEPCTL_EPEna                           (1 << 31)
-#define DxEPCTL_EPDis                           (1 << 30)
-#define DxEPCTL_SetD1PID                        (1 << 29)
-#define DxEPCTL_SetOddFr                        (1 << 29)
-#define DxEPCTL_SetD0PID                        (1 << 28)
-#define DxEPCTL_SetEvenFr                       (1 << 28)
-#define DxEPCTL_SNAK                            (1 << 27)
-#define DxEPCTL_CNAK                            (1 << 26)
-#define DxEPCTL_TxFNum_MASK                     (0xf << 22)
-#define DxEPCTL_TxFNum_SHIFT                    (22)
-#define DxEPCTL_TxFNum_LIMIT                    (0xf)
-#define DxEPCTL_TxFNum(_x)                      ((_x) << 22)
-
-#define DxEPCTL_Stall                           (1 << 21)
-#define DxEPCTL_Snp                             (1 << 20)
-#define DxEPCTL_EPType_MASK                     (0x3 << 18)
-#define DxEPCTL_EPType_SHIFT                    (18)
-#define DxEPCTL_EPType_Control                  (0x0 << 18)
-#define DxEPCTL_EPType_Iso                      (0x1 << 18)
-#define DxEPCTL_EPType_Bulk                     (0x2 << 18)
-#define DxEPCTL_EPType_Intterupt                (0x3 << 18)
-
-#define DxEPCTL_NAKsts                          (1 << 17)
-#define DxEPCTL_DPID                            (1 << 16)
-#define DxEPCTL_EOFrNum                 (1 << 16)
-#define DxEPCTL_USBActEp                        (1 << 15)
-#define DxEPCTL_NextEp_MASK                     (0xf << 11)
-#define DxEPCTL_NextEp_SHIFT                    (11)
-#define DxEPCTL_NextEp_LIMIT                    (0xf)
-#define DxEPCTL_NextEp(_x)                      ((_x) << 11)
-
-#define DxEPCTL_MPS_MASK                        (0x7ff << 0)
-#define DxEPCTL_MPS_SHIFT                       (0)
-#define DxEPCTL_MPS_LIMIT                       (0x7ff)
-#define DxEPCTL_MPS(_x)                 ((_x) << 0)
-
-#define DIEPINT(_a)                     HSOTG_REG(0x908 + ((_a) * 0x20))
-#define DOEPINT(_a)                     HSOTG_REG(0xB08 + ((_a) * 0x20))
-
-#define DxEPINT_INEPNakEff                      (1 << 6)
-#define DxEPINT_Back2BackSetup                  (1 << 6)
-#define DxEPINT_INTknEPMis                      (1 << 5)
-#define DxEPINT_INTknTXFEmp                     (1 << 4)
-#define DxEPINT_OUTTknEPdis                     (1 << 4)
-#define DxEPINT_Timeout                 (1 << 3)
-#define DxEPINT_Setup                           (1 << 3)
-#define DxEPINT_AHBErr                          (1 << 2)
-#define DxEPINT_EPDisbld                        (1 << 1)
-#define DxEPINT_XferCompl                       (1 << 0)
-
-#define DIEPTSIZ0                               HSOTG_REG(0x910)
-
-#define DIEPTSIZ0_PktCnt_MASK                   (0x3 << 19)
-#define DIEPTSIZ0_PktCnt_SHIFT                  (19)
-#define DIEPTSIZ0_PktCnt_LIMIT                  (0x3)
-#define DIEPTSIZ0_PktCnt(_x)                    ((_x) << 19)
-
-#define DIEPTSIZ0_XferSize_MASK         (0x7f << 0)
-#define DIEPTSIZ0_XferSize_SHIFT                (0)
-#define DIEPTSIZ0_XferSize_LIMIT                (0x7f)
-#define DIEPTSIZ0_XferSize(_x)                  ((_x) << 0)
-
-#define DOEPTSIZ0                               HSOTG_REG(0xB10)
-#define DOEPTSIZ0_SUPCnt_MASK                   (0x3 << 29)
-#define DOEPTSIZ0_SUPCnt_SHIFT                  (29)
-#define DOEPTSIZ0_SUPCnt_LIMIT                  (0x3)
-#define DOEPTSIZ0_SUPCnt(_x)                    ((_x) << 29)
-
-#define DOEPTSIZ0_PktCnt                        (1 << 19)
-#define DOEPTSIZ0_XferSize_MASK         (0x7f << 0)
-#define DOEPTSIZ0_XferSize_SHIFT                (0)
-
-#define DIEPTSIZ(_a)                    HSOTG_REG(0x910 + ((_a) * 0x20))
-#define DOEPTSIZ(_a)                    HSOTG_REG(0xB10 + ((_a) * 0x20))
-
-#define DxEPTSIZ_MC_MASK                        (0x3 << 29)
-#define DxEPTSIZ_MC_SHIFT                       (29)
-#define DxEPTSIZ_MC_LIMIT                       (0x3)
-#define DxEPTSIZ_MC(_x)                 ((_x) << 29)
-
-#define DxEPTSIZ_PktCnt_MASK                    (0x3ff << 19)
-#define DxEPTSIZ_PktCnt_SHIFT                   (19)
-#define DxEPTSIZ_PktCnt_GET(_v)         (((_v) >> 19) & 0x3ff)
-#define DxEPTSIZ_PktCnt_LIMIT                   (0x3ff)
-#define DxEPTSIZ_PktCnt(_x)                     ((_x) << 19)
-
-#define DxEPTSIZ_XferSize_MASK                  (0x7ffff << 0)
-#define DxEPTSIZ_XferSize_SHIFT         (0)
-#define DxEPTSIZ_XferSize_GET(_v)               (((_v) >> 0) & 0x7ffff)
-#define DxEPTSIZ_XferSize_LIMIT         (0x7ffff)
-#define DxEPTSIZ_XferSize(_x)                   ((_x) << 0)
-
-#define DIEPDMA(_a)                     HSOTG_REG(0x914 + ((_a) * 0x20))
-#define DOEPDMA(_a)                     HSOTG_REG(0xB14 + ((_a) * 0x20))
-#define DTXFSTS(_a)                     HSOTG_REG(0x918 + ((_a) * 0x20))
-
-#define EPFIFO(_a)                      HSOTG_REG(0x1000 + ((_a) * 0x1000))
-
-#endif /* __REGS_USB_HSOTG_H */
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index dd9678f85c58..7987aa049fab 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -117,7 +117,8 @@ static int dprintk(int level, const char *fmt, ...)
                         sizeof(printk_buf)-len, fmt, args);
         va_end(args);
 
-        return pr_debug("%s", printk_buf);
+        pr_debug("%s", printk_buf);
+        return len;
 }
 #else
 static int dprintk(int level, const char *fmt, ...)
diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index ec20a1f50c2d..ff205a7bc55c 100644
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -43,7 +43,7 @@ struct usb_interface_descriptor fsg_intf_desc = {
         .bInterfaceProtocol =   USB_PR_BULK,    /* Adjusted during fsg_bind() */
         .iInterface =           FSG_STRING_INTERFACE,
 };
-EXPORT_SYMBOL(fsg_intf_desc);
+EXPORT_SYMBOL_GPL(fsg_intf_desc);
 
 /*
  * Three full-speed endpoint descriptors: bulk-in, bulk-out, and
@@ -58,7 +58,7 @@ struct usb_endpoint_descriptor fsg_fs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
-EXPORT_SYMBOL(fsg_fs_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_fs_bulk_in_desc);
 
 struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -68,7 +68,7 @@ struct usb_endpoint_descriptor fsg_fs_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         /* wMaxPacketSize set by autoconfiguration */
 };
-EXPORT_SYMBOL(fsg_fs_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_fs_bulk_out_desc);
 
 struct usb_descriptor_header *fsg_fs_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
@@ -76,7 +76,7 @@ struct usb_descriptor_header *fsg_fs_function[] = {
         (struct usb_descriptor_header *) &fsg_fs_bulk_out_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_fs_function);
+EXPORT_SYMBOL_GPL(fsg_fs_function);
 
 
 /*
@@ -95,7 +95,7 @@ struct usb_endpoint_descriptor fsg_hs_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(512),
 };
-EXPORT_SYMBOL(fsg_hs_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_hs_bulk_in_desc);
 
 struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -106,7 +106,7 @@ struct usb_endpoint_descriptor fsg_hs_bulk_out_desc = {
         .wMaxPacketSize =       cpu_to_le16(512),
         .bInterval =            1,      /* NAK every 1 uframe */
 };
-EXPORT_SYMBOL(fsg_hs_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_hs_bulk_out_desc);
 
 
 struct usb_descriptor_header *fsg_hs_function[] = {
@@ -115,7 +115,7 @@ struct usb_descriptor_header *fsg_hs_function[] = {
         (struct usb_descriptor_header *) &fsg_hs_bulk_out_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_hs_function);
+EXPORT_SYMBOL_GPL(fsg_hs_function);
 
 struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -125,7 +125,7 @@ struct usb_endpoint_descriptor fsg_ss_bulk_in_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
-EXPORT_SYMBOL(fsg_ss_bulk_in_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_desc);
 
 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
@@ -133,7 +133,7 @@ struct usb_ss_ep_comp_descriptor fsg_ss_bulk_in_comp_desc = {
 
         /*.bMaxBurst =          DYNAMIC, */
 };
-EXPORT_SYMBOL(fsg_ss_bulk_in_comp_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_in_comp_desc);
 
 struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
         .bLength =              USB_DT_ENDPOINT_SIZE,
@@ -143,7 +143,7 @@ struct usb_endpoint_descriptor fsg_ss_bulk_out_desc = {
         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
         .wMaxPacketSize =       cpu_to_le16(1024),
 };
-EXPORT_SYMBOL(fsg_ss_bulk_out_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_desc);
 
 struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
         .bLength =              sizeof(fsg_ss_bulk_in_comp_desc),
@@ -151,7 +151,7 @@ struct usb_ss_ep_comp_descriptor fsg_ss_bulk_out_comp_desc = {
 
         /*.bMaxBurst =          DYNAMIC, */
 };
-EXPORT_SYMBOL(fsg_ss_bulk_out_comp_desc);
+EXPORT_SYMBOL_GPL(fsg_ss_bulk_out_comp_desc);
 
 struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_intf_desc,
@@ -161,7 +161,7 @@ struct usb_descriptor_header *fsg_ss_function[] = {
         (struct usb_descriptor_header *) &fsg_ss_bulk_out_comp_desc,
         NULL,
 };
-EXPORT_SYMBOL(fsg_ss_function);
+EXPORT_SYMBOL_GPL(fsg_ss_function);
 
 
  /*-------------------------------------------------------------------------*/
@@ -179,7 +179,7 @@ void fsg_lun_close(struct fsg_lun *curlun)
                 curlun->filp = NULL;
         }
 }
-EXPORT_SYMBOL(fsg_lun_close);
+EXPORT_SYMBOL_GPL(fsg_lun_close);
 
 int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
 {
@@ -278,7 +278,7 @@ out:
         fput(filp);
         return rc;
 }
-EXPORT_SYMBOL(fsg_lun_open);
+EXPORT_SYMBOL_GPL(fsg_lun_open);
 
 
 /*-------------------------------------------------------------------------*/
@@ -295,7 +295,7 @@ int fsg_lun_fsync_sub(struct fsg_lun *curlun)
                 return 0;
         return vfs_fsync(filp, 1);
 }
-EXPORT_SYMBOL(fsg_lun_fsync_sub);
+EXPORT_SYMBOL_GPL(fsg_lun_fsync_sub);
 
 void store_cdrom_address(u8 *dest, int msf, u32 addr)
 {
@@ -314,7 +314,7 @@ void store_cdrom_address(u8 *dest, int msf, u32 addr)
                 put_unaligned_be32(addr, dest);
         }
 }
-EXPORT_SYMBOL(store_cdrom_address);
+EXPORT_SYMBOL_GPL(store_cdrom_address);
 
 /*-------------------------------------------------------------------------*/
 
@@ -325,13 +325,13 @@ ssize_t fsg_show_ro(struct fsg_lun *curlun, char *buf)
                                   ? curlun->ro
                                   : curlun->initially_ro);
 }
-EXPORT_SYMBOL(fsg_show_ro);
+EXPORT_SYMBOL_GPL(fsg_show_ro);
 
 ssize_t fsg_show_nofua(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->nofua);
 }
-EXPORT_SYMBOL(fsg_show_nofua);
+EXPORT_SYMBOL_GPL(fsg_show_nofua);
 
 ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                       char *buf)
@@ -357,19 +357,19 @@ ssize_t fsg_show_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
         up_read(filesem);
         return rc;
 }
-EXPORT_SYMBOL(fsg_show_file);
+EXPORT_SYMBOL_GPL(fsg_show_file);
 
 ssize_t fsg_show_cdrom(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->cdrom);
 }
-EXPORT_SYMBOL(fsg_show_cdrom);
+EXPORT_SYMBOL_GPL(fsg_show_cdrom);
 
 ssize_t fsg_show_removable(struct fsg_lun *curlun, char *buf)
 {
         return sprintf(buf, "%u\n", curlun->removable);
 }
-EXPORT_SYMBOL(fsg_show_removable);
+EXPORT_SYMBOL_GPL(fsg_show_removable);
 
 /*
  * The caller must hold fsg->filesem for reading when calling this function.
@@ -410,7 +410,7 @@ ssize_t fsg_store_ro(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 
         return rc;
 }
-EXPORT_SYMBOL(fsg_store_ro);
+EXPORT_SYMBOL_GPL(fsg_store_ro);
 
 ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 {
@@ -429,7 +429,7 @@ ssize_t fsg_store_nofua(struct fsg_lun *curlun, const char *buf, size_t count)
 
         return count;
 }
-EXPORT_SYMBOL(fsg_store_nofua);
+EXPORT_SYMBOL_GPL(fsg_store_nofua);
 
 ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                        const char *buf, size_t count)
@@ -460,7 +460,7 @@ ssize_t fsg_store_file(struct fsg_lun *curlun, struct rw_semaphore *filesem,
         up_write(filesem);
         return (rc < 0 ? rc : count);
 }
-EXPORT_SYMBOL(fsg_store_file);
+EXPORT_SYMBOL_GPL(fsg_store_file);
 
 ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
                         const char *buf, size_t count)
@@ -483,7 +483,7 @@ ssize_t fsg_store_cdrom(struct fsg_lun *curlun, struct rw_semaphore *filesem,
 
         return ret;
 }
-EXPORT_SYMBOL(fsg_store_cdrom);
+EXPORT_SYMBOL_GPL(fsg_store_cdrom);
 
 ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
                             size_t count)
@@ -499,6 +499,6 @@ ssize_t fsg_store_removable(struct fsg_lun *curlun, const char *buf,
 
         return count;
 }
-EXPORT_SYMBOL(fsg_store_removable);
+EXPORT_SYMBOL_GPL(fsg_store_removable);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index f058c0368d61..49481e0a3382 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -1383,10 +1383,8 @@ static struct se_node_acl *usbg_alloc_fabric_acl(struct se_portal_group *se_tpg)
         struct usbg_nacl *nacl;
 
         nacl = kzalloc(sizeof(struct usbg_nacl), GFP_KERNEL);
-        if (!nacl) {
-                printk(KERN_ERR "Unable to allocate struct usbg_nacl\n");
+        if (!nacl)
                 return NULL;
-        }
 
         return &nacl->se_node_acl;
 }
@@ -1561,10 +1559,8 @@ static struct se_portal_group *usbg_make_tpg(
         }
 
         tpg = kzalloc(sizeof(struct usbg_tpg), GFP_KERNEL);
-        if (!tpg) {
-                printk(KERN_ERR "Unable to allocate struct usbg_tpg");
+        if (!tpg)
                 return ERR_PTR(-ENOMEM);
-        }
         mutex_init(&tpg->tpg_mutex);
         atomic_set(&tpg->tpg_port_count, 0);
         tpg->workqueue = alloc_workqueue("tcm_usb_gadget", 0, 1);
@@ -1613,10 +1609,8 @@ static struct se_wwn *usbg_make_tport(
                 return ERR_PTR(-EINVAL);
 
         tport = kzalloc(sizeof(struct usbg_tport), GFP_KERNEL);
-        if (!(tport)) {
-                printk(KERN_ERR "Unable to allocate struct usbg_tport");
+        if (!(tport))
                 return ERR_PTR(-ENOMEM);
-        }
         tport->tport_wwpn = wwpn;
         snprintf(tport->tport_name, sizeof(tport->tport_name), "%s", wnn_name);
         return &tport->tport_wwn;
@@ -1727,10 +1721,8 @@ static int tcm_usbg_make_nexus(struct usbg_tpg *tpg, char *name)
 
         ret = -ENOMEM;
         tv_nexus = kzalloc(sizeof(*tv_nexus), GFP_KERNEL);
-        if (!tv_nexus) {
-                pr_err("Unable to allocate struct tcm_vhost_nexus\n");
+        if (!tv_nexus)
                 goto err_unlock;
-        }
         tv_nexus->tvn_se_sess = transport_init_session(TARGET_PROT_NORMAL);
         if (IS_ERR(tv_nexus->tvn_se_sess))
                 goto err_free;
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index b7d4f82872b7..fe0880d0873e 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -818,7 +818,7 @@ struct eth_dev *gether_setup_name(struct usb_gadget *g,
 
         return dev;
 }
-EXPORT_SYMBOL(gether_setup_name);
+EXPORT_SYMBOL_GPL(gether_setup_name);
 
 struct net_device *gether_setup_name_default(const char *netname)
 {
@@ -855,7 +855,7 @@ struct net_device *gether_setup_name_default(const char *netname)
 
         return net;
 }
-EXPORT_SYMBOL(gether_setup_name_default);
+EXPORT_SYMBOL_GPL(gether_setup_name_default);
 
 int gether_register_netdev(struct net_device *net)
 {
@@ -893,7 +893,7 @@ int gether_register_netdev(struct net_device *net)
 
         return status;
 }
-EXPORT_SYMBOL(gether_register_netdev);
+EXPORT_SYMBOL_GPL(gether_register_netdev);
 
 void gether_set_gadget(struct net_device *net, struct usb_gadget *g)
 {
@@ -903,7 +903,7 @@ void gether_set_gadget(struct net_device *net, struct usb_gadget *g)
         dev->gadget = g;
         SET_NETDEV_DEV(net, &g->dev);
 }
-EXPORT_SYMBOL(gether_set_gadget);
+EXPORT_SYMBOL_GPL(gether_set_gadget);
 
 int gether_set_dev_addr(struct net_device *net, const char *dev_addr)
 {
@@ -916,7 +916,7 @@ int gether_set_dev_addr(struct net_device *net, const char *dev_addr)
         memcpy(dev->dev_mac, new_addr, ETH_ALEN);
         return 0;
 }
-EXPORT_SYMBOL(gether_set_dev_addr);
+EXPORT_SYMBOL_GPL(gether_set_dev_addr);
 
 int gether_get_dev_addr(struct net_device *net, char *dev_addr, int len)
 {
@@ -925,7 +925,7 @@ int gether_get_dev_addr(struct net_device *net, char *dev_addr, int len)
         dev = netdev_priv(net);
         return get_ether_addr_str(dev->dev_mac, dev_addr, len);
 }
-EXPORT_SYMBOL(gether_get_dev_addr);
+EXPORT_SYMBOL_GPL(gether_get_dev_addr);
 
 int gether_set_host_addr(struct net_device *net, const char *host_addr)
 {
@@ -938,7 +938,7 @@ int gether_set_host_addr(struct net_device *net, const char *host_addr)
         memcpy(dev->host_mac, new_addr, ETH_ALEN);
         return 0;
 }
-EXPORT_SYMBOL(gether_set_host_addr);
+EXPORT_SYMBOL_GPL(gether_set_host_addr);
 
 int gether_get_host_addr(struct net_device *net, char *host_addr, int len)
 {
@@ -947,7 +947,7 @@ int gether_get_host_addr(struct net_device *net, char *host_addr, int len)
         dev = netdev_priv(net);
         return get_ether_addr_str(dev->host_mac, host_addr, len);
 }
-EXPORT_SYMBOL(gether_get_host_addr);
+EXPORT_SYMBOL_GPL(gether_get_host_addr);
 
 int gether_get_host_addr_cdc(struct net_device *net, char *host_addr, int len)
 {
@@ -961,7 +961,7 @@ int gether_get_host_addr_cdc(struct net_device *net, char *host_addr, int len)
 
         return strlen(host_addr);
 }
-EXPORT_SYMBOL(gether_get_host_addr_cdc);
+EXPORT_SYMBOL_GPL(gether_get_host_addr_cdc);
 
 void gether_get_host_addr_u8(struct net_device *net, u8 host_mac[ETH_ALEN])
 {
@@ -970,7 +970,7 @@ void gether_get_host_addr_u8(struct net_device *net, u8 host_mac[ETH_ALEN])
         dev = netdev_priv(net);
         memcpy(host_mac, dev->host_mac, ETH_ALEN);
 }
-EXPORT_SYMBOL(gether_get_host_addr_u8);
+EXPORT_SYMBOL_GPL(gether_get_host_addr_u8);
 
 void gether_set_qmult(struct net_device *net, unsigned qmult)
 {
@@ -979,7 +979,7 @@ void gether_set_qmult(struct net_device *net, unsigned qmult)
         dev = netdev_priv(net);
         dev->qmult = qmult;
 }
-EXPORT_SYMBOL(gether_set_qmult);
+EXPORT_SYMBOL_GPL(gether_set_qmult);
 
 unsigned gether_get_qmult(struct net_device *net)
 {
@@ -988,7 +988,7 @@ unsigned gether_get_qmult(struct net_device *net)
         dev = netdev_priv(net);
         return dev->qmult;
 }
-EXPORT_SYMBOL(gether_get_qmult);
+EXPORT_SYMBOL_GPL(gether_get_qmult);
 
 int gether_get_ifname(struct net_device *net, char *name, int len)
 {
@@ -997,7 +997,7 @@ int gether_get_ifname(struct net_device *net, char *name, int len)
         rtnl_unlock();
         return strlen(name);
 }
-EXPORT_SYMBOL(gether_get_ifname);
+EXPORT_SYMBOL_GPL(gether_get_ifname);
 
 /**
  * gether_cleanup - remove Ethernet-over-USB device
@@ -1014,7 +1014,7 @@ void gether_cleanup(struct eth_dev *dev)
         flush_work(&dev->work);
         free_netdev(dev->net);
 }
-EXPORT_SYMBOL(gether_cleanup);
+EXPORT_SYMBOL_GPL(gether_cleanup);
 
 /**
  * gether_connect - notify network layer that USB link is active
@@ -1095,7 +1095,7 @@ fail0:
                 return ERR_PTR(result);
         return dev->net;
 }
-EXPORT_SYMBOL(gether_connect);
+EXPORT_SYMBOL_GPL(gether_connect);
 
 /**
  * gether_disconnect - notify network layer that USB link is inactive
@@ -1166,7 +1166,7 @@ void gether_disconnect(struct gether *link)
         dev->port_usb = NULL;
         spin_unlock(&dev->lock);
 }
-EXPORT_SYMBOL(gether_disconnect);
+EXPORT_SYMBOL_GPL(gether_disconnect);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("David Brownell");
diff --git a/drivers/usb/gadget/u_f.c b/drivers/usb/gadget/u_f.c
index 63b6642c162b..c6276f0268ae 100644
--- a/drivers/usb/gadget/u_f.c
+++ b/drivers/usb/gadget/u_f.c
@@ -29,4 +29,4 @@ struct usb_request *alloc_ep_req(struct usb_ep *ep, int len, int default_len)
         }
         return req;
 }
-EXPORT_SYMBOL(alloc_ep_req);
+EXPORT_SYMBOL_GPL(alloc_ep_req);
diff --git a/drivers/usb/gadget/u_f.h b/drivers/usb/gadget/u_f.h
index 71034c061fca..1d5f0eb68552 100644
--- a/drivers/usb/gadget/u_f.h
+++ b/drivers/usb/gadget/u_f.h
@@ -16,6 +16,32 @@
 #ifndef __U_F_H__
 #define __U_F_H__
 
+/* Variable Length Array Macros **********************************************/
+#define vla_group(groupname) size_t groupname##__next = 0
+#define vla_group_size(groupname) groupname##__next
+
+#define vla_item(groupname, type, name, n) \
+        size_t groupname##_##name##__offset = ({                               \
+                size_t align_mask = __alignof__(type) - 1;                     \
+                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
+                size_t size = (n) * sizeof(type);                              \
+                groupname##__next = offset + size;                             \
+                offset;                                                        \
+        })
+
+#define vla_item_with_sz(groupname, type, name, n) \
+        size_t groupname##_##name##__sz = (n) * sizeof(type);                  \
+        size_t groupname##_##name##__offset = ({                               \
+                size_t align_mask = __alignof__(type) - 1;                     \
+                size_t offset = (groupname##__next + align_mask) & ~align_mask;\
+                size_t size = groupname##_##name##__sz;                        \
+                groupname##__next = offset + size;                             \
+                offset;                                                        \
+        })
+
+#define vla_ptr(ptr, groupname, name) \
+        ((void *) ((char *)ptr + groupname##_##name##__offset))
+
 struct usb_ep;
 struct usb_request;
 
diff --git a/drivers/usb/gadget/u_os_desc.h b/drivers/usb/gadget/u_os_desc.h
new file mode 100644
index 000000000000..ea5cf8c2da28
--- /dev/null
+++ b/drivers/usb/gadget/u_os_desc.h
@@ -0,0 +1,90 @@
+/*
+ * u_os_desc.h
+ *
+ * Utility definitions for "OS Descriptors" support
+ *
+ * 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_OS_DESC_H__
+#define __U_OS_DESC_H__
+
+#include <asm/unaligned.h>
+#include <linux/nls.h>
+
+#define USB_EXT_PROP_DW_SIZE                    0
+#define USB_EXT_PROP_DW_PROPERTY_DATA_TYPE      4
+#define USB_EXT_PROP_W_PROPERTY_NAME_LENGTH     8
+#define USB_EXT_PROP_B_PROPERTY_NAME            10
+#define USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH    10
+#define USB_EXT_PROP_B_PROPERTY_DATA            14
+
+#define USB_EXT_PROP_RESERVED                   0
+#define USB_EXT_PROP_UNICODE                    1
+#define USB_EXT_PROP_UNICODE_ENV                2
+#define USB_EXT_PROP_BINARY                     3
+#define USB_EXT_PROP_LE32                       4
+#define USB_EXT_PROP_BE32                       5
+#define USB_EXT_PROP_UNICODE_LINK               6
+#define USB_EXT_PROP_UNICODE_MULTI              7
+
+static inline void usb_ext_prop_put_size(u8 *buf, int dw_size)
+{
+        put_unaligned_le32(dw_size, &buf[USB_EXT_PROP_DW_SIZE]);
+}
+
+static inline void usb_ext_prop_put_type(u8 *buf, int type)
+{
+        put_unaligned_le32(type, &buf[USB_EXT_PROP_DW_PROPERTY_DATA_TYPE]);
+}
+
+static inline int usb_ext_prop_put_name(u8 *buf, const char *name, int pnl)
+{
+        int result;
+
+        put_unaligned_le16(pnl, &buf[USB_EXT_PROP_W_PROPERTY_NAME_LENGTH]);
+        result = utf8s_to_utf16s(name, strlen(name), UTF16_LITTLE_ENDIAN,
+                (wchar_t *) &buf[USB_EXT_PROP_B_PROPERTY_NAME], pnl - 2);
+        if (result < 0)
+                return result;
+
+        put_unaligned_le16(0, &buf[USB_EXT_PROP_B_PROPERTY_NAME + pnl]);
+
+        return pnl;
+}
+
+static inline void usb_ext_prop_put_binary(u8 *buf, int pnl, const u8 *data,
+                                           int data_len)
+{
+        put_unaligned_le32(data_len,
+                           &buf[USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH + pnl]);
+        memcpy(&buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl], data, data_len);
+}
+
+static inline int usb_ext_prop_put_unicode(u8 *buf, int pnl, const char *string,
+                                           int data_len)
+{
+        int result;
+        put_unaligned_le32(data_len,
+                        &buf[USB_EXT_PROP_DW_PROPERTY_DATA_LENGTH + pnl]);
+
+        result = utf8s_to_utf16s(string, data_len >> 1, UTF16_LITTLE_ENDIAN,
+                        (wchar_t *) &buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl],
+                        data_len - 2);
+        if (result < 0)
+                return result;
+
+        put_unaligned_le16(0,
+                        &buf[USB_EXT_PROP_B_PROPERTY_DATA + pnl + data_len]);
+
+        return data_len;
+}
+
+#endif /* __U_OS_DESC_H__ */
diff --git a/drivers/usb/gadget/u_rndis.h b/drivers/usb/gadget/u_rndis.h
index 7291b15c9dce..e902aa42a297 100644
--- a/drivers/usb/gadget/u_rndis.h
+++ b/drivers/usb/gadget/u_rndis.h
@@ -26,6 +26,9 @@ struct f_rndis_opts {
         bool                            bound;
         bool                            borrowed_net;
 
+        struct usb_os_desc              rndis_os_desc;
+        char                            rndis_ext_compat_id[16];
+
         /*
          * Read/write access to configfs attributes is handled by configfs.
          *
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index 27768a7d986a..b0d98172bc07 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -428,6 +428,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
         list_for_each_entry(udc, &udc_list, list)
                 if (udc->driver == driver) {
                         usb_gadget_remove_driver(udc);
+                        usb_gadget_set_state(udc->gadget,
+                                        USB_STATE_NOTATTACHED);
                         ret = 0;
                         break;
                 }
diff --git a/drivers/usb/gadget/uvc_queue.c b/drivers/usb/gadget/uvc_queue.c
index 0bb5d50075de..1c29bc954db9 100644
--- a/drivers/usb/gadget/uvc_queue.c
+++ b/drivers/usb/gadget/uvc_queue.c
@@ -20,6 +20,7 @@
 #include <linux/vmalloc.h>
 #include <linux/wait.h>
 
+#include <media/v4l2-common.h>
 #include <media/videobuf2-vmalloc.h>
 
 #include "uvc.h"
@@ -136,6 +137,8 @@ static int uvc_queue_init(struct uvc_video_queue *queue,
         queue->queue.buf_struct_size = sizeof(struct uvc_buffer);
         queue->queue.ops = &uvc_queue_qops;
         queue->queue.mem_ops = &vb2_vmalloc_memops;
+        queue->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
+                                     | V4L2_BUF_FLAG_TSTAMP_SRC_EOF;
         ret = vb2_queue_init(&queue->queue);
         if (ret)
                 return ret;
@@ -379,14 +382,9 @@ static struct uvc_buffer *uvc_queue_next_buffer(struct uvc_video_queue *queue,
         else
                 nextbuf = NULL;
 
-        /*
-         * FIXME: with videobuf2, the sequence number or timestamp fields
-         * are valid only for video capture devices and the UVC gadget usually
-         * is a video output device. Keeping these until the specs are clear on
-         * this aspect.
-         */
+        buf->buf.v4l2_buf.field = V4L2_FIELD_NONE;
         buf->buf.v4l2_buf.sequence = queue->sequence++;
-        do_gettimeofday(&buf->buf.v4l2_buf.timestamp);
+        v4l2_get_timestamp(&buf->buf.v4l2_buf.timestamp);
 
         vb2_set_plane_payload(&buf->buf, 0, buf->bytesused);
         vb2_buffer_done(&buf->buf, VB2_BUF_STATE_DONE);
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 3d9e54062d62..61b7817bd66b 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -29,6 +29,14 @@ if USB_XHCI_HCD
 config USB_XHCI_PLATFORM
         tristate
 
+config USB_XHCI_MVEBU
+        tristate "xHCI support for Marvell Armada 375/38x"
+        select USB_XHCI_PLATFORM
+        depends on ARCH_MVEBU || COMPILE_TEST
+        ---help---
+          Say 'Y' to enable the support for the xHCI host controller
+          found in Marvell Armada 375/38x ARM SOCs.
+
 endif # USB_XHCI_HCD
 
 config USB_EHCI_HCD
@@ -170,7 +178,6 @@ config USB_EHCI_MSM
         tristate "Support for Qualcomm QSD/MSM on-chip EHCI USB controller"
         depends on ARCH_MSM
         select USB_EHCI_ROOT_HUB_TT
-        select USB_MSM_OTG
         ---help---
           Enables support for the USB Host controller present on the
           Qualcomm chipsets. Root Hub has inbuilt TT.
@@ -343,10 +350,19 @@ config USB_FOTG210_HCD
           To compile this driver as a module, choose M here: the
           module will be called fotg210-hcd.
 
+config USB_MAX3421_HCD
+        tristate "MAX3421 HCD (USB-over-SPI) support"
+        depends on USB && SPI
+        ---help---
+          The Maxim MAX3421E chip supports standard USB 2.0-compliant
+          full-speed devices either in host or peripheral mode.  This
+          driver supports the host-mode of the MAX3421E only.
+
+          To compile this driver as a module, choose M here: the module will
+          be called max3421-hcd.
+
 config USB_OHCI_HCD
         tristate "OHCI HCD (USB 1.1) support"
-        select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
-        depends on USB_ISP1301 || !ARCH_LPC32XX
         ---help---
           The Open Host Controller Interface (OHCI) is a standard for accessing
           USB 1.1 host controller hardware.  It does more in hardware than Intel's
@@ -365,6 +381,7 @@ if USB_OHCI_HCD
 config USB_OHCI_HCD_OMAP1
         tristate "OHCI support for OMAP1/2 chips"
         depends on ARCH_OMAP1
+        depends on ISP1301_OMAP || !(MACH_OMAP_H2 || MACH_OMAP_H3)
         default y
         ---help---
           Enables support for the OHCI controller on OMAP1/2 chips.
@@ -388,6 +405,7 @@ config USB_OHCI_HCD_S3C2410
 config USB_OHCI_HCD_LPC32XX
         tristate "Support for LPC on-chip OHCI USB controller"
         depends on USB_OHCI_HCD && ARCH_LPC32XX
+        depends on USB_ISP1301
         default y
         ---help---
           Enables support for the on-chip OHCI controller on
@@ -417,6 +435,16 @@ config USB_OHCI_HCD_OMAP3
           Enables support for the on-chip OHCI controller on
           OMAP3 and later chips.
 
+config USB_OHCI_HCD_DAVINCI
+        bool "OHCI support for TI DaVinci DA8xx"
+        depends on ARCH_DAVINCI_DA8XX
+        depends on USB_OHCI_HCD=y
+        default y
+        help
+          Enables support for the DaVinci DA8xx integrated OHCI
+          controller. This driver cannot currently be a loadable
+          module because it lacks a proper PHY abstraction.
+
 config USB_OHCI_ATH79
         bool "USB OHCI support for the Atheros AR71XX/AR7240 SoCs (DEPRECATED)"
         depends on (SOC_AR71XX || SOC_AR724X)
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 7530468c9a4f..af89a903d97e 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -19,6 +19,9 @@ xhci-hcd-$(CONFIG_PCI)	+= xhci-pci.o
 
 ifneq ($(CONFIG_USB_XHCI_PLATFORM), )
         xhci-hcd-y              += xhci-plat.o
+ifneq ($(CONFIG_USB_XHCI_MVEBU), )
+        xhci-hcd-y              += xhci-mvebu.o
+endif
 endif
 
 obj-$(CONFIG_USB_WHCI_HCD)      += whci/
@@ -70,3 +73,4 @@ obj-$(CONFIG_USB_HCD_BCMA)	+= bcma-hcd.o
 obj-$(CONFIG_USB_HCD_SSB)       += ssb-hcd.o
 obj-$(CONFIG_USB_FUSBH200_HCD)  += fusbh200-hcd.o
 obj-$(CONFIG_USB_FOTG210_HCD)   += fotg210-hcd.o
+obj-$(CONFIG_USB_MAX3421_HCD)   += max3421-hcd.o
diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index 7f425acd9be5..d1c76216350f 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -19,6 +19,7 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #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>
@@ -42,17 +43,106 @@
 static const char hcd_name[] = "ehci-exynos";
 static struct hc_driver __read_mostly exynos_ehci_hc_driver;
 
+#define PHY_NUMBER 3
+
 struct exynos_ehci_hcd {
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
+        struct phy *phy_g[PHY_NUMBER];
 };
 
 #define to_exynos_ehci(hcd) (struct exynos_ehci_hcd *)(hcd_to_ehci(hcd)->priv)
 
-static void exynos_setup_vbus_gpio(struct platform_device *pdev)
+static int exynos_ehci_get_phy(struct device *dev,
+                                struct exynos_ehci_hcd *exynos_ehci)
+{
+        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;
+        }
+
+        for_each_available_child_of_node(dev->of_node, child) {
+                ret = of_property_read_u32(child, "reg", &phy_number);
+                if (ret) {
+                        dev_err(dev, "Failed to parse device tree\n");
+                        of_node_put(child);
+                        return ret;
+                }
+
+                if (phy_number >= PHY_NUMBER) {
+                        dev_err(dev, "Invalid number of PHYs\n");
+                        of_node_put(child);
+                        return -EINVAL;
+                }
+
+                phy = devm_of_phy_get(dev, child, 0);
+                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");
+                                return ret;
+                        }
+                        dev_dbg(dev, "Failed to get usb2 phy\n");
+                }
+                exynos_ehci->phy_g[phy_number] = phy;
+        }
+
+        return ret;
+}
+
+static int exynos_ehci_phy_enable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
+        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 (ret)
+                for (i--; i >= 0; i--)
+                        if (!IS_ERR(exynos_ehci->phy_g[i]))
+                                phy_power_off(exynos_ehci->phy_g[i]);
+
+        return ret;
+}
+
+static void exynos_ehci_phy_disable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(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]);
+}
+
+static void exynos_setup_vbus_gpio(struct device *dev)
 {
-        struct device *dev = &pdev->dev;
         int err;
         int gpio;
 
@@ -75,7 +165,6 @@ static int exynos_ehci_probe(struct platform_device *pdev)
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
         struct resource *res;
-        struct usb_phy *phy;
         int irq;
         int err;
 
@@ -88,7 +177,7 @@ static int exynos_ehci_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        exynos_setup_vbus_gpio(pdev);
+        exynos_setup_vbus_gpio(&pdev->dev);
 
         hcd = usb_create_hcd(&exynos_ehci_hc_driver,
                              &pdev->dev, dev_name(&pdev->dev));
@@ -102,15 +191,9 @@ static int exynos_ehci_probe(struct platform_device *pdev)
                                         "samsung,exynos5440-ehci"))
                 goto skip_phy;
 
-        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(phy)) {
-                usb_put_hcd(hcd);
-                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                return -EPROBE_DEFER;
-        } else {
-                exynos_ehci->phy = phy;
-                exynos_ehci->otg = phy->otg;
-        }
+        err = exynos_ehci_get_phy(&pdev->dev, exynos_ehci);
+        if (err)
+                goto fail_clk;
 
 skip_phy:
 
@@ -135,10 +218,9 @@ skip_phy:
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto fail_io;
         }
 
@@ -152,8 +234,11 @@ skip_phy:
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_init(exynos_ehci->phy);
+        err = exynos_ehci_phy_enable(&pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to enable USB phy\n");
+                goto fail_io;
+        }
 
         ehci = hcd_to_ehci(hcd);
         ehci->caps = hcd->regs;
@@ -173,8 +258,7 @@ skip_phy:
         return 0;
 
 fail_add_hcd:
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(&pdev->dev);
 fail_io:
         clk_disable_unprepare(exynos_ehci->clk);
 fail_clk:
@@ -192,8 +276,7 @@ static int exynos_ehci_remove(struct platform_device *pdev)
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
 
@@ -218,8 +301,7 @@ static int exynos_ehci_suspend(struct device *dev)
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_shutdown(exynos_ehci->phy);
+        exynos_ehci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ehci->clk);
 
@@ -230,14 +312,19 @@ static int exynos_ehci_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ehci_hcd *exynos_ehci = to_exynos_ehci(hcd);
+        int ret;
 
         clk_prepare_enable(exynos_ehci->clk);
 
         if (exynos_ehci->otg)
                 exynos_ehci->otg->set_host(exynos_ehci->otg, &hcd->self);
 
-        if (exynos_ehci->phy)
-                usb_phy_init(exynos_ehci->phy);
+        ret = exynos_ehci_phy_enable(dev);
+        if (ret) {
+                dev_err(dev, "Failed to enable USB phy\n");
+                clk_disable_unprepare(exynos_ehci->clk);
+                return ret;
+        }
 
         /* DMA burst Enable */
         writel(EHCI_INSNREG00_ENABLE_DMA_BURST, EHCI_INSNREG00(hcd->regs));
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 7ae0c4d51741..cc305c71ac3d 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -33,15 +33,6 @@
 
 #ifdef  CONFIG_PM
 
-static int ehci_hub_control(
-        struct usb_hcd  *hcd,
-        u16             typeReq,
-        u16             wValue,
-        u16             wIndex,
-        char            *buf,
-        u16             wLength
-);
-
 static int persist_enabled_on_companion(struct usb_device *udev, void *unused)
 {
         return !udev->maxchild && udev->persist_enabled &&
@@ -865,7 +856,7 @@ cleanup:
 #endif /* CONFIG_USB_HCD_TEST_MODE */
 /*-------------------------------------------------------------------------*/
 
-static int ehci_hub_control (
+int ehci_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -1285,6 +1276,7 @@ error_exit:
         spin_unlock_irqrestore (&ehci->lock, flags);
         return retval;
 }
+EXPORT_SYMBOL_GPL(ehci_hub_control);
 
 static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
 {
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index f341651d6f6c..982c09bebe0f 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -96,10 +96,9 @@ static int ehci_msm_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "ioremap failed\n");
-                ret = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                ret = PTR_ERR(hcd->regs);
                 goto put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index bd61612a7251..08147c35f836 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -176,11 +176,9 @@ static int mv_ehci_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ehci_mv->phy_regs = devm_ioremap(&pdev->dev, r->start,
-                                         resource_size(r));
-        if (!ehci_mv->phy_regs) {
-                dev_err(&pdev->dev, "failed to map phy I/O memory\n");
-                retval = -EFAULT;
+        ehci_mv->phy_regs = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(ehci_mv->phy_regs)) {
+                retval = PTR_ERR(ehci_mv->phy_regs);
                 goto err_put_hcd;
         }
 
@@ -191,11 +189,9 @@ static int mv_ehci_probe(struct platform_device *pdev)
                 goto err_put_hcd;
         }
 
-        ehci_mv->cap_regs = devm_ioremap(&pdev->dev, r->start,
-                                         resource_size(r));
-        if (ehci_mv->cap_regs == NULL) {
-                dev_err(&pdev->dev, "failed to map I/O memory\n");
-                retval = -EFAULT;
+        ehci_mv->cap_regs = devm_ioremap_resource(&pdev->dev, r);
+        if (IS_ERR(ehci_mv->cap_regs)) {
+                retval = PTR_ERR(ehci_mv->cap_regs);
                 goto err_put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 30d35e5e503a..22e15cab8ea5 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -15,6 +15,7 @@
 #include <linux/clk.h>
 #include <linux/platform_data/usb-ehci-orion.h>
 #include <linux/of.h>
+#include <linux/phy/phy.h>
 #include <linux/of_device.h>
 #include <linux/of_irq.h>
 #include <linux/usb.h>
@@ -42,6 +43,13 @@
 
 #define DRIVER_DESC "EHCI orion driver"
 
+#define hcd_to_orion_priv(h) ((struct orion_ehci_hcd *)hcd_to_ehci(h)->priv)
+
+struct orion_ehci_hcd {
+        struct clk *clk;
+        struct phy *phy;
+};
+
 static const char hcd_name[] = "ehci-orion";
 
 static struct hc_driver __read_mostly ehci_orion_hc_driver;
@@ -137,6 +145,10 @@ ehci_orion_conf_mbus_windows(struct usb_hcd *hcd,
         }
 }
 
+static const struct ehci_driver_overrides orion_overrides __initconst = {
+        .extra_priv_size =      sizeof(struct orion_ehci_hcd),
+};
+
 static int ehci_orion_drv_probe(struct platform_device *pdev)
 {
         struct orion_ehci_data *pd = dev_get_platdata(&pdev->dev);
@@ -144,26 +156,23 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
         struct resource *res;
         struct usb_hcd *hcd;
         struct ehci_hcd *ehci;
-        struct clk *clk;
         void __iomem *regs;
         int irq, err;
         enum orion_ehci_phy_ver phy_version;
+        struct orion_ehci_hcd *priv;
 
         if (usb_disabled())
                 return -ENODEV;
 
         pr_debug("Initializing Orion-SoC USB Host Controller\n");
 
-        if (pdev->dev.of_node)
-                irq = irq_of_parse_and_map(pdev->dev.of_node, 0);
-        else
-                irq = platform_get_irq(pdev, 0);
+        irq = platform_get_irq(pdev, 0);
         if (irq <= 0) {
                 dev_err(&pdev->dev,
                         "Found HC with no IRQ. Check %s setup!\n",
                         dev_name(&pdev->dev));
                 err = -ENODEV;
-                goto err1;
+                goto err;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -172,7 +181,7 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
                         "Found HC with no register addr. Check %s setup!\n",
                         dev_name(&pdev->dev));
                 err = -ENODEV;
-                goto err1;
+                goto err;
         }
 
         /*
@@ -182,25 +191,19 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
          */
         err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
         if (err)
-                goto err1;
+                goto err;
 
         regs = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(regs)) {
                 err = PTR_ERR(regs);
-                goto err1;
+                goto err;
         }
 
-        /* Not all platforms can gate the clock, so it is not
-           an error if the clock does not exists. */
-        clk = devm_clk_get(&pdev->dev, NULL);
-        if (!IS_ERR(clk))
-                clk_prepare_enable(clk);
-
         hcd = usb_create_hcd(&ehci_orion_hc_driver,
                         &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
                 err = -ENOMEM;
-                goto err2;
+                goto err;
         }
 
         hcd->rsrc_start = res->start;
@@ -211,6 +214,29 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
         ehci->caps = hcd->regs + 0x100;
         hcd->has_tt = 1;
 
+        priv = hcd_to_orion_priv(hcd);
+        /*
+         * Not all platforms can gate the clock, so it is not an error if
+         * the clock does not exists.
+         */
+        priv->clk = devm_clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(priv->clk))
+                clk_prepare_enable(priv->clk);
+
+        priv->phy = devm_phy_optional_get(&pdev->dev, "usb");
+        if (IS_ERR(priv->phy)) {
+                err = PTR_ERR(priv->phy);
+                goto err_phy_get;
+        } else {
+                err = phy_init(priv->phy);
+                if (err)
+                        goto err_phy_init;
+
+                err = phy_power_on(priv->phy);
+                if (err)
+                        goto err_phy_power_on;
+        }
+
         /*
          * (Re-)program MBUS remapping windows if we are asked to.
          */
@@ -240,17 +266,23 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
 
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
-                goto err3;
+                goto err_add_hcd;
 
         device_wakeup_enable(hcd->self.controller);
         return 0;
 
-err3:
+err_add_hcd:
+        if (!IS_ERR(priv->phy))
+                phy_power_off(priv->phy);
+err_phy_power_on:
+        if (!IS_ERR(priv->phy))
+                phy_exit(priv->phy);
+err_phy_init:
+err_phy_get:
+        if (!IS_ERR(priv->clk))
+                clk_disable_unprepare(priv->clk);
         usb_put_hcd(hcd);
-err2:
-        if (!IS_ERR(clk))
-                clk_disable_unprepare(clk);
-err1:
+err:
         dev_err(&pdev->dev, "init %s fail, %d\n",
                 dev_name(&pdev->dev), err);
 
@@ -260,14 +292,20 @@ err1:
 static int ehci_orion_drv_remove(struct platform_device *pdev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
-        struct clk *clk;
+        struct orion_ehci_hcd *priv = hcd_to_orion_priv(hcd);
 
         usb_remove_hcd(hcd);
+
+        if (!IS_ERR(priv->phy)) {
+                phy_power_off(priv->phy);
+                phy_exit(priv->phy);
+        }
+
+        if (!IS_ERR(priv->clk))
+                clk_disable_unprepare(priv->clk);
+
         usb_put_hcd(hcd);
 
-        clk = devm_clk_get(&pdev->dev, NULL);
-        if (!IS_ERR(clk))
-                clk_disable_unprepare(clk);
         return 0;
 }
 
@@ -295,7 +333,7 @@ static int __init ehci_orion_init(void)
 
         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
 
-        ehci_init_driver(&ehci_orion_hc_driver, NULL);
+        ehci_init_driver(&ehci_orion_hc_driver, &orion_overrides);
         return platform_driver_register(&ehci_orion_driver);
 }
 module_init(ehci_orion_init);
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index c7dd93aad20c..2f5b9ce3e042 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -29,6 +29,7 @@
 #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>
@@ -41,6 +42,7 @@
 
 struct ehci_platform_priv {
         struct clk *clks[EHCI_MAX_CLKS];
+        struct reset_control *rst;
         struct phy *phy;
 };
 
@@ -208,6 +210,18 @@ static int ehci_platform_probe(struct platform_device *dev)
                 }
         }
 
+        priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->rst = NULL;
+        } else {
+                err = reset_control_deassert(priv->rst);
+                if (err)
+                        goto err_put_clks;
+        }
+
         if (pdata->big_endian_desc)
                 ehci->big_endian_desc = 1;
         if (pdata->big_endian_mmio)
@@ -218,7 +232,7 @@ static int ehci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_MMIO not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 #ifndef CONFIG_USB_EHCI_BIG_ENDIAN_DESC
@@ -226,14 +240,14 @@ static int ehci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_EHCI_BIG_ENDIAN_DESC not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        goto err_put_clks;
+                        goto err_reset;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -256,6 +270,9 @@ static int ehci_platform_probe(struct platform_device *dev)
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_reset:
+        if (priv->rst)
+                reset_control_assert(priv->rst);
 err_put_clks:
         while (--clk >= 0)
                 clk_put(priv->clks[clk]);
@@ -280,6 +297,9 @@ static int ehci_platform_remove(struct platform_device *dev)
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        if (priv->rst)
+                reset_control_assert(priv->rst);
+
         for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++)
                 clk_put(priv->clks[clk]);
 
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 8bd915b2ae8c..1d59958ad0ce 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -106,16 +106,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        if (!devm_request_mem_region(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                retval = -EBUSY;
-                goto err_put_hcd;
-        }
-
-        hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
-        if (hcd->regs == NULL) {
-                dev_dbg(&pdev->dev, "error mapping memory\n");
-                retval = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                retval = PTR_ERR(hcd->regs);
                 goto err_put_hcd;
         }
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 7ef00ecb0da1..6fdcb8ad2296 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -51,10 +51,6 @@ struct tegra_ehci_soc_config {
         bool has_hostpc;
 };
 
-static int (*orig_hub_control)(struct usb_hcd *hcd,
-                                u16 typeReq, u16 wValue, u16 wIndex,
-                                char *buf, u16 wLength);
-
 struct tegra_ehci_hcd {
         struct tegra_usb_phy *phy;
         struct clk *clk;
@@ -236,7 +232,7 @@ static int tegra_ehci_hub_control(
         spin_unlock_irqrestore(&ehci->lock, flags);
 
         /* Handle the hub control events here */
-        return orig_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        return ehci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
 
 done:
         spin_unlock_irqrestore(&ehci->lock, flags);
@@ -415,10 +411,9 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto cleanup_clk_en;
         }
         ehci->caps = hcd->regs + 0x100;
@@ -554,8 +549,6 @@ static int __init ehci_tegra_init(void)
          * too easy.
          */
 
-        orig_hub_control = tegra_ehci_hc_driver.hub_control;
-
         tegra_ehci_hc_driver.map_urb_for_dma = tegra_ehci_map_urb_for_dma;
         tegra_ehci_hc_driver.unmap_urb_for_dma = tegra_ehci_unmap_urb_for_dma;
         tegra_ehci_hc_driver.hub_control = tegra_ehci_hub_control;
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 9dfc6c1394d6..eee228a26a0e 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -872,4 +872,7 @@ extern int	ehci_suspend(struct usb_hcd *hcd, bool do_wakeup);
 extern int      ehci_resume(struct usb_hcd *hcd, bool hibernated);
 #endif  /* CONFIG_PM */
 
+extern int      ehci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                 u16 wIndex, char *buf, u16 wLength);
+
 #endif /* __LINUX_EHCI_HCD_H */
diff --git a/drivers/usb/host/max3421-hcd.c b/drivers/usb/host/max3421-hcd.c
new file mode 100644
index 000000000000..858efcfda50b
--- /dev/null
+++ b/drivers/usb/host/max3421-hcd.c
@@ -0,0 +1,1957 @@
+/*
+ * MAX3421 Host Controller driver for USB.
+ *
+ * Author: David Mosberger-Tang <davidm@egauge.net>
+ *
+ * (C) Copyright 2014 David Mosberger-Tang <davidm@egauge.net>
+ *
+ * MAX3421 is a chip implementing a USB 2.0 Full-/Low-Speed host
+ * controller on a SPI bus.
+ *
+ * Based on:
+ *      o MAX3421E datasheet
+ *              http://datasheets.maximintegrated.com/en/ds/MAX3421E.pdf
+ *      o MAX3421E Programming Guide
+ *              http://www.hdl.co.jp/ftpdata/utl-001/AN3785.pdf
+ *      o gadget/dummy_hcd.c
+ *              For USB HCD implementation.
+ *      o Arduino MAX3421 driver
+ *           https://github.com/felis/USB_Host_Shield_2.0/blob/master/Usb.cpp
+ *
+ * This file is licenced under the GPL v2.
+ *
+ * Important note on worst-case (full-speed) packet size constraints
+ * (See USB 2.0 Section 5.6.3 and following):
+ *
+ *      - control:        64 bytes
+ *      - isochronous:  1023 bytes
+ *      - interrupt:      64 bytes
+ *      - bulk:           64 bytes
+ *
+ * Since the MAX3421 FIFO size is 64 bytes, we do not have to work about
+ * multi-FIFO writes/reads for a single USB packet *except* for isochronous
+ * transfers.  We don't support isochronous transfers at this time, so we
+ * just assume that a USB packet always fits into a single FIFO buffer.
+ *
+ * NOTE: The June 2006 version of "MAX3421E Programming Guide"
+ * (AN3785) has conflicting info for the RCVDAVIRQ bit:
+ *
+ *      The description of RCVDAVIRQ says "The CPU *must* clear
+ *      this IRQ bit (by writing a 1 to it) before reading the
+ *      RCVFIFO data.
+ *
+ * However, the earlier section on "Programming BULK-IN
+ * Transfers" says * that:
+ *
+ *      After the CPU retrieves the data, it clears the
+ *      RCVDAVIRQ bit.
+ *
+ * The December 2006 version has been corrected and it consistently
+ * states the second behavior is the correct one.
+ *
+ * Synchronous SPI transactions sleep so we can't perform any such
+ * transactions while holding a spin-lock (and/or while interrupts are
+ * masked).  To achieve this, all SPI transactions are issued from a
+ * single thread (max3421_spi_thread).
+ */
+
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/usb.h>
+#include <linux/usb/hcd.h>
+
+#include <linux/platform_data/max3421-hcd.h>
+
+#define DRIVER_DESC     "MAX3421 USB Host-Controller Driver"
+#define DRIVER_VERSION  "1.0"
+
+/* 11-bit counter that wraps around (USB 2.0 Section 8.3.3): */
+#define USB_MAX_FRAME_NUMBER    0x7ff
+#define USB_MAX_RETRIES         3 /* # of retries before error is reported */
+
+/*
+ * Max. # of times we're willing to retransmit a request immediately in
+ * resposne to a NAK.  Afterwards, we fall back on trying once a frame.
+ */
+#define NAK_MAX_FAST_RETRANSMITS        2
+
+#define POWER_BUDGET    500     /* in mA; use 8 for low-power port testing */
+
+/* Port-change mask: */
+#define PORT_C_MASK     ((USB_PORT_STAT_C_CONNECTION |  \
+                          USB_PORT_STAT_C_ENABLE |      \
+                          USB_PORT_STAT_C_SUSPEND |     \
+                          USB_PORT_STAT_C_OVERCURRENT | \
+                          USB_PORT_STAT_C_RESET) << 16)
+
+enum max3421_rh_state {
+        MAX3421_RH_RESET,
+        MAX3421_RH_SUSPENDED,
+        MAX3421_RH_RUNNING
+};
+
+enum pkt_state {
+        PKT_STATE_SETUP,        /* waiting to send setup packet to ctrl pipe */
+        PKT_STATE_TRANSFER,     /* waiting to xfer transfer_buffer */
+        PKT_STATE_TERMINATE     /* waiting to terminate control transfer */
+};
+
+enum scheduling_pass {
+        SCHED_PASS_PERIODIC,
+        SCHED_PASS_NON_PERIODIC,
+        SCHED_PASS_DONE
+};
+
+struct max3421_dma_buf {
+        u8 data[2];
+};
+
+struct max3421_hcd {
+        spinlock_t lock;
+
+        struct task_struct *spi_thread;
+
+        struct max3421_hcd *next;
+
+        enum max3421_rh_state rh_state;
+        /* lower 16 bits contain port status, upper 16 bits the change mask: */
+        u32 port_status;
+
+        unsigned active:1;
+
+        struct list_head ep_list;       /* list of EP's with work */
+
+        /*
+         * The following are owned by spi_thread (may be accessed by
+         * SPI-thread without acquiring the HCD lock:
+         */
+        u8 rev;                         /* chip revision */
+        u16 frame_number;
+        /*
+         * kmalloc'd buffers guaranteed to be in separate (DMA)
+         * cache-lines:
+         */
+        struct max3421_dma_buf *tx;
+        struct max3421_dma_buf *rx;
+        /*
+         * URB we're currently processing.  Must not be reset to NULL
+         * unless MAX3421E chip is idle:
+         */
+        struct urb *curr_urb;
+        enum scheduling_pass sched_pass;
+        struct usb_device *loaded_dev;  /* dev that's loaded into the chip */
+        int loaded_epnum;               /* epnum whose toggles are loaded */
+        int urb_done;                   /* > 0 -> no errors, < 0: errno */
+        size_t curr_len;
+        u8 hien;
+        u8 mode;
+        u8 iopins[2];
+        unsigned int do_enable_irq:1;
+        unsigned int do_reset_hcd:1;
+        unsigned int do_reset_port:1;
+        unsigned int do_check_unlink:1;
+        unsigned int do_iopin_update:1;
+#ifdef DEBUG
+        unsigned long err_stat[16];
+#endif
+};
+
+struct max3421_ep {
+        struct usb_host_endpoint *ep;
+        struct list_head ep_list;
+        u32 naks;
+        u16 last_active;                /* frame # this ep was last active */
+        enum pkt_state pkt_state;
+        u8 retries;
+        u8 retransmit;                  /* packet needs retransmission */
+};
+
+static struct max3421_hcd *max3421_hcd_list;
+
+#define MAX3421_FIFO_SIZE       64
+
+#define MAX3421_SPI_DIR_RD      0       /* read register from MAX3421 */
+#define MAX3421_SPI_DIR_WR      1       /* write register to MAX3421 */
+
+/* SPI commands: */
+#define MAX3421_SPI_DIR_SHIFT   1
+#define MAX3421_SPI_REG_SHIFT   3
+
+#define MAX3421_REG_RCVFIFO     1
+#define MAX3421_REG_SNDFIFO     2
+#define MAX3421_REG_SUDFIFO     4
+#define MAX3421_REG_RCVBC       6
+#define MAX3421_REG_SNDBC       7
+#define MAX3421_REG_USBIRQ      13
+#define MAX3421_REG_USBIEN      14
+#define MAX3421_REG_USBCTL      15
+#define MAX3421_REG_CPUCTL      16
+#define MAX3421_REG_PINCTL      17
+#define MAX3421_REG_REVISION    18
+#define MAX3421_REG_IOPINS1     20
+#define MAX3421_REG_IOPINS2     21
+#define MAX3421_REG_GPINIRQ     22
+#define MAX3421_REG_GPINIEN     23
+#define MAX3421_REG_GPINPOL     24
+#define MAX3421_REG_HIRQ        25
+#define MAX3421_REG_HIEN        26
+#define MAX3421_REG_MODE        27
+#define MAX3421_REG_PERADDR     28
+#define MAX3421_REG_HCTL        29
+#define MAX3421_REG_HXFR        30
+#define MAX3421_REG_HRSL        31
+
+enum {
+        MAX3421_USBIRQ_OSCOKIRQ_BIT = 0,
+        MAX3421_USBIRQ_NOVBUSIRQ_BIT = 5,
+        MAX3421_USBIRQ_VBUSIRQ_BIT
+};
+
+enum {
+        MAX3421_CPUCTL_IE_BIT = 0,
+        MAX3421_CPUCTL_PULSEWID0_BIT = 6,
+        MAX3421_CPUCTL_PULSEWID1_BIT
+};
+
+enum {
+        MAX3421_USBCTL_PWRDOWN_BIT = 4,
+        MAX3421_USBCTL_CHIPRES_BIT
+};
+
+enum {
+        MAX3421_PINCTL_GPXA_BIT = 0,
+        MAX3421_PINCTL_GPXB_BIT,
+        MAX3421_PINCTL_POSINT_BIT,
+        MAX3421_PINCTL_INTLEVEL_BIT,
+        MAX3421_PINCTL_FDUPSPI_BIT,
+        MAX3421_PINCTL_EP0INAK_BIT,
+        MAX3421_PINCTL_EP2INAK_BIT,
+        MAX3421_PINCTL_EP3INAK_BIT,
+};
+
+enum {
+        MAX3421_HI_BUSEVENT_BIT = 0,    /* bus-reset/-resume */
+        MAX3421_HI_RWU_BIT,             /* remote wakeup */
+        MAX3421_HI_RCVDAV_BIT,          /* receive FIFO data available */
+        MAX3421_HI_SNDBAV_BIT,          /* send buffer available */
+        MAX3421_HI_SUSDN_BIT,           /* suspend operation done */
+        MAX3421_HI_CONDET_BIT,          /* peripheral connect/disconnect */
+        MAX3421_HI_FRAME_BIT,           /* frame generator */
+        MAX3421_HI_HXFRDN_BIT,          /* host transfer done */
+};
+
+enum {
+        MAX3421_HCTL_BUSRST_BIT = 0,
+        MAX3421_HCTL_FRMRST_BIT,
+        MAX3421_HCTL_SAMPLEBUS_BIT,
+        MAX3421_HCTL_SIGRSM_BIT,
+        MAX3421_HCTL_RCVTOG0_BIT,
+        MAX3421_HCTL_RCVTOG1_BIT,
+        MAX3421_HCTL_SNDTOG0_BIT,
+        MAX3421_HCTL_SNDTOG1_BIT
+};
+
+enum {
+        MAX3421_MODE_HOST_BIT = 0,
+        MAX3421_MODE_LOWSPEED_BIT,
+        MAX3421_MODE_HUBPRE_BIT,
+        MAX3421_MODE_SOFKAENAB_BIT,
+        MAX3421_MODE_SEPIRQ_BIT,
+        MAX3421_MODE_DELAYISO_BIT,
+        MAX3421_MODE_DMPULLDN_BIT,
+        MAX3421_MODE_DPPULLDN_BIT
+};
+
+enum {
+        MAX3421_HRSL_OK = 0,
+        MAX3421_HRSL_BUSY,
+        MAX3421_HRSL_BADREQ,
+        MAX3421_HRSL_UNDEF,
+        MAX3421_HRSL_NAK,
+        MAX3421_HRSL_STALL,
+        MAX3421_HRSL_TOGERR,
+        MAX3421_HRSL_WRONGPID,
+        MAX3421_HRSL_BADBC,
+        MAX3421_HRSL_PIDERR,
+        MAX3421_HRSL_PKTERR,
+        MAX3421_HRSL_CRCERR,
+        MAX3421_HRSL_KERR,
+        MAX3421_HRSL_JERR,
+        MAX3421_HRSL_TIMEOUT,
+        MAX3421_HRSL_BABBLE,
+        MAX3421_HRSL_RESULT_MASK = 0xf,
+        MAX3421_HRSL_RCVTOGRD_BIT = 4,
+        MAX3421_HRSL_SNDTOGRD_BIT,
+        MAX3421_HRSL_KSTATUS_BIT,
+        MAX3421_HRSL_JSTATUS_BIT
+};
+
+/* Return same error-codes as ohci.h:cc_to_error: */
+static const int hrsl_to_error[] = {
+        [MAX3421_HRSL_OK] =             0,
+        [MAX3421_HRSL_BUSY] =           -EINVAL,
+        [MAX3421_HRSL_BADREQ] =         -EINVAL,
+        [MAX3421_HRSL_UNDEF] =          -EINVAL,
+        [MAX3421_HRSL_NAK] =            -EAGAIN,
+        [MAX3421_HRSL_STALL] =          -EPIPE,
+        [MAX3421_HRSL_TOGERR] =         -EILSEQ,
+        [MAX3421_HRSL_WRONGPID] =       -EPROTO,
+        [MAX3421_HRSL_BADBC] =          -EREMOTEIO,
+        [MAX3421_HRSL_PIDERR] =         -EPROTO,
+        [MAX3421_HRSL_PKTERR] =         -EPROTO,
+        [MAX3421_HRSL_CRCERR] =         -EILSEQ,
+        [MAX3421_HRSL_KERR] =           -EIO,
+        [MAX3421_HRSL_JERR] =           -EIO,
+        [MAX3421_HRSL_TIMEOUT] =        -ETIME,
+        [MAX3421_HRSL_BABBLE] =         -EOVERFLOW
+};
+
+/*
+ * See http://www.beyondlogic.org/usbnutshell/usb4.shtml#Control for a
+ * reasonable overview of how control transfers use the the IN/OUT
+ * tokens.
+ */
+#define MAX3421_HXFR_BULK_IN(ep)        (0x00 | (ep))   /* bulk or interrupt */
+#define MAX3421_HXFR_SETUP               0x10
+#define MAX3421_HXFR_BULK_OUT(ep)       (0x20 | (ep))   /* bulk or interrupt */
+#define MAX3421_HXFR_ISO_IN(ep)         (0x40 | (ep))
+#define MAX3421_HXFR_ISO_OUT(ep)        (0x60 | (ep))
+#define MAX3421_HXFR_HS_IN               0x80           /* handshake in */
+#define MAX3421_HXFR_HS_OUT              0xa0           /* handshake out */
+
+#define field(val, bit) ((val) << (bit))
+
+static inline s16
+frame_diff(u16 left, u16 right)
+{
+        return ((unsigned) (left - right)) % (USB_MAX_FRAME_NUMBER + 1);
+}
+
+static inline struct max3421_hcd *
+hcd_to_max3421(struct usb_hcd *hcd)
+{
+        return (struct max3421_hcd *) hcd->hcd_priv;
+}
+
+static inline struct usb_hcd *
+max3421_to_hcd(struct max3421_hcd *max3421_hcd)
+{
+        return container_of((void *) max3421_hcd, struct usb_hcd, hcd_priv);
+}
+
+static u8
+spi_rd8(struct usb_hcd *hcd, unsigned int reg)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct spi_transfer transfer;
+        struct spi_message msg;
+
+        memset(&transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
+
+        transfer.tx_buf = max3421_hcd->tx->data;
+        transfer.rx_buf = max3421_hcd->rx->data;
+        transfer.len = 2;
+
+        spi_message_add_tail(&transfer, &msg);
+        spi_sync(spi, &msg);
+
+        return max3421_hcd->rx->data[1];
+}
+
+static void
+spi_wr8(struct usb_hcd *hcd, unsigned int reg, u8 val)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer;
+        struct spi_message msg;
+
+        memset(&transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
+        max3421_hcd->tx->data[1] = val;
+
+        transfer.tx_buf = max3421_hcd->tx->data;
+        transfer.len = 2;
+
+        spi_message_add_tail(&transfer, &msg);
+        spi_sync(spi, &msg);
+}
+
+static void
+spi_rd_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer[2];
+        struct spi_message msg;
+
+        memset(transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_RD, MAX3421_SPI_DIR_SHIFT));
+        transfer[0].tx_buf = max3421_hcd->tx->data;
+        transfer[0].len = 1;
+
+        transfer[1].rx_buf = buf;
+        transfer[1].len = len;
+
+        spi_message_add_tail(&transfer[0], &msg);
+        spi_message_add_tail(&transfer[1], &msg);
+        spi_sync(spi, &msg);
+}
+
+static void
+spi_wr_buf(struct usb_hcd *hcd, unsigned int reg, void *buf, size_t len)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct spi_transfer transfer[2];
+        struct spi_message msg;
+
+        memset(transfer, 0, sizeof(transfer));
+
+        spi_message_init(&msg);
+
+        max3421_hcd->tx->data[0] =
+                (field(reg, MAX3421_SPI_REG_SHIFT) |
+                 field(MAX3421_SPI_DIR_WR, MAX3421_SPI_DIR_SHIFT));
+
+        transfer[0].tx_buf = max3421_hcd->tx->data;
+        transfer[0].len = 1;
+
+        transfer[1].tx_buf = buf;
+        transfer[1].len = len;
+
+        spi_message_add_tail(&transfer[0], &msg);
+        spi_message_add_tail(&transfer[1], &msg);
+        spi_sync(spi, &msg);
+}
+
+/*
+ * Figure out the correct setting for the LOWSPEED and HUBPRE mode
+ * bits.  The HUBPRE bit needs to be set when MAX3421E operates at
+ * full speed, but it's talking to a low-speed device (i.e., through a
+ * hub).  Setting that bit ensures that every low-speed packet is
+ * preceded by a full-speed PRE PID.  Possible configurations:
+ *
+ * Hub speed:   Device speed:   =>      LOWSPEED bit:   HUBPRE bit:
+ *      FULL    FULL            =>      0               0
+ *      FULL    LOW             =>      1               1
+ *      LOW     LOW             =>      1               0
+ *      LOW     FULL            =>      1               0
+ */
+static void
+max3421_set_speed(struct usb_hcd *hcd, struct usb_device *dev)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 mode_lowspeed, mode_hubpre, mode = max3421_hcd->mode;
+
+        mode_lowspeed = BIT(MAX3421_MODE_LOWSPEED_BIT);
+        mode_hubpre   = BIT(MAX3421_MODE_HUBPRE_BIT);
+        if (max3421_hcd->port_status & USB_PORT_STAT_LOW_SPEED) {
+                mode |=  mode_lowspeed;
+                mode &= ~mode_hubpre;
+        } else if (dev->speed == USB_SPEED_LOW) {
+                mode |= mode_lowspeed | mode_hubpre;
+        } else {
+                mode &= ~(mode_lowspeed | mode_hubpre);
+        }
+        if (mode != max3421_hcd->mode) {
+                max3421_hcd->mode = mode;
+                spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+        }
+
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_set_address(struct usb_hcd *hcd, struct usb_device *dev, int epnum,
+                    int force_toggles)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int old_epnum, same_ep, rcvtog, sndtog;
+        struct usb_device *old_dev;
+        u8 hctl;
+
+        old_dev = max3421_hcd->loaded_dev;
+        old_epnum = max3421_hcd->loaded_epnum;
+
+        same_ep = (dev == old_dev && epnum == old_epnum);
+        if (same_ep && !force_toggles)
+                return;
+
+        if (old_dev && !same_ep) {
+                /* save the old end-points toggles: */
+                u8 hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+
+                rcvtog = (hrsl >> MAX3421_HRSL_RCVTOGRD_BIT) & 1;
+                sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
+
+                /* no locking: HCD (i.e., we) own toggles, don't we? */
+                usb_settoggle(old_dev, old_epnum, 0, rcvtog);
+                usb_settoggle(old_dev, old_epnum, 1, sndtog);
+        }
+        /* setup new endpoint's toggle bits: */
+        rcvtog = usb_gettoggle(dev, epnum, 0);
+        sndtog = usb_gettoggle(dev, epnum, 1);
+        hctl = (BIT(rcvtog + MAX3421_HCTL_RCVTOG0_BIT) |
+                BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
+
+        max3421_hcd->loaded_epnum = epnum;
+        spi_wr8(hcd, MAX3421_REG_HCTL, hctl);
+
+        /*
+         * Note: devnum for one and the same device can change during
+         * address-assignment so it's best to just always load the
+         * address whenever the end-point changed/was forced.
+         */
+        max3421_hcd->loaded_dev = dev;
+        spi_wr8(hcd, MAX3421_REG_PERADDR, dev->devnum);
+}
+
+static int
+max3421_ctrl_setup(struct usb_hcd *hcd, struct urb *urb)
+{
+        spi_wr_buf(hcd, MAX3421_REG_SUDFIFO, urb->setup_packet, 8);
+        return MAX3421_HXFR_SETUP;
+}
+
+static int
+max3421_transfer_in(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int epnum = usb_pipeendpoint(urb->pipe);
+
+        max3421_hcd->curr_len = 0;
+        max3421_hcd->hien |= BIT(MAX3421_HI_RCVDAV_BIT);
+        return MAX3421_HXFR_BULK_IN(epnum);
+}
+
+static int
+max3421_transfer_out(struct usb_hcd *hcd, struct urb *urb, int fast_retransmit)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int epnum = usb_pipeendpoint(urb->pipe);
+        u32 max_packet;
+        void *src;
+
+        src = urb->transfer_buffer + urb->actual_length;
+
+        if (fast_retransmit) {
+                if (max3421_hcd->rev == 0x12) {
+                        /* work around rev 0x12 bug: */
+                        spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
+                        spi_wr8(hcd, MAX3421_REG_SNDFIFO, ((u8 *) src)[0]);
+                        spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
+                }
+                return MAX3421_HXFR_BULK_OUT(epnum);
+        }
+
+        max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
+
+        if (max_packet > MAX3421_FIFO_SIZE) {
+                /*
+                 * We do not support isochronous transfers at this
+                 * time.
+                 */
+                dev_err(&spi->dev,
+                        "%s: packet-size of %u too big (limit is %u bytes)",
+                        __func__, max_packet, MAX3421_FIFO_SIZE);
+                max3421_hcd->urb_done = -EMSGSIZE;
+                return -EMSGSIZE;
+        }
+        max3421_hcd->curr_len = min((urb->transfer_buffer_length -
+                                     urb->actual_length), max_packet);
+
+        spi_wr_buf(hcd, MAX3421_REG_SNDFIFO, src, max3421_hcd->curr_len);
+        spi_wr8(hcd, MAX3421_REG_SNDBC, max3421_hcd->curr_len);
+        return MAX3421_HXFR_BULK_OUT(epnum);
+}
+
+/*
+ * Issue the next host-transfer command.
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_next_transfer(struct usb_hcd *hcd, int fast_retransmit)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+        int cmd = -EINVAL;
+
+        if (!urb)
+                return; /* nothing to do */
+
+        max3421_ep = urb->ep->hcpriv;
+
+        switch (max3421_ep->pkt_state) {
+        case PKT_STATE_SETUP:
+                cmd = max3421_ctrl_setup(hcd, urb);
+                break;
+
+        case PKT_STATE_TRANSFER:
+                if (usb_urb_dir_in(urb))
+                        cmd = max3421_transfer_in(hcd, urb);
+                else
+                        cmd = max3421_transfer_out(hcd, urb, fast_retransmit);
+                break;
+
+        case PKT_STATE_TERMINATE:
+                /*
+                 * IN transfers are terminated with HS_OUT token,
+                 * OUT transfers with HS_IN:
+                 */
+                if (usb_urb_dir_in(urb))
+                        cmd = MAX3421_HXFR_HS_OUT;
+                else
+                        cmd = MAX3421_HXFR_HS_IN;
+                break;
+        }
+
+        if (cmd < 0)
+                return;
+
+        /* issue the command and wait for host-xfer-done interrupt: */
+
+        spi_wr8(hcd, MAX3421_REG_HXFR, cmd);
+        max3421_hcd->hien |= BIT(MAX3421_HI_HXFRDN_BIT);
+}
+
+/*
+ * Find the next URB to process and start its execution.
+ *
+ * At this time, we do not anticipate ever connecting a USB hub to the
+ * MAX3421 chip, so at most USB device can be connected and we can use
+ * a simplistic scheduler: at the start of a frame, schedule all
+ * periodic transfers.  Once that is done, use the remainder of the
+ * frame to process non-periodic (bulk & control) transfers.
+ *
+ * Preconditions:
+ * o Caller must NOT hold HCD spinlock.
+ * o max3421_hcd->curr_urb MUST BE NULL.
+ * o MAX3421E chip must be idle.
+ */
+static int
+max3421_select_and_start_urb(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb, *curr_urb = NULL;
+        struct max3421_ep *max3421_ep;
+        int epnum, force_toggles = 0;
+        struct usb_host_endpoint *ep;
+        struct list_head *pos;
+        unsigned long flags;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        for (;
+             max3421_hcd->sched_pass < SCHED_PASS_DONE;
+             ++max3421_hcd->sched_pass)
+                list_for_each(pos, &max3421_hcd->ep_list) {
+                        urb = NULL;
+                        max3421_ep = container_of(pos, struct max3421_ep,
+                                                  ep_list);
+                        ep = max3421_ep->ep;
+
+                        switch (usb_endpoint_type(&ep->desc)) {
+                        case USB_ENDPOINT_XFER_ISOC:
+                        case USB_ENDPOINT_XFER_INT:
+                                if (max3421_hcd->sched_pass !=
+                                    SCHED_PASS_PERIODIC)
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_CONTROL:
+                        case USB_ENDPOINT_XFER_BULK:
+                                if (max3421_hcd->sched_pass !=
+                                    SCHED_PASS_NON_PERIODIC)
+                                        continue;
+                                break;
+                        }
+
+                        if (list_empty(&ep->urb_list))
+                                continue;       /* nothing to do */
+                        urb = list_first_entry(&ep->urb_list, struct urb,
+                                               urb_list);
+                        if (urb->unlinked) {
+                                dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
+                                        __func__, urb, urb->unlinked);
+                                max3421_hcd->curr_urb = urb;
+                                max3421_hcd->urb_done = 1;
+                                spin_unlock_irqrestore(&max3421_hcd->lock,
+                                                       flags);
+                                return 1;
+                        }
+
+                        switch (usb_endpoint_type(&ep->desc)) {
+                        case USB_ENDPOINT_XFER_CONTROL:
+                                /*
+                                 * Allow one control transaction per
+                                 * frame per endpoint:
+                                 */
+                                if (frame_diff(max3421_ep->last_active,
+                                               max3421_hcd->frame_number) == 0)
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_BULK:
+                                if (max3421_ep->retransmit
+                                    && (frame_diff(max3421_ep->last_active,
+                                                   max3421_hcd->frame_number)
+                                        == 0))
+                                        /*
+                                         * We already tried this EP
+                                         * during this frame and got a
+                                         * NAK or error; wait for next frame
+                                         */
+                                        continue;
+                                break;
+
+                        case USB_ENDPOINT_XFER_ISOC:
+                        case USB_ENDPOINT_XFER_INT:
+                                if (frame_diff(max3421_hcd->frame_number,
+                                               max3421_ep->last_active)
+                                    < urb->interval)
+                                        /*
+                                         * We already processed this
+                                         * end-point in the current
+                                         * frame
+                                         */
+                                        continue;
+                                break;
+                        }
+
+                        /* move current ep to tail: */
+                        list_move_tail(pos, &max3421_hcd->ep_list);
+                        curr_urb = urb;
+                        goto done;
+                }
+done:
+        if (!curr_urb) {
+                spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+                return 0;
+        }
+
+        urb = max3421_hcd->curr_urb = curr_urb;
+        epnum = usb_endpoint_num(&urb->ep->desc);
+        if (max3421_ep->retransmit)
+                /* restart (part of) a USB transaction: */
+                max3421_ep->retransmit = 0;
+        else {
+                /* start USB transaction: */
+                if (usb_endpoint_xfer_control(&ep->desc)) {
+                        /*
+                         * See USB 2.0 spec section 8.6.1
+                         * Initialization via SETUP Token:
+                         */
+                        usb_settoggle(urb->dev, epnum, 0, 1);
+                        usb_settoggle(urb->dev, epnum, 1, 1);
+                        max3421_ep->pkt_state = PKT_STATE_SETUP;
+                        force_toggles = 1;
+                } else
+                        max3421_ep->pkt_state = PKT_STATE_TRANSFER;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+        max3421_ep->last_active = max3421_hcd->frame_number;
+        max3421_set_address(hcd, urb->dev, epnum, force_toggles);
+        max3421_set_speed(hcd, urb->dev);
+        max3421_next_transfer(hcd, 0);
+        return 1;
+}
+
+/*
+ * Check all endpoints for URBs that got unlinked.
+ *
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_check_unlink(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct list_head *pos, *upos, *next_upos;
+        struct max3421_ep *max3421_ep;
+        struct usb_host_endpoint *ep;
+        struct urb *urb;
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        list_for_each(pos, &max3421_hcd->ep_list) {
+                max3421_ep = container_of(pos, struct max3421_ep, ep_list);
+                ep = max3421_ep->ep;
+                list_for_each_safe(upos, next_upos, &ep->urb_list) {
+                        urb = container_of(upos, struct urb, urb_list);
+                        if (urb->unlinked) {
+                                retval = 1;
+                                dev_dbg(&spi->dev, "%s: URB %p unlinked=%d",
+                                        __func__, urb, urb->unlinked);
+                                usb_hcd_unlink_urb_from_ep(hcd, urb);
+                                spin_unlock_irqrestore(&max3421_hcd->lock,
+                                                       flags);
+                                usb_hcd_giveback_urb(hcd, urb, 0);
+                                spin_lock_irqsave(&max3421_hcd->lock, flags);
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_slow_retransmit(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+
+        max3421_ep = urb->ep->hcpriv;
+        max3421_ep->retransmit = 1;
+        max3421_hcd->curr_urb = NULL;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_recv_data_available(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        size_t remaining, transfer_size;
+        u8 rcvbc;
+
+        rcvbc = spi_rd8(hcd, MAX3421_REG_RCVBC);
+
+        if (rcvbc > MAX3421_FIFO_SIZE)
+                rcvbc = MAX3421_FIFO_SIZE;
+        if (urb->actual_length >= urb->transfer_buffer_length)
+                remaining = 0;
+        else
+                remaining = urb->transfer_buffer_length - urb->actual_length;
+        transfer_size = rcvbc;
+        if (transfer_size > remaining)
+                transfer_size = remaining;
+        if (transfer_size > 0) {
+                void *dst = urb->transfer_buffer + urb->actual_length;
+
+                spi_rd_buf(hcd, MAX3421_REG_RCVFIFO, dst, transfer_size);
+                urb->actual_length += transfer_size;
+                max3421_hcd->curr_len = transfer_size;
+        }
+
+        /* ack the RCVDAV irq now that the FIFO has been read: */
+        spi_wr8(hcd, MAX3421_REG_HIRQ, BIT(MAX3421_HI_RCVDAV_BIT));
+}
+
+static void
+max3421_handle_error(struct usb_hcd *hcd, u8 hrsl)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep = urb->ep->hcpriv;
+        int switch_sndfifo;
+
+        /*
+         * If an OUT command results in any response other than OK
+         * (i.e., error or NAK), we have to perform a dummy-write to
+         * SNDBC so the FIFO gets switched back to us.  Otherwise, we
+         * get out of sync with the SNDFIFO double buffer.
+         */
+        switch_sndfifo = (max3421_ep->pkt_state == PKT_STATE_TRANSFER &&
+                          usb_urb_dir_out(urb));
+
+        switch (result_code) {
+        case MAX3421_HRSL_OK:
+                return;                 /* this shouldn't happen */
+
+        case MAX3421_HRSL_WRONGPID:     /* received wrong PID */
+        case MAX3421_HRSL_BUSY:         /* SIE busy */
+        case MAX3421_HRSL_BADREQ:       /* bad val in HXFR */
+        case MAX3421_HRSL_UNDEF:        /* reserved */
+        case MAX3421_HRSL_KERR:         /* K-state instead of response */
+        case MAX3421_HRSL_JERR:         /* J-state instead of response */
+                /*
+                 * packet experienced an error that we cannot recover
+                 * from; report error
+                 */
+                max3421_hcd->urb_done = hrsl_to_error[result_code];
+                dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                        __func__, hrsl);
+                break;
+
+        case MAX3421_HRSL_TOGERR:
+                if (usb_urb_dir_in(urb))
+                        ; /* don't do anything (device will switch toggle) */
+                else {
+                        /* flip the send toggle bit: */
+                        int sndtog = (hrsl >> MAX3421_HRSL_SNDTOGRD_BIT) & 1;
+
+                        sndtog ^= 1;
+                        spi_wr8(hcd, MAX3421_REG_HCTL,
+                                BIT(sndtog + MAX3421_HCTL_SNDTOG0_BIT));
+                }
+                /* FALL THROUGH */
+        case MAX3421_HRSL_BADBC:        /* bad byte count */
+        case MAX3421_HRSL_PIDERR:       /* received PID is corrupted */
+        case MAX3421_HRSL_PKTERR:       /* packet error (stuff, EOP) */
+        case MAX3421_HRSL_CRCERR:       /* CRC error */
+        case MAX3421_HRSL_BABBLE:       /* device talked too long */
+        case MAX3421_HRSL_TIMEOUT:
+                if (max3421_ep->retries++ < USB_MAX_RETRIES)
+                        /* retry the packet again in the next frame */
+                        max3421_slow_retransmit(hcd);
+                else {
+                        /* Based on ohci.h cc_to_err[]: */
+                        max3421_hcd->urb_done = hrsl_to_error[result_code];
+                        dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                                __func__, hrsl);
+                }
+                break;
+
+        case MAX3421_HRSL_STALL:
+                dev_dbg(&spi->dev, "%s: unexpected error HRSL=0x%02x",
+                        __func__, hrsl);
+                max3421_hcd->urb_done = hrsl_to_error[result_code];
+                break;
+
+        case MAX3421_HRSL_NAK:
+                /*
+                 * Device wasn't ready for data or has no data
+                 * available: retry the packet again.
+                 */
+                if (max3421_ep->naks++ < NAK_MAX_FAST_RETRANSMITS) {
+                        max3421_next_transfer(hcd, 1);
+                        switch_sndfifo = 0;
+                } else
+                        max3421_slow_retransmit(hcd);
+                break;
+        }
+        if (switch_sndfifo)
+                spi_wr8(hcd, MAX3421_REG_SNDBC, 0);
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_transfer_in_done(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u32 max_packet;
+
+        if (urb->actual_length >= urb->transfer_buffer_length)
+                return 1;       /* read is complete, so we're done */
+
+        /*
+         * USB 2.0 Section 5.3.2 Pipes: packets must be full size
+         * except for last one.
+         */
+        max_packet = usb_maxpacket(urb->dev, urb->pipe, 0);
+        if (max_packet > MAX3421_FIFO_SIZE) {
+                /*
+                 * We do not support isochronous transfers at this
+                 * time...
+                 */
+                dev_err(&spi->dev,
+                        "%s: packet-size of %u too big (limit is %u bytes)",
+                        __func__, max_packet, MAX3421_FIFO_SIZE);
+                return -EINVAL;
+        }
+
+        if (max3421_hcd->curr_len < max_packet) {
+                if (urb->transfer_flags & URB_SHORT_NOT_OK) {
+                        /*
+                         * remaining > 0 and received an
+                         * unexpected partial packet ->
+                         * error
+                         */
+                        return -EREMOTEIO;
+                } else
+                        /* short read, but it's OK */
+                        return 1;
+        }
+        return 0;       /* not done */
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static int
+max3421_transfer_out_done(struct usb_hcd *hcd, struct urb *urb)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        urb->actual_length += max3421_hcd->curr_len;
+        if (urb->actual_length < urb->transfer_buffer_length)
+                return 0;
+        if (urb->transfer_flags & URB_ZERO_PACKET) {
+                /*
+                 * Some hardware needs a zero-size packet at the end
+                 * of a bulk-out transfer if the last transfer was a
+                 * full-sized packet (i.e., such hardware use <
+                 * max_packet as an indicator that the end of the
+                 * packet has been reached).
+                 */
+                u32 max_packet = usb_maxpacket(urb->dev, urb->pipe, 1);
+
+                if (max3421_hcd->curr_len == max_packet)
+                        return 0;
+        }
+        return 1;
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_host_transfer_done(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct urb *urb = max3421_hcd->curr_urb;
+        struct max3421_ep *max3421_ep;
+        u8 result_code, hrsl;
+        int urb_done = 0;
+
+        max3421_hcd->hien &= ~(BIT(MAX3421_HI_HXFRDN_BIT) |
+                               BIT(MAX3421_HI_RCVDAV_BIT));
+
+        hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+        result_code = hrsl & MAX3421_HRSL_RESULT_MASK;
+
+#ifdef DEBUG
+        ++max3421_hcd->err_stat[result_code];
+#endif
+
+        max3421_ep = urb->ep->hcpriv;
+
+        if (unlikely(result_code != MAX3421_HRSL_OK)) {
+                max3421_handle_error(hcd, hrsl);
+                return;
+        }
+
+        max3421_ep->naks = 0;
+        max3421_ep->retries = 0;
+        switch (max3421_ep->pkt_state) {
+
+        case PKT_STATE_SETUP:
+                if (urb->transfer_buffer_length > 0)
+                        max3421_ep->pkt_state = PKT_STATE_TRANSFER;
+                else
+                        max3421_ep->pkt_state = PKT_STATE_TERMINATE;
+                break;
+
+        case PKT_STATE_TRANSFER:
+                if (usb_urb_dir_in(urb))
+                        urb_done = max3421_transfer_in_done(hcd, urb);
+                else
+                        urb_done = max3421_transfer_out_done(hcd, urb);
+                if (urb_done > 0 && usb_pipetype(urb->pipe) == PIPE_CONTROL) {
+                        /*
+                         * We aren't really done - we still need to
+                         * terminate the control transfer:
+                         */
+                        max3421_hcd->urb_done = urb_done = 0;
+                        max3421_ep->pkt_state = PKT_STATE_TERMINATE;
+                }
+                break;
+
+        case PKT_STATE_TERMINATE:
+                urb_done = 1;
+                break;
+        }
+
+        if (urb_done)
+                max3421_hcd->urb_done = urb_done;
+        else
+                max3421_next_transfer(hcd, 0);
+}
+
+/*
+ * Caller must NOT hold HCD spinlock.
+ */
+static void
+max3421_detect_conn(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned int jk, have_conn = 0;
+        u32 old_port_status, chg;
+        unsigned long flags;
+        u8 hrsl, mode;
+
+        hrsl = spi_rd8(hcd, MAX3421_REG_HRSL);
+
+        jk = ((((hrsl >> MAX3421_HRSL_JSTATUS_BIT) & 1) << 0) |
+              (((hrsl >> MAX3421_HRSL_KSTATUS_BIT) & 1) << 1));
+
+        mode = max3421_hcd->mode;
+
+        switch (jk) {
+        case 0x0: /* SE0: disconnect */
+                /*
+                 * Turn off SOFKAENAB bit to avoid getting interrupt
+                 * every milli-second:
+                 */
+                mode &= ~BIT(MAX3421_MODE_SOFKAENAB_BIT);
+                break;
+
+        case 0x1: /* J=0,K=1: low-speed (in full-speed or vice versa) */
+        case 0x2: /* J=1,K=0: full-speed (in full-speed or vice versa) */
+                if (jk == 0x2)
+                        /* need to switch to the other speed: */
+                        mode ^= BIT(MAX3421_MODE_LOWSPEED_BIT);
+                /* turn on SOFKAENAB bit: */
+                mode |= BIT(MAX3421_MODE_SOFKAENAB_BIT);
+                have_conn = 1;
+                break;
+
+        case 0x3: /* illegal */
+                break;
+        }
+
+        max3421_hcd->mode = mode;
+        spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        old_port_status = max3421_hcd->port_status;
+        if (have_conn)
+                max3421_hcd->port_status |=  USB_PORT_STAT_CONNECTION;
+        else
+                max3421_hcd->port_status &= ~USB_PORT_STAT_CONNECTION;
+        if (mode & BIT(MAX3421_MODE_LOWSPEED_BIT))
+                max3421_hcd->port_status |=  USB_PORT_STAT_LOW_SPEED;
+        else
+                max3421_hcd->port_status &= ~USB_PORT_STAT_LOW_SPEED;
+        chg = (old_port_status ^ max3421_hcd->port_status);
+        max3421_hcd->port_status |= chg << 16;
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+static irqreturn_t
+max3421_irq_handler(int irq, void *dev_id)
+{
+        struct usb_hcd *hcd = dev_id;
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        if (max3421_hcd->spi_thread &&
+            max3421_hcd->spi_thread->state != TASK_RUNNING)
+                wake_up_process(max3421_hcd->spi_thread);
+        if (!max3421_hcd->do_enable_irq) {
+                max3421_hcd->do_enable_irq = 1;
+                disable_irq_nosync(spi->irq);
+        }
+        return IRQ_HANDLED;
+}
+
+#ifdef DEBUG
+
+static void
+dump_eps(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_ep *max3421_ep;
+        struct usb_host_endpoint *ep;
+        struct list_head *pos, *upos;
+        char ubuf[512], *dp, *end;
+        unsigned long flags;
+        struct urb *urb;
+        int epnum, ret;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        list_for_each(pos, &max3421_hcd->ep_list) {
+                max3421_ep = container_of(pos, struct max3421_ep, ep_list);
+                ep = max3421_ep->ep;
+
+                dp = ubuf;
+                end = dp + sizeof(ubuf);
+                *dp = '\0';
+                list_for_each(upos, &ep->urb_list) {
+                        urb = container_of(upos, struct urb, urb_list);
+                        ret = snprintf(dp, end - dp, " %p(%d.%s %d/%d)", urb,
+                                       usb_pipetype(urb->pipe),
+                                       usb_urb_dir_in(urb) ? "IN" : "OUT",
+                                       urb->actual_length,
+                                       urb->transfer_buffer_length);
+                        if (ret < 0 || ret >= end - dp)
+                                break;  /* error or buffer full */
+                        dp += ret;
+                }
+
+                epnum = usb_endpoint_num(&ep->desc);
+                pr_info("EP%0u %u lst %04u rtr %u nak %6u rxmt %u: %s\n",
+                        epnum, max3421_ep->pkt_state, max3421_ep->last_active,
+                        max3421_ep->retries, max3421_ep->naks,
+                        max3421_ep->retransmit, ubuf);
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+#endif /* DEBUG */
+
+/* Return zero if no work was performed, 1 otherwise.  */
+static int
+max3421_handle_irqs(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u32 chg, old_port_status;
+        unsigned long flags;
+        u8 hirq;
+
+        /*
+         * Read and ack pending interrupts (CPU must never
+         * clear SNDBAV directly and RCVDAV must be cleared by
+         * max3421_recv_data_available()!):
+         */
+        hirq = spi_rd8(hcd, MAX3421_REG_HIRQ);
+        hirq &= max3421_hcd->hien;
+        if (!hirq)
+                return 0;
+
+        spi_wr8(hcd, MAX3421_REG_HIRQ,
+                hirq & ~(BIT(MAX3421_HI_SNDBAV_BIT) |
+                         BIT(MAX3421_HI_RCVDAV_BIT)));
+
+        if (hirq & BIT(MAX3421_HI_FRAME_BIT)) {
+                max3421_hcd->frame_number = ((max3421_hcd->frame_number + 1)
+                                             & USB_MAX_FRAME_NUMBER);
+                max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
+        }
+
+        if (hirq & BIT(MAX3421_HI_RCVDAV_BIT))
+                max3421_recv_data_available(hcd);
+
+        if (hirq & BIT(MAX3421_HI_HXFRDN_BIT))
+                max3421_host_transfer_done(hcd);
+
+        if (hirq & BIT(MAX3421_HI_CONDET_BIT))
+                max3421_detect_conn(hcd);
+
+        /*
+         * Now process interrupts that may affect HCD state
+         * other than the end-points:
+         */
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        old_port_status = max3421_hcd->port_status;
+        if (hirq & BIT(MAX3421_HI_BUSEVENT_BIT)) {
+                if (max3421_hcd->port_status & USB_PORT_STAT_RESET) {
+                        /* BUSEVENT due to completion of Bus Reset */
+                        max3421_hcd->port_status &= ~USB_PORT_STAT_RESET;
+                        max3421_hcd->port_status |=  USB_PORT_STAT_ENABLE;
+                } else {
+                        /* BUSEVENT due to completion of Bus Resume */
+                        pr_info("%s: BUSEVENT Bus Resume Done\n", __func__);
+                }
+        }
+        if (hirq & BIT(MAX3421_HI_RWU_BIT))
+                pr_info("%s: RWU\n", __func__);
+        if (hirq & BIT(MAX3421_HI_SUSDN_BIT))
+                pr_info("%s: SUSDN\n", __func__);
+
+        chg = (old_port_status ^ max3421_hcd->port_status);
+        max3421_hcd->port_status |= chg << 16;
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+#ifdef DEBUG
+        {
+                static unsigned long last_time;
+                char sbuf[16 * 16], *dp, *end;
+                int i;
+
+                if (jiffies - last_time > 5*HZ) {
+                        dp = sbuf;
+                        end = sbuf + sizeof(sbuf);
+                        *dp = '\0';
+                        for (i = 0; i < 16; ++i) {
+                                int ret = snprintf(dp, end - dp, " %lu",
+                                                   max3421_hcd->err_stat[i]);
+                                if (ret < 0 || ret >= end - dp)
+                                        break;  /* error or buffer full */
+                                dp += ret;
+                        }
+                        pr_info("%s: hrsl_stats %s\n", __func__, sbuf);
+                        memset(max3421_hcd->err_stat, 0,
+                               sizeof(max3421_hcd->err_stat));
+                        last_time = jiffies;
+
+                        dump_eps(hcd);
+                }
+        }
+#endif
+        return 1;
+}
+
+static int
+max3421_reset_hcd(struct usb_hcd *hcd)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int timeout;
+
+        /* perform a chip reset and wait for OSCIRQ signal to appear: */
+        spi_wr8(hcd, MAX3421_REG_USBCTL, BIT(MAX3421_USBCTL_CHIPRES_BIT));
+        /* clear reset: */
+        spi_wr8(hcd, MAX3421_REG_USBCTL, 0);
+        timeout = 1000;
+        while (1) {
+                if (spi_rd8(hcd, MAX3421_REG_USBIRQ)
+                    & BIT(MAX3421_USBIRQ_OSCOKIRQ_BIT))
+                        break;
+                if (--timeout < 0) {
+                        dev_err(&spi->dev,
+                                "timed out waiting for oscillator OK signal");
+                        return 1;
+                }
+                cond_resched();
+        }
+
+        /*
+         * Turn on host mode, automatic generation of SOF packets, and
+         * enable pull-down registers on DM/DP:
+         */
+        max3421_hcd->mode = (BIT(MAX3421_MODE_HOST_BIT) |
+                             BIT(MAX3421_MODE_SOFKAENAB_BIT) |
+                             BIT(MAX3421_MODE_DMPULLDN_BIT) |
+                             BIT(MAX3421_MODE_DPPULLDN_BIT));
+        spi_wr8(hcd, MAX3421_REG_MODE, max3421_hcd->mode);
+
+        /* reset frame-number: */
+        max3421_hcd->frame_number = USB_MAX_FRAME_NUMBER;
+        spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_FRMRST_BIT));
+
+        /* sample the state of the D+ and D- lines */
+        spi_wr8(hcd, MAX3421_REG_HCTL, BIT(MAX3421_HCTL_SAMPLEBUS_BIT));
+        max3421_detect_conn(hcd);
+
+        /* enable frame, connection-detected, and bus-event interrupts: */
+        max3421_hcd->hien = (BIT(MAX3421_HI_FRAME_BIT) |
+                             BIT(MAX3421_HI_CONDET_BIT) |
+                             BIT(MAX3421_HI_BUSEVENT_BIT));
+        spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
+
+        /* enable interrupts: */
+        spi_wr8(hcd, MAX3421_REG_CPUCTL, BIT(MAX3421_CPUCTL_IE_BIT));
+        return 1;
+}
+
+static int
+max3421_urb_done(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        struct urb *urb;
+        int status;
+
+        status = max3421_hcd->urb_done;
+        max3421_hcd->urb_done = 0;
+        if (status > 0)
+                status = 0;
+        urb = max3421_hcd->curr_urb;
+        if (urb) {
+                max3421_hcd->curr_urb = NULL;
+                spin_lock_irqsave(&max3421_hcd->lock, flags);
+                usb_hcd_unlink_urb_from_ep(hcd, urb);
+                spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+                /* must be called without the HCD spinlock: */
+                usb_hcd_giveback_urb(hcd, urb, status);
+        }
+        return 1;
+}
+
+static int
+max3421_spi_thread(void *dev_id)
+{
+        struct usb_hcd *hcd = dev_id;
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        int i, i_worked = 1;
+
+        /* set full-duplex SPI mode, low-active interrupt pin: */
+        spi_wr8(hcd, MAX3421_REG_PINCTL,
+                (BIT(MAX3421_PINCTL_FDUPSPI_BIT) |      /* full-duplex */
+                 BIT(MAX3421_PINCTL_INTLEVEL_BIT)));    /* low-active irq */
+
+        while (!kthread_should_stop()) {
+                max3421_hcd->rev = spi_rd8(hcd, MAX3421_REG_REVISION);
+                if (max3421_hcd->rev == 0x12 || max3421_hcd->rev == 0x13)
+                        break;
+                dev_err(&spi->dev, "bad rev 0x%02x", max3421_hcd->rev);
+                msleep(10000);
+        }
+        dev_info(&spi->dev, "rev 0x%x, SPI clk %dHz, bpw %u, irq %d\n",
+                 max3421_hcd->rev, spi->max_speed_hz, spi->bits_per_word,
+                 spi->irq);
+
+        while (!kthread_should_stop()) {
+                if (!i_worked) {
+                        /*
+                         * We'll be waiting for wakeups from the hard
+                         * interrupt handler, so now is a good time to
+                         * sync our hien with the chip:
+                         */
+                        spi_wr8(hcd, MAX3421_REG_HIEN, max3421_hcd->hien);
+
+                        set_current_state(TASK_INTERRUPTIBLE);
+                        if (max3421_hcd->do_enable_irq) {
+                                max3421_hcd->do_enable_irq = 0;
+                                enable_irq(spi->irq);
+                        }
+                        schedule();
+                        __set_current_state(TASK_RUNNING);
+                }
+
+                i_worked = 0;
+
+                if (max3421_hcd->urb_done)
+                        i_worked |= max3421_urb_done(hcd);
+                else if (max3421_handle_irqs(hcd))
+                        i_worked = 1;
+                else if (!max3421_hcd->curr_urb)
+                        i_worked |= max3421_select_and_start_urb(hcd);
+
+                if (max3421_hcd->do_reset_hcd) {
+                        /* reset the HCD: */
+                        max3421_hcd->do_reset_hcd = 0;
+                        i_worked |= max3421_reset_hcd(hcd);
+                }
+                if (max3421_hcd->do_reset_port) {
+                        /* perform a USB bus reset: */
+                        max3421_hcd->do_reset_port = 0;
+                        spi_wr8(hcd, MAX3421_REG_HCTL,
+                                BIT(MAX3421_HCTL_BUSRST_BIT));
+                        i_worked = 1;
+                }
+                if (max3421_hcd->do_check_unlink) {
+                        max3421_hcd->do_check_unlink = 0;
+                        i_worked |= max3421_check_unlink(hcd);
+                }
+                if (max3421_hcd->do_iopin_update) {
+                        /*
+                         * IOPINS1/IOPINS2 do not auto-increment, so we can't
+                         * use spi_wr_buf().
+                         */
+                        for (i = 0; i < ARRAY_SIZE(max3421_hcd->iopins); ++i) {
+                                u8 val = spi_rd8(hcd, MAX3421_REG_IOPINS1);
+
+                                val = ((val & 0xf0) |
+                                       (max3421_hcd->iopins[i] & 0x0f));
+                                spi_wr8(hcd, MAX3421_REG_IOPINS1 + i, val);
+                                max3421_hcd->iopins[i] = val;
+                        }
+                        max3421_hcd->do_iopin_update = 0;
+                        i_worked = 1;
+                }
+        }
+        set_current_state(TASK_RUNNING);
+        dev_info(&spi->dev, "SPI thread exiting");
+        return 0;
+}
+
+static int
+max3421_reset_port(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        max3421_hcd->port_status &= ~(USB_PORT_STAT_ENABLE |
+                                      USB_PORT_STAT_LOW_SPEED);
+        max3421_hcd->do_reset_port = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+        return 0;
+}
+
+static int
+max3421_reset(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        hcd->self.sg_tablesize = 0;
+        hcd->speed = HCD_USB2;
+        hcd->self.root_hub->speed = USB_SPEED_FULL;
+        max3421_hcd->do_reset_hcd = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+        return 0;
+}
+
+static int
+max3421_start(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+
+        spin_lock_init(&max3421_hcd->lock);
+        max3421_hcd->rh_state = MAX3421_RH_RUNNING;
+
+        INIT_LIST_HEAD(&max3421_hcd->ep_list);
+
+        hcd->power_budget = POWER_BUDGET;
+        hcd->state = HC_STATE_RUNNING;
+        hcd->uses_new_polling = 1;
+        return 0;
+}
+
+static void
+max3421_stop(struct usb_hcd *hcd)
+{
+}
+
+static int
+max3421_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_ep *max3421_ep;
+        unsigned long flags;
+        int retval;
+
+        switch (usb_pipetype(urb->pipe)) {
+        case PIPE_INTERRUPT:
+        case PIPE_ISOCHRONOUS:
+                if (urb->interval < 0) {
+                        dev_err(&spi->dev,
+                          "%s: interval=%d for intr-/iso-pipe; expected > 0\n",
+                                __func__, urb->interval);
+                        return -EINVAL;
+                }
+        default:
+                break;
+        }
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        max3421_ep = urb->ep->hcpriv;
+        if (!max3421_ep) {
+                /* gets freed in max3421_endpoint_disable: */
+                max3421_ep = kzalloc(sizeof(struct max3421_ep), mem_flags);
+                if (!max3421_ep) {
+                        retval = -ENOMEM;
+                        goto out;
+                }
+                max3421_ep->ep = urb->ep;
+                max3421_ep->last_active = max3421_hcd->frame_number;
+                urb->ep->hcpriv = max3421_ep;
+
+                list_add_tail(&max3421_ep->ep_list, &max3421_hcd->ep_list);
+        }
+
+        retval = usb_hcd_link_urb_to_ep(hcd, urb);
+        if (retval == 0) {
+                /* Since we added to the queue, restart scheduling: */
+                max3421_hcd->sched_pass = SCHED_PASS_PERIODIC;
+                wake_up_process(max3421_hcd->spi_thread);
+        }
+
+out:
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static int
+max3421_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        int retval;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        /*
+         * This will set urb->unlinked which in turn causes the entry
+         * to be dropped at the next opportunity.
+         */
+        retval = usb_hcd_check_unlink_urb(hcd, urb, status);
+        if (retval == 0) {
+                max3421_hcd->do_check_unlink = 1;
+                wake_up_process(max3421_hcd->spi_thread);
+        }
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static void
+max3421_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        if (ep->hcpriv) {
+                struct max3421_ep *max3421_ep = ep->hcpriv;
+
+                /* remove myself from the ep_list: */
+                if (!list_empty(&max3421_ep->ep_list))
+                        list_del(&max3421_ep->ep_list);
+                kfree(max3421_ep);
+                ep->hcpriv = NULL;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+}
+
+static int
+max3421_get_frame_number(struct usb_hcd *hcd)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        return max3421_hcd->frame_number;
+}
+
+/*
+ * Should return a non-zero value when any port is undergoing a resume
+ * transition while the root hub is suspended.
+ */
+static int
+max3421_hub_status_data(struct usb_hcd *hcd, char *buf)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+        if (!HCD_HW_ACCESSIBLE(hcd))
+                goto done;
+
+        *buf = 0;
+        if ((max3421_hcd->port_status & PORT_C_MASK) != 0) {
+                *buf = (1 << 1); /* a hub over-current condition exists */
+                dev_dbg(hcd->self.controller,
+                        "port status 0x%08x has changes\n",
+                        max3421_hcd->port_status);
+                retval = 1;
+                if (max3421_hcd->rh_state == MAX3421_RH_SUSPENDED)
+                        usb_hcd_resume_root_hub(hcd);
+        }
+done:
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static inline void
+hub_descriptor(struct usb_hub_descriptor *desc)
+{
+        memset(desc, 0, sizeof(*desc));
+        /*
+         * See Table 11-13: Hub Descriptor in USB 2.0 spec.
+         */
+        desc->bDescriptorType = 0x29;   /* hub descriptor */
+        desc->bDescLength = 9;
+        desc->wHubCharacteristics = cpu_to_le16(0x0001);
+        desc->bNbrPorts = 1;
+}
+
+/*
+ * Set the MAX3421E general-purpose output with number PIN_NUMBER to
+ * VALUE (0 or 1).  PIN_NUMBER may be in the range from 1-8.  For
+ * any other value, this function acts as a no-op.
+ */
+static void
+max3421_gpout_set_value(struct usb_hcd *hcd, u8 pin_number, u8 value)
+{
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        u8 mask, idx;
+
+        --pin_number;
+        if (pin_number > 7)
+                return;
+
+        mask = 1u << pin_number;
+        idx = pin_number / 4;
+
+        if (value)
+                max3421_hcd->iopins[idx] |=  mask;
+        else
+                max3421_hcd->iopins[idx] &= ~mask;
+        max3421_hcd->do_iopin_update = 1;
+        wake_up_process(max3421_hcd->spi_thread);
+}
+
+static int
+max3421_hub_control(struct usb_hcd *hcd, u16 type_req, u16 value, u16 index,
+                    char *buf, u16 length)
+{
+        struct spi_device *spi = to_spi_device(hcd->self.controller);
+        struct max3421_hcd *max3421_hcd = hcd_to_max3421(hcd);
+        struct max3421_hcd_platform_data *pdata;
+        unsigned long flags;
+        int retval = 0;
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        pdata = spi->dev.platform_data;
+
+        switch (type_req) {
+        case ClearHubFeature:
+                break;
+        case ClearPortFeature:
+                switch (value) {
+                case USB_PORT_FEAT_SUSPEND:
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(hcd->self.controller, "power-off\n");
+                        max3421_gpout_set_value(hcd, pdata->vbus_gpout,
+                                                !pdata->vbus_active_level);
+                        /* FALLS THROUGH */
+                default:
+                        max3421_hcd->port_status &= ~(1 << value);
+                }
+                break;
+        case GetHubDescriptor:
+                hub_descriptor((struct usb_hub_descriptor *) buf);
+                break;
+
+        case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
+        case GetPortErrorCount:
+        case SetHubDepth:
+                /* USB3 only */
+                goto error;
+
+        case GetHubStatus:
+                *(__le32 *) buf = cpu_to_le32(0);
+                break;
+
+        case GetPortStatus:
+                if (index != 1) {
+                        retval = -EPIPE;
+                        goto error;
+                }
+                ((__le16 *) buf)[0] = cpu_to_le16(max3421_hcd->port_status);
+                ((__le16 *) buf)[1] =
+                        cpu_to_le16(max3421_hcd->port_status >> 16);
+                break;
+
+        case SetHubFeature:
+                retval = -EPIPE;
+                break;
+
+        case SetPortFeature:
+                switch (value) {
+                case USB_PORT_FEAT_LINK_STATE:
+                case USB_PORT_FEAT_U1_TIMEOUT:
+                case USB_PORT_FEAT_U2_TIMEOUT:
+                case USB_PORT_FEAT_BH_PORT_RESET:
+                        goto error;
+                case USB_PORT_FEAT_SUSPEND:
+                        if (max3421_hcd->active)
+                                max3421_hcd->port_status |=
+                                        USB_PORT_STAT_SUSPEND;
+                        break;
+                case USB_PORT_FEAT_POWER:
+                        dev_dbg(hcd->self.controller, "power-on\n");
+                        max3421_hcd->port_status |= USB_PORT_STAT_POWER;
+                        max3421_gpout_set_value(hcd, pdata->vbus_gpout,
+                                                pdata->vbus_active_level);
+                        break;
+                case USB_PORT_FEAT_RESET:
+                        max3421_reset_port(hcd);
+                        /* FALLS THROUGH */
+                default:
+                        if ((max3421_hcd->port_status & USB_PORT_STAT_POWER)
+                            != 0)
+                                max3421_hcd->port_status |= (1 << value);
+                }
+                break;
+
+        default:
+                dev_dbg(hcd->self.controller,
+                        "hub control req%04x v%04x i%04x l%d\n",
+                        type_req, value, index, length);
+error:          /* "protocol stall" on error */
+                retval = -EPIPE;
+        }
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+        return retval;
+}
+
+static int
+max3421_bus_suspend(struct usb_hcd *hcd)
+{
+        return -1;
+}
+
+static int
+max3421_bus_resume(struct usb_hcd *hcd)
+{
+        return -1;
+}
+
+/*
+ * The SPI driver already takes care of DMA-mapping/unmapping, so no
+ * reason to do it twice.
+ */
+static int
+max3421_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
+{
+        return 0;
+}
+
+static void
+max3421_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
+{
+}
+
+static struct hc_driver max3421_hcd_desc = {
+        .description =          "max3421",
+        .product_desc =         DRIVER_DESC,
+        .hcd_priv_size =        sizeof(struct max3421_hcd),
+        .flags =                HCD_USB11,
+        .reset =                max3421_reset,
+        .start =                max3421_start,
+        .stop =                 max3421_stop,
+        .get_frame_number =     max3421_get_frame_number,
+        .urb_enqueue =          max3421_urb_enqueue,
+        .urb_dequeue =          max3421_urb_dequeue,
+        .map_urb_for_dma =      max3421_map_urb_for_dma,
+        .unmap_urb_for_dma =    max3421_unmap_urb_for_dma,
+        .endpoint_disable =     max3421_endpoint_disable,
+        .hub_status_data =      max3421_hub_status_data,
+        .hub_control =          max3421_hub_control,
+        .bus_suspend =          max3421_bus_suspend,
+        .bus_resume =           max3421_bus_resume,
+};
+
+static int
+max3421_probe(struct spi_device *spi)
+{
+        struct max3421_hcd *max3421_hcd;
+        struct usb_hcd *hcd = NULL;
+        int retval = -ENOMEM;
+
+        if (spi_setup(spi) < 0) {
+                dev_err(&spi->dev, "Unable to setup SPI bus");
+                return -EFAULT;
+        }
+
+        hcd = usb_create_hcd(&max3421_hcd_desc, &spi->dev,
+                             dev_name(&spi->dev));
+        if (!hcd) {
+                dev_err(&spi->dev, "failed to create HCD structure\n");
+                goto error;
+        }
+        set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        max3421_hcd = hcd_to_max3421(hcd);
+        max3421_hcd->next = max3421_hcd_list;
+        max3421_hcd_list = max3421_hcd;
+        INIT_LIST_HEAD(&max3421_hcd->ep_list);
+
+        max3421_hcd->tx = kmalloc(sizeof(*max3421_hcd->tx), GFP_KERNEL);
+        if (!max3421_hcd->tx) {
+                dev_err(&spi->dev, "failed to kmalloc tx buffer\n");
+                goto error;
+        }
+        max3421_hcd->rx = kmalloc(sizeof(*max3421_hcd->rx), GFP_KERNEL);
+        if (!max3421_hcd->rx) {
+                dev_err(&spi->dev, "failed to kmalloc rx buffer\n");
+                goto error;
+        }
+
+        max3421_hcd->spi_thread = kthread_run(max3421_spi_thread, hcd,
+                                              "max3421_spi_thread");
+        if (max3421_hcd->spi_thread == ERR_PTR(-ENOMEM)) {
+                dev_err(&spi->dev,
+                        "failed to create SPI thread (out of memory)\n");
+                goto error;
+        }
+
+        retval = usb_add_hcd(hcd, 0, 0);
+        if (retval) {
+                dev_err(&spi->dev, "failed to add HCD\n");
+                goto error;
+        }
+
+        retval = request_irq(spi->irq, max3421_irq_handler,
+                             IRQF_TRIGGER_LOW, "max3421", hcd);
+        if (retval < 0) {
+                dev_err(&spi->dev, "failed to request irq %d\n", spi->irq);
+                goto error;
+        }
+        return 0;
+
+error:
+        if (hcd) {
+                kfree(max3421_hcd->tx);
+                kfree(max3421_hcd->rx);
+                if (max3421_hcd->spi_thread)
+                        kthread_stop(max3421_hcd->spi_thread);
+                usb_put_hcd(hcd);
+        }
+        return retval;
+}
+
+static int
+max3421_remove(struct spi_device *spi)
+{
+        struct max3421_hcd *max3421_hcd = NULL, **prev;
+        struct usb_hcd *hcd = NULL;
+        unsigned long flags;
+
+        for (prev = &max3421_hcd_list; *prev; prev = &(*prev)->next) {
+                max3421_hcd = *prev;
+                hcd = max3421_to_hcd(max3421_hcd);
+                if (hcd->self.controller == &spi->dev)
+                        break;
+        }
+        if (!max3421_hcd) {
+                dev_err(&spi->dev, "no MAX3421 HCD found for SPI device %p\n",
+                        spi);
+                return -ENODEV;
+        }
+
+        usb_remove_hcd(hcd);
+
+        spin_lock_irqsave(&max3421_hcd->lock, flags);
+
+        kthread_stop(max3421_hcd->spi_thread);
+        *prev = max3421_hcd->next;
+
+        spin_unlock_irqrestore(&max3421_hcd->lock, flags);
+
+        free_irq(spi->irq, hcd);
+
+        usb_put_hcd(hcd);
+        return 0;
+}
+
+static struct spi_driver max3421_driver = {
+        .probe          = max3421_probe,
+        .remove         = max3421_remove,
+        .driver         = {
+                .name   = "max3421-hcd",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_spi_driver(max3421_driver);
+
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_AUTHOR("David Mosberger <davidm@egauge.net>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 091ae4905cfc..e49eb4f90f5d 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -46,9 +46,6 @@ static const char hcd_name[] = "ohci-atmel";
 
 static struct hc_driver __read_mostly ohci_at91_hc_driver;
 static int clocked;
-static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
-                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
-static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
 
 extern int usb_disabled(void);
 
@@ -262,7 +259,7 @@ static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
-        int length = orig_ohci_hub_status_data(hcd, buf);
+        int length = ohci_hub_status_data(hcd, buf);
         int port;
 
         at91_for_each_port(port) {
@@ -340,8 +337,7 @@ static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 break;
         }
 
-        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex + 1,
-                                buf, wLength);
+        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
         if (ret)
                 goto out;
 
@@ -690,9 +686,6 @@ static int __init ohci_at91_init(void)
          * too easy.
          */
 
-        orig_ohci_hub_control = ohci_at91_hc_driver.hub_control;
-        orig_ohci_hub_status_data = ohci_at91_hc_driver.hub_status_data;
-
         ohci_at91_hc_driver.hub_status_data     = ohci_at91_hub_status_data;
         ohci_at91_hc_driver.hub_control         = ohci_at91_hub_control;
 
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index 68588d8a09bb..060a6a414750 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -18,6 +18,7 @@
 #include <linux/module.h>
 #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>
@@ -33,28 +34,110 @@ static struct hc_driver __read_mostly exynos_ohci_hc_driver;
 
 #define to_exynos_ohci(hcd) (struct exynos_ohci_hcd *)(hcd_to_ohci(hcd)->priv)
 
+#define PHY_NUMBER 3
+
 struct exynos_ohci_hcd {
         struct clk *clk;
         struct usb_phy *phy;
         struct usb_otg *otg;
+        struct phy *phy_g[PHY_NUMBER];
 };
 
-static void exynos_ohci_phy_enable(struct platform_device *pdev)
+static int exynos_ohci_get_phy(struct device *dev,
+                                struct exynos_ohci_hcd *exynos_ohci)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        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;
+        }
+
+        /*
+         * 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.
+         */
+        for_each_available_child_of_node(dev->of_node, child) {
+                ret = of_property_read_u32(child, "reg", &phy_number);
+                if (ret) {
+                        dev_err(dev, "Failed to parse device tree\n");
+                        of_node_put(child);
+                        return ret;
+                }
+
+                if (phy_number >= PHY_NUMBER) {
+                        dev_err(dev, "Invalid number of PHYs\n");
+                        of_node_put(child);
+                        return -EINVAL;
+                }
+
+                phy = devm_of_phy_get(dev, child, 0);
+                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");
+                                return ret;
+                        }
+                        dev_dbg(dev, "Failed to get usb2 phy\n");
+                }
+                exynos_ohci->phy_g[phy_number] = phy;
+        }
+
+        return ret;
+}
+
+static int exynos_ohci_phy_enable(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
+        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 (ret)
+                for (i--; i >= 0; i--)
+                        if (!IS_ERR(exynos_ohci->phy_g[i]))
+                                phy_power_off(exynos_ohci->phy_g[i]);
 
-        if (exynos_ohci->phy)
-                usb_phy_init(exynos_ohci->phy);
+        return ret;
 }
 
-static void exynos_ohci_phy_disable(struct platform_device *pdev)
+static void exynos_ohci_phy_disable(struct device *dev)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
+        int i;
 
-        if (exynos_ohci->phy)
+        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]);
 }
 
 static int exynos_ohci_probe(struct platform_device *pdev)
@@ -62,7 +145,6 @@ static int exynos_ohci_probe(struct platform_device *pdev)
         struct exynos_ohci_hcd *exynos_ohci;
         struct usb_hcd *hcd;
         struct resource *res;
-        struct usb_phy *phy;
         int irq;
         int err;
 
@@ -88,15 +170,9 @@ static int exynos_ohci_probe(struct platform_device *pdev)
                                         "samsung,exynos5440-ohci"))
                 goto skip_phy;
 
-        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
-        if (IS_ERR(phy)) {
-                usb_put_hcd(hcd);
-                dev_warn(&pdev->dev, "no platform data or transceiver defined\n");
-                return -EPROBE_DEFER;
-        } else {
-                exynos_ohci->phy = phy;
-                exynos_ohci->otg = phy->otg;
-        }
+        err = exynos_ohci_get_phy(&pdev->dev, exynos_ohci);
+        if (err)
+                goto fail_clk;
 
 skip_phy:
         exynos_ohci->clk = devm_clk_get(&pdev->dev, "usbhost");
@@ -120,10 +196,9 @@ skip_phy:
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = devm_ioremap(&pdev->dev, res->start, hcd->rsrc_len);
-        if (!hcd->regs) {
-                dev_err(&pdev->dev, "Failed to remap I/O memory\n");
-                err = -ENOMEM;
+        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(hcd->regs)) {
+                err = PTR_ERR(hcd->regs);
                 goto fail_io;
         }
 
@@ -139,7 +214,11 @@ skip_phy:
 
         platform_set_drvdata(pdev, hcd);
 
-        exynos_ohci_phy_enable(pdev);
+        err = exynos_ohci_phy_enable(&pdev->dev);
+        if (err) {
+                dev_err(&pdev->dev, "Failed to enable USB phy\n");
+                goto fail_io;
+        }
 
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err) {
@@ -150,7 +229,7 @@ skip_phy:
         return 0;
 
 fail_add_hcd:
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(&pdev->dev);
 fail_io:
         clk_disable_unprepare(exynos_ohci->clk);
 fail_clk:
@@ -168,7 +247,7 @@ static int exynos_ohci_remove(struct platform_device *pdev)
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(&pdev->dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
@@ -190,26 +269,19 @@ static int exynos_ohci_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        struct platform_device *pdev = to_platform_device(dev);
         bool do_wakeup = device_may_wakeup(dev);
-        unsigned long flags;
         int rc = ohci_suspend(hcd, do_wakeup);
 
         if (rc)
                 return rc;
 
-        spin_lock_irqsave(&ohci->lock, flags);
-
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_disable(pdev);
+        exynos_ohci_phy_disable(dev);
 
         clk_disable_unprepare(exynos_ohci->clk);
 
-        spin_unlock_irqrestore(&ohci->lock, flags);
-
         return 0;
 }
 
@@ -217,14 +289,19 @@ static int exynos_ohci_resume(struct device *dev)
 {
         struct usb_hcd *hcd                     = dev_get_drvdata(dev);
         struct exynos_ohci_hcd *exynos_ohci     = to_exynos_ohci(hcd);
-        struct platform_device *pdev            = to_platform_device(dev);
+        int ret;
 
         clk_prepare_enable(exynos_ohci->clk);
 
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
 
-        exynos_ohci_phy_enable(pdev);
+        ret = exynos_ohci_phy_enable(dev);
+        if (ret) {
+                dev_err(dev, "Failed to enable USB phy\n");
+                clk_disable_unprepare(exynos_ohci->clk);
+                return ret;
+        }
 
         ohci_resume(hcd, false);
 
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 3586460fb2a1..f98d03f3144c 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -1178,7 +1178,7 @@ MODULE_LICENSE ("GPL");
 #define SA1111_DRIVER           ohci_hcd_sa1111_driver
 #endif
 
-#ifdef CONFIG_ARCH_DAVINCI_DA8XX
+#ifdef CONFIG_USB_OHCI_HCD_DAVINCI
 #include "ohci-da8xx.c"
 #define DAVINCI_PLATFORM_DRIVER ohci_hcd_da8xx_driver
 #endif
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index cd871b895013..b4940de1eba3 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -456,8 +456,7 @@ static int ohci_root_hub_state_changes(struct ohci_hcd *ohci, int changed,
 
 /* build "status change" packet (one or two bytes) from HC registers */
 
-static int
-ohci_hub_status_data (struct usb_hcd *hcd, char *buf)
+int ohci_hub_status_data(struct usb_hcd *hcd, char *buf)
 {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
         int             i, changed = 0, length = 1;
@@ -522,6 +521,7 @@ done:
 
         return changed ? length : 0;
 }
+EXPORT_SYMBOL_GPL(ohci_hub_status_data);
 
 /*-------------------------------------------------------------------------*/
 
@@ -664,7 +664,7 @@ static inline int root_port_reset (struct ohci_hcd *ohci, unsigned port)
         return 0;
 }
 
-static int ohci_hub_control (
+int ohci_hub_control(
         struct usb_hcd  *hcd,
         u16             typeReq,
         u16             wValue,
@@ -790,4 +790,4 @@ error:
         }
         return retval;
 }
-
+EXPORT_SYMBOL_GPL(ohci_hub_control);
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index b6002c951c5c..4369299064c7 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -24,6 +24,7 @@
 #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>
@@ -36,6 +37,7 @@
 
 struct ohci_platform_priv {
         struct clk *clks[OHCI_MAX_CLKS];
+        struct reset_control *rst;
         struct phy *phy;
 };
 
@@ -191,6 +193,19 @@ static int ohci_platform_probe(struct platform_device *dev)
                                 break;
                         }
                 }
+
+        }
+
+        priv->rst = devm_reset_control_get_optional(&dev->dev, NULL);
+        if (IS_ERR(priv->rst)) {
+                err = PTR_ERR(priv->rst);
+                if (err == -EPROBE_DEFER)
+                        goto err_put_clks;
+                priv->rst = NULL;
+        } else {
+                err = reset_control_deassert(priv->rst);
+                if (err)
+                        goto err_put_clks;
         }
 
         if (pdata->big_endian_desc)
@@ -203,7 +218,7 @@ static int ohci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_OHCI_BIG_ENDIAN_MMIO not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 #ifndef CONFIG_USB_OHCI_BIG_ENDIAN_DESC
@@ -211,14 +226,14 @@ static int ohci_platform_probe(struct platform_device *dev)
                 dev_err(&dev->dev,
                         "Error: CONFIG_USB_OHCI_BIG_ENDIAN_DESC not set\n");
                 err = -EINVAL;
-                goto err_put_clks;
+                goto err_reset;
         }
 #endif
 
         if (pdata->power_on) {
                 err = pdata->power_on(dev);
                 if (err < 0)
-                        goto err_put_clks;
+                        goto err_reset;
         }
 
         hcd->rsrc_start = res_mem->start;
@@ -242,6 +257,9 @@ static int ohci_platform_probe(struct platform_device *dev)
 err_power:
         if (pdata->power_off)
                 pdata->power_off(dev);
+err_reset:
+        if (priv->rst)
+                reset_control_assert(priv->rst);
 err_put_clks:
         while (--clk >= 0)
                 clk_put(priv->clks[clk]);
@@ -266,6 +284,9 @@ static int ohci_platform_remove(struct platform_device *dev)
         if (pdata->power_off)
                 pdata->power_off(dev);
 
+        if (priv->rst)
+                reset_control_assert(priv->rst);
+
         for (clk = 0; clk < OHCI_MAX_CLKS && priv->clks[clk]; clk++)
                 clk_put(priv->clks[clk]);
 
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index d21d5fefa76c..e68f3d02cd1a 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -30,6 +30,7 @@
 #include <linux/platform_data/usb-ohci-pxa27x.h>
 #include <linux/platform_data/usb-pxa3xx-ulpi.h>
 #include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
 #include <linux/signal.h>
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
@@ -120,6 +121,8 @@ static struct hc_driver __read_mostly ohci_pxa27x_hc_driver;
 struct pxa27x_ohci {
         struct clk      *clk;
         void __iomem    *mmio_base;
+        struct regulator *vbus[3];
+        bool            vbus_enabled[3];
 };
 
 #define to_pxa27x_ohci(hcd)     (struct pxa27x_ohci *)(hcd_to_ohci(hcd)->priv)
@@ -166,6 +169,52 @@ static int pxa27x_ohci_select_pmm(struct pxa27x_ohci *pxa_ohci, int mode)
         return 0;
 }
 
+static int pxa27x_ohci_set_vbus_power(struct pxa27x_ohci *pxa_ohci,
+                                      unsigned int port, bool enable)
+{
+        struct regulator *vbus = pxa_ohci->vbus[port];
+        int ret = 0;
+
+        if (IS_ERR_OR_NULL(vbus))
+                return 0;
+
+        if (enable && !pxa_ohci->vbus_enabled[port])
+                ret = regulator_enable(vbus);
+        else if (!enable && pxa_ohci->vbus_enabled[port])
+                ret = regulator_disable(vbus);
+
+        if (ret < 0)
+                return ret;
+
+        pxa_ohci->vbus_enabled[port] = enable;
+
+        return 0;
+}
+
+static int pxa27x_ohci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                   u16 wIndex, char *buf, u16 wLength)
+{
+        struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
+        int ret;
+
+        switch (typeReq) {
+        case SetPortFeature:
+        case ClearPortFeature:
+                if (!wIndex || wIndex > 3)
+                        return -EPIPE;
+
+                if (wValue != USB_PORT_FEAT_POWER)
+                        break;
+
+                ret = pxa27x_ohci_set_vbus_power(pxa_ohci, wIndex - 1,
+                                                 typeReq == SetPortFeature);
+                if (ret)
+                        return ret;
+                break;
+        }
+
+        return ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+}
 /*-------------------------------------------------------------------------*/
 
 static inline void pxa27x_setup_hc(struct pxa27x_ohci *pxa_ohci,
@@ -372,6 +421,7 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         struct ohci_hcd *ohci;
         struct resource *r;
         struct clk *usb_clk;
+        unsigned int i;
 
         retval = ohci_pxa_of_init(pdev);
         if (retval)
@@ -417,6 +467,16 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         pxa_ohci->clk = usb_clk;
         pxa_ohci->mmio_base = (void __iomem *)hcd->regs;
 
+        for (i = 0; i < 3; ++i) {
+                char name[6];
+
+                if (!(inf->flags & (ENABLE_PORT1 << i)))
+                        continue;
+
+                sprintf(name, "vbus%u", i + 1);
+                pxa_ohci->vbus[i] = devm_regulator_get(&pdev->dev, name);
+        }
+
         retval = pxa27x_start_hc(pxa_ohci, &pdev->dev);
         if (retval < 0) {
                 pr_debug("pxa27x_start_hc failed");
@@ -462,9 +522,14 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
 void usb_hcd_pxa27x_remove (struct usb_hcd *hcd, struct platform_device *pdev)
 {
         struct pxa27x_ohci *pxa_ohci = to_pxa27x_ohci(hcd);
+        unsigned int i;
 
         usb_remove_hcd(hcd);
         pxa27x_stop_hc(pxa_ohci, &pdev->dev);
+
+        for (i = 0; i < 3; ++i)
+                pxa27x_ohci_set_vbus_power(pxa_ohci, i, false);
+
         usb_put_hcd(hcd);
 }
 
@@ -563,7 +628,10 @@ static int __init ohci_pxa27x_init(void)
                 return -ENODEV;
 
         pr_info("%s: " DRIVER_DESC "\n", hcd_name);
+
         ohci_init_driver(&ohci_pxa27x_hc_driver, &pxa27x_overrides);
+        ohci_pxa27x_hc_driver.hub_control = pxa27x_ohci_hub_control;
+
         return platform_driver_register(&ohci_hcd_pxa27x_driver);
 }
 module_init(ohci_pxa27x_init);
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index ff7c8f1c48fb..3d753a9d3141 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -45,10 +45,6 @@ static struct clk *usb_clk;
 
 /* forward definitions */
 
-static int (*orig_ohci_hub_control)(struct usb_hcd  *hcd, u16 typeReq,
-                        u16 wValue, u16 wIndex, char *buf, u16 wLength);
-static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf);
-
 static void s3c2410_hcd_oc(struct s3c2410_hcd_info *info, int port_oc);
 
 /* conversion functions */
@@ -110,7 +106,7 @@ ohci_s3c2410_hub_status_data(struct usb_hcd *hcd, char *buf)
         int orig;
         int portno;
 
-        orig = orig_ohci_hub_status_data(hcd, buf);
+        orig = ohci_hub_status_data(hcd, buf);
 
         if (info == NULL)
                 return orig;
@@ -181,7 +177,7 @@ static int ohci_s3c2410_hub_control(
          * process the request straight away and exit */
 
         if (info == NULL) {
-                ret = orig_ohci_hub_control(hcd, typeReq, wValue,
+                ret = ohci_hub_control(hcd, typeReq, wValue,
                                        wIndex, buf, wLength);
                 goto out;
         }
@@ -231,7 +227,7 @@ static int ohci_s3c2410_hub_control(
                 break;
         }
 
-        ret = orig_ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
+        ret = ohci_hub_control(hcd, typeReq, wValue, wIndex, buf, wLength);
         if (ret)
                 goto out;
 
@@ -489,9 +485,6 @@ static int __init ohci_s3c2410_init(void)
          * override these functions by making it too easy.
          */
 
-        orig_ohci_hub_control = ohci_s3c2410_hc_driver.hub_control;
-        orig_ohci_hub_status_data = ohci_s3c2410_hc_driver.hub_status_data;
-
         ohci_s3c2410_hc_driver.hub_status_data  = ohci_s3c2410_hub_status_data;
         ohci_s3c2410_hc_driver.hub_control      = ohci_s3c2410_hub_control;
 
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 4550ce05af7f..05e02a709d4f 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -729,3 +729,6 @@ extern int	ohci_setup(struct usb_hcd *hcd);
 extern int      ohci_suspend(struct usb_hcd *hcd, bool do_wakeup);
 extern int      ohci_resume(struct usb_hcd *hcd, bool hibernated);
 #endif
+extern int      ohci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
+                                 u16 wIndex, char *buf, u16 wLength);
+extern int      ohci_hub_status_data(struct usb_hcd *hcd, char *buf);
diff --git a/drivers/usb/host/pci-quirks.h b/drivers/usb/host/pci-quirks.h
index 638e88f7a28b..c622ddf21c94 100644
--- a/drivers/usb/host/pci-quirks.h
+++ b/drivers/usb/host/pci-quirks.h
@@ -5,6 +5,7 @@
 void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
 int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
 int usb_amd_find_chipset_info(void);
+int usb_hcd_amd_remote_wakeup_quirk(struct pci_dev *pdev);
 bool usb_amd_hang_symptom_quirk(void);
 bool usb_amd_prefetch_quirk(void);
 void usb_amd_dev_put(void);
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 1ad6bc1951c7..6231ce6aa0c3 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -20,7 +20,8 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <linux/gfp.h>
+
+#include <linux/slab.h>
 #include <asm/unaligned.h>
 
 #include "xhci.h"
@@ -270,7 +271,6 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
         struct xhci_virt_device *virt_dev;
         struct xhci_command *cmd;
         unsigned long flags;
-        int timeleft;
         int ret;
         int i;
 
@@ -284,34 +284,31 @@ static int xhci_stop_device(struct xhci_hcd *xhci, int slot_id, int suspend)
 
         spin_lock_irqsave(&xhci->lock, flags);
         for (i = LAST_EP_INDEX; i > 0; i--) {
-                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue)
-                        xhci_queue_stop_endpoint(xhci, slot_id, i, suspend);
+                if (virt_dev->eps[i].ring && virt_dev->eps[i].ring->dequeue) {
+                        struct xhci_command *command;
+                        command = xhci_alloc_command(xhci, false, false,
+                                                     GFP_NOIO);
+                        if (!command) {
+                                spin_unlock_irqrestore(&xhci->lock, flags);
+                                xhci_free_command(xhci, cmd);
+                                return -ENOMEM;
+
+                        }
+                        xhci_queue_stop_endpoint(xhci, command, slot_id, i,
+                                                 suspend);
+                }
         }
-        cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        list_add_tail(&cmd->cmd_list, &virt_dev->cmd_list);
-        xhci_queue_stop_endpoint(xhci, slot_id, 0, suspend);
+        xhci_queue_stop_endpoint(xhci, cmd, slot_id, 0, suspend);
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for last stop endpoint command to finish */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        cmd->completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for stop endpoint command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                spin_lock_irqsave(&xhci->lock, flags);
-                /* The timeout might have raced with the event ring handler, so
-                 * only delete from the list if the item isn't poisoned.
-                 */
-                if (cmd->cmd_list.next != LIST_POISON1)
-                        list_del(&cmd->cmd_list);
-                spin_unlock_irqrestore(&xhci->lock, flags);
+        wait_for_completion(cmd->completion);
+
+        if (cmd->status == COMP_CMD_ABORT || cmd->status == COMP_CMD_STOP) {
+                xhci_warn(xhci, "Timeout while waiting for stop endpoint command\n");
                 ret = -ETIME;
-                goto command_cleanup;
         }
-
-command_cleanup:
         xhci_free_command(xhci, cmd);
         return ret;
 }
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index c089668308ad..6a57e81c2a76 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1020,7 +1020,6 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id,
         dev->num_rings_cached = 0;
 
         init_completion(&dev->cmd_completion);
-        INIT_LIST_HEAD(&dev->cmd_list);
         dev->udev = udev;
 
         /* Point to output device context in dcbaa. */
@@ -1794,10 +1793,11 @@ void xhci_free_command(struct xhci_hcd *xhci,
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct device   *dev = xhci_to_hcd(xhci)->self.controller;
-        struct xhci_cd  *cur_cd, *next_cd;
         int size;
         int i, j, num_ports;
 
+        del_timer_sync(&xhci->cmd_timer);
+
         /* Free the Event Ring Segment Table and the actual Event Ring */
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
@@ -1816,11 +1816,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed command ring");
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                list_del(&cur_cd->cancel_cmd_list);
-                kfree(cur_cd);
-        }
+        xhci_cleanup_command_queue(xhci);
 
         for (i = 1; i < MAX_HC_SLOTS; ++i)
                 xhci_free_virt_device(xhci, i);
@@ -2323,7 +2319,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         u32 page_size, temp;
         int i;
 
-        INIT_LIST_HEAD(&xhci->cancel_cmd_list);
+        INIT_LIST_HEAD(&xhci->cmd_list);
 
         page_size = readl(&xhci->op_regs->page_size);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
@@ -2509,6 +2505,11 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                         "Wrote ERST address to ir_set 0.");
         xhci_print_ir_set(xhci, 0);
 
+        /* init command timeout timer */
+        init_timer(&xhci->cmd_timer);
+        xhci->cmd_timer.data = (unsigned long) xhci;
+        xhci->cmd_timer.function = xhci_handle_command_timeout;
+
         /*
          * XXX: Might need to set the Interrupter Moderation Register to
          * something other than the default (~1ms minimum between interrupts).
diff --git a/drivers/usb/host/xhci-mvebu.c b/drivers/usb/host/xhci-mvebu.c
new file mode 100644
index 000000000000..1eefc988192d
--- /dev/null
+++ b/drivers/usb/host/xhci-mvebu.c
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 Marvell
+ * Author: Gregory CLEMENT <gregory.clement@free-electrons.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/io.h>
+#include <linux/mbus.h>
+#include <linux/of.h>
+#include <linux/platform_device.h>
+
+#include "xhci-mvebu.h"
+
+#define USB3_MAX_WINDOWS        4
+#define USB3_WIN_CTRL(w)        (0x0 + ((w) * 8))
+#define USB3_WIN_BASE(w)        (0x4 + ((w) * 8))
+
+static void xhci_mvebu_mbus_config(void __iomem *base,
+                        const struct mbus_dram_target_info *dram)
+{
+        int win;
+
+        /* Clear all existing windows */
+        for (win = 0; win < USB3_MAX_WINDOWS; win++) {
+                writel(0, base + USB3_WIN_CTRL(win));
+                writel(0, base + USB3_WIN_BASE(win));
+        }
+
+        /* Program each DRAM CS in a seperate window */
+        for (win = 0; win < dram->num_cs; win++) {
+                const struct mbus_dram_window *cs = dram->cs + win;
+
+                writel(((cs->size - 1) & 0xffff0000) | (cs->mbus_attr << 8) |
+                       (dram->mbus_dram_target_id << 4) | 1,
+                       base + USB3_WIN_CTRL(win));
+
+                writel((cs->base & 0xffff0000), base + USB3_WIN_BASE(win));
+        }
+}
+
+int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev)
+{
+        struct resource *res;
+        void __iomem *base;
+        const struct mbus_dram_target_info *dram;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res)
+                return -ENODEV;
+
+        /*
+         * We don't use devm_ioremap() because this mapping should
+         * only exists for the duration of this probe function.
+         */
+        base = ioremap(res->start, resource_size(res));
+        if (!base)
+                return -ENODEV;
+
+        dram = mv_mbus_dram_info();
+        xhci_mvebu_mbus_config(base, dram);
+
+        /*
+         * This memory area was only needed to configure the MBus
+         * windows, and is therefore no longer useful.
+         */
+        iounmap(base);
+
+        return 0;
+}
diff --git a/drivers/usb/host/xhci-mvebu.h b/drivers/usb/host/xhci-mvebu.h
new file mode 100644
index 000000000000..7ede92aa41f6
--- /dev/null
+++ b/drivers/usb/host/xhci-mvebu.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2014 Marvell
+ *
+ * Gregory Clement <gregory.clement@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __LINUX_XHCI_MVEBU_H
+#define __LINUX_XHCI_MVEBU_H
+#if IS_ENABLED(CONFIG_USB_XHCI_MVEBU)
+int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev);
+#else
+static inline int xhci_mvebu_mbus_init_quirk(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
+#endif /* __LINUX_XHCI_MVEBU_H */
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 35d447780707..e20520f42753 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -134,14 +134,14 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  */
                 if (pdev->subsystem_vendor == PCI_VENDOR_ID_HP)
                         xhci->quirks |= XHCI_SPURIOUS_WAKEUP;
-
+        }
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI) {
                 xhci->quirks |= XHCI_SPURIOUS_REBOOT;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
-                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
-                                "QUIRK: Resetting on resume");
                 xhci->quirks |= XHCI_TRUST_TX_LENGTH;
         }
         if (pdev->vendor == PCI_VENDOR_ID_RENESAS &&
@@ -149,6 +149,10 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
         if (pdev->vendor == PCI_VENDOR_ID_VIA)
                 xhci->quirks |= XHCI_RESET_ON_RESUME;
+
+        if (xhci->quirks & XHCI_RESET_ON_RESUME)
+                xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
+                                "QUIRK: Resetting on resume");
 }
 
 /* called during probe() after chip reset completes */
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 151901ce1ba9..29d8adb5c8d1 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -11,13 +11,15 @@
  * version 2 as published by the Free Software Foundation.
  */
 
-#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
 #include <linux/module.h>
-#include <linux/slab.h>
 #include <linux/of.h>
-#include <linux/dma-mapping.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
 
 #include "xhci.h"
+#include "xhci-mvebu.h"
 
 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
@@ -35,6 +37,11 @@ static int xhci_plat_setup(struct usb_hcd *hcd)
         return xhci_gen_setup(hcd, xhci_plat_quirks);
 }
 
+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",
@@ -50,7 +57,7 @@ static const struct hc_driver xhci_plat_xhci_driver = {
          * basic lifecycle operations
          */
         .reset =                xhci_plat_setup,
-        .start =                xhci_run,
+        .start =                xhci_plat_start,
         .stop =                 xhci_stop,
         .shutdown =             xhci_shutdown,
 
@@ -91,6 +98,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
         struct xhci_hcd         *xhci;
         struct resource         *res;
         struct usb_hcd          *hcd;
+        struct clk              *clk;
         int                     ret;
         int                     irq;
 
@@ -107,6 +115,15 @@ static int xhci_plat_probe(struct platform_device *pdev)
         if (!res)
                 return -ENODEV;
 
+        if (of_device_is_compatible(pdev->dev.of_node,
+                                    "marvell,armada-375-xhci") ||
+            of_device_is_compatible(pdev->dev.of_node,
+                                    "marvell,armada-380-xhci")) {
+                ret = xhci_mvebu_mbus_init_quirk(pdev);
+                if (ret)
+                        return ret;
+        }
+
         /* Initialize dma_mask and coherent_dma_mask to 32-bits */
         ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
         if (ret)
@@ -137,14 +154,27 @@ static int xhci_plat_probe(struct platform_device *pdev)
                 goto release_mem_region;
         }
 
+        /*
+         * Not all platforms have a clk so it is not an error if the
+         * clock does not exists.
+         */
+        clk = devm_clk_get(&pdev->dev, NULL);
+        if (!IS_ERR(clk)) {
+                ret = clk_prepare_enable(clk);
+                if (ret)
+                        goto unmap_registers;
+        }
+
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
-                goto unmap_registers;
+                goto disable_clk;
+
         device_wakeup_enable(hcd->self.controller);
 
         /* USB 2.0 roothub is stored in the platform_device now. */
         hcd = platform_get_drvdata(pdev);
         xhci = hcd_to_xhci(hcd);
+        xhci->clk = clk;
         xhci->shared_hcd = usb_create_shared_hcd(driver, &pdev->dev,
                         dev_name(&pdev->dev), hcd);
         if (!xhci->shared_hcd) {
@@ -173,6 +203,10 @@ put_usb3_hcd:
 dealloc_usb2_hcd:
         usb_remove_hcd(hcd);
 
+disable_clk:
+        if (!IS_ERR(clk))
+                clk_disable_unprepare(clk);
+
 unmap_registers:
         iounmap(hcd->regs);
 
@@ -189,11 +223,14 @@ static int xhci_plat_remove(struct platform_device *dev)
 {
         struct usb_hcd  *hcd = platform_get_drvdata(dev);
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+        struct clk *clk = xhci->clk;
 
         usb_remove_hcd(xhci->shared_hcd);
         usb_put_hcd(xhci->shared_hcd);
 
         usb_remove_hcd(hcd);
+        if (!IS_ERR(clk))
+                clk_disable_unprepare(clk);
         iounmap(hcd->regs);
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
@@ -202,7 +239,7 @@ static int xhci_plat_remove(struct platform_device *dev)
         return 0;
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int xhci_plat_suspend(struct device *dev)
 {
         struct usb_hcd  *hcd = dev_get_drvdata(dev);
@@ -231,6 +268,8 @@ static const struct dev_pm_ops xhci_plat_pm_ops = {
 static const struct of_device_id usb_xhci_of_match[] = {
         { .compatible = "generic-xhci" },
         { .compatible = "xhci-platform" },
+        { .compatible = "marvell,armada-375-xhci"},
+        { .compatible = "marvell,armada-380-xhci"},
         { },
 };
 MODULE_DEVICE_TABLE(of, usb_xhci_of_match);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7a0e3c720c00..d67ff71209f5 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -69,10 +69,6 @@
 #include "xhci.h"
 #include "xhci-trace.h"
 
-static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_virt_device *virt_dev,
-                struct xhci_event_cmd *event);
-
 /*
  * Returns zero if the TRB isn't in this segment, otherwise it returns the DMA
  * address of the TRB.
@@ -123,16 +119,6 @@ static int enqueue_is_link_trb(struct xhci_ring *ring)
         return TRB_TYPE_LINK_LE32(link->control);
 }
 
-union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring)
-{
-        /* Enqueue pointer can be left pointing to the link TRB,
-         * we must handle that
-         */
-        if (TRB_TYPE_LINK_LE32(ring->enqueue->link.control))
-                return ring->enq_seg->next->trbs;
-        return ring->enqueue;
-}
-
 /* Updates trb to point to the next TRB in the ring, and updates seg if the next
  * TRB is in a new segment.  This does not skip over link TRBs, and it does not
  * effect the ring dequeue or enqueue pointers.
@@ -301,17 +287,7 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
 
         xhci_dbg(xhci, "Abort command ring\n");
 
-        if (!(xhci->cmd_ring_state & CMD_RING_STATE_RUNNING)) {
-                xhci_dbg(xhci, "The command ring isn't running, "
-                                "Have the command ring been stopped?\n");
-                return 0;
-        }
-
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
-        if (!(temp_64 & CMD_RING_RUNNING)) {
-                xhci_dbg(xhci, "Command ring had been stopped\n");
-                return 0;
-        }
         xhci->cmd_ring_state = CMD_RING_STATE_ABORTED;
         xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
                         &xhci->op_regs->cmd_ring);
@@ -337,71 +313,6 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
         return 0;
 }
 
-static int xhci_queue_cd(struct xhci_hcd *xhci,
-                struct xhci_command *command,
-                union xhci_trb *cmd_trb)
-{
-        struct xhci_cd *cd;
-        cd = kzalloc(sizeof(struct xhci_cd), GFP_ATOMIC);
-        if (!cd)
-                return -ENOMEM;
-        INIT_LIST_HEAD(&cd->cancel_cmd_list);
-
-        cd->command = command;
-        cd->cmd_trb = cmd_trb;
-        list_add_tail(&cd->cancel_cmd_list, &xhci->cancel_cmd_list);
-
-        return 0;
-}
-
-/*
- * Cancel the command which has issue.
- *
- * Some commands may hang due to waiting for acknowledgement from
- * usb device. It is outside of the xHC's ability to control and
- * will cause the command ring is blocked. When it occurs software
- * should intervene to recover the command ring.
- * See Section 4.6.1.1 and 4.6.1.2
- */
-int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
-                union xhci_trb *cmd_trb)
-{
-        int retval = 0;
-        unsigned long flags;
-
-        spin_lock_irqsave(&xhci->lock, flags);
-
-        if (xhci->xhc_state & XHCI_STATE_DYING) {
-                xhci_warn(xhci, "Abort the command ring,"
-                                " but the xHCI is dead.\n");
-                retval = -ESHUTDOWN;
-                goto fail;
-        }
-
-        /* queue the cmd desriptor to cancel_cmd_list */
-        retval = xhci_queue_cd(xhci, command, cmd_trb);
-        if (retval) {
-                xhci_warn(xhci, "Queuing command descriptor failed.\n");
-                goto fail;
-        }
-
-        /* abort command ring */
-        retval = xhci_abort_cmd_ring(xhci);
-        if (retval) {
-                xhci_err(xhci, "Abort command ring failed\n");
-                if (unlikely(retval == -ESHUTDOWN)) {
-                        spin_unlock_irqrestore(&xhci->lock, flags);
-                        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
-                        xhci_dbg(xhci, "xHCI host controller is dead.\n");
-                        return retval;
-                }
-        }
-
-fail:
-        spin_unlock_irqrestore(&xhci->lock, flags);
-        return retval;
-}
-
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
                 unsigned int ep_index,
@@ -684,12 +595,14 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
         }
 }
 
-static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
+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)
@@ -704,7 +617,7 @@ void xhci_queue_new_dequeue_state(struct xhci_hcd *xhci,
                         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, slot_id, ep_index, stream_id,
+        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);
@@ -773,7 +686,6 @@ static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
                 union xhci_trb *trb, struct xhci_event_cmd *event)
 {
         unsigned int ep_index;
-        struct xhci_virt_device *virt_dev;
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
         struct list_head *entry;
@@ -783,11 +695,7 @@ static void xhci_handle_cmd_stop_ep(struct xhci_hcd *xhci, int slot_id,
         struct xhci_dequeue_state deq_state;
 
         if (unlikely(TRB_TO_SUSPEND_PORT(le32_to_cpu(trb->generic.field[3])))) {
-                virt_dev = xhci->devs[slot_id];
-                if (virt_dev)
-                        handle_cmd_in_cmd_wait_list(xhci, virt_dev,
-                                event);
-                else
+                if (!xhci->devs[slot_id])
                         xhci_warn(xhci, "Stop endpoint command "
                                 "completion for disabled slot %u\n",
                                 slot_id);
@@ -858,7 +766,9 @@ remove_finished_td:
 
         /* If necessary, queue a Set Transfer Ring Dequeue Pointer command */
         if (deq_state.new_deq_ptr && deq_state.new_deq_seg) {
-                xhci_queue_new_dequeue_state(xhci,
+                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);
@@ -1206,9 +1116,11 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
          * because the HW can't handle two commands being queued in a row.
          */
         if (xhci->quirks & XHCI_RESET_EP_QUIRK) {
+                struct xhci_command *command;
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
                 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
                                 "Queueing configure endpoint command");
-                xhci_queue_configure_endpoint(xhci,
+                xhci_queue_configure_endpoint(xhci, command,
                                 xhci->devs[slot_id]->in_ctx->dma, slot_id,
                                 false);
                 xhci_ring_cmd_db(xhci);
@@ -1219,187 +1131,6 @@ static void xhci_handle_cmd_reset_ep(struct xhci_hcd *xhci, int slot_id,
         }
 }
 
-/* Complete the command and detele it from the devcie's command queue.
- */
-static void xhci_complete_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_command *command, u32 status)
-{
-        command->status = status;
-        list_del(&command->cmd_list);
-        if (command->completion)
-                complete(command->completion);
-        else
-                xhci_free_command(xhci, command);
-}
-
-
-/* Check to see if a command in the device's command queue matches this one.
- * Signal the completion or free the command, and return 1.  Return 0 if the
- * completed command isn't at the head of the command list.
- */
-static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
-                struct xhci_virt_device *virt_dev,
-                struct xhci_event_cmd *event)
-{
-        struct xhci_command *command;
-
-        if (list_empty(&virt_dev->cmd_list))
-                return 0;
-
-        command = list_entry(virt_dev->cmd_list.next,
-                        struct xhci_command, cmd_list);
-        if (xhci->cmd_ring->dequeue != command->command_trb)
-                return 0;
-
-        xhci_complete_cmd_in_cmd_wait_list(xhci, command,
-                        GET_COMP_CODE(le32_to_cpu(event->status)));
-        return 1;
-}
-
-/*
- * Finding the command trb need to be cancelled and modifying it to
- * NO OP command. And if the command is in device's command wait
- * list, finishing and freeing it.
- *
- * If we can't find the command trb, we think it had already been
- * executed.
- */
-static void xhci_cmd_to_noop(struct xhci_hcd *xhci, struct xhci_cd *cur_cd)
-{
-        struct xhci_segment *cur_seg;
-        union xhci_trb *cmd_trb;
-        u32 cycle_state;
-
-        if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
-                return;
-
-        /* find the current segment of command ring */
-        cur_seg = find_trb_seg(xhci->cmd_ring->first_seg,
-                        xhci->cmd_ring->dequeue, &cycle_state);
-
-        if (!cur_seg) {
-                xhci_warn(xhci, "Command ring mismatch, dequeue = %p %llx (dma)\n",
-                                xhci->cmd_ring->dequeue,
-                                (unsigned long long)
-                                xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
-                                        xhci->cmd_ring->dequeue));
-                xhci_debug_ring(xhci, xhci->cmd_ring);
-                xhci_dbg_ring_ptrs(xhci, xhci->cmd_ring);
-                return;
-        }
-
-        /* find the command trb matched by cd from command ring */
-        for (cmd_trb = xhci->cmd_ring->dequeue;
-                        cmd_trb != xhci->cmd_ring->enqueue;
-                        next_trb(xhci, xhci->cmd_ring, &cur_seg, &cmd_trb)) {
-                /* If the trb is link trb, continue */
-                if (TRB_TYPE_LINK_LE32(cmd_trb->generic.field[3]))
-                        continue;
-
-                if (cur_cd->cmd_trb == cmd_trb) {
-
-                        /* If the command in device's command list, we should
-                         * finish it and free the command structure.
-                         */
-                        if (cur_cd->command)
-                                xhci_complete_cmd_in_cmd_wait_list(xhci,
-                                        cur_cd->command, COMP_CMD_STOP);
-
-                        /* get cycle state from the origin command trb */
-                        cycle_state = le32_to_cpu(cmd_trb->generic.field[3])
-                                & TRB_CYCLE;
-
-                        /* modify the command trb to NO OP command */
-                        cmd_trb->generic.field[0] = 0;
-                        cmd_trb->generic.field[1] = 0;
-                        cmd_trb->generic.field[2] = 0;
-                        cmd_trb->generic.field[3] = cpu_to_le32(
-                                        TRB_TYPE(TRB_CMD_NOOP) | cycle_state);
-                        break;
-                }
-        }
-}
-
-static void xhci_cancel_cmd_in_cd_list(struct xhci_hcd *xhci)
-{
-        struct xhci_cd *cur_cd, *next_cd;
-
-        if (list_empty(&xhci->cancel_cmd_list))
-                return;
-
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                xhci_cmd_to_noop(xhci, cur_cd);
-                list_del(&cur_cd->cancel_cmd_list);
-                kfree(cur_cd);
-        }
-}
-
-/*
- * traversing the cancel_cmd_list. If the command descriptor according
- * to cmd_trb is found, the function free it and return 1, otherwise
- * return 0.
- */
-static int xhci_search_cmd_trb_in_cd_list(struct xhci_hcd *xhci,
-                union xhci_trb *cmd_trb)
-{
-        struct xhci_cd *cur_cd, *next_cd;
-
-        if (list_empty(&xhci->cancel_cmd_list))
-                return 0;
-
-        list_for_each_entry_safe(cur_cd, next_cd,
-                        &xhci->cancel_cmd_list, cancel_cmd_list) {
-                if (cur_cd->cmd_trb == cmd_trb) {
-                        if (cur_cd->command)
-                                xhci_complete_cmd_in_cmd_wait_list(xhci,
-                                        cur_cd->command, COMP_CMD_STOP);
-                        list_del(&cur_cd->cancel_cmd_list);
-                        kfree(cur_cd);
-                        return 1;
-                }
-        }
-
-        return 0;
-}
-
-/*
- * If the cmd_trb_comp_code is COMP_CMD_ABORT, we just check whether the
- * trb pointed by the command ring dequeue pointer is the trb we want to
- * cancel or not. And if the cmd_trb_comp_code is COMP_CMD_STOP, we will
- * traverse the cancel_cmd_list to trun the all of the commands according
- * to command descriptor to NO-OP trb.
- */
-static int handle_stopped_cmd_ring(struct xhci_hcd *xhci,
-                int cmd_trb_comp_code)
-{
-        int cur_trb_is_good = 0;
-
-        /* Searching the cmd trb pointed by the command ring dequeue
-         * pointer in command descriptor list. If it is found, free it.
-         */
-        cur_trb_is_good = xhci_search_cmd_trb_in_cd_list(xhci,
-                        xhci->cmd_ring->dequeue);
-
-        if (cmd_trb_comp_code == COMP_CMD_ABORT)
-                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
-        else if (cmd_trb_comp_code == COMP_CMD_STOP) {
-                /* traversing the cancel_cmd_list and canceling
-                 * the command according to command descriptor
-                 */
-                xhci_cancel_cmd_in_cd_list(xhci);
-
-                xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
-                /*
-                 * ring command ring doorbell again to restart the
-                 * command ring
-                 */
-                if (xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue)
-                        xhci_ring_cmd_db(xhci);
-        }
-        return cur_trb_is_good;
-}
-
 static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
                 u32 cmd_comp_code)
 {
@@ -1407,7 +1138,6 @@ static void xhci_handle_cmd_enable_slot(struct xhci_hcd *xhci, int slot_id,
                 xhci->slot_id = slot_id;
         else
                 xhci->slot_id = 0;
-        complete(&xhci->addr_dev);
 }
 
 static void xhci_handle_cmd_disable_slot(struct xhci_hcd *xhci, int slot_id)
@@ -1432,9 +1162,6 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
         unsigned int ep_state;
         u32 add_flags, drop_flags;
 
-        virt_dev = xhci->devs[slot_id];
-        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                return;
         /*
          * Configure endpoint commands can come from the USB core
          * configuration or alt setting changes, or because the HW
@@ -1443,6 +1170,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
          * If the command was for a halted endpoint, the xHCI driver
          * is not waiting on the configure endpoint command.
          */
+        virt_dev = xhci->devs[slot_id];
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "Could not get input context, bad type.\n");
@@ -1465,7 +1193,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
                         add_flags - SLOT_FLAG == drop_flags) {
                 ep_state = virt_dev->eps[ep_index].ep_state;
                 if (!(ep_state & EP_HALTED))
-                        goto bandwidth_change;
+                        return;
                 xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
                                 "Completed config ep cmd - "
                                 "last ep index = %d, state = %d",
@@ -1475,43 +1203,14 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
-bandwidth_change:
-        xhci_dbg_trace(xhci,  trace_xhci_dbg_context_change,
-                        "Completed config ep cmd");
-        virt_dev->cmd_status = cmd_comp_code;
-        complete(&virt_dev->cmd_completion);
         return;
 }
 
-static void xhci_handle_cmd_eval_ctx(struct xhci_hcd *xhci, int slot_id,
-                struct xhci_event_cmd *event, u32 cmd_comp_code)
-{
-        struct xhci_virt_device *virt_dev;
-
-        virt_dev = xhci->devs[slot_id];
-        if (handle_cmd_in_cmd_wait_list(xhci, virt_dev, event))
-                return;
-        virt_dev->cmd_status = cmd_comp_code;
-        complete(&virt_dev->cmd_completion);
-}
-
-static void xhci_handle_cmd_addr_dev(struct xhci_hcd *xhci, int slot_id,
-                u32 cmd_comp_code)
-{
-        xhci->devs[slot_id]->cmd_status = cmd_comp_code;
-        complete(&xhci->addr_dev);
-}
-
 static void xhci_handle_cmd_reset_dev(struct xhci_hcd *xhci, int slot_id,
                 struct xhci_event_cmd *event)
 {
-        struct xhci_virt_device *virt_dev;
-
         xhci_dbg(xhci, "Completed reset device command.\n");
-        virt_dev = xhci->devs[slot_id];
-        if (virt_dev)
-                handle_cmd_in_cmd_wait_list(xhci, virt_dev, event);
-        else
+        if (!xhci->devs[slot_id])
                 xhci_warn(xhci, "Reset device command completion "
                                 "for disabled slot %u\n", slot_id);
 }
@@ -1529,6 +1228,116 @@ static void xhci_handle_cmd_nec_get_fw(struct xhci_hcd *xhci,
                         NEC_FW_MINOR(le32_to_cpu(event->status)));
 }
 
+static void xhci_complete_del_and_free_cmd(struct xhci_command *cmd, u32 status)
+{
+        list_del(&cmd->cmd_list);
+
+        if (cmd->completion) {
+                cmd->status = status;
+                complete(cmd->completion);
+        } else {
+                kfree(cmd);
+        }
+}
+
+void xhci_cleanup_command_queue(struct xhci_hcd *xhci)
+{
+        struct xhci_command *cur_cmd, *tmp_cmd;
+        list_for_each_entry_safe(cur_cmd, tmp_cmd, &xhci->cmd_list, cmd_list)
+                xhci_complete_del_and_free_cmd(cur_cmd, COMP_CMD_ABORT);
+}
+
+/*
+ * Turn all commands on command ring with status set to "aborted" to no-op trbs.
+ * If there are other commands waiting then restart the ring and kick the timer.
+ * This must be called with command ring stopped and xhci->lock held.
+ */
+static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci,
+                                         struct xhci_command *cur_cmd)
+{
+        struct xhci_command *i_cmd, *tmp_cmd;
+        u32 cycle_state;
+
+        /* Turn all aborted commands in list to no-ops, then restart */
+        list_for_each_entry_safe(i_cmd, tmp_cmd, &xhci->cmd_list,
+                                 cmd_list) {
+
+                if (i_cmd->status != COMP_CMD_ABORT)
+                        continue;
+
+                i_cmd->status = COMP_CMD_STOP;
+
+                xhci_dbg(xhci, "Turn aborted command %p to no-op\n",
+                         i_cmd->command_trb);
+                /* get cycle state from the original cmd trb */
+                cycle_state = le32_to_cpu(
+                        i_cmd->command_trb->generic.field[3]) & TRB_CYCLE;
+                /* modify the command trb to no-op command */
+                i_cmd->command_trb->generic.field[0] = 0;
+                i_cmd->command_trb->generic.field[1] = 0;
+                i_cmd->command_trb->generic.field[2] = 0;
+                i_cmd->command_trb->generic.field[3] = cpu_to_le32(
+                        TRB_TYPE(TRB_CMD_NOOP) | cycle_state);
+
+                /*
+                 * caller waiting for completion is called when command
+                 *  completion event is received for these no-op commands
+                 */
+        }
+
+        xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
+
+        /* ring command ring doorbell to restart the command ring */
+        if ((xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue) &&
+            !(xhci->xhc_state & XHCI_STATE_DYING)) {
+                xhci->current_cmd = cur_cmd;
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+                xhci_ring_cmd_db(xhci);
+        }
+        return;
+}
+
+
+void xhci_handle_command_timeout(unsigned long data)
+{
+        struct xhci_hcd *xhci;
+        int ret;
+        unsigned long flags;
+        u64 hw_ring_state;
+        struct xhci_command *cur_cmd = NULL;
+        xhci = (struct xhci_hcd *) data;
+
+        /* mark this command to be cancelled */
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (xhci->current_cmd) {
+                cur_cmd = xhci->current_cmd;
+                cur_cmd->status = COMP_CMD_ABORT;
+        }
+
+
+        /* Make sure command ring is running before aborting it */
+        hw_ring_state = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        if ((xhci->cmd_ring_state & CMD_RING_STATE_RUNNING) &&
+            (hw_ring_state & CMD_RING_RUNNING))  {
+
+                spin_unlock_irqrestore(&xhci->lock, flags);
+                xhci_dbg(xhci, "Command timeout\n");
+                ret = xhci_abort_cmd_ring(xhci);
+                if (unlikely(ret == -ESHUTDOWN)) {
+                        xhci_err(xhci, "Abort command ring failed\n");
+                        xhci_cleanup_command_queue(xhci);
+                        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
+                        xhci_dbg(xhci, "xHCI host controller is dead.\n");
+                }
+                return;
+        }
+        /* command timeout on stopped ring, ring can't be aborted */
+        xhci_dbg(xhci, "Command timeout on stopped ring\n");
+        xhci_handle_stopped_cmd_ring(xhci, xhci->current_cmd);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return;
+}
+
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
@@ -1537,6 +1346,7 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
         dma_addr_t cmd_dequeue_dma;
         u32 cmd_comp_code;
         union xhci_trb *cmd_trb;
+        struct xhci_command *cmd;
         u32 cmd_type;
 
         cmd_dma = le64_to_cpu(event->cmd_trb);
@@ -1554,26 +1364,35 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 return;
         }
 
+        cmd = list_entry(xhci->cmd_list.next, struct xhci_command, cmd_list);
+
+        if (cmd->command_trb != xhci->cmd_ring->dequeue) {
+                xhci_err(xhci,
+                         "Command completion event does not match command\n");
+                return;
+        }
+
+        del_timer(&xhci->cmd_timer);
+
         trace_xhci_cmd_completion(cmd_trb, (struct xhci_generic_trb *) event);
 
         cmd_comp_code = GET_COMP_CODE(le32_to_cpu(event->status));
-        if (cmd_comp_code == COMP_CMD_ABORT || cmd_comp_code == COMP_CMD_STOP) {
-                /* If the return value is 0, we think the trb pointed by
-                 * command ring dequeue pointer is a good trb. The good
-                 * trb means we don't want to cancel the trb, but it have
-                 * been stopped by host. So we should handle it normally.
-                 * Otherwise, driver should invoke inc_deq() and return.
-                 */
-                if (handle_stopped_cmd_ring(xhci, cmd_comp_code)) {
-                        inc_deq(xhci, xhci->cmd_ring);
-                        return;
-                }
-                /* There is no command to handle if we get a stop event when the
-                 * command ring is empty, event->cmd_trb points to the next
-                 * unset command
-                 */
-                if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
-                        return;
+
+        /* If CMD ring stopped we own the trbs between enqueue and dequeue */
+        if (cmd_comp_code == COMP_CMD_STOP) {
+                xhci_handle_stopped_cmd_ring(xhci, cmd);
+                return;
+        }
+        /*
+         * Host aborted the command ring, check if the current command was
+         * supposed to be aborted, otherwise continue normally.
+         * The command ring is stopped now, but the xHC will issue a Command
+         * Ring Stopped event which will cause us to restart it.
+         */
+        if (cmd_comp_code == COMP_CMD_ABORT) {
+                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
+                if (cmd->status == COMP_CMD_ABORT)
+                        goto event_handled;
         }
 
         cmd_type = TRB_FIELD_TO_TYPE(le32_to_cpu(cmd_trb->generic.field[3]));
@@ -1585,13 +1404,13 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci_handle_cmd_disable_slot(xhci, slot_id);
                 break;
         case TRB_CONFIG_EP:
-                xhci_handle_cmd_config_ep(xhci, slot_id, event, cmd_comp_code);
+                if (!cmd->completion)
+                        xhci_handle_cmd_config_ep(xhci, slot_id, event,
+                                                  cmd_comp_code);
                 break;
         case TRB_EVAL_CONTEXT:
-                xhci_handle_cmd_eval_ctx(xhci, slot_id, event, cmd_comp_code);
                 break;
         case TRB_ADDR_DEV:
-                xhci_handle_cmd_addr_dev(xhci, slot_id, cmd_comp_code);
                 break;
         case TRB_STOP_RING:
                 WARN_ON(slot_id != TRB_TO_SLOT_ID(
@@ -1604,6 +1423,9 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci_handle_cmd_set_deq(xhci, slot_id, cmd_trb, cmd_comp_code);
                 break;
         case TRB_CMD_NOOP:
+                /* Is this an aborted command turned to NO-OP? */
+                if (cmd->status == COMP_CMD_STOP)
+                        cmd_comp_code = COMP_CMD_STOP;
                 break;
         case TRB_RESET_EP:
                 WARN_ON(slot_id != TRB_TO_SLOT_ID(
@@ -1623,6 +1445,17 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci->error_bitmask |= 1 << 6;
                 break;
         }
+
+        /* restart timer if this wasn't the last command */
+        if (cmd->cmd_list.next != &xhci->cmd_list) {
+                xhci->current_cmd = list_entry(cmd->cmd_list.next,
+                                               struct xhci_command, cmd_list);
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+        }
+
+event_handled:
+        xhci_complete_del_and_free_cmd(cmd, cmd_comp_code);
+
         inc_deq(xhci, xhci->cmd_ring);
 }
 
@@ -1938,11 +1771,16 @@ static void xhci_cleanup_halted_endpoint(struct xhci_hcd *xhci,
                 struct xhci_td *td, union xhci_trb *event_trb)
 {
         struct xhci_virt_ep *ep = &xhci->devs[slot_id]->eps[ep_index];
+        struct xhci_command *command;
+        command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+        if (!command)
+                return;
+
         ep->ep_state |= EP_HALTED;
         ep->stopped_td = td;
         ep->stopped_stream = stream_id;
 
-        xhci_queue_reset_ep(xhci, slot_id, ep_index);
+        xhci_queue_reset_ep(xhci, command, slot_id, ep_index);
         xhci_cleanup_stalled_ring(xhci, td->urb->dev, ep_index);
 
         ep->stopped_td = NULL;
@@ -2654,7 +2492,7 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                                  * successful event after a short transfer.
                                  * Ignore it.
                                  */
-                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) && 
+                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) &&
                                                 ep_ring->last_td_was_short) {
                                         ep_ring->last_td_was_short = false;
                                         ret = 0;
@@ -3996,11 +3834,14 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
  * Don't decrement xhci->cmd_ring_reserved_trbs after we've queued the TRB
  * because the command event handler may want to resubmit a failed command.
  */
-static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
-                u32 field3, u32 field4, bool command_must_succeed)
+static int queue_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                         u32 field1, u32 field2,
+                         u32 field3, u32 field4, bool command_must_succeed)
 {
         int reserved_trbs = xhci->cmd_ring_reserved_trbs;
         int ret;
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ESHUTDOWN;
 
         if (!command_must_succeed)
                 reserved_trbs++;
@@ -4014,57 +3855,71 @@ static int queue_command(struct xhci_hcd *xhci, u32 field1, u32 field2,
                                         "unfailable commands failed.\n");
                 return ret;
         }
+
+        cmd->command_trb = xhci->cmd_ring->enqueue;
+        list_add_tail(&cmd->cmd_list, &xhci->cmd_list);
+
+        /* if there are no other commands queued we start the timeout timer */
+        if (xhci->cmd_list.next == &cmd->cmd_list &&
+            !timer_pending(&xhci->cmd_timer)) {
+                xhci->current_cmd = cmd;
+                mod_timer(&xhci->cmd_timer, jiffies + XHCI_CMD_DEFAULT_TIMEOUT);
+        }
+
         queue_trb(xhci, xhci->cmd_ring, false, field1, field2, field3,
                         field4 | xhci->cmd_ring->cycle_state);
         return 0;
 }
 
 /* Queue a slot enable or disable request on the command ring */
-int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id)
+int xhci_queue_slot_control(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 trb_type, u32 slot_id)
 {
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         TRB_TYPE(trb_type) | SLOT_ID_FOR_TRB(slot_id), false);
 }
 
 /* Queue an address device command TRB */
-int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                              u32 slot_id, enum xhci_setup_dev setup)
+int xhci_queue_address_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, enum xhci_setup_dev setup)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id)
                         | (setup == SETUP_CONTEXT_ONLY ? TRB_BSR : 0), false);
 }
 
-int xhci_queue_vendor_command(struct xhci_hcd *xhci,
+int xhci_queue_vendor_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
                 u32 field1, u32 field2, u32 field3, u32 field4)
 {
-        return queue_command(xhci, field1, field2, field3, field4, false);
+        return queue_command(xhci, cmd, field1, field2, field3, field4, false);
 }
 
 /* Queue a reset device command TRB */
-int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id)
+int xhci_queue_reset_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 slot_id)
 {
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         TRB_TYPE(TRB_RESET_DEV) | SLOT_ID_FOR_TRB(slot_id),
                         false);
 }
 
 /* Queue a configure endpoint command TRB */
-int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
+int xhci_queue_configure_endpoint(struct xhci_hcd *xhci,
+                struct xhci_command *cmd, dma_addr_t in_ctx_ptr,
                 u32 slot_id, bool command_must_succeed)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_CONFIG_EP) | SLOT_ID_FOR_TRB(slot_id),
                         command_must_succeed);
 }
 
 /* Queue an evaluate context command TRB */
-int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed)
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, bool command_must_succeed)
 {
-        return queue_command(xhci, lower_32_bits(in_ctx_ptr),
+        return queue_command(xhci, cmd, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
                         TRB_TYPE(TRB_EVAL_CONTEXT) | SLOT_ID_FOR_TRB(slot_id),
                         command_must_succeed);
@@ -4074,25 +3929,26 @@ int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
  * Suspend is set to indicate "Stop Endpoint Command" is being issued to stop
  * activity on an endpoint that is about to be suspended.
  */
-int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, int suspend)
+int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                             int slot_id, unsigned int ep_index, int suspend)
 {
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_STOP_RING);
         u32 trb_suspend = SUSPEND_PORT_FOR_TRB(suspend);
 
-        return queue_command(xhci, 0, 0, 0,
+        return queue_command(xhci, cmd, 0, 0, 0,
                         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, int slot_id,
-                unsigned int ep_index, unsigned int stream_id,
-                struct xhci_segment *deq_seg,
-                union xhci_trb *deq_ptr, u32 cycle_state)
+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)
 {
         dma_addr_t addr;
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
@@ -4119,18 +3975,19 @@ static int queue_set_tr_deq(struct xhci_hcd *xhci, int slot_id,
         ep->queued_deq_ptr = deq_ptr;
         if (stream_id)
                 trb_sct = SCT_FOR_TRB(SCT_PRI_TR);
-        return queue_command(xhci, lower_32_bits(addr) | trb_sct | cycle_state,
+        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);
 }
 
-int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index)
+int xhci_queue_reset_ep(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                        int slot_id, unsigned int ep_index)
 {
         u32 trb_slot_id = SLOT_ID_FOR_TRB(slot_id);
         u32 trb_ep_index = EP_ID_FOR_TRB(ep_index);
         u32 type = TRB_TYPE(TRB_RESET_EP);
 
-        return queue_command(xhci, 0, 0, 0, trb_slot_id | trb_ep_index | type,
-                        false);
+        return queue_command(xhci, cmd, 0, 0, 0,
+                        trb_slot_id | trb_ep_index | type, false);
 }
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 300836972faa..2b8d9a24af09 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -291,7 +291,7 @@ static int xhci_setup_msix(struct xhci_hcd *xhci)
                 xhci->msix_entries[i].vector = 0;
         }
 
-        ret = pci_enable_msix(pdev, xhci->msix_entries, xhci->msix_count);
+        ret = pci_enable_msix_exact(pdev, xhci->msix_entries, xhci->msix_count);
         if (ret) {
                 xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                                 "Failed to enable MSI-X");
@@ -641,10 +641,14 @@ int xhci_run(struct usb_hcd *hcd)
         writel(ER_IRQ_ENABLE(temp), &xhci->ir_set->irq_pending);
         xhci_print_ir_set(xhci, 0);
 
-        if (xhci->quirks & XHCI_NEC_HOST)
-                xhci_queue_vendor_command(xhci, 0, 0, 0,
+        if (xhci->quirks & XHCI_NEC_HOST) {
+                struct xhci_command *command;
+                command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+                if (!command)
+                        return -ENOMEM;
+                xhci_queue_vendor_command(xhci, command, 0, 0, 0,
                                 TRB_TYPE(TRB_NEC_GET_FW));
-
+        }
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "Finished xhci_run for USB2 roothub");
         return 0;
@@ -1187,10 +1191,10 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
 static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, struct urb *urb)
 {
-        struct xhci_container_ctx *in_ctx;
         struct xhci_container_ctx *out_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
         struct xhci_ep_ctx *ep_ctx;
+        struct xhci_command *command;
         int max_packet_size;
         int hw_max_packet_size;
         int ret = 0;
@@ -1215,18 +1219,24 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 /* FIXME: This won't work if a non-default control endpoint
                  * changes max packet sizes.
                  */
-                in_ctx = xhci->devs[slot_id]->in_ctx;
-                ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+
+                command = xhci_alloc_command(xhci, false, true, GFP_KERNEL);
+                if (!command)
+                        return -ENOMEM;
+
+                command->in_ctx = xhci->devs[slot_id]->in_ctx;
+                ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
                 if (!ctrl_ctx) {
                         xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                         __func__);
-                        return -ENOMEM;
+                        ret = -ENOMEM;
+                        goto command_cleanup;
                 }
                 /* Set up the modified control endpoint 0 */
                 xhci_endpoint_copy(xhci, xhci->devs[slot_id]->in_ctx,
                                 xhci->devs[slot_id]->out_ctx, ep_index);
 
-                ep_ctx = xhci_get_ep_ctx(xhci, in_ctx, ep_index);
+                ep_ctx = xhci_get_ep_ctx(xhci, command->in_ctx, ep_index);
                 ep_ctx->ep_info2 &= cpu_to_le32(~MAX_PACKET_MASK);
                 ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet_size));
 
@@ -1234,17 +1244,20 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                 ctrl_ctx->drop_flags = 0;
 
                 xhci_dbg(xhci, "Slot %d input context\n", slot_id);
-                xhci_dbg_ctx(xhci, in_ctx, ep_index);
+                xhci_dbg_ctx(xhci, command->in_ctx, ep_index);
                 xhci_dbg(xhci, "Slot %d output context\n", slot_id);
                 xhci_dbg_ctx(xhci, out_ctx, ep_index);
 
-                ret = xhci_configure_endpoint(xhci, urb->dev, NULL,
+                ret = xhci_configure_endpoint(xhci, urb->dev, command,
                                 true, false);
 
                 /* Clean up the input context for later use by bandwidth
                  * functions.
                  */
                 ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG);
+command_cleanup:
+                kfree(command->completion);
+                kfree(command);
         }
         return ret;
 }
@@ -1465,6 +1478,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         unsigned int ep_index;
         struct xhci_ring *ep_ring;
         struct xhci_virt_ep *ep;
+        struct xhci_command *command;
 
         xhci = hcd_to_xhci(hcd);
         spin_lock_irqsave(&xhci->lock, flags);
@@ -1534,12 +1548,14 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
          * the first cancellation to be handled.
          */
         if (!(ep->ep_state & EP_HALT_PENDING)) {
+                command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
                 ep->ep_state |= EP_HALT_PENDING;
                 ep->stop_cmds_pending++;
                 ep->stop_cmd_timer.expires = jiffies +
                         XHCI_STOP_EP_CMD_TIMEOUT * HZ;
                 add_timer(&ep->stop_cmd_timer);
-                xhci_queue_stop_endpoint(xhci, urb->dev->slot_id, ep_index, 0);
+                xhci_queue_stop_endpoint(xhci, command, urb->dev->slot_id,
+                                         ep_index, 0);
                 xhci_ring_cmd_db(xhci);
         }
 done:
@@ -1804,6 +1820,11 @@ static int xhci_configure_endpoint_result(struct xhci_hcd *xhci,
         int ret;
 
         switch (*cmd_status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for configure endpoint command\n");
+                ret = -ETIME;
+                break;
         case COMP_ENOMEM:
                 dev_warn(&udev->dev, "Not enough host controller resources "
                                 "for new device state.\n");
@@ -1850,6 +1871,11 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
         struct xhci_virt_device *virt_dev = xhci->devs[udev->slot_id];
 
         switch (*cmd_status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for evaluate context command\n");
+                ret = -ETIME;
+                break;
         case COMP_EINVAL:
                 dev_warn(&udev->dev, "WARN: xHCI driver setup invalid evaluate "
                                 "context command.\n");
@@ -2574,23 +2600,17 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 bool ctx_change, bool must_succeed)
 {
         int ret;
-        int timeleft;
         unsigned long flags;
-        struct xhci_container_ctx *in_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
-        struct completion *cmd_completion;
-        u32 *cmd_status;
         struct xhci_virt_device *virt_dev;
-        union xhci_trb *cmd_trb;
+
+        if (!command)
+                return -EINVAL;
 
         spin_lock_irqsave(&xhci->lock, flags);
         virt_dev = xhci->devs[udev->slot_id];
 
-        if (command)
-                in_ctx = command->in_ctx;
-        else
-                in_ctx = virt_dev->in_ctx;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
         if (!ctrl_ctx) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@@ -2607,7 +2627,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 return -ENOMEM;
         }
         if ((xhci->quirks & XHCI_SW_BW_CHECKING) &&
-                        xhci_reserve_bandwidth(xhci, virt_dev, in_ctx)) {
+            xhci_reserve_bandwidth(xhci, virt_dev, command->in_ctx)) {
                 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
                         xhci_free_host_resources(xhci, ctrl_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -2615,27 +2635,15 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 return -ENOMEM;
         }
 
-        if (command) {
-                cmd_completion = command->completion;
-                cmd_status = &command->status;
-                command->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-                list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
-        } else {
-                cmd_completion = &virt_dev->cmd_completion;
-                cmd_status = &virt_dev->cmd_status;
-        }
-        init_completion(cmd_completion);
-
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         if (!ctx_change)
-                ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
+                ret = xhci_queue_configure_endpoint(xhci, command,
+                                command->in_ctx->dma,
                                 udev->slot_id, must_succeed);
         else
-                ret = xhci_queue_evaluate_context(xhci, in_ctx->dma,
+                ret = xhci_queue_evaluate_context(xhci, command,
+                                command->in_ctx->dma,
                                 udev->slot_id, must_succeed);
         if (ret < 0) {
-                if (command)
-                        list_del(&command->cmd_list);
                 if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
                         xhci_free_host_resources(xhci, ctrl_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -2647,26 +2655,14 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for the configure endpoint command to complete */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        cmd_completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for %s command\n",
-                                timeleft == 0 ? "Timeout" : "Signal",
-                                ctx_change == 0 ?
-                                        "configure endpoint" :
-                                        "evaluate context");
-                /* cancel the configure endpoint command */
-                ret = xhci_cancel_cmd(xhci, command, cmd_trb);
-                if (ret < 0)
-                        return ret;
-                return -ETIME;
-        }
+        wait_for_completion(command->completion);
 
         if (!ctx_change)
-                ret = xhci_configure_endpoint_result(xhci, udev, cmd_status);
+                ret = xhci_configure_endpoint_result(xhci, udev,
+                                                     &command->status);
         else
-                ret = xhci_evaluate_context_result(xhci, udev, cmd_status);
+                ret = xhci_evaluate_context_result(xhci, udev,
+                                                   &command->status);
 
         if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
                 spin_lock_irqsave(&xhci->lock, flags);
@@ -2714,6 +2710,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_virt_device *virt_dev;
         struct xhci_input_control_ctx *ctrl_ctx;
         struct xhci_slot_ctx *slot_ctx;
+        struct xhci_command *command;
 
         ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
         if (ret <= 0)
@@ -2725,12 +2722,19 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         virt_dev = xhci->devs[udev->slot_id];
 
+        command = xhci_alloc_command(xhci, false, true, GFP_KERNEL);
+        if (!command)
+                return -ENOMEM;
+
+        command->in_ctx = virt_dev->in_ctx;
+
         /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                 __func__);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto command_cleanup;
         }
         ctrl_ctx->add_flags |= cpu_to_le32(SLOT_FLAG);
         ctrl_ctx->add_flags &= cpu_to_le32(~EP0_FLAG);
@@ -2738,20 +2742,20 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Don't issue the command if there's no endpoints to update. */
         if (ctrl_ctx->add_flags == cpu_to_le32(SLOT_FLAG) &&
-                        ctrl_ctx->drop_flags == 0)
-                return 0;
-
+            ctrl_ctx->drop_flags == 0) {
+                ret = 0;
+                goto command_cleanup;
+        }
         xhci_dbg(xhci, "New Input Control Context:\n");
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx,
                      LAST_CTX_TO_EP_NUM(le32_to_cpu(slot_ctx->dev_info)));
 
-        ret = xhci_configure_endpoint(xhci, udev, NULL,
+        ret = xhci_configure_endpoint(xhci, udev, command,
                         false, false);
-        if (ret) {
+        if (ret)
                 /* Callee should call reset_bandwidth() */
-                return ret;
-        }
+                goto command_cleanup;
 
         xhci_dbg(xhci, "Output context after successful config ep cmd:\n");
         xhci_dbg_ctx(xhci, virt_dev->out_ctx,
@@ -2783,6 +2787,9 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
                 virt_dev->eps[i].ring = virt_dev->eps[i].new_ring;
                 virt_dev->eps[i].new_ring = NULL;
         }
+command_cleanup:
+        kfree(command->completion);
+        kfree(command);
 
         return ret;
 }
@@ -2884,9 +2891,14 @@ 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, udev->slot_id,
+                xhci_queue_new_dequeue_state(xhci, command, udev->slot_id,
                                 ep_index, ep->stopped_stream, &deq_state);
         } else {
                 /* Better hope no one uses the input context between now and the
@@ -2917,6 +2929,7 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
         unsigned long flags;
         int ret;
         struct xhci_virt_ep *virt_ep;
+        struct xhci_command *command;
 
         xhci = hcd_to_xhci(hcd);
         udev = (struct usb_device *) ep->hcpriv;
@@ -2939,10 +2952,14 @@ void xhci_endpoint_reset(struct usb_hcd *hcd,
                 return;
         }
 
+        command = xhci_alloc_command(xhci, false, false, GFP_ATOMIC);
+        if (!command)
+                return;
+
         xhci_dbg_trace(xhci, trace_xhci_dbg_reset_ep,
                         "Queueing reset endpoint command");
         spin_lock_irqsave(&xhci->lock, flags);
-        ret = xhci_queue_reset_ep(xhci, udev->slot_id, ep_index);
+        ret = xhci_queue_reset_ep(xhci, command, udev->slot_id, ep_index);
         /*
          * Can't change the ring dequeue pointer until it's transitioned to the
          * stopped state, which is only upon a successful reset endpoint
@@ -3416,7 +3433,6 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         unsigned int slot_id;
         struct xhci_virt_device *virt_dev;
         struct xhci_command *reset_device_cmd;
-        int timeleft;
         int last_freed_endpoint;
         struct xhci_slot_ctx *slot_ctx;
         int old_active_eps = 0;
@@ -3473,13 +3489,10 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* Attempt to submit the Reset Device command to the command ring */
         spin_lock_irqsave(&xhci->lock, flags);
-        reset_device_cmd->command_trb = xhci_find_next_enqueue(xhci->cmd_ring);
 
-        list_add_tail(&reset_device_cmd->cmd_list, &virt_dev->cmd_list);
-        ret = xhci_queue_reset_device(xhci, slot_id);
+        ret = xhci_queue_reset_device(xhci, reset_device_cmd, slot_id);
         if (ret) {
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
-                list_del(&reset_device_cmd->cmd_list);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 goto command_cleanup;
         }
@@ -3487,22 +3500,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* Wait for the Reset Device command to finish */
-        timeleft = wait_for_completion_interruptible_timeout(
-                        reset_device_cmd->completion,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for reset device command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                spin_lock_irqsave(&xhci->lock, flags);
-                /* The timeout might have raced with the event ring handler, so
-                 * only delete from the list if the item isn't poisoned.
-                 */
-                if (reset_device_cmd->cmd_list.next != LIST_POISON1)
-                        list_del(&reset_device_cmd->cmd_list);
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                ret = -ETIME;
-                goto command_cleanup;
-        }
+        wait_for_completion(reset_device_cmd->completion);
 
         /* The Reset Device command can't fail, according to the 0.95/0.96 spec,
          * unless we tried to reset a slot ID that wasn't enabled,
@@ -3510,6 +3508,11 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
          */
         ret = reset_device_cmd->status;
         switch (ret) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout waiting for reset device command\n");
+                ret = -ETIME;
+                goto command_cleanup;
         case COMP_EBADSLT: /* 0.95 completion code for bad slot ID */
         case COMP_CTX_STATE: /* 0.96 completion code for same thing */
                 xhci_dbg(xhci, "Can't reset device (slot ID %u) in %s state\n",
@@ -3589,6 +3592,11 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         unsigned long flags;
         u32 state;
         int i, ret;
+        struct xhci_command *command;
+
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return;
 
 #ifndef CONFIG_USB_DEFAULT_PERSIST
         /*
@@ -3604,8 +3612,10 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
         /* If the host is halted due to driver unload, we still need to free the
          * device.
          */
-        if (ret <= 0 && ret != -ENODEV)
+        if (ret <= 0 && ret != -ENODEV) {
+                kfree(command);
                 return;
+        }
 
         virt_dev = xhci->devs[udev->slot_id];
 
@@ -3622,16 +3632,19 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
                         (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
                 spin_unlock_irqrestore(&xhci->lock, flags);
+                kfree(command);
                 return;
         }
 
-        if (xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id)) {
+        if (xhci_queue_slot_control(xhci, command, TRB_DISABLE_SLOT,
+                                    udev->slot_id)) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
                 return;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
+
         /*
          * Event command completion handler will free any data structures
          * associated with the slot.  XXX Can free sleep?
@@ -3669,33 +3682,33 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         unsigned long flags;
-        int timeleft;
         int ret;
-        union xhci_trb *cmd_trb;
+        struct xhci_command *command;
+
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return 0;
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0);
+        command->completion = &xhci->addr_dev;
+        ret = xhci_queue_slot_control(xhci, command, TRB_ENABLE_SLOT, 0);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME: allocate a command ring segment\n");
+                kfree(command);
                 return 0;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
-        /* XXX: how much time for xHC slot assignment? */
-        timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for a slot\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
-                /* cancel the enable slot request */
-                return xhci_cancel_cmd(xhci, NULL, cmd_trb);
-        }
+        wait_for_completion(command->completion);
 
-        if (!xhci->slot_id) {
+        if (!xhci->slot_id || command->status != COMP_SUCCESS) {
                 xhci_err(xhci, "Error while assigning device slot ID\n");
+                xhci_err(xhci, "Max number of devices this xHCI host supports is %u.\n",
+                                HCS_MAX_SLOTS(
+                                        readl(&xhci->cap_regs->hcs_params1)));
+                kfree(command);
                 return 0;
         }
 
@@ -3730,6 +3743,8 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 pm_runtime_get_noresume(hcd->self.controller);
 #endif
 
+
+        kfree(command);
         /* Is this a LS or FS device under a HS hub? */
         /* Hub or peripherial? */
         return 1;
@@ -3737,7 +3752,10 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 disable_slot:
         /* Disable slot, if we can do it without mem alloc */
         spin_lock_irqsave(&xhci->lock, flags);
-        if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
+        command->completion = NULL;
+        command->status = 0;
+        if (!xhci_queue_slot_control(xhci, command, TRB_DISABLE_SLOT,
+                                     udev->slot_id))
                 xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
         return 0;
@@ -3754,14 +3772,13 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
 {
         const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
         unsigned long flags;
-        int timeleft;
         struct xhci_virt_device *virt_dev;
         int ret = 0;
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         struct xhci_slot_ctx *slot_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
         u64 temp_64;
-        union xhci_trb *cmd_trb;
+        struct xhci_command *command;
 
         if (!udev->slot_id) {
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
@@ -3782,11 +3799,19 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                 return -EINVAL;
         }
 
+        command = xhci_alloc_command(xhci, false, false, GFP_KERNEL);
+        if (!command)
+                return -ENOMEM;
+
+        command->in_ctx = virt_dev->in_ctx;
+        command->completion = &xhci->addr_dev;
+
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
         ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
         if (!ctrl_ctx) {
                 xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                 __func__);
+                kfree(command);
                 return -EINVAL;
         }
         /*
@@ -3808,36 +3833,31 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                                 le32_to_cpu(slot_ctx->dev_info) >> 27);
 
         spin_lock_irqsave(&xhci->lock, flags);
-        cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
-        ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma,
+        ret = xhci_queue_address_device(xhci, command, virt_dev->in_ctx->dma,
                                         udev->slot_id, setup);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                                 "FIXME: allocate a command ring segment");
+                kfree(command);
                 return ret;
         }
         xhci_ring_cmd_db(xhci);
         spin_unlock_irqrestore(&xhci->lock, flags);
 
         /* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */
-        timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        XHCI_CMD_DEFAULT_TIMEOUT);
+        wait_for_completion(command->completion);
+
         /* FIXME: From section 4.3.4: "Software shall be responsible for timing
          * the SetAddress() "recovery interval" required by USB and aborting the
          * command on a timeout.
          */
-        if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for setup %s command\n",
-                          timeleft == 0 ? "Timeout" : "Signal", act);
-                /* cancel the address device command */
-                ret = xhci_cancel_cmd(xhci, NULL, cmd_trb);
-                if (ret < 0)
-                        return ret;
-                return -ETIME;
-        }
-
-        switch (virt_dev->cmd_status) {
+        switch (command->status) {
+        case COMP_CMD_ABORT:
+        case COMP_CMD_STOP:
+                xhci_warn(xhci, "Timeout while waiting for setup device command\n");
+                ret = -ETIME;
+                break;
         case COMP_CTX_STATE:
         case COMP_EBADSLT:
                 xhci_err(xhci, "Setup ERROR: setup %s command for slot %d.\n",
@@ -3860,7 +3880,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         default:
                 xhci_err(xhci,
                          "ERROR: unexpected setup %s command completion code 0x%x.\n",
-                         act, virt_dev->cmd_status);
+                         act, command->status);
                 xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
                 xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
                 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, 1);
@@ -3868,6 +3888,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
                 break;
         }
         if (ret) {
+                kfree(command);
                 return ret;
         }
         temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
@@ -3902,7 +3923,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                        "Internal device address = %d",
                        le32_to_cpu(slot_ctx->dev_state) & DEV_ADDR_MASK);
-
+        kfree(command);
         return 0;
 }
 
@@ -4092,7 +4113,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
         field = le32_to_cpu(udev->bos->ext_cap->bmAttributes);
 
         xhci_dbg(xhci, "%s port %d USB2 hardware LPM\n",
-                        enable ? "enable" : "disable", port_num);
+                        enable ? "enable" : "disable", port_num + 1);
 
         if (enable) {
                 /* Host supports BESL timeout instead of HIRD */
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 4746816aed3e..9ffecd56600d 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -937,9 +937,6 @@ struct xhci_virt_device {
 #define XHCI_MAX_RINGS_CACHED   31
         struct xhci_virt_ep             eps[31];
         struct completion               cmd_completion;
-        /* Status of the last command issued for this device */
-        u32                             cmd_status;
-        struct list_head                cmd_list;
         u8                              fake_port;
         u8                              real_port;
         struct xhci_interval_bw_table   *bw_table;
@@ -1298,7 +1295,6 @@ struct xhci_td {
 
 /* command descriptor */
 struct xhci_cd {
-        struct list_head        cancel_cmd_list;
         struct xhci_command     *command;
         union xhci_trb          *cmd_trb;
 };
@@ -1476,6 +1472,8 @@ struct xhci_hcd {
         /* msi-x vectors */
         int             msix_count;
         struct msix_entry       *msix_entries;
+        /* optional clock */
+        struct clk              *clk;
         /* data structures */
         struct xhci_device_context_array *dcbaa;
         struct xhci_ring        *cmd_ring;
@@ -1483,8 +1481,10 @@ struct xhci_hcd {
 #define CMD_RING_STATE_RUNNING         (1 << 0)
 #define CMD_RING_STATE_ABORTED         (1 << 1)
 #define CMD_RING_STATE_STOPPED         (1 << 2)
-        struct list_head        cancel_cmd_list;
+        struct list_head        cmd_list;
         unsigned int            cmd_ring_reserved_trbs;
+        struct timer_list       cmd_timer;
+        struct xhci_command     *current_cmd;
         struct xhci_ring        *event_ring;
         struct xhci_erst        erst;
         /* Scratchpad */
@@ -1738,8 +1738,7 @@ static inline int xhci_register_pci(void) { return 0; }
 static inline void xhci_unregister_pci(void) {}
 #endif
 
-#if defined(CONFIG_USB_XHCI_PLATFORM) \
-        || defined(CONFIG_USB_XHCI_PLATFORM_MODULE)
+#if IS_ENABLED(CONFIG_USB_XHCI_PLATFORM)
 int xhci_register_plat(void);
 void xhci_unregister_plat(void);
 #else
@@ -1808,13 +1807,14 @@ struct xhci_segment *trb_in_td(struct xhci_segment *start_seg,
                 dma_addr_t suspect_dma);
 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, u32 trb_type, u32 slot_id);
-int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, enum xhci_setup_dev);
-int xhci_queue_vendor_command(struct xhci_hcd *xhci,
+int xhci_queue_slot_control(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 trb_type, u32 slot_id);
+int xhci_queue_address_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, enum xhci_setup_dev);
+int xhci_queue_vendor_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
                 u32 field1, u32 field2, u32 field3, u32 field4);
-int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index, int suspend);
+int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                int slot_id, unsigned int ep_index, int suspend);
 int xhci_queue_ctrl_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_bulk_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
@@ -1823,18 +1823,21 @@ int xhci_queue_intr_tx(struct xhci_hcd *xhci, gfp_t mem_flags, struct urb *urb,
                 int slot_id, unsigned int ep_index);
 int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
                 struct urb *urb, int slot_id, unsigned int ep_index);
-int xhci_queue_configure_endpoint(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed);
-int xhci_queue_evaluate_context(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id, bool command_must_succeed);
-int xhci_queue_reset_ep(struct xhci_hcd *xhci, int slot_id,
-                unsigned int ep_index);
-int xhci_queue_reset_device(struct xhci_hcd *xhci, u32 slot_id);
+int xhci_queue_configure_endpoint(struct xhci_hcd *xhci,
+                struct xhci_command *cmd, dma_addr_t in_ctx_ptr, u32 slot_id,
+                bool command_must_succeed);
+int xhci_queue_evaluate_context(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                dma_addr_t in_ctx_ptr, u32 slot_id, bool command_must_succeed);
+int xhci_queue_reset_ep(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                int slot_id, unsigned int ep_index);
+int xhci_queue_reset_device(struct xhci_hcd *xhci, struct xhci_command *cmd,
+                u32 slot_id);
 void xhci_find_new_dequeue_state(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 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);
@@ -1844,11 +1847,11 @@ void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state);
 void xhci_stop_endpoint_command_watchdog(unsigned long arg);
-int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
-                union xhci_trb *cmd_trb);
+void xhci_handle_command_timeout(unsigned long data);
+
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, unsigned int stream_id);
-union xhci_trb *xhci_find_next_enqueue(struct xhci_ring *ring);
+void xhci_cleanup_command_queue(struct xhci_hcd *xhci);
 
 /* xHCI roothub code */
 void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
diff --git a/drivers/usb/misc/appledisplay.c b/drivers/usb/misc/appledisplay.c
index ba6a5d6e618e..b3d245ef46ef 100644
--- a/drivers/usb/misc/appledisplay.c
+++ b/drivers/usb/misc/appledisplay.c
@@ -81,6 +81,7 @@ struct appledisplay {
         struct delayed_work work;
         int button_pressed;
         spinlock_t lock;
+        struct mutex sysfslock;         /* concurrent read and write */
 };
 
 static atomic_t count_displays = ATOMIC_INIT(0);
@@ -110,7 +111,7 @@ static void appledisplay_complete(struct urb *urb)
                         __func__, status);
                 return;
         default:
-                dev_dbg(dev, "%s - nonzero urb status received: %d/n",
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n",
                         __func__, status);
                 goto exit;
         }
@@ -144,6 +145,7 @@ static int appledisplay_bl_update_status(struct backlight_device *bd)
         struct appledisplay *pdata = bl_get_data(bd);
         int retval;
 
+        mutex_lock(&pdata->sysfslock);
         pdata->msgdata[0] = 0x10;
         pdata->msgdata[1] = bd->props.brightness;
 
@@ -156,15 +158,17 @@ static int appledisplay_bl_update_status(struct backlight_device *bd)
                 0,
                 pdata->msgdata, 2,
                 ACD_USB_TIMEOUT);
-
+        mutex_unlock(&pdata->sysfslock);
+        
         return retval;
 }
 
 static int appledisplay_bl_get_brightness(struct backlight_device *bd)
 {
         struct appledisplay *pdata = bl_get_data(bd);
-        int retval;
+        int retval, brightness;
 
+        mutex_lock(&pdata->sysfslock);
         retval = usb_control_msg(
                 pdata->udev,
                 usb_rcvctrlpipe(pdata->udev, 0),
@@ -174,11 +178,13 @@ static int appledisplay_bl_get_brightness(struct backlight_device *bd)
                 0,
                 pdata->msgdata, 2,
                 ACD_USB_TIMEOUT);
+        brightness = pdata->msgdata[1];
+        mutex_unlock(&pdata->sysfslock);
 
         if (retval < 0)
                 return retval;
         else
-                return pdata->msgdata[1];
+                return brightness;
 }
 
 static const struct backlight_ops appledisplay_bl_data = {
@@ -241,6 +247,7 @@ static int appledisplay_probe(struct usb_interface *iface,
 
         spin_lock_init(&pdata->lock);
         INIT_DELAYED_WORK(&pdata->work, appledisplay_work);
+        mutex_init(&pdata->sysfslock);
 
         /* Allocate buffer for control messages */
         pdata->msgdata = kmalloc(ACD_MSG_BUFFER_LEN, GFP_KERNEL);
diff --git a/drivers/usb/misc/ftdi-elan.c b/drivers/usb/misc/ftdi-elan.c
index a4a3c7cd4a11..8ab1f8f3c26e 100644
--- a/drivers/usb/misc/ftdi-elan.c
+++ b/drivers/usb/misc/ftdi-elan.c
@@ -1,40 +1,43 @@
 /*
-* USB FTDI client driver for Elan Digital Systems's Uxxx adapters
-*
-* Copyright(C) 2006 Elan Digital Systems Limited
-* http://www.elandigitalsystems.com
-*
-* Author and Maintainer - Tony Olech - Elan Digital Systems
-* tony.olech@elandigitalsystems.com
-*
-* This program is free software;you can redistribute it and/or
-* modify it under the terms of the GNU General Public License as
-* published by the Free Software Foundation, version 2.
-*
-*
-* This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
-* based on various USB client drivers in the 2.6.15 linux kernel
-* with constant reference to the 3rd Edition of Linux Device Drivers
-* published by O'Reilly
-*
-* The U132 adapter is a USB to CardBus adapter specifically designed
-* for PC cards that contain an OHCI host controller. Typical PC cards
-* are the Orange Mobile 3G Option GlobeTrotter Fusion card.
-*
-* The U132 adapter will *NOT *work with PC cards that do not contain
-* an OHCI controller. A simple way to test whether a PC card has an
-* OHCI controller as an interface is to insert the PC card directly
-* into a laptop(or desktop) with a CardBus slot and if "lspci" shows
-* a new USB controller and "lsusb -v" shows a new OHCI Host Controller
-* then there is a good chance that the U132 adapter will support the
-* PC card.(you also need the specific client driver for the PC card)
-*
-* Please inform the Author and Maintainer about any PC cards that
-* contain OHCI Host Controller and work when directly connected to
-* an embedded CardBus slot but do not work when they are connected
-* via an ELAN U132 adapter.
-*
-*/
+ * USB FTDI client driver for Elan Digital Systems's Uxxx adapters
+ *
+ * Copyright(C) 2006 Elan Digital Systems Limited
+ * http://www.elandigitalsystems.com
+ *
+ * Author and Maintainer - Tony Olech - Elan Digital Systems
+ * tony.olech@elandigitalsystems.com
+ *
+ * This program is free software;you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ *
+ *
+ * This driver was written by Tony Olech(tony.olech@elandigitalsystems.com)
+ * based on various USB client drivers in the 2.6.15 linux kernel
+ * with constant reference to the 3rd Edition of Linux Device Drivers
+ * published by O'Reilly
+ *
+ * The U132 adapter is a USB to CardBus adapter specifically designed
+ * for PC cards that contain an OHCI host controller. Typical PC cards
+ * are the Orange Mobile 3G Option GlobeTrotter Fusion card.
+ *
+ * The U132 adapter will *NOT *work with PC cards that do not contain
+ * an OHCI controller. A simple way to test whether a PC card has an
+ * OHCI controller as an interface is to insert the PC card directly
+ * into a laptop(or desktop) with a CardBus slot and if "lspci" shows
+ * a new USB controller and "lsusb -v" shows a new OHCI Host Controller
+ * then there is a good chance that the U132 adapter will support the
+ * PC card.(you also need the specific client driver for the PC card)
+ *
+ * Please inform the Author and Maintainer about any PC cards that
+ * contain OHCI Host Controller and work when directly connected to
+ * an embedded CardBus slot but do not work when they are connected
+ * via an ELAN U132 adapter.
+ *
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
@@ -55,31 +58,31 @@ MODULE_LICENSE("GPL");
 #define INT_MODULE_PARM(n, v) static int n = v;module_param(n, int, 0444)
 static bool distrust_firmware = 1;
 module_param(distrust_firmware, bool, 0);
-MODULE_PARM_DESC(distrust_firmware, "true to distrust firmware power/overcurren"
-        "t setup");
+MODULE_PARM_DESC(distrust_firmware,
+                 "true to distrust firmware power/overcurrent setup");
 extern struct platform_driver u132_platform_driver;
 static struct workqueue_struct *status_queue;
 static struct workqueue_struct *command_queue;
 static struct workqueue_struct *respond_queue;
 /*
-* ftdi_module_lock exists to protect access to global variables
-*
-*/
+ * ftdi_module_lock exists to protect access to global variables
+ *
+ */
 static struct mutex ftdi_module_lock;
 static int ftdi_instances = 0;
 static struct list_head ftdi_static_list;
 /*
-* end of the global variables protected by ftdi_module_lock
-*/
+ * end of the global variables protected by ftdi_module_lock
+ */
 #include "usb_u132.h"
 #include <asm/io.h>
 #include <linux/usb/hcd.h>
 
-        /* FIXME ohci.h is ONLY for internal use by the OHCI driver.
-         * If you're going to try stuff like this, you need to split
-         * out shareable stuff (register declarations?) into its own
-         * file, maybe name <linux/usb/ohci.h>
-         */
+/* FIXME ohci.h is ONLY for internal use by the OHCI driver.
+ * If you're going to try stuff like this, you need to split
+ * out shareable stuff (register declarations?) into its own
+ * file, maybe name <linux/usb/ohci.h>
+ */
 
 #include "../host/ohci.h"
 /* Define these values to match your devices*/
@@ -87,140 +90,140 @@ static struct list_head ftdi_static_list;
 #define USB_FTDI_ELAN_PRODUCT_ID 0xd6ea
 /* table of devices that work with this driver*/
 static const struct usb_device_id ftdi_elan_table[] = {
-        {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
-        { /* Terminating entry */ }
+        {USB_DEVICE(USB_FTDI_ELAN_VENDOR_ID, USB_FTDI_ELAN_PRODUCT_ID)},
+        { /* Terminating entry */ }
 };
 
 MODULE_DEVICE_TABLE(usb, ftdi_elan_table);
 /* only the jtag(firmware upgrade device) interface requires
-* a device file and corresponding minor number, but the
-* interface is created unconditionally - I suppose it could
-* be configured or not according to a module parameter.
-* But since we(now) require one interface per device,
-* and since it unlikely that a normal installation would
-* require more than a couple of elan-ftdi devices, 8 seems
-* like a reasonable limit to have here, and if someone
-* really requires more than 8 devices, then they can frig the
-* code and recompile
-*/
+ * a device file and corresponding minor number, but the
+ * interface is created unconditionally - I suppose it could
+ * be configured or not according to a module parameter.
+ * But since we(now) require one interface per device,
+ * and since it unlikely that a normal installation would
+ * require more than a couple of elan-ftdi devices, 8 seems
+ * like a reasonable limit to have here, and if someone
+ * really requires more than 8 devices, then they can frig the
+ * code and recompile
+ */
 #define USB_FTDI_ELAN_MINOR_BASE 192
 #define COMMAND_BITS 5
 #define COMMAND_SIZE (1<<COMMAND_BITS)
 #define COMMAND_MASK (COMMAND_SIZE-1)
 struct u132_command {
-        u8 header;
-        u16 length;
-        u8 address;
-        u8 width;
-        u32 value;
-        int follows;
-        void *buffer;
+        u8 header;
+        u16 length;
+        u8 address;
+        u8 width;
+        u32 value;
+        int follows;
+        void *buffer;
 };
 #define RESPOND_BITS 5
 #define RESPOND_SIZE (1<<RESPOND_BITS)
 #define RESPOND_MASK (RESPOND_SIZE-1)
 struct u132_respond {
-        u8 header;
-        u8 address;
-        u32 *value;
-        int *result;
-        struct completion wait_completion;
+        u8 header;
+        u8 address;
+        u32 *value;
+        int *result;
+        struct completion wait_completion;
 };
 struct u132_target {
-        void *endp;
-        struct urb *urb;
-        int toggle_bits;
-        int error_count;
-        int condition_code;
-        int repeat_number;
-        int halted;
-        int skipped;
-        int actual;
-        int non_null;
-        int active;
-        int abandoning;
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-                int toggle_bits, int error_count, int condition_code,
-                int repeat_number, int halted, int skipped, int actual,
-                int non_null);
+        void *endp;
+        struct urb *urb;
+        int toggle_bits;
+        int error_count;
+        int condition_code;
+        int repeat_number;
+        int halted;
+        int skipped;
+        int actual;
+        int non_null;
+        int active;
+        int abandoning;
+        void (*callback)(void *endp, struct urb *urb, u8 *buf, int len,
+                         int toggle_bits, int error_count, int condition_code,
+                         int repeat_number, int halted, int skipped, int actual,
+                         int non_null);
 };
 /* Structure to hold all of our device specific stuff*/
 struct usb_ftdi {
-        struct list_head ftdi_list;
-        struct mutex u132_lock;
-        int command_next;
-        int command_head;
-        struct u132_command command[COMMAND_SIZE];
-        int respond_next;
-        int respond_head;
-        struct u132_respond respond[RESPOND_SIZE];
-        struct u132_target target[4];
-        char device_name[16];
-        unsigned synchronized:1;
-        unsigned enumerated:1;
-        unsigned registered:1;
-        unsigned initialized:1;
-        unsigned card_ejected:1;
-        int function;
-        int sequence_num;
-        int disconnected;
-        int gone_away;
-        int stuck_status;
-        int status_queue_delay;
-        struct semaphore sw_lock;
-        struct usb_device *udev;
-        struct usb_interface *interface;
-        struct usb_class_driver *class;
-        struct delayed_work status_work;
-        struct delayed_work command_work;
-        struct delayed_work respond_work;
-        struct u132_platform_data platform_data;
-        struct resource resources[0];
-        struct platform_device platform_dev;
-        unsigned char *bulk_in_buffer;
-        size_t bulk_in_size;
-        size_t bulk_in_last;
-        size_t bulk_in_left;
-        __u8 bulk_in_endpointAddr;
-        __u8 bulk_out_endpointAddr;
-        struct kref kref;
-        u32 controlreg;
-        u8 response[4 + 1024];
-        int expected;
-        int received;
-        int ed_found;
+        struct list_head ftdi_list;
+        struct mutex u132_lock;
+        int command_next;
+        int command_head;
+        struct u132_command command[COMMAND_SIZE];
+        int respond_next;
+        int respond_head;
+        struct u132_respond respond[RESPOND_SIZE];
+        struct u132_target target[4];
+        char device_name[16];
+        unsigned synchronized:1;
+        unsigned enumerated:1;
+        unsigned registered:1;
+        unsigned initialized:1;
+        unsigned card_ejected:1;
+        int function;
+        int sequence_num;
+        int disconnected;
+        int gone_away;
+        int stuck_status;
+        int status_queue_delay;
+        struct semaphore sw_lock;
+        struct usb_device *udev;
+        struct usb_interface *interface;
+        struct usb_class_driver *class;
+        struct delayed_work status_work;
+        struct delayed_work command_work;
+        struct delayed_work respond_work;
+        struct u132_platform_data platform_data;
+        struct resource resources[0];
+        struct platform_device platform_dev;
+        unsigned char *bulk_in_buffer;
+        size_t bulk_in_size;
+        size_t bulk_in_last;
+        size_t bulk_in_left;
+        __u8 bulk_in_endpointAddr;
+        __u8 bulk_out_endpointAddr;
+        struct kref kref;
+        u32 controlreg;
+        u8 response[4 + 1024];
+        int expected;
+        int received;
+        int ed_found;
 };
 #define kref_to_usb_ftdi(d) container_of(d, struct usb_ftdi, kref)
 #define platform_device_to_usb_ftdi(d) container_of(d, struct usb_ftdi, \
-        platform_dev)
+                                                    platform_dev)
 static struct usb_driver ftdi_elan_driver;
 static void ftdi_elan_delete(struct kref *kref)
 {
-        struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
-        dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
-        usb_put_dev(ftdi->udev);
-        ftdi->disconnected += 1;
-        mutex_lock(&ftdi_module_lock);
-        list_del_init(&ftdi->ftdi_list);
-        ftdi_instances -= 1;
-        mutex_unlock(&ftdi_module_lock);
-        kfree(ftdi->bulk_in_buffer);
-        ftdi->bulk_in_buffer = NULL;
+        struct usb_ftdi *ftdi = kref_to_usb_ftdi(kref);
+        dev_warn(&ftdi->udev->dev, "FREEING ftdi=%p\n", ftdi);
+        usb_put_dev(ftdi->udev);
+        ftdi->disconnected += 1;
+        mutex_lock(&ftdi_module_lock);
+        list_del_init(&ftdi->ftdi_list);
+        ftdi_instances -= 1;
+        mutex_unlock(&ftdi_module_lock);
+        kfree(ftdi->bulk_in_buffer);
+        ftdi->bulk_in_buffer = NULL;
 }
 
 static void ftdi_elan_put_kref(struct usb_ftdi *ftdi)
 {
-        kref_put(&ftdi->kref, ftdi_elan_delete);
+        kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_elan_get_kref(struct usb_ftdi *ftdi)
 {
-        kref_get(&ftdi->kref);
+        kref_get(&ftdi->kref);
 }
 
 static void ftdi_elan_init_kref(struct usb_ftdi *ftdi)
 {
-        kref_init(&ftdi->kref);
+        kref_init(&ftdi->kref);
 }
 
 static void ftdi_status_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
@@ -237,8 +240,8 @@ static void ftdi_status_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_status_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->status_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->status_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_command_requeue_work(struct usb_ftdi *ftdi, unsigned int delta)
@@ -255,12 +258,12 @@ static void ftdi_command_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_command_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->command_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->command_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 static void ftdi_response_requeue_work(struct usb_ftdi *ftdi,
-        unsigned int delta)
+                                       unsigned int delta)
 {
         if (!queue_delayed_work(respond_queue, &ftdi->respond_work, delta))
                 kref_put(&ftdi->kref, ftdi_elan_delete);
@@ -274,26 +277,26 @@ static void ftdi_respond_queue_work(struct usb_ftdi *ftdi, unsigned int delta)
 
 static void ftdi_response_cancel_work(struct usb_ftdi *ftdi)
 {
-        if (cancel_delayed_work(&ftdi->respond_work))
-                kref_put(&ftdi->kref, ftdi_elan_delete);
+        if (cancel_delayed_work(&ftdi->respond_work))
+                kref_put(&ftdi->kref, ftdi_elan_delete);
 }
 
 void ftdi_elan_gone_away(struct platform_device *pdev)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        ftdi->gone_away += 1;
-        ftdi_elan_put_kref(ftdi);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        ftdi->gone_away += 1;
+        ftdi_elan_put_kref(ftdi);
 }
 
 
 EXPORT_SYMBOL_GPL(ftdi_elan_gone_away);
 static void ftdi_release_platform_dev(struct device *dev)
 {
-        dev->parent = NULL;
+        dev->parent = NULL;
 }
 
 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
-        struct u132_target *target, u8 *buffer, int length);
+                                  struct u132_target *target, u8 *buffer, int length);
 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi);
 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi);
 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi);
@@ -305,421 +308,416 @@ static int ftdi_elan_command_engine(struct usb_ftdi *ftdi);
 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi);
 static int ftdi_elan_hcd_init(struct usb_ftdi *ftdi)
 {
-        int result;
-        if (ftdi->platform_dev.dev.parent)
-                return -EBUSY;
-        ftdi_elan_get_kref(ftdi);
-        ftdi->platform_data.potpg = 100;
-        ftdi->platform_data.reset = NULL;
-        ftdi->platform_dev.id = ftdi->sequence_num;
-        ftdi->platform_dev.resource = ftdi->resources;
-        ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
-        ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
-        ftdi->platform_dev.dev.parent = NULL;
-        ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
-        ftdi->platform_dev.dev.dma_mask = NULL;
-        snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
-        ftdi->platform_dev.name = ftdi->device_name;
-        dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
-        request_module("u132_hcd");
-        dev_info(&ftdi->udev->dev, "registering '%s'\n",
-                ftdi->platform_dev.name);
-        result = platform_device_register(&ftdi->platform_dev);
-        return result;
+        int result;
+        if (ftdi->platform_dev.dev.parent)
+                return -EBUSY;
+        ftdi_elan_get_kref(ftdi);
+        ftdi->platform_data.potpg = 100;
+        ftdi->platform_data.reset = NULL;
+        ftdi->platform_dev.id = ftdi->sequence_num;
+        ftdi->platform_dev.resource = ftdi->resources;
+        ftdi->platform_dev.num_resources = ARRAY_SIZE(ftdi->resources);
+        ftdi->platform_dev.dev.platform_data = &ftdi->platform_data;
+        ftdi->platform_dev.dev.parent = NULL;
+        ftdi->platform_dev.dev.release = ftdi_release_platform_dev;
+        ftdi->platform_dev.dev.dma_mask = NULL;
+        snprintf(ftdi->device_name, sizeof(ftdi->device_name), "u132_hcd");
+        ftdi->platform_dev.name = ftdi->device_name;
+        dev_info(&ftdi->udev->dev, "requesting module '%s'\n", "u132_hcd");
+        request_module("u132_hcd");
+        dev_info(&ftdi->udev->dev, "registering '%s'\n",
+                 ftdi->platform_dev.name);
+        result = platform_device_register(&ftdi->platform_dev);
+        return result;
 }
 
 static void ftdi_elan_abandon_completions(struct usb_ftdi *ftdi)
 {
-        mutex_lock(&ftdi->u132_lock);
-        while (ftdi->respond_next > ftdi->respond_head) {
-                struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
-                        ftdi->respond_head++];
-                *respond->result = -ESHUTDOWN;
-                *respond->value = 0;
-                complete(&respond->wait_completion);
-        } mutex_unlock(&ftdi->u132_lock);
+        mutex_lock(&ftdi->u132_lock);
+        while (ftdi->respond_next > ftdi->respond_head) {
+                struct u132_respond *respond = &ftdi->respond[RESPOND_MASK &
+                                                              ftdi->respond_head++];
+                *respond->result = -ESHUTDOWN;
+                *respond->value = 0;
+                complete(&respond->wait_completion);
+        } mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_abandon_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                if (target->active == 1) {
-                        target->condition_code = TD_DEVNOTRESP;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, NULL, 0);
-                        mutex_lock(&ftdi->u132_lock);
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                if (target->active == 1) {
+                        target->condition_code = TD_DEVNOTRESP;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, NULL, 0);
+                        mutex_lock(&ftdi->u132_lock);
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_flush_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                target->abandoning = 1;
-              wait_1:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x80 | (ed_number << 5) | 0x4;
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait_1;
-                        }
-                }
-              wait_2:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x90 | (ed_number << 5);
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait_2;
-                        }
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                target->abandoning = 1;
+        wait_1:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x80 | (ed_number << 5) | 0x4;
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait_1;
+                        }
+                }
+        wait_2:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x90 | (ed_number << 5);
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait_2;
+                        }
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_cancel_targets(struct usb_ftdi *ftdi)
 {
-        int ed_number = 4;
-        mutex_lock(&ftdi->u132_lock);
-        while (ed_number-- > 0) {
-                struct u132_target *target = &ftdi->target[ed_number];
-                target->abandoning = 1;
-              wait:if (target->active == 1) {
-                        int command_size = ftdi->command_next -
-                                ftdi->command_head;
-                        if (command_size < COMMAND_SIZE) {
-                                struct u132_command *command = &ftdi->command[
-                                        COMMAND_MASK & ftdi->command_next];
-                                command->header = 0x80 | (ed_number << 5) | 0x4;
-                                command->length = 0x00;
-                                command->address = 0x00;
-                                command->width = 0x00;
-                                command->follows = 0;
-                                command->value = 0;
-                                command->buffer = &command->value;
-                                ftdi->command_next += 1;
-                                ftdi_elan_kick_command_queue(ftdi);
-                        } else {
-                                mutex_unlock(&ftdi->u132_lock);
-                                msleep(100);
-                                mutex_lock(&ftdi->u132_lock);
-                                goto wait;
-                        }
-                }
-        }
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        mutex_unlock(&ftdi->u132_lock);
+        int ed_number = 4;
+        mutex_lock(&ftdi->u132_lock);
+        while (ed_number-- > 0) {
+                struct u132_target *target = &ftdi->target[ed_number];
+                target->abandoning = 1;
+        wait:if (target->active == 1) {
+                        int command_size = ftdi->command_next -
+                                ftdi->command_head;
+                        if (command_size < COMMAND_SIZE) {
+                                struct u132_command *command = &ftdi->command[
+                                        COMMAND_MASK & ftdi->command_next];
+                                command->header = 0x80 | (ed_number << 5) | 0x4;
+                                command->length = 0x00;
+                                command->address = 0x00;
+                                command->width = 0x00;
+                                command->follows = 0;
+                                command->value = 0;
+                                command->buffer = &command->value;
+                                ftdi->command_next += 1;
+                                ftdi_elan_kick_command_queue(ftdi);
+                        } else {
+                                mutex_unlock(&ftdi->u132_lock);
+                                msleep(100);
+                                mutex_lock(&ftdi->u132_lock);
+                                goto wait;
+                        }
+                }
+        }
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        mutex_unlock(&ftdi->u132_lock);
 }
 
 static void ftdi_elan_kick_command_queue(struct usb_ftdi *ftdi)
 {
-        ftdi_command_queue_work(ftdi, 0);
+        ftdi_command_queue_work(ftdi, 0);
 }
 
 static void ftdi_elan_command_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, command_work.work);
 
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                int retval = ftdi_elan_command_engine(ftdi);
-                if (retval == -ESHUTDOWN) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -ENODEV) {
-                        ftdi->disconnected += 1;
-                } else if (retval)
-                        dev_err(&ftdi->udev->dev, "command error %d\n", retval);
-                ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
-                return;
-        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                int retval = ftdi_elan_command_engine(ftdi);
+                if (retval == -ESHUTDOWN) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -ENODEV) {
+                        ftdi->disconnected += 1;
+                } else if (retval)
+                        dev_err(&ftdi->udev->dev, "command error %d\n", retval);
+                ftdi_command_requeue_work(ftdi, msecs_to_jiffies(10));
+                return;
+        }
 }
 
 static void ftdi_elan_kick_respond_queue(struct usb_ftdi *ftdi)
 {
-        ftdi_respond_queue_work(ftdi, 0);
+        ftdi_respond_queue_work(ftdi, 0);
 }
 
 static void ftdi_elan_respond_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, respond_work.work);
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                int retval = ftdi_elan_respond_engine(ftdi);
-                if (retval == 0) {
-                } else if (retval == -ESHUTDOWN) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -ENODEV) {
-                        ftdi->disconnected += 1;
-                } else if (retval == -EILSEQ) {
-                        ftdi->disconnected += 1;
-                } else {
-                        ftdi->disconnected += 1;
-                        dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
-                }
-                if (ftdi->disconnected > 0) {
-                        ftdi_elan_abandon_completions(ftdi);
-                        ftdi_elan_abandon_targets(ftdi);
-                }
-                ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
-                return;
-        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                int retval = ftdi_elan_respond_engine(ftdi);
+                if (retval == 0) {
+                } else if (retval == -ESHUTDOWN) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -ENODEV) {
+                        ftdi->disconnected += 1;
+                } else if (retval == -EILSEQ) {
+                        ftdi->disconnected += 1;
+                } else {
+                        ftdi->disconnected += 1;
+                        dev_err(&ftdi->udev->dev, "respond error %d\n", retval);
+                }
+                if (ftdi->disconnected > 0) {
+                        ftdi_elan_abandon_completions(ftdi);
+                        ftdi_elan_abandon_targets(ftdi);
+                }
+                ftdi_response_requeue_work(ftdi, msecs_to_jiffies(10));
+                return;
+        }
 }
 
 
 /*
-* the sw_lock is initially held and will be freed
-* after the FTDI has been synchronized
-*
-*/
+ * the sw_lock is initially held and will be freed
+ * after the FTDI has been synchronized
+ *
+ */
 static void ftdi_elan_status_work(struct work_struct *work)
 {
-        struct usb_ftdi *ftdi =
+        struct usb_ftdi *ftdi =
                 container_of(work, struct usb_ftdi, status_work.work);
-        int work_delay_in_msec = 0;
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else if (ftdi->synchronized == 0) {
-                down(&ftdi->sw_lock);
-                if (ftdi_elan_synchronize(ftdi) == 0) {
-                        ftdi->synchronized = 1;
-                        ftdi_command_queue_work(ftdi, 1);
-                        ftdi_respond_queue_work(ftdi, 1);
-                        up(&ftdi->sw_lock);
-                        work_delay_in_msec = 100;
-                } else {
-                        dev_err(&ftdi->udev->dev, "synchronize failed\n");
-                        up(&ftdi->sw_lock);
-                        work_delay_in_msec = 10 *1000;
-                }
-        } else if (ftdi->stuck_status > 0) {
-                if (ftdi_elan_stuck_waiting(ftdi) == 0) {
-                        ftdi->stuck_status = 0;
-                        ftdi->synchronized = 0;
-                } else if ((ftdi->stuck_status++ % 60) == 1) {
-                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
-                                "- please remove\n");
-                } else
-                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted "
-                                "- checked %d times\n", ftdi->stuck_status);
-                work_delay_in_msec = 100;
-        } else if (ftdi->enumerated == 0) {
-                if (ftdi_elan_enumeratePCI(ftdi) == 0) {
-                        ftdi->enumerated = 1;
-                        work_delay_in_msec = 250;
-                } else
-                        work_delay_in_msec = 1000;
-        } else if (ftdi->initialized == 0) {
-                if (ftdi_elan_setupOHCI(ftdi) == 0) {
-                        ftdi->initialized = 1;
-                        work_delay_in_msec = 500;
-                } else {
-                        dev_err(&ftdi->udev->dev, "initialized failed - trying "
-                                "again in 10 seconds\n");
-                        work_delay_in_msec = 1 *1000;
-                }
-        } else if (ftdi->registered == 0) {
-                work_delay_in_msec = 10;
-                if (ftdi_elan_hcd_init(ftdi) == 0) {
-                        ftdi->registered = 1;
-                } else
-                        dev_err(&ftdi->udev->dev, "register failed\n");
-                work_delay_in_msec = 250;
-        } else {
-                if (ftdi_elan_checkingPCI(ftdi) == 0) {
-                        work_delay_in_msec = 250;
-                } else if (ftdi->controlreg & 0x00400000) {
-                        if (ftdi->gone_away > 0) {
-                                dev_err(&ftdi->udev->dev, "PCI device eject con"
-                                        "firmed platform_dev.dev.parent=%p plat"
-                                        "form_dev.dev=%p\n",
-                                        ftdi->platform_dev.dev.parent,
-                                        &ftdi->platform_dev.dev);
-                                platform_device_unregister(&ftdi->platform_dev);
-                                ftdi->platform_dev.dev.parent = NULL;
-                                ftdi->registered = 0;
-                                ftdi->enumerated = 0;
-                                ftdi->card_ejected = 0;
-                                ftdi->initialized = 0;
-                                ftdi->gone_away = 0;
-                        } else
-                                ftdi_elan_flush_targets(ftdi);
-                        work_delay_in_msec = 250;
-                } else {
-                        dev_err(&ftdi->udev->dev, "PCI device has disappeared\n"
-                                );
-                        ftdi_elan_cancel_targets(ftdi);
-                        work_delay_in_msec = 500;
-                        ftdi->enumerated = 0;
-                        ftdi->initialized = 0;
-                }
-        }
-        if (ftdi->disconnected > 0) {
-                ftdi_elan_put_kref(ftdi);
-                return;
-        } else {
-                ftdi_status_requeue_work(ftdi,
-                        msecs_to_jiffies(work_delay_in_msec));
-                return;
-        }
+        int work_delay_in_msec = 0;
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else if (ftdi->synchronized == 0) {
+                down(&ftdi->sw_lock);
+                if (ftdi_elan_synchronize(ftdi) == 0) {
+                        ftdi->synchronized = 1;
+                        ftdi_command_queue_work(ftdi, 1);
+                        ftdi_respond_queue_work(ftdi, 1);
+                        up(&ftdi->sw_lock);
+                        work_delay_in_msec = 100;
+                } else {
+                        dev_err(&ftdi->udev->dev, "synchronize failed\n");
+                        up(&ftdi->sw_lock);
+                        work_delay_in_msec = 10 *1000;
+                }
+        } else if (ftdi->stuck_status > 0) {
+                if (ftdi_elan_stuck_waiting(ftdi) == 0) {
+                        ftdi->stuck_status = 0;
+                        ftdi->synchronized = 0;
+                } else if ((ftdi->stuck_status++ % 60) == 1) {
+                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted - please remove\n");
+                } else
+                        dev_err(&ftdi->udev->dev, "WRONG type of card inserted - checked %d times\n",
+                                ftdi->stuck_status);
+                work_delay_in_msec = 100;
+        } else if (ftdi->enumerated == 0) {
+                if (ftdi_elan_enumeratePCI(ftdi) == 0) {
+                        ftdi->enumerated = 1;
+                        work_delay_in_msec = 250;
+                } else
+                        work_delay_in_msec = 1000;
+        } else if (ftdi->initialized == 0) {
+                if (ftdi_elan_setupOHCI(ftdi) == 0) {
+                        ftdi->initialized = 1;
+                        work_delay_in_msec = 500;
+                } else {
+                        dev_err(&ftdi->udev->dev, "initialized failed - trying again in 10 seconds\n");
+                        work_delay_in_msec = 1 *1000;
+                }
+        } else if (ftdi->registered == 0) {
+                work_delay_in_msec = 10;
+                if (ftdi_elan_hcd_init(ftdi) == 0) {
+                        ftdi->registered = 1;
+                } else
+                        dev_err(&ftdi->udev->dev, "register failed\n");
+                work_delay_in_msec = 250;
+        } else {
+                if (ftdi_elan_checkingPCI(ftdi) == 0) {
+                        work_delay_in_msec = 250;
+                } else if (ftdi->controlreg & 0x00400000) {
+                        if (ftdi->gone_away > 0) {
+                                dev_err(&ftdi->udev->dev, "PCI device eject confirmed platform_dev.dev.parent=%p platform_dev.dev=%p\n",
+                                        ftdi->platform_dev.dev.parent,
+                                        &ftdi->platform_dev.dev);
+                                platform_device_unregister(&ftdi->platform_dev);
+                                ftdi->platform_dev.dev.parent = NULL;
+                                ftdi->registered = 0;
+                                ftdi->enumerated = 0;
+                                ftdi->card_ejected = 0;
+                                ftdi->initialized = 0;
+                                ftdi->gone_away = 0;
+                        } else
+                                ftdi_elan_flush_targets(ftdi);
+                        work_delay_in_msec = 250;
+                } else {
+                        dev_err(&ftdi->udev->dev, "PCI device has disappeared\n");
+                        ftdi_elan_cancel_targets(ftdi);
+                        work_delay_in_msec = 500;
+                        ftdi->enumerated = 0;
+                        ftdi->initialized = 0;
+                }
+        }
+        if (ftdi->disconnected > 0) {
+                ftdi_elan_put_kref(ftdi);
+                return;
+        } else {
+                ftdi_status_requeue_work(ftdi,
+                                         msecs_to_jiffies(work_delay_in_msec));
+                return;
+        }
 }
 
 
 /*
-* file_operations for the jtag interface
-*
-* the usage count for the device is incremented on open()
-* and decremented on release()
-*/
+ * file_operations for the jtag interface
+ *
+ * the usage count for the device is incremented on open()
+ * and decremented on release()
+ */
 static int ftdi_elan_open(struct inode *inode, struct file *file)
 {
         int subminor;
         struct usb_interface *interface;
 
-        subminor = iminor(inode);
-        interface = usb_find_interface(&ftdi_elan_driver, subminor);
-
-        if (!interface) {
-                printk(KERN_ERR "can't find device for minor %d\n", subminor);
-                return -ENODEV;
-        } else {
-                struct usb_ftdi *ftdi = usb_get_intfdata(interface);
-                if (!ftdi) {
-                        return -ENODEV;
-                } else {
-                        if (down_interruptible(&ftdi->sw_lock)) {
-                                return -EINTR;
-                        } else {
-                                ftdi_elan_get_kref(ftdi);
-                                file->private_data = ftdi;
-                                return 0;
-                        }
-                }
-        }
+        subminor = iminor(inode);
+        interface = usb_find_interface(&ftdi_elan_driver, subminor);
+
+        if (!interface) {
+                pr_err("can't find device for minor %d\n", subminor);
+                return -ENODEV;
+        } else {
+                struct usb_ftdi *ftdi = usb_get_intfdata(interface);
+                if (!ftdi) {
+                        return -ENODEV;
+                } else {
+                        if (down_interruptible(&ftdi->sw_lock)) {
+                                return -EINTR;
+                        } else {
+                                ftdi_elan_get_kref(ftdi);
+                                file->private_data = ftdi;
+                                return 0;
+                        }
+                }
+        }
 }
 
 static int ftdi_elan_release(struct inode *inode, struct file *file)
 {
-        struct usb_ftdi *ftdi = file->private_data;
-        if (ftdi == NULL)
-                return -ENODEV;
-        up(&ftdi->sw_lock);        /* decrement the count on our device */
-        ftdi_elan_put_kref(ftdi);
-        return 0;
+        struct usb_ftdi *ftdi = file->private_data;
+        if (ftdi == NULL)
+                return -ENODEV;
+        up(&ftdi->sw_lock);        /* decrement the count on our device */
+        ftdi_elan_put_kref(ftdi);
+        return 0;
 }
 
 
 /*
-*
-* blocking bulk reads are used to get data from the device
-*
-*/
+ *
+ * blocking bulk reads are used to get data from the device
+ *
+ */
 static ssize_t ftdi_elan_read(struct file *file, char __user *buffer,
                               size_t count, loff_t *ppos)
 {
-        char data[30 *3 + 4];
-        char *d = data;
-        int m = (sizeof(data) - 1) / 3;
-        int bytes_read = 0;
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        struct usb_ftdi *ftdi = file->private_data;
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        }
-        data[0] = 0;
-      have:if (ftdi->bulk_in_left > 0) {
-                if (count-- > 0) {
-                        char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
-                        ftdi->bulk_in_left -= 1;
-                        if (bytes_read < m) {
-                                d += sprintf(d, " %02X", 0x000000FF & *p);
-                        } else if (bytes_read > m) {
-                        } else
-                                d += sprintf(d, " ..");
-                        if (copy_to_user(buffer++, p, 1)) {
-                                return -EFAULT;
-                        } else {
-                                bytes_read += 1;
-                                goto have;
-                        }
-                } else
-                        return bytes_read;
-        }
-      more:if (count > 0) {
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 50);
-                if (packet_bytes > 2) {
-                        ftdi->bulk_in_left = packet_bytes - 2;
-                        ftdi->bulk_in_last = 1;
-                        goto have;
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else if (bytes_read > 0) {
-                                return bytes_read;
-                        } else
-                                return retval;
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return bytes_read;
-                } else
-                        return retval;
-        } else
-                return bytes_read;
+        char data[30 *3 + 4];
+        char *d = data;
+        int m = (sizeof(data) - 1) / 3;
+        int bytes_read = 0;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        struct usb_ftdi *ftdi = file->private_data;
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        }
+        data[0] = 0;
+have:if (ftdi->bulk_in_left > 0) {
+                if (count-- > 0) {
+                        char *p = ++ftdi->bulk_in_last + ftdi->bulk_in_buffer;
+                        ftdi->bulk_in_left -= 1;
+                        if (bytes_read < m) {
+                                d += sprintf(d, " %02X", 0x000000FF & *p);
+                        } else if (bytes_read > m) {
+                        } else
+                                d += sprintf(d, " ..");
+                        if (copy_to_user(buffer++, p, 1)) {
+                                return -EFAULT;
+                        } else {
+                                bytes_read += 1;
+                                goto have;
+                        }
+                } else
+                        return bytes_read;
+        }
+more:if (count > 0) {
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 50);
+                if (packet_bytes > 2) {
+                        ftdi->bulk_in_left = packet_bytes - 2;
+                        ftdi->bulk_in_last = 1;
+                        goto have;
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else if (bytes_read > 0) {
+                                return bytes_read;
+                        } else
+                                return retval;
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return bytes_read;
+                } else
+                        return retval;
+        } else
+                return bytes_read;
 }
 
 static void ftdi_elan_write_bulk_callback(struct urb *urb)
@@ -728,467 +726,460 @@ static void ftdi_elan_write_bulk_callback(struct urb *urb)
         int status = urb->status;
 
         if (status && !(status == -ENOENT || status == -ECONNRESET ||
-            status == -ESHUTDOWN)) {
-                dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %"
-                        "d\n", urb, status);
-        }
-        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
-                urb->transfer_buffer, urb->transfer_dma);
+                        status == -ESHUTDOWN)) {
+                dev_err(&ftdi->udev->dev,
+                        "urb=%p write bulk status received: %d\n", urb, status);
+        }
+        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
+                          urb->transfer_buffer, urb->transfer_dma);
 }
 
 static int fill_buffer_with_all_queued_commands(struct usb_ftdi *ftdi,
-        char *buf, int command_size, int total_size)
-{
-        int ed_commands = 0;
-        int b = 0;
-        int I = command_size;
-        int i = ftdi->command_head;
-        while (I-- > 0) {
-                struct u132_command *command = &ftdi->command[COMMAND_MASK &
-                        i++];
-                int F = command->follows;
-                u8 *f = command->buffer;
-                if (command->header & 0x80) {
-                        ed_commands |= 1 << (0x3 & (command->header >> 5));
-                }
-                buf[b++] = command->header;
-                buf[b++] = (command->length >> 0) & 0x00FF;
-                buf[b++] = (command->length >> 8) & 0x00FF;
-                buf[b++] = command->address;
-                buf[b++] = command->width;
-                while (F-- > 0) {
-                        buf[b++] = *f++;
-                }
-        }
-        return ed_commands;
+                                                char *buf, int command_size, int total_size)
+{
+        int ed_commands = 0;
+        int b = 0;
+        int I = command_size;
+        int i = ftdi->command_head;
+        while (I-- > 0) {
+                struct u132_command *command = &ftdi->command[COMMAND_MASK &
+                                                              i++];
+                int F = command->follows;
+                u8 *f = command->buffer;
+                if (command->header & 0x80) {
+                        ed_commands |= 1 << (0x3 & (command->header >> 5));
+                }
+                buf[b++] = command->header;
+                buf[b++] = (command->length >> 0) & 0x00FF;
+                buf[b++] = (command->length >> 8) & 0x00FF;
+                buf[b++] = command->address;
+                buf[b++] = command->width;
+                while (F-- > 0) {
+                        buf[b++] = *f++;
+                }
+        }
+        return ed_commands;
 }
 
 static int ftdi_elan_total_command_size(struct usb_ftdi *ftdi, int command_size)
 {
-        int total_size = 0;
-        int I = command_size;
-        int i = ftdi->command_head;
-        while (I-- > 0) {
-                struct u132_command *command = &ftdi->command[COMMAND_MASK &
-                        i++];
-                total_size += 5 + command->follows;
-        } return total_size;
+        int total_size = 0;
+        int I = command_size;
+        int i = ftdi->command_head;
+        while (I-- > 0) {
+                struct u132_command *command = &ftdi->command[COMMAND_MASK &
+                                                              i++];
+                total_size += 5 + command->follows;
+        } return total_size;
 }
 
 static int ftdi_elan_command_engine(struct usb_ftdi *ftdi)
 {
-        int retval;
-        char *buf;
-        int ed_commands;
-        int total_size;
-        struct urb *urb;
-        int command_size = ftdi->command_next - ftdi->command_head;
-        if (command_size == 0)
-                return 0;
-        total_size = ftdi_elan_total_command_size(ftdi, command_size);
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not get a urb to write %d comm"
-                        "ands totaling %d bytes to the Uxxx\n", command_size,
-                        total_size);
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
-                &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer to write %d c"
-                        "ommands totaling %d bytes to the Uxxx\n", command_size,
-                         total_size);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
-                command_size, total_size);
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, total_size,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        if (ed_commands) {
-                char diag[40 *3 + 4];
-                char *d = diag;
-                int m = total_size;
-                u8 *c = buf;
-                int s = (sizeof(diag) - 1) / 3;
-                diag[0] = 0;
-                while (s-- > 0 && m-- > 0) {
-                        if (s > 0 || m == 0) {
-                                d += sprintf(d, " %02X", *c++);
-                        } else
-                                d += sprintf(d, " ..");
-                }
-        }
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write "
-                        "%d commands totaling %d bytes to the Uxxx\n", retval,
-                        urb, command_size, total_size);
-                usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return retval;
-        }
-        usb_free_urb(urb);        /* release our reference to this urb,
-                the USB core will eventually free it entirely */
-        ftdi->command_head += command_size;
-        ftdi_elan_kick_respond_queue(ftdi);
-        return 0;
+        int retval;
+        char *buf;
+        int ed_commands;
+        int total_size;
+        struct urb *urb;
+        int command_size = ftdi->command_next - ftdi->command_head;
+        if (command_size == 0)
+                return 0;
+        total_size = ftdi_elan_total_command_size(ftdi, command_size);
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not get a urb to write %d commands totaling %d bytes to the Uxxx\n",
+                        command_size, total_size);
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL,
+                                 &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer to write %d commands totaling %d bytes to the Uxxx\n",
+                        command_size, total_size);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        ed_commands = fill_buffer_with_all_queued_commands(ftdi, buf,
+                                                           command_size, total_size);
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, total_size,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        if (ed_commands) {
+                char diag[40 *3 + 4];
+                char *d = diag;
+                int m = total_size;
+                u8 *c = buf;
+                int s = (sizeof(diag) - 1) / 3;
+                diag[0] = 0;
+                while (s-- > 0 && m-- > 0) {
+                        if (s > 0 || m == 0) {
+                                d += sprintf(d, " %02X", *c++);
+                        } else
+                                d += sprintf(d, " ..");
+                }
+        }
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write %d commands totaling %d bytes to the Uxxx\n",
+                        retval, urb, command_size, total_size);
+                usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return retval;
+        }
+        usb_free_urb(urb);        /* release our reference to this urb,
+                                     the USB core will eventually free it entirely */
+        ftdi->command_head += command_size;
+        ftdi_elan_kick_respond_queue(ftdi);
+        return 0;
 }
 
 static void ftdi_elan_do_callback(struct usb_ftdi *ftdi,
-        struct u132_target *target, u8 *buffer, int length)
-{
-        struct urb *urb = target->urb;
-        int halted = target->halted;
-        int skipped = target->skipped;
-        int actual = target->actual;
-        int non_null = target->non_null;
-        int toggle_bits = target->toggle_bits;
-        int error_count = target->error_count;
-        int condition_code = target->condition_code;
-        int repeat_number = target->repeat_number;
-        void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int,
-                int, int, int, int) = target->callback;
-        target->active -= 1;
-        target->callback = NULL;
-        (*callback) (target->endp, urb, buffer, length, toggle_bits,
-                error_count, condition_code, repeat_number, halted, skipped,
-                actual, non_null);
+                                  struct u132_target *target, u8 *buffer, int length)
+{
+        struct urb *urb = target->urb;
+        int halted = target->halted;
+        int skipped = target->skipped;
+        int actual = target->actual;
+        int non_null = target->non_null;
+        int toggle_bits = target->toggle_bits;
+        int error_count = target->error_count;
+        int condition_code = target->condition_code;
+        int repeat_number = target->repeat_number;
+        void (*callback) (void *, struct urb *, u8 *, int, int, int, int, int,
+                          int, int, int, int) = target->callback;
+        target->active -= 1;
+        target->callback = NULL;
+        (*callback) (target->endp, urb, buffer, length, toggle_bits,
+                     error_count, condition_code, repeat_number, halted, skipped,
+                     actual, non_null);
 }
 
 static char *have_ed_set_response(struct usb_ftdi *ftdi,
-        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
-        char *b)
-{
-        int payload = (ed_length >> 0) & 0x07FF;
-        mutex_lock(&ftdi->u132_lock);
-        target->actual = 0;
-        target->non_null = (ed_length >> 15) & 0x0001;
-        target->repeat_number = (ed_length >> 11) & 0x000F;
-        if (ed_type == 0x02) {
-                if (payload == 0 || target->abandoning > 0) {
-                        target->abandoning = 0;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        return ftdi->response;
-                } else {
-                        ftdi->expected = 4 + payload;
-                        ftdi->ed_found = 1;
-                        mutex_unlock(&ftdi->u132_lock);
-                        return b;
-                }
-        } else if (ed_type == 0x03) {
-                if (payload == 0 || target->abandoning > 0) {
-                        target->abandoning = 0;
-                        mutex_unlock(&ftdi->u132_lock);
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        return ftdi->response;
-                } else {
-                        ftdi->expected = 4 + payload;
-                        ftdi->ed_found = 1;
-                        mutex_unlock(&ftdi->u132_lock);
-                        return b;
-                }
-        } else if (ed_type == 0x01) {
-                target->abandoning = 0;
-                mutex_unlock(&ftdi->u132_lock);
-                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                        payload);
-                ftdi->received = 0;
-                ftdi->expected = 4;
-                ftdi->ed_found = 0;
-                return ftdi->response;
-        } else {
-                target->abandoning = 0;
-                mutex_unlock(&ftdi->u132_lock);
-                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                        payload);
-                ftdi->received = 0;
-                ftdi->expected = 4;
-                ftdi->ed_found = 0;
-                return ftdi->response;
-        }
+                                  struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
+                                  char *b)
+{
+        int payload = (ed_length >> 0) & 0x07FF;
+        mutex_lock(&ftdi->u132_lock);
+        target->actual = 0;
+        target->non_null = (ed_length >> 15) & 0x0001;
+        target->repeat_number = (ed_length >> 11) & 0x000F;
+        if (ed_type == 0x02) {
+                if (payload == 0 || target->abandoning > 0) {
+                        target->abandoning = 0;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        return ftdi->response;
+                } else {
+                        ftdi->expected = 4 + payload;
+                        ftdi->ed_found = 1;
+                        mutex_unlock(&ftdi->u132_lock);
+                        return b;
+                }
+        } else if (ed_type == 0x03) {
+                if (payload == 0 || target->abandoning > 0) {
+                        target->abandoning = 0;
+                        mutex_unlock(&ftdi->u132_lock);
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        return ftdi->response;
+                } else {
+                        ftdi->expected = 4 + payload;
+                        ftdi->ed_found = 1;
+                        mutex_unlock(&ftdi->u132_lock);
+                        return b;
+                }
+        } else if (ed_type == 0x01) {
+                target->abandoning = 0;
+                mutex_unlock(&ftdi->u132_lock);
+                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                      payload);
+                ftdi->received = 0;
+                ftdi->expected = 4;
+                ftdi->ed_found = 0;
+                return ftdi->response;
+        } else {
+                target->abandoning = 0;
+                mutex_unlock(&ftdi->u132_lock);
+                ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                      payload);
+                ftdi->received = 0;
+                ftdi->expected = 4;
+                ftdi->ed_found = 0;
+                return ftdi->response;
+        }
 }
 
 static char *have_ed_get_response(struct usb_ftdi *ftdi,
-        struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
-        char *b)
+                                  struct u132_target *target, u16 ed_length, int ed_number, int ed_type,
+                                  char *b)
 {
-        mutex_lock(&ftdi->u132_lock);
-        target->condition_code = TD_DEVNOTRESP;
-        target->actual = (ed_length >> 0) & 0x01FF;
-        target->non_null = (ed_length >> 15) & 0x0001;
-        target->repeat_number = (ed_length >> 11) & 0x000F;
-        mutex_unlock(&ftdi->u132_lock);
-        if (target->active)
-                ftdi_elan_do_callback(ftdi, target, NULL, 0);
-        target->abandoning = 0;
-        ftdi->received = 0;
-        ftdi->expected = 4;
-        ftdi->ed_found = 0;
-        return ftdi->response;
+        mutex_lock(&ftdi->u132_lock);
+        target->condition_code = TD_DEVNOTRESP;
+        target->actual = (ed_length >> 0) & 0x01FF;
+        target->non_null = (ed_length >> 15) & 0x0001;
+        target->repeat_number = (ed_length >> 11) & 0x000F;
+        mutex_unlock(&ftdi->u132_lock);
+        if (target->active)
+                ftdi_elan_do_callback(ftdi, target, NULL, 0);
+        target->abandoning = 0;
+        ftdi->received = 0;
+        ftdi->expected = 4;
+        ftdi->ed_found = 0;
+        return ftdi->response;
 }
 
 
 /*
-* The engine tries to empty the FTDI fifo
-*
-* all responses found in the fifo data are dispatched thus
-* the response buffer can only ever hold a maximum sized
-* response from the Uxxx.
-*
-*/
+ * The engine tries to empty the FTDI fifo
+ *
+ * all responses found in the fifo data are dispatched thus
+ * the response buffer can only ever hold a maximum sized
+ * response from the Uxxx.
+ *
+ */
 static int ftdi_elan_respond_engine(struct usb_ftdi *ftdi)
 {
-        u8 *b = ftdi->response + ftdi->received;
-        int bytes_read = 0;
-        int retry_on_empty = 1;
-        int retry_on_timeout = 3;
-        int empty_packets = 0;
-      read:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 500);
-                char diag[30 *3 + 4];
-                char *d = diag;
-                int m = packet_bytes;
-                u8 *c = ftdi->bulk_in_buffer;
-                int s = (sizeof(diag) - 1) / 3;
-                diag[0] = 0;
-                while (s-- > 0 && m-- > 0) {
-                        if (s > 0 || m == 0) {
-                                d += sprintf(d, " %02X", *c++);
-                        } else
-                                d += sprintf(d, " ..");
-                }
-                if (packet_bytes > 2) {
-                        ftdi->bulk_in_left = packet_bytes - 2;
-                        ftdi->bulk_in_last = 1;
-                        goto have;
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
-                                        "t_bytes = %d with total %d bytes%s\n",
-                                        packet_bytes, bytes_read, diag);
-                                goto more;
-                        } else if (bytes_read > 0) {
-                                dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
-                                        bytes_read, diag);
-                                return -ENOMEM;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT with packe"
-                                        "t_bytes = %d with total %d bytes%s\n",
-                                        packet_bytes, bytes_read, diag);
-                                return -ENOMEM;
-                        }
-                } else if (retval == -EILSEQ) {
-                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
-                                " = %d with total %d bytes%s\n", retval,
-                                packet_bytes, bytes_read, diag);
-                        return retval;
-                } else if (retval) {
-                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes"
-                                " = %d with total %d bytes%s\n", retval,
-                                packet_bytes, bytes_read, diag);
-                        return retval;
-                } else if (packet_bytes == 2) {
-                        unsigned char s0 = ftdi->bulk_in_buffer[0];
-                        unsigned char s1 = ftdi->bulk_in_buffer[1];
-                        empty_packets += 1;
-                        if (s0 == 0x31 && s1 == 0x60) {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        } else if (s0 == 0x31 && s1 == 0x00) {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        } else {
-                                if (retry_on_empty-- > 0) {
-                                        goto more;
-                                } else
-                                        return 0;
-                        }
-                } else if (packet_bytes == 1) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return 0;
-                } else {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else
-                                return 0;
-                }
-        }
-      more:{
-                goto read;
-        }
-      have:if (ftdi->bulk_in_left > 0) {
-                u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
-                bytes_read += 1;
-                ftdi->bulk_in_left -= 1;
-                if (ftdi->received == 0 && c == 0xFF) {
-                        goto have;
-                } else
-                        *b++ = c;
-                if (++ftdi->received < ftdi->expected) {
-                        goto have;
-                } else if (ftdi->ed_found) {
-                        int ed_number = (ftdi->response[0] >> 5) & 0x03;
-                        u16 ed_length = (ftdi->response[2] << 8) |
-                                ftdi->response[1];
-                        struct u132_target *target = &ftdi->target[ed_number];
-                        int payload = (ed_length >> 0) & 0x07FF;
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = payload;
-                        u8 *c = 4 + ftdi->response;
-                        int s = (sizeof(diag) - 1) / 3;
-                        diag[0] = 0;
-                        while (s-- > 0 && m-- > 0) {
-                                if (s > 0 || m == 0) {
-                                        d += sprintf(d, " %02X", *c++);
-                                } else
-                                        d += sprintf(d, " ..");
-                        }
-                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
-                                payload);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        b = ftdi->response;
-                        goto have;
-                } else if (ftdi->expected == 8) {
-                        u8 buscmd;
-                        int respond_head = ftdi->respond_head++;
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & respond_head];
-                        u32 data = ftdi->response[7];
-                        data <<= 8;
-                        data |= ftdi->response[6];
-                        data <<= 8;
-                        data |= ftdi->response[5];
-                        data <<= 8;
-                        data |= ftdi->response[4];
-                        *respond->value = data;
-                        *respond->result = 0;
-                        complete(&respond->wait_completion);
-                        ftdi->received = 0;
-                        ftdi->expected = 4;
-                        ftdi->ed_found = 0;
-                        b = ftdi->response;
-                        buscmd = (ftdi->response[0] >> 0) & 0x0F;
-                        if (buscmd == 0x00) {
-                        } else if (buscmd == 0x02) {
-                        } else if (buscmd == 0x06) {
-                        } else if (buscmd == 0x0A) {
-                        } else
-                                dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) va"
-                                        "lue = %08X\n", buscmd, data);
-                        goto have;
-                } else {
-                        if ((ftdi->response[0] & 0x80) == 0x00) {
-                                ftdi->expected = 8;
-                                goto have;
-                        } else {
-                                int ed_number = (ftdi->response[0] >> 5) & 0x03;
-                                int ed_type = (ftdi->response[0] >> 0) & 0x03;
-                                u16 ed_length = (ftdi->response[2] << 8) |
-                                        ftdi->response[1];
-                                struct u132_target *target = &ftdi->target[
-                                        ed_number];
-                                target->halted = (ftdi->response[0] >> 3) &
-                                        0x01;
-                                target->skipped = (ftdi->response[0] >> 2) &
-                                        0x01;
-                                target->toggle_bits = (ftdi->response[3] >> 6)
-                                        & 0x03;
-                                target->error_count = (ftdi->response[3] >> 4)
-                                        & 0x03;
-                                target->condition_code = (ftdi->response[
-                                        3] >> 0) & 0x0F;
-                                if ((ftdi->response[0] & 0x10) == 0x00) {
-                                        b = have_ed_set_response(ftdi, target,
-                                                ed_length, ed_number, ed_type,
-                                                b);
-                                        goto have;
-                                } else {
-                                        b = have_ed_get_response(ftdi, target,
-                                                ed_length, ed_number, ed_type,
-                                                b);
-                                        goto have;
-                                }
-                        }
-                }
-        } else
-                goto more;
+        u8 *b = ftdi->response + ftdi->received;
+        int bytes_read = 0;
+        int retry_on_empty = 1;
+        int retry_on_timeout = 3;
+        int empty_packets = 0;
+read:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 500);
+                char diag[30 *3 + 4];
+                char *d = diag;
+                int m = packet_bytes;
+                u8 *c = ftdi->bulk_in_buffer;
+                int s = (sizeof(diag) - 1) / 3;
+                diag[0] = 0;
+                while (s-- > 0 && m-- > 0) {
+                        if (s > 0 || m == 0) {
+                                d += sprintf(d, " %02X", *c++);
+                        } else
+                                d += sprintf(d, " ..");
+                }
+                if (packet_bytes > 2) {
+                        ftdi->bulk_in_left = packet_bytes - 2;
+                        ftdi->bulk_in_last = 1;
+                        goto have;
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
+                                        packet_bytes, bytes_read, diag);
+                                goto more;
+                        } else if (bytes_read > 0) {
+                                dev_err(&ftdi->udev->dev, "ONLY %d bytes%s\n",
+                                        bytes_read, diag);
+                                return -ENOMEM;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT with packet_bytes = %d with total %d bytes%s\n",
+                                        packet_bytes, bytes_read, diag);
+                                return -ENOMEM;
+                        }
+                } else if (retval == -EILSEQ) {
+                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
+                                retval, packet_bytes, bytes_read, diag);
+                        return retval;
+                } else if (retval) {
+                        dev_err(&ftdi->udev->dev, "error = %d with packet_bytes = %d with total %d bytes%s\n",
+                                retval, packet_bytes, bytes_read, diag);
+                        return retval;
+                } else if (packet_bytes == 2) {
+                        unsigned char s0 = ftdi->bulk_in_buffer[0];
+                        unsigned char s1 = ftdi->bulk_in_buffer[1];
+                        empty_packets += 1;
+                        if (s0 == 0x31 && s1 == 0x60) {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        } else if (s0 == 0x31 && s1 == 0x00) {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        } else {
+                                if (retry_on_empty-- > 0) {
+                                        goto more;
+                                } else
+                                        return 0;
+                        }
+                } else if (packet_bytes == 1) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return 0;
+                } else {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else
+                                return 0;
+                }
+        }
+more:{
+                goto read;
+        }
+have:if (ftdi->bulk_in_left > 0) {
+                u8 c = ftdi->bulk_in_buffer[++ftdi->bulk_in_last];
+                bytes_read += 1;
+                ftdi->bulk_in_left -= 1;
+                if (ftdi->received == 0 && c == 0xFF) {
+                        goto have;
+                } else
+                        *b++ = c;
+                if (++ftdi->received < ftdi->expected) {
+                        goto have;
+                } else if (ftdi->ed_found) {
+                        int ed_number = (ftdi->response[0] >> 5) & 0x03;
+                        u16 ed_length = (ftdi->response[2] << 8) |
+                                ftdi->response[1];
+                        struct u132_target *target = &ftdi->target[ed_number];
+                        int payload = (ed_length >> 0) & 0x07FF;
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = payload;
+                        u8 *c = 4 + ftdi->response;
+                        int s = (sizeof(diag) - 1) / 3;
+                        diag[0] = 0;
+                        while (s-- > 0 && m-- > 0) {
+                                if (s > 0 || m == 0) {
+                                        d += sprintf(d, " %02X", *c++);
+                                } else
+                                        d += sprintf(d, " ..");
+                        }
+                        ftdi_elan_do_callback(ftdi, target, 4 + ftdi->response,
+                                              payload);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        b = ftdi->response;
+                        goto have;
+                } else if (ftdi->expected == 8) {
+                        u8 buscmd;
+                        int respond_head = ftdi->respond_head++;
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & respond_head];
+                        u32 data = ftdi->response[7];
+                        data <<= 8;
+                        data |= ftdi->response[6];
+                        data <<= 8;
+                        data |= ftdi->response[5];
+                        data <<= 8;
+                        data |= ftdi->response[4];
+                        *respond->value = data;
+                        *respond->result = 0;
+                        complete(&respond->wait_completion);
+                        ftdi->received = 0;
+                        ftdi->expected = 4;
+                        ftdi->ed_found = 0;
+                        b = ftdi->response;
+                        buscmd = (ftdi->response[0] >> 0) & 0x0F;
+                        if (buscmd == 0x00) {
+                        } else if (buscmd == 0x02) {
+                        } else if (buscmd == 0x06) {
+                        } else if (buscmd == 0x0A) {
+                        } else
+                                dev_err(&ftdi->udev->dev, "Uxxx unknown(%0X) value = %08X\n",
+                                        buscmd, data);
+                        goto have;
+                } else {
+                        if ((ftdi->response[0] & 0x80) == 0x00) {
+                                ftdi->expected = 8;
+                                goto have;
+                        } else {
+                                int ed_number = (ftdi->response[0] >> 5) & 0x03;
+                                int ed_type = (ftdi->response[0] >> 0) & 0x03;
+                                u16 ed_length = (ftdi->response[2] << 8) |
+                                        ftdi->response[1];
+                                struct u132_target *target = &ftdi->target[
+                                        ed_number];
+                                target->halted = (ftdi->response[0] >> 3) &
+                                        0x01;
+                                target->skipped = (ftdi->response[0] >> 2) &
+                                        0x01;
+                                target->toggle_bits = (ftdi->response[3] >> 6)
+                                        & 0x03;
+                                target->error_count = (ftdi->response[3] >> 4)
+                                        & 0x03;
+                                target->condition_code = (ftdi->response[
+                                                                  3] >> 0) & 0x0F;
+                                if ((ftdi->response[0] & 0x10) == 0x00) {
+                                        b = have_ed_set_response(ftdi, target,
+                                                                 ed_length, ed_number, ed_type,
+                                                                 b);
+                                        goto have;
+                                } else {
+                                        b = have_ed_get_response(ftdi, target,
+                                                                 ed_length, ed_number, ed_type,
+                                                                 b);
+                                        goto have;
+                                }
+                        }
+                }
+        } else
+                goto more;
 }
 
 
 /*
-* create a urb, and a buffer for it, and copy the data to the urb
-*
-*/
+ * create a urb, and a buffer for it, and copy the data to the urb
+ *
+ */
 static ssize_t ftdi_elan_write(struct file *file,
                                const char __user *user_buffer, size_t count,
                                loff_t *ppos)
 {
-        int retval = 0;
-        struct urb *urb;
-        char *buf;
-        struct usb_ftdi *ftdi = file->private_data;
-
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        }
-        if (count == 0) {
-                goto exit;
-        }
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                retval = -ENOMEM;
-                goto error_1;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
-                &urb->transfer_dma);
-        if (!buf) {
-                retval = -ENOMEM;
-                goto error_2;
-        }
-        if (copy_from_user(buf, user_buffer, count)) {
-                retval = -EFAULT;
-                goto error_3;
-        }
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, count,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed submitting write urb, error %"
-                        "d\n", retval);
-                goto error_3;
-        }
-        usb_free_urb(urb);
+        int retval = 0;
+        struct urb *urb;
+        char *buf;
+        struct usb_ftdi *ftdi = file->private_data;
+
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        }
+        if (count == 0) {
+                goto exit;
+        }
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                retval = -ENOMEM;
+                goto error_1;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL,
+                                 &urb->transfer_dma);
+        if (!buf) {
+                retval = -ENOMEM;
+                goto error_2;
+        }
+        if (copy_from_user(buf, user_buffer, count)) {
+                retval = -EFAULT;
+                goto error_3;
+        }
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, count,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev,
+                        "failed submitting write urb, error %d\n", retval);
+                goto error_3;
+        }
+        usb_free_urb(urb);
 
 exit:
-        return count;
+        return count;
 error_3:
         usb_free_coherent(ftdi->udev, count, buf, urb->transfer_dma);
 error_2:
@@ -1198,29 +1189,29 @@ error_1:
 }
 
 static const struct file_operations ftdi_elan_fops = {
-        .owner = THIS_MODULE,
-        .llseek = no_llseek,
-        .read = ftdi_elan_read,
-        .write = ftdi_elan_write,
-        .open = ftdi_elan_open,
-        .release = ftdi_elan_release,
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .read = ftdi_elan_read,
+        .write = ftdi_elan_write,
+        .open = ftdi_elan_open,
+        .release = ftdi_elan_release,
 };
 
 /*
-* usb class driver info in order to get a minor number from the usb core,
-* and to have the device registered with the driver core
-*/
+ * usb class driver info in order to get a minor number from the usb core,
+ * and to have the device registered with the driver core
+ */
 static struct usb_class_driver ftdi_elan_jtag_class = {
-        .name = "ftdi-%d-jtag",
-        .fops = &ftdi_elan_fops,
-        .minor_base = USB_FTDI_ELAN_MINOR_BASE,
+        .name = "ftdi-%d-jtag",
+        .fops = &ftdi_elan_fops,
+        .minor_base = USB_FTDI_ELAN_MINOR_BASE,
 };
 
 /*
-* the following definitions are for the
-* ELAN FPGA state machgine processor that
-* lies on the other side of the FTDI chip
-*/
+ * the following definitions are for the
+ * ELAN FPGA state machgine processor that
+ * lies on the other side of the FTDI chip
+ */
 #define cPCIu132rd 0x0
 #define cPCIu132wr 0x1
 #define cPCIiord 0x2
@@ -1251,1694 +1242,1663 @@ static struct usb_class_driver ftdi_elan_jtag_class = {
 #define cCCnotaccessed 0xF
 static int ftdi_elan_write_reg(struct usb_ftdi *ftdi, u32 data)
 {
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | cPCIu132wr;
-                        command->length = 0x04;
-                        command->address = 0x00;
-                        command->width = 0x00;
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | cPCIu132wr;
+                        command->length = 0x04;
+                        command->address = 0x00;
+                        command->width = 0x00;
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_write_config(struct usb_ftdi *ftdi, int config_offset,
-        u8 width, u32 data)
-{
-        u8 addressofs = config_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | (cPCIcfgwr & 0x0F);
-                        command->length = 0x04;
-                        command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  u8 width, u32 data)
+{
+        u8 addressofs = config_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | (cPCIcfgwr & 0x0F);
+                        command->length = 0x04;
+                        command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_write_pcimem(struct usb_ftdi *ftdi, int mem_offset,
-        u8 width, u32 data)
-{
-        u8 addressofs = mem_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x00 | (cPCImemwr & 0x0F);
-                        command->length = 0x04;
-                        command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 4;
-                        command->value = data;
-                        command->buffer = &command->value;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  u8 width, u32 data)
+{
+        u8 addressofs = mem_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x00 | (cPCImemwr & 0x0F);
+                        command->length = 0x04;
+                        command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 4;
+                        command->value = data;
+                        command->buffer = &command->value;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_write_pcimem(struct platform_device *pdev, int mem_offset,
-        u8 width, u32 data)
+                               u8 width, u32 data)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_write_pcimem(ftdi, mem_offset, width, data);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_write_pcimem);
 static int ftdi_elan_read_reg(struct usb_ftdi *ftdi, u32 *data)
 {
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | cPCIu132rd;
-                        command->length = 0x04;
-                        respond->address = command->address = cU132cmd_status;
-                        command->width = 0x00;
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | cPCIu132rd;
+                        command->length = 0x04;
+                        respond->address = command->address = cU132cmd_status;
+                        command->width = 0x00;
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_read_config(struct usb_ftdi *ftdi, int config_offset,
-        u8 width, u32 *data)
-{
-        u8 addressofs = config_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | (cPCIcfgrd &
-                                0x0F);
-                        command->length = 0x04;
-                        respond->address = command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 u8 width, u32 *data)
+{
+        u8 addressofs = config_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | (cPCIcfgrd &
+                                                                    0x0F);
+                        command->length = 0x04;
+                        respond->address = command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 static int ftdi_elan_read_pcimem(struct usb_ftdi *ftdi, int mem_offset,
-        u8 width, u32 *data)
-{
-        u8 addressofs = mem_offset / 4;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                int respond_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                respond_size = ftdi->respond_next - ftdi->respond_head;
-                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
-                        {
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        struct u132_respond *respond = &ftdi->respond[
-                                RESPOND_MASK & ftdi->respond_next];
-                        int result = -ENODEV;
-                        respond->result = &result;
-                        respond->header = command->header = 0x00 | (cPCImemrd &
-                                0x0F);
-                        command->length = 0x04;
-                        respond->address = command->address = addressofs;
-                        command->width = 0x00 | (width & 0x0F);
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        respond->value = data;
-                        init_completion(&respond->wait_completion);
-                        ftdi->command_next += 1;
-                        ftdi->respond_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        wait_for_completion(&respond->wait_completion);
-                        return result;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 u8 width, u32 *data)
+{
+        u8 addressofs = mem_offset / 4;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                int respond_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                respond_size = ftdi->respond_next - ftdi->respond_head;
+                if (command_size < COMMAND_SIZE && respond_size < RESPOND_SIZE)
+                {
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        struct u132_respond *respond = &ftdi->respond[
+                                RESPOND_MASK & ftdi->respond_next];
+                        int result = -ENODEV;
+                        respond->result = &result;
+                        respond->header = command->header = 0x00 | (cPCImemrd &
+                                                                    0x0F);
+                        command->length = 0x04;
+                        respond->address = command->address = addressofs;
+                        command->width = 0x00 | (width & 0x0F);
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        respond->value = data;
+                        init_completion(&respond->wait_completion);
+                        ftdi->command_next += 1;
+                        ftdi->respond_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        wait_for_completion(&respond->wait_completion);
+                        return result;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_read_pcimem(struct platform_device *pdev, int mem_offset,
-        u8 width, u32 *data)
+                              u8 width, u32 *data)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else
-                return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else
+                return ftdi_elan_read_pcimem(ftdi, mem_offset, width, data);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_read_pcimem);
 static int ftdi_elan_edset_setup(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x80 | (ed << 5);
-                        command->length = 0x8007;
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 8;
-                        command->value = 0;
-                        command->buffer = urb->setup_packet;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x80 | (ed << 5);
+                        command->length = 0x8007;
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 8;
+                        command->value = 0;
+                        command->buffer = urb->setup_packet;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_setup(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_setup(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_setup);
 static int ftdi_elan_edset_input(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        u32 remaining_length = urb->transfer_buffer_length -
-                                urb->actual_length;
-                        command->header = 0x82 | (ed << 5);
-                        if (remaining_length == 0) {
-                                command->length = 0x0000;
-                        } else if (remaining_length > 1024) {
-                                command->length = 0x8000 | 1023;
-                        } else
-                                command->length = 0x8000 | (remaining_length -
-                                        1);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        u32 remaining_length = urb->transfer_buffer_length -
+                                urb->actual_length;
+                        command->header = 0x82 | (ed << 5);
+                        if (remaining_length == 0) {
+                                command->length = 0x0000;
+                        } else if (remaining_length > 1024) {
+                                command->length = 0x8000 | 1023;
+                        } else
+                                command->length = 0x8000 | (remaining_length -
+                                                            1);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_input(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_input(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_input);
 static int ftdi_elan_edset_empty(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x81 | (ed << 5);
-                        command->length = 0x0000;
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                 void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                 void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                   int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                   int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x81 | (ed << 5);
+                        command->length = 0x0000;
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_empty(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                              void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                              void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_empty(ftdi, ed_number, endp, urb, address,
+                                     ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_empty);
 static int ftdi_elan_edset_output(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        u8 *b;
-                        u16 urb_size;
-                        int i = 0;
-                        char data[30 *3 + 4];
-                        char *d = data;
-                        int m = (sizeof(data) - 1) / 3;
-                        int l = 0;
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x81 | (ed << 5);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = min_t(u32, 1024,
-                                urb->transfer_buffer_length -
-                                urb->actual_length);
-                        command->value = 0;
-                        command->buffer = urb->transfer_buffer +
-                                urb->actual_length;
-                        command->length = 0x8000 | (command->follows - 1);
-                        b = command->buffer;
-                        urb_size = command->follows;
-                        data[0] = 0;
-                        while (urb_size-- > 0) {
-                                if (i > m) {
-                                } else if (i++ < m) {
-                                        int w = sprintf(d, " %02X", *b++);
-                                        d += w;
-                                        l += w;
-                                } else
-                                        d += sprintf(d, " ..");
-                        }
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                  void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                    int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                    int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        u8 *b;
+                        u16 urb_size;
+                        int i = 0;
+                        char data[30 *3 + 4];
+                        char *d = data;
+                        int m = (sizeof(data) - 1) / 3;
+                        int l = 0;
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x81 | (ed << 5);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = min_t(u32, 1024,
+                                                 urb->transfer_buffer_length -
+                                                 urb->actual_length);
+                        command->value = 0;
+                        command->buffer = urb->transfer_buffer +
+                                urb->actual_length;
+                        command->length = 0x8000 | (command->follows - 1);
+                        b = command->buffer;
+                        urb_size = command->follows;
+                        data[0] = 0;
+                        while (urb_size-- > 0) {
+                                if (i > m) {
+                                } else if (i++ < m) {
+                                        int w = sprintf(d, " %02X", *b++);
+                                        d += w;
+                                        l += w;
+                                } else
+                                        d += sprintf(d, " ..");
+                        }
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_output(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                               void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                               void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                 int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                 int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_output(ftdi, ed_number, endp, urb, address,
+                                      ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_output);
 static int ftdi_elan_edset_single(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
-{
-        u8 ed = ed_number - 1;
-      wait:if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                int command_size;
-                mutex_lock(&ftdi->u132_lock);
-                command_size = ftdi->command_next - ftdi->command_head;
-                if (command_size < COMMAND_SIZE) {
-                        u32 remaining_length = urb->transfer_buffer_length -
-                                urb->actual_length;
-                        struct u132_target *target = &ftdi->target[ed];
-                        struct u132_command *command = &ftdi->command[
-                                COMMAND_MASK & ftdi->command_next];
-                        command->header = 0x83 | (ed << 5);
-                        if (remaining_length == 0) {
-                                command->length = 0x0000;
-                        } else if (remaining_length > 1024) {
-                                command->length = 0x8000 | 1023;
-                        } else
-                                command->length = 0x8000 | (remaining_length -
-                                        1);
-                        command->address = (toggle_bits << 6) | (ep_number << 2)
-                                | (address << 0);
-                        command->width = usb_maxpacket(urb->dev, urb->pipe,
-                                usb_pipeout(urb->pipe));
-                        command->follows = 0;
-                        command->value = 0;
-                        command->buffer = NULL;
-                        target->callback = callback;
-                        target->endp = endp;
-                        target->urb = urb;
-                        target->active = 1;
-                        ftdi->command_next += 1;
-                        ftdi_elan_kick_command_queue(ftdi);
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        mutex_unlock(&ftdi->u132_lock);
-                        msleep(100);
-                        goto wait;
-                }
-        }
+                                  void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                                  void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                    int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                    int halted, int skipped, int actual, int non_null))
+{
+        u8 ed = ed_number - 1;
+wait:if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                int command_size;
+                mutex_lock(&ftdi->u132_lock);
+                command_size = ftdi->command_next - ftdi->command_head;
+                if (command_size < COMMAND_SIZE) {
+                        u32 remaining_length = urb->transfer_buffer_length -
+                                urb->actual_length;
+                        struct u132_target *target = &ftdi->target[ed];
+                        struct u132_command *command = &ftdi->command[
+                                COMMAND_MASK & ftdi->command_next];
+                        command->header = 0x83 | (ed << 5);
+                        if (remaining_length == 0) {
+                                command->length = 0x0000;
+                        } else if (remaining_length > 1024) {
+                                command->length = 0x8000 | 1023;
+                        } else
+                                command->length = 0x8000 | (remaining_length -
+                                                            1);
+                        command->address = (toggle_bits << 6) | (ep_number << 2)
+                                | (address << 0);
+                        command->width = usb_maxpacket(urb->dev, urb->pipe,
+                                                       usb_pipeout(urb->pipe));
+                        command->follows = 0;
+                        command->value = 0;
+                        command->buffer = NULL;
+                        target->callback = callback;
+                        target->endp = endp;
+                        target->urb = urb;
+                        target->active = 1;
+                        ftdi->command_next += 1;
+                        ftdi_elan_kick_command_queue(ftdi);
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        mutex_unlock(&ftdi->u132_lock);
+                        msleep(100);
+                        goto wait;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_single(struct platform_device *pdev, u8 ed_number,
-        void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
-        void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
-        int toggle_bits, int error_count, int condition_code, int repeat_number,
-         int halted, int skipped, int actual, int non_null))
+                               void *endp, struct urb *urb, u8 address, u8 ep_number, u8 toggle_bits,
+                               void (*callback) (void *endp, struct urb *urb, u8 *buf, int len,
+                                                 int toggle_bits, int error_count, int condition_code, int repeat_number,
+                                                 int halted, int skipped, int actual, int non_null))
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
-                ep_number, toggle_bits, callback);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_single(ftdi, ed_number, endp, urb, address,
+                                      ep_number, toggle_bits, callback);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_single);
 static int ftdi_elan_edset_flush(struct usb_ftdi *ftdi, u8 ed_number,
-        void *endp)
-{
-        u8 ed = ed_number - 1;
-        if (ftdi->disconnected > 0) {
-                return -ENODEV;
-        } else if (ftdi->initialized == 0) {
-                return -ENODEV;
-        } else {
-                struct u132_target *target = &ftdi->target[ed];
-                mutex_lock(&ftdi->u132_lock);
-                if (target->abandoning > 0) {
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                } else {
-                        target->abandoning = 1;
-                      wait_1:if (target->active == 1) {
-                                int command_size = ftdi->command_next -
-                                        ftdi->command_head;
-                                if (command_size < COMMAND_SIZE) {
-                                        struct u132_command *command =
-                                                &ftdi->command[COMMAND_MASK &
-                                                ftdi->command_next];
-                                        command->header = 0x80 | (ed << 5) |
-                                                0x4;
-                                        command->length = 0x00;
-                                        command->address = 0x00;
-                                        command->width = 0x00;
-                                        command->follows = 0;
-                                        command->value = 0;
-                                        command->buffer = &command->value;
-                                        ftdi->command_next += 1;
-                                        ftdi_elan_kick_command_queue(ftdi);
-                                } else {
-                                        mutex_unlock(&ftdi->u132_lock);
-                                        msleep(100);
-                                        mutex_lock(&ftdi->u132_lock);
-                                        goto wait_1;
-                                }
-                        }
-                        mutex_unlock(&ftdi->u132_lock);
-                        return 0;
-                }
-        }
+                                 void *endp)
+{
+        u8 ed = ed_number - 1;
+        if (ftdi->disconnected > 0) {
+                return -ENODEV;
+        } else if (ftdi->initialized == 0) {
+                return -ENODEV;
+        } else {
+                struct u132_target *target = &ftdi->target[ed];
+                mutex_lock(&ftdi->u132_lock);
+                if (target->abandoning > 0) {
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                } else {
+                        target->abandoning = 1;
+                wait_1:if (target->active == 1) {
+                                int command_size = ftdi->command_next -
+                                        ftdi->command_head;
+                                if (command_size < COMMAND_SIZE) {
+                                        struct u132_command *command =
+                                                &ftdi->command[COMMAND_MASK &
+                                                               ftdi->command_next];
+                                        command->header = 0x80 | (ed << 5) |
+                                                0x4;
+                                        command->length = 0x00;
+                                        command->address = 0x00;
+                                        command->width = 0x00;
+                                        command->follows = 0;
+                                        command->value = 0;
+                                        command->buffer = &command->value;
+                                        ftdi->command_next += 1;
+                                        ftdi_elan_kick_command_queue(ftdi);
+                                } else {
+                                        mutex_unlock(&ftdi->u132_lock);
+                                        msleep(100);
+                                        mutex_lock(&ftdi->u132_lock);
+                                        goto wait_1;
+                                }
+                        }
+                        mutex_unlock(&ftdi->u132_lock);
+                        return 0;
+                }
+        }
 }
 
 int usb_ftdi_elan_edset_flush(struct platform_device *pdev, u8 ed_number,
-        void *endp)
+                              void *endp)
 {
-        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
-        return ftdi_elan_edset_flush(ftdi, ed_number, endp);
+        struct usb_ftdi *ftdi = platform_device_to_usb_ftdi(pdev);
+        return ftdi_elan_edset_flush(ftdi, ed_number, endp);
 }
 
 
 EXPORT_SYMBOL_GPL(usb_ftdi_elan_edset_flush);
 static int ftdi_elan_flush_input_fifo(struct usb_ftdi *ftdi)
 {
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        int retry_on_status = 20;
-      more:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 100);
-                if (packet_bytes > 2) {
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = (sizeof(diag) - 1) / 3;
-                        char *b = ftdi->bulk_in_buffer;
-                        int bytes_read = 0;
-                        diag[0] = 0;
-                        while (packet_bytes-- > 0) {
-                                char c = *b++;
-                                if (bytes_read < m) {
-                                        d += sprintf(d, " %02X",
-                                                0x000000FF & c);
-                                } else if (bytes_read > m) {
-                                } else
-                                        d += sprintf(d, " ..");
-                                bytes_read += 1;
-                                continue;
-                        }
-                        goto more;
-                } else if (packet_bytes > 1) {
-                        char s1 = ftdi->bulk_in_buffer[0];
-                        char s2 = ftdi->bulk_in_buffer[1];
-                        if (s1 == 0x31 && s2 == 0x60) {
-                                return 0;
-                        } else if (retry_on_status-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (packet_bytes > 0) {
-                        char b1 = ftdi->bulk_in_buffer[0];
-                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
-                                "TDI = %02X\n", b1);
-                        if (retry_on_status-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
-                                        "t reached\n");
-                                return -ENOMEM;
-                        }
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "empty packet retry l"
-                                        "imit reached\n");
-                                return -ENOMEM;
-                        }
-                } else {
-                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
-                        return retval;
-                }
-        }
-        return -1;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        int retry_on_status = 20;
+more:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 100);
+                if (packet_bytes > 2) {
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = (sizeof(diag) - 1) / 3;
+                        char *b = ftdi->bulk_in_buffer;
+                        int bytes_read = 0;
+                        diag[0] = 0;
+                        while (packet_bytes-- > 0) {
+                                char c = *b++;
+                                if (bytes_read < m) {
+                                        d += sprintf(d, " %02X",
+                                                     0x000000FF & c);
+                                } else if (bytes_read > m) {
+                                } else
+                                        d += sprintf(d, " ..");
+                                bytes_read += 1;
+                                continue;
+                        }
+                        goto more;
+                } else if (packet_bytes > 1) {
+                        char s1 = ftdi->bulk_in_buffer[0];
+                        char s2 = ftdi->bulk_in_buffer[1];
+                        if (s1 == 0x31 && s2 == 0x60) {
+                                return 0;
+                        } else if (retry_on_status-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (packet_bytes > 0) {
+                        char b1 = ftdi->bulk_in_buffer[0];
+                        dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n",
+                                b1);
+                        if (retry_on_status-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else {
+                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
+                        return retval;
+                }
+        }
+        return -1;
 }
 
 
 /*
-* send the long flush sequence
-*
-*/
+ * send the long flush sequence
+ *
+ */
 static int ftdi_elan_synchronize_flush(struct usb_ftdi *ftdi)
 {
-        int retval;
-        struct urb *urb;
-        char *buf;
-        int I = 257;
-        int i = 0;
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequ"
-                        "ence\n");
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer for flush seq"
-                        "uence\n");
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        while (I-- > 0)
-                buf[i++] = 0x55;
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, i,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
-                        "flush sequence\n");
-                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        usb_free_urb(urb);
-        return 0;
+        int retval;
+        struct urb *urb;
+        char *buf;
+        int I = 257;
+        int i = 0;
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not alloc a urb for flush sequence\n");
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer for flush sequence\n");
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        while (I-- > 0)
+                buf[i++] = 0x55;
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, i,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed to submit urb containing the flush sequence\n");
+                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        usb_free_urb(urb);
+        return 0;
 }
 
 
 /*
-* send the reset sequence
-*
-*/
+ * send the reset sequence
+ *
+ */
 static int ftdi_elan_synchronize_reset(struct usb_ftdi *ftdi)
 {
-        int retval;
-        struct urb *urb;
-        char *buf;
-        int I = 4;
-        int i = 0;
-        urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!urb) {
-                dev_err(&ftdi->udev->dev, "could not get a urb for the reset se"
-                        "quence\n");
-                return -ENOMEM;
-        }
-        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
-        if (!buf) {
-                dev_err(&ftdi->udev->dev, "could not get a buffer for the reset"
-                        " sequence\n");
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        buf[i++] = 0x55;
-        buf[i++] = 0xAA;
-        buf[i++] = 0x5A;
-        buf[i++] = 0xA5;
-        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
-                ftdi->bulk_out_endpointAddr), buf, i,
-                ftdi_elan_write_bulk_callback, ftdi);
-        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-        retval = usb_submit_urb(urb, GFP_KERNEL);
-        if (retval) {
-                dev_err(&ftdi->udev->dev, "failed to submit urb containing the "
-                        "reset sequence\n");
-                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
-                usb_free_urb(urb);
-                return -ENOMEM;
-        }
-        usb_free_urb(urb);
-        return 0;
+        int retval;
+        struct urb *urb;
+        char *buf;
+        int I = 4;
+        int i = 0;
+        urb = usb_alloc_urb(0, GFP_KERNEL);
+        if (!urb) {
+                dev_err(&ftdi->udev->dev, "could not get a urb for the reset sequence\n");
+                return -ENOMEM;
+        }
+        buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma);
+        if (!buf) {
+                dev_err(&ftdi->udev->dev, "could not get a buffer for the reset sequence\n");
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        buf[i++] = 0x55;
+        buf[i++] = 0xAA;
+        buf[i++] = 0x5A;
+        buf[i++] = 0xA5;
+        usb_fill_bulk_urb(urb, ftdi->udev, usb_sndbulkpipe(ftdi->udev,
+                                                           ftdi->bulk_out_endpointAddr), buf, i,
+                          ftdi_elan_write_bulk_callback, ftdi);
+        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+        retval = usb_submit_urb(urb, GFP_KERNEL);
+        if (retval) {
+                dev_err(&ftdi->udev->dev, "failed to submit urb containing the reset sequence\n");
+                usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma);
+                usb_free_urb(urb);
+                return -ENOMEM;
+        }
+        usb_free_urb(urb);
+        return 0;
 }
 
 static int ftdi_elan_synchronize(struct usb_ftdi *ftdi)
 {
-        int retval;
-        int long_stop = 10;
-        int retry_on_timeout = 5;
-        int retry_on_empty = 10;
-        int err_count = 0;
-        retval = ftdi_elan_flush_input_fifo(ftdi);
-        if (retval)
-                return retval;
-        ftdi->bulk_in_left = 0;
-        ftdi->bulk_in_last = -1;
-        while (long_stop-- > 0) {
-                int read_stop;
-                int read_stuck;
-                retval = ftdi_elan_synchronize_flush(ftdi);
-                if (retval)
-                        return retval;
-                retval = ftdi_elan_flush_input_fifo(ftdi);
-                if (retval)
-                        return retval;
-              reset:retval = ftdi_elan_synchronize_reset(ftdi);
-                if (retval)
-                        return retval;
-                read_stop = 100;
-                read_stuck = 10;
-              read:{
-                        int packet_bytes = 0;
-                        retval = usb_bulk_msg(ftdi->udev,
-                                usb_rcvbulkpipe(ftdi->udev,
-                                ftdi->bulk_in_endpointAddr),
-                                ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                                &packet_bytes, 500);
-                        if (packet_bytes > 2) {
-                                char diag[30 *3 + 4];
-                                char *d = diag;
-                                int m = (sizeof(diag) - 1) / 3;
-                                char *b = ftdi->bulk_in_buffer;
-                                int bytes_read = 0;
-                                unsigned char c = 0;
-                                diag[0] = 0;
-                                while (packet_bytes-- > 0) {
-                                        c = *b++;
-                                        if (bytes_read < m) {
-                                                d += sprintf(d, " %02X", c);
-                                        } else if (bytes_read > m) {
-                                        } else
-                                                d += sprintf(d, " ..");
-                                        bytes_read += 1;
-                                        continue;
-                                }
-                                if (c == 0x7E) {
-                                        return 0;
-                                } else {
-                                        if (c == 0x55) {
-                                                goto read;
-                                        } else if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                }
-                        } else if (packet_bytes > 1) {
-                                unsigned char s1 = ftdi->bulk_in_buffer[0];
-                                unsigned char s2 = ftdi->bulk_in_buffer[1];
-                                if (s1 == 0x31 && s2 == 0x00) {
-                                        if (read_stuck-- > 0) {
-                                                goto read;
-                                        } else
-                                                goto reset;
-                                } else if (s1 == 0x31 && s2 == 0x60) {
-                                        if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                } else {
-                                        if (read_stop-- > 0) {
-                                                goto read;
-                                        } else {
-                                                dev_err(&ftdi->udev->dev, "retr"
-                                                        "y limit reached\n");
-                                                continue;
-                                        }
-                                }
-                        } else if (packet_bytes > 0) {
-                                if (read_stop-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "retry limit "
-                                                "reached\n");
-                                        continue;
-                                }
-                        } else if (retval == -ETIMEDOUT) {
-                                if (retry_on_timeout-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "TIMED OUT re"
-                                                "try limit reached\n");
-                                        continue;
-                                }
-                        } else if (retval == 0) {
-                                if (retry_on_empty-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "empty packet"
-                                                " retry limit reached\n");
-                                        continue;
-                                }
-                        } else {
-                                err_count += 1;
-                                dev_err(&ftdi->udev->dev, "error = %d\n",
-                                        retval);
-                                if (read_stop-- > 0) {
-                                        goto read;
-                                } else {
-                                        dev_err(&ftdi->udev->dev, "retry limit "
-                                                "reached\n");
-                                        continue;
-                                }
-                        }
-                }
-        }
-        dev_err(&ftdi->udev->dev, "failed to synchronize\n");
-        return -EFAULT;
+        int retval;
+        int long_stop = 10;
+        int retry_on_timeout = 5;
+        int retry_on_empty = 10;
+        int err_count = 0;
+        retval = ftdi_elan_flush_input_fifo(ftdi);
+        if (retval)
+                return retval;
+        ftdi->bulk_in_left = 0;
+        ftdi->bulk_in_last = -1;
+        while (long_stop-- > 0) {
+                int read_stop;
+                int read_stuck;
+                retval = ftdi_elan_synchronize_flush(ftdi);
+                if (retval)
+                        return retval;
+                retval = ftdi_elan_flush_input_fifo(ftdi);
+                if (retval)
+                        return retval;
+        reset:retval = ftdi_elan_synchronize_reset(ftdi);
+                if (retval)
+                        return retval;
+                read_stop = 100;
+                read_stuck = 10;
+        read:{
+                        int packet_bytes = 0;
+                        retval = usb_bulk_msg(ftdi->udev,
+                                              usb_rcvbulkpipe(ftdi->udev,
+                                                              ftdi->bulk_in_endpointAddr),
+                                              ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                              &packet_bytes, 500);
+                        if (packet_bytes > 2) {
+                                char diag[30 *3 + 4];
+                                char *d = diag;
+                                int m = (sizeof(diag) - 1) / 3;
+                                char *b = ftdi->bulk_in_buffer;
+                                int bytes_read = 0;
+                                unsigned char c = 0;
+                                diag[0] = 0;
+                                while (packet_bytes-- > 0) {
+                                        c = *b++;
+                                        if (bytes_read < m) {
+                                                d += sprintf(d, " %02X", c);
+                                        } else if (bytes_read > m) {
+                                        } else
+                                                d += sprintf(d, " ..");
+                                        bytes_read += 1;
+                                        continue;
+                                }
+                                if (c == 0x7E) {
+                                        return 0;
+                                } else {
+                                        if (c == 0x55) {
+                                                goto read;
+                                        } else if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                }
+                        } else if (packet_bytes > 1) {
+                                unsigned char s1 = ftdi->bulk_in_buffer[0];
+                                unsigned char s2 = ftdi->bulk_in_buffer[1];
+                                if (s1 == 0x31 && s2 == 0x00) {
+                                        if (read_stuck-- > 0) {
+                                                goto read;
+                                        } else
+                                                goto reset;
+                                } else if (s1 == 0x31 && s2 == 0x60) {
+                                        if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                } else {
+                                        if (read_stop-- > 0) {
+                                                goto read;
+                                        } else {
+                                                dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                                continue;
+                                        }
+                                }
+                        } else if (packet_bytes > 0) {
+                                if (read_stop-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                        continue;
+                                }
+                        } else if (retval == -ETIMEDOUT) {
+                                if (retry_on_timeout-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                        continue;
+                                }
+                        } else if (retval == 0) {
+                                if (retry_on_empty-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                        continue;
+                                }
+                        } else {
+                                err_count += 1;
+                                dev_err(&ftdi->udev->dev, "error = %d\n",
+                                        retval);
+                                if (read_stop-- > 0) {
+                                        goto read;
+                                } else {
+                                        dev_err(&ftdi->udev->dev, "retry limit reached\n");
+                                        continue;
+                                }
+                        }
+                }
+        }
+        dev_err(&ftdi->udev->dev, "failed to synchronize\n");
+        return -EFAULT;
 }
 
 static int ftdi_elan_stuck_waiting(struct usb_ftdi *ftdi)
 {
-        int retry_on_empty = 10;
-        int retry_on_timeout = 5;
-        int retry_on_status = 50;
-      more:{
-                int packet_bytes = 0;
-                int retval = usb_bulk_msg(ftdi->udev,
-                        usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
-                         ftdi->bulk_in_buffer, ftdi->bulk_in_size,
-                        &packet_bytes, 1000);
-                if (packet_bytes > 2) {
-                        char diag[30 *3 + 4];
-                        char *d = diag;
-                        int m = (sizeof(diag) - 1) / 3;
-                        char *b = ftdi->bulk_in_buffer;
-                        int bytes_read = 0;
-                        diag[0] = 0;
-                        while (packet_bytes-- > 0) {
-                                char c = *b++;
-                                if (bytes_read < m) {
-                                        d += sprintf(d, " %02X",
-                                                0x000000FF & c);
-                                } else if (bytes_read > m) {
-                                } else
-                                        d += sprintf(d, " ..");
-                                bytes_read += 1;
-                                continue;
-                        }
-                        goto more;
-                } else if (packet_bytes > 1) {
-                        char s1 = ftdi->bulk_in_buffer[0];
-                        char s2 = ftdi->bulk_in_buffer[1];
-                        if (s1 == 0x31 && s2 == 0x60) {
-                                return 0;
-                        } else if (retry_on_status-- > 0) {
-                                msleep(5);
-                                goto more;
-                        } else
-                                return -EFAULT;
-                } else if (packet_bytes > 0) {
-                        char b1 = ftdi->bulk_in_buffer[0];
-                        dev_err(&ftdi->udev->dev, "only one byte flushed from F"
-                                "TDI = %02X\n", b1);
-                        if (retry_on_status-- > 0) {
-                                msleep(5);
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry l"
-                                        "imit reached\n");
-                                return -EFAULT;
-                        }
-                } else if (retval == -ETIMEDOUT) {
-                        if (retry_on_timeout-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limi"
-                                        "t reached\n");
-                                return -ENOMEM;
-                        }
-                } else if (retval == 0) {
-                        if (retry_on_empty-- > 0) {
-                                goto more;
-                        } else {
-                                dev_err(&ftdi->udev->dev, "empty packet retry l"
-                                        "imit reached\n");
-                                return -ENOMEM;
-                        }
-                } else {
-                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
-                        return -ENOMEM;
-                }
-        }
-        return -1;
+        int retry_on_empty = 10;
+        int retry_on_timeout = 5;
+        int retry_on_status = 50;
+more:{
+                int packet_bytes = 0;
+                int retval = usb_bulk_msg(ftdi->udev,
+                                          usb_rcvbulkpipe(ftdi->udev, ftdi->bulk_in_endpointAddr),
+                                          ftdi->bulk_in_buffer, ftdi->bulk_in_size,
+                                          &packet_bytes, 1000);
+                if (packet_bytes > 2) {
+                        char diag[30 *3 + 4];
+                        char *d = diag;
+                        int m = (sizeof(diag) - 1) / 3;
+                        char *b = ftdi->bulk_in_buffer;
+                        int bytes_read = 0;
+                        diag[0] = 0;
+                        while (packet_bytes-- > 0) {
+                                char c = *b++;
+                                if (bytes_read < m) {
+                                        d += sprintf(d, " %02X",
+                                                     0x000000FF & c);
+                                } else if (bytes_read > m) {
+                                } else
+                                        d += sprintf(d, " ..");
+                                bytes_read += 1;
+                                continue;
+                        }
+                        goto more;
+                } else if (packet_bytes > 1) {
+                        char s1 = ftdi->bulk_in_buffer[0];
+                        char s2 = ftdi->bulk_in_buffer[1];
+                        if (s1 == 0x31 && s2 == 0x60) {
+                                return 0;
+                        } else if (retry_on_status-- > 0) {
+                                msleep(5);
+                                goto more;
+                        } else
+                                return -EFAULT;
+                } else if (packet_bytes > 0) {
+                        char b1 = ftdi->bulk_in_buffer[0];
+                        dev_err(&ftdi->udev->dev, "only one byte flushed from FTDI = %02X\n", b1);
+                        if (retry_on_status-- > 0) {
+                                msleep(5);
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "STATUS ERROR retry limit reached\n");
+                                return -EFAULT;
+                        }
+                } else if (retval == -ETIMEDOUT) {
+                        if (retry_on_timeout-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "TIMED OUT retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else if (retval == 0) {
+                        if (retry_on_empty-- > 0) {
+                                goto more;
+                        } else {
+                                dev_err(&ftdi->udev->dev, "empty packet retry limit reached\n");
+                                return -ENOMEM;
+                        }
+                } else {
+                        dev_err(&ftdi->udev->dev, "error = %d\n", retval);
+                        return -ENOMEM;
+                }
+        }
+        return -1;
 }
 
 static int ftdi_elan_checkingPCI(struct usb_ftdi *ftdi)
 {
-        int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        if (ftdi->controlreg & 0x00400000) {
-                if (ftdi->card_ejected) {
-                } else {
-                        ftdi->card_ejected = 1;
-                        dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = "
-                                "%08X\n", ftdi->controlreg);
-                }
-                return -ENODEV;
-        } else {
-                u8 fn = ftdi->function - 1;
-                int activePCIfn = fn << 8;
-                u32 pcidata;
-                u32 pciVID;
-                u32 pciPID;
-                int reg = 0;
-                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                        &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                pciVID = pcidata & 0xFFFF;
-                pciPID = (pcidata >> 16) & 0xFFFF;
-                if (pciVID == ftdi->platform_data.vendor && pciPID ==
-                        ftdi->platform_data.device) {
-                        return 0;
-                } else {
-                        dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X devi"
-                                "ce=%04X pciPID=%04X\n",
-                                ftdi->platform_data.vendor, pciVID,
-                                ftdi->platform_data.device, pciPID);
-                        return -ENODEV;
-                }
-        }
+        int UxxxStatus = ftdi_elan_read_reg(ftdi, &ftdi->controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        if (ftdi->controlreg & 0x00400000) {
+                if (ftdi->card_ejected) {
+                } else {
+                        ftdi->card_ejected = 1;
+                        dev_err(&ftdi->udev->dev, "CARD EJECTED - controlreg = %08X\n",
+                                ftdi->controlreg);
+                }
+                return -ENODEV;
+        } else {
+                u8 fn = ftdi->function - 1;
+                int activePCIfn = fn << 8;
+                u32 pcidata;
+                u32 pciVID;
+                u32 pciPID;
+                int reg = 0;
+                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                                   &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                pciVID = pcidata & 0xFFFF;
+                pciPID = (pcidata >> 16) & 0xFFFF;
+                if (pciVID == ftdi->platform_data.vendor && pciPID ==
+                    ftdi->platform_data.device) {
+                        return 0;
+                } else {
+                        dev_err(&ftdi->udev->dev, "vendor=%04X pciVID=%04X device=%04X pciPID=%04X\n",
+                                ftdi->platform_data.vendor, pciVID,
+                                ftdi->platform_data.device, pciPID);
+                        return -ENODEV;
+                }
+        }
 }
 
 
 #define ftdi_read_pcimem(ftdi, member, data) ftdi_elan_read_pcimem(ftdi, \
-        offsetof(struct ohci_regs, member), 0, data);
+                                                                   offsetof(struct ohci_regs, member), 0, data);
 #define ftdi_write_pcimem(ftdi, member, data) ftdi_elan_write_pcimem(ftdi, \
-        offsetof(struct ohci_regs, member), 0, data);
+                                                                     offsetof(struct ohci_regs, member), 0, data);
 
 #define OHCI_CONTROL_INIT OHCI_CTRL_CBSR
-#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD | \
-        OHCI_INTR_WDH)
+#define OHCI_INTR_INIT (OHCI_INTR_MIE | OHCI_INTR_UE | OHCI_INTR_RD |   \
+                        OHCI_INTR_WDH)
 static int ftdi_elan_check_controller(struct usb_ftdi *ftdi, int quirk)
 {
-        int devices = 0;
-        int retval;
-        u32 hc_control;
-        int num_ports;
-        u32 control;
-        u32 rh_a = -1;
-        u32 status;
-        u32 fminterval;
-        u32 hc_fminterval;
-        u32 periodicstart;
-        u32 cmdstatus;
-        u32 roothub_a;
-        int mask = OHCI_INTR_INIT;
-        int sleep_time = 0;
-        int reset_timeout = 30;        /* ... allow extra time */
-        int temp;
-        retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
-        if (retval)
-                return retval;
-        num_ports = rh_a & RH_A_NDP;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
-        if (retval)
-                return retval;
-        hc_fminterval &= 0x3fff;
-        if (hc_fminterval != FI) {
-        }
-        hc_fminterval |= FSMP(hc_fminterval) << 16;
-        retval = ftdi_read_pcimem(ftdi, control, &hc_control);
-        if (retval)
-                return retval;
-        switch (hc_control & OHCI_CTRL_HCFS) {
-        case OHCI_USB_OPER:
-                sleep_time = 0;
-                break;
-        case OHCI_USB_SUSPEND:
-        case OHCI_USB_RESUME:
-                hc_control &= OHCI_CTRL_RWC;
-                hc_control |= OHCI_USB_RESUME;
-                sleep_time = 10;
-                break;
-        default:
-                hc_control &= OHCI_CTRL_RWC;
-                hc_control |= OHCI_USB_RESET;
-                sleep_time = 50;
-                break;
-        }
-        retval = ftdi_write_pcimem(ftdi, control, hc_control);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        msleep(sleep_time);
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
-        if (retval)
-                return retval;
-        if (!(roothub_a & RH_A_NPS)) {        /* power down each port */
-                for (temp = 0; temp < num_ports; temp++) {
-                        retval = ftdi_write_pcimem(ftdi,
-                                roothub.portstatus[temp], RH_PS_LSDA);
-                        if (retval)
-                                return retval;
-                }
-        }
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-      retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
-        if (retval)
-                return retval;
-      extra:{
-                retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
-                if (retval)
-                        return retval;
-                if (0 != (status & OHCI_HCR)) {
-                        if (--reset_timeout == 0) {
-                                dev_err(&ftdi->udev->dev, "USB HC reset timed o"
-                                        "ut!\n");
-                                return -ENODEV;
-                        } else {
-                                msleep(5);
-                                goto extra;
-                        }
-                }
-        }
-        if (quirk & OHCI_QUIRK_INITRESET) {
-                retval = ftdi_write_pcimem(ftdi, control, hc_control);
-                if (retval)
-                        return retval;
-                retval = ftdi_read_pcimem(ftdi, control, &control);
-                if (retval)
-                        return retval;
-        }
-        retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, fminterval,
-                ((fminterval & FIT) ^ FIT) | hc_fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, periodicstart,
-                ((9 *hc_fminterval) / 10) & 0x3fff);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
-        if (retval)
-                return retval;
-        if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
-                if (!(quirk & OHCI_QUIRK_INITRESET)) {
-                        quirk |= OHCI_QUIRK_INITRESET;
-                        goto retry;
-                } else
-                        dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
-                                fminterval, periodicstart);
-        }                        /* start controller operations */
-        hc_control &= OHCI_CTRL_RWC;
-        hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
-        retval = ftdi_write_pcimem(ftdi, control, hc_control);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, intrdisable,
-                OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
-                OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
-                OHCI_INTR_SO);
-        if (retval)
-                return retval;        /* handle root hub init quirks ... */
-        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
-        if (retval)
-                return retval;
-        roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
-        if (quirk & OHCI_QUIRK_SUPERIO) {
-                roothub_a |= RH_A_NOCP;
-                roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
-                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
-                if (retval)
-                        return retval;
-        } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) {
-                roothub_a |= RH_A_NPS;
-                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
-                if (retval)
-                        return retval;
-        }
-        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
-        if (retval)
-                return retval;
-        retval = ftdi_write_pcimem(ftdi, roothub.b,
-                (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
-        if (retval)
-                return retval;
-        retval = ftdi_read_pcimem(ftdi, control, &control);
-        if (retval)
-                return retval;
-        mdelay((roothub_a >> 23) & 0x1fe);
-        for (temp = 0; temp < num_ports; temp++) {
-                u32 portstatus;
-                retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
-                        &portstatus);
-                if (retval)
-                        return retval;
-                if (1 & portstatus)
-                        devices += 1;
-        }
-        return devices;
+        int devices = 0;
+        int retval;
+        u32 hc_control;
+        int num_ports;
+        u32 control;
+        u32 rh_a = -1;
+        u32 status;
+        u32 fminterval;
+        u32 hc_fminterval;
+        u32 periodicstart;
+        u32 cmdstatus;
+        u32 roothub_a;
+        int mask = OHCI_INTR_INIT;
+        int sleep_time = 0;
+        int reset_timeout = 30;        /* ... allow extra time */
+        int temp;
+        retval = ftdi_write_pcimem(ftdi, intrdisable, OHCI_INTR_MIE);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &rh_a);
+        if (retval)
+                return retval;
+        num_ports = rh_a & RH_A_NDP;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &hc_fminterval);
+        if (retval)
+                return retval;
+        hc_fminterval &= 0x3fff;
+        if (hc_fminterval != FI) {
+        }
+        hc_fminterval |= FSMP(hc_fminterval) << 16;
+        retval = ftdi_read_pcimem(ftdi, control, &hc_control);
+        if (retval)
+                return retval;
+        switch (hc_control & OHCI_CTRL_HCFS) {
+        case OHCI_USB_OPER:
+                sleep_time = 0;
+                break;
+        case OHCI_USB_SUSPEND:
+        case OHCI_USB_RESUME:
+                hc_control &= OHCI_CTRL_RWC;
+                hc_control |= OHCI_USB_RESUME;
+                sleep_time = 10;
+                break;
+        default:
+                hc_control &= OHCI_CTRL_RWC;
+                hc_control |= OHCI_USB_RESET;
+                sleep_time = 50;
+                break;
+        }
+        retval = ftdi_write_pcimem(ftdi, control, hc_control);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        msleep(sleep_time);
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
+        if (retval)
+                return retval;
+        if (!(roothub_a & RH_A_NPS)) {        /* power down each port */
+                for (temp = 0; temp < num_ports; temp++) {
+                        retval = ftdi_write_pcimem(ftdi,
+                                                   roothub.portstatus[temp], RH_PS_LSDA);
+                        if (retval)
+                                return retval;
+                }
+        }
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+retry:retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_HCR);
+        if (retval)
+                return retval;
+extra:{
+                retval = ftdi_read_pcimem(ftdi, cmdstatus, &status);
+                if (retval)
+                        return retval;
+                if (0 != (status & OHCI_HCR)) {
+                        if (--reset_timeout == 0) {
+                                dev_err(&ftdi->udev->dev, "USB HC reset timed out!\n");
+                                return -ENODEV;
+                        } else {
+                                msleep(5);
+                                goto extra;
+                        }
+                }
+        }
+        if (quirk & OHCI_QUIRK_INITRESET) {
+                retval = ftdi_write_pcimem(ftdi, control, hc_control);
+                if (retval)
+                        return retval;
+                retval = ftdi_read_pcimem(ftdi, control, &control);
+                if (retval)
+                        return retval;
+        }
+        retval = ftdi_write_pcimem(ftdi, ed_controlhead, 0x00000000);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, ed_bulkhead, 0x11000000);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, hcca, 0x00000000);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, fminterval,
+                                   ((fminterval & FIT) ^ FIT) | hc_fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, periodicstart,
+                                   ((9 *hc_fminterval) / 10) & 0x3fff);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, fminterval, &fminterval);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, periodicstart, &periodicstart);
+        if (retval)
+                return retval;
+        if (0 == (fminterval & 0x3fff0000) || 0 == periodicstart) {
+                if (!(quirk & OHCI_QUIRK_INITRESET)) {
+                        quirk |= OHCI_QUIRK_INITRESET;
+                        goto retry;
+                } else
+                        dev_err(&ftdi->udev->dev, "init err(%08x %04x)\n",
+                                fminterval, periodicstart);
+        }                        /* start controller operations */
+        hc_control &= OHCI_CTRL_RWC;
+        hc_control |= OHCI_CONTROL_INIT | OHCI_CTRL_BLE | OHCI_USB_OPER;
+        retval = ftdi_write_pcimem(ftdi, control, hc_control);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, cmdstatus, OHCI_BLF);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, cmdstatus, &cmdstatus);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_DRWE);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, intrstatus, mask);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, intrdisable,
+                                   OHCI_INTR_MIE | OHCI_INTR_OC | OHCI_INTR_RHSC | OHCI_INTR_FNO |
+                                   OHCI_INTR_UE | OHCI_INTR_RD | OHCI_INTR_SF | OHCI_INTR_WDH |
+                                   OHCI_INTR_SO);
+        if (retval)
+                return retval;        /* handle root hub init quirks ... */
+        retval = ftdi_read_pcimem(ftdi, roothub.a, &roothub_a);
+        if (retval)
+                return retval;
+        roothub_a &= ~(RH_A_PSM | RH_A_OCPM);
+        if (quirk & OHCI_QUIRK_SUPERIO) {
+                roothub_a |= RH_A_NOCP;
+                roothub_a &= ~(RH_A_POTPGT | RH_A_NPS);
+                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
+                if (retval)
+                        return retval;
+        } else if ((quirk & OHCI_QUIRK_AMD756) || distrust_firmware) {
+                roothub_a |= RH_A_NPS;
+                retval = ftdi_write_pcimem(ftdi, roothub.a, roothub_a);
+                if (retval)
+                        return retval;
+        }
+        retval = ftdi_write_pcimem(ftdi, roothub.status, RH_HS_LPSC);
+        if (retval)
+                return retval;
+        retval = ftdi_write_pcimem(ftdi, roothub.b,
+                                   (roothub_a & RH_A_NPS) ? 0 : RH_B_PPCM);
+        if (retval)
+                return retval;
+        retval = ftdi_read_pcimem(ftdi, control, &control);
+        if (retval)
+                return retval;
+        mdelay((roothub_a >> 23) & 0x1fe);
+        for (temp = 0; temp < num_ports; temp++) {
+                u32 portstatus;
+                retval = ftdi_read_pcimem(ftdi, roothub.portstatus[temp],
+                                          &portstatus);
+                if (retval)
+                        return retval;
+                if (1 & portstatus)
+                        devices += 1;
+        }
+        return devices;
 }
 
 static int ftdi_elan_setup_controller(struct usb_ftdi *ftdi, int fn)
 {
-        u32 latence_timer;
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        int activePCIfn = fn << 8;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 16;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xFFFFFFFF);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xF0000000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 12;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        latence_timer &= 0xFFFF00FF;
-        latence_timer |= 0x00001600;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 4;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                0x06);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        for (reg = 0; reg <= 0x54; reg += 4) {
-                UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-        }
-        return 0;
+        u32 latence_timer;
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        int activePCIfn = fn << 8;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 16;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xFFFFFFFF);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xF0000000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 12;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        latence_timer &= 0xFFFF00FF;
+        latence_timer |= 0x00001600;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 4;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            0x06);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        for (reg = 0; reg <= 0x54; reg += 4) {
+                UxxxStatus = ftdi_elan_read_pcimem(ftdi, reg, 0, &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+        }
+        return 0;
 }
 
 static int ftdi_elan_close_controller(struct usb_ftdi *ftdi, int fn)
 {
-        u32 latence_timer;
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        int activePCIfn = fn << 8;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 16;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0xFFFFFFFF);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
-                0x00000000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 12;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        latence_timer &= 0xFFFF00FF;
-        latence_timer |= 0x00001600;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                latence_timer);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        reg = 4;
-        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
-                0x00);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                &pcidata);
-        if (UxxxStatus)
-                return UxxxStatus;
-        return 0;
+        u32 latence_timer;
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        int activePCIfn = fn << 8;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x2800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 16;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0xFFFFFFFF);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0,
+                                            0x00000000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 12;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        latence_timer &= 0xFFFF00FF;
+        latence_timer |= 0x00001600;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            latence_timer);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        reg = 4;
+        UxxxStatus = ftdi_elan_write_config(ftdi, activePCIfn | reg, 0x00,
+                                            0x00);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                           &pcidata);
+        if (UxxxStatus)
+                return UxxxStatus;
+        return 0;
 }
 
 static int ftdi_elan_found_controller(struct usb_ftdi *ftdi, int fn, int quirk)
 {
-        int result;
-        int UxxxStatus;
-        UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
-        if (UxxxStatus)
-                return UxxxStatus;
-        result = ftdi_elan_check_controller(ftdi, quirk);
-        UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
-        if (UxxxStatus)
-                return UxxxStatus;
-        return result;
+        int result;
+        int UxxxStatus;
+        UxxxStatus = ftdi_elan_setup_controller(ftdi, fn);
+        if (UxxxStatus)
+                return UxxxStatus;
+        result = ftdi_elan_check_controller(ftdi, quirk);
+        UxxxStatus = ftdi_elan_close_controller(ftdi, fn);
+        if (UxxxStatus)
+                return UxxxStatus;
+        return result;
 }
 
 static int ftdi_elan_enumeratePCI(struct usb_ftdi *ftdi)
 {
-        u32 controlreg;
-        u8 sensebits;
-        int UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(750);
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(250);
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
-        if (UxxxStatus)
-                return UxxxStatus;
-        msleep(1000);
-        sensebits = (controlreg >> 16) & 0x000F;
-        if (0x0D == sensebits)
-                return 0;
-        else
+        u32 controlreg;
+        u8 sensebits;
+        int UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000000L);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(750);
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x100);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x00000200L | 0x500);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020CL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020DL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(250);
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000020FL | 0x000);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_write_reg(ftdi, 0x0000025FL | 0x800);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        UxxxStatus = ftdi_elan_read_reg(ftdi, &controlreg);
+        if (UxxxStatus)
+                return UxxxStatus;
+        msleep(1000);
+        sensebits = (controlreg >> 16) & 0x000F;
+        if (0x0D == sensebits)
+                return 0;
+        else
                 return - ENXIO;
 }
 
 static int ftdi_elan_setupOHCI(struct usb_ftdi *ftdi)
 {
-        int UxxxStatus;
-        u32 pcidata;
-        int reg = 0;
-        u8 fn;
-        int activePCIfn = 0;
-        int max_devices = 0;
-        int controllers = 0;
-        int unrecognized = 0;
-        ftdi->function = 0;
-        for (fn = 0; (fn < 4); fn++) {
-                u32 pciVID = 0;
-                u32 pciPID = 0;
-                int devices = 0;
-                activePCIfn = fn << 8;
-                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
-                        &pcidata);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                pciVID = pcidata & 0xFFFF;
-                pciPID = (pcidata >> 16) & 0xFFFF;
-                if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035))
-                        {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802))
-                        {
-                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
-                        controllers += 1;
-                } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) {
-                        devices = ftdi_elan_found_controller(ftdi, fn,
-                                OHCI_QUIRK_AMD756);
-                        controllers += 1;
-                } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) {
-                        devices = ftdi_elan_found_controller(ftdi, fn,
-                                OHCI_QUIRK_ZFMICRO);
-                        controllers += 1;
-                } else if (0 == pcidata) {
-                } else
-                        unrecognized += 1;
-                if (devices > max_devices) {
-                        max_devices = devices;
-                        ftdi->function = fn + 1;
-                        ftdi->platform_data.vendor = pciVID;
-                        ftdi->platform_data.device = pciPID;
-                }
-        }
-        if (ftdi->function > 0) {
-                UxxxStatus = ftdi_elan_setup_controller(ftdi,
-                        ftdi->function - 1);
-                if (UxxxStatus)
-                        return UxxxStatus;
-                return 0;
-        } else if (controllers > 0) {
-                return -ENXIO;
-        } else if (unrecognized > 0) {
-                return -ENXIO;
-        } else {
-                ftdi->enumerated = 0;
-                return -ENXIO;
-        }
+        int UxxxStatus;
+        u32 pcidata;
+        int reg = 0;
+        u8 fn;
+        int activePCIfn = 0;
+        int max_devices = 0;
+        int controllers = 0;
+        int unrecognized = 0;
+        ftdi->function = 0;
+        for (fn = 0; (fn < 4); fn++) {
+                u32 pciVID = 0;
+                u32 pciPID = 0;
+                int devices = 0;
+                activePCIfn = fn << 8;
+                UxxxStatus = ftdi_elan_read_config(ftdi, activePCIfn | reg, 0,
+                                                   &pcidata);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                pciVID = pcidata & 0xFFFF;
+                pciPID = (pcidata >> 16) & 0xFFFF;
+                if ((pciVID == PCI_VENDOR_ID_OPTI) && (pciPID == 0xc861)) {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_NEC) && (pciPID == 0x0035))
+                {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_AL) && (pciPID == 0x5237)) {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if ((pciVID == PCI_VENDOR_ID_ATT) && (pciPID == 0x5802))
+                {
+                        devices = ftdi_elan_found_controller(ftdi, fn, 0);
+                        controllers += 1;
+                } else if (pciVID == PCI_VENDOR_ID_AMD && pciPID == 0x740c) {
+                        devices = ftdi_elan_found_controller(ftdi, fn,
+                                                             OHCI_QUIRK_AMD756);
+                        controllers += 1;
+                } else if (pciVID == PCI_VENDOR_ID_COMPAQ && pciPID == 0xa0f8) {
+                        devices = ftdi_elan_found_controller(ftdi, fn,
+                                                             OHCI_QUIRK_ZFMICRO);
+                        controllers += 1;
+                } else if (0 == pcidata) {
+                } else
+                        unrecognized += 1;
+                if (devices > max_devices) {
+                        max_devices = devices;
+                        ftdi->function = fn + 1;
+                        ftdi->platform_data.vendor = pciVID;
+                        ftdi->platform_data.device = pciPID;
+                }
+        }
+        if (ftdi->function > 0) {
+                UxxxStatus = ftdi_elan_setup_controller(ftdi,
+                                                        ftdi->function - 1);
+                if (UxxxStatus)
+                        return UxxxStatus;
+                return 0;
+        } else if (controllers > 0) {
+                return -ENXIO;
+        } else if (unrecognized > 0) {
+                return -ENXIO;
+        } else {
+                ftdi->enumerated = 0;
+                return -ENXIO;
+        }
 }
 
 
 /*
-* we use only the first bulk-in and bulk-out endpoints
-*/
+ * we use only the first bulk-in and bulk-out endpoints
+ */
 static int ftdi_elan_probe(struct usb_interface *interface,
-        const struct usb_device_id *id)
+                           const struct usb_device_id *id)
 {
-        struct usb_host_interface *iface_desc;
-        struct usb_endpoint_descriptor *endpoint;
-        size_t buffer_size;
-        int i;
-        int retval = -ENOMEM;
-        struct usb_ftdi *ftdi;
+        struct usb_host_interface *iface_desc;
+        struct usb_endpoint_descriptor *endpoint;
+        size_t buffer_size;
+        int i;
+        int retval = -ENOMEM;
+        struct usb_ftdi *ftdi;
 
         ftdi = kzalloc(sizeof(struct usb_ftdi), GFP_KERNEL);
-        if (!ftdi) {
-                printk(KERN_ERR "Out of memory\n");
-                return -ENOMEM;
-        }
-
-        mutex_lock(&ftdi_module_lock);
-        list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
-        ftdi->sequence_num = ++ftdi_instances;
-        mutex_unlock(&ftdi_module_lock);
-        ftdi_elan_init_kref(ftdi);
+        if (!ftdi)
+                return -ENOMEM;
+
+        mutex_lock(&ftdi_module_lock);
+        list_add_tail(&ftdi->ftdi_list, &ftdi_static_list);
+        ftdi->sequence_num = ++ftdi_instances;
+        mutex_unlock(&ftdi_module_lock);
+        ftdi_elan_init_kref(ftdi);
         sema_init(&ftdi->sw_lock, 1);
-        ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
-        ftdi->interface = interface;
-        mutex_init(&ftdi->u132_lock);
-        ftdi->expected = 4;
-        iface_desc = interface->cur_altsetting;
-        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
-                endpoint = &iface_desc->endpoint[i].desc;
-                if (!ftdi->bulk_in_endpointAddr &&
+        ftdi->udev = usb_get_dev(interface_to_usbdev(interface));
+        ftdi->interface = interface;
+        mutex_init(&ftdi->u132_lock);
+        ftdi->expected = 4;
+        iface_desc = interface->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
+                endpoint = &iface_desc->endpoint[i].desc;
+                if (!ftdi->bulk_in_endpointAddr &&
                     usb_endpoint_is_bulk_in(endpoint)) {
-                        buffer_size = usb_endpoint_maxp(endpoint);
-                        ftdi->bulk_in_size = buffer_size;
-                        ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress;
-                        ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
-                        if (!ftdi->bulk_in_buffer) {
-                                dev_err(&ftdi->udev->dev, "Could not allocate b"
-                                        "ulk_in_buffer\n");
-                                retval = -ENOMEM;
-                                goto error;
-                        }
-                }
-                if (!ftdi->bulk_out_endpointAddr &&
+                        buffer_size = usb_endpoint_maxp(endpoint);
+                        ftdi->bulk_in_size = buffer_size;
+                        ftdi->bulk_in_endpointAddr = endpoint->bEndpointAddress;
+                        ftdi->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
+                        if (!ftdi->bulk_in_buffer) {
+                                dev_err(&ftdi->udev->dev, "Could not allocate bulk_in_buffer\n");
+                                retval = -ENOMEM;
+                                goto error;
+                        }
+                }
+                if (!ftdi->bulk_out_endpointAddr &&
                     usb_endpoint_is_bulk_out(endpoint)) {
-                        ftdi->bulk_out_endpointAddr =
-                                endpoint->bEndpointAddress;
-                }
-        }
-        if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) {
-                dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk"
-                        "-out endpoints\n");
-                retval = -ENODEV;
-                goto error;
-        }
-        dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
-                iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
-                ftdi->bulk_out_endpointAddr);
-        usb_set_intfdata(interface, ftdi);
-        if (iface_desc->desc.bInterfaceNumber == 0 &&
-                ftdi->bulk_in_endpointAddr == 0x81 &&
-                ftdi->bulk_out_endpointAddr == 0x02) {
-                retval = usb_register_dev(interface, &ftdi_elan_jtag_class);
-                if (retval) {
-                        dev_err(&ftdi->udev->dev, "Not able to get a minor for "
-                                "this device.\n");
-                        usb_set_intfdata(interface, NULL);
-                        retval = -ENOMEM;
-                        goto error;
-                } else {
-                        ftdi->class = &ftdi_elan_jtag_class;
-                        dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface "
-                                "%d now attached to ftdi%d\n", ftdi,
-                                iface_desc->desc.bInterfaceNumber,
-                                interface->minor);
-                        return 0;
-                }
-        } else if (iface_desc->desc.bInterfaceNumber == 1 &&
-                ftdi->bulk_in_endpointAddr == 0x83 &&
-                ftdi->bulk_out_endpointAddr == 0x04) {
-                ftdi->class = NULL;
-                dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now a"
-                        "ctivated\n", ftdi, iface_desc->desc.bInterfaceNumber);
-                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
-                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
-                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
-                ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
-                return 0;
-        } else {
-                dev_err(&ftdi->udev->dev,
-                        "Could not find ELAN's U132 device\n");
-                retval = -ENODEV;
-                goto error;
-        }
-      error:if (ftdi) {
-                ftdi_elan_put_kref(ftdi);
-        }
-        return retval;
+                        ftdi->bulk_out_endpointAddr =
+                                endpoint->bEndpointAddress;
+                }
+        }
+        if (!(ftdi->bulk_in_endpointAddr && ftdi->bulk_out_endpointAddr)) {
+                dev_err(&ftdi->udev->dev, "Could not find both bulk-in and bulk-out endpoints\n");
+                retval = -ENODEV;
+                goto error;
+        }
+        dev_info(&ftdi->udev->dev, "interface %d has I=%02X O=%02X\n",
+                 iface_desc->desc.bInterfaceNumber, ftdi->bulk_in_endpointAddr,
+                 ftdi->bulk_out_endpointAddr);
+        usb_set_intfdata(interface, ftdi);
+        if (iface_desc->desc.bInterfaceNumber == 0 &&
+            ftdi->bulk_in_endpointAddr == 0x81 &&
+            ftdi->bulk_out_endpointAddr == 0x02) {
+                retval = usb_register_dev(interface, &ftdi_elan_jtag_class);
+                if (retval) {
+                        dev_err(&ftdi->udev->dev, "Not able to get a minor for this device\n");
+                        usb_set_intfdata(interface, NULL);
+                        retval = -ENOMEM;
+                        goto error;
+                } else {
+                        ftdi->class = &ftdi_elan_jtag_class;
+                        dev_info(&ftdi->udev->dev, "USB FDTI=%p JTAG interface %d now attached to ftdi%d\n",
+                                 ftdi, iface_desc->desc.bInterfaceNumber,
+                                 interface->minor);
+                        return 0;
+                }
+        } else if (iface_desc->desc.bInterfaceNumber == 1 &&
+                   ftdi->bulk_in_endpointAddr == 0x83 &&
+                   ftdi->bulk_out_endpointAddr == 0x04) {
+                ftdi->class = NULL;
+                dev_info(&ftdi->udev->dev, "USB FDTI=%p ELAN interface %d now activated\n",
+                         ftdi, iface_desc->desc.bInterfaceNumber);
+                INIT_DELAYED_WORK(&ftdi->status_work, ftdi_elan_status_work);
+                INIT_DELAYED_WORK(&ftdi->command_work, ftdi_elan_command_work);
+                INIT_DELAYED_WORK(&ftdi->respond_work, ftdi_elan_respond_work);
+                ftdi_status_queue_work(ftdi, msecs_to_jiffies(3 *1000));
+                return 0;
+        } else {
+                dev_err(&ftdi->udev->dev,
+                        "Could not find ELAN's U132 device\n");
+                retval = -ENODEV;
+                goto error;
+        }
+error:if (ftdi) {
+                ftdi_elan_put_kref(ftdi);
+        }
+        return retval;
 }
 
 static void ftdi_elan_disconnect(struct usb_interface *interface)
 {
-        struct usb_ftdi *ftdi = usb_get_intfdata(interface);
-        ftdi->disconnected += 1;
-        if (ftdi->class) {
-                int minor = interface->minor;
-                struct usb_class_driver *class = ftdi->class;
-                usb_set_intfdata(interface, NULL);
-                usb_deregister_dev(interface, class);
-                dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on min"
-                        "or %d now disconnected\n", minor);
-        } else {
-                ftdi_status_cancel_work(ftdi);
-                ftdi_command_cancel_work(ftdi);
-                ftdi_response_cancel_work(ftdi);
-                ftdi_elan_abandon_completions(ftdi);
-                ftdi_elan_abandon_targets(ftdi);
-                if (ftdi->registered) {
-                        platform_device_unregister(&ftdi->platform_dev);
-                        ftdi->synchronized = 0;
-                        ftdi->enumerated = 0;
-                        ftdi->initialized = 0;
-                        ftdi->registered = 0;
-                }
-                flush_workqueue(status_queue);
-                flush_workqueue(command_queue);
-                flush_workqueue(respond_queue);
-                ftdi->disconnected += 1;
-                usb_set_intfdata(interface, NULL);
-                dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller inter"
-                        "face now disconnected\n");
-        }
-        ftdi_elan_put_kref(ftdi);
+        struct usb_ftdi *ftdi = usb_get_intfdata(interface);
+        ftdi->disconnected += 1;
+        if (ftdi->class) {
+                int minor = interface->minor;
+                struct usb_class_driver *class = ftdi->class;
+                usb_set_intfdata(interface, NULL);
+                usb_deregister_dev(interface, class);
+                dev_info(&ftdi->udev->dev, "USB FTDI U132 jtag interface on minor %d now disconnected\n",
+                         minor);
+        } else {
+                ftdi_status_cancel_work(ftdi);
+                ftdi_command_cancel_work(ftdi);
+                ftdi_response_cancel_work(ftdi);
+                ftdi_elan_abandon_completions(ftdi);
+                ftdi_elan_abandon_targets(ftdi);
+                if (ftdi->registered) {
+                        platform_device_unregister(&ftdi->platform_dev);
+                        ftdi->synchronized = 0;
+                        ftdi->enumerated = 0;
+                        ftdi->initialized = 0;
+                        ftdi->registered = 0;
+                }
+                flush_workqueue(status_queue);
+                flush_workqueue(command_queue);
+                flush_workqueue(respond_queue);
+                ftdi->disconnected += 1;
+                usb_set_intfdata(interface, NULL);
+                dev_info(&ftdi->udev->dev, "USB FTDI U132 host controller interface now disconnected\n");
+        }
+        ftdi_elan_put_kref(ftdi);
 }
 
 static struct usb_driver ftdi_elan_driver = {
-        .name = "ftdi-elan",
-        .probe = ftdi_elan_probe,
-        .disconnect = ftdi_elan_disconnect,
-        .id_table = ftdi_elan_table,
+        .name = "ftdi-elan",
+        .probe = ftdi_elan_probe,
+        .disconnect = ftdi_elan_disconnect,
+        .id_table = ftdi_elan_table,
 };
 static int __init ftdi_elan_init(void)
 {
-        int result;
-        printk(KERN_INFO "driver %s\n", ftdi_elan_driver.name);
-        mutex_init(&ftdi_module_lock);
-        INIT_LIST_HEAD(&ftdi_static_list);
-        status_queue = create_singlethread_workqueue("ftdi-status-control");
+        int result;
+        pr_info("driver %s\n", ftdi_elan_driver.name);
+        mutex_init(&ftdi_module_lock);
+        INIT_LIST_HEAD(&ftdi_static_list);
+        status_queue = create_singlethread_workqueue("ftdi-status-control");
         if (!status_queue)
                 goto err_status_queue;
-        command_queue = create_singlethread_workqueue("ftdi-command-engine");
+        command_queue = create_singlethread_workqueue("ftdi-command-engine");
         if (!command_queue)
                 goto err_command_queue;
-        respond_queue = create_singlethread_workqueue("ftdi-respond-engine");
+        respond_queue = create_singlethread_workqueue("ftdi-respond-engine");
         if (!respond_queue)
                 goto err_respond_queue;
-        result = usb_register(&ftdi_elan_driver);
-        if (result) {
+        result = usb_register(&ftdi_elan_driver);
+        if (result) {
                 destroy_workqueue(status_queue);
                 destroy_workqueue(command_queue);
                 destroy_workqueue(respond_queue);
-                printk(KERN_ERR "usb_register failed. Error number %d\n",
-                       result);
+                pr_err("usb_register failed. Error number %d\n", result);
         }
-        return result;
+        return result;
 
- err_respond_queue:
+err_respond_queue:
         destroy_workqueue(command_queue);
- err_command_queue:
+err_command_queue:
         destroy_workqueue(status_queue);
- err_status_queue:
-        printk(KERN_ERR "%s couldn't create workqueue\n", ftdi_elan_driver.name);
+err_status_queue:
+        pr_err("%s couldn't create workqueue\n", ftdi_elan_driver.name);
         return -ENOMEM;
 }
 
 static void __exit ftdi_elan_exit(void)
 {
-        struct usb_ftdi *ftdi;
-        struct usb_ftdi *temp;
-        usb_deregister(&ftdi_elan_driver);
-        printk(KERN_INFO "ftdi_u132 driver deregistered\n");
-        list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
-                ftdi_status_cancel_work(ftdi);
-                ftdi_command_cancel_work(ftdi);
-                ftdi_response_cancel_work(ftdi);
-        } flush_workqueue(status_queue);
-        destroy_workqueue(status_queue);
-        status_queue = NULL;
-        flush_workqueue(command_queue);
-        destroy_workqueue(command_queue);
-        command_queue = NULL;
-        flush_workqueue(respond_queue);
-        destroy_workqueue(respond_queue);
-        respond_queue = NULL;
+        struct usb_ftdi *ftdi;
+        struct usb_ftdi *temp;
+        usb_deregister(&ftdi_elan_driver);
+        pr_info("ftdi_u132 driver deregistered\n");
+        list_for_each_entry_safe(ftdi, temp, &ftdi_static_list, ftdi_list) {
+                ftdi_status_cancel_work(ftdi);
+                ftdi_command_cancel_work(ftdi);
+                ftdi_response_cancel_work(ftdi);
+        } flush_workqueue(status_queue);
+        destroy_workqueue(status_queue);
+        status_queue = NULL;
+        flush_workqueue(command_queue);
+        destroy_workqueue(command_queue);
+        command_queue = NULL;
+        flush_workqueue(respond_queue);
+        destroy_workqueue(respond_queue);
+        respond_queue = NULL;
 }
 
 
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 20bcfdd7eace..c6bfd13f6c92 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -51,19 +51,12 @@
 */
 #define MAX_WRITES_IN_FLIGHT 4
 
-/* Use our own dbg macro */
-#undef dbg
-#define dbg( format, arg... ) do { if( debug ) printk( KERN_DEBUG __FILE__ ": " format "\n" , ## arg ); } while ( 0 )
-
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 /* Module parameters */
 static DEFINE_MUTEX(iowarrior_mutex);
-static bool debug = 0;
-module_param(debug, bool, 0644);
-MODULE_PARM_DESC(debug, "debug=1 enables debugging messages");
 
 static struct usb_driver iowarrior_driver;
 static DEFINE_MUTEX(iowarrior_open_disc_lock);
@@ -235,8 +228,8 @@ static void iowarrior_write_callback(struct urb *urb)
         if (status &&
             !(status == -ENOENT ||
               status == -ECONNRESET || status == -ESHUTDOWN)) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&dev->interface->dev,
+                        "nonzero write bulk status received: %d\n", status);
         }
         /* free up our allocated buffer */
         usb_free_coherent(urb->dev, urb->transfer_buffer_length,
@@ -251,7 +244,7 @@ static void iowarrior_write_callback(struct urb *urb)
  */
 static inline void iowarrior_delete(struct iowarrior *dev)
 {
-        dbg("%s - minor %d", __func__, dev->minor);
+        dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor);
         kfree(dev->int_in_buffer);
         usb_free_urb(dev->int_in_urb);
         kfree(dev->read_queue);
@@ -288,7 +281,8 @@ static ssize_t iowarrior_read(struct file *file, char __user *buffer,
         if (dev == NULL || !dev->present)
                 return -ENODEV;
 
-        dbg("%s - minor %d, count = %zd", __func__, dev->minor, count);
+        dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n",
+                dev->minor, count);
 
         /* read count must be packet size (+ time stamp) */
         if ((count != dev->report_size)
@@ -356,7 +350,8 @@ static ssize_t iowarrior_write(struct file *file,
                 retval = -ENODEV;
                 goto exit;
         }
-        dbg("%s - minor %d, count = %zd", __func__, dev->minor, count);
+        dev_dbg(&dev->interface->dev, "minor %d, count = %zd\n",
+                dev->minor, count);
         /* if count is 0 we're already done */
         if (count == 0) {
                 retval = 0;
@@ -418,14 +413,16 @@ static ssize_t iowarrior_write(struct file *file,
                 int_out_urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (!int_out_urb) {
                         retval = -ENOMEM;
-                        dbg("%s Unable to allocate urb ", __func__);
+                        dev_dbg(&dev->interface->dev,
+                                "Unable to allocate urb\n");
                         goto error_no_urb;
                 }
                 buf = usb_alloc_coherent(dev->udev, dev->report_size,
                                          GFP_KERNEL, &int_out_urb->transfer_dma);
                 if (!buf) {
                         retval = -ENOMEM;
-                        dbg("%s Unable to allocate buffer ", __func__);
+                        dev_dbg(&dev->interface->dev,
+                                "Unable to allocate buffer\n");
                         goto error_no_buffer;
                 }
                 usb_fill_int_urb(int_out_urb, dev->udev,
@@ -441,8 +438,9 @@ static ssize_t iowarrior_write(struct file *file,
                 }
                 retval = usb_submit_urb(int_out_urb, GFP_KERNEL);
                 if (retval) {
-                        dbg("%s submit error %d for urb nr.%d", __func__,
-                            retval, atomic_read(&dev->write_busy));
+                        dev_dbg(&dev->interface->dev,
+                                "submit error %d for urb nr.%d\n",
+                                retval, atomic_read(&dev->write_busy));
                         goto error;
                 }
                 /* submit was ok */
@@ -502,8 +500,8 @@ static long iowarrior_ioctl(struct file *file, unsigned int cmd,
                 goto error_out;
         }
 
-        dbg("%s - minor %d, cmd 0x%.4x, arg %ld", __func__, dev->minor, cmd,
-            arg);
+        dev_dbg(&dev->interface->dev, "minor %d, cmd 0x%.4x, arg %ld\n",
+                dev->minor, cmd, arg);
 
         retval = 0;
         io_res = 0;
@@ -601,8 +599,6 @@ static int iowarrior_open(struct inode *inode, struct file *file)
         int subminor;
         int retval = 0;
 
-        dbg("%s", __func__);
-
         mutex_lock(&iowarrior_mutex);
         subminor = iminor(inode);
 
@@ -662,7 +658,7 @@ static int iowarrior_release(struct inode *inode, struct file *file)
                 return -ENODEV;
         }
 
-        dbg("%s - minor %d", __func__, dev->minor);
+        dev_dbg(&dev->interface->dev, "minor %d\n", dev->minor);
 
         /* lock our device */
         mutex_lock(&dev->mutex);
diff --git a/drivers/usb/misc/usb3503.c b/drivers/usb/misc/usb3503.c
index a31641e18d19..f43c61989cef 100644
--- a/drivers/usb/misc/usb3503.c
+++ b/drivers/usb/misc/usb3503.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <linux/clk.h>
 #include <linux/i2c.h>
 #include <linux/gpio.h>
 #include <linux/delay.h>
@@ -57,10 +58,12 @@ struct usb3503 {
         enum usb3503_mode       mode;
         struct regmap           *regmap;
         struct device           *dev;
+        struct clk              *clk;
         u8      port_off_mask;
         int     gpio_intn;
         int     gpio_reset;
         int     gpio_connect;
+        bool    secondary_ref_clk;
 };
 
 static int usb3503_reset(struct usb3503 *hub, int state)
@@ -184,8 +187,58 @@ static int usb3503_probe(struct usb3503 *hub)
                 hub->gpio_reset         = pdata->gpio_reset;
                 hub->mode               = pdata->initial_mode;
         } else if (np) {
+                struct clk *clk;
                 hub->port_off_mask = 0;
 
+                clk = devm_clk_get(dev, "refclk");
+                if (IS_ERR(clk) && PTR_ERR(clk) != -ENOENT) {
+                        dev_err(dev, "unable to request refclk (%d)\n", err);
+                        return PTR_ERR(clk);
+                }
+
+                if (!IS_ERR(clk)) {
+                        u32 rate = 0;
+                        hub->clk = clk;
+
+                        if (!of_property_read_u32(np, "refclk-frequency",
+                                                 &rate)) {
+
+                                switch (rate) {
+                                case 38400000:
+                                case 26000000:
+                                case 19200000:
+                                case 12000000:
+                                        hub->secondary_ref_clk = 0;
+                                        break;
+                                case 24000000:
+                                case 27000000:
+                                case 25000000:
+                                case 50000000:
+                                        hub->secondary_ref_clk = 1;
+                                        break;
+                                default:
+                                        dev_err(dev,
+                                                "unsupported reference clock rate (%d)\n",
+                                                (int) rate);
+                                        return -EINVAL;
+                                }
+                                err = clk_set_rate(hub->clk, rate);
+                                if (err) {
+                                        dev_err(dev,
+                                                "unable to set reference clock rate to %d\n",
+                                                (int) rate);
+                                        return err;
+                                }
+                        }
+
+                        err = clk_prepare_enable(hub->clk);
+                        if (err) {
+                                dev_err(dev,
+                                        "unable to enable reference clock\n");
+                                return err;
+                        }
+                }
+
                 property = of_get_property(np, "disabled-ports", &len);
                 if (property && (len / sizeof(u32)) > 0) {
                         int i;
@@ -213,8 +266,10 @@ static int usb3503_probe(struct usb3503 *hub)
                 dev_err(dev, "Ports disabled with no control interface\n");
 
         if (gpio_is_valid(hub->gpio_intn)) {
-                err = devm_gpio_request_one(dev, hub->gpio_intn,
-                                GPIOF_OUT_INIT_HIGH, "usb3503 intn");
+                int val = hub->secondary_ref_clk ? GPIOF_OUT_INIT_LOW :
+                                                   GPIOF_OUT_INIT_HIGH;
+                err = devm_gpio_request_one(dev, hub->gpio_intn, val,
+                                            "usb3503 intn");
                 if (err) {
                         dev_err(dev,
                                 "unable to request GPIO %d as connect pin (%d)\n",
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index f6568b5e9b06..51a6da256772 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -1320,6 +1320,11 @@ static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
         urb->context = &completion;
         urb->complete = unlink1_callback;
 
+        if (usb_pipeout(urb->pipe)) {
+                simple_fill_buf(urb);
+                urb->transfer_flags |= URB_ZERO_PACKET;
+        }
+
         /* keep the endpoint busy.  there are lots of hc/hcd-internal
          * states, and testing should get to all of them over time.
          *
@@ -1340,6 +1345,9 @@ static int unlink1(struct usbtest_dev *dev, int pipe, int size, int async)
                 while (!completion_done(&completion)) {
                         retval = usb_unlink_urb(urb);
 
+                        if (retval == 0 && usb_pipein(urb->pipe))
+                                retval = simple_check_buf(dev, urb);
+
                         switch (retval) {
                         case -EBUSY:
                         case -EIDRM:
@@ -1450,6 +1458,11 @@ static int unlink_queued(struct usbtest_dev *dev, int pipe, unsigned num,
                                 unlink_queued_callback, &ctx);
                 ctx.urbs[i]->transfer_dma = buf_dma;
                 ctx.urbs[i]->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+
+                if (usb_pipeout(ctx.urbs[i]->pipe)) {
+                        simple_fill_buf(ctx.urbs[i]);
+                        ctx.urbs[i]->transfer_flags |= URB_ZERO_PACKET;
+                }
         }
 
         /* Submit all the URBs and then unlink URBs num - 4 and num - 2. */
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
index 24278208bf74..1472805083de 100644
--- a/drivers/usb/misc/yurex.c
+++ b/drivers/usb/misc/yurex.c
@@ -296,6 +296,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
 
         /* save our data pointer in this interface device */
         usb_set_intfdata(interface, dev);
+        dev->bbu = -1;
 
         /* we can register the device now, as it is ready */
         retval = usb_register_dev(interface, &yurex_class);
@@ -306,8 +307,6 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
                 goto error;
         }
 
-        dev->bbu = -1;
-
         dev_info(&interface->dev,
                  "USB YUREX device now attached to Yurex #%d\n",
                  interface->minor);
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 8b789792f6fa..06cc5d6ea681 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -76,7 +76,7 @@ config USB_MUSB_TUSB6010
 
 config USB_MUSB_OMAP2PLUS
         tristate "OMAP2430 and onwards"
-        depends on ARCH_OMAP2PLUS
+        depends on ARCH_OMAP2PLUS && USB
         select GENERIC_PHY
 
 config USB_MUSB_AM35X
@@ -141,10 +141,11 @@ config USB_TI_CPPI_DMA
 config USB_TI_CPPI41_DMA
         bool 'TI CPPI 4.1 (AM335x)'
         depends on ARCH_OMAP
+        select TI_CPPI41
 
 config USB_TUSB_OMAP_DMA
         bool 'TUSB 6010'
-        depends on USB_MUSB_TUSB6010
+        depends on USB_MUSB_TUSB6010 = USB_MUSB_HDRC # both built-in or both modules
         depends on ARCH_OMAP
         help
           Enable DMA transfers on TUSB 6010 when OMAP DMA is available.
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index b3aa0184af9a..0a34dd859555 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -32,7 +32,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/platform_data/usb-omap.h>
 
 #include "musb_core.h"
@@ -85,6 +85,7 @@
 struct am35x_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
         struct clk              *phy_clk;
         struct clk              *clk;
 };
@@ -360,7 +361,6 @@ static int am35x_musb_init(struct musb *musb)
         if (!rev)
                 return -ENODEV;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -EPROBE_DEFER;
@@ -402,7 +402,6 @@ static int am35x_musb_exit(struct musb *musb)
                 data->set_phy_power(0);
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -505,6 +504,9 @@ static int am35x_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &am35x_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy))
+                goto err7;
         platform_set_drvdata(pdev, glue);
 
         pinfo = am35x_dev_info;
@@ -518,11 +520,14 @@ static int am35x_probe(struct platform_device *pdev)
         if (IS_ERR(musb)) {
                 ret = PTR_ERR(musb);
                 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
-                goto err7;
+                goto err8;
         }
 
         return 0;
 
+err8:
+        usb_phy_generic_unregister(glue->phy);
+
 err7:
         clk_disable(clk);
 
@@ -547,6 +552,7 @@ static int am35x_remove(struct platform_device *pdev)
         struct am35x_glue       *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         clk_disable(glue->clk);
         clk_disable(glue->phy_clk);
         clk_put(glue->clk);
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 796677fa9a15..d40d5f0b5528 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -18,7 +18,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/prefetch.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <asm/cacheflush.h>
 
@@ -29,6 +29,7 @@
 struct bfin_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
 };
 #define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
@@ -401,7 +402,6 @@ static int bfin_musb_init(struct musb *musb)
         }
         gpio_direction_output(musb->config->gpio_vrsel, 0);
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 gpio_free(musb->config->gpio_vrsel);
@@ -424,9 +424,8 @@ static int bfin_musb_init(struct musb *musb)
 static int bfin_musb_exit(struct musb *musb)
 {
         gpio_free(musb->config->gpio_vrsel);
-
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
+
         return 0;
 }
 
@@ -477,6 +476,9 @@ static int bfin_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &bfin_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy))
+                goto err2;
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -514,6 +516,9 @@ static int bfin_probe(struct platform_device *pdev)
         return 0;
 
 err3:
+        usb_phy_generic_unregister(glue->phy);
+
+err2:
         platform_device_put(musb);
 
 err1:
@@ -528,6 +533,7 @@ static int bfin_remove(struct platform_device *pdev)
         struct bfin_glue                *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         kfree(glue);
 
         return 0;
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index e3486de71995..058775e647ad 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -32,7 +32,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <mach/da8xx.h>
 #include <linux/platform_data/usb-davinci.h>
@@ -85,6 +85,7 @@
 struct da8xx_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
         struct clk              *clk;
 };
 
@@ -418,7 +419,6 @@ static int da8xx_musb_init(struct musb *musb)
         if (!rev)
                 goto fail;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 ret = -EPROBE_DEFER;
@@ -453,7 +453,6 @@ static int da8xx_musb_exit(struct musb *musb)
         phy_off();
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -512,6 +511,11 @@ static int da8xx_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &da8xx_ops;
 
+        glue->phy = usb_phy_generic_register();
+        if (IS_ERR(glue->phy)) {
+                ret = PTR_ERR(glue->phy);
+                goto err5;
+        }
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -538,11 +542,14 @@ static int da8xx_probe(struct platform_device *pdev)
         if (IS_ERR(musb)) {
                 ret = PTR_ERR(musb);
                 dev_err(&pdev->dev, "failed to register musb device: %d\n", ret);
-                goto err5;
+                goto err6;
         }
 
         return 0;
 
+err6:
+        usb_phy_generic_unregister(glue->phy);
+
 err5:
         clk_disable(clk);
 
@@ -561,6 +568,7 @@ static int da8xx_remove(struct platform_device *pdev)
         struct da8xx_glue               *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         clk_disable(glue->clk);
         clk_put(glue->clk);
         kfree(glue);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index c259dac9d056..de8492b06e46 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -32,7 +32,7 @@
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include <mach/cputype.h>
 #include <mach/hardware.h>
@@ -381,7 +381,6 @@ static int davinci_musb_init(struct musb *musb)
         u32             revision;
         int             ret = -ENODEV;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv)) {
                 ret = -EPROBE_DEFER;
@@ -439,7 +438,7 @@ static int davinci_musb_init(struct musb *musb)
 fail:
         usb_put_phy(musb->xceiv);
 unregister:
-        usb_nop_xceiv_unregister();
+        usb_phy_generic_unregister();
         return ret;
 }
 
@@ -487,7 +486,6 @@ static int davinci_musb_exit(struct musb *musb)
         phy_off();
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
 
         return 0;
 }
@@ -545,6 +543,7 @@ static int davinci_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &davinci_ops;
 
+        usb_phy_generic_register();
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -603,6 +602,7 @@ static int davinci_remove(struct platform_device *pdev)
         struct davinci_glue             *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister();
         clk_disable(glue->clk);
         clk_put(glue->clk);
         kfree(glue);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 07576907e2c6..61da471b7aed 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -848,6 +848,10 @@ b_host:
                 }
         }
 
+        /* handle babble condition */
+        if (int_usb & MUSB_INTR_BABBLE)
+                schedule_work(&musb->recover_work);
+
 #if 0
 /* REVISIT ... this would be for multiplexing periodic endpoints, or
  * supporting transfer phasing to prevent exceeding ISO bandwidth
@@ -1746,6 +1750,34 @@ static void musb_irq_work(struct work_struct *data)
         }
 }
 
+/* Recover from babble interrupt conditions */
+static void musb_recover_work(struct work_struct *data)
+{
+        struct musb *musb = container_of(data, struct musb, recover_work);
+        int status;
+
+        musb_platform_reset(musb);
+
+        usb_phy_vbus_off(musb->xceiv);
+        udelay(100);
+
+        usb_phy_vbus_on(musb->xceiv);
+        udelay(100);
+
+        /*
+         * When a babble condition occurs, the musb controller removes the
+         * session bit and the endpoint config is lost.
+         */
+        if (musb->dyn_fifo)
+                status = ep_config_from_table(musb);
+        else
+                status = ep_config_from_hw(musb);
+
+        /* start the session again */
+        if (status == 0)
+                musb_start(musb);
+}
+
 /* --------------------------------------------------------------------------
  * Init support
  */
@@ -1913,6 +1945,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
         /* Init IRQ workqueue before request_irq */
         INIT_WORK(&musb->irq_work, musb_irq_work);
+        INIT_WORK(&musb->recover_work, musb_recover_work);
         INIT_DELAYED_WORK(&musb->deassert_reset_work, musb_deassert_reset);
         INIT_DELAYED_WORK(&musb->finish_resume_work, musb_host_finish_resume);
 
@@ -2008,6 +2041,7 @@ fail4:
 
 fail3:
         cancel_work_sync(&musb->irq_work);
+        cancel_work_sync(&musb->recover_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         if (musb->dma_controller)
@@ -2073,6 +2107,7 @@ static int musb_remove(struct platform_device *pdev)
                 dma_controller_destroy(musb->dma_controller);
 
         cancel_work_sync(&musb->irq_work);
+        cancel_work_sync(&musb->recover_work);
         cancel_delayed_work_sync(&musb->finish_resume_work);
         cancel_delayed_work_sync(&musb->deassert_reset_work);
         musb_free(musb);
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 7083e82776ff..d155a156f240 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -192,6 +192,7 @@ struct musb_platform_ops {
 
         int     (*set_mode)(struct musb *musb, u8 mode);
         void    (*try_idle)(struct musb *musb, unsigned long timeout);
+        void    (*reset)(struct musb *musb);
 
         int     (*vbus_status)(struct musb *musb);
         void    (*set_vbus)(struct musb *musb, int on);
@@ -296,6 +297,7 @@ struct musb {
 
         irqreturn_t             (*isr)(int, void *);
         struct work_struct      irq_work;
+        struct work_struct      recover_work;
         struct delayed_work     deassert_reset_work;
         struct delayed_work     finish_resume_work;
         u16                     hwvers;
@@ -337,6 +339,7 @@ struct musb {
         dma_addr_t              async;
         dma_addr_t              sync;
         void __iomem            *sync_va;
+        u8                      tusb_revision;
 #endif
 
         /* passed down from chip/board specific irq handlers */
@@ -552,6 +555,12 @@ static inline void musb_platform_try_idle(struct musb *musb,
                 musb->ops->try_idle(musb, timeout);
 }
 
+static inline void musb_platform_reset(struct musb *musb)
+{
+        if (musb->ops->reset)
+                musb->ops->reset(musb);
+}
+
 static inline int musb_platform_get_vbus_status(struct musb *musb)
 {
         if (!musb->ops->vbus_status)
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index e2fd263585de..51beb13c7e1a 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -35,7 +35,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/pm_runtime.h>
 #include <linux/module.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/platform_data/usb-omap.h>
 #include <linux/sizes.h>
 
@@ -329,9 +329,21 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
          * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
          * Also, DRVVBUS pulses for SRP (but not at 5V) ...
          */
-        if (is_host_active(musb) && usbintr & MUSB_INTR_BABBLE)
+        if (is_host_active(musb) && usbintr & MUSB_INTR_BABBLE) {
                 pr_info("CAUTION: musb: Babble Interrupt Occurred\n");
 
+                /*
+                 * When a babble condition occurs, the musb controller removes
+                 * the session and is no longer in host mode. Hence, all
+                 * devices connected to its root hub get disconnected.
+                 *
+                 * Hand this error down to the musb core isr, so it can
+                 * recover.
+                 */
+                musb->int_usb = MUSB_INTR_BABBLE | MUSB_INTR_DISCONNECT;
+                musb->int_tx = musb->int_rx = 0;
+        }
+
         if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) {
                 int drvvbus = dsps_readl(reg_base, wrp->status);
                 void __iomem *mregs = musb->mregs;
@@ -524,6 +536,16 @@ static int dsps_musb_set_mode(struct musb *musb, u8 mode)
         return 0;
 }
 
+static void dsps_musb_reset(struct musb *musb)
+{
+        struct device *dev = musb->controller;
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+
+        dsps_writel(musb->ctrl_base, wrp->control, (1 << wrp->reset));
+        udelay(100);
+}
+
 static struct musb_platform_ops dsps_ops = {
         .init           = dsps_musb_init,
         .exit           = dsps_musb_exit,
@@ -533,6 +555,7 @@ static struct musb_platform_ops dsps_ops = {
 
         .try_idle       = dsps_musb_try_idle,
         .set_mode       = dsps_musb_set_mode,
+        .reset          = dsps_musb_reset,
 };
 
 static u64 musb_dmamask = DMA_BIT_MASK(32);
@@ -750,7 +773,7 @@ static const struct of_device_id musb_dsps_of_match[] = {
 };
 MODULE_DEVICE_TABLE(of, musb_dsps_of_match);
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int dsps_suspend(struct device *dev)
 {
         struct dsps_glue *glue = dev_get_drvdata(dev);
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 4e9fb1d08698..159ef4be1ef2 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -24,13 +24,14 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
 #include "musb_core.h"
 
 struct tusb6010_glue {
         struct device           *dev;
         struct platform_device  *musb;
+        struct platform_device  *phy;
 };
 
 static void tusb_musb_set_vbus(struct musb *musb, int is_on);
@@ -42,7 +43,7 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on);
  * Checks the revision. We need to use the DMA register as 3.0 does not
  * have correct versions for TUSB_PRCM_REV or TUSB_INT_CTRL_REV.
  */
-u8 tusb_get_revision(struct musb *musb)
+static u8 tusb_get_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             die_id;
@@ -58,14 +59,13 @@ u8 tusb_get_revision(struct musb *musb)
 
         return rev;
 }
-EXPORT_SYMBOL_GPL(tusb_get_revision);
 
-static int tusb_print_revision(struct musb *musb)
+static void tusb_print_revision(struct musb *musb)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u8              rev;
 
-        rev = tusb_get_revision(musb);
+        rev = musb->tusb_revision;
 
         pr_info("tusb: %s%i.%i %s%i.%i %s%i.%i %s%i.%i %s%i %s%i.%i\n",
                 "prcm",
@@ -84,8 +84,6 @@ static int tusb_print_revision(struct musb *musb)
                 TUSB_DIDR1_HI_CHIP_REV(musb_readl(tbase, TUSB_DIDR1_HI)),
                 "rev",
                 TUSB_REV_MAJOR(rev), TUSB_REV_MINOR(rev));
-
-        return tusb_get_revision(musb);
 }
 
 #define WBUS_QUIRK_MASK (TUSB_PHY_OTG_CTRL_TESTM2 | TUSB_PHY_OTG_CTRL_TESTM1 \
@@ -349,7 +347,7 @@ static void tusb_allow_idle(struct musb *musb, u32 wakeup_enables)
         u32             reg;
 
         if ((wakeup_enables & TUSB_PRCM_WBUS)
-                        && (tusb_get_revision(musb) == TUSB_REV_30))
+                        && (musb->tusb_revision == TUSB_REV_30))
                 tusb_wbus_quirk(musb, 1);
 
         tusb_set_clock_source(musb, 0);
@@ -797,7 +795,7 @@ static irqreturn_t tusb_musb_interrupt(int irq, void *__hci)
                 u32     reg;
                 u32     i;
 
-                if (tusb_get_revision(musb) == TUSB_REV_30)
+                if (musb->tusb_revision == TUSB_REV_30)
                         tusb_wbus_quirk(musb, 0);
 
                 /* there are issues re-locking the PLL on wakeup ... */
@@ -1011,10 +1009,11 @@ static int tusb_musb_start(struct musb *musb)
                 goto err;
         }
 
-        ret = tusb_print_revision(musb);
-        if (ret < 2) {
+        musb->tusb_revision = tusb_get_revision(musb);
+        tusb_print_revision(musb);
+        if (musb->tusb_revision < 2) {
                 printk(KERN_ERR "tusb: Unsupported TUSB6010 revision %i\n",
-                                ret);
+                                musb->tusb_revision);
                 goto err;
         }
 
@@ -1065,7 +1064,6 @@ static int tusb_musb_init(struct musb *musb)
         void __iomem            *sync = NULL;
         int                     ret;
 
-        usb_nop_xceiv_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -EPROBE_DEFER;
@@ -1117,7 +1115,6 @@ done:
                         iounmap(sync);
 
                 usb_put_phy(musb->xceiv);
-                usb_nop_xceiv_unregister();
         }
         return ret;
 }
@@ -1133,7 +1130,6 @@ static int tusb_musb_exit(struct musb *musb)
         iounmap(musb->sync_va);
 
         usb_put_phy(musb->xceiv);
-        usb_nop_xceiv_unregister();
         return 0;
 }
 
@@ -1176,6 +1172,7 @@ static int tusb_probe(struct platform_device *pdev)
 
         pdata->platform_ops             = &tusb_ops;
 
+        usb_phy_generic_register();
         platform_set_drvdata(pdev, glue);
 
         memset(musb_resources, 0x00, sizeof(*musb_resources) *
@@ -1224,6 +1221,7 @@ static int tusb_remove(struct platform_device *pdev)
         struct tusb6010_glue            *glue = platform_get_drvdata(pdev);
 
         platform_device_unregister(glue->musb);
+        usb_phy_generic_unregister(glue->phy);
         kfree(glue);
 
         return 0;
diff --git a/drivers/usb/musb/tusb6010.h b/drivers/usb/musb/tusb6010.h
index 35c933a5d991..aec86c86ce32 100644
--- a/drivers/usb/musb/tusb6010.h
+++ b/drivers/usb/musb/tusb6010.h
@@ -12,14 +12,6 @@
 #ifndef __TUSB6010_H__
 #define __TUSB6010_H__
 
-extern u8 tusb_get_revision(struct musb *musb);
-
-#ifdef CONFIG_USB_TUSB6010
-#define musb_in_tusb()                  1
-#else
-#define musb_in_tusb()                  0
-#endif
-
 #ifdef CONFIG_USB_TUSB_OMAP_DMA
 #define tusb_dma_omap()                 1
 #else
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index e33b6b2c44c2..3ce152c0408e 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -677,7 +677,7 @@ struct dma_controller *dma_controller_create(struct musb *musb, void __iomem *ba
         tusb_dma->controller.channel_program = tusb_omap_dma_program;
         tusb_dma->controller.channel_abort = tusb_omap_dma_abort;
 
-        if (tusb_get_revision(musb) >= TUSB_REV_30)
+        if (musb->tusb_revision >= TUSB_REV_30)
                 tusb_dma->multichannel = 1;
 
         for (i = 0; i < MAX_DMAREQ; i++) {
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index 416e0c8cf6ff..e253fa05be68 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -6,15 +6,6 @@ menu "USB Physical Layer drivers"
 config USB_PHY
         def_bool n
 
-config USB_OTG_FSM
-        tristate "USB 2.0 OTG FSM implementation"
-        depends on USB
-        select USB_OTG
-        select USB_PHY
-        help
-          Implements OTG Final State Machine as specified in On-The-Go
-          and Embedded Host Supplement to the USB Revision 2.0 Specification.
-
 #
 # USB Transceiver Drivers
 #
@@ -59,14 +50,6 @@ config KEYSTONE_USB_PHY
           interface to interact with USB 2.0 and USB 3.0 PHY that is part
           of the Keystone SOC.
 
-config MV_U3D_PHY
-        bool "Marvell USB 3.0 PHY controller Driver"
-        depends on CPU_MMP3
-        select USB_PHY
-        help
-          Enable this to support Marvell USB 3.0 phy controller for Marvell
-          SoC.
-
 config NOP_USB_XCEIV
         tristate "NOP USB Transceiver Driver"
         select USB_PHY
@@ -171,11 +154,12 @@ config USB_ISP1301
           module will be called phy-isp1301.
 
 config USB_MSM_OTG
-        tristate "OTG support for Qualcomm on-chip USB controller"
-        depends on (USB || USB_GADGET) && ARCH_MSM
+        tristate "Qualcomm on-chip USB OTG controller support"
+        depends on (USB || USB_GADGET) && (ARCH_MSM || ARCH_QCOM || COMPILE_TEST)
+        depends on RESET_CONTROLLER
         select USB_PHY
         help
-          Enable this to support the USB OTG transceiver on MSM chips. It
+          Enable this to support the USB OTG transceiver on Qualcomm chips. It
           handles PHY initialization, clock management, and workarounds
           required after resetting the hardware and power management.
           This driver is required even for peripheral only or host only
@@ -208,6 +192,7 @@ config USB_MXS_PHY
 config USB_RCAR_PHY
         tristate "Renesas R-Car USB PHY support"
         depends on USB || USB_GADGET
+        depends on ARCH_R8A7778 || ARCH_R8A7779 || COMPILE_TEST
         select USB_PHY
         help
           Say Y here to add support for the Renesas R-Car USB common PHY driver.
@@ -232,7 +217,7 @@ config USB_RCAR_GEN2_PHY
 
 config USB_ULPI
         bool "Generic ULPI Transceiver Driver"
-        depends on ARM
+        depends on ARM || ARM64
         help
           Enable this to support ULPI connected USB OTG transceivers which
           are likely found on embedded boards.
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index f8fa719a31b9..24a91332d4ad 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -3,14 +3,12 @@
 #
 obj-$(CONFIG_USB_PHY)                   += phy.o
 obj-$(CONFIG_OF)                        += of.o
-obj-$(CONFIG_USB_OTG_FSM)               += phy-fsm-usb.o
 
 # transceiver drivers, keep the list sorted
 
 obj-$(CONFIG_AB8500_USB)                += phy-ab8500-usb.o
 obj-$(CONFIG_FSL_USB2_OTG)              += phy-fsl-usb.o
 obj-$(CONFIG_ISP1301_OMAP)              += phy-isp1301-omap.o
-obj-$(CONFIG_MV_U3D_PHY)                += phy-mv-u3d-usb.o
 obj-$(CONFIG_NOP_USB_XCEIV)             += phy-generic.o
 obj-$(CONFIG_TAHVO_USB)                 += phy-tahvo.o
 obj-$(CONFIG_AM335X_CONTROL_USB)        += phy-am335x-control.o
diff --git a/drivers/usb/phy/phy-am335x.c b/drivers/usb/phy/phy-am335x.c
index 12fc3468a01e..585e50cb1980 100644
--- a/drivers/usb/phy/phy-am335x.c
+++ b/drivers/usb/phy/phy-am335x.c
@@ -2,7 +2,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
@@ -13,7 +13,7 @@
 #include "phy-generic.h"
 
 struct am335x_phy {
-        struct usb_phy_gen_xceiv usb_phy_gen;
+        struct usb_phy_generic usb_phy_gen;
         struct phy_control *phy_ctrl;
         int id;
 };
diff --git a/drivers/usb/phy/phy-generic.c b/drivers/usb/phy/phy-generic.c
index bb394980532b..7594e5069ae5 100644
--- a/drivers/usb/phy/phy-generic.c
+++ b/drivers/usb/phy/phy-generic.c
@@ -30,7 +30,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/slab.h>
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
@@ -41,34 +41,25 @@
 
 #include "phy-generic.h"
 
-static struct platform_device *pd;
-
-void usb_nop_xceiv_register(void)
+struct platform_device *usb_phy_generic_register(void)
 {
-        if (pd)
-                return;
-        pd = platform_device_register_simple("usb_phy_gen_xceiv", -1, NULL, 0);
-        if (IS_ERR(pd)) {
-                pr_err("Unable to register generic usb transceiver\n");
-                pd = NULL;
-                return;
-        }
+        return platform_device_register_simple("usb_phy_generic",
+                        PLATFORM_DEVID_AUTO, NULL, 0);
 }
-EXPORT_SYMBOL(usb_nop_xceiv_register);
+EXPORT_SYMBOL_GPL(usb_phy_generic_register);
 
-void usb_nop_xceiv_unregister(void)
+void usb_phy_generic_unregister(struct platform_device *pdev)
 {
-        platform_device_unregister(pd);
-        pd = NULL;
+        platform_device_unregister(pdev);
 }
-EXPORT_SYMBOL(usb_nop_xceiv_unregister);
+EXPORT_SYMBOL_GPL(usb_phy_generic_unregister);
 
 static int nop_set_suspend(struct usb_phy *x, int suspend)
 {
         return 0;
 }
 
-static void nop_reset_set(struct usb_phy_gen_xceiv *nop, int asserted)
+static void nop_reset_set(struct usb_phy_generic *nop, int asserted)
 {
         int value;
 
@@ -87,7 +78,7 @@ static void nop_reset_set(struct usb_phy_gen_xceiv *nop, int asserted)
 
 int usb_gen_phy_init(struct usb_phy *phy)
 {
-        struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
+        struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 
         if (!IS_ERR(nop->vcc)) {
                 if (regulator_enable(nop->vcc))
@@ -106,7 +97,7 @@ EXPORT_SYMBOL_GPL(usb_gen_phy_init);
 
 void usb_gen_phy_shutdown(struct usb_phy *phy)
 {
-        struct usb_phy_gen_xceiv *nop = dev_get_drvdata(phy->dev);
+        struct usb_phy_generic *nop = dev_get_drvdata(phy->dev);
 
         /* Assert RESET */
         nop_reset_set(nop, 1);
@@ -150,8 +141,8 @@ static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
         return 0;
 }
 
-int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                struct usb_phy_gen_xceiv_platform_data *pdata)
+int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
+                struct usb_phy_generic_platform_data *pdata)
 {
         enum usb_phy_type type = USB_PHY_TYPE_USB2;
         int err;
@@ -245,10 +236,10 @@ int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
 }
 EXPORT_SYMBOL_GPL(usb_phy_gen_create_phy);
 
-static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
+static int usb_phy_generic_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
-        struct usb_phy_gen_xceiv        *nop;
+        struct usb_phy_generic  *nop;
         int err;
 
         nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL);
@@ -274,9 +265,9 @@ static int usb_phy_gen_xceiv_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int usb_phy_gen_xceiv_remove(struct platform_device *pdev)
+static int usb_phy_generic_remove(struct platform_device *pdev)
 {
-        struct usb_phy_gen_xceiv *nop = platform_get_drvdata(pdev);
+        struct usb_phy_generic *nop = platform_get_drvdata(pdev);
 
         usb_remove_phy(&nop->phy);
 
@@ -290,29 +281,29 @@ static const struct of_device_id nop_xceiv_dt_ids[] = {
 
 MODULE_DEVICE_TABLE(of, nop_xceiv_dt_ids);
 
-static struct platform_driver usb_phy_gen_xceiv_driver = {
-        .probe          = usb_phy_gen_xceiv_probe,
-        .remove         = usb_phy_gen_xceiv_remove,
+static struct platform_driver usb_phy_generic_driver = {
+        .probe          = usb_phy_generic_probe,
+        .remove         = usb_phy_generic_remove,
         .driver         = {
-                .name   = "usb_phy_gen_xceiv",
+                .name   = "usb_phy_generic",
                 .owner  = THIS_MODULE,
                 .of_match_table = nop_xceiv_dt_ids,
         },
 };
 
-static int __init usb_phy_gen_xceiv_init(void)
+static int __init usb_phy_generic_init(void)
 {
-        return platform_driver_register(&usb_phy_gen_xceiv_driver);
+        return platform_driver_register(&usb_phy_generic_driver);
 }
-subsys_initcall(usb_phy_gen_xceiv_init);
+subsys_initcall(usb_phy_generic_init);
 
-static void __exit usb_phy_gen_xceiv_exit(void)
+static void __exit usb_phy_generic_exit(void)
 {
-        platform_driver_unregister(&usb_phy_gen_xceiv_driver);
+        platform_driver_unregister(&usb_phy_generic_driver);
 }
-module_exit(usb_phy_gen_xceiv_exit);
+module_exit(usb_phy_generic_exit);
 
-MODULE_ALIAS("platform:usb_phy_gen_xceiv");
+MODULE_ALIAS("platform:usb_phy_generic");
 MODULE_AUTHOR("Texas Instruments Inc");
 MODULE_DESCRIPTION("NOP USB Transceiver driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/usb/phy/phy-generic.h b/drivers/usb/phy/phy-generic.h
index 38a81f307b82..d8feacc0b7fb 100644
--- a/drivers/usb/phy/phy-generic.h
+++ b/drivers/usb/phy/phy-generic.h
@@ -1,9 +1,9 @@
 #ifndef _PHY_GENERIC_H_
 #define _PHY_GENERIC_H_
 
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 
-struct usb_phy_gen_xceiv {
+struct usb_phy_generic {
         struct usb_phy phy;
         struct device *dev;
         struct clk *clk;
@@ -15,7 +15,7 @@ struct usb_phy_gen_xceiv {
 int usb_gen_phy_init(struct usb_phy *phy);
 void usb_gen_phy_shutdown(struct usb_phy *phy);
 
-int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_gen_xceiv *nop,
-                struct usb_phy_gen_xceiv_platform_data *pdata);
+int usb_phy_gen_create_phy(struct device *dev, struct usb_phy_generic *nop,
+                struct usb_phy_generic_platform_data *pdata);
 
 #endif
diff --git a/drivers/usb/phy/phy-keystone.c b/drivers/usb/phy/phy-keystone.c
index d762003896c0..f4d722de912b 100644
--- a/drivers/usb/phy/phy-keystone.c
+++ b/drivers/usb/phy/phy-keystone.c
@@ -18,7 +18,7 @@
 
 #include <linux/module.h>
 #include <linux/platform_device.h>
-#include <linux/usb/usb_phy_gen_xceiv.h>
+#include <linux/usb/usb_phy_generic.h>
 #include <linux/io.h>
 #include <linux/of.h>
 
@@ -35,7 +35,7 @@
 #define PHY_REF_SSP_EN                  BIT(29)
 
 struct keystone_usbphy {
-        struct usb_phy_gen_xceiv        usb_phy_gen;
+        struct usb_phy_generic  usb_phy_gen;
         void __iomem                    *phy_ctrl;
 };
 
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index 5b37b81f2ef6..ced34f39bdd4 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -30,9 +30,13 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/pm_runtime.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/reset.h>
 
 #include <linux/usb.h>
 #include <linux/usb/otg.h>
+#include <linux/usb/of.h>
 #include <linux/usb/ulpi.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/hcd.h>
@@ -44,6 +48,7 @@
 #define DRIVER_NAME     "msm_otg"
 
 #define ULPI_IO_TIMEOUT_USEC    (10 * 1000)
+#define LINK_RESET_TIMEOUT_USEC (250 * 1000)
 
 #define USB_PHY_3P3_VOL_MIN     3050000 /* uV */
 #define USB_PHY_3P3_VOL_MAX     3300000 /* uV */
@@ -57,48 +62,38 @@
 
 #define USB_PHY_VDD_DIG_VOL_MIN 1000000 /* uV */
 #define USB_PHY_VDD_DIG_VOL_MAX 1320000 /* uV */
+#define USB_PHY_SUSP_DIG_VOL    500000  /* uV */
 
-static struct regulator *hsusb_3p3;
-static struct regulator *hsusb_1p8;
-static struct regulator *hsusb_vddcx;
+enum vdd_levels {
+        VDD_LEVEL_NONE = 0,
+        VDD_LEVEL_MIN,
+        VDD_LEVEL_MAX,
+};
 
 static int msm_hsusb_init_vddcx(struct msm_otg *motg, int init)
 {
         int ret = 0;
 
         if (init) {
-                hsusb_vddcx = regulator_get(motg->phy.dev, "HSUSB_VDDCX");
-                if (IS_ERR(hsusb_vddcx)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb vddcx\n");
-                        return PTR_ERR(hsusb_vddcx);
-                }
-
-                ret = regulator_set_voltage(hsusb_vddcx,
-                                USB_PHY_VDD_DIG_VOL_MIN,
-                                USB_PHY_VDD_DIG_VOL_MAX);
+                ret = regulator_set_voltage(motg->vddcx,
+                                motg->vdd_levels[VDD_LEVEL_MIN],
+                                motg->vdd_levels[VDD_LEVEL_MAX]);
                 if (ret) {
-                        dev_err(motg->phy.dev, "unable to set the voltage "
-                                        "for hsusb vddcx\n");
-                        regulator_put(hsusb_vddcx);
+                        dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
                         return ret;
                 }
 
-                ret = regulator_enable(hsusb_vddcx);
-                if (ret) {
+                ret = regulator_enable(motg->vddcx);
+                if (ret)
                         dev_err(motg->phy.dev, "unable to enable hsusb vddcx\n");
-                        regulator_put(hsusb_vddcx);
-                }
         } else {
-                ret = regulator_set_voltage(hsusb_vddcx, 0,
-                        USB_PHY_VDD_DIG_VOL_MAX);
+                ret = regulator_set_voltage(motg->vddcx, 0,
+                                motg->vdd_levels[VDD_LEVEL_MAX]);
                 if (ret)
-                        dev_err(motg->phy.dev, "unable to set the voltage "
-                                        "for hsusb vddcx\n");
-                ret = regulator_disable(hsusb_vddcx);
+                        dev_err(motg->phy.dev, "Cannot set vddcx voltage\n");
+                ret = regulator_disable(motg->vddcx);
                 if (ret)
                         dev_err(motg->phy.dev, "unable to disable hsusb vddcx\n");
-
-                regulator_put(hsusb_vddcx);
         }
 
         return ret;
@@ -109,98 +104,67 @@ static int msm_hsusb_ldo_init(struct msm_otg *motg, int init)
         int rc = 0;
 
         if (init) {
-                hsusb_3p3 = regulator_get(motg->phy.dev, "HSUSB_3p3");
-                if (IS_ERR(hsusb_3p3)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb 3p3\n");
-                        return PTR_ERR(hsusb_3p3);
-                }
-
-                rc = regulator_set_voltage(hsusb_3p3, USB_PHY_3P3_VOL_MIN,
+                rc = regulator_set_voltage(motg->v3p3, USB_PHY_3P3_VOL_MIN,
                                 USB_PHY_3P3_VOL_MAX);
                 if (rc) {
-                        dev_err(motg->phy.dev, "unable to set voltage level "
-                                        "for hsusb 3p3\n");
-                        goto put_3p3;
+                        dev_err(motg->phy.dev, "Cannot set v3p3 voltage\n");
+                        goto exit;
                 }
-                rc = regulator_enable(hsusb_3p3);
+                rc = regulator_enable(motg->v3p3);
                 if (rc) {
                         dev_err(motg->phy.dev, "unable to enable the hsusb 3p3\n");
-                        goto put_3p3;
+                        goto exit;
                 }
-                hsusb_1p8 = regulator_get(motg->phy.dev, "HSUSB_1p8");
-                if (IS_ERR(hsusb_1p8)) {
-                        dev_err(motg->phy.dev, "unable to get hsusb 1p8\n");
-                        rc = PTR_ERR(hsusb_1p8);
-                        goto disable_3p3;
-                }
-                rc = regulator_set_voltage(hsusb_1p8, USB_PHY_1P8_VOL_MIN,
+                rc = regulator_set_voltage(motg->v1p8, USB_PHY_1P8_VOL_MIN,
                                 USB_PHY_1P8_VOL_MAX);
                 if (rc) {
-                        dev_err(motg->phy.dev, "unable to set voltage level "
-                                        "for hsusb 1p8\n");
-                        goto put_1p8;
+                        dev_err(motg->phy.dev, "Cannot set v1p8 voltage\n");
+                        goto disable_3p3;
                 }
-                rc = regulator_enable(hsusb_1p8);
+                rc = regulator_enable(motg->v1p8);
                 if (rc) {
                         dev_err(motg->phy.dev, "unable to enable the hsusb 1p8\n");
-                        goto put_1p8;
+                        goto disable_3p3;
                 }
 
                 return 0;
         }
 
-        regulator_disable(hsusb_1p8);
-put_1p8:
-        regulator_put(hsusb_1p8);
+        regulator_disable(motg->v1p8);
 disable_3p3:
-        regulator_disable(hsusb_3p3);
-put_3p3:
-        regulator_put(hsusb_3p3);
+        regulator_disable(motg->v3p3);
+exit:
         return rc;
 }
 
-static int msm_hsusb_ldo_set_mode(int on)
+static int msm_hsusb_ldo_set_mode(struct msm_otg *motg, int on)
 {
         int ret = 0;
 
-        if (!hsusb_1p8 || IS_ERR(hsusb_1p8)) {
-                pr_err("%s: HSUSB_1p8 is not initialized\n", __func__);
-                return -ENODEV;
-        }
-
-        if (!hsusb_3p3 || IS_ERR(hsusb_3p3)) {
-                pr_err("%s: HSUSB_3p3 is not initialized\n", __func__);
-                return -ENODEV;
-        }
-
         if (on) {
-                ret = regulator_set_optimum_mode(hsusb_1p8,
+                ret = regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_HPM_LOAD);
                 if (ret < 0) {
-                        pr_err("%s: Unable to set HPM of the regulator "
-                                "HSUSB_1p8\n", __func__);
+                        pr_err("Could not set HPM for v1p8\n");
                         return ret;
                 }
-                ret = regulator_set_optimum_mode(hsusb_3p3,
+                ret = regulator_set_optimum_mode(motg->v3p3,
                                 USB_PHY_3P3_HPM_LOAD);
                 if (ret < 0) {
-                        pr_err("%s: Unable to set HPM of the regulator "
-                                "HSUSB_3p3\n", __func__);
-                        regulator_set_optimum_mode(hsusb_1p8,
+                        pr_err("Could not set HPM for v3p3\n");
+                        regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_LPM_LOAD);
                         return ret;
                 }
         } else {
-                ret = regulator_set_optimum_mode(hsusb_1p8,
+                ret = regulator_set_optimum_mode(motg->v1p8,
                                 USB_PHY_1P8_LPM_LOAD);
                 if (ret < 0)
-                        pr_err("%s: Unable to set LPM of the regulator "
-                                "HSUSB_1p8\n", __func__);
-                ret = regulator_set_optimum_mode(hsusb_3p3,
+                        pr_err("Could not set LPM for v1p8\n");
+                ret = regulator_set_optimum_mode(motg->v3p3,
                                 USB_PHY_3P3_LPM_LOAD);
                 if (ret < 0)
-                        pr_err("%s: Unable to set LPM of the regulator "
-                                "HSUSB_3p3\n", __func__);
+                        pr_err("Could not set LPM for v3p3\n");
         }
 
         pr_debug("reg (%s)\n", on ? "HPM" : "LPM");
@@ -265,27 +229,47 @@ static struct usb_phy_io_ops msm_otg_io_ops = {
 static void ulpi_init(struct msm_otg *motg)
 {
         struct msm_otg_platform_data *pdata = motg->pdata;
-        int *seq = pdata->phy_init_seq;
+        int *seq = pdata->phy_init_seq, idx;
+        u32 addr = ULPI_EXT_VENDOR_SPECIFIC;
 
-        if (!seq)
-                return;
+        for (idx = 0; idx < pdata->phy_init_sz; idx++) {
+                if (seq[idx] == -1)
+                        continue;
 
-        while (seq[0] >= 0) {
                 dev_vdbg(motg->phy.dev, "ulpi: write 0x%02x to 0x%02x\n",
-                                seq[0], seq[1]);
-                ulpi_write(&motg->phy, seq[0], seq[1]);
-                seq += 2;
+                                seq[idx], addr + idx);
+                ulpi_write(&motg->phy, seq[idx], addr + idx);
         }
 }
 
+static int msm_phy_notify_disconnect(struct usb_phy *phy,
+                                   enum usb_device_speed speed)
+{
+        int val;
+
+        /*
+         * Put the transceiver in non-driving mode. Otherwise host
+         * may not detect soft-disconnection.
+         */
+        val = ulpi_read(phy, ULPI_FUNC_CTRL);
+        val &= ~ULPI_FUNC_CTRL_OPMODE_MASK;
+        val |= ULPI_FUNC_CTRL_OPMODE_NONDRIVING;
+        ulpi_write(phy, val, ULPI_FUNC_CTRL);
+
+        return 0;
+}
+
 static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
 {
-        int ret = 0;
+        int ret;
 
-        if (!motg->pdata->link_clk_reset)
-                return ret;
+        if (motg->pdata->link_clk_reset)
+                ret = motg->pdata->link_clk_reset(motg->clk, assert);
+        else if (assert)
+                ret = reset_control_assert(motg->link_rst);
+        else
+                ret = reset_control_deassert(motg->link_rst);
 
-        ret = motg->pdata->link_clk_reset(motg->clk, assert);
         if (ret)
                 dev_err(motg->phy.dev, "usb link clk reset %s failed\n",
                         assert ? "assert" : "deassert");
@@ -295,111 +279,150 @@ static int msm_otg_link_clk_reset(struct msm_otg *motg, bool assert)
 
 static int msm_otg_phy_clk_reset(struct msm_otg *motg)
 {
-        int ret = 0;
+        int ret;
 
-        if (!motg->pdata->phy_clk_reset)
-                return ret;
+        if (motg->pdata->phy_clk_reset)
+                ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
+        else
+                ret = reset_control_reset(motg->phy_rst);
 
-        ret = motg->pdata->phy_clk_reset(motg->phy_reset_clk);
         if (ret)
                 dev_err(motg->phy.dev, "usb phy clk reset failed\n");
 
         return ret;
 }
 
-static int msm_otg_phy_reset(struct msm_otg *motg)
+static int msm_link_reset(struct msm_otg *motg)
 {
         u32 val;
         int ret;
-        int retries;
 
         ret = msm_otg_link_clk_reset(motg, 1);
         if (ret)
                 return ret;
-        ret = msm_otg_phy_clk_reset(motg);
-        if (ret)
-                return ret;
+
+        /* wait for 1ms delay as suggested in HPG. */
+        usleep_range(1000, 1200);
+
         ret = msm_otg_link_clk_reset(motg, 0);
         if (ret)
                 return ret;
 
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
+
+        /* put transceiver in serial mode as part of reset */
         val = readl(USB_PORTSC) & ~PORTSC_PTS_MASK;
-        writel(val | PORTSC_PTS_ULPI, USB_PORTSC);
+        writel(val | PORTSC_PTS_SERIAL, USB_PORTSC);
 
-        for (retries = 3; retries > 0; retries--) {
-                ret = ulpi_write(&motg->phy, ULPI_FUNC_CTRL_SUSPENDM,
-                                ULPI_CLR(ULPI_FUNC_CTRL));
-                if (!ret)
-                        break;
-                ret = msm_otg_phy_clk_reset(motg);
-                if (ret)
-                        return ret;
-        }
-        if (!retries)
-                return -ETIMEDOUT;
+        return 0;
+}
 
-        /* This reset calibrates the phy, if the above write succeeded */
-        ret = msm_otg_phy_clk_reset(motg);
-        if (ret)
-                return ret;
+static int msm_otg_reset(struct usb_phy *phy)
+{
+        struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
+        int cnt = 0;
 
-        for (retries = 3; retries > 0; retries--) {
-                ret = ulpi_read(&motg->phy, ULPI_DEBUG);
-                if (ret != -ETIMEDOUT)
+        writel(USBCMD_RESET, USB_USBCMD);
+        while (cnt < LINK_RESET_TIMEOUT_USEC) {
+                if (!(readl(USB_USBCMD) & USBCMD_RESET))
                         break;
-                ret = msm_otg_phy_clk_reset(motg);
-                if (ret)
-                        return ret;
+                udelay(1);
+                cnt++;
         }
-        if (!retries)
+        if (cnt >= LINK_RESET_TIMEOUT_USEC)
                 return -ETIMEDOUT;
 
-        dev_info(motg->phy.dev, "phy_reset: success\n");
+        /* select ULPI phy and clear other status/control bits in PORTSC */
+        writel(PORTSC_PTS_ULPI, USB_PORTSC);
+
+        writel(0x0, USB_AHBBURST);
+        writel(0x08, USB_AHBMODE);
+
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
         return 0;
 }
 
-#define LINK_RESET_TIMEOUT_USEC         (250 * 1000)
-static int msm_otg_reset(struct usb_phy *phy)
+static void msm_phy_reset(struct msm_otg *motg)
+{
+        void __iomem *addr;
+
+        if (motg->pdata->phy_type != SNPS_28NM_INTEGRATED_PHY) {
+                msm_otg_phy_clk_reset(motg);
+                return;
+        }
+
+        addr = USB_PHY_CTRL;
+        if (motg->phy_number)
+                addr = USB_PHY_CTRL2;
+
+        /* Assert USB PHY_POR */
+        writel(readl(addr) | PHY_POR_ASSERT, addr);
+
+        /*
+         * wait for minimum 10 microseconds as suggested in HPG.
+         * Use a slightly larger value since the exact value didn't
+         * work 100% of the time.
+         */
+        udelay(12);
+
+        /* Deassert USB PHY_POR */
+        writel(readl(addr) & ~PHY_POR_ASSERT, addr);
+}
+
+static int msm_usb_reset(struct usb_phy *phy)
 {
         struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
-        struct msm_otg_platform_data *pdata = motg->pdata;
-        int cnt = 0;
         int ret;
-        u32 val = 0;
-        u32 ulpi_val = 0;
 
-        ret = msm_otg_phy_reset(motg);
+        if (!IS_ERR(motg->core_clk))
+                clk_prepare_enable(motg->core_clk);
+
+        ret = msm_link_reset(motg);
         if (ret) {
                 dev_err(phy->dev, "phy_reset failed\n");
                 return ret;
         }
 
-        ulpi_init(motg);
-
-        writel(USBCMD_RESET, USB_USBCMD);
-        while (cnt < LINK_RESET_TIMEOUT_USEC) {
-                if (!(readl(USB_USBCMD) & USBCMD_RESET))
-                        break;
-                udelay(1);
-                cnt++;
+        ret = msm_otg_reset(&motg->phy);
+        if (ret) {
+                dev_err(phy->dev, "link reset failed\n");
+                return ret;
         }
-        if (cnt >= LINK_RESET_TIMEOUT_USEC)
-                return -ETIMEDOUT;
-
-        /* select ULPI phy */
-        writel(0x80000000, USB_PORTSC);
 
         msleep(100);
 
-        writel(0x0, USB_AHBBURST);
-        writel(0x00, USB_AHBMODE);
+        /* Reset USB PHY after performing USB Link RESET */
+        msm_phy_reset(motg);
+
+        if (!IS_ERR(motg->core_clk))
+                clk_disable_unprepare(motg->core_clk);
+
+        return 0;
+}
+
+static int msm_phy_init(struct usb_phy *phy)
+{
+        struct msm_otg *motg = container_of(phy, struct msm_otg, phy);
+        struct msm_otg_platform_data *pdata = motg->pdata;
+        u32 val, ulpi_val = 0;
+
+        /* Program USB PHY Override registers. */
+        ulpi_init(motg);
+
+        /*
+         * It is recommended in HPG to reset USB PHY after programming
+         * USB PHY Override registers.
+         */
+        msm_phy_reset(motg);
 
         if (pdata->otg_control == OTG_PHY_CONTROL) {
                 val = readl(USB_OTGSC);
-                if (pdata->mode == USB_OTG) {
+                if (pdata->mode == USB_DR_MODE_OTG) {
                         ulpi_val = ULPI_INT_IDGRD | ULPI_INT_SESS_VALID;
                         val |= OTGSC_IDIE | OTGSC_BSVIE;
-                } else if (pdata->mode == USB_PERIPHERAL) {
+                } else if (pdata->mode == USB_DR_MODE_PERIPHERAL) {
                         ulpi_val = ULPI_INT_SESS_VALID;
                         val |= OTGSC_BSVIE;
                 }
@@ -408,6 +431,9 @@ static int msm_otg_reset(struct usb_phy *phy)
                 ulpi_write(phy, ulpi_val, ULPI_USB_INT_EN_FALL);
         }
 
+        if (motg->phy_number)
+                writel(readl(USB_PHY_CTRL2) | BIT(16), USB_PHY_CTRL2);
+
         return 0;
 }
 
@@ -416,22 +442,20 @@ static int msm_otg_reset(struct usb_phy *phy)
 
 #ifdef CONFIG_PM
 
-#define USB_PHY_SUSP_DIG_VOL  500000
-static int msm_hsusb_config_vddcx(int high)
+static int msm_hsusb_config_vddcx(struct msm_otg *motg, int high)
 {
-        int max_vol = USB_PHY_VDD_DIG_VOL_MAX;
+        int max_vol = motg->vdd_levels[VDD_LEVEL_MAX];
         int min_vol;
         int ret;
 
         if (high)
-                min_vol = USB_PHY_VDD_DIG_VOL_MIN;
+                min_vol = motg->vdd_levels[VDD_LEVEL_MIN];
         else
-                min_vol = USB_PHY_SUSP_DIG_VOL;
+                min_vol = motg->vdd_levels[VDD_LEVEL_NONE];
 
-        ret = regulator_set_voltage(hsusb_vddcx, min_vol, max_vol);
+        ret = regulator_set_voltage(motg->vddcx, min_vol, max_vol);
         if (ret) {
-                pr_err("%s: unable to set the voltage for regulator "
-                        "HSUSB_VDDCX\n", __func__);
+                pr_err("Cannot set vddcx voltage\n");
                 return ret;
         }
 
@@ -445,6 +469,7 @@ static int msm_otg_suspend(struct msm_otg *motg)
         struct usb_phy *phy = &motg->phy;
         struct usb_bus *bus = phy->otg->host;
         struct msm_otg_platform_data *pdata = motg->pdata;
+        void __iomem *addr;
         int cnt = 0;
 
         if (atomic_read(&motg->in_lpm))
@@ -504,22 +529,23 @@ static int msm_otg_suspend(struct msm_otg *motg)
          */
         writel(readl(USB_USBCMD) | ASYNC_INTR_CTRL | ULPI_STP_CTRL, USB_USBCMD);
 
+        addr = USB_PHY_CTRL;
+        if (motg->phy_number)
+                addr = USB_PHY_CTRL2;
+
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL)
-                writel(readl(USB_PHY_CTRL) | PHY_RETEN, USB_PHY_CTRL);
+                writel(readl(addr) | PHY_RETEN, addr);
 
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_disable_unprepare(motg->core_clk);
 
-        if (!IS_ERR(motg->pclk_src))
-                clk_disable_unprepare(motg->pclk_src);
-
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL) {
-                msm_hsusb_ldo_set_mode(0);
-                msm_hsusb_config_vddcx(0);
+                msm_hsusb_ldo_set_mode(motg, 0);
+                msm_hsusb_config_vddcx(motg, 0);
         }
 
         if (device_may_wakeup(phy->dev))
@@ -539,25 +565,28 @@ static int msm_otg_resume(struct msm_otg *motg)
 {
         struct usb_phy *phy = &motg->phy;
         struct usb_bus *bus = phy->otg->host;
+        void __iomem *addr;
         int cnt = 0;
         unsigned temp;
 
         if (!atomic_read(&motg->in_lpm))
                 return 0;
 
-        if (!IS_ERR(motg->pclk_src))
-                clk_prepare_enable(motg->pclk_src);
-
         clk_prepare_enable(motg->pclk);
         clk_prepare_enable(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_prepare_enable(motg->core_clk);
 
         if (motg->pdata->phy_type == SNPS_28NM_INTEGRATED_PHY &&
                         motg->pdata->otg_control == OTG_PMIC_CONTROL) {
-                msm_hsusb_ldo_set_mode(1);
-                msm_hsusb_config_vddcx(1);
-                writel(readl(USB_PHY_CTRL) & ~PHY_RETEN, USB_PHY_CTRL);
+
+                addr = USB_PHY_CTRL;
+                if (motg->phy_number)
+                        addr = USB_PHY_CTRL2;
+
+                msm_hsusb_ldo_set_mode(motg, 1);
+                msm_hsusb_config_vddcx(motg, 1);
+                writel(readl(addr) & ~PHY_RETEN, addr);
         }
 
         temp = readl(USB_USBCMD);
@@ -586,8 +615,7 @@ static int msm_otg_resume(struct msm_otg *motg)
                  * PHY. USB state can not be restored. Re-insertion
                  * of USB cable is the only way to get USB working.
                  */
-                dev_err(phy->dev, "Unable to resume USB."
-                                "Re-plugin the cable\n");
+                dev_err(phy->dev, "Unable to resume USB. Re-plugin the cable\n");
                 msm_otg_reset(phy);
         }
 
@@ -687,7 +715,7 @@ static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
          * Fail host registration if this board can support
          * only peripheral configuration.
          */
-        if (motg->pdata->mode == USB_PERIPHERAL) {
+        if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL) {
                 dev_info(otg->phy->dev, "Host mode is not supported\n");
                 return -ENODEV;
         }
@@ -716,7 +744,7 @@ static int msm_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
          * Kick the state machine work, if peripheral is not supported
          * or peripheral is already registered with us.
          */
-        if (motg->pdata->mode == USB_HOST || otg->gadget) {
+        if (motg->pdata->mode == USB_DR_MODE_HOST || otg->gadget) {
                 pm_runtime_get_sync(otg->phy->dev);
                 schedule_work(&motg->sm_work);
         }
@@ -760,7 +788,7 @@ static int msm_otg_set_peripheral(struct usb_otg *otg,
          * Fail peripheral registration if this board can support
          * only host configuration.
          */
-        if (motg->pdata->mode == USB_HOST) {
+        if (motg->pdata->mode == USB_DR_MODE_HOST) {
                 dev_info(otg->phy->dev, "Peripheral mode is not supported\n");
                 return -ENODEV;
         }
@@ -785,7 +813,7 @@ static int msm_otg_set_peripheral(struct usb_otg *otg,
          * Kick the state machine work, if host is not supported
          * or host is already registered with us.
          */
-        if (motg->pdata->mode == USB_PERIPHERAL || otg->host) {
+        if (motg->pdata->mode == USB_DR_MODE_PERIPHERAL || otg->host) {
                 pm_runtime_get_sync(otg->phy->dev);
                 schedule_work(&motg->sm_work);
         }
@@ -1106,7 +1134,7 @@ static void msm_otg_init_sm(struct msm_otg *motg)
         u32 otgsc = readl(USB_OTGSC);
 
         switch (pdata->mode) {
-        case USB_OTG:
+        case USB_DR_MODE_OTG:
                 if (pdata->otg_control == OTG_PHY_CONTROL) {
                         if (otgsc & OTGSC_ID)
                                 set_bit(ID, &motg->inputs);
@@ -1118,21 +1146,14 @@ static void msm_otg_init_sm(struct msm_otg *motg)
                         else
                                 clear_bit(B_SESS_VLD, &motg->inputs);
                 } else if (pdata->otg_control == OTG_USER_CONTROL) {
-                        if (pdata->default_mode == USB_HOST) {
-                                clear_bit(ID, &motg->inputs);
-                        } else if (pdata->default_mode == USB_PERIPHERAL) {
-                                set_bit(ID, &motg->inputs);
-                                set_bit(B_SESS_VLD, &motg->inputs);
-                        } else {
                                 set_bit(ID, &motg->inputs);
                                 clear_bit(B_SESS_VLD, &motg->inputs);
-                        }
                 }
                 break;
-        case USB_HOST:
+        case USB_DR_MODE_HOST:
                 clear_bit(ID, &motg->inputs);
                 break;
-        case USB_PERIPHERAL:
+        case USB_DR_MODE_PERIPHERAL:
                 set_bit(ID, &motg->inputs);
                 if (otgsc & OTGSC_BSV)
                         set_bit(B_SESS_VLD, &motg->inputs);
@@ -1282,13 +1303,13 @@ static int msm_otg_mode_show(struct seq_file *s, void *unused)
 
         switch (otg->phy->state) {
         case OTG_STATE_A_HOST:
-                seq_printf(s, "host\n");
+                seq_puts(s, "host\n");
                 break;
         case OTG_STATE_B_PERIPHERAL:
-                seq_printf(s, "peripheral\n");
+                seq_puts(s, "peripheral\n");
                 break;
         default:
-                seq_printf(s, "none\n");
+                seq_puts(s, "none\n");
                 break;
         }
 
@@ -1308,7 +1329,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
         char buf[16];
         struct usb_otg *otg = motg->phy.otg;
         int status = count;
-        enum usb_mode_type req_mode;
+        enum usb_dr_mode req_mode;
 
         memset(buf, 0x00, sizeof(buf));
 
@@ -1318,18 +1339,18 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
         }
 
         if (!strncmp(buf, "host", 4)) {
-                req_mode = USB_HOST;
+                req_mode = USB_DR_MODE_HOST;
         } else if (!strncmp(buf, "peripheral", 10)) {
-                req_mode = USB_PERIPHERAL;
+                req_mode = USB_DR_MODE_PERIPHERAL;
         } else if (!strncmp(buf, "none", 4)) {
-                req_mode = USB_NONE;
+                req_mode = USB_DR_MODE_UNKNOWN;
         } else {
                 status = -EINVAL;
                 goto out;
         }
 
         switch (req_mode) {
-        case USB_NONE:
+        case USB_DR_MODE_UNKNOWN:
                 switch (otg->phy->state) {
                 case OTG_STATE_A_HOST:
                 case OTG_STATE_B_PERIPHERAL:
@@ -1340,7 +1361,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
                         goto out;
                 }
                 break;
-        case USB_PERIPHERAL:
+        case USB_DR_MODE_PERIPHERAL:
                 switch (otg->phy->state) {
                 case OTG_STATE_B_IDLE:
                 case OTG_STATE_A_HOST:
@@ -1351,7 +1372,7 @@ static ssize_t msm_otg_mode_write(struct file *file, const char __user *ubuf,
                         goto out;
                 }
                 break;
-        case USB_HOST:
+        case USB_DR_MODE_HOST:
                 switch (otg->phy->state) {
                 case OTG_STATE_B_IDLE:
                 case OTG_STATE_B_PERIPHERAL:
@@ -1406,74 +1427,154 @@ static void msm_otg_debugfs_cleanup(void)
         debugfs_remove(msm_otg_dbg_root);
 }
 
-static int __init msm_otg_probe(struct platform_device *pdev)
+static struct of_device_id msm_otg_dt_match[] = {
+        {
+                .compatible = "qcom,usb-otg-ci",
+                .data = (void *) CI_45NM_INTEGRATED_PHY
+        },
+        {
+                .compatible = "qcom,usb-otg-snps",
+                .data = (void *) SNPS_28NM_INTEGRATED_PHY
+        },
+        { }
+};
+MODULE_DEVICE_TABLE(of, msm_otg_dt_match);
+
+static int msm_otg_read_dt(struct platform_device *pdev, struct msm_otg *motg)
+{
+        struct msm_otg_platform_data *pdata;
+        const struct of_device_id *id;
+        struct device_node *node = pdev->dev.of_node;
+        struct property *prop;
+        int len, ret, words;
+        u32 val, tmp[3];
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        motg->pdata = pdata;
+
+        id = of_match_device(msm_otg_dt_match, &pdev->dev);
+        pdata->phy_type = (enum msm_usb_phy_type) id->data;
+
+        motg->link_rst = devm_reset_control_get(&pdev->dev, "link");
+        if (IS_ERR(motg->link_rst))
+                return PTR_ERR(motg->link_rst);
+
+        motg->phy_rst = devm_reset_control_get(&pdev->dev, "phy");
+        if (IS_ERR(motg->phy_rst))
+                return PTR_ERR(motg->phy_rst);
+
+        pdata->mode = of_usb_get_dr_mode(node);
+        if (pdata->mode == USB_DR_MODE_UNKNOWN)
+                pdata->mode = USB_DR_MODE_OTG;
+
+        pdata->otg_control = OTG_PHY_CONTROL;
+        if (!of_property_read_u32(node, "qcom,otg-control", &val))
+                if (val == OTG_PMIC_CONTROL)
+                        pdata->otg_control = val;
+
+        if (!of_property_read_u32(node, "qcom,phy-num", &val) && val < 2)
+                motg->phy_number = val;
+
+        motg->vdd_levels[VDD_LEVEL_NONE] = USB_PHY_SUSP_DIG_VOL;
+        motg->vdd_levels[VDD_LEVEL_MIN] = USB_PHY_VDD_DIG_VOL_MIN;
+        motg->vdd_levels[VDD_LEVEL_MAX] = USB_PHY_VDD_DIG_VOL_MAX;
+
+        if (of_get_property(node, "qcom,vdd-levels", &len) &&
+            len == sizeof(tmp)) {
+                of_property_read_u32_array(node, "qcom,vdd-levels",
+                                           tmp, len / sizeof(*tmp));
+                motg->vdd_levels[VDD_LEVEL_NONE] = tmp[VDD_LEVEL_NONE];
+                motg->vdd_levels[VDD_LEVEL_MIN] = tmp[VDD_LEVEL_MIN];
+                motg->vdd_levels[VDD_LEVEL_MAX] = tmp[VDD_LEVEL_MAX];
+        }
+
+        prop = of_find_property(node, "qcom,phy-init-sequence", &len);
+        if (!prop || !len)
+                return 0;
+
+        words = len / sizeof(u32);
+
+        if (words >= ULPI_EXT_VENDOR_SPECIFIC) {
+                dev_warn(&pdev->dev, "Too big PHY init sequence %d\n", words);
+                return 0;
+        }
+
+        pdata->phy_init_seq = devm_kzalloc(&pdev->dev, len, GFP_KERNEL);
+        if (!pdata->phy_init_seq) {
+                dev_warn(&pdev->dev, "No space for PHY init sequence\n");
+                return 0;
+        }
+
+        ret = of_property_read_u32_array(node, "qcom,phy-init-sequence",
+                                         pdata->phy_init_seq, words);
+        if (!ret)
+                pdata->phy_init_sz = words;
+
+        return 0;
+}
+
+static int msm_otg_probe(struct platform_device *pdev)
 {
+        struct regulator_bulk_data regs[3];
         int ret = 0;
+        struct device_node *np = pdev->dev.of_node;
+        struct msm_otg_platform_data *pdata;
         struct resource *res;
         struct msm_otg *motg;
         struct usb_phy *phy;
+        void __iomem *phy_select;
 
-        dev_info(&pdev->dev, "msm_otg probe\n");
-        if (!dev_get_platdata(&pdev->dev)) {
-                dev_err(&pdev->dev, "No platform data given. Bailing out\n");
-                return -ENODEV;
-        }
-
-        motg = kzalloc(sizeof(struct msm_otg), GFP_KERNEL);
+        motg = devm_kzalloc(&pdev->dev, sizeof(struct msm_otg), GFP_KERNEL);
         if (!motg) {
                 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
                 return -ENOMEM;
         }
 
-        motg->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
+        pdata = dev_get_platdata(&pdev->dev);
+        if (!pdata) {
+                if (!np)
+                        return -ENXIO;
+                ret = msm_otg_read_dt(pdev, motg);
+                if (ret)
+                        return ret;
+        }
+
+        motg->phy.otg = devm_kzalloc(&pdev->dev, sizeof(struct usb_otg),
+                                     GFP_KERNEL);
         if (!motg->phy.otg) {
                 dev_err(&pdev->dev, "unable to allocate msm_otg\n");
-                ret = -ENOMEM;
-                goto free_motg;
+                return -ENOMEM;
         }
 
-        motg->pdata = dev_get_platdata(&pdev->dev);
         phy = &motg->phy;
         phy->dev = &pdev->dev;
 
-        motg->phy_reset_clk = clk_get(&pdev->dev, "usb_phy_clk");
+        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");
-                ret = PTR_ERR(motg->phy_reset_clk);
-                goto free_motg;
+                return PTR_ERR(motg->phy_reset_clk);
         }
 
-        motg->clk = clk_get(&pdev->dev, "usb_hs_clk");
+        motg->clk = devm_clk_get(&pdev->dev, np ? "core" : "usb_hs_clk");
         if (IS_ERR(motg->clk)) {
                 dev_err(&pdev->dev, "failed to get usb_hs_clk\n");
-                ret = PTR_ERR(motg->clk);
-                goto put_phy_reset_clk;
+                return PTR_ERR(motg->clk);
         }
-        clk_set_rate(motg->clk, 60000000);
 
         /*
          * If USB Core is running its protocol engine based on CORE CLK,
          * CORE CLK  must be running at >55Mhz for correct HSUSB
          * operation and USB core cannot tolerate frequency changes on
-         * CORE CLK. For such USB cores, vote for maximum clk frequency
-         * on pclk source
+         * CORE CLK.
          */
-         if (motg->pdata->pclk_src_name) {
-                motg->pclk_src = clk_get(&pdev->dev,
-                        motg->pdata->pclk_src_name);
-                if (IS_ERR(motg->pclk_src))
-                        goto put_clk;
-                clk_set_rate(motg->pclk_src, INT_MAX);
-                clk_prepare_enable(motg->pclk_src);
-        } else
-                motg->pclk_src = ERR_PTR(-ENOENT);
-
-
-        motg->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
+        motg->pclk = devm_clk_get(&pdev->dev, np ? "iface" : "usb_hs_pclk");
         if (IS_ERR(motg->pclk)) {
                 dev_err(&pdev->dev, "failed to get usb_hs_pclk\n");
-                ret = PTR_ERR(motg->pclk);
-                goto put_pclk_src;
+                return PTR_ERR(motg->pclk);
         }
 
         /*
@@ -1481,69 +1582,90 @@ static int __init msm_otg_probe(struct platform_device *pdev)
          * clock is introduced to remove the dependency on AXI
          * bus frequency.
          */
-        motg->core_clk = clk_get(&pdev->dev, "usb_hs_core_clk");
-        if (IS_ERR(motg->core_clk))
-                motg->core_clk = NULL;
+        motg->core_clk = devm_clk_get(&pdev->dev,
+                                      np ? "alt_core" : "usb_hs_core_clk");
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "failed to get platform resource mem\n");
-                ret = -ENODEV;
-                goto put_core_clk;
-        }
+        if (!res)
+                return -EINVAL;
+        motg->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
+        if (!motg->regs)
+                return -ENOMEM;
 
-        motg->regs = ioremap(res->start, resource_size(res));
-        if (!motg->regs) {
-                dev_err(&pdev->dev, "ioremap failed\n");
-                ret = -ENOMEM;
-                goto put_core_clk;
+        /*
+         * NOTE: The PHYs can be multiplexed between the chipidea controller
+         * and the dwc3 controller, using a single bit. It is important that
+         * the dwc3 driver does not set this bit in an incompatible way.
+         */
+        if (motg->phy_number) {
+                phy_select = devm_ioremap_nocache(&pdev->dev, USB2_PHY_SEL, 4);
+                if (IS_ERR(phy_select))
+                        return PTR_ERR(phy_select);
+                /* Enable second PHY with the OTG port */
+                writel(0x1, phy_select);
         }
+
         dev_info(&pdev->dev, "OTG regs = %p\n", motg->regs);
 
         motg->irq = platform_get_irq(pdev, 0);
-        if (!motg->irq) {
+        if (motg->irq < 0) {
                 dev_err(&pdev->dev, "platform_get_irq failed\n");
-                ret = -ENODEV;
-                goto free_regs;
+                return motg->irq;
         }
 
+        regs[0].supply = "vddcx";
+        regs[1].supply = "v3p3";
+        regs[2].supply = "v1p8";
+
+        ret = devm_regulator_bulk_get(motg->phy.dev, ARRAY_SIZE(regs), regs);
+        if (ret)
+                return ret;
+
+        motg->vddcx = regs[0].consumer;
+        motg->v3p3  = regs[1].consumer;
+        motg->v1p8  = regs[2].consumer;
+
+        clk_set_rate(motg->clk, 60000000);
+
         clk_prepare_enable(motg->clk);
         clk_prepare_enable(motg->pclk);
 
+        if (!IS_ERR(motg->core_clk))
+                clk_prepare_enable(motg->core_clk);
+
         ret = msm_hsusb_init_vddcx(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vddcx configuration failed\n");
-                goto free_regs;
+                goto disable_clks;
         }
 
         ret = msm_hsusb_ldo_init(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vreg configuration failed\n");
-                goto vddcx_exit;
+                goto disable_vddcx;
         }
-        ret = msm_hsusb_ldo_set_mode(1);
+        ret = msm_hsusb_ldo_set_mode(motg, 1);
         if (ret) {
                 dev_err(&pdev->dev, "hsusb vreg enable failed\n");
-                goto ldo_exit;
+                goto disable_ldo;
         }
 
-        if (motg->core_clk)
-                clk_prepare_enable(motg->core_clk);
-
         writel(0, USB_USBINTR);
         writel(0, USB_OTGSC);
 
         INIT_WORK(&motg->sm_work, msm_otg_sm_work);
         INIT_DELAYED_WORK(&motg->chg_work, msm_chg_detect_work);
-        ret = request_irq(motg->irq, msm_otg_irq, IRQF_SHARED,
+        ret = devm_request_irq(&pdev->dev, motg->irq, msm_otg_irq, IRQF_SHARED,
                                         "msm_otg", motg);
         if (ret) {
                 dev_err(&pdev->dev, "request irq failed\n");
-                goto disable_clks;
+                goto disable_ldo;
         }
 
-        phy->init = msm_otg_reset;
+        phy->init = msm_phy_init;
         phy->set_power = msm_otg_set_power;
+        phy->notify_disconnect = msm_phy_notify_disconnect;
+        phy->type = USB_PHY_TYPE_USB2;
 
         phy->io_ops = &msm_otg_io_ops;
 
@@ -1551,54 +1673,38 @@ static int __init msm_otg_probe(struct platform_device *pdev)
         phy->otg->set_host = msm_otg_set_host;
         phy->otg->set_peripheral = msm_otg_set_peripheral;
 
-        ret = usb_add_phy(&motg->phy, USB_PHY_TYPE_USB2);
+        msm_usb_reset(phy);
+
+        ret = usb_add_phy_dev(&motg->phy);
         if (ret) {
                 dev_err(&pdev->dev, "usb_add_phy failed\n");
-                goto free_irq;
+                goto disable_ldo;
         }
 
         platform_set_drvdata(pdev, motg);
         device_init_wakeup(&pdev->dev, 1);
 
-        if (motg->pdata->mode == USB_OTG &&
-                        motg->pdata->otg_control == OTG_USER_CONTROL) {
+        if (motg->pdata->mode == USB_DR_MODE_OTG &&
+                motg->pdata->otg_control == OTG_USER_CONTROL) {
                 ret = msm_otg_debugfs_init(motg);
                 if (ret)
-                        dev_dbg(&pdev->dev, "mode debugfs file is"
-                                        "not available\n");
+                        dev_dbg(&pdev->dev, "Can not create mode change file\n");
         }
 
         pm_runtime_set_active(&pdev->dev);
         pm_runtime_enable(&pdev->dev);
 
         return 0;
-free_irq:
-        free_irq(motg->irq, motg);
+
+disable_ldo:
+        msm_hsusb_ldo_init(motg, 0);
+disable_vddcx:
+        msm_hsusb_init_vddcx(motg, 0);
 disable_clks:
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-ldo_exit:
-        msm_hsusb_ldo_init(motg, 0);
-vddcx_exit:
-        msm_hsusb_init_vddcx(motg, 0);
-free_regs:
-        iounmap(motg->regs);
-put_core_clk:
-        if (motg->core_clk)
-                clk_put(motg->core_clk);
-        clk_put(motg->pclk);
-put_pclk_src:
-        if (!IS_ERR(motg->pclk_src)) {
-                clk_disable_unprepare(motg->pclk_src);
-                clk_put(motg->pclk_src);
-        }
-put_clk:
-        clk_put(motg->clk);
-put_phy_reset_clk:
-        clk_put(motg->phy_reset_clk);
-free_motg:
-        kfree(motg->phy.otg);
-        kfree(motg);
+        if (!IS_ERR(motg->core_clk))
+                clk_disable_unprepare(motg->core_clk);
         return ret;
 }
 
@@ -1621,7 +1727,7 @@ static int msm_otg_remove(struct platform_device *pdev)
         pm_runtime_disable(&pdev->dev);
 
         usb_remove_phy(phy);
-        free_irq(motg->irq, motg);
+        disable_irq(motg->irq);
 
         /*
          * Put PHY in low power mode.
@@ -1641,26 +1747,12 @@ static int msm_otg_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(motg->pclk);
         clk_disable_unprepare(motg->clk);
-        if (motg->core_clk)
+        if (!IS_ERR(motg->core_clk))
                 clk_disable_unprepare(motg->core_clk);
-        if (!IS_ERR(motg->pclk_src)) {
-                clk_disable_unprepare(motg->pclk_src);
-                clk_put(motg->pclk_src);
-        }
         msm_hsusb_ldo_init(motg, 0);
 
-        iounmap(motg->regs);
         pm_runtime_set_suspended(&pdev->dev);
 
-        clk_put(motg->phy_reset_clk);
-        clk_put(motg->pclk);
-        clk_put(motg->clk);
-        if (motg->core_clk)
-                clk_put(motg->core_clk);
-
-        kfree(motg->phy.otg);
-        kfree(motg);
-
         return 0;
 }
 
@@ -1740,15 +1832,17 @@ static const struct dev_pm_ops msm_otg_dev_pm_ops = {
 };
 
 static struct platform_driver msm_otg_driver = {
+        .probe = msm_otg_probe,
         .remove = msm_otg_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
                 .pm = &msm_otg_dev_pm_ops,
+                .of_match_table = msm_otg_dt_match,
         },
 };
 
-module_platform_driver_probe(msm_otg_driver, msm_otg_probe);
+module_platform_driver(msm_otg_driver);
 
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("MSM USB transceiver driver");
diff --git a/drivers/usb/phy/phy-mv-u3d-usb.c b/drivers/usb/phy/phy-mv-u3d-usb.c
deleted file mode 100644
index d317903022bf..000000000000
--- a/drivers/usb/phy/phy-mv-u3d-usb.c
+++ /dev/null
@@ -1,338 +0,0 @@
-/*
- * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- */
-
-#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/usb/otg.h>
-#include <linux/platform_data/mv_usb.h>
-
-#include "phy-mv-u3d-usb.h"
-
-/*
- * struct mv_u3d_phy - transceiver driver state
- * @phy: transceiver structure
- * @dev: The parent device supplied to the probe function
- * @clk: usb phy clock
- * @base: usb phy register memory base
- */
-struct mv_u3d_phy {
-        struct usb_phy  phy;
-        struct mv_usb_platform_data *plat;
-        struct device   *dev;
-        struct clk      *clk;
-        void __iomem    *base;
-};
-
-static u32 mv_u3d_phy_read(void __iomem *base, u32 reg)
-{
-        void __iomem *addr, *data;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        return readl_relaxed(data);
-}
-
-static void mv_u3d_phy_set(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-        u32 tmp;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        tmp = readl_relaxed(data);
-        tmp |= value;
-        writel_relaxed(tmp, data);
-}
-
-static void mv_u3d_phy_clear(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-        u32 tmp;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        tmp = readl_relaxed(data);
-        tmp &= ~value;
-        writel_relaxed(tmp, data);
-}
-
-static void mv_u3d_phy_write(void __iomem *base, u32 reg, u32 value)
-{
-        void __iomem *addr, *data;
-
-        addr = base;
-        data = base + 0x4;
-
-        writel_relaxed(reg, addr);
-        writel_relaxed(value, data);
-}
-
-static void mv_u3d_phy_shutdown(struct usb_phy *phy)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        void __iomem *base;
-        u32 val;
-
-        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
-        base = mv_u3d_phy->base;
-
-        /* Power down Reference Analog current, bit 15
-         * Power down PLL, bit 14
-         * Power down Receiver, bit 13
-         * Power down Transmitter, bit 12
-         * of USB3_POWER_PLL_CONTROL register
-         */
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_PU);
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-
-        if (mv_u3d_phy->clk)
-                clk_disable(mv_u3d_phy->clk);
-}
-
-static int mv_u3d_phy_init(struct usb_phy *phy)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        void __iomem *base;
-        u32 val, count;
-
-        /* enable usb3 phy */
-        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
-
-        if (mv_u3d_phy->clk)
-                clk_enable(mv_u3d_phy->clk);
-
-        base = mv_u3d_phy->base;
-
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_PU_MASK);
-        val |= 0xF << USB3_POWER_PLL_CONTROL_PU_SHIFT;
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-        udelay(100);
-
-        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
-                        USB3_RESET_CONTROL_RESET_PIPE);
-        udelay(100);
-
-        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
-                        USB3_RESET_CONTROL_RESET_PIPE
-                        | USB3_RESET_CONTROL_RESET_PHY);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
-        val &= ~(USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK
-                | USB3_POWER_PLL_CONTROL_PHY_MODE_MASK);
-        val |=  (USB3_PLL_25MHZ << USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT)
-                | (0x5 << USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT);
-        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
-        udelay(100);
-
-        mv_u3d_phy_clear(base, USB3_KVCO_CALI_CONTROL,
-                USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_SQUELCH_FFE);
-        val &= ~(USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK
-                | USB3_SQUELCH_FFE_FFE_RES_SEL_MASK
-                | USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK);
-        val |= ((0xD << USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT)
-                | (0x7 << USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT)
-                | (0x8 << USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT));
-        mv_u3d_phy_write(base, USB3_SQUELCH_FFE, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN1_SET0);
-        val &= ~USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK;
-        val |= 1 << USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT;
-        mv_u3d_phy_write(base, USB3_GEN1_SET0, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN2_SET0);
-        val &= ~(USB3_GEN2_SET0_G2_TX_AMP_MASK
-                | USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK
-                | USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK);
-        val |= ((0x14 << USB3_GEN2_SET0_G2_TX_AMP_SHIFT)
-                | (1 << USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT)
-                | (0xA << USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT)
-                | (1 << USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT));
-        mv_u3d_phy_write(base, USB3_GEN2_SET0, val);
-        udelay(100);
-
-        mv_u3d_phy_read(base, USB3_TX_EMPPH);
-        val &= ~(USB3_TX_EMPPH_AMP_MASK
-                | USB3_TX_EMPPH_EN_MASK
-                | USB3_TX_EMPPH_AMP_FORCE_MASK
-                | USB3_TX_EMPPH_PAR1_MASK
-                | USB3_TX_EMPPH_PAR2_MASK);
-        val |= ((0xB << USB3_TX_EMPPH_AMP_SHIFT)
-                | (1 << USB3_TX_EMPPH_EN_SHIFT)
-                | (1 << USB3_TX_EMPPH_AMP_FORCE_SHIFT)
-                | (0x1C << USB3_TX_EMPPH_PAR1_SHIFT)
-                | (1 << USB3_TX_EMPPH_PAR2_SHIFT));
-
-        mv_u3d_phy_write(base, USB3_TX_EMPPH, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_GEN2_SET1);
-        val &= ~(USB3_GEN2_SET1_G2_RX_SELMUPI_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUPF_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUFI_MASK
-                | USB3_GEN2_SET1_G2_RX_SELMUFF_MASK);
-        val |= ((1 << USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT)
-                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT));
-        mv_u3d_phy_write(base, USB3_GEN2_SET1, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_DIGITAL_LOOPBACK_EN);
-        val &= ~USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK;
-        val |= 1 << USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT;
-        mv_u3d_phy_write(base, USB3_DIGITAL_LOOPBACK_EN, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_TX_SSC);
-        val &= ~USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK;
-        val |= 0xC << USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT;
-        mv_u3d_phy_write(base, USB3_IMPEDANCE_TX_SSC, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_CALI_CTRL);
-        val &= ~USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK;
-        val |= 0x4 << USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT;
-        mv_u3d_phy_write(base, USB3_IMPEDANCE_CALI_CTRL, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_PHY_ISOLATION_MODE);
-        val &= ~(USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK
-                | USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK
-                | USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK);
-        val |= ((1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT)
-                | (1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT));
-        mv_u3d_phy_write(base, USB3_PHY_ISOLATION_MODE, val);
-        udelay(100);
-
-        val = mv_u3d_phy_read(base, USB3_TXDETRX);
-        val &= ~(USB3_TXDETRX_VTHSEL_MASK);
-        val |= 0x1 << USB3_TXDETRX_VTHSEL_SHIFT;
-        mv_u3d_phy_write(base, USB3_TXDETRX, val);
-        udelay(100);
-
-        dev_dbg(mv_u3d_phy->dev, "start calibration\n");
-
-calstart:
-        /* Perform Manual Calibration */
-        mv_u3d_phy_set(base, USB3_KVCO_CALI_CONTROL,
-                1 << USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT);
-
-        mdelay(1);
-
-        count = 0;
-        while (1) {
-                val = mv_u3d_phy_read(base, USB3_KVCO_CALI_CONTROL);
-                if (val & (1 << USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT))
-                        break;
-                else if (count > 50) {
-                        dev_dbg(mv_u3d_phy->dev, "calibration failure, retry...\n");
-                        goto calstart;
-                }
-                count++;
-                mdelay(1);
-        }
-
-        /* active PIPE interface */
-        mv_u3d_phy_write(base, USB3_PIPE_SM_CTRL,
-                1 << USB3_PIPE_SM_CTRL_PHY_INIT_DONE);
-
-        return 0;
-}
-
-static int mv_u3d_phy_probe(struct platform_device *pdev)
-{
-        struct mv_u3d_phy *mv_u3d_phy;
-        struct mv_usb_platform_data *pdata;
-        struct device *dev = &pdev->dev;
-        struct resource *res;
-        void __iomem    *phy_base;
-        int     ret;
-
-        pdata = dev_get_platdata(&pdev->dev);
-        if (!pdata) {
-                dev_err(&pdev->dev, "%s: no platform data defined\n", __func__);
-                return -EINVAL;
-        }
-
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        phy_base = devm_ioremap_resource(dev, res);
-        if (IS_ERR(phy_base))
-                return PTR_ERR(phy_base);
-
-        mv_u3d_phy = devm_kzalloc(dev, sizeof(*mv_u3d_phy), GFP_KERNEL);
-        if (!mv_u3d_phy)
-                return -ENOMEM;
-
-        mv_u3d_phy->dev                 = &pdev->dev;
-        mv_u3d_phy->plat                = pdata;
-        mv_u3d_phy->base                = phy_base;
-        mv_u3d_phy->phy.dev             = mv_u3d_phy->dev;
-        mv_u3d_phy->phy.label           = "mv-u3d-phy";
-        mv_u3d_phy->phy.init            = mv_u3d_phy_init;
-        mv_u3d_phy->phy.shutdown        = mv_u3d_phy_shutdown;
-
-        ret = usb_add_phy(&mv_u3d_phy->phy, USB_PHY_TYPE_USB3);
-        if (ret)
-                goto err;
-
-        if (!mv_u3d_phy->clk)
-                mv_u3d_phy->clk = clk_get(mv_u3d_phy->dev, "u3dphy");
-
-        platform_set_drvdata(pdev, mv_u3d_phy);
-
-        dev_info(&pdev->dev, "Initialized Marvell USB 3.0 PHY\n");
-err:
-        return ret;
-}
-
-static int mv_u3d_phy_remove(struct platform_device *pdev)
-{
-        struct mv_u3d_phy *mv_u3d_phy = platform_get_drvdata(pdev);
-
-        usb_remove_phy(&mv_u3d_phy->phy);
-
-        if (mv_u3d_phy->clk) {
-                clk_put(mv_u3d_phy->clk);
-                mv_u3d_phy->clk = NULL;
-        }
-
-        return 0;
-}
-
-static struct platform_driver mv_u3d_phy_driver = {
-        .probe          = mv_u3d_phy_probe,
-        .remove         = mv_u3d_phy_remove,
-        .driver         = {
-                .name   = "mv-u3d-phy",
-                .owner  = THIS_MODULE,
-        },
-};
-
-module_platform_driver(mv_u3d_phy_driver);
-MODULE_DESCRIPTION("Marvell USB 3.0 PHY controller");
-MODULE_AUTHOR("Yu Xu <yuxu@marvell.com>");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:mv-u3d-phy");
diff --git a/drivers/usb/phy/phy-mv-u3d-usb.h b/drivers/usb/phy/phy-mv-u3d-usb.h
deleted file mode 100644
index 2a658cb9a527..000000000000
--- a/drivers/usb/phy/phy-mv-u3d-usb.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- */
-
-#ifndef __MV_U3D_PHY_H
-#define __MV_U3D_PHY_H
-
-#define USB3_POWER_PLL_CONTROL          0x1
-#define USB3_KVCO_CALI_CONTROL          0x2
-#define USB3_IMPEDANCE_CALI_CTRL        0x3
-#define USB3_IMPEDANCE_TX_SSC           0x4
-#define USB3_SQUELCH_FFE                0x6
-#define USB3_GEN1_SET0                  0xD
-#define USB3_GEN2_SET0                  0xF
-#define USB3_GEN2_SET1                  0x10
-#define USB3_DIGITAL_LOOPBACK_EN        0x23
-#define USB3_PHY_ISOLATION_MODE         0x26
-#define USB3_TXDETRX                    0x48
-#define USB3_TX_EMPPH                   0x5E
-#define USB3_RESET_CONTROL              0x90
-#define USB3_PIPE_SM_CTRL               0x91
-
-#define USB3_RESET_CONTROL_RESET_PIPE                   0x1
-#define USB3_RESET_CONTROL_RESET_PHY                    0x2
-
-#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK        (0x1F << 0)
-#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT       0
-#define USB3_PLL_25MHZ                                  0x2
-#define USB3_PLL_26MHZ                                  0x5
-#define USB3_POWER_PLL_CONTROL_PHY_MODE_MASK            (0x7 << 5)
-#define USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT           5
-#define USB3_POWER_PLL_CONTROL_PU_MASK                  (0xF << 12)
-#define USB3_POWER_PLL_CONTROL_PU_SHIFT                 12
-#define USB3_POWER_PLL_CONTROL_PU                       (0xF << 12)
-
-#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK    (0x1 << 12)
-#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_SHIFT   12
-#define USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT           14
-#define USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT          15
-
-#define USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK               0xF
-#define USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT              0
-#define USB3_SQUELCH_FFE_FFE_RES_SEL_MASK               (0x7 << 4)
-#define USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT              4
-#define USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK              (0x1F << 8)
-#define USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT             8
-
-#define USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
-#define USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT              11
-
-#define USB3_GEN2_SET0_G2_TX_AMP_MASK                   (0x1F << 1)
-#define USB3_GEN2_SET0_G2_TX_AMP_SHIFT                  1
-#define USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT              6
-#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK              (0xF << 7)
-#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT             7
-#define USB3_GEN2_SET0_G2_TX_EMPH_EN_MASK               (0x1 << 11)
-#define USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT              11
-#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
-#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_SHIFT         15
-
-#define USB3_GEN2_SET1_G2_RX_SELMUPI_MASK               (0x7 << 0)
-#define USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT              0
-#define USB3_GEN2_SET1_G2_RX_SELMUPF_MASK               (0x7 << 3)
-#define USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT              3
-#define USB3_GEN2_SET1_G2_RX_SELMUFI_MASK               (0x3 << 6)
-#define USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT              6
-#define USB3_GEN2_SET1_G2_RX_SELMUFF_MASK               (0x3 << 8)
-#define USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT              8
-
-#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK          (0x3 << 10)
-#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT         10
-
-#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK       (0x7 << 12)
-#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT      12
-
-#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK              (0x3F << 0)
-#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT             0
-
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK         0xF
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT        0
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK         (0xF << 4)
-#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT        4
-#define USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK        (0x1 << 8)
-
-#define USB3_TXDETRX_VTHSEL_MASK                        (0x3 << 4)
-#define USB3_TXDETRX_VTHSEL_SHIFT                       4
-
-#define USB3_TX_EMPPH_AMP_MASK                          (0xF << 0)
-#define USB3_TX_EMPPH_AMP_SHIFT                         0
-#define USB3_TX_EMPPH_EN_MASK                           (0x1 << 6)
-#define USB3_TX_EMPPH_EN_SHIFT                          6
-#define USB3_TX_EMPPH_AMP_FORCE_MASK                    (0x1 << 7)
-#define USB3_TX_EMPPH_AMP_FORCE_SHIFT                   7
-#define USB3_TX_EMPPH_PAR1_MASK                         (0x1F << 8)
-#define USB3_TX_EMPPH_PAR1_SHIFT                        8
-#define USB3_TX_EMPPH_PAR2_MASK                         (0x1 << 13)
-#define USB3_TX_EMPPH_PAR2_SHIFT                        13
-
-#define USB3_PIPE_SM_CTRL_PHY_INIT_DONE                 15
-
-#endif /* __MV_U3D_PHY_H */
diff --git a/drivers/usb/phy/phy-ulpi.c b/drivers/usb/phy/phy-ulpi.c
index 17ea3f271bd8..4e3877c329f2 100644
--- a/drivers/usb/phy/phy-ulpi.c
+++ b/drivers/usb/phy/phy-ulpi.c
@@ -48,6 +48,7 @@ static struct ulpi_info ulpi_ids[] = {
         ULPI_INFO(ULPI_ID(0x04cc, 0x1504), "NXP ISP1504"),
         ULPI_INFO(ULPI_ID(0x0424, 0x0006), "SMSC USB331x"),
         ULPI_INFO(ULPI_ID(0x0424, 0x0007), "SMSC USB3320"),
+        ULPI_INFO(ULPI_ID(0x0424, 0x0009), "SMSC USB334x"),
         ULPI_INFO(ULPI_ID(0x0451, 0x1507), "TI TUSB1210"),
 };
 
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index 35a2373cde67..9374bd2aba20 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -97,13 +97,19 @@ static int usb_serial_device_remove(struct device *dev)
         struct usb_serial_port *port;
         int retval = 0;
         int minor;
+        int autopm_err;
 
         port = to_usb_serial_port(dev);
         if (!port)
                 return -ENODEV;
 
-        /* make sure suspend/resume doesn't race against port_remove */
-        usb_autopm_get_interface(port->serial->interface);
+        /*
+         * Make sure suspend/resume doesn't race against port_remove.
+         *
+         * Note that no further runtime PM callbacks will be made if
+         * autopm_get fails.
+         */
+        autopm_err = usb_autopm_get_interface(port->serial->interface);
 
         minor = port->minor;
         tty_unregister_device(usb_serial_tty_driver, minor);
@@ -117,7 +123,9 @@ static int usb_serial_device_remove(struct device *dev)
         dev_info(dev, "%s converter now disconnected from ttyUSB%d\n",
                  driver->description, minor);
 
-        usb_autopm_put_interface(port->serial->interface);
+        if (!autopm_err)
+                usb_autopm_put_interface(port->serial->interface);
+
         return retval;
 }
 
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index d3acaead5a81..93cb7cebda62 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1535,14 +1535,14 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
 
         this_urb = p_priv->outcont_urb;
 
-        dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
-
                 /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
                 dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
                 return -1;
         }
 
+        dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
+
         /* Save reset port val for resend.
            Don't overwrite resend for open/close condition. */
         if ((reset_port + 1) > p_priv->resend_cont)
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index fee242387f55..078f9ed419c8 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -215,13 +215,13 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                         priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
                 /* Setting Baudrate, Parity and Stopbits */
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_SetBaudRateParityAndStopBits,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity |
                                                         SUSBCR_SPASB_1StopBit,
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                 );
@@ -229,12 +229,12 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
 
                 /* reset all queues */
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_Misc,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_MSC_ResetAllQueues,
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                 );
@@ -445,12 +445,12 @@ static int kobil_tiocmset(struct tty_struct *tty,
                 else
                         dev_dbg(dev, "%s - Clearing DTR\n", __func__);
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_SetStatusLinesOrQueues,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
                           0,
-                          transfer_buffer,
+                          NULL,
                           0,
                           KOBIL_TIMEOUT);
         } else {
@@ -459,12 +459,12 @@ static int kobil_tiocmset(struct tty_struct *tty,
                 else
                         dev_dbg(dev, "%s - Clearing RTS\n", __func__);
                 result = usb_control_msg(port->serial->dev,
-                        usb_rcvctrlpipe(port->serial->dev, 0),
+                        usb_sndctrlpipe(port->serial->dev, 0),
                         SUSBCRequest_SetStatusLinesOrQueues,
                         USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                         ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
                         0,
-                        transfer_buffer,
+                        NULL,
                         0,
                         KOBIL_TIMEOUT);
         }
@@ -514,7 +514,7 @@ static void kobil_set_termios(struct tty_struct *tty,
         tty_encode_baud_rate(tty, speed, speed);
 
         result = usb_control_msg(port->serial->dev,
-                  usb_rcvctrlpipe(port->serial->dev, 0),
+                  usb_sndctrlpipe(port->serial->dev, 0),
                   SUSBCRequest_SetBaudRateParityAndStopBits,
                   USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                   urb_val,
@@ -546,12 +546,12 @@ static int kobil_ioctl(struct tty_struct *tty,
                         return -ENOBUFS;
 
                 result = usb_control_msg(port->serial->dev,
-                          usb_rcvctrlpipe(port->serial->dev, 0),
+                          usb_sndctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_Misc,
                           USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
                           SUSBCR_MSC_ResetAllQueues,
                           0,
-                          NULL, /* transfer_buffer, */
+                          NULL,
                           0,
                           KOBIL_TIMEOUT
                         );
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index f213ee978516..51e30740b2fe 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -1729,7 +1729,6 @@ static struct usb_serial_driver option_1port_device = {
         .write             = usb_wwan_write,
         .write_room        = usb_wwan_write_room,
         .chars_in_buffer   = usb_wwan_chars_in_buffer,
-        .set_termios       = usb_wwan_set_termios,
         .tiocmget          = usb_wwan_tiocmget,
         .tiocmset          = usb_wwan_tiocmset,
         .ioctl             = usb_wwan_ioctl,
@@ -1904,6 +1903,7 @@ static void option_instat_callback(struct urb *urb)
 
         /* Resubmit urb so we continue receiving IRQ data */
         if (status != -ESHUTDOWN && status != -ENOENT) {
+                usb_mark_last_busy(port->serial->dev);
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
                         dev_dbg(dev, "%s: resubmit intr urb failed. (%d)\n",
@@ -1923,6 +1923,7 @@ static int option_send_setup(struct usb_serial_port *port)
         struct option_private *priv = intfdata->private;
         struct usb_wwan_port_private *portdata;
         int val = 0;
+        int res;
 
         portdata = usb_get_serial_port_data(port);
 
@@ -1931,9 +1932,17 @@ static int option_send_setup(struct usb_serial_port *port)
         if (portdata->rts_state)
                 val |= 0x02;
 
-        return usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+        res = usb_autopm_get_interface(serial->interface);
+        if (res)
+                return res;
+
+        res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                                 0x22, 0x21, val, priv->bInterfaceNumber, NULL,
                                 0, USB_CTRL_SET_TIMEOUT);
+
+        usb_autopm_put_interface(serial->interface);
+
+        return res;
 }
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index 6c0a542e8ec1..b2aa003bf411 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -22,8 +22,17 @@
 #define DRIVER_AUTHOR "Qualcomm Inc"
 #define DRIVER_DESC "Qualcomm USB Serial driver"
 
+/* standard device layouts supported by this driver */
+enum qcserial_layouts {
+        QCSERIAL_G2K = 0,       /* Gobi 2000 */
+        QCSERIAL_G1K = 1,       /* Gobi 1000 */
+        QCSERIAL_SWI = 2,       /* Sierra Wireless */
+};
+
 #define DEVICE_G1K(v, p) \
-        USB_DEVICE(v, p), .driver_info = 1
+        USB_DEVICE(v, p), .driver_info = QCSERIAL_G1K
+#define DEVICE_SWI(v, p) \
+        USB_DEVICE(v, p), .driver_info = QCSERIAL_SWI
 
 static const struct usb_device_id id_table[] = {
         /* Gobi 1000 devices */
@@ -126,46 +135,27 @@ static const struct usb_device_id id_table[] = {
         {USB_DEVICE(0x12D1, 0x14F1)},   /* Sony Gobi 3000 Composite */
         {USB_DEVICE(0x0AF0, 0x8120)},   /* Option GTM681W */
 
-        /* non Gobi Qualcomm serial devices */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 0)},       /* Sierra Wireless MC7700 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 2)},       /* Sierra Wireless MC7700 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x0f3d, 0x68a2, 3)},       /* Sierra Wireless MC7700 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 0)},       /* Sierra Wireless MC7750 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 2)},       /* Sierra Wireless MC7750 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x114f, 0x68a2, 3)},       /* Sierra Wireless MC7750 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 0)},       /* Sierra Wireless MC7710 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 2)},       /* Sierra Wireless MC7710 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68a2, 3)},       /* Sierra Wireless MC7710 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 0)},       /* Sierra Wireless MC73xx Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 2)},       /* Sierra Wireless MC73xx NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x68c0, 3)},       /* Sierra Wireless MC73xx Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 0)},       /* Sierra Wireless EM7700 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 2)},       /* Sierra Wireless EM7700 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901c, 3)},       /* Sierra Wireless EM7700 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 0)},       /* Sierra Wireless EM7355 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 2)},       /* Sierra Wireless EM7355 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x901f, 3)},       /* Sierra Wireless EM7355 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 0)},       /* Sierra Wireless MC7305/MC7355 Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 2)},       /* Sierra Wireless MC7305/MC7355 NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9041, 3)},       /* Sierra Wireless MC7305/MC7355 Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 0)},       /* Netgear AirCard 340U Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 2)},       /* Netgear AirCard 340U NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x1199, 0x9051, 3)},       /* Netgear AirCard 340U Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 0)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 2)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a2, 3)},       /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 0)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 2)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a3, 3)},       /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 0)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 2)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a4, 3)},       /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 0)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 2)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a8, 3)},       /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card Modem */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 0)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card Device Management */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 2)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card NMEA */
-        {USB_DEVICE_INTERFACE_NUMBER(0x413c, 0x81a9, 3)},       /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card Modem */
+        /* non-Gobi Sierra Wireless devices */
+        {DEVICE_SWI(0x0f3d, 0x68a2)},   /* Sierra Wireless MC7700 */
+        {DEVICE_SWI(0x114f, 0x68a2)},   /* Sierra Wireless MC7750 */
+        {DEVICE_SWI(0x1199, 0x68a2)},   /* Sierra Wireless MC7710 */
+        {DEVICE_SWI(0x1199, 0x68c0)},   /* Sierra Wireless MC73xx */
+        {DEVICE_SWI(0x1199, 0x901c)},   /* Sierra Wireless EM7700 */
+        {DEVICE_SWI(0x1199, 0x901f)},   /* Sierra Wireless EM7355 */
+        {DEVICE_SWI(0x1199, 0x9040)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9041)},   /* Sierra Wireless MC7305/MC7355 */
+        {DEVICE_SWI(0x1199, 0x9051)},   /* Netgear AirCard 340U */
+        {DEVICE_SWI(0x1199, 0x9053)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9054)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9055)},   /* Netgear AirCard 341U */
+        {DEVICE_SWI(0x1199, 0x9056)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9060)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x1199, 0x9061)},   /* Sierra Wireless Modem */
+        {DEVICE_SWI(0x413c, 0x81a2)},   /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a3)},   /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a4)},   /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a8)},   /* Dell Wireless 5808 Gobi(TM) 4G LTE Mobile Broadband Card */
+        {DEVICE_SWI(0x413c, 0x81a9)},   /* Dell Wireless 5808e Gobi(TM) 4G LTE Mobile Broadband Card */
 
         { }                             /* Terminating entry */
 };
@@ -178,11 +168,8 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
         int retval = -ENODEV;
         __u8 nintf;
         __u8 ifnum;
-        bool is_gobi1k = id->driver_info ? true : false;
         int altsetting = -1;
 
-        dev_dbg(dev, "Is Gobi 1000 = %d\n", is_gobi1k);
-
         nintf = serial->dev->actconfig->desc.bNumInterfaces;
         dev_dbg(dev, "Num Interfaces = %d\n", nintf);
         ifnum = intf->desc.bInterfaceNumber;
@@ -210,32 +197,29 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
 
         }
 
-        /* allow any number of interfaces when doing direct interface match */
-        if (id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) {
-                dev_dbg(dev, "Generic Qualcomm serial interface found\n");
-                altsetting = 0;
-                goto done;
-        }
-
-        if (nintf < 3 || nintf > 4) {
-                dev_err(dev, "unknown number of interfaces: %d\n", nintf);
-                goto done;
-        }
-
         /* default to enabling interface */
         altsetting = 0;
 
-        /* Composite mode; don't bind to the QMI/net interface as that
+        /*
+         * Composite mode; don't bind to the QMI/net interface as that
          * gets handled by other drivers.
          */
 
-        if (is_gobi1k) {
-                /* Gobi 1K USB layout:
+        switch (id->driver_info) {
+        case QCSERIAL_G1K:
+                /*
+                 * Gobi 1K USB layout:
                  * 0: DM/DIAG (use libqcdm from ModemManager for communication)
                  * 1: serial port (doesn't respond)
                  * 2: AT-capable modem port
                  * 3: QMI/net
                  */
+                if (nintf < 3 || nintf > 4) {
+                        dev_err(dev, "unknown number of interfaces: %d\n", nintf);
+                        altsetting = -1;
+                        goto done;
+                }
+
                 if (ifnum == 0) {
                         dev_dbg(dev, "Gobi 1K DM/DIAG interface found\n");
                         altsetting = 1;
@@ -243,13 +227,21 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                         dev_dbg(dev, "Modem port found\n");
                 else
                         altsetting = -1;
-        } else {
-                /* Gobi 2K+ USB layout:
+                break;
+        case QCSERIAL_G2K:
+                /*
+                 * Gobi 2K+ USB layout:
                  * 0: QMI/net
                  * 1: DM/DIAG (use libqcdm from ModemManager for communication)
                  * 2: AT-capable modem port
                  * 3: NMEA
                  */
+                if (nintf < 3 || nintf > 4) {
+                        dev_err(dev, "unknown number of interfaces: %d\n", nintf);
+                        altsetting = -1;
+                        goto done;
+                }
+
                 switch (ifnum) {
                 case 0:
                         /* Don't claim the QMI/net interface */
@@ -270,6 +262,35 @@ static int qcprobe(struct usb_serial *serial, const struct usb_device_id *id)
                         dev_dbg(dev, "Gobi 2K+ NMEA GPS interface found\n");
                         break;
                 }
+                break;
+        case QCSERIAL_SWI:
+                /*
+                 * Sierra Wireless layout:
+                 * 0: DM/DIAG (use libqcdm from ModemManager for communication)
+                 * 2: NMEA
+                 * 3: AT-capable modem port
+                 * 8: QMI/net
+                 */
+                switch (ifnum) {
+                case 0:
+                        dev_dbg(dev, "DM/DIAG interface found\n");
+                        break;
+                case 2:
+                        dev_dbg(dev, "NMEA GPS interface found\n");
+                        break;
+                case 3:
+                        dev_dbg(dev, "Modem port found\n");
+                        break;
+                default:
+                        /* don't claim any unsupported interface */
+                        altsetting = -1;
+                        break;
+                }
+                break;
+        default:
+                dev_err(dev, "unsupported device layout type: %lu\n",
+                        id->driver_info);
+                break;
         }
 
 done:
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 6b192e602ce0..6f7f01eb556a 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -58,6 +58,7 @@ struct sierra_intf_private {
         spinlock_t susp_lock;
         unsigned int suspended:1;
         int in_flight;
+        unsigned int open_ports;
 };
 
 static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
@@ -315,7 +316,6 @@ struct sierra_port_private {
         int dsr_state;
         int dcd_state;
         int ri_state;
-        unsigned int opened:1;
 };
 
 static int sierra_send_setup(struct usb_serial_port *port)
@@ -364,20 +364,13 @@ static int sierra_send_setup(struct usb_serial_port *port)
         if (retval < 0)
                 return retval;
 
-        retval = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+        retval = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                 0x22, 0x21, val, interface, NULL, 0, USB_CTRL_SET_TIMEOUT);
         usb_autopm_put_interface(serial->interface);
 
         return retval;
 }
 
-static void sierra_set_termios(struct tty_struct *tty,
-                struct usb_serial_port *port, struct ktermios *old_termios)
-{
-        tty_termios_copy_hw(&tty->termios, old_termios);
-        sierra_send_setup(port);
-}
-
 static int sierra_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -418,9 +411,7 @@ static int sierra_tiocmset(struct tty_struct *tty,
 
 static void sierra_release_urb(struct urb *urb)
 {
-        struct usb_serial_port *port;
         if (urb) {
-                port = urb->context;
                 kfree(urb->transfer_buffer);
                 usb_free_urb(urb);
         }
@@ -433,7 +424,7 @@ static void sierra_outdat_callback(struct urb *urb)
         struct sierra_intf_private *intfdata;
         int status = urb->status;
 
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
         kfree(urb->transfer_buffer);
@@ -470,7 +461,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
                 return 0;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = serial->private;
+        intfdata = usb_get_serial_data(serial);
 
         dev_dbg(&port->dev, "%s: write (%zd bytes)\n", __func__, writesize);
         spin_lock_irqsave(&portdata->lock, flags);
@@ -674,6 +665,23 @@ static int sierra_write_room(struct tty_struct *tty)
         return 2048;
 }
 
+static int sierra_chars_in_buffer(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        unsigned long flags;
+        int chars;
+
+        /* NOTE: This overcounts somewhat. */
+        spin_lock_irqsave(&portdata->lock, flags);
+        chars = portdata->outstanding_urbs * MAX_TRANSFER;
+        spin_unlock_irqrestore(&portdata->lock, flags);
+
+        dev_dbg(&port->dev, "%s - %d\n", __func__, chars);
+
+        return chars;
+}
+
 static void sierra_stop_rx_urbs(struct usb_serial_port *port)
 {
         int i;
@@ -729,9 +737,6 @@ static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
         struct urb      *urb;
         u8              *buf;
 
-        if (endpoint == -1)
-                return NULL;
-
         urb = usb_alloc_urb(0, mem_flags);
         if (!urb)
                 return NULL;
@@ -758,40 +763,48 @@ static void sierra_close(struct usb_serial_port *port)
         int i;
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
-        struct sierra_intf_private *intfdata = port->serial->private;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
+        struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
 
-        portdata->rts_state = 0;
-        portdata->dtr_state = 0;
-
-        mutex_lock(&serial->disc_mutex);
-        if (!serial->disconnected) {
+        /*
+         * Need to take susp_lock to make sure port is not already being
+         * resumed, but no need to hold it due to ASYNC_INITIALIZED.
+         */
+        spin_lock_irq(&intfdata->susp_lock);
+        if (--intfdata->open_ports == 0)
                 serial->interface->needs_remote_wakeup = 0;
-                /* odd error handling due to pm counters */
-                if (!usb_autopm_get_interface(serial->interface))
-                        sierra_send_setup(port);
-                else
-                        usb_autopm_get_interface_no_resume(serial->interface);
+        spin_unlock_irq(&intfdata->susp_lock);
 
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+                kfree(urb->transfer_buffer);
+                usb_free_urb(urb);
+                usb_autopm_put_interface_async(serial->interface);
+                spin_lock(&portdata->lock);
+                portdata->outstanding_urbs--;
+                spin_unlock(&portdata->lock);
         }
-        mutex_unlock(&serial->disc_mutex);
-        spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 0;
-        spin_unlock_irq(&intfdata->susp_lock);
 
         sierra_stop_rx_urbs(port);
+        usb_kill_anchored_urbs(&portdata->active);
+
         for (i = 0; i < portdata->num_in_urbs; i++) {
                 sierra_release_urb(portdata->in_urbs[i]);
                 portdata->in_urbs[i] = NULL;
         }
+
+        usb_autopm_get_interface_no_resume(serial->interface);
 }
 
 static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
-        struct sierra_intf_private *intfdata = serial->private;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
         int i;
         int err;
         int endpoint;
@@ -799,11 +812,6 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         portdata = usb_get_serial_port_data(port);
 
-        /* Set some sane defaults */
-        portdata->rts_state = 1;
-        portdata->dtr_state = 1;
-
-
         endpoint = port->bulk_in_endpointAddress;
         for (i = 0; i < portdata->num_in_urbs; i++) {
                 urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
@@ -816,23 +824,26 @@ static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
                         usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);
 
         err = sierra_submit_rx_urbs(port, GFP_KERNEL);
-        if (err) {
-                /* get rid of everything as in close */
-                sierra_close(port);
-                /* restore balance for autopm */
-                if (!serial->disconnected)
-                        usb_autopm_put_interface(serial->interface);
-                return err;
-        }
-        sierra_send_setup(port);
+        if (err)
+                goto err_submit;
 
-        serial->interface->needs_remote_wakeup = 1;
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 1;
+        if (++intfdata->open_ports == 1)
+                serial->interface->needs_remote_wakeup = 1;
         spin_unlock_irq(&intfdata->susp_lock);
         usb_autopm_put_interface(serial->interface);
 
         return 0;
+
+err_submit:
+        sierra_stop_rx_urbs(port);
+
+        for (i = 0; i < portdata->num_in_urbs; i++) {
+                sierra_release_urb(portdata->in_urbs[i]);
+                portdata->in_urbs[i] = NULL;
+        }
+
+        return err;
 }
 
 
@@ -928,6 +939,7 @@ static int sierra_port_remove(struct usb_serial_port *port)
         struct sierra_port_private *portdata;
 
         portdata = usb_get_serial_port_data(port);
+        usb_set_serial_port_data(port, NULL);
         kfree(portdata);
 
         return 0;
@@ -944,6 +956,8 @@ static void stop_read_write_urbs(struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
+                if (!portdata)
+                        continue;
                 sierra_stop_rx_urbs(port);
                 usb_kill_anchored_urbs(&portdata->active);
         }
@@ -951,58 +965,84 @@ static void stop_read_write_urbs(struct usb_serial *serial)
 
 static int sierra_suspend(struct usb_serial *serial, pm_message_t message)
 {
-        struct sierra_intf_private *intfdata;
-        int b;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
 
+        spin_lock_irq(&intfdata->susp_lock);
         if (PMSG_IS_AUTO(message)) {
-                intfdata = serial->private;
-                spin_lock_irq(&intfdata->susp_lock);
-                b = intfdata->in_flight;
-
-                if (b) {
+                if (intfdata->in_flight) {
                         spin_unlock_irq(&intfdata->susp_lock);
                         return -EBUSY;
-                } else {
-                        intfdata->suspended = 1;
-                        spin_unlock_irq(&intfdata->susp_lock);
                 }
         }
+        intfdata->suspended = 1;
+        spin_unlock_irq(&intfdata->susp_lock);
+
         stop_read_write_urbs(serial);
 
         return 0;
 }
 
+/* Caller must hold susp_lock. */
+static int sierra_submit_delayed_urbs(struct usb_serial_port *port)
+{
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
+        struct sierra_intf_private *intfdata;
+        struct urb *urb;
+        int ec = 0;
+        int err;
+
+        intfdata = usb_get_serial_data(port->serial);
+
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+
+                usb_anchor_urb(urb, &portdata->active);
+                intfdata->in_flight++;
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err) {
+                        dev_err(&port->dev, "%s - submit urb failed: %d",
+                                        __func__, err);
+                        ec++;
+                        intfdata->in_flight--;
+                        usb_unanchor_urb(urb);
+                        kfree(urb->transfer_buffer);
+                        usb_free_urb(urb);
+
+                        spin_lock(&portdata->lock);
+                        portdata->outstanding_urbs--;
+                        spin_unlock(&portdata->lock);
+                }
+        }
+
+        if (ec)
+                return -EIO;
+
+        return 0;
+}
+
 static int sierra_resume(struct usb_serial *serial)
 {
         struct usb_serial_port *port;
-        struct sierra_intf_private *intfdata = serial->private;
-        struct sierra_port_private *portdata;
-        struct urb *urb;
+        struct sierra_intf_private *intfdata = usb_get_serial_data(serial);
         int ec = 0;
         int i, err;
 
         spin_lock_irq(&intfdata->susp_lock);
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                portdata = usb_get_serial_port_data(port);
 
-                while ((urb = usb_get_from_anchor(&portdata->delayed))) {
-                        usb_anchor_urb(urb, &portdata->active);
-                        intfdata->in_flight++;
-                        err = usb_submit_urb(urb, GFP_ATOMIC);
-                        if (err < 0) {
-                                intfdata->in_flight--;
-                                usb_unanchor_urb(urb);
-                                usb_scuttle_anchored_urbs(&portdata->delayed);
-                                break;
-                        }
-                }
+                if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
+                        continue;
 
-                if (portdata->opened) {
-                        err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
-                        if (err)
-                                ec++;
-                }
+                err = sierra_submit_delayed_urbs(port);
+                if (err)
+                        ec++;
+
+                err = sierra_submit_rx_urbs(port, GFP_ATOMIC);
+                if (err)
+                        ec++;
         }
         intfdata->suspended = 0;
         spin_unlock_irq(&intfdata->susp_lock);
@@ -1029,7 +1069,7 @@ static struct usb_serial_driver sierra_device = {
         .dtr_rts           = sierra_dtr_rts,
         .write             = sierra_write,
         .write_room        = sierra_write_room,
-        .set_termios       = sierra_set_termios,
+        .chars_in_buffer   = sierra_chars_in_buffer,
         .tiocmget          = sierra_tiocmget,
         .tiocmset          = sierra_tiocmset,
         .attach            = sierra_startup,
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 6d40d56378d7..02de3110fe94 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -1060,6 +1060,7 @@ static void usb_serial_disconnect(struct usb_interface *interface)
         struct usb_serial *serial = usb_get_intfdata(interface);
         struct device *dev = &interface->dev;
         struct usb_serial_port *port;
+        struct tty_struct *tty;
 
         usb_serial_console_disconnect(serial);
 
@@ -1070,18 +1071,16 @@ static void usb_serial_disconnect(struct usb_interface *interface)
 
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
-                if (port) {
-                        struct tty_struct *tty = tty_port_tty_get(&port->port);
-                        if (tty) {
-                                tty_vhangup(tty);
-                                tty_kref_put(tty);
-                        }
-                        usb_serial_port_poison_urbs(port);
-                        wake_up_interruptible(&port->port.delta_msr_wait);
-                        cancel_work_sync(&port->work);
-                        if (device_is_registered(&port->dev))
-                                device_del(&port->dev);
+                tty = tty_port_tty_get(&port->port);
+                if (tty) {
+                        tty_vhangup(tty);
+                        tty_kref_put(tty);
                 }
+                usb_serial_port_poison_urbs(port);
+                wake_up_interruptible(&port->port.delta_msr_wait);
+                cancel_work_sync(&port->work);
+                if (device_is_registered(&port->dev))
+                        device_del(&port->dev);
         }
         if (serial->type->disconnect)
                 serial->type->disconnect(serial);
@@ -1094,7 +1093,6 @@ static void usb_serial_disconnect(struct usb_interface *interface)
 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct usb_serial *serial = usb_get_intfdata(intf);
-        struct usb_serial_port *port;
         int i, r = 0;
 
         serial->suspending = 1;
@@ -1112,12 +1110,8 @@ int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
                 }
         }
 
-        for (i = 0; i < serial->num_ports; ++i) {
-                port = serial->port[i];
-                if (port)
-                        usb_serial_port_poison_urbs(port);
-        }
-
+        for (i = 0; i < serial->num_ports; ++i)
+                usb_serial_port_poison_urbs(serial->port[i]);
 err_out:
         return r;
 }
@@ -1125,14 +1119,10 @@ EXPORT_SYMBOL(usb_serial_suspend);
 
 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
 {
-        struct usb_serial_port *port;
         int i;
 
-        for (i = 0; i < serial->num_ports; ++i) {
-                port = serial->port[i];
-                if (port)
-                        usb_serial_port_unpoison_urbs(port);
-        }
+        for (i = 0; i < serial->num_ports; ++i)
+                usb_serial_port_unpoison_urbs(serial->port[i]);
 }
 
 int usb_serial_resume(struct usb_interface *intf)
diff --git a/drivers/usb/serial/usb-wwan.h b/drivers/usb/serial/usb-wwan.h
index 684739b8efd0..f22dff58b587 100644
--- a/drivers/usb/serial/usb-wwan.h
+++ b/drivers/usb/serial/usb-wwan.h
@@ -11,15 +11,11 @@ extern void usb_wwan_close(struct usb_serial_port *port);
 extern int usb_wwan_port_probe(struct usb_serial_port *port);
 extern int usb_wwan_port_remove(struct usb_serial_port *port);
 extern int usb_wwan_write_room(struct tty_struct *tty);
-extern void usb_wwan_set_termios(struct tty_struct *tty,
-                                 struct usb_serial_port *port,
-                                 struct ktermios *old);
 extern int usb_wwan_tiocmget(struct tty_struct *tty);
 extern int usb_wwan_tiocmset(struct tty_struct *tty,
                              unsigned int set, unsigned int clear);
 extern int usb_wwan_ioctl(struct tty_struct *tty,
                           unsigned int cmd, unsigned long arg);
-extern int usb_wwan_send_setup(struct usb_serial_port *port);
 extern int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                           const unsigned char *buf, int count);
 extern int usb_wwan_chars_in_buffer(struct tty_struct *tty);
@@ -39,6 +35,7 @@ struct usb_wwan_intf_private {
         spinlock_t susp_lock;
         unsigned int suspended:1;
         int in_flight;
+        unsigned int open_ports;
         int (*send_setup) (struct usb_serial_port *port);
         void *private;
 };
@@ -51,7 +48,6 @@ struct usb_wwan_port_private {
         struct urb *out_urbs[N_OUT_URB];
         u8 *out_buffer[N_OUT_URB];
         unsigned long out_busy; /* Bit vector of URBs in use */
-        int opened;
         struct usb_anchor delayed;
 
         /* Settings for the port */
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index b078440e822f..2932d9cfb166 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -41,7 +41,7 @@ void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
         struct usb_wwan_port_private *portdata;
         struct usb_wwan_intf_private *intfdata;
 
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         if (!intfdata->send_setup)
                 return;
@@ -55,20 +55,6 @@ void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
 }
 EXPORT_SYMBOL(usb_wwan_dtr_rts);
 
-void usb_wwan_set_termios(struct tty_struct *tty,
-                          struct usb_serial_port *port,
-                          struct ktermios *old_termios)
-{
-        struct usb_wwan_intf_private *intfdata = port->serial->private;
-
-        /* Doesn't support option setting */
-        tty_termios_copy_hw(&tty->termios, old_termios);
-
-        if (intfdata->send_setup)
-                intfdata->send_setup(port);
-}
-EXPORT_SYMBOL(usb_wwan_set_termios);
-
 int usb_wwan_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
@@ -96,7 +82,7 @@ int usb_wwan_tiocmset(struct tty_struct *tty,
         struct usb_wwan_intf_private *intfdata;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         if (!intfdata->send_setup)
                 return -EINVAL;
@@ -192,7 +178,6 @@ int usb_wwan_ioctl(struct tty_struct *tty,
 }
 EXPORT_SYMBOL(usb_wwan_ioctl);
 
-/* Write */
 int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                    const unsigned char *buf, int count)
 {
@@ -205,7 +190,7 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
         unsigned long flags;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
 
@@ -228,8 +213,10 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         usb_pipeendpoint(this_urb->pipe), i);
 
                 err = usb_autopm_get_interface_async(port->serial->interface);
-                if (err < 0)
+                if (err < 0) {
+                        clear_bit(i, &portdata->out_busy);
                         break;
+                }
 
                 /* send the data */
                 memcpy(this_urb->transfer_buffer, buf, todo);
@@ -244,9 +231,9 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         spin_unlock_irqrestore(&intfdata->susp_lock, flags);
                         err = usb_submit_urb(this_urb, GFP_ATOMIC);
                         if (err) {
-                                dev_dbg(&port->dev,
-                                        "usb_submit_urb %p (write bulk) failed (%d)\n",
-                                        this_urb, err);
+                                dev_err(&port->dev,
+                                        "%s: submit urb %d failed: %d\n",
+                                        __func__, i, err);
                                 clear_bit(i, &portdata->out_busy);
                                 spin_lock_irqsave(&intfdata->susp_lock, flags);
                                 intfdata->in_flight--;
@@ -314,7 +301,7 @@ static void usb_wwan_outdat_callback(struct urb *urb)
         int i;
 
         port = urb->context;
-        intfdata = port->serial->private;
+        intfdata = usb_get_serial_data(port->serial);
 
         usb_serial_port_softint(port);
         usb_autopm_put_interface_async(port->serial->interface);
@@ -384,7 +371,15 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
-        intfdata = serial->private;
+        intfdata = usb_get_serial_data(serial);
+
+        if (port->interrupt_in_urb) {
+                err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit int urb failed: %d\n",
+                                __func__, err);
+                }
+        }
 
         /* Start reading from the IN endpoint */
         for (i = 0; i < N_IN_URB; i++) {
@@ -393,17 +388,15 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
                         continue;
                 err = usb_submit_urb(urb, GFP_KERNEL);
                 if (err) {
-                        dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
-                                __func__, i, err, urb->transfer_buffer_length);
+                        dev_err(&port->dev,
+                                "%s: submit read urb %d failed: %d\n",
+                                __func__, i, err);
                 }
         }
 
-        if (intfdata->send_setup)
-                intfdata->send_setup(port);
-
-        serial->interface->needs_remote_wakeup = 1;
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 1;
+        if (++intfdata->open_ports == 1)
+                serial->interface->needs_remote_wakeup = 1;
         spin_unlock_irq(&intfdata->susp_lock);
         /* this balances a get in the generic USB serial code */
         usb_autopm_put_interface(serial->interface);
@@ -412,32 +405,56 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
 }
 EXPORT_SYMBOL(usb_wwan_open);
 
+static void unbusy_queued_urb(struct urb *urb,
+                                        struct usb_wwan_port_private *portdata)
+{
+        int i;
+
+        for (i = 0; i < N_OUT_URB; i++) {
+                if (urb == portdata->out_urbs[i]) {
+                        clear_bit(i, &portdata->out_busy);
+                        break;
+                }
+        }
+}
+
 void usb_wwan_close(struct usb_serial_port *port)
 {
         int i;
         struct usb_serial *serial = port->serial;
         struct usb_wwan_port_private *portdata;
-        struct usb_wwan_intf_private *intfdata = port->serial->private;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
+        struct urb *urb;
 
         portdata = usb_get_serial_port_data(port);
 
-        /* Stop reading/writing urbs */
+        /*
+         * Need to take susp_lock to make sure port is not already being
+         * resumed, but no need to hold it due to ASYNC_INITIALIZED.
+         */
         spin_lock_irq(&intfdata->susp_lock);
-        portdata->opened = 0;
+        if (--intfdata->open_ports == 0)
+                serial->interface->needs_remote_wakeup = 0;
         spin_unlock_irq(&intfdata->susp_lock);
 
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
+                        break;
+                unbusy_queued_urb(urb, portdata);
+                usb_autopm_put_interface_async(serial->interface);
+        }
+
         for (i = 0; i < N_IN_URB; i++)
                 usb_kill_urb(portdata->in_urbs[i]);
         for (i = 0; i < N_OUT_URB; i++)
                 usb_kill_urb(portdata->out_urbs[i]);
+        usb_kill_urb(port->interrupt_in_urb);
 
-        /* balancing - important as an error cannot be handled*/
         usb_autopm_get_interface_no_resume(serial->interface);
-        serial->interface->needs_remote_wakeup = 0;
 }
 EXPORT_SYMBOL(usb_wwan_close);
 
-/* Helper functions used by usb_wwan_setup_urbs */
 static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
                                       int endpoint,
                                       int dir, void *ctx, char *buf, int len,
@@ -450,7 +467,6 @@ static struct urb *usb_wwan_setup_urb(struct usb_serial_port *port,
         if (!urb)
                 return NULL;
 
-        /* Fill URB using supplied data. */
         usb_fill_bulk_urb(urb, serial->dev,
                           usb_sndbulkpipe(serial->dev, endpoint) | dir,
                           buf, len, callback, ctx);
@@ -463,7 +479,6 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
         u8 *buffer;
-        int err;
         int i;
 
         if (!port->bulk_in_size || !port->bulk_out_size)
@@ -503,13 +518,6 @@ int usb_wwan_port_probe(struct usb_serial_port *port)
 
         usb_set_serial_port_data(port, portdata);
 
-        if (port->interrupt_in_urb) {
-                err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
-                if (err)
-                        dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
-                                __func__, err);
-        }
-
         return 0;
 
 bail_out_error2:
@@ -536,32 +544,28 @@ int usb_wwan_port_remove(struct usb_serial_port *port)
         portdata = usb_get_serial_port_data(port);
         usb_set_serial_port_data(port, NULL);
 
-        /* Stop reading/writing urbs and free them */
         for (i = 0; i < N_IN_URB; i++) {
-                usb_kill_urb(portdata->in_urbs[i]);
                 usb_free_urb(portdata->in_urbs[i]);
                 free_page((unsigned long)portdata->in_buffer[i]);
         }
         for (i = 0; i < N_OUT_URB; i++) {
-                usb_kill_urb(portdata->out_urbs[i]);
                 usb_free_urb(portdata->out_urbs[i]);
                 kfree(portdata->out_buffer[i]);
         }
 
-        /* Now free port private data */
         kfree(portdata);
+
         return 0;
 }
 EXPORT_SYMBOL(usb_wwan_port_remove);
 
 #ifdef CONFIG_PM
-static void stop_read_write_urbs(struct usb_serial *serial)
+static void stop_urbs(struct usb_serial *serial)
 {
         int i, j;
         struct usb_serial_port *port;
         struct usb_wwan_port_private *portdata;
 
-        /* Stop reading/writing urbs */
         for (i = 0; i < serial->num_ports; ++i) {
                 port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
@@ -571,123 +575,117 @@ static void stop_read_write_urbs(struct usb_serial *serial)
                         usb_kill_urb(portdata->in_urbs[j]);
                 for (j = 0; j < N_OUT_URB; j++)
                         usb_kill_urb(portdata->out_urbs[j]);
+                usb_kill_urb(port->interrupt_in_urb);
         }
 }
 
 int usb_wwan_suspend(struct usb_serial *serial, pm_message_t message)
 {
-        struct usb_wwan_intf_private *intfdata = serial->private;
-        int b;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
 
+        spin_lock_irq(&intfdata->susp_lock);
         if (PMSG_IS_AUTO(message)) {
-                spin_lock_irq(&intfdata->susp_lock);
-                b = intfdata->in_flight;
-                spin_unlock_irq(&intfdata->susp_lock);
-
-                if (b)
+                if (intfdata->in_flight) {
+                        spin_unlock_irq(&intfdata->susp_lock);
                         return -EBUSY;
+                }
         }
-
-        spin_lock_irq(&intfdata->susp_lock);
         intfdata->suspended = 1;
         spin_unlock_irq(&intfdata->susp_lock);
-        stop_read_write_urbs(serial);
+
+        stop_urbs(serial);
 
         return 0;
 }
 EXPORT_SYMBOL(usb_wwan_suspend);
 
-static void unbusy_queued_urb(struct urb *urb, struct usb_wwan_port_private *portdata)
+/* Caller must hold susp_lock. */
+static int usb_wwan_submit_delayed_urbs(struct usb_serial_port *port)
 {
-        int i;
-
-        for (i = 0; i < N_OUT_URB; i++) {
-                if (urb == portdata->out_urbs[i]) {
-                        clear_bit(i, &portdata->out_busy);
-                        break;
-                }
-        }
-}
-
-static void play_delayed(struct usb_serial_port *port)
-{
-        struct usb_wwan_intf_private *data;
+        struct usb_serial *serial = port->serial;
+        struct usb_wwan_intf_private *data = usb_get_serial_data(serial);
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
+        int err_count = 0;
         int err;
 
         portdata = usb_get_serial_port_data(port);
-        data = port->serial->private;
-        while ((urb = usb_get_from_anchor(&portdata->delayed))) {
-                err = usb_submit_urb(urb, GFP_ATOMIC);
-                if (!err) {
-                        data->in_flight++;
-                } else {
-                        /* we have to throw away the rest */
-                        do {
-                                unbusy_queued_urb(urb, portdata);
-                                usb_autopm_put_interface_no_suspend(port->serial->interface);
-                        } while ((urb = usb_get_from_anchor(&portdata->delayed)));
+
+        for (;;) {
+                urb = usb_get_from_anchor(&portdata->delayed);
+                if (!urb)
                         break;
+
+                err = usb_submit_urb(urb, GFP_ATOMIC);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit urb failed: %d\n",
+                                        __func__, err);
+                        err_count++;
+                        unbusy_queued_urb(urb, portdata);
+                        usb_autopm_put_interface_async(serial->interface);
+                        continue;
                 }
+                data->in_flight++;
         }
+
+        if (err_count)
+                return -EIO;
+
+        return 0;
 }
 
 int usb_wwan_resume(struct usb_serial *serial)
 {
         int i, j;
         struct usb_serial_port *port;
-        struct usb_wwan_intf_private *intfdata = serial->private;
+        struct usb_wwan_intf_private *intfdata = usb_get_serial_data(serial);
         struct usb_wwan_port_private *portdata;
         struct urb *urb;
-        int err = 0;
+        int err;
+        int err_count = 0;
 
-        /* get the interrupt URBs resubmitted unconditionally */
+        spin_lock_irq(&intfdata->susp_lock);
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                if (!port->interrupt_in_urb) {
-                        dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
+
+                if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
                         continue;
-                }
-                err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
-                dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
-                if (err < 0) {
-                        dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
-                                __func__, err);
-                        goto err_out;
-                }
-        }
 
-        for (i = 0; i < serial->num_ports; i++) {
-                /* walk all ports */
-                port = serial->port[i];
                 portdata = usb_get_serial_port_data(port);
 
-                /* skip closed ports */
-                spin_lock_irq(&intfdata->susp_lock);
-                if (!portdata || !portdata->opened) {
-                        spin_unlock_irq(&intfdata->susp_lock);
-                        continue;
+                if (port->interrupt_in_urb) {
+                        err = usb_submit_urb(port->interrupt_in_urb,
+                                        GFP_ATOMIC);
+                        if (err) {
+                                dev_err(&port->dev,
+                                        "%s: submit int urb failed: %d\n",
+                                        __func__, err);
+                                err_count++;
+                        }
                 }
 
+                err = usb_wwan_submit_delayed_urbs(port);
+                if (err)
+                        err_count++;
+
                 for (j = 0; j < N_IN_URB; j++) {
                         urb = portdata->in_urbs[j];
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err < 0) {
-                                dev_err(&port->dev, "%s: Error %d for bulk URB %d\n",
-                                        __func__, err, i);
-                                spin_unlock_irq(&intfdata->susp_lock);
-                                goto err_out;
+                                dev_err(&port->dev,
+                                        "%s: submit read urb %d failed: %d\n",
+                                        __func__, i, err);
+                                err_count++;
                         }
                 }
-                play_delayed(port);
-                spin_unlock_irq(&intfdata->susp_lock);
         }
-        spin_lock_irq(&intfdata->susp_lock);
         intfdata->suspended = 0;
         spin_unlock_irq(&intfdata->susp_lock);
-err_out:
-        return err;
+
+        if (err_count)
+                return -EIO;
+
+        return 0;
 }
 EXPORT_SYMBOL(usb_wwan_resume);
 #endif
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
index 1bfc9a6cab5f..ef6efb55dc31 100644
--- a/drivers/usb/storage/ene_ub6250.c
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -1928,11 +1928,10 @@ static int ene_load_bincode(struct us_data *us, unsigned char flag)
                 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
                 goto nofw;
         }
-        buf = kmalloc(sd_fw->size, GFP_KERNEL);
+        buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
         if (buf == NULL)
                 goto nofw;
 
-        memcpy(buf, sd_fw->data, sd_fw->size);
         memset(bcb, 0, sizeof(struct bulk_cb_wrap));
         bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
         bcb->DataTransferLength = sd_fw->size;
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index 6d6da127f6de..a80c5d284b59 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -524,7 +524,7 @@ void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 
                 usb_control_msg(
-                        wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
+                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                         USB_REQ_RPIPE_ABORT,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                         0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
@@ -545,7 +545,7 @@ void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
                 u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
 
                 usb_control_msg(
-                        wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
+                        wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                         USB_REQ_CLEAR_FEATURE,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                         RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
diff --git a/drivers/uwb/beacon.c b/drivers/uwb/beacon.c
index 57b5ff61020c..f40745fcbd34 100644
--- a/drivers/uwb/beacon.c
+++ b/drivers/uwb/beacon.c
@@ -125,8 +125,10 @@ int uwb_rc_beacon(struct uwb_rc *rc, int channel, unsigned bpst_offset)
         else {
                 /* channel >= 0...dah */
                 result = uwb_rc_start_beacon(rc, bpst_offset, channel);
-                if (result < 0)
+                if (result < 0) {
+                        dev_err(dev, "Cannot start beaconing: %d\n", result);
                         return result;
+                }
                 if (le16_to_cpu(rc->ies->wIELength) > 0) {
                         result = uwb_rc_set_ie(rc, rc->ies);
                         if (result < 0) {
@@ -395,7 +397,6 @@ int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
         struct uwb_rc_evt_beacon *be;
         struct uwb_beacon_frame *bf;
         struct uwb_beca_e *bce;
-        unsigned long last_ts;
 
         rc = evt->rc;
         be = container_of(evt->notif.rceb, struct uwb_rc_evt_beacon, rceb);
@@ -439,8 +440,6 @@ int uwbd_evt_handle_rc_beacon(struct uwb_event *evt)
         /* purge old beacon data */
         kfree(bce->be);
 
-        last_ts = bce->ts_jiffies;
-
         /* Update commonly used fields */
         bce->ts_jiffies = evt->ts_jiffies;
         bce->be = be;
diff --git a/drivers/uwb/drp.c b/drivers/uwb/drp.c
index 468c89fb6a16..05b7bd762254 100644
--- a/drivers/uwb/drp.c
+++ b/drivers/uwb/drp.c
@@ -29,19 +29,19 @@
 enum uwb_drp_conflict_action {
         /* Reservation is maintained, no action needed */
         UWB_DRP_CONFLICT_MANTAIN = 0,
-        
+
         /* the device shall not transmit frames in conflicting MASs in
          * the following superframe. If the device is the reservation
          * target, it shall also set the Reason Code in its DRP IE to
          * Conflict in its beacon in the following superframe.
          */
         UWB_DRP_CONFLICT_ACT1,
-        
+
         /* the device shall not set the Reservation Status bit to ONE
          * and shall not transmit frames in conflicting MASs. If the
          * device is the reservation target, it shall also set the
          * Reason Code in its DRP IE to Conflict.
-         */     
+         */
         UWB_DRP_CONFLICT_ACT2,
 
         /* the device shall not transmit frames in conflicting MASs in
@@ -115,7 +115,8 @@ int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
                         if (uwb_rsv_has_two_drp_ies(rsv) &&
                                 (rsv->mv.companion_drp_ie != NULL)) {
                                 mv = &rsv->mv;
-                                num_bytes += mv->companion_drp_ie->hdr.length + 2;      
+                                num_bytes +=
+                                        mv->companion_drp_ie->hdr.length + 2;
                         }
                 }
         }
@@ -139,21 +140,23 @@ int uwb_rc_send_all_drp_ie(struct uwb_rc *rc)
                         memcpy(IEDataptr, rsv->drp_ie,
                                rsv->drp_ie->hdr.length + 2);
                         IEDataptr += rsv->drp_ie->hdr.length + 2;
-                        
+
                         if (uwb_rsv_has_two_drp_ies(rsv) &&
                                 (rsv->mv.companion_drp_ie != NULL)) {
                                 mv = &rsv->mv;
                                 memcpy(IEDataptr, mv->companion_drp_ie,
                                        mv->companion_drp_ie->hdr.length + 2);
-                                IEDataptr += mv->companion_drp_ie->hdr.length + 2;      
+                                IEDataptr +=
+                                        mv->companion_drp_ie->hdr.length + 2;
                         }
                 }
         }
 
-        result = uwb_rc_cmd_async(rc, "SET-DRP-IE", &cmd->rccb, sizeof(*cmd) + num_bytes,
-                                  UWB_RC_CET_GENERAL, UWB_RC_CMD_SET_DRP_IE,
-                                  uwb_rc_set_drp_cmd_done, NULL);
-        
+        result = uwb_rc_cmd_async(rc, "SET-DRP-IE",
+                                &cmd->rccb, sizeof(*cmd) + num_bytes,
+                                UWB_RC_CET_GENERAL, UWB_RC_CMD_SET_DRP_IE,
+                                uwb_rc_set_drp_cmd_done, NULL);
+
         rc->set_drp_ie_pending = 1;
 
         kfree(cmd);
@@ -176,8 +179,8 @@ static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beaco
         int ext_tie_breaker = uwb_ie_drp_tiebreaker(ext_drp_ie);
         int ext_status      = uwb_ie_drp_status(ext_drp_ie);
         int ext_type        = uwb_ie_drp_type(ext_drp_ie);
-        
-        
+
+
         /* [ECMA-368 2nd Edition] 17.4.6 */
         if (ext_type == UWB_DRP_TYPE_PCA && our_type == UWB_DRP_TYPE_PCA) {
                 return UWB_DRP_CONFLICT_MANTAIN;
@@ -187,7 +190,7 @@ static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beaco
         if (our_type == UWB_DRP_TYPE_ALIEN_BP) {
                 return UWB_DRP_CONFLICT_MANTAIN;
         }
-        
+
         /* [ECMA-368 2nd Edition] 17.4.6-2 */
         if (ext_type == UWB_DRP_TYPE_ALIEN_BP) {
                 /* here we know our_type != UWB_DRP_TYPE_ALIEN_BP */
@@ -215,7 +218,7 @@ static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beaco
             our_beacon_slot >  ext_beacon_slot) {
                 return UWB_DRP_CONFLICT_MANTAIN;
         }
-        
+
         if (our_status == 0) {
                 if (our_tie_breaker == ext_tie_breaker) {
                         /* [ECMA-368 2nd Edition] 17.4.6-6a */
@@ -244,9 +247,9 @@ static int evaluate_conflict_action(struct uwb_ie_drp *ext_drp_ie, int ext_beaco
         return UWB_DRP_CONFLICT_MANTAIN;
 }
 
-static void handle_conflict_normal(struct uwb_ie_drp *drp_ie, 
-                                   int ext_beacon_slot, 
-                                   struct uwb_rsv *rsv, 
+static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
+                                   int ext_beacon_slot,
+                                   struct uwb_rsv *rsv,
                                    struct uwb_mas_bm *conflicting_mas)
 {
         struct uwb_rc *rc = rsv->rc;
@@ -263,7 +266,7 @@ static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_TO_BE_MOVED);
                         if (bow->can_reserve_extra_mases == false)
                                 uwb_rsv_backoff_win_increment(rc);
-                        
+
                         break;
                 case UWB_DRP_CONFLICT_ACT3:
                         uwb_rsv_backoff_win_increment(rc);
@@ -278,13 +281,13 @@ static void handle_conflict_normal(struct uwb_ie_drp *drp_ie,
                 switch(action) {
                 case UWB_DRP_CONFLICT_ACT2:
                 case UWB_DRP_CONFLICT_ACT3:
-                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);       
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
                 default:
                         break;
                 }
 
         }
-        
+
 }
 
 static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_slot,
@@ -295,7 +298,7 @@ static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_
         struct uwb_drp_backoff_win *bow = &rc->bow;
         struct uwb_rsv_move *mv = &rsv->mv;
         int action;
-        
+
         if (companion_only) {
                 /* status of companion is 0 at this point */
                 action = evaluate_conflict_action(drp_ie, ext_beacon_slot, rsv, 0);
@@ -303,21 +306,24 @@ static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_
                         switch(action) {
                         case UWB_DRP_CONFLICT_ACT2:
                         case UWB_DRP_CONFLICT_ACT3:
-                                uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
+                                uwb_rsv_set_state(rsv,
+                                                UWB_RSV_STATE_O_ESTABLISHED);
                                 rsv->needs_release_companion_mas = false;
                                 if (bow->can_reserve_extra_mases == false)
                                         uwb_rsv_backoff_win_increment(rc);
-                                uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
+                                uwb_drp_avail_release(rsv->rc,
+                                                &rsv->mv.companion_mas);
                         }
-                } else { /* rsv is target */                    
+                } else { /* rsv is target */
                         switch(action) {
                         case UWB_DRP_CONFLICT_ACT2:
                         case UWB_DRP_CONFLICT_ACT3:
-                                uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_CONFLICT);
+                                uwb_rsv_set_state(rsv,
+                                        UWB_RSV_STATE_T_EXPANDING_CONFLICT);
                                 /* send_drp_avail_ie = true; */
                         }
                 }
-        } else { /* also base part of the reservation is conflicting */         
+        } else { /* also base part of the reservation is conflicting */
                 if (uwb_rsv_is_owner(rsv)) {
                         uwb_rsv_backoff_win_increment(rc);
                         /* remove companion part */
@@ -326,7 +332,8 @@ static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_
                         /* drop some mases with reason modified */
 
                         /* put in the companion the mases to be dropped */
-                        bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS);
+                        bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm,
+                                        conflicting_mas->bm, UWB_NUM_MAS);
                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
                 } else { /* it is a target rsv */
                         uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
@@ -336,7 +343,7 @@ static void handle_conflict_expanding(struct uwb_ie_drp *drp_ie, int ext_beacon_
 }
 
 static void uwb_drp_handle_conflict_rsv(struct uwb_rc *rc, struct uwb_rsv *rsv,
-                                        struct uwb_rc_evt_drp *drp_evt, 
+                                        struct uwb_rc_evt_drp *drp_evt,
                                         struct uwb_ie_drp *drp_ie,
                                         struct uwb_mas_bm *conflicting_mas)
 {
@@ -345,83 +352,107 @@ static void uwb_drp_handle_conflict_rsv(struct uwb_rc *rc, struct uwb_rsv *rsv,
         /* check if the conflicting reservation has two drp_ies */
         if (uwb_rsv_has_two_drp_ies(rsv)) {
                 mv = &rsv->mv;
-                if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
-                        handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
-                                                  rsv, false, conflicting_mas);
+                if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm,
+                                                                UWB_NUM_MAS)) {
+                        handle_conflict_expanding(drp_ie,
+                                                drp_evt->beacon_slot_number,
+                                                rsv, false, conflicting_mas);
                 } else {
-                        if (bitmap_intersects(mv->companion_mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
-                                handle_conflict_expanding(drp_ie, drp_evt->beacon_slot_number,
-                                                          rsv, true, conflicting_mas);  
+                        if (bitmap_intersects(mv->companion_mas.bm,
+                                        conflicting_mas->bm, UWB_NUM_MAS)) {
+                                handle_conflict_expanding(
+                                        drp_ie, drp_evt->beacon_slot_number,
+                                        rsv, true, conflicting_mas);
                         }
                 }
-        } else if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm, UWB_NUM_MAS)) {
-                handle_conflict_normal(drp_ie, drp_evt->beacon_slot_number, rsv, conflicting_mas);
+        } else if (bitmap_intersects(rsv->mas.bm, conflicting_mas->bm,
+                                                        UWB_NUM_MAS)) {
+                handle_conflict_normal(drp_ie, drp_evt->beacon_slot_number,
+                                        rsv, conflicting_mas);
         }
 }
 
 static void uwb_drp_handle_all_conflict_rsv(struct uwb_rc *rc,
-                                            struct uwb_rc_evt_drp *drp_evt, 
+                                            struct uwb_rc_evt_drp *drp_evt,
                                             struct uwb_ie_drp *drp_ie,
                                             struct uwb_mas_bm *conflicting_mas)
 {
         struct uwb_rsv *rsv;
-        
+
         list_for_each_entry(rsv, &rc->reservations, rc_node) {
-                uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie, conflicting_mas); 
+                uwb_drp_handle_conflict_rsv(rc, rsv, drp_evt, drp_ie,
+                                                        conflicting_mas);
+        }
+}
+
+static void uwb_drp_process_target_accepted(struct uwb_rc *rc,
+        struct uwb_rsv *rsv, struct uwb_rc_evt_drp *drp_evt,
+        struct uwb_ie_drp *drp_ie, struct uwb_mas_bm *mas)
+{
+        struct uwb_rsv_move *mv = &rsv->mv;
+        int status;
+
+        status = uwb_ie_drp_status(drp_ie);
+
+        if (rsv->state == UWB_RSV_STATE_T_CONFLICT) {
+                uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
+                return;
+        }
+
+        if (rsv->state == UWB_RSV_STATE_T_EXPANDING_ACCEPTED) {
+                /* drp_ie is companion */
+                if (!bitmap_equal(rsv->mas.bm, mas->bm, UWB_NUM_MAS)) {
+                        /* stroke companion */
+                        uwb_rsv_set_state(rsv,
+                                UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
+                }
+        } else {
+                if (!bitmap_equal(rsv->mas.bm, mas->bm, UWB_NUM_MAS)) {
+                        if (uwb_drp_avail_reserve_pending(rc, mas) == -EBUSY) {
+                                /* FIXME: there is a conflict, find
+                                 * the conflicting reservations and
+                                 * take a sensible action. Consider
+                                 * that in drp_ie there is the
+                                 * "neighbour" */
+                                uwb_drp_handle_all_conflict_rsv(rc, drp_evt,
+                                                drp_ie, mas);
+                        } else {
+                                /* accept the extra reservation */
+                                bitmap_copy(mv->companion_mas.bm, mas->bm,
+                                                                UWB_NUM_MAS);
+                                uwb_rsv_set_state(rsv,
+                                        UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
+                        }
+                } else {
+                        if (status) {
+                                uwb_rsv_set_state(rsv,
+                                                UWB_RSV_STATE_T_ACCEPTED);
+                        }
+                }
+
         }
 }
-        
+
 /*
  * Based on the DRP IE, transition a target reservation to a new
  * state.
  */
 static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
-                                   struct uwb_ie_drp *drp_ie, struct uwb_rc_evt_drp *drp_evt)
+                   struct uwb_ie_drp *drp_ie, struct uwb_rc_evt_drp *drp_evt)
 {
         struct device *dev = &rc->uwb_dev.dev;
         struct uwb_rsv_move *mv = &rsv->mv;
         int status;
         enum uwb_drp_reason reason_code;
         struct uwb_mas_bm mas;
-        
+
         status = uwb_ie_drp_status(drp_ie);
         reason_code = uwb_ie_drp_reason_code(drp_ie);
         uwb_drp_ie_to_bm(&mas, drp_ie);
 
         switch (reason_code) {
         case UWB_DRP_REASON_ACCEPTED:
-
-                if (rsv->state == UWB_RSV_STATE_T_CONFLICT) {
-                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_CONFLICT);
-                        break;
-                }
-
-                if (rsv->state == UWB_RSV_STATE_T_EXPANDING_ACCEPTED) {
-                        /* drp_ie is companion */
-                        if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS))
-                                /* stroke companion */
-                                uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);     
-                } else {
-                        if (!bitmap_equal(rsv->mas.bm, mas.bm, UWB_NUM_MAS)) {
-                                if (uwb_drp_avail_reserve_pending(rc, &mas) == -EBUSY) {
-                                        /* FIXME: there is a conflict, find
-                                         * the conflicting reservations and
-                                         * take a sensible action. Consider
-                                         * that in drp_ie there is the
-                                         * "neighbour" */
-                                        uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
-                                } else {
-                                        /* accept the extra reservation */
-                                        bitmap_copy(mv->companion_mas.bm, mas.bm, UWB_NUM_MAS);
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_EXPANDING_ACCEPTED);
-                                }
-                        } else {
-                                if (status) {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
-                                }
-                        }
-                        
-                }
+                uwb_drp_process_target_accepted(rc, rsv, drp_evt, drp_ie, &mas);
                 break;
 
         case UWB_DRP_REASON_MODIFIED:
@@ -434,7 +465,8 @@ static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
                 /* find if the owner wants to expand or reduce */
                 if (bitmap_subset(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
                         /* owner is reducing */
-                        bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mas.bm, UWB_NUM_MAS);
+                        bitmap_andnot(mv->companion_mas.bm, rsv->mas.bm, mas.bm,
+                                UWB_NUM_MAS);
                         uwb_drp_avail_release(rsv->rc, &mv->companion_mas);
                 }
 
@@ -447,6 +479,48 @@ static void uwb_drp_process_target(struct uwb_rc *rc, struct uwb_rsv *rsv,
         }
 }
 
+static void uwb_drp_process_owner_accepted(struct uwb_rsv *rsv,
+                                                struct uwb_mas_bm *mas)
+{
+        struct uwb_rsv_move *mv = &rsv->mv;
+
+        switch (rsv->state) {
+        case UWB_RSV_STATE_O_PENDING:
+        case UWB_RSV_STATE_O_INITIATED:
+        case UWB_RSV_STATE_O_ESTABLISHED:
+                uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
+                break;
+        case UWB_RSV_STATE_O_MODIFIED:
+                if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
+                else
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);
+                break;
+
+        case UWB_RSV_STATE_O_MOVE_REDUCING: /* shouldn' t be a problem */
+                if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
+                else
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
+                break;
+        case UWB_RSV_STATE_O_MOVE_EXPANDING:
+                if (bitmap_equal(mas->bm, mv->companion_mas.bm, UWB_NUM_MAS)) {
+                        /* Companion reservation accepted */
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
+                } else {
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
+                }
+                break;
+        case UWB_RSV_STATE_O_MOVE_COMBINING:
+                if (bitmap_equal(mas->bm, rsv->mas.bm, UWB_NUM_MAS))
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
+                else
+                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
+                break;
+        default:
+                break;
+        }
+}
 /*
  * Based on the DRP IE, transition an owner reservation to a new
  * state.
@@ -456,7 +530,6 @@ static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
                                   struct uwb_rc_evt_drp *drp_evt)
 {
         struct device *dev = &rc->uwb_dev.dev;
-        struct uwb_rsv_move *mv = &rsv->mv;
         int status;
         enum uwb_drp_reason reason_code;
         struct uwb_mas_bm mas;
@@ -468,44 +541,7 @@ static void uwb_drp_process_owner(struct uwb_rc *rc, struct uwb_rsv *rsv,
         if (status) {
                 switch (reason_code) {
                 case UWB_DRP_REASON_ACCEPTED:
-                        switch (rsv->state) {
-                        case UWB_RSV_STATE_O_PENDING:
-                        case UWB_RSV_STATE_O_INITIATED:
-                        case UWB_RSV_STATE_O_ESTABLISHED:
-                                uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
-                                break;
-                        case UWB_RSV_STATE_O_MODIFIED:
-                                if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
-                                } else {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MODIFIED);       
-                                }
-                                break;
-                                
-                        case UWB_RSV_STATE_O_MOVE_REDUCING: /* shouldn' t be a problem */
-                                if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS)) {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_ESTABLISHED);
-                                } else {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);  
-                                }
-                                break;
-                        case UWB_RSV_STATE_O_MOVE_EXPANDING:
-                                if (bitmap_equal(mas.bm, mv->companion_mas.bm, UWB_NUM_MAS)) {
-                                        /* Companion reservation accepted */
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
-                                } else {
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_EXPANDING);
-                                }
-                                break;
-                        case UWB_RSV_STATE_O_MOVE_COMBINING:
-                                if (bitmap_equal(mas.bm, rsv->mas.bm, UWB_NUM_MAS))
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_REDUCING);
-                                else
-                                        uwb_rsv_set_state(rsv, UWB_RSV_STATE_O_MOVE_COMBINING);
-                                break;
-                        default:
-                                break;  
-                        }
+                        uwb_drp_process_owner_accepted(rsv, &mas);
                         break;
                 default:
                         dev_warn(dev, "ignoring invalid DRP IE state (%d/%d)\n",
@@ -545,9 +581,9 @@ static void uwb_cnflt_update_work(struct work_struct *work)
                                                      cnflt_update_work);
         struct uwb_cnflt_alien *c;
         struct uwb_rc *rc = cnflt->rc;
-        
+
         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
-        
+
         mutex_lock(&rc->rsvs_mutex);
 
         list_del(&cnflt->rc_node);
@@ -556,10 +592,12 @@ static void uwb_cnflt_update_work(struct work_struct *work)
         bitmap_zero(rc->cnflt_alien_bitmap.bm, UWB_NUM_MAS);
 
         list_for_each_entry(c, &rc->cnflt_alien_list, rc_node) {
-                bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, c->mas.bm, UWB_NUM_MAS);                        
+                bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm,
+                                                c->mas.bm, UWB_NUM_MAS);
         }
-        
-        queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
+
+        queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work,
+                                        usecs_to_jiffies(delay_us));
 
         kfree(cnflt);
         mutex_unlock(&rc->rsvs_mutex);
@@ -583,10 +621,10 @@ static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_i
         struct uwb_cnflt_alien *cnflt;
         char buf[72];
         unsigned long delay_us = UWB_MAS_LENGTH_US * UWB_MAS_PER_ZONE;
-        
+
         uwb_drp_ie_to_bm(&mas, drp_ie);
         bitmap_scnprintf(buf, sizeof(buf), mas.bm, UWB_NUM_MAS);
-        
+
         list_for_each_entry(cnflt, &rc->cnflt_alien_list, rc_node) {
                 if (bitmap_equal(cnflt->mas.bm, mas.bm, UWB_NUM_MAS)) {
                         /* Existing alien BP reservation conflicting
@@ -612,7 +650,7 @@ static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_i
 
         cnflt->rc = rc;
         INIT_WORK(&cnflt->cnflt_update_work, uwb_cnflt_update_work);
-        
+
         bitmap_copy(cnflt->mas.bm, mas.bm, UWB_NUM_MAS);
 
         list_add_tail(&cnflt->rc_node, &rc->cnflt_alien_list);
@@ -621,17 +659,17 @@ static void uwb_drp_handle_alien_drp(struct uwb_rc *rc, struct uwb_ie_drp *drp_i
         bitmap_or(rc->cnflt_alien_bitmap.bm, rc->cnflt_alien_bitmap.bm, mas.bm, UWB_NUM_MAS);
 
         queue_delayed_work(rc->rsv_workq, &rc->rsv_alien_bp_work, usecs_to_jiffies(delay_us));
-        
+
         /* start the timer */
         uwb_cnflt_alien_stroke_timer(cnflt);
 }
 
 static void uwb_drp_process_not_involved(struct uwb_rc *rc,
-                                         struct uwb_rc_evt_drp *drp_evt, 
+                                         struct uwb_rc_evt_drp *drp_evt,
                                          struct uwb_ie_drp *drp_ie)
 {
         struct uwb_mas_bm mas;
-        
+
         uwb_drp_ie_to_bm(&mas, drp_ie);
         uwb_drp_handle_all_conflict_rsv(rc, drp_evt, drp_ie, &mas);
 }
@@ -651,7 +689,7 @@ static void uwb_drp_process_involved(struct uwb_rc *rc, struct uwb_dev *src,
                  */
                 return;
         }
-        
+
         /*
          * Do nothing with DRP IEs for reservations that have been
          * terminated.
@@ -660,12 +698,12 @@ static void uwb_drp_process_involved(struct uwb_rc *rc, struct uwb_dev *src,
                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_NONE);
                 return;
         }
-                        
+
         if (uwb_ie_drp_owner(drp_ie))
                 uwb_drp_process_target(rc, rsv, drp_ie, drp_evt);
         else
                 uwb_drp_process_owner(rc, rsv, src, drp_ie, drp_evt);
-        
+
 }
 
 
diff --git a/drivers/uwb/est.c b/drivers/uwb/est.c
index 457f31d99bf4..f3e232584284 100644
--- a/drivers/uwb/est.c
+++ b/drivers/uwb/est.c
@@ -258,7 +258,6 @@ int uwb_est_register(u8 type, u8 event_high, u16 vendor, u16 product,
 {
         unsigned long flags;
         unsigned itr;
-        u16 type_event_high;
         int result = 0;
 
         write_lock_irqsave(&uwb_est_lock, flags);
@@ -268,7 +267,6 @@ int uwb_est_register(u8 type, u8 event_high, u16 vendor, u16 product,
                         goto out;
         }
         /* Find the right spot to insert it in */
-        type_event_high = type << 8 | event_high;
         for (itr = 0; itr < uwb_est_used; itr++)
                 if (uwb_est[itr].type_event_high < type
                     && uwb_est[itr].vendor < vendor
diff --git a/drivers/uwb/ie-rcv.c b/drivers/uwb/ie-rcv.c
index 917e6d78a798..5fac5744a699 100644
--- a/drivers/uwb/ie-rcv.c
+++ b/drivers/uwb/ie-rcv.c
@@ -31,7 +31,6 @@ int uwbd_evt_handle_rc_ie_rcv(struct uwb_event *evt)
         int result = -EINVAL;
         struct device *dev = &evt->rc->uwb_dev.dev;
         struct uwb_rc_evt_ie_rcv *iercv;
-        size_t iesize;
 
         /* Is there enough data to decode it? */
         if (evt->notif.size < sizeof(*iercv)) {
@@ -41,7 +40,6 @@ int uwbd_evt_handle_rc_ie_rcv(struct uwb_event *evt)
                 goto error;
         }
         iercv = container_of(evt->notif.rceb, struct uwb_rc_evt_ie_rcv, rceb);
-        iesize = le16_to_cpu(iercv->wIELength);
 
         dev_dbg(dev, "IE received, element ID=%d\n", iercv->IEData[0]);
 
diff --git a/drivers/uwb/radio.c b/drivers/uwb/radio.c
index fd23d985ea71..2427e944883d 100644
--- a/drivers/uwb/radio.c
+++ b/drivers/uwb/radio.c
@@ -115,7 +115,7 @@ int uwb_radio_start(struct uwb_pal *pal)
 EXPORT_SYMBOL_GPL(uwb_radio_start);
 
 /**
- * uwb_radio_stop - request tha the radio be stopped.
+ * uwb_radio_stop - request that the radio be stopped.
  * @pal: the PAL making the request.
  *
  * Stops the radio if no other PAL is making use of it.
diff --git a/drivers/uwb/rsv.c b/drivers/uwb/rsv.c
index 3fe611941046..0887ae982783 100644
--- a/drivers/uwb/rsv.c
+++ b/drivers/uwb/rsv.c
@@ -163,8 +163,10 @@ static int uwb_rsv_get_stream(struct uwb_rsv *rsv)
         }
 
         stream = find_first_zero_bit(streams_bm, UWB_NUM_STREAMS);
-        if (stream >= UWB_NUM_STREAMS)
+        if (stream >= UWB_NUM_STREAMS) {
+                dev_err(dev, "%s: no available stream found\n", __func__);
                 return -EBUSY;
+        }
 
         rsv->stream = stream;
         set_bit(stream, streams_bm);
@@ -249,7 +251,9 @@ static void uwb_rsv_stroke_timer(struct uwb_rsv *rsv)
          * super frame and should not be terminated if no response is
          * received.
          */
-        if (rsv->is_multicast) {
+        if (rsv->state == UWB_RSV_STATE_NONE) {
+                sframes = 0;
+        } else if (rsv->is_multicast) {
                 if (rsv->state == UWB_RSV_STATE_O_INITIATED
                     || rsv->state == UWB_RSV_STATE_O_MOVE_EXPANDING
                     || rsv->state == UWB_RSV_STATE_O_MOVE_COMBINING
@@ -322,6 +326,7 @@ void uwb_rsv_set_state(struct uwb_rsv *rsv, enum uwb_rsv_state new_state)
         switch (new_state) {
         case UWB_RSV_STATE_NONE:
                 uwb_rsv_state_update(rsv, UWB_RSV_STATE_NONE);
+                uwb_rsv_remove(rsv);
                 uwb_rsv_callback(rsv);
                 break;
         case UWB_RSV_STATE_O_INITIATED:
@@ -442,6 +447,8 @@ static void uwb_rsv_handle_timeout_work(struct work_struct *work)
                 uwb_rsv_set_state(rsv, UWB_RSV_STATE_T_ACCEPTED);
                 uwb_drp_avail_release(rsv->rc, &rsv->mv.companion_mas);
                 goto unlock;
+        case UWB_RSV_STATE_NONE:
+                goto unlock;
         default:
                 break;
         }
@@ -550,12 +557,16 @@ int uwb_rsv_establish(struct uwb_rsv *rsv)
 {
         struct uwb_rc *rc = rsv->rc;
         struct uwb_mas_bm available;
+        struct device *dev = &rc->uwb_dev.dev;
         int ret;
 
         mutex_lock(&rc->rsvs_mutex);
         ret = uwb_rsv_get_stream(rsv);
-        if (ret)
+        if (ret) {
+                dev_err(dev, "%s: uwb_rsv_get_stream failed: %d\n",
+                        __func__, ret);
                 goto out;
+        }
 
         rsv->tiebreaker = prandom_u32() & 1;
         /* get available mas bitmap */
@@ -565,12 +576,16 @@ int uwb_rsv_establish(struct uwb_rsv *rsv)
         if (ret == UWB_RSV_ALLOC_NOT_FOUND) {
                 ret = -EBUSY;
                 uwb_rsv_put_stream(rsv);
+                dev_err(dev, "%s: uwb_rsv_find_best_allocation failed: %d\n",
+                        __func__, ret);
                 goto out;
         }
 
         ret = uwb_drp_avail_reserve_pending(rc, &rsv->mas);
         if (ret != 0) {
                 uwb_rsv_put_stream(rsv);
+                dev_err(dev, "%s: uwb_drp_avail_reserve_pending failed: %d\n",
+                        __func__, ret);
                 goto out;
         }
 
diff --git a/include/linux/mfd/syscon/exynos5-pmu.h b/include/linux/mfd/syscon/exynos5-pmu.h
new file mode 100644
index 000000000000..00ef24bf6ede
--- /dev/null
+++ b/include/linux/mfd/syscon/exynos5-pmu.h
@@ -0,0 +1,44 @@
+/*
+ * Exynos5 SoC series Power Management Unit (PMU) register offsets
+ * and bit definitions.
+ *
+ * Copyright (C) 2014 Samsung Electronics Co., Ltd.
+ *
+ * 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 _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_
+#define _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_
+
+/* Exynos5 PMU register definitions */
+#define EXYNOS5_HDMI_PHY_CONTROL                (0x700)
+#define EXYNOS5_USBDRD_PHY_CONTROL              (0x704)
+
+/* Exynos5250 specific register definitions */
+#define EXYNOS5_USBHOST_PHY_CONTROL             (0x708)
+#define EXYNOS5_EFNAND_PHY_CONTROL              (0x70c)
+#define EXYNOS5_MIPI_PHY0_CONTROL               (0x710)
+#define EXYNOS5_MIPI_PHY1_CONTROL               (0x714)
+#define EXYNOS5_ADC_PHY_CONTROL                 (0x718)
+#define EXYNOS5_MTCADC_PHY_CONTROL              (0x71c)
+#define EXYNOS5_DPTX_PHY_CONTROL                (0x720)
+#define EXYNOS5_SATA_PHY_CONTROL                (0x724)
+
+/* Exynos5420 specific register definitions */
+#define EXYNOS5420_USBDRD1_PHY_CONTROL          (0x708)
+#define EXYNOS5420_USBHOST_PHY_CONTROL          (0x70c)
+#define EXYNOS5420_MIPI_PHY0_CONTROL            (0x714)
+#define EXYNOS5420_MIPI_PHY1_CONTROL            (0x718)
+#define EXYNOS5420_MIPI_PHY2_CONTROL            (0x71c)
+#define EXYNOS5420_ADC_PHY_CONTROL              (0x720)
+#define EXYNOS5420_MTCADC_PHY_CONTROL           (0x724)
+#define EXYNOS5420_DPTX_PHY_CONTROL             (0x728)
+
+#define EXYNOS5_PHY_ENABLE                      BIT(0)
+
+#define EXYNOS5_MIPI_PHY_S_RESETN               BIT(1)
+#define EXYNOS5_MIPI_PHY_M_RESETN               BIT(2)
+
+#endif /* _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_ */
diff --git a/include/linux/platform_data/max3421-hcd.h b/include/linux/platform_data/max3421-hcd.h
new file mode 100644
index 000000000000..0303d1970084
--- /dev/null
+++ b/include/linux/platform_data/max3421-hcd.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2014 eGauge Systems LLC
+ *      Contributed by David Mosberger-Tang <davidm@egauge.net>
+ *
+ * Platform-data structure for MAX3421 USB HCD driver.
+ *
+ */
+#ifndef MAX3421_HCD_PLAT_H_INCLUDED
+#define MAX3421_HCD_PLAT_H_INCLUDED
+
+/*
+ * This structure defines the mapping of certain auxiliary functions to the
+ * MAX3421E GPIO pins.  The chip has eight GP inputs and eight GP outputs.
+ * A value of 0 indicates that the pin is not used/wired to anything.
+ *
+ * At this point, the only control the max3421-hcd driver cares about is
+ * to control Vbus (5V to the peripheral).
+ */
+struct max3421_hcd_platform_data {
+        u8 vbus_gpout;                  /* pin controlling Vbus */
+        u8 vbus_active_level;           /* level that turns on power */
+};
+
+#endif /* MAX3421_HCD_PLAT_H_INCLUDED */
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 6b7ec376fb4d..d2465bc0e73c 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -352,6 +352,8 @@ struct usb_bus {
         struct usb_bus *hs_companion;   /* Companion EHCI bus, if any */
         struct list_head bus_list;      /* list of busses */
 
+        struct mutex usb_address0_mutex; /* unaddressed device mutex */
+
         int bandwidth_allocated;        /* on this bus: how much of the time
                                          * reserved for periodic (intr/iso)
                                          * requests is used, on average?
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index d3ca3b53837c..7373203140e7 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -57,6 +57,61 @@
 struct usb_configuration;
 
 /**
+ * struct usb_os_desc_ext_prop - describes one "Extended Property"
+ * @entry: used to keep a list of extended properties
+ * @type: Extended Property type
+ * @name_len: Extended Property unicode name length, including terminating '\0'
+ * @name: Extended Property name
+ * @data_len: Length of Extended Property blob (for unicode store double len)
+ * @data: Extended Property blob
+ * @item: Represents this Extended Property in configfs
+ */
+struct usb_os_desc_ext_prop {
+        struct list_head        entry;
+        u8                      type;
+        int                     name_len;
+        char                    *name;
+        int                     data_len;
+        char                    *data;
+        struct config_item      item;
+};
+
+/**
+ * struct usb_os_desc - describes OS descriptors associated with one interface
+ * @ext_compat_id: 16 bytes of "Compatible ID" and "Subcompatible ID"
+ * @ext_prop: Extended Properties list
+ * @ext_prop_len: Total length of Extended Properties blobs
+ * @ext_prop_count: Number of Extended Properties
+ * @opts_mutex: Optional mutex protecting config data of a usb_function_instance
+ * @group: Represents OS descriptors associated with an interface in configfs
+ * @owner: Module associated with this OS descriptor
+ */
+struct usb_os_desc {
+        char                    *ext_compat_id;
+        struct list_head        ext_prop;
+        int                     ext_prop_len;
+        int                     ext_prop_count;
+        struct mutex            *opts_mutex;
+        struct config_group     group;
+        struct module           *owner;
+};
+
+/**
+ * struct usb_os_desc_table - describes OS descriptors associated with one
+ * interface of a usb_function
+ * @if_id: Interface id
+ * @os_desc: "Extended Compatibility ID" and "Extended Properties" of the
+ *      interface
+ *
+ * Each interface can have at most one "Extended Compatibility ID" and a
+ * number of "Extended Properties".
+ */
+struct usb_os_desc_table {
+        int                     if_id;
+        struct usb_os_desc      *os_desc;
+};
+
+/**
  * struct usb_function - describes one function of a configuration
  * @name: For diagnostics, identifies the function.
  * @strings: tables of strings, keyed by identifiers assigned during bind()
@@ -73,6 +128,10 @@ struct usb_configuration;
  *      be available at super speed.
  * @config: assigned when @usb_add_function() is called; this is the
  *      configuration with which this function is associated.
+ * @os_desc_table: Table of (interface id, os descriptors) pairs. The function
+ *      can expose more than one interface. If an interface is a member of
+ *      an IAD, only the first interface of IAD has its entry in the table.
+ * @os_desc_n: Number of entries in os_desc_table
  * @bind: Before the gadget can register, all of its functions bind() to the
  *      available resources including string and interface identifiers used
  *      in interface or class descriptors; endpoints; I/O buffers; and so on.
@@ -129,6 +188,9 @@ struct usb_function {
 
         struct usb_configuration        *config;
 
+        struct usb_os_desc_table        *os_desc_table;
+        unsigned                        os_desc_n;
+
         /* REVISIT:  bind() functions can be marked __init, which
          * makes trouble for section mismatch analysis.  See if
          * we can't restructure things to avoid mismatching.
@@ -327,6 +389,8 @@ extern void usb_composite_unregister(struct usb_composite_driver *driver);
 extern void usb_composite_setup_continue(struct usb_composite_dev *cdev);
 extern int composite_dev_prepare(struct usb_composite_driver *composite,
                 struct usb_composite_dev *cdev);
+extern int composite_os_desc_req_prepare(struct usb_composite_dev *cdev,
+                                         struct usb_ep *ep0);
 void composite_dev_cleanup(struct usb_composite_dev *cdev);
 
 static inline struct usb_composite_driver *to_cdriver(
@@ -335,11 +399,19 @@ static inline struct usb_composite_driver *to_cdriver(
         return container_of(gdrv, struct usb_composite_driver, gadget_driver);
 }
 
+#define OS_STRING_QW_SIGN_LEN           14
+#define OS_STRING_IDX                   0xEE
+
 /**
  * struct usb_composite_device - represents one composite usb gadget
  * @gadget: read-only, abstracts the gadget's usb peripheral controller
  * @req: used for control responses; buffer is pre-allocated
+ * @os_desc_req: used for OS descriptors responses; buffer is pre-allocated
  * @config: the currently active configuration
+ * @qw_sign: qwSignature part of the OS string
+ * @b_vendor_code: bMS_VendorCode part of the OS string
+ * @use_os_string: false by default, interested gadgets set it
+ * @os_desc_config: the configuration to be used with OS descriptors
  *
  * One of these devices is allocated and initialized before the
  * associated device driver's bind() is called.
@@ -369,9 +441,16 @@ static inline struct usb_composite_driver *to_cdriver(
 struct usb_composite_dev {
         struct usb_gadget               *gadget;
         struct usb_request              *req;
+        struct usb_request              *os_desc_req;
 
         struct usb_configuration        *config;
 
+        /* OS String is a custom (yet popular) extension to the USB standard. */
+        u8                              qw_sign[OS_STRING_QW_SIGN_LEN];
+        u8                              b_vendor_code;
+        struct usb_configuration        *os_desc_config;
+        unsigned int                    use_os_string:1;
+
         /* private: */
         /* internals */
         unsigned int                    suspended:1;
diff --git a/include/linux/usb/msm_hsusb.h b/include/linux/usb/msm_hsusb.h
index 32754835a39b..b0a39243295a 100644
--- a/include/linux/usb/msm_hsusb.h
+++ b/include/linux/usb/msm_hsusb.h
@@ -23,21 +23,6 @@
 #include <linux/clk.h>
 
 /**
- * Supported USB modes
- *
- * USB_PERIPHERAL       Only peripheral mode is supported.
- * USB_HOST             Only host mode is supported.
- * USB_OTG              OTG mode is supported.
- *
- */
-enum usb_mode_type {
-        USB_NONE = 0,
-        USB_PERIPHERAL,
-        USB_HOST,
-        USB_OTG,
-};
-
-/**
  * OTG control
  *
  * OTG_NO_CONTROL       Id/VBUS notifications not required. Useful in host
@@ -115,27 +100,23 @@ enum usb_chg_type {
 /**
  * struct msm_otg_platform_data - platform device data
  *              for msm_otg driver.
- * @phy_init_seq: PHY configuration sequence. val, reg pairs
- *              terminated by -1.
+ * @phy_init_seq: PHY configuration sequence values. Value of -1 is reserved as
+ *              "do not overwrite default vaule at this address".
+ * @phy_init_sz: PHY configuration sequence size.
  * @vbus_power: VBUS power on/off routine.
  * @power_budget: VBUS power budget in mA (0 will be treated as 500mA).
  * @mode: Supported mode (OTG/peripheral/host).
  * @otg_control: OTG switch controlled by user/Id pin
- * @default_mode: Default operational mode. Applicable only if
- *              OTG switch is controller by user.
- * @pclk_src_name: pclk is derived from ebi1_usb_clk in case of 7x27 and 8k
- *              dfab_usb_hs_clk in case of 8660 and 8960.
  */
 struct msm_otg_platform_data {
         int *phy_init_seq;
+        int phy_init_sz;
         void (*vbus_power)(bool on);
         unsigned power_budget;
-        enum usb_mode_type mode;
+        enum usb_dr_mode mode;
         enum otg_control_type otg_control;
-        enum usb_mode_type default_mode;
         enum msm_usb_phy_type phy_type;
         void (*setup_gpio)(enum usb_otg_state state);
-        char *pclk_src_name;
         int (*link_clk_reset)(struct clk *link_clk, bool assert);
         int (*phy_clk_reset)(struct clk *phy_clk);
 };
@@ -147,7 +128,6 @@ struct msm_otg_platform_data {
  * @irq: IRQ number assigned for HSUSB controller.
  * @clk: clock struct of usb_hs_clk.
  * @pclk: clock struct of usb_hs_pclk.
- * @pclk_src: pclk source for voting.
  * @phy_reset_clk: clock struct of usb_phy_clk.
  * @core_clk: clock struct of usb_hs_core_clk.
  * @regs: ioremapped register base address.
@@ -168,7 +148,6 @@ struct msm_otg {
         int irq;
         struct clk *clk;
         struct clk *pclk;
-        struct clk *pclk_src;
         struct clk *phy_reset_clk;
         struct clk *core_clk;
         void __iomem *regs;
@@ -179,10 +158,18 @@ struct msm_otg {
         atomic_t in_lpm;
         int async_int;
         unsigned cur_power;
+        int phy_number;
         struct delayed_work chg_work;
         enum usb_chg_state chg_state;
         enum usb_chg_type chg_type;
         u8 dcd_retries;
+        struct regulator *v3p3;
+        struct regulator *v1p8;
+        struct regulator *vddcx;
+
+        struct reset_control *phy_rst;
+        struct reset_control *link_rst;
+        int vdd_levels[3];
 };
 
 #endif
diff --git a/include/linux/usb/msm_hsusb_hw.h b/include/linux/usb/msm_hsusb_hw.h
index 6e97a2d3d39f..a29f6030afb1 100644
--- a/include/linux/usb/msm_hsusb_hw.h
+++ b/include/linux/usb/msm_hsusb_hw.h
@@ -16,6 +16,9 @@
 #ifndef __LINUX_USB_GADGET_MSM72K_UDC_H__
 #define __LINUX_USB_GADGET_MSM72K_UDC_H__
 
+/* USB phy selector - in TCSR address range */
+#define USB2_PHY_SEL         0xfd4ab000
+
 #define USB_AHBBURST         (MSM_USB_BASE + 0x0090)
 #define USB_AHBMODE          (MSM_USB_BASE + 0x0098)
 #define USB_CAPLENGTH        (MSM_USB_BASE + 0x0100) /* 8 bit */
@@ -25,13 +28,15 @@
 #define USB_OTGSC            (MSM_USB_BASE + 0x01A4)
 #define USB_USBMODE          (MSM_USB_BASE + 0x01A8)
 #define USB_PHY_CTRL         (MSM_USB_BASE + 0x0240)
+#define USB_PHY_CTRL2        (MSM_USB_BASE + 0x0278)
 
 #define USBCMD_RESET   2
 #define USB_USBINTR          (MSM_USB_BASE + 0x0148)
 
 #define PORTSC_PHCD            (1 << 23) /* phy suspend mode */
-#define PORTSC_PTS_MASK         (3 << 30)
-#define PORTSC_PTS_ULPI         (3 << 30)
+#define PORTSC_PTS_MASK        (3 << 30)
+#define PORTSC_PTS_ULPI        (2 << 30)
+#define PORTSC_PTS_SERIAL      (3 << 30)
 
 #define USB_ULPI_VIEWPORT    (MSM_USB_BASE + 0x0170)
 #define ULPI_RUN              (1 << 30)
@@ -41,9 +46,14 @@
 #define ULPI_DATA(n)          ((n) & 255)
 #define ULPI_DATA_READ(n)     (((n) >> 8) & 255)
 
+/* synopsys 28nm phy registers */
+#define ULPI_PWR_CLK_MNG_REG    0x88
+#define OTG_COMP_DISABLE        BIT(0)
+
 #define ASYNC_INTR_CTRL         (1 << 29) /* Enable async interrupt */
 #define ULPI_STP_CTRL           (1 << 30) /* Block communication with PHY */
 #define PHY_RETEN               (1 << 1) /* PHY retention enable/disable */
+#define PHY_POR_ASSERT          (1 << 0) /* USB2 28nm PHY POR ASSERT */
 
 /* OTG definitions */
 #define OTGSC_INTSTS_MASK       (0x7f << 16)
diff --git a/include/linux/usb/usb_phy_gen_xceiv.h b/include/linux/usb/usb_phy_generic.h
index cc8d818a83be..68adae83affc 100644
--- a/include/linux/usb/usb_phy_gen_xceiv.h
+++ b/include/linux/usb/usb_phy_generic.h
@@ -3,7 +3,7 @@
 
 #include <linux/usb/otg.h>
 
-struct usb_phy_gen_xceiv_platform_data {
+struct usb_phy_generic_platform_data {
         enum usb_phy_type type;
         unsigned long clk_rate;
 
@@ -13,16 +13,17 @@ struct usb_phy_gen_xceiv_platform_data {
         int gpio_reset;
 };
 
-#if defined(CONFIG_NOP_USB_XCEIV) || (defined(CONFIG_NOP_USB_XCEIV_MODULE) && defined(MODULE))
+#if IS_ENABLED(CONFIG_NOP_USB_XCEIV)
 /* sometimes transceivers are accessed only through e.g. ULPI */
-extern void usb_nop_xceiv_register(void);
-extern void usb_nop_xceiv_unregister(void);
+extern struct platform_device *usb_phy_generic_register(void);
+extern void usb_phy_generic_unregister(struct platform_device *);
 #else
-static inline void usb_nop_xceiv_register(void)
+static inline struct platform_device *usb_phy_generic_register(void)
 {
+        return NULL;
 }
 
-static inline void usb_nop_xceiv_unregister(void)
+static inline void usb_phy_generic_unregister(struct platform_device *pdev)
 {
 }
 #endif
diff --git a/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c b/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c
new file mode 100644
index 000000000000..87216a0c4a8b
--- /dev/null
+++ b/tools/usb/ffs-aio-example/multibuff/device_app/aio_multibuff.c
@@ -0,0 +1,349 @@
+#define _BSD_SOURCE /* for endian.h */
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/eventfd.h>
+
+#include "libaio.h"
+#define IOCB_FLAG_RESFD         (1 << 0)
+
+#include <linux/usb/functionfs.h>
+
+#define BUF_LEN         8192
+#define BUFS_MAX        128
+#define AIO_MAX         (BUFS_MAX*2)
+
+/******************** Descriptors and Strings *******************************/
+
+static const struct {
+        struct usb_functionfs_descs_head header;
+        struct {
+                struct usb_interface_descriptor intf;
+                struct usb_endpoint_descriptor_no_audio bulk_sink;
+                struct usb_endpoint_descriptor_no_audio bulk_source;
+        } __attribute__ ((__packed__)) fs_descs, hs_descs;
+} __attribute__ ((__packed__)) descriptors = {
+        .header = {
+                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+                .length = htole32(sizeof(descriptors)),
+                .fs_count = 3,
+                .hs_count = 3,
+        },
+        .fs_descs = {
+                .intf = {
+                        .bLength = sizeof(descriptors.fs_descs.intf),
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .bulk_sink = {
+                        .bLength = sizeof(descriptors.fs_descs.bulk_sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+                .bulk_source = {
+                        .bLength = sizeof(descriptors.fs_descs.bulk_source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+        },
+        .hs_descs = {
+                .intf = {
+                        .bLength = sizeof(descriptors.hs_descs.intf),
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .bulk_sink = {
+                        .bLength = sizeof(descriptors.hs_descs.bulk_sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = htole16(512),
+                },
+                .bulk_source = {
+                        .bLength = sizeof(descriptors.hs_descs.bulk_source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = htole16(512),
+                },
+        },
+};
+
+#define STR_INTERFACE "AIO Test"
+
+static const struct {
+        struct usb_functionfs_strings_head header;
+        struct {
+                __le16 code;
+                const char str1[sizeof(STR_INTERFACE)];
+        } __attribute__ ((__packed__)) lang0;
+} __attribute__ ((__packed__)) strings = {
+        .header = {
+                .magic = htole32(FUNCTIONFS_STRINGS_MAGIC),
+                .length = htole32(sizeof(strings)),
+                .str_count = htole32(1),
+                .lang_count = htole32(1),
+        },
+        .lang0 = {
+                htole16(0x0409), /* en-us */
+                STR_INTERFACE,
+        },
+};
+
+/********************** Buffer structure *******************************/
+
+struct io_buffer {
+        struct iocb **iocb;
+        unsigned char **buf;
+        unsigned cnt;
+        unsigned len;
+        unsigned requested;
+};
+
+/******************** Endpoints handling *******************************/
+
+static void display_event(struct usb_functionfs_event *event)
+{
+        static const char *const names[] = {
+                [FUNCTIONFS_BIND] = "BIND",
+                [FUNCTIONFS_UNBIND] = "UNBIND",
+                [FUNCTIONFS_ENABLE] = "ENABLE",
+                [FUNCTIONFS_DISABLE] = "DISABLE",
+                [FUNCTIONFS_SETUP] = "SETUP",
+                [FUNCTIONFS_SUSPEND] = "SUSPEND",
+                [FUNCTIONFS_RESUME] = "RESUME",
+        };
+        switch (event->type) {
+        case FUNCTIONFS_BIND:
+        case FUNCTIONFS_UNBIND:
+        case FUNCTIONFS_ENABLE:
+        case FUNCTIONFS_DISABLE:
+        case FUNCTIONFS_SETUP:
+        case FUNCTIONFS_SUSPEND:
+        case FUNCTIONFS_RESUME:
+                printf("Event %s\n", names[event->type]);
+        }
+}
+
+static void handle_ep0(int ep0, bool *ready)
+{
+        int ret;
+        struct usb_functionfs_event event;
+
+        ret = read(ep0, &event, sizeof(event));
+        if (!ret) {
+                perror("unable to read event from ep0");
+                return;
+        }
+        display_event(&event);
+        switch (event.type) {
+        case FUNCTIONFS_SETUP:
+                if (event.u.setup.bRequestType & USB_DIR_IN)
+                        write(ep0, NULL, 0);
+                else
+                        read(ep0, NULL, 0);
+                break;
+
+        case FUNCTIONFS_ENABLE:
+                *ready = true;
+                break;
+
+        case FUNCTIONFS_DISABLE:
+                *ready = false;
+                break;
+
+        default:
+                break;
+        }
+}
+
+void init_bufs(struct io_buffer *iobuf, unsigned n, unsigned len)
+{
+        unsigned i;
+        iobuf->buf = malloc(n*sizeof(*iobuf->buf));
+        iobuf->iocb = malloc(n*sizeof(*iobuf->iocb));
+        iobuf->cnt = n;
+        iobuf->len = len;
+        iobuf->requested = 0;
+        for (i = 0; i < n; ++i) {
+                iobuf->buf[i] = malloc(len*sizeof(**iobuf->buf));
+                iobuf->iocb[i] = malloc(sizeof(**iobuf->iocb));
+        }
+        iobuf->cnt = n;
+}
+
+void delete_bufs(struct io_buffer *iobuf)
+{
+        unsigned i;
+        for (i = 0; i < iobuf->cnt; ++i) {
+                free(iobuf->buf[i]);
+                free(iobuf->iocb[i]);
+        }
+        free(iobuf->buf);
+        free(iobuf->iocb);
+}
+
+int main(int argc, char *argv[])
+{
+        int ret;
+        unsigned i, j;
+        char *ep_path;
+
+        int ep0, ep1;
+
+        io_context_t ctx;
+
+        int evfd;
+        fd_set rfds;
+
+        struct io_buffer iobuf[2];
+        int actual = 0;
+        bool ready;
+
+        if (argc != 2) {
+                printf("ffs directory not specified!\n");
+                return 1;
+        }
+
+        ep_path = malloc(strlen(argv[1]) + 4 /* "/ep#" */ + 1 /* '\0' */);
+        if (!ep_path) {
+                perror("malloc");
+                return 1;
+        }
+
+        /* open endpoint files */
+        sprintf(ep_path, "%s/ep0", argv[1]);
+        ep0 = open(ep_path, O_RDWR);
+        if (ep0 < 0) {
+                perror("unable to open ep0");
+                return 1;
+        }
+        if (write(ep0, &descriptors, sizeof(descriptors)) < 0) {
+                perror("unable do write descriptors");
+                return 1;
+        }
+        if (write(ep0, &strings, sizeof(strings)) < 0) {
+                perror("unable to write strings");
+                return 1;
+        }
+        sprintf(ep_path, "%s/ep1", argv[1]);
+        ep1 = open(ep_path, O_RDWR);
+        if (ep1 < 0) {
+                perror("unable to open ep1");
+                return 1;
+        }
+
+        free(ep_path);
+
+        memset(&ctx, 0, sizeof(ctx));
+        /* setup aio context to handle up to AIO_MAX requests */
+        if (io_setup(AIO_MAX, &ctx) < 0) {
+                perror("unable to setup aio");
+                return 1;
+        }
+
+        evfd = eventfd(0, 0);
+        if (evfd < 0) {
+                perror("unable to open eventfd");
+                return 1;
+        }
+
+        for (i = 0; i < sizeof(iobuf)/sizeof(*iobuf); ++i)
+                init_bufs(&iobuf[i], BUFS_MAX, BUF_LEN);
+
+        while (1) {
+                FD_ZERO(&rfds);
+                FD_SET(ep0, &rfds);
+                FD_SET(evfd, &rfds);
+
+                ret = select(((ep0 > evfd) ? ep0 : evfd)+1,
+                             &rfds, NULL, NULL, NULL);
+                if (ret < 0) {
+                        if (errno == EINTR)
+                                continue;
+                        perror("select");
+                        break;
+                }
+
+                if (FD_ISSET(ep0, &rfds))
+                        handle_ep0(ep0, &ready);
+
+                /* we are waiting for function ENABLE */
+                if (!ready)
+                        continue;
+
+                /*
+                 * when we're preparing new data to submit,
+                 * second buffer being transmitted
+                 */
+                for (i = 0; i < sizeof(iobuf)/sizeof(*iobuf); ++i) {
+                        if (iobuf[i].requested)
+                                continue;
+                        /* prepare requests */
+                        for (j = 0; j < iobuf[i].cnt; ++j) {
+                                io_prep_pwrite(iobuf[i].iocb[j], ep1,
+                                               iobuf[i].buf[j],
+                                               iobuf[i].len, 0);
+                                /* enable eventfd notification */
+                                iobuf[i].iocb[j]->u.c.flags |= IOCB_FLAG_RESFD;
+                                iobuf[i].iocb[j]->u.c.resfd = evfd;
+                        }
+                        /* submit table of requests */
+                        ret = io_submit(ctx, iobuf[i].cnt, iobuf[i].iocb);
+                        if (ret >= 0) {
+                                iobuf[i].requested = ret;
+                                printf("submit: %d requests buf: %d\n", ret, i);
+                        } else
+                                perror("unable to submit reqests");
+                }
+
+                /* if event is ready to read */
+                if (!FD_ISSET(evfd, &rfds))
+                        continue;
+
+                uint64_t ev_cnt;
+                ret = read(evfd, &ev_cnt, sizeof(ev_cnt));
+                if (ret < 0) {
+                        perror("unable to read eventfd");
+                        break;
+                }
+
+                struct io_event e[BUFS_MAX];
+                /* we read aio events */
+                ret = io_getevents(ctx, 1, BUFS_MAX, e, NULL);
+                if (ret > 0) /* if we got events */
+                        iobuf[actual].requested -= ret;
+
+                /* if all req's from iocb completed */
+                if (!iobuf[actual].requested)
+                        actual = (actual + 1)%(sizeof(iobuf)/sizeof(*iobuf));
+        }
+
+        /* free resources */
+
+        for (i = 0; i < sizeof(iobuf)/sizeof(*iobuf); ++i)
+                delete_bufs(&iobuf[i]);
+        io_destroy(ctx);
+
+        close(ep1);
+        close(ep0);
+
+        return 0;
+}
diff --git a/tools/usb/ffs-aio-example/multibuff/host_app/Makefile b/tools/usb/ffs-aio-example/multibuff/host_app/Makefile
new file mode 100644
index 000000000000..8c4a6f0aa82d
--- /dev/null
+++ b/tools/usb/ffs-aio-example/multibuff/host_app/Makefile
@@ -0,0 +1,13 @@
+CC = gcc
+LIBUSB_CFLAGS = $(shell pkg-config --cflags libusb-1.0)
+LIBUSB_LIBS = $(shell pkg-config --libs libusb-1.0)
+WARNINGS = -Wall -Wextra
+CFLAGS = $(LIBUSB_CFLAGS) $(WARNINGS)
+LDFLAGS = $(LIBUSB_LIBS)
+
+all: test
+%: %.c
+        $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+clean:
+        $(RM) test
diff --git a/tools/usb/ffs-aio-example/multibuff/host_app/test.c b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
new file mode 100644
index 000000000000..b0ad8747d03f
--- /dev/null
+++ b/tools/usb/ffs-aio-example/multibuff/host_app/test.c
@@ -0,0 +1,146 @@
+#include <libusb.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#define VENDOR  0x1d6b
+#define PRODUCT 0x0105
+
+/* endpoints indexes */
+
+#define EP_BULK_IN      (1 | LIBUSB_ENDPOINT_IN)
+#define EP_BULK_OUT     (2 | LIBUSB_ENDPOINT_OUT)
+
+#define BUF_LEN         8192
+
+/*
+ * struct test_state - describes test program state
+ * @list: list of devices returned by libusb_get_device_list function
+ * @found: pointer to struct describing tested device
+ * @ctx: context, set to NULL
+ * @handle: handle of tested device
+ * @attached: indicates that device was attached to kernel, and has to be
+ *            reattached at the end of test program
+ */
+
+struct test_state {
+        libusb_device *found;
+        libusb_context *ctx;
+        libusb_device_handle *handle;
+        int attached;
+};
+
+/*
+ * test_init - initialize test program
+ */
+
+int test_init(struct test_state *state)
+{
+        int i, ret;
+        ssize_t cnt;
+        libusb_device **list;
+
+        state->found = NULL;
+        state->ctx = NULL;
+        state->handle = NULL;
+        state->attached = 0;
+
+        ret = libusb_init(&state->ctx);
+        if (ret) {
+                printf("cannot init libusb: %s\n", libusb_error_name(ret));
+                return 1;
+        }
+
+        cnt = libusb_get_device_list(state->ctx, &list);
+        if (cnt <= 0) {
+                printf("no devices found\n");
+                goto error1;
+        }
+
+        for (i = 0; i < cnt; ++i) {
+                libusb_device *dev = list[i];
+                struct libusb_device_descriptor desc;
+                ret = libusb_get_device_descriptor(dev, &desc);
+                if (ret) {
+                        printf("unable to get device descriptor: %s\n",
+                               libusb_error_name(ret));
+                        goto error2;
+                }
+                if (desc.idVendor == VENDOR && desc.idProduct == PRODUCT) {
+                        state->found = dev;
+                        break;
+                }
+        }
+
+        if (!state->found) {
+                printf("no devices found\n");
+                goto error2;
+        }
+
+        ret = libusb_open(state->found, &state->handle);
+        if (ret) {
+                printf("cannot open device: %s\n", libusb_error_name(ret));
+                goto error2;
+        }
+
+        if (libusb_claim_interface(state->handle, 0)) {
+                ret = libusb_detach_kernel_driver(state->handle, 0);
+                if (ret) {
+                        printf("unable to detach kernel driver: %s\n",
+                               libusb_error_name(ret));
+                        goto error3;
+                }
+                state->attached = 1;
+                ret = libusb_claim_interface(state->handle, 0);
+                if (ret) {
+                        printf("cannot claim interface: %s\n",
+                               libusb_error_name(ret));
+                        goto error4;
+                }
+        }
+
+        return 0;
+
+error4:
+        if (state->attached == 1)
+                libusb_attach_kernel_driver(state->handle, 0);
+
+error3:
+        libusb_close(state->handle);
+
+error2:
+        libusb_free_device_list(list, 1);
+
+error1:
+        libusb_exit(state->ctx);
+        return 1;
+}
+
+/*
+ * test_exit - cleanup test program
+ */
+
+void test_exit(struct test_state *state)
+{
+        libusb_release_interface(state->handle, 0);
+        if (state->attached == 1)
+                libusb_attach_kernel_driver(state->handle, 0);
+        libusb_close(state->handle);
+        libusb_exit(state->ctx);
+}
+
+int main(void)
+{
+        struct test_state state;
+
+        if (test_init(&state))
+                return 1;
+
+        while (1) {
+                static unsigned char buffer[BUF_LEN];
+                int bytes;
+                libusb_bulk_transfer(state.handle, EP_BULK_IN, buffer, BUF_LEN,
+                                     &bytes, 500);
+        }
+        test_exit(&state);
+}
diff --git a/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
new file mode 100644
index 000000000000..f558664a3317
--- /dev/null
+++ b/tools/usb/ffs-aio-example/simple/device_app/aio_simple.c
@@ -0,0 +1,335 @@
+#define _BSD_SOURCE /* for endian.h */
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/eventfd.h>
+
+#include "libaio.h"
+#define IOCB_FLAG_RESFD         (1 << 0)
+
+#include <linux/usb/functionfs.h>
+
+#define BUF_LEN         8192
+
+/******************** Descriptors and Strings *******************************/
+
+static const struct {
+        struct usb_functionfs_descs_head header;
+        struct {
+                struct usb_interface_descriptor intf;
+                struct usb_endpoint_descriptor_no_audio bulk_sink;
+                struct usb_endpoint_descriptor_no_audio bulk_source;
+        } __attribute__ ((__packed__)) fs_descs, hs_descs;
+} __attribute__ ((__packed__)) descriptors = {
+        .header = {
+                .magic = htole32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+                .length = htole32(sizeof(descriptors)),
+                .fs_count = 3,
+                .hs_count = 3,
+        },
+        .fs_descs = {
+                .intf = {
+                        .bLength = sizeof(descriptors.fs_descs.intf),
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .bulk_sink = {
+                        .bLength = sizeof(descriptors.fs_descs.bulk_sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+                .bulk_source = {
+                        .bLength = sizeof(descriptors.fs_descs.bulk_source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+        },
+        .hs_descs = {
+                .intf = {
+                        .bLength = sizeof(descriptors.hs_descs.intf),
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .bulk_sink = {
+                        .bLength = sizeof(descriptors.hs_descs.bulk_sink),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+                .bulk_source = {
+                        .bLength = sizeof(descriptors.hs_descs.bulk_source),
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                },
+        },
+};
+
+#define STR_INTERFACE "AIO Test"
+
+static const struct {
+        struct usb_functionfs_strings_head header;
+        struct {
+                __le16 code;
+                const char str1[sizeof(STR_INTERFACE)];
+        } __attribute__ ((__packed__)) lang0;
+} __attribute__ ((__packed__)) strings = {
+        .header = {
+                .magic = htole32(FUNCTIONFS_STRINGS_MAGIC),
+                .length = htole32(sizeof(strings)),
+                .str_count = htole32(1),
+                .lang_count = htole32(1),
+        },
+        .lang0 = {
+                htole16(0x0409), /* en-us */
+                STR_INTERFACE,
+        },
+};
+
+/******************** Endpoints handling *******************************/
+
+static void display_event(struct usb_functionfs_event *event)
+{
+        static const char *const names[] = {
+                [FUNCTIONFS_BIND] = "BIND",
+                [FUNCTIONFS_UNBIND] = "UNBIND",
+                [FUNCTIONFS_ENABLE] = "ENABLE",
+                [FUNCTIONFS_DISABLE] = "DISABLE",
+                [FUNCTIONFS_SETUP] = "SETUP",
+                [FUNCTIONFS_SUSPEND] = "SUSPEND",
+                [FUNCTIONFS_RESUME] = "RESUME",
+        };
+        switch (event->type) {
+        case FUNCTIONFS_BIND:
+        case FUNCTIONFS_UNBIND:
+        case FUNCTIONFS_ENABLE:
+        case FUNCTIONFS_DISABLE:
+        case FUNCTIONFS_SETUP:
+        case FUNCTIONFS_SUSPEND:
+        case FUNCTIONFS_RESUME:
+                printf("Event %s\n", names[event->type]);
+        }
+}
+
+static void handle_ep0(int ep0, bool *ready)
+{
+        struct usb_functionfs_event event;
+        int ret;
+
+        struct pollfd pfds[1];
+        pfds[0].fd = ep0;
+        pfds[0].events = POLLIN;
+
+        ret = poll(pfds, 1, 0);
+
+        if (ret && (pfds[0].revents & POLLIN)) {
+                ret = read(ep0, &event, sizeof(event));
+                if (!ret) {
+                        perror("unable to read event from ep0");
+                        return;
+                }
+                display_event(&event);
+                switch (event.type) {
+                case FUNCTIONFS_SETUP:
+                        if (event.u.setup.bRequestType & USB_DIR_IN)
+                                write(ep0, NULL, 0);
+                        else
+                                read(ep0, NULL, 0);
+                        break;
+
+                case FUNCTIONFS_ENABLE:
+                        *ready = true;
+                        break;
+
+                case FUNCTIONFS_DISABLE:
+                        *ready = false;
+                        break;
+
+                default:
+                        break;
+                }
+        }
+}
+
+int main(int argc, char *argv[])
+{
+        int i, ret;
+        char *ep_path;
+
+        int ep0;
+        int ep[2];
+
+        io_context_t ctx;
+
+        int evfd;
+        fd_set rfds;
+
+        char *buf_in, *buf_out;
+        struct iocb *iocb_in, *iocb_out;
+        int req_in = 0, req_out = 0;
+        bool ready;
+
+        if (argc != 2) {
+                printf("ffs directory not specified!\n");
+                return 1;
+        }
+
+        ep_path = malloc(strlen(argv[1]) + 4 /* "/ep#" */ + 1 /* '\0' */);
+        if (!ep_path) {
+                perror("malloc");
+                return 1;
+        }
+
+        /* open endpoint files */
+        sprintf(ep_path, "%s/ep0", argv[1]);
+        ep0 = open(ep_path, O_RDWR);
+        if (ep0 < 0) {
+                perror("unable to open ep0");
+                return 1;
+        }
+        if (write(ep0, &descriptors, sizeof(descriptors)) < 0) {
+                perror("unable do write descriptors");
+                return 1;
+        }
+        if (write(ep0, &strings, sizeof(strings)) < 0) {
+                perror("unable to write strings");
+                return 1;
+        }
+        for (i = 0; i < 2; ++i) {
+                sprintf(ep_path, "%s/ep%d", argv[1], i+1);
+                ep[i] = open(ep_path, O_RDWR);
+                if (ep[i] < 0) {
+                        printf("unable to open ep%d: %s\n", i+1,
+                               strerror(errno));
+                        return 1;
+                }
+        }
+
+        free(ep_path);
+
+        memset(&ctx, 0, sizeof(ctx));
+        /* setup aio context to handle up to 2 requests */
+        if (io_setup(2, &ctx) < 0) {
+                perror("unable to setup aio");
+                return 1;
+        }
+
+        evfd = eventfd(0, 0);
+        if (evfd < 0) {
+                perror("unable to open eventfd");
+                return 1;
+        }
+
+        /* alloc buffers and requests */
+        buf_in = malloc(BUF_LEN);
+        buf_out = malloc(BUF_LEN);
+        iocb_in = malloc(sizeof(*iocb_in));
+        iocb_out = malloc(sizeof(*iocb_out));
+
+        while (1) {
+                FD_ZERO(&rfds);
+                FD_SET(ep0, &rfds);
+                FD_SET(evfd, &rfds);
+
+                ret = select(((ep0 > evfd) ? ep0 : evfd)+1,
+                             &rfds, NULL, NULL, NULL);
+                if (ret < 0) {
+                        if (errno == EINTR)
+                                continue;
+                        perror("select");
+                        break;
+                }
+
+                if (FD_ISSET(ep0, &rfds))
+                        handle_ep0(ep0, &ready);
+
+                /* we are waiting for function ENABLE */
+                if (!ready)
+                        continue;
+
+                /* if something was submitted we wait for event */
+                if (FD_ISSET(evfd, &rfds)) {
+                        uint64_t ev_cnt;
+                        ret = read(evfd, &ev_cnt, sizeof(ev_cnt));
+                        if (ret < 0) {
+                                perror("unable to read eventfd");
+                                break;
+                        }
+
+                        struct io_event e[2];
+                        /* we wait for one event */
+                        ret = io_getevents(ctx, 1, 2, e, NULL);
+                        /* if we got event */
+                        for (i = 0; i < ret; ++i) {
+                                if (e[i].obj->aio_fildes == ep[0]) {
+                                        printf("ev=in; ret=%lu\n", e[i].res);
+                                        req_in = 0;
+                                } else if (e[i].obj->aio_fildes == ep[1]) {
+                                        printf("ev=out; ret=%lu\n", e[i].res);
+                                        req_out = 0;
+                                }
+                        }
+                }
+
+                if (!req_in) { /* if IN transfer not requested*/
+                        /* prepare write request */
+                        io_prep_pwrite(iocb_in, ep[0], buf_in, BUF_LEN, 0);
+                        /* enable eventfd notification */
+                        iocb_in->u.c.flags |= IOCB_FLAG_RESFD;
+                        iocb_in->u.c.resfd = evfd;
+                        /* submit table of requests */
+                        ret = io_submit(ctx, 1, &iocb_in);
+                        if (ret >= 0) { /* if ret > 0 request is queued */
+                                req_in = 1;
+                                printf("submit: in\n");
+                        } else
+                                perror("unable to submit request");
+                }
+                if (!req_out) { /* if OUT transfer not requested */
+                        /* prepare read request */
+                        io_prep_pread(iocb_out, ep[1], buf_out, BUF_LEN, 0);
+                        /* enable eventfs notification */
+                        iocb_out->u.c.flags |= IOCB_FLAG_RESFD;
+                        iocb_out->u.c.resfd = evfd;
+                        /* submit table of requests */
+                        ret = io_submit(ctx, 1, &iocb_out);
+                        if (ret >= 0) { /* if ret > 0 request is queued */
+                                req_out = 1;
+                                printf("submit: out\n");
+                        } else
+                                perror("unable to submit request");
+                }
+        }
+
+        /* free resources */
+
+        io_destroy(ctx);
+
+        free(buf_in);
+        free(buf_out);
+        free(iocb_in);
+        free(iocb_out);
+
+        for (i = 0; i < 2; ++i)
+                close(ep[i]);
+        close(ep0);
+
+        return 0;
+}
diff --git a/tools/usb/ffs-aio-example/simple/host_app/Makefile b/tools/usb/ffs-aio-example/simple/host_app/Makefile
new file mode 100644
index 000000000000..8c4a6f0aa82d
--- /dev/null
+++ b/tools/usb/ffs-aio-example/simple/host_app/Makefile
@@ -0,0 +1,13 @@
+CC = gcc
+LIBUSB_CFLAGS = $(shell pkg-config --cflags libusb-1.0)
+LIBUSB_LIBS = $(shell pkg-config --libs libusb-1.0)
+WARNINGS = -Wall -Wextra
+CFLAGS = $(LIBUSB_CFLAGS) $(WARNINGS)
+LDFLAGS = $(LIBUSB_LIBS)
+
+all: test
+%: %.c
+        $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+
+clean:
+        $(RM) test
diff --git a/tools/usb/ffs-aio-example/simple/host_app/test.c b/tools/usb/ffs-aio-example/simple/host_app/test.c
new file mode 100644
index 000000000000..64b6a57d8ca3
--- /dev/null
+++ b/tools/usb/ffs-aio-example/simple/host_app/test.c
@@ -0,0 +1,148 @@
+#include <libusb.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#define VENDOR  0x1d6b
+#define PRODUCT 0x0105
+
+/* endpoints indexes */
+
+#define EP_BULK_IN      (1 | LIBUSB_ENDPOINT_IN)
+#define EP_BULK_OUT     (2 | LIBUSB_ENDPOINT_OUT)
+
+#define BUF_LEN         8192
+
+/*
+ * struct test_state - describes test program state
+ * @list: list of devices returned by libusb_get_device_list function
+ * @found: pointer to struct describing tested device
+ * @ctx: context, set to NULL
+ * @handle: handle of tested device
+ * @attached: indicates that device was attached to kernel, and has to be
+ *            reattached at the end of test program
+ */
+
+struct test_state {
+        libusb_device *found;
+        libusb_context *ctx;
+        libusb_device_handle *handle;
+        int attached;
+};
+
+/*
+ * test_init - initialize test program
+ */
+
+int test_init(struct test_state *state)
+{
+        int i, ret;
+        ssize_t cnt;
+        libusb_device **list;
+
+        state->found = NULL;
+        state->ctx = NULL;
+        state->handle = NULL;
+        state->attached = 0;
+
+        ret = libusb_init(&state->ctx);
+        if (ret) {
+                printf("cannot init libusb: %s\n", libusb_error_name(ret));
+                return 1;
+        }
+
+        cnt = libusb_get_device_list(state->ctx, &list);
+        if (cnt <= 0) {
+                printf("no devices found\n");
+                goto error1;
+        }
+
+        for (i = 0; i < cnt; ++i) {
+                libusb_device *dev = list[i];
+                struct libusb_device_descriptor desc;
+                ret = libusb_get_device_descriptor(dev, &desc);
+                if (ret) {
+                        printf("unable to get device descriptor: %s\n",
+                               libusb_error_name(ret));
+                        goto error2;
+                }
+                if (desc.idVendor == VENDOR && desc.idProduct == PRODUCT) {
+                        state->found = dev;
+                        break;
+                }
+        }
+
+        if (!state->found) {
+                printf("no devices found\n");
+                goto error2;
+        }
+
+        ret = libusb_open(state->found, &state->handle);
+        if (ret) {
+                printf("cannot open device: %s\n", libusb_error_name(ret));
+                goto error2;
+        }
+
+        if (libusb_claim_interface(state->handle, 0)) {
+                ret = libusb_detach_kernel_driver(state->handle, 0);
+                if (ret) {
+                        printf("unable to detach kernel driver: %s\n",
+                               libusb_error_name(ret));
+                        goto error3;
+                }
+                state->attached = 1;
+                ret = libusb_claim_interface(state->handle, 0);
+                if (ret) {
+                        printf("cannot claim interface: %s\n",
+                               libusb_error_name(ret));
+                        goto error4;
+                }
+        }
+
+        return 0;
+
+error4:
+        if (state->attached == 1)
+                libusb_attach_kernel_driver(state->handle, 0);
+
+error3:
+        libusb_close(state->handle);
+
+error2:
+        libusb_free_device_list(list, 1);
+
+error1:
+        libusb_exit(state->ctx);
+        return 1;
+}
+
+/*
+ * test_exit - cleanup test program
+ */
+
+void test_exit(struct test_state *state)
+{
+        libusb_release_interface(state->handle, 0);
+        if (state->attached == 1)
+                libusb_attach_kernel_driver(state->handle, 0);
+        libusb_close(state->handle);
+        libusb_exit(state->ctx);
+}
+
+int main(void)
+{
+        struct test_state state;
+
+        if (test_init(&state))
+                return 1;
+
+        while (1) {
+                static unsigned char buffer[BUF_LEN];
+                int bytes;
+                libusb_bulk_transfer(state.handle, EP_BULK_IN, buffer, BUF_LEN,
+                                     &bytes, 500);
+                libusb_bulk_transfer(state.handle, EP_BULK_OUT, buffer, BUF_LEN,
+                                     &bytes, 500);
+        }
+        test_exit(&state);
+}