89 files changed, 1181 insertions, 831 deletions
diff --git a/Documentation/devicetree/bindings/phy/phy-miphy28lp.txt b/Documentation/devicetree/bindings/phy/phy-miphy28lp.txt
index 46a135dae6b3..89caa885d08c 100644
--- a/Documentation/devicetree/bindings/phy/phy-miphy28lp.txt
+++ b/Documentation/devicetree/bindings/phy/phy-miphy28lp.txt
@@ -26,6 +26,7 @@ Required properties (port (child) node):
                  filled in "reg". It can also contain the offset of the system configuration
                  registers used as glue-logic to setup the device for SATA/PCIe or USB3
                  devices.
+- st,syscfg     : Offset of the parent configuration register.
 - resets        : phandle to the parent reset controller.
 - reset-names   : Associated name must be "miphy-sw-rst".
@@ -54,18 +55,12 @@ example:
                        phy_port0: port@9b22000 {
                                reg = <0x9b22000 0xff>,
                                      <0x9b09000 0xff>,
-                                      <0x9b04000 0xff>,
+                                      <0x9b04000 0xff>;
-                                      <0x114 0x4>, /* sysctrl MiPHY cntrl */
-                                      <0x818 0x4>, /* sysctrl MiPHY status*/
-                                      <0xe0  0x4>, /* sysctrl PCIe */
-                                      <0xec  0x4>; /* sysctrl SATA */
                                reg-names = "sata-up",
                                            "pcie-up",
-                                            "pipew",
+                                            "pipew";
-                                            "miphy-ctrl-glue",
-                                            "miphy-status-glue",
+                                st,syscfg = <0x114 0x818 0xe0 0xec>;
-                                            "pcie-glue",
-                                            "sata-glue";
                                #phy-cells = <1>;
                                st,osc-rdy;
                                reset-names = "miphy-sw-rst";
@@ -75,18 +70,13 @@ example:
                        phy_port1: port@9b2a000 {
                                reg = <0x9b2a000 0xff>,
                                      <0x9b19000 0xff>,
-                                      <0x9b14000 0xff>,
+                                      <0x9b14000 0xff>;
-                                      <0x118 0x4>,
-                                      <0x81c 0x4>,
-                                      <0xe4  0x4>,
-                                      <0xf0  0x4>;
                                reg-names = "sata-up",
                                            "pcie-up",
-                                            "pipew",
+                                            "pipew";
-                                            "miphy-ctrl-glue",
-                                            "miphy-status-glue",
+                                st,syscfg = <0x118 0x81c 0xe4 0xf0>;
-                                            "pcie-glue",
-                                            "sata-glue";
                                #phy-cells = <1>;
                                st,osc-force-ext;
                                reset-names = "miphy-sw-rst";
@@ -95,13 +85,12 @@ example:
                        phy_port2: port@8f95000 {
                                reg = <0x8f95000 0xff>,
-                                      <0x8f90000 0xff>,
+                                      <0x8f90000 0xff>;
-                                      <0x11c 0x4>,
-                                      <0x820 0x4>;
                                reg-names = "pipew",
-                                    "usb3-up",
+                                            "usb3-up";
-                                    "miphy-ctrl-glue",
-                                    "miphy-status-glue";
+                                st,syscfg = <0x11c 0x820>;
                                #phy-cells = <1>;
                                reset-names = "miphy-sw-rst";
                                resets = <&softreset STIH407_MIPHY2_SOFTRESET>;
@@ -125,4 +114,4 @@ example:
 Macro definitions for the supported miphy configuration can be found in:
-include/dt-bindings/phy/phy-miphy28lp.h
+include/dt-bindings/phy/phy.h
diff --git a/Documentation/devicetree/bindings/phy/phy-miphy365x.txt b/Documentation/devicetree/bindings/phy/phy-miphy365x.txt
index 42c880886cf7..9802d5d911aa 100644
--- a/Documentation/devicetree/bindings/phy/phy-miphy365x.txt
+++ b/Documentation/devicetree/bindings/phy/phy-miphy365x.txt
@@ -6,8 +6,10 @@ for SATA and PCIe.
 Required properties (controller (parent) node):
 - compatible    : Should be "st,miphy365x-phy"
- st,syscfg     : Should be a phandle of the system configuration register group
+- st,syscfg     : Phandle / integer array property. Phandle of sysconfig group
-                  which contain the SATA, PCIe mode setting bits
+                  containing the miphy registers and integer array should contain
+                  an entry for each port sub-node, specifying the control
+                  register offset inside the sysconfig group.
 Required nodes  :  A sub-node is required for each channel the controller
                   provides. Address range information including the usual
@@ -26,7 +28,6 @@ Required properties (port (child) node):
                  registers filled in "reg":
                        - sata:   For SATA devices
                        - pcie:   For PCIe devices
-                        - syscfg: To specify the syscfg based config register
 Optional properties (port (child) node):
 - st,sata-gen        :  Generation of locally attached SATA IP. Expected values
@@ -39,20 +40,20 @@ Example:
        miphy365x_phy: miphy365x@fe382000 {
                compatible      = "st,miphy365x-phy";
-                st,syscfg       = <&syscfg_rear>;
+                st,syscfg       = <&syscfg_rear 0x824 0x828>;
                #address-cells  = <1>;
                #size-cells     = <1>;
                ranges;
                phy_port0: port@fe382000 {
-                        reg = <0xfe382000 0x100>, <0xfe394000 0x100>, <0x824 0x4>;
+                        reg = <0xfe382000 0x100>, <0xfe394000 0x100>;
-                        reg-names = "sata", "pcie", "syscfg";
+                        reg-names = "sata", "pcie";
                        #phy-cells = <1>;
                        st,sata-gen = <3>;
                };
                phy_port1: port@fe38a000 {
-                        reg = <0xfe38a000 0x100>, <0xfe804000 0x100>, <0x828 0x4>;;
+                        reg = <0xfe38a000 0x100>, <0xfe804000 0x100>;;
                        reg-names = "sata", "pcie", "syscfg";
                        #phy-cells = <1>;
                        st,pcie-tx-pol-inv;
diff --git a/Documentation/devicetree/bindings/phy/phy-stih407-usb.txt b/Documentation/devicetree/bindings/phy/phy-stih407-usb.txt
index 1ef8228db73b..de6a706abcdb 100644
--- a/Documentation/devicetree/bindings/phy/phy-stih407-usb.txt
+++ b/Documentation/devicetree/bindings/phy/phy-stih407-usb.txt
@@ -5,10 +5,7 @@ host controllers (when controlling usb2/1.1 devices) available on STiH407 SoC fa
 Required properties:
 - compatible            : should be "st,stih407-usb2-phy"
- reg                   : contain the offset and length of the system configuration registers
+- st,syscfg             : phandle of sysconfig bank plus integer array containing phyparam and phyctrl register offsets
-                          used as glue logic to control & parameter phy
- reg-names             : the names of the system configuration registers in "reg", should be "param" and "reg"
- st,syscfg             : sysconfig register to manage phy parameter at driver level
 - resets                : list of phandle and reset specifier pairs. There should be two entries, one
                          for the whole phy and one for the port
 - reset-names           : list of reset signal names. Should be "global" and "port"
@@ -19,11 +16,8 @@ Example:
 usb2_picophy0: usbpicophy@f8 {
        compatible      = "st,stih407-usb2-phy";
-        reg             = <0xf8 0x04>,  /* syscfg 5062 */
-                          <0xf4 0x04>;  /* syscfg 5061 */
-        reg-names       = "param", "ctrl";
        #phy-cells      = <0>;
-        st,syscfg       = <&syscfg_core>;
+        st,syscfg       = <&syscfg_core 0x100 0xf4>;
        resets          = <&softreset STIH407_PICOPHY_SOFTRESET>,
                          <&picophyreset STIH407_PICOPHY0_RESET>;
        reset-names     = "global", "port";
diff --git a/Documentation/devicetree/bindings/phy/rockchip-usb-phy.txt b/Documentation/devicetree/bindings/phy/rockchip-usb-phy.txt
new file mode 100644
index 000000000000..826454ac43bb
--- /dev/null
+++ b/Documentation/devicetree/bindings/phy/rockchip-usb-phy.txt
@@ -0,0 +1,37 @@
+ROCKCHIP USB2 PHY
+Required properties:
+ - compatible: rockchip,rk3288-usb-phy
+ - rockchip,grf : phandle to the syscon managing the "general
+   register files"
+ - #address-cells: should be 1
+ - #size-cells: should be 0
+Sub-nodes:
+Each PHY should be represented as a sub-node.
+Sub-nodes
+required properties:
+- #phy-cells: should be 0
+- reg: PHY configure reg address offset in GRF
+                "0x320" - for PHY attach to OTG controller
+                "0x334" - for PHY attach to HOST0 controller
+                "0x348" - for PHY attach to HOST1 controller
+Optional Properties:
+- clocks : phandle + clock specifier for the phy clocks
+- clock-names: string, clock name, must be "phyclk"
+Example:
+usbphy: phy {
+        compatible = "rockchip,rk3288-usb-phy";
+        rockchip,grf = <&grf>;
+        #address-cells = <1>;
+        #size-cells = <0>;
+        usbphy0: usb-phy0 {
+                #phy-cells = <0>;
+                reg = <0x320>;
+        };
+};
diff --git a/Documentation/devicetree/bindings/phy/samsung-phy.txt b/Documentation/devicetree/bindings/phy/samsung-phy.txt
index d5bad920827f..91e38cfe1f8f 100644
--- a/Documentation/devicetree/bindings/phy/samsung-phy.txt
+++ b/Documentation/devicetree/bindings/phy/samsung-phy.txt
@@ -3,8 +3,8 @@ Samsung S5P/EXYNOS SoC series MIPI CSIS/DSIM DPHY
 Required properties:
 - compatible : should be "samsung,s5pv210-mipi-video-phy";
- reg : offset and length of the MIPI DPHY register set;
 - #phy-cells : from the generic phy bindings, must be 1;
+- syscon - phandle to the PMU system controller;
 For "samsung,s5pv210-mipi-video-phy" compatible PHYs the second cell in
 the PHY specifier identifies the PHY and its meaning is as follows:
diff --git a/Documentation/devicetree/bindings/usb/usb-ehci.txt b/Documentation/devicetree/bindings/usb/usb-ehci.txt
index 43c1a4e06767..0b04fdff9d5a 100644
--- a/Documentation/devicetree/bindings/usb/usb-ehci.txt
+++ b/Documentation/devicetree/bindings/usb/usb-ehci.txt
@@ -12,6 +12,7 @@ Optional properties:
 - big-endian-regs : boolean, set this for hcds with big-endian registers
 - big-endian-desc : boolean, set this for hcds with big-endian descriptors
 - big-endian : boolean, for hcds with big-endian-regs + big-endian-desc
+ - needs-reset-on-resume : boolean, set this to force EHCI reset after resume
 - clocks : a list of phandle + clock specifier pairs
 - phys : phandle + phy specifier pair
 - phy-names : "usb"
diff --git a/Documentation/usb/usbmon.txt b/Documentation/usb/usbmon.txt
index c42bb9cd3b43..28425f736756 100644
--- a/Documentation/usb/usbmon.txt
+++ b/Documentation/usb/usbmon.txt
@@ -72,7 +72,7 @@ to listen on a single bus, otherwise, to listen on all buses, type:
 # cat /sys/kernel/debug/usb/usbmon/0u > /tmp/1.mon.out
-This process will be reading until killed. Naturally, the output can be
+This process will read until it is killed. Naturally, the output can be
 redirected to a desirable location. This is preferred, because it is going
 to be quite long.
@@ -231,7 +231,7 @@ number. Number zero (/dev/usbmon0) is special and means "all buses".
 Note that specific naming policy is set by your Linux distribution.
 If you create /dev/usbmon0 by hand, make sure that it is owned by root
-and has mode 0600. Otherwise, unpriviledged users will be able to snoop
+and has mode 0600. Otherwise, unprivileged users will be able to snoop
 keyboard traffic.
 The following ioctl calls are available, with MON_IOC_MAGIC 0x92:
diff --git a/arch/arm/boot/dts/stih416.dtsi b/arch/arm/boot/dts/stih416.dtsi
index fad9073ddeed..85afe01c34fa 100644
--- a/arch/arm/boot/dts/stih416.dtsi
+++ b/arch/arm/boot/dts/stih416.dtsi
@@ -283,21 +283,21 @@
                miphy365x_phy: phy@fe382000 {
                        compatible      = "st,miphy365x-phy";
-                        st,syscfg       = <&syscfg_rear>;
+                        st,syscfg       = <&syscfg_rear 0x824 0x828>;
                        #address-cells  = <1>;
                        #size-cells     = <1>;
                        ranges;
                        phy_port0: port@fe382000 {
                                #phy-cells = <1>;
-                                reg = <0xfe382000 0x100>, <0xfe394000 0x100>, <0x824 0x4>;
+                                reg = <0xfe382000 0x100>, <0xfe394000 0x100>;
-                                reg-names = "sata", "pcie", "syscfg";
+                                reg-names = "sata", "pcie";
                        };
                        phy_port1: port@fe38a000 {
                                #phy-cells = <1>;
-                                reg = <0xfe38a000 0x100>, <0xfe804000 0x100>, <0x828 0x4>;
+                                reg = <0xfe38a000 0x100>, <0xfe804000 0x100>;
-                                reg-names = "sata", "pcie", "syscfg";
+                                reg-names = "sata", "pcie";
                        };
                };
diff --git a/arch/mips/cavium-octeon/octeon-platform.c b/arch/mips/cavium-octeon/octeon-platform.c
index b67ddf0f8bcd..12410a2788d8 100644
--- a/arch/mips/cavium-octeon/octeon-platform.c
+++ b/arch/mips/cavium-octeon/octeon-platform.c
@@ -77,7 +77,7 @@ static DEFINE_MUTEX(octeon2_usb_clocks_mutex);
 static int octeon2_usb_clock_start_cnt;
-static void octeon2_usb_clocks_start(void)
+static void octeon2_usb_clocks_start(struct device *dev)
 {
        u64 div;
        union cvmx_uctlx_if_ena if_ena;
@@ -86,6 +86,8 @@ static void octeon2_usb_clocks_start(void)
        union cvmx_uctlx_uphy_portx_ctl_status port_ctl_status;
        int i;
        unsigned long io_clk_64_to_ns;
+        u32 clock_rate = 12000000;
+        bool is_crystal_clock = false;
        mutex_lock(&octeon2_usb_clocks_mutex);
@@ -96,6 +98,28 @@ static void octeon2_usb_clocks_start(void)
        io_clk_64_to_ns = 64000000000ull / octeon_get_io_clock_rate();
+        if (dev->of_node) {
+                struct device_node *uctl_node;
+                const char *clock_type;
+                uctl_node = of_get_parent(dev->of_node);
+                if (!uctl_node) {
+                        dev_err(dev, "No UCTL device node\n");
+                        goto exit;
+                }
+                i = of_property_read_u32(uctl_node,
+                                         "refclk-frequency", &clock_rate);
+                if (i) {
+                        dev_err(dev, "No UCTL \"refclk-frequency\"\n");
+                        goto exit;
+                }
+                i = of_property_read_string(uctl_node,
+                                            "refclk-type", &clock_type);
+                if (!i && strcmp("crystal", clock_type) == 0)
+                        is_crystal_clock = true;
+        }
        /*
         * Step 1: Wait for voltages stable.  That surely happened
         * before starting the kernel.
@@ -126,9 +150,22 @@ static void octeon2_usb_clocks_start(void)
        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
        /* 3b */
-        /* 12MHz crystal. */
+        clk_rst_ctl.s.p_refclk_sel = is_crystal_clock ? 0 : 1;
-        clk_rst_ctl.s.p_refclk_sel = 0;
+        switch (clock_rate) {
-        clk_rst_ctl.s.p_refclk_div = 0;
+        default:
+                pr_err("Invalid UCTL clock rate of %u, using 12000000 instead\n",
+                        clock_rate);
+                /* Fall through */
+        case 12000000:
+                clk_rst_ctl.s.p_refclk_div = 0;
+                break;
+        case 24000000:
+                clk_rst_ctl.s.p_refclk_div = 1;
+                break;
+        case 48000000:
+                clk_rst_ctl.s.p_refclk_div = 2;
+                break;
+        }
        cvmx_write_csr(CVMX_UCTLX_CLK_RST_CTL(0), clk_rst_ctl.u64);
        /* 3c */
@@ -259,7 +296,7 @@ static void octeon2_usb_clocks_stop(void)
 static int octeon_ehci_power_on(struct platform_device *pdev)
 {
-        octeon2_usb_clocks_start();
+        octeon2_usb_clocks_start(&pdev->dev);
        return 0;
 }
@@ -273,15 +310,16 @@ static struct usb_ehci_pdata octeon_ehci_pdata = {
 #ifdef __BIG_ENDIAN
        .big_endian_mmio        = 1,
 #endif
+        .dma_mask_64    = 1,
        .power_on       = octeon_ehci_power_on,
        .power_off      = octeon_ehci_power_off,
 };
-static void __init octeon_ehci_hw_start(void)
+static void __init octeon_ehci_hw_start(struct device *dev)
 {
        union cvmx_uctlx_ehci_ctl ehci_ctl;
-        octeon2_usb_clocks_start();
+        octeon2_usb_clocks_start(dev);
        ehci_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_EHCI_CTL(0));
        /* Use 64-bit addressing. */
@@ -294,64 +332,30 @@ static void __init octeon_ehci_hw_start(void)
        octeon2_usb_clocks_stop();
 }
-static u64 octeon_ehci_dma_mask = DMA_BIT_MASK(64);
 static int __init octeon_ehci_device_init(void)
 {
        struct platform_device *pd;
+        struct device_node *ehci_node;
        int ret = 0;
-        struct resource usb_resources[] = {
+        ehci_node = of_find_node_by_name(NULL, "ehci");
-                {
+        if (!ehci_node)
-                        .flags  = IORESOURCE_MEM,
-                }, {
-                        .flags  = IORESOURCE_IRQ,
-                }
-        };
-        /* Only Octeon2 has ehci/ohci */
-        if (!OCTEON_IS_MODEL(OCTEON_CN63XX))
                return 0;
-        if (octeon_is_simulation() || usb_disabled())
+        pd = of_find_device_by_node(ehci_node);
-                return 0; /* No USB in the simulator. */
+        if (!pd)
+                return 0;
-        pd = platform_device_alloc("ehci-platform", 0);
-        if (!pd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        usb_resources[0].start = 0x00016F0000000000ULL;
-        usb_resources[0].end = usb_resources[0].start + 0x100;
-        usb_resources[1].start = OCTEON_IRQ_USB0;
-        usb_resources[1].end = OCTEON_IRQ_USB0;
-        ret = platform_device_add_resources(pd, usb_resources,
-                                            ARRAY_SIZE(usb_resources));
-        if (ret)
-                goto fail;
-        pd->dev.dma_mask = &octeon_ehci_dma_mask;
        pd->dev.platform_data = &octeon_ehci_pdata;
-        octeon_ehci_hw_start();
+        octeon_ehci_hw_start(&pd->dev);
-        ret = platform_device_add(pd);
-        if (ret)
-                goto fail;
-        return ret;
-fail:
-        platform_device_put(pd);
-out:
        return ret;
 }
 device_initcall(octeon_ehci_device_init);
 static int octeon_ohci_power_on(struct platform_device *pdev)
 {
-        octeon2_usb_clocks_start();
+        octeon2_usb_clocks_start(&pdev->dev);
        return 0;
 }
@@ -369,11 +373,11 @@ static struct usb_ohci_pdata octeon_ohci_pdata = {
        .power_off      = octeon_ohci_power_off,
 };
-static void __init octeon_ohci_hw_start(void)
+static void __init octeon_ohci_hw_start(struct device *dev)
 {
        union cvmx_uctlx_ohci_ctl ohci_ctl;
-        octeon2_usb_clocks_start();
+        octeon2_usb_clocks_start(dev);
        ohci_ctl.u64 = cvmx_read_csr(CVMX_UCTLX_OHCI_CTL(0));
        ohci_ctl.s.l2c_addr_msb = 0;
@@ -387,57 +391,27 @@ static void __init octeon_ohci_hw_start(void)
 static int __init octeon_ohci_device_init(void)
 {
        struct platform_device *pd;
+        struct device_node *ohci_node;
        int ret = 0;
-        struct resource usb_resources[] = {
+        ohci_node = of_find_node_by_name(NULL, "ohci");
-                {
+        if (!ohci_node)
-                        .flags  = IORESOURCE_MEM,
-                }, {
-                        .flags  = IORESOURCE_IRQ,
-                }
-        };
-        /* Only Octeon2 has ehci/ohci */
-        if (!OCTEON_IS_MODEL(OCTEON_CN63XX))
                return 0;
-        if (octeon_is_simulation() || usb_disabled())
+        pd = of_find_device_by_node(ohci_node);
-                return 0; /* No USB in the simulator. */
+        if (!pd)
+                return 0;
-        pd = platform_device_alloc("ohci-platform", 0);
-        if (!pd) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        usb_resources[0].start = 0x00016F0000000400ULL;
-        usb_resources[0].end = usb_resources[0].start + 0x100;
-        usb_resources[1].start = OCTEON_IRQ_USB0;
-        usb_resources[1].end = OCTEON_IRQ_USB0;
-        ret = platform_device_add_resources(pd, usb_resources,
-                                            ARRAY_SIZE(usb_resources));
-        if (ret)
-                goto fail;
        pd->dev.platform_data = &octeon_ohci_pdata;
-        octeon_ohci_hw_start();
+        octeon_ohci_hw_start(&pd->dev);
-        ret = platform_device_add(pd);
-        if (ret)
-                goto fail;
        return ret;
-fail:
-        platform_device_put(pd);
-out:
-        return ret;
 }
 device_initcall(octeon_ohci_device_init);
 #endif /* CONFIG_USB */
 static struct of_device_id __initdata octeon_ids[] = {
        { .compatible = "simple-bus", },
        { .compatible = "cavium,octeon-6335-uctl", },
diff --git a/drivers/phy/Kconfig b/drivers/phy/Kconfig
index ccad8809ecb1..b24500afba25 100644
--- a/drivers/phy/Kconfig
+++ b/drivers/phy/Kconfig
@@ -239,6 +239,13 @@ config PHY_QCOM_IPQ806X_SATA
        depends on OF
        select GENERIC_PHY
+config PHY_ROCKCHIP_USB
+        tristate "Rockchip USB2 PHY Driver"
+        depends on ARCH_ROCKCHIP && OF
+        select GENERIC_PHY
+        help
+          Enable this to support the Rockchip USB 2.0 PHY.
 config PHY_ST_SPEAR1310_MIPHY
        tristate "ST SPEAR1310-MIPHY driver"
        select GENERIC_PHY
diff --git a/drivers/phy/Makefile b/drivers/phy/Makefile
index aa74f961e44e..48bf5a15f161 100644
--- a/drivers/phy/Makefile
+++ b/drivers/phy/Makefile
@@ -28,6 +28,7 @@ phy-exynos-usb2-$(CONFIG_PHY_EXYNOS5250_USB2)	+= phy-exynos5250-usb2.o
 phy-exynos-usb2-$(CONFIG_PHY_S5PV210_USB2)      += phy-s5pv210-usb2.o
 obj-$(CONFIG_PHY_EXYNOS5_USBDRD)        += phy-exynos5-usbdrd.o
 obj-$(CONFIG_PHY_QCOM_APQ8064_SATA)     += phy-qcom-apq8064-sata.o
+obj-$(CONFIG_PHY_ROCKCHIP_USB) += phy-rockchip-usb.o
 obj-$(CONFIG_PHY_QCOM_IPQ806X_SATA)     += phy-qcom-ipq806x-sata.o
 obj-$(CONFIG_PHY_ST_SPEAR1310_MIPHY)    += phy-spear1310-miphy.o
 obj-$(CONFIG_PHY_ST_SPEAR1340_MIPHY)    += phy-spear1340-miphy.o
diff --git a/drivers/phy/phy-armada375-usb2.c b/drivers/phy/phy-armada375-usb2.c
index ac7d99d01cb3..7c99ca256f05 100644
--- a/drivers/phy/phy-armada375-usb2.c
+++ b/drivers/phy/phy-armada375-usb2.c
@@ -118,8 +118,8 @@ static int armada375_usb_phy_probe(struct platform_device *pdev)
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        usb_cluster_base = devm_ioremap_resource(&pdev->dev, res);
-        if (!usb_cluster_base)
+        if (IS_ERR(usb_cluster_base))
-                return -ENOMEM;
+                return PTR_ERR(usb_cluster_base);
        phy = devm_phy_create(dev, NULL, &armada375_usb_phy_ops);
        if (IS_ERR(phy)) {
diff --git a/drivers/phy/phy-exynos-mipi-video.c b/drivers/phy/phy-exynos-mipi-video.c
index 943e0f88a120..f017b2f2a54e 100644
--- a/drivers/phy/phy-exynos-mipi-video.c
+++ b/drivers/phy/phy-exynos-mipi-video.c
@@ -12,19 +12,18 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
+#include <linux/mfd/syscon/exynos4-pmu.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/regmap.h>
 #include <linux/spinlock.h>
+#include <linux/mfd/syscon.h>
-/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
+/* MIPI_PHYn_CONTROL reg. offset (for base address from ioremap): n = 0..1 */
 #define EXYNOS_MIPI_PHY_CONTROL(n)      ((n) * 4)
-#define EXYNOS_MIPI_PHY_ENABLE          (1 << 0)
-#define EXYNOS_MIPI_PHY_SRESETN         (1 << 1)
-#define EXYNOS_MIPI_PHY_MRESETN         (1 << 2)
-#define EXYNOS_MIPI_PHY_RESET_MASK      (3 << 1)
 enum exynos_mipi_phy_id {
        EXYNOS_MIPI_PHY_ID_CSIS0,
@@ -38,43 +37,62 @@ enum exynos_mipi_phy_id {
        ((id) == EXYNOS_MIPI_PHY_ID_DSIM0 || (id) == EXYNOS_MIPI_PHY_ID_DSIM1)
 struct exynos_mipi_video_phy {
-        spinlock_t slock;
        struct video_phy_desc {
                struct phy *phy;
                unsigned int index;
        } phys[EXYNOS_MIPI_PHYS_NUM];
+        spinlock_t slock;
        void __iomem *regs;
+        struct mutex mutex;
+        struct regmap *regmap;
 };
 static int __set_phy_state(struct exynos_mipi_video_phy *state,
                        enum exynos_mipi_phy_id id, unsigned int on)
 {
+        const unsigned int offset = EXYNOS4_MIPI_PHY_CONTROL(id / 2);
        void __iomem *addr;
-        u32 reg, reset;
+        u32 val, reset;
-        addr = state->regs + EXYNOS_MIPI_PHY_CONTROL(id / 2);
        if (is_mipi_dsim_phy_id(id))
-                reset = EXYNOS_MIPI_PHY_MRESETN;
+                reset = EXYNOS4_MIPI_PHY_MRESETN;
-        else
-                reset = EXYNOS_MIPI_PHY_SRESETN;
-        spin_lock(&state->slock);
-        reg = readl(addr);
-        if (on)
-                reg |= reset;
        else
-                reg &= ~reset;
+                reset = EXYNOS4_MIPI_PHY_SRESETN;
-        writel(reg, addr);
+        if (state->regmap) {
-        /* Clear ENABLE bit only if MRESETN, SRESETN bits are not set. */
+                mutex_lock(&state->mutex);
-        if (on)
+                regmap_read(state->regmap, offset, &val);
-                reg |= EXYNOS_MIPI_PHY_ENABLE;
+                if (on)
-        else if (!(reg & EXYNOS_MIPI_PHY_RESET_MASK))
+                        val |= reset;
-                reg &= ~EXYNOS_MIPI_PHY_ENABLE;
+                else
+                        val &= ~reset;
+                regmap_write(state->regmap, offset, val);
+                if (on)
+                        val |= EXYNOS4_MIPI_PHY_ENABLE;
+                else if (!(val & EXYNOS4_MIPI_PHY_RESET_MASK))
+                        val &= ~EXYNOS4_MIPI_PHY_ENABLE;
+                regmap_write(state->regmap, offset, val);
+                mutex_unlock(&state->mutex);
+        } else {
+                addr = state->regs + EXYNOS_MIPI_PHY_CONTROL(id / 2);
+                spin_lock(&state->slock);
+                val = readl(addr);
+                if (on)
+                        val |= reset;
+                else
+                        val &= ~reset;
+                writel(val, addr);
+                /* Clear ENABLE bit only if MRESETN, SRESETN bits are not set */
+                if (on)
+                        val |= EXYNOS4_MIPI_PHY_ENABLE;
+                else if (!(val & EXYNOS4_MIPI_PHY_RESET_MASK))
+                        val &= ~EXYNOS4_MIPI_PHY_ENABLE;
+                writel(val, addr);
+                spin_unlock(&state->slock);
+        }
-        writel(reg, addr);
-        spin_unlock(&state->slock);
        return 0;
 }
@@ -118,7 +136,6 @@ static int exynos_mipi_video_phy_probe(struct platform_device *pdev)
 {
        struct exynos_mipi_video_phy *state;
        struct device *dev = &pdev->dev;
-        struct resource *res;
        struct phy_provider *phy_provider;
        unsigned int i;
@@ -126,14 +143,22 @@ static int exynos_mipi_video_phy_probe(struct platform_device *pdev)
        if (!state)
                return -ENOMEM;
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        state->regmap = syscon_regmap_lookup_by_phandle(dev->of_node, "syscon");
+        if (IS_ERR(state->regmap)) {
+                struct resource *res;
-        state->regs = devm_ioremap_resource(dev, res);
+                dev_info(dev, "regmap lookup failed: %ld\n",
-        if (IS_ERR(state->regs))
+                         PTR_ERR(state->regmap));
-                return PTR_ERR(state->regs);
+                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+                state->regs = devm_ioremap_resource(dev, res);
+                if (IS_ERR(state->regs))
+                        return PTR_ERR(state->regs);
+        }
        dev_set_drvdata(dev, state);
        spin_lock_init(&state->slock);
+        mutex_init(&state->mutex);
        for (i = 0; i < EXYNOS_MIPI_PHYS_NUM; i++) {
                struct phy *phy = devm_phy_create(dev, NULL,
diff --git a/drivers/phy/phy-miphy28lp.c b/drivers/phy/phy-miphy28lp.c
index 27fa62ce6136..9b2848e6115d 100644
--- a/drivers/phy/phy-miphy28lp.c
+++ b/drivers/phy/phy-miphy28lp.c
@@ -194,6 +194,14 @@
 #define MIPHY_SATA_BANK_NB      3
 #define MIPHY_PCIE_BANK_NB      2
+enum {
+        SYSCFG_CTRL,
+        SYSCFG_STATUS,
+        SYSCFG_PCI,
+        SYSCFG_SATA,
+        SYSCFG_REG_MAX,
+};
 struct miphy28lp_phy {
        struct phy *phy;
        struct miphy28lp_dev *phydev;
@@ -211,10 +219,7 @@ struct miphy28lp_phy {
        u32 sata_gen;
        /* Sysconfig registers offsets needed to configure the device */
-        u32 syscfg_miphy_ctrl;
+        u32 syscfg_reg[SYSCFG_REG_MAX];
-        u32 syscfg_miphy_status;
-        u32 syscfg_pci;
-        u32 syscfg_sata;
        u8 type;
 };
@@ -834,12 +839,12 @@ static int miphy_osc_is_ready(struct miphy28lp_phy *miphy_phy)
        if (!miphy_phy->osc_rdy)
                return 0;
-        if (!miphy_phy->syscfg_miphy_status)
+        if (!miphy_phy->syscfg_reg[SYSCFG_STATUS])
                return -EINVAL;
        do {
-                regmap_read(miphy_dev->regmap, miphy_phy->syscfg_miphy_status,
+                regmap_read(miphy_dev->regmap,
-                            &val);
+                                miphy_phy->syscfg_reg[SYSCFG_STATUS], &val);
                if ((val & MIPHY_OSC_RDY) != MIPHY_OSC_RDY)
                        cpu_relax();
@@ -888,7 +893,7 @@ static int miphy28lp_setup(struct miphy28lp_phy *miphy_phy, u32 miphy_val)
        int err;
        struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
-        if (!miphy_phy->syscfg_miphy_ctrl)
+        if (!miphy_phy->syscfg_reg[SYSCFG_CTRL])
                return -EINVAL;
        err = reset_control_assert(miphy_phy->miphy_rst);
@@ -900,7 +905,8 @@ static int miphy28lp_setup(struct miphy28lp_phy *miphy_phy, u32 miphy_val)
        if (miphy_phy->osc_force_ext)
                miphy_val |= MIPHY_OSC_FORCE_EXT;
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_miphy_ctrl,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_CTRL],
                           MIPHY_CTRL_MASK, miphy_val);
        err = reset_control_deassert(miphy_phy->miphy_rst);
@@ -917,8 +923,9 @@ static int miphy28lp_init_sata(struct miphy28lp_phy *miphy_phy)
        struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
        int err, sata_conf = SATA_CTRL_SELECT_SATA;
-        if ((!miphy_phy->syscfg_sata) || (!miphy_phy->syscfg_pci)
+        if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) ||
-                || (!miphy_phy->base))
+                        (!miphy_phy->syscfg_reg[SYSCFG_PCI]) ||
+                        (!miphy_phy->base))
                return -EINVAL;
        dev_info(miphy_dev->dev, "sata-up mode, addr 0x%p\n", miphy_phy->base);
@@ -926,10 +933,11 @@ static int miphy28lp_init_sata(struct miphy28lp_phy *miphy_phy)
        /* Configure the glue-logic */
        sata_conf |= ((miphy_phy->sata_gen - SATA_GEN1) << SATA_SPDMODE);
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_sata,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_SATA],
                           SATA_CTRL_MASK, sata_conf);
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_pci,
+        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI],
                           PCIE_CTRL_MASK, SATA_CTRL_SELECT_PCIE);
        /* MiPHY path and clocking init */
@@ -951,17 +959,19 @@ static int miphy28lp_init_pcie(struct miphy28lp_phy *miphy_phy)
        struct miphy28lp_dev *miphy_dev = miphy_phy->phydev;
        int err;
-        if ((!miphy_phy->syscfg_sata) || (!miphy_phy->syscfg_pci)
+        if ((!miphy_phy->syscfg_reg[SYSCFG_SATA]) ||
+                        (!miphy_phy->syscfg_reg[SYSCFG_PCI])
                || (!miphy_phy->base) || (!miphy_phy->pipebase))
                return -EINVAL;
        dev_info(miphy_dev->dev, "pcie-up mode, addr 0x%p\n", miphy_phy->base);
        /* Configure the glue-logic */
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_sata,
+        regmap_update_bits(miphy_dev->regmap,
+                           miphy_phy->syscfg_reg[SYSCFG_SATA],
                           SATA_CTRL_MASK, SATA_CTRL_SELECT_PCIE);
-        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_pci,
+        regmap_update_bits(miphy_dev->regmap, miphy_phy->syscfg_reg[SYSCFG_PCI],
                           PCIE_CTRL_MASK, SYSCFG_PCIE_PCIE_VAL);
        /* MiPHY path and clocking init */
@@ -1156,7 +1166,8 @@ static int miphy28lp_probe_resets(struct device_node *node,
 static int miphy28lp_of_probe(struct device_node *np,
                              struct miphy28lp_phy *miphy_phy)
 {
-        struct resource res;
+        int i;
+        u32 ctrlreg;
        miphy_phy->osc_force_ext =
                of_property_read_bool(np, "st,osc-force-ext");
@@ -1175,18 +1186,10 @@ static int miphy28lp_of_probe(struct device_node *np,
        if (!miphy_phy->sata_gen)
                miphy_phy->sata_gen = SATA_GEN1;
-        if (!miphy28lp_get_resource_byname(np, "miphy-ctrl-glue", &res))
+        for (i = 0; i < SYSCFG_REG_MAX; i++) {
-                miphy_phy->syscfg_miphy_ctrl = res.start;
+                if (!of_property_read_u32_index(np, "st,syscfg", i, &ctrlreg))
+                        miphy_phy->syscfg_reg[i] = ctrlreg;
-        if (!miphy28lp_get_resource_byname(np, "miphy-status-glue", &res))
+        }
-                miphy_phy->syscfg_miphy_status = res.start;
-        if (!miphy28lp_get_resource_byname(np, "pcie-glue", &res))
-                miphy_phy->syscfg_pci = res.start;
-        if (!miphy28lp_get_resource_byname(np, "sata-glue", &res))
-                miphy_phy->syscfg_sata = res.start;
        return 0;
 }
diff --git a/drivers/phy/phy-miphy365x.c b/drivers/phy/phy-miphy365x.c
index 6ab43a814ad2..6c80154e8bff 100644
--- a/drivers/phy/phy-miphy365x.c
+++ b/drivers/phy/phy-miphy365x.c
@@ -141,7 +141,7 @@ struct miphy365x_phy {
        bool pcie_tx_pol_inv;
        bool sata_tx_pol_inv;
        u32 sata_gen;
-        u64 ctrlreg;
+        u32 ctrlreg;
        u8 type;
 };
@@ -179,7 +179,7 @@ static int miphy365x_set_path(struct miphy365x_phy *miphy_phy,
        bool sata = (miphy_phy->type == MIPHY_TYPE_SATA);
        return regmap_update_bits(miphy_dev->regmap,
-                                  (unsigned int)miphy_phy->ctrlreg,
+                                  miphy_phy->ctrlreg,
                                  SYSCFG_SELECT_SATA_MASK,
                                  sata << SYSCFG_SELECT_SATA_POS);
 }
@@ -445,7 +445,6 @@ int miphy365x_get_addr(struct device *dev, struct miphy365x_phy *miphy_phy,
 {
        struct device_node *phynode = miphy_phy->phy->dev.of_node;
        const char *name;
-        const __be32 *taddr;
        int type = miphy_phy->type;
        int ret;
@@ -455,22 +454,6 @@ int miphy365x_get_addr(struct device *dev, struct miphy365x_phy *miphy_phy,
                return ret;
        }
-        if (!strncmp(name, "syscfg", 6)) {
-                taddr = of_get_address(phynode, index, NULL, NULL);
-                if (!taddr) {
-                        dev_err(dev, "failed to fetch syscfg address\n");
-                        return -EINVAL;
-                }
-                miphy_phy->ctrlreg = of_translate_address(phynode, taddr);
-                if (miphy_phy->ctrlreg == OF_BAD_ADDR) {
-                        dev_err(dev, "failed to translate syscfg address\n");
-                        return -EINVAL;
-                }
-                return 0;
-        }
        if (!((!strncmp(name, "sata", 4) && type == MIPHY_TYPE_SATA) ||
              (!strncmp(name, "pcie", 4) && type == MIPHY_TYPE_PCIE)))
                return 0;
@@ -606,7 +589,15 @@ static int miphy365x_probe(struct platform_device *pdev)
                        return ret;
                phy_set_drvdata(phy, miphy_dev->phys[port]);
                port++;
+                /* sysconfig offsets are indexed from 1 */
+                ret = of_property_read_u32_index(np, "st,syscfg", port,
+                                        &miphy_phy->ctrlreg);
+                if (ret) {
+                        dev_err(&pdev->dev, "No sysconfig offset found\n");
+                        return ret;
+                }
        }
        provider = devm_of_phy_provider_register(&pdev->dev, miphy365x_xlate);
diff --git a/drivers/phy/phy-rockchip-usb.c b/drivers/phy/phy-rockchip-usb.c
new file mode 100644
index 000000000000..22011c3b6a4b
--- /dev/null
+++ b/drivers/phy/phy-rockchip-usb.c
@@ -0,0 +1,158 @@
+/*
+ * Rockchip usb PHY driver
+ *
+ * Copyright (C) 2014 Yunzhi Li <lyz@rock-chips.com>
+ * Copyright (C) 2014 ROCKCHIP, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/phy/phy.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/reset.h>
+#include <linux/regmap.h>
+#include <linux/mfd/syscon.h>
+/*
+ * The higher 16-bit of this register is used for write protection
+ * only if BIT(13 + 16) set to 1 the BIT(13) can be written.
+ */
+#define SIDDQ_WRITE_ENA BIT(29)
+#define SIDDQ_ON                BIT(13)
+#define SIDDQ_OFF               (0 << 13)
+struct rockchip_usb_phy {
+        unsigned int    reg_offset;
+        struct regmap   *reg_base;
+        struct clk      *clk;
+        struct phy      *phy;
+};
+static int rockchip_usb_phy_power(struct rockchip_usb_phy *phy,
+                                           bool siddq)
+{
+        return regmap_write(phy->reg_base, phy->reg_offset,
+                            SIDDQ_WRITE_ENA | (siddq ? SIDDQ_ON : SIDDQ_OFF));
+}
+static int rockchip_usb_phy_power_off(struct phy *_phy)
+{
+        struct rockchip_usb_phy *phy = phy_get_drvdata(_phy);
+        int ret = 0;
+        /* Power down usb phy analog blocks by set siddq 1 */
+        ret = rockchip_usb_phy_power(phy, 1);
+        if (ret)
+                return ret;
+        clk_disable_unprepare(phy->clk);
+        if (ret)
+                return ret;
+        return 0;
+}
+static int rockchip_usb_phy_power_on(struct phy *_phy)
+{
+        struct rockchip_usb_phy *phy = phy_get_drvdata(_phy);
+        int ret = 0;
+        ret = clk_prepare_enable(phy->clk);
+        if (ret)
+                return ret;
+        /* Power up usb phy analog blocks by set siddq 0 */
+        ret = rockchip_usb_phy_power(phy, 0);
+        if (ret)
+                return ret;
+        return 0;
+}
+static struct phy_ops ops = {
+        .power_on       = rockchip_usb_phy_power_on,
+        .power_off      = rockchip_usb_phy_power_off,
+        .owner          = THIS_MODULE,
+};
+static int rockchip_usb_phy_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct rockchip_usb_phy *rk_phy;
+        struct phy_provider *phy_provider;
+        struct device_node *child;
+        struct regmap *grf;
+        unsigned int reg_offset;
+        grf = syscon_regmap_lookup_by_phandle(dev->of_node, "rockchip,grf");
+        if (IS_ERR(grf)) {
+                dev_err(&pdev->dev, "Missing rockchip,grf property\n");
+                return PTR_ERR(grf);
+        }
+        for_each_available_child_of_node(dev->of_node, child) {
+                rk_phy = devm_kzalloc(dev, sizeof(*rk_phy), GFP_KERNEL);
+                if (!rk_phy)
+                        return -ENOMEM;
+                if (of_property_read_u32(child, "reg", &reg_offset)) {
+                        dev_err(dev, "missing reg property in node %s\n",
+                                child->name);
+                        return -EINVAL;
+                }
+                rk_phy->reg_offset = reg_offset;
+                rk_phy->reg_base = grf;
+                rk_phy->clk = of_clk_get_by_name(child, "phyclk");
+                if (IS_ERR(rk_phy->clk))
+                        rk_phy->clk = NULL;
+                rk_phy->phy = devm_phy_create(dev, child, &ops);
+                if (IS_ERR(rk_phy->phy)) {
+                        dev_err(dev, "failed to create PHY\n");
+                        return PTR_ERR(rk_phy->phy);
+                }
+                phy_set_drvdata(rk_phy->phy, rk_phy);
+        }
+        phy_provider = devm_of_phy_provider_register(dev, of_phy_simple_xlate);
+        return PTR_ERR_OR_ZERO(phy_provider);
+}
+static const struct of_device_id rockchip_usb_phy_dt_ids[] = {
+        { .compatible = "rockchip,rk3288-usb-phy" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, rockchip_usb_phy_dt_ids);
+static struct platform_driver rockchip_usb_driver = {
+        .probe          = rockchip_usb_phy_probe,
+        .driver         = {
+                .name   = "rockchip-usb-phy",
+                .owner  = THIS_MODULE,
+                .of_match_table = rockchip_usb_phy_dt_ids,
+        },
+};
+module_platform_driver(rockchip_usb_driver);
+MODULE_AUTHOR("Yunzhi Li <lyz@rock-chips.com>");
+MODULE_DESCRIPTION("Rockchip USB 2.0 PHY driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/phy/phy-stih407-usb.c b/drivers/phy/phy-stih407-usb.c
index 74f0fab3cd8a..1d5ae5f8ef69 100644
--- a/drivers/phy/phy-stih407-usb.c
+++ b/drivers/phy/phy-stih407-usb.c
@@ -22,6 +22,9 @@
 #include <linux/mfd/syscon.h>
 #include <linux/phy/phy.h>
+#define PHYPARAM_REG    1
+#define PHYCTRL_REG     2
 /* Default PHY_SEL and REFCLKSEL configuration */
 #define STIH407_USB_PICOPHY_CTRL_PORT_CONF      0x6
 #define STIH407_USB_PICOPHY_CTRL_PORT_MASK      0x1f
@@ -93,7 +96,7 @@ static int stih407_usb2_picophy_probe(struct platform_device *pdev)
        struct device_node *np = dev->of_node;
        struct phy_provider *phy_provider;
        struct phy *phy;
-        struct resource *res;
+        int ret;
        phy_dev = devm_kzalloc(dev, sizeof(*phy_dev), GFP_KERNEL);
        if (!phy_dev)
@@ -123,19 +126,19 @@ static int stih407_usb2_picophy_probe(struct platform_device *pdev)
                return PTR_ERR(phy_dev->regmap);
        }
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "ctrl");
+        ret = of_property_read_u32_index(np, "st,syscfg", PHYPARAM_REG,
-        if (!res) {
+                                        &phy_dev->param);
-                dev_err(dev, "No ctrl reg found\n");
+        if (ret) {
-                return -ENXIO;
+                dev_err(dev, "can't get phyparam offset (%d)\n", ret);
+                return ret;
        }
-        phy_dev->ctrl = res->start;
-        res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "param");
+        ret = of_property_read_u32_index(np, "st,syscfg", PHYCTRL_REG,
-        if (!res) {
+                                        &phy_dev->ctrl);
-                dev_err(dev, "No param reg found\n");
+        if (ret) {
-                return -ENXIO;
+                dev_err(dev, "can't get phyctrl offset (%d)\n", ret);
+                return ret;
        }
-        phy_dev->param = res->start;
        phy = devm_phy_create(dev, NULL, &stih407_usb2_picophy_data);
        if (IS_ERR(phy)) {
diff --git a/drivers/phy/phy-ti-pipe3.c b/drivers/phy/phy-ti-pipe3.c
index 465de2c800f2..95c88f929f27 100644
--- a/drivers/phy/phy-ti-pipe3.c
+++ b/drivers/phy/phy-ti-pipe3.c
@@ -28,6 +28,7 @@
 #include <linux/delay.h>
 #include <linux/phy/omap_control_phy.h>
 #include <linux/of_platform.h>
+#include <linux/spinlock.h>
 #define PLL_STATUS              0x00000004
 #define PLL_GO                  0x00000008
@@ -82,6 +83,10 @@ struct ti_pipe3 {
        struct clk              *refclk;
        struct clk              *div_clk;
        struct pipe3_dpll_map   *dpll_map;
+        bool                    enabled;
+        spinlock_t              lock;   /* serialize clock enable/disable */
+        /* the below flag is needed specifically for SATA */
+        bool                    refclk_enabled;
 };
 static struct pipe3_dpll_map dpll_map_usb[] = {
@@ -307,6 +312,7 @@ static int ti_pipe3_probe(struct platform_device *pdev)
                return -ENOMEM;
        phy->dev                = &pdev->dev;
+        spin_lock_init(&phy->lock);
        if (!of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
                match = of_match_device(of_match_ptr(ti_pipe3_id_table),
@@ -333,21 +339,24 @@ static int ti_pipe3_probe(struct platform_device *pdev)
                }
        }
+        phy->refclk = devm_clk_get(phy->dev, "refclk");
+        if (IS_ERR(phy->refclk)) {
+                dev_err(&pdev->dev, "unable to get refclk\n");
+                /* older DTBs have missing refclk in SATA PHY
+                 * so don't bail out in case of SATA PHY.
+                 */
+                if (!of_device_is_compatible(node, "ti,phy-pipe3-sata"))
+                        return PTR_ERR(phy->refclk);
+        }
        if (!of_device_is_compatible(node, "ti,phy-pipe3-sata")) {
                phy->wkupclk = devm_clk_get(phy->dev, "wkupclk");
                if (IS_ERR(phy->wkupclk)) {
                        dev_err(&pdev->dev, "unable to get wkupclk\n");
                        return PTR_ERR(phy->wkupclk);
                }
-                phy->refclk = devm_clk_get(phy->dev, "refclk");
-                if (IS_ERR(phy->refclk)) {
-                        dev_err(&pdev->dev, "unable to get refclk\n");
-                        return PTR_ERR(phy->refclk);
-                }
        } else {
                phy->wkupclk = ERR_PTR(-ENODEV);
-                phy->refclk = ERR_PTR(-ENODEV);
        }
        if (of_device_is_compatible(node, "ti,phy-pipe3-pcie")) {
@@ -426,33 +435,42 @@ static int ti_pipe3_remove(struct platform_device *pdev)
 }
 #ifdef CONFIG_PM
+static int ti_pipe3_enable_refclk(struct ti_pipe3 *phy)
-static int ti_pipe3_runtime_suspend(struct device *dev)
 {
-        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        if (!IS_ERR(phy->refclk) && !phy->refclk_enabled) {
+                int ret;
-        if (!IS_ERR(phy->wkupclk))
+                ret = clk_prepare_enable(phy->refclk);
-                clk_disable_unprepare(phy->wkupclk);
+                if (ret) {
+                        dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
+                        return ret;
+                }
+                phy->refclk_enabled = true;
+        }
+        return 0;
+}
+static void ti_pipe3_disable_refclk(struct ti_pipe3 *phy)
+{
        if (!IS_ERR(phy->refclk))
                clk_disable_unprepare(phy->refclk);
-        if (!IS_ERR(phy->div_clk))
-                clk_disable_unprepare(phy->div_clk);
-        return 0;
+        phy->refclk_enabled = false;
 }
-static int ti_pipe3_runtime_resume(struct device *dev)
+static int ti_pipe3_enable_clocks(struct ti_pipe3 *phy)
 {
-        u32 ret = 0;
+        int ret = 0;
-        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        unsigned long flags;
-        if (!IS_ERR(phy->refclk)) {
+        spin_lock_irqsave(&phy->lock, flags);
-                ret = clk_prepare_enable(phy->refclk);
+        if (phy->enabled)
-                if (ret) {
+                goto err1;
-                        dev_err(phy->dev, "Failed to enable refclk %d\n", ret);
-                        goto err1;
+        ret = ti_pipe3_enable_refclk(phy);
-                }
+        if (ret)
-        }
+                goto err1;
        if (!IS_ERR(phy->wkupclk)) {
                ret = clk_prepare_enable(phy->wkupclk);
@@ -469,6 +487,9 @@ static int ti_pipe3_runtime_resume(struct device *dev)
                        goto err3;
                }
        }
+        phy->enabled = true;
+        spin_unlock_irqrestore(&phy->lock, flags);
        return 0;
 err3:
@@ -479,20 +500,80 @@ err2:
        if (!IS_ERR(phy->refclk))
                clk_disable_unprepare(phy->refclk);
+        ti_pipe3_disable_refclk(phy);
 err1:
+        spin_unlock_irqrestore(&phy->lock, flags);
        return ret;
 }
+static void ti_pipe3_disable_clocks(struct ti_pipe3 *phy)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&phy->lock, flags);
+        if (!phy->enabled) {
+                spin_unlock_irqrestore(&phy->lock, flags);
+                return;
+        }
+        if (!IS_ERR(phy->wkupclk))
+                clk_disable_unprepare(phy->wkupclk);
+        /* Don't disable refclk for SATA PHY due to Errata i783 */
+        if (!of_device_is_compatible(phy->dev->of_node, "ti,phy-pipe3-sata"))
+                ti_pipe3_disable_refclk(phy);
+        if (!IS_ERR(phy->div_clk))
+                clk_disable_unprepare(phy->div_clk);
+        phy->enabled = false;
+        spin_unlock_irqrestore(&phy->lock, flags);
+}
+static int ti_pipe3_runtime_suspend(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        ti_pipe3_disable_clocks(phy);
+        return 0;
+}
+static int ti_pipe3_runtime_resume(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        int ret = 0;
+        ret = ti_pipe3_enable_clocks(phy);
+        return ret;
+}
+static int ti_pipe3_suspend(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        ti_pipe3_disable_clocks(phy);
+        return 0;
+}
+static int ti_pipe3_resume(struct device *dev)
+{
+        struct ti_pipe3 *phy = dev_get_drvdata(dev);
+        int ret;
+        ret = ti_pipe3_enable_clocks(phy);
+        if (ret)
+                return ret;
+        pm_runtime_disable(dev);
+        pm_runtime_set_active(dev);
+        pm_runtime_enable(dev);
+        return 0;
+}
+#endif
 static const struct dev_pm_ops ti_pipe3_pm_ops = {
        SET_RUNTIME_PM_OPS(ti_pipe3_runtime_suspend,
                           ti_pipe3_runtime_resume, NULL)
+        SET_SYSTEM_SLEEP_PM_OPS(ti_pipe3_suspend, ti_pipe3_resume)
 };
-#define DEV_PM_OPS     (&ti_pipe3_pm_ops)
-#else
-#define DEV_PM_OPS     NULL
-#endif
 #ifdef CONFIG_OF
 static const struct of_device_id ti_pipe3_id_table[] = {
        {
@@ -520,7 +601,7 @@ static struct platform_driver ti_pipe3_driver = {
        .remove         = ti_pipe3_remove,
        .driver         = {
                .name   = "ti-pipe3",
-                .pm     = DEV_PM_OPS,
+                .pm     = &ti_pipe3_pm_ops,
                .of_match_table = of_match_ptr(ti_pipe3_id_table),
        },
 };
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 546a17e8ad5b..e78720b59d67 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1091,6 +1091,7 @@ static int acm_probe(struct usb_interface *intf,
        unsigned long quirks;
        int num_rx_buf;
        int i;
+        unsigned int elength = 0;
        int combined_interfaces = 0;
        struct device *tty_dev;
        int rv = -ENOMEM;
@@ -1136,9 +1137,12 @@ static int acm_probe(struct usb_interface *intf,
                        dev_err(&intf->dev, "skipping garbage\n");
                        goto next_desc;
                }
+                elength = buffer[0];
                switch (buffer[2]) {
                case USB_CDC_UNION_TYPE: /* we've found it */
+                        if (elength < sizeof(struct usb_cdc_union_desc))
+                                goto next_desc;
                        if (union_header) {
                                dev_err(&intf->dev, "More than one "
                                        "union descriptor, skipping ...\n");
@@ -1147,29 +1151,36 @@ static int acm_probe(struct usb_interface *intf,
                        union_header = (struct usb_cdc_union_desc *)buffer;
                        break;
                case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
+                        if (elength < sizeof(struct usb_cdc_country_functional_desc))
+                                goto next_desc;
                        cfd = (struct usb_cdc_country_functional_desc *)buffer;
                        break;
                case USB_CDC_HEADER_TYPE: /* maybe check version */
                        break; /* for now we ignore it */
                case USB_CDC_ACM_TYPE:
+                        if (elength < 4)
+                                goto next_desc;
                        ac_management_function = buffer[3];
                        break;
                case USB_CDC_CALL_MANAGEMENT_TYPE:
+                        if (elength < 5)
+                                goto next_desc;
                        call_management_function = buffer[3];
                        call_interface_num = buffer[4];
                        break;
                default:
-                        /* there are LOTS more CDC descriptors that
+                        /*
+                         * there are LOTS more CDC descriptors that
                         * could legitimately be found here.
                         */
                        dev_dbg(&intf->dev, "Ignoring descriptor: "
-                                        "type %02x, length %d\n",
+                                        "type %02x, length %ud\n",
-                                        buffer[2], buffer[0]);
+                                        buffer[2], elength);
                        break;
                }
 next_desc:
-                buflen -= buffer[0];
+                buflen -= elength;
-                buffer += buffer[0];
+                buffer += elength;
        }
        if (!union_header) {
@@ -1287,10 +1298,8 @@ made_compressed_probe:
        dev_dbg(&intf->dev, "interfaces are valid\n");
        acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
-        if (acm == NULL) {
+        if (acm == NULL)
-                dev_err(&intf->dev, "out of memory (acm kzalloc)\n");
                goto alloc_fail;
-        }
        minor = acm_alloc_minor(acm);
        if (minor == ACM_TTY_MINORS) {
@@ -1329,42 +1338,32 @@ made_compressed_probe:
        acm->quirks = quirks;
        buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
-        if (!buf) {
+        if (!buf)
-                dev_err(&intf->dev, "out of memory (ctrl buffer alloc)\n");
                goto alloc_fail2;
-        }
        acm->ctrl_buffer = buf;
-        if (acm_write_buffers_alloc(acm) < 0) {
+        if (acm_write_buffers_alloc(acm) < 0)
-                dev_err(&intf->dev, "out of memory (write buffer alloc)\n");
                goto alloc_fail4;
-        }
        acm->ctrlurb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!acm->ctrlurb) {
+        if (!acm->ctrlurb)
-                dev_err(&intf->dev, "out of memory (ctrlurb kmalloc)\n");
                goto alloc_fail5;
-        }
        for (i = 0; i < num_rx_buf; i++) {
                struct acm_rb *rb = &(acm->read_buffers[i]);
                struct urb *urb;
                rb->base = usb_alloc_coherent(acm->dev, readsize, GFP_KERNEL,
                                                                &rb->dma);
-                if (!rb->base) {
+                if (!rb->base)
-                        dev_err(&intf->dev, "out of memory "
-                                        "(read bufs usb_alloc_coherent)\n");
                        goto alloc_fail6;
-                }
                rb->index = i;
                rb->instance = acm;
                urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (!urb) {
+                if (!urb)
-                        dev_err(&intf->dev,
-                                "out of memory (read urbs usb_alloc_urb)\n");
                        goto alloc_fail6;
-                }
                urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
                urb->transfer_dma = rb->dma;
                if (acm->is_int_ep) {
@@ -1389,11 +1388,8 @@ made_compressed_probe:
                struct acm_wb *snd = &(acm->wb[i]);
                snd->urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (snd->urb == NULL) {
+                if (snd->urb == NULL)
-                        dev_err(&intf->dev,
-                                "out of memory (write urbs usb_alloc_urb)\n");
                        goto alloc_fail7;
-                }
                if (usb_endpoint_xfer_int(epwrite))
                        usb_fill_int_urb(snd->urb, usb_dev,
diff --git a/drivers/usb/core/buffer.c b/drivers/usb/core/buffer.c
index 684ef70dc09d..506b969ea7fd 100644
--- a/drivers/usb/core/buffer.c
+++ b/drivers/usb/core/buffer.c
@@ -22,17 +22,25 @@
 */
 /* FIXME tune these based on pool statistics ... */
-static const size_t     pool_max[HCD_BUFFER_POOLS] = {
+static size_t pool_max[HCD_BUFFER_POOLS] = {
-        /* platforms without dma-friendly caches might need to
+        32, 128, 512, 2048,
-         * prevent cacheline sharing...
-         */
-        32,
-        128,
-        512,
-        PAGE_SIZE / 2
-        /* bigger --> allocate pages */
 };
+void __init usb_init_pool_max(void)
+{
+        /*
+         * The pool_max values must never be smaller than
+         * ARCH_KMALLOC_MINALIGN.
+         */
+        if (ARCH_KMALLOC_MINALIGN <= 32)
+                ;                       /* Original value is okay */
+        else if (ARCH_KMALLOC_MINALIGN <= 64)
+                pool_max[0] = 64;
+        else if (ARCH_KMALLOC_MINALIGN <= 128)
+                pool_max[0] = 0;        /* Don't use this pool */
+        else
+                BUILD_BUG();            /* We don't allow this */
+}
 /* SETUP primitives */
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 0b59731c3021..66abdbcfbfa5 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -1689,7 +1689,7 @@ static struct async *reap_as(struct usb_dev_state *ps)
        for (;;) {
                __set_current_state(TASK_INTERRUPTIBLE);
                as = async_getcompleted(ps);
-                if (as)
+                if (as || !connected(ps))
                        break;
                if (signal_pending(current))
                        break;
@@ -1712,7 +1712,7 @@ static int proc_reapurb(struct usb_dev_state *ps, void __user *arg)
        }
        if (signal_pending(current))
                return -EINTR;
-        return -EIO;
+        return -ENODEV;
 }
 static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg)
@@ -1721,10 +1721,11 @@ static int proc_reapurbnonblock(struct usb_dev_state *ps, void __user *arg)
        struct async *as;
        as = async_getcompleted(ps);
-        retval = -EAGAIN;
        if (as) {
                retval = processcompl(as, (void __user * __user *)arg);
                free_async(as);
+        } else {
+                retval = (connected(ps) ? -EAGAIN : -ENODEV);
        }
        return retval;
 }
@@ -1854,7 +1855,7 @@ static int proc_reapurb_compat(struct usb_dev_state *ps, void __user *arg)
        }
        if (signal_pending(current))
                return -EINTR;
-        return -EIO;
+        return -ENODEV;
 }
 static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *arg)
@@ -1862,11 +1863,12 @@ static int proc_reapurbnonblock_compat(struct usb_dev_state *ps, void __user *ar
        int retval;
        struct async *as;
-        retval = -EAGAIN;
        as = async_getcompleted(ps);
        if (as) {
                retval = processcompl_compat(as, (void __user * __user *)arg);
                free_async(as);
+        } else {
+                retval = (connected(ps) ? -EAGAIN : -ENODEV);
        }
        return retval;
 }
@@ -2038,7 +2040,8 @@ static int proc_get_capabilities(struct usb_dev_state *ps, void __user *arg)
 {
        __u32 caps;
-        caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM;
+        caps = USBDEVFS_CAP_ZERO_PACKET | USBDEVFS_CAP_NO_PACKET_SIZE_LIM |
+                        USBDEVFS_CAP_REAP_AFTER_DISCONNECT;
        if (!ps->dev->bus->no_stop_on_short)
                caps |= USBDEVFS_CAP_BULK_CONTINUATION;
        if (ps->dev->bus->sg_tablesize)
@@ -2138,6 +2141,32 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                return -EPERM;
        usb_lock_device(dev);
+        /* Reap operations are allowed even after disconnection */
+        switch (cmd) {
+        case USBDEVFS_REAPURB:
+                snoop(&dev->dev, "%s: REAPURB\n", __func__);
+                ret = proc_reapurb(ps, p);
+                goto done;
+        case USBDEVFS_REAPURBNDELAY:
+                snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
+                ret = proc_reapurbnonblock(ps, p);
+                goto done;
+#ifdef CONFIG_COMPAT
+        case USBDEVFS_REAPURB32:
+                snoop(&dev->dev, "%s: REAPURB32\n", __func__);
+                ret = proc_reapurb_compat(ps, p);
+                goto done;
+        case USBDEVFS_REAPURBNDELAY32:
+                snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
+                ret = proc_reapurbnonblock_compat(ps, p);
+                goto done;
+#endif
+        }
        if (!connected(ps)) {
                usb_unlock_device(dev);
                return -ENODEV;
@@ -2231,16 +2260,6 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                        inode->i_mtime = CURRENT_TIME;
                break;
-        case USBDEVFS_REAPURB32:
-                snoop(&dev->dev, "%s: REAPURB32\n", __func__);
-                ret = proc_reapurb_compat(ps, p);
-                break;
-        case USBDEVFS_REAPURBNDELAY32:
-                snoop(&dev->dev, "%s: REAPURBNDELAY32\n", __func__);
-                ret = proc_reapurbnonblock_compat(ps, p);
-                break;
        case USBDEVFS_IOCTL32:
                snoop(&dev->dev, "%s: IOCTL32\n", __func__);
                ret = proc_ioctl_compat(ps, ptr_to_compat(p));
@@ -2252,16 +2271,6 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                ret = proc_unlinkurb(ps, p);
                break;
-        case USBDEVFS_REAPURB:
-                snoop(&dev->dev, "%s: REAPURB\n", __func__);
-                ret = proc_reapurb(ps, p);
-                break;
-        case USBDEVFS_REAPURBNDELAY:
-                snoop(&dev->dev, "%s: REAPURBNDELAY\n", __func__);
-                ret = proc_reapurbnonblock(ps, p);
-                break;
        case USBDEVFS_DISCSIGNAL:
                snoop(&dev->dev, "%s: DISCSIGNAL\n", __func__);
                ret = proc_disconnectsignal(ps, p);
@@ -2304,6 +2313,8 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
                ret = proc_free_streams(ps, p);
                break;
        }
+ done:
        usb_unlock_device(dev);
        if (ret >= 0)
                inode->i_atime = CURRENT_TIME;
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 874dec31a111..818369afff63 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -275,21 +275,6 @@ static int usb_unbind_device(struct device *dev)
        return 0;
 }
-/*
- * Cancel any pending scheduled resets
- *
- * [see usb_queue_reset_device()]
- *
- * Called after unconfiguring / when releasing interfaces. See
- * comments in __usb_queue_reset_device() regarding
- * udev->reset_running.
- */
-static void usb_cancel_queued_reset(struct usb_interface *iface)
-{
-        if (iface->reset_running == 0)
-                cancel_work_sync(&iface->reset_ws);
-}
 /* called from driver core with dev locked */
 static int usb_probe_interface(struct device *dev)
 {
@@ -380,7 +365,6 @@ static int usb_probe_interface(struct device *dev)
        usb_set_intfdata(intf, NULL);
        intf->needs_remote_wakeup = 0;
        intf->condition = USB_INTERFACE_UNBOUND;
-        usb_cancel_queued_reset(intf);
        /* If the LPM disable succeeded, balance the ref counts. */
        if (!lpm_disable_error)
@@ -425,7 +409,6 @@ static int usb_unbind_interface(struct device *dev)
                usb_disable_interface(udev, intf, false);
        driver->disconnect(intf);
-        usb_cancel_queued_reset(intf);
        /* Free streams */
        for (i = 0, j = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
@@ -1797,6 +1780,18 @@ static int autosuspend_check(struct usb_device *udev)
                dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
                return -EOPNOTSUPP;
        }
+        /*
+         * If the device is a direct child of the root hub and the HCD
+         * doesn't handle wakeup requests, don't allow autosuspend when
+         * wakeup is needed.
+         */
+        if (w && udev->parent == udev->bus->root_hub &&
+                        bus_to_hcd(udev->bus)->cant_recv_wakeups) {
+                dev_dbg(&udev->dev, "HCD doesn't handle wakeup requests\n");
+                return -EOPNOTSUPP;
+        }
        udev->do_remote_wakeup = w;
        return 0;
 }
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 11cee55ae397..45a915ccd71c 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -1618,6 +1618,7 @@ static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
 int usb_hcd_unlink_urb (struct urb *urb, int status)
 {
        struct usb_hcd          *hcd;
+        struct usb_device       *udev = urb->dev;
        int                     retval = -EIDRM;
        unsigned long           flags;
@@ -1629,20 +1630,19 @@ int usb_hcd_unlink_urb (struct urb *urb, int status)
        spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
        if (atomic_read(&urb->use_count) > 0) {
                retval = 0;
-                usb_get_dev(urb->dev);
+                usb_get_dev(udev);
        }
        spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
        if (retval == 0) {
                hcd = bus_to_hcd(urb->dev->bus);
                retval = unlink1(hcd, urb, status);
-                usb_put_dev(urb->dev);
+                if (retval == 0)
+                        retval = -EINPROGRESS;
+                else if (retval != -EIDRM && retval != -EBUSY)
+                        dev_dbg(&udev->dev, "hcd_unlink_urb %p fail %d\n",
+                                        urb, retval);
+                usb_put_dev(udev);
        }
-        if (retval == 0)
-                retval = -EINPROGRESS;
-        else if (retval != -EIDRM && retval != -EBUSY)
-                dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
-                                urb, retval);
        return retval;
 }
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index aeb50bb6ba9c..3e9c4d477d1a 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -4655,9 +4655,13 @@ static void hub_port_connect(struct usb_hub *hub, int port1, u16 portstatus,
        if (!(portstatus & USB_PORT_STAT_CONNECTION) ||
                        test_bit(port1, hub->removed_bits)) {
-                /* maybe switch power back on (e.g. root hub was reset) */
+                /*
+                 * maybe switch power back on (e.g. root hub was reset)
+                 * but only if the port isn't owned by someone else.
+                 */
                if (hub_is_port_power_switchable(hub)
-                                && !port_is_power_on(hub, portstatus))
+                                && !port_is_power_on(hub, portstatus)
+                                && !port_dev->port_owner)
                        set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
                if (portstatus & USB_PORT_STAT_ENABLE)
@@ -5589,26 +5593,19 @@ EXPORT_SYMBOL_GPL(usb_reset_device);
 *   possible; depending on how the driver attached to each interface
 *   handles ->pre_reset(), the second reset might happen or not.
 *
- * - If a driver is unbound and it had a pending reset, the reset will
+ * - If the reset is delayed so long that the interface is unbound from
- *   be cancelled.
+ *   its driver, the reset will be skipped.
- *
- * - This function can be called during .probe() or .disconnect()
- *   times. On return from .disconnect(), any pending resets will be
- *   cancelled.
- *
- * There is no no need to lock/unlock the @reset_ws as schedule_work()
- * does its own.
 *
- * NOTE: We don't do any reference count tracking because it is not
+ * - This function can be called during .probe().  It can also be called
- *     needed. The lifecycle of the work_struct is tied to the
+ *   during .disconnect(), but doing so is pointless because the reset
- *     usb_interface. Before destroying the interface we cancel the
+ *   will not occur.  If you really want to reset the device during
- *     work_struct, so the fact that work_struct is queued and or
+ *   .disconnect(), call usb_reset_device() directly -- but watch out
- *     running means the interface (and thus, the device) exist and
+ *   for nested unbinding issues!
- *     are referenced.
 */
 void usb_queue_reset_device(struct usb_interface *iface)
 {
-        schedule_work(&iface->reset_ws);
+        if (schedule_work(&iface->reset_ws))
+                usb_get_intf(iface);
 }
 EXPORT_SYMBOL_GPL(usb_queue_reset_device);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index f7b7713cfb2a..f368d2053da5 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -1551,6 +1551,7 @@ static void usb_release_interface(struct device *dev)
                        altsetting_to_usb_interface_cache(intf->altsetting);
        kref_put(&intfc->ref, usb_release_interface_cache);
+        usb_put_dev(interface_to_usbdev(intf));
        kfree(intf);
 }
@@ -1626,24 +1627,6 @@ static struct usb_interface_assoc_descriptor *find_iad(struct usb_device *dev,
 /*
 * Internal function to queue a device reset
- *
- * This is initialized into the workstruct in 'struct
- * usb_device->reset_ws' that is launched by
- * message.c:usb_set_configuration() when initializing each 'struct
- * usb_interface'.
- *
- * It is safe to get the USB device without reference counts because
- * the life cycle of @iface is bound to the life cycle of @udev. Then,
- * this function will be ran only if @iface is alive (and before
- * freeing it any scheduled instances of it will have been cancelled).
- *
- * We need to set a flag (usb_dev->reset_running) because when we call
- * the reset, the interfaces might be unbound. The current interface
- * cannot try to remove the queued work as it would cause a deadlock
- * (you cannot remove your work from within your executing
- * workqueue). This flag lets it know, so that
- * usb_cancel_queued_reset() doesn't try to do it.
- *
 * See usb_queue_reset_device() for more details
 */
 static void __usb_queue_reset_device(struct work_struct *ws)
@@ -1655,11 +1638,10 @@ static void __usb_queue_reset_device(struct work_struct *ws)
        rc = usb_lock_device_for_reset(udev, iface);
        if (rc >= 0) {
-                iface->reset_running = 1;
                usb_reset_device(udev);
-                iface->reset_running = 0;
                usb_unlock_device(udev);
        }
+        usb_put_intf(iface);    /* Undo _get_ in usb_queue_reset_device() */
 }
@@ -1854,6 +1836,7 @@ free_interfaces:
                dev_set_name(&intf->dev, "%d-%s:%d.%d",
                        dev->bus->busnum, dev->devpath,
                        configuration, alt->desc.bInterfaceNumber);
+                usb_get_dev(dev);
        }
        kfree(new_interfaces);
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 2a92b97f0144..b1fb9aef0f5b 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -1049,6 +1049,7 @@ static int __init usb_init(void)
                pr_info("%s: USB support disabled\n", usbcore_name);
                return 0;
        }
+        usb_init_pool_max();
        retval = usb_debugfs_init();
        if (retval)
diff --git a/drivers/usb/dwc2/hcd.c b/drivers/usb/dwc2/hcd.c
index a0cd9db6f4cd..c5fd43d2513f 100644
--- a/drivers/usb/dwc2/hcd.c
+++ b/drivers/usb/dwc2/hcd.c
@@ -1622,7 +1622,9 @@ static int dwc2_hcd_hub_control(struct dwc2_hsotg *hsotg, u16 typereq,
                hub_desc->bDescLength = 9;
                hub_desc->bDescriptorType = 0x29;
                hub_desc->bNbrPorts = 1;
-                hub_desc->wHubCharacteristics = cpu_to_le16(0x08);
+                hub_desc->wHubCharacteristics =
+                        cpu_to_le16(HUB_CHAR_COMMON_LPSM |
+                                    HUB_CHAR_INDV_PORT_OCPM);
                hub_desc->bPwrOn2PwrGood = 1;
                hub_desc->bHubContrCurrent = 0;
                hub_desc->u.hs.DeviceRemovable[0] = 0;
diff --git a/drivers/usb/gadget/udc/bdc/bdc_core.c b/drivers/usb/gadget/udc/bdc/bdc_core.c
index c6dfef8c7bbc..5c8f4effb62a 100644
--- a/drivers/usb/gadget/udc/bdc/bdc_core.c
+++ b/drivers/usb/gadget/udc/bdc/bdc_core.c
@@ -521,7 +521,6 @@ static int bdc_remove(struct platform_device *pdev)
 static struct platform_driver bdc_driver = {
        .driver         = {
                .name   = BRCM_BDC_NAME,
-                .owner  = THIS_MODULE
        },
        .probe          = bdc_probe,
        .remove         = bdc_remove,
diff --git a/drivers/usb/gadget/udc/dummy_hcd.c b/drivers/usb/gadget/udc/dummy_hcd.c
index 9c598801404c..270c1ec650fa 100644
--- a/drivers/usb/gadget/udc/dummy_hcd.c
+++ b/drivers/usb/gadget/udc/dummy_hcd.c
@@ -1924,7 +1924,9 @@ ss_hub_descriptor(struct usb_hub_descriptor *desc)
        memset(desc, 0, sizeof *desc);
        desc->bDescriptorType = 0x2a;
        desc->bDescLength = 12;
-        desc->wHubCharacteristics = cpu_to_le16(0x0001);
+        desc->wHubCharacteristics = cpu_to_le16(
+                        HUB_CHAR_INDV_PORT_LPSM |
+                        HUB_CHAR_COMMON_OCPM);
        desc->bNbrPorts = 1;
        desc->u.ss.bHubHdrDecLat = 0x04; /* Worst case: 0.4 micro sec*/
        desc->u.ss.DeviceRemovable = 0xffff;
@@ -1935,7 +1937,9 @@ static inline void hub_descriptor(struct usb_hub_descriptor *desc)
        memset(desc, 0, sizeof *desc);
        desc->bDescriptorType = 0x29;
        desc->bDescLength = 9;
-        desc->wHubCharacteristics = cpu_to_le16(0x0001);
+        desc->wHubCharacteristics = cpu_to_le16(
+                        HUB_CHAR_INDV_PORT_LPSM |
+                        HUB_CHAR_COMMON_OCPM);
        desc->bNbrPorts = 1;
        desc->u.hs.DeviceRemovable[0] = 0xff;
        desc->u.hs.DeviceRemovable[1] = 0xff;
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 56a88506febe..663f7908b15c 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -27,44 +27,66 @@
 #define DRIVER_DESC "EHCI Atmel driver"
 static const char hcd_name[] = "ehci-atmel";
-static struct hc_driver __read_mostly ehci_atmel_hc_driver;
 /* interface and function clocks */
-static struct clk *iclk, *fclk, *uclk;
+#define hcd_to_atmel_ehci_priv(h) \
-static int clocked;
+        ((struct atmel_ehci_priv *)hcd_to_ehci(h)->priv)
+struct atmel_ehci_priv {
+        struct clk *iclk;
+        struct clk *fclk;
+        struct clk *uclk;
+        bool clocked;
+};
+static struct hc_driver __read_mostly ehci_atmel_hc_driver;
+static const struct ehci_driver_overrides ehci_atmel_drv_overrides __initconst = {
+        .extra_priv_size = sizeof(struct atmel_ehci_priv),
+};
 /*-------------------------------------------------------------------------*/
-static void atmel_start_clock(void)
+static void atmel_start_clock(struct atmel_ehci_priv *atmel_ehci)
 {
+        if (atmel_ehci->clocked)
+                return;
        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                clk_set_rate(uclk, 48000000);
+                clk_set_rate(atmel_ehci->uclk, 48000000);
-                clk_prepare_enable(uclk);
+                clk_prepare_enable(atmel_ehci->uclk);
        }
-        clk_prepare_enable(iclk);
+        clk_prepare_enable(atmel_ehci->iclk);
-        clk_prepare_enable(fclk);
+        clk_prepare_enable(atmel_ehci->fclk);
-        clocked = 1;
+        atmel_ehci->clocked = true;
 }
-static void atmel_stop_clock(void)
+static void atmel_stop_clock(struct atmel_ehci_priv *atmel_ehci)
 {
-        clk_disable_unprepare(fclk);
+        if (!atmel_ehci->clocked)
-        clk_disable_unprepare(iclk);
+                return;
+        clk_disable_unprepare(atmel_ehci->fclk);
+        clk_disable_unprepare(atmel_ehci->iclk);
        if (IS_ENABLED(CONFIG_COMMON_CLK))
-                clk_disable_unprepare(uclk);
+                clk_disable_unprepare(atmel_ehci->uclk);
-        clocked = 0;
+        atmel_ehci->clocked = false;
 }
 static void atmel_start_ehci(struct platform_device *pdev)
 {
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
        dev_dbg(&pdev->dev, "start\n");
-        atmel_start_clock();
+        atmel_start_clock(atmel_ehci);
 }
 static void atmel_stop_ehci(struct platform_device *pdev)
 {
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+        struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
        dev_dbg(&pdev->dev, "stop\n");
-        atmel_stop_clock();
+        atmel_stop_clock(atmel_ehci);
 }
 /*-------------------------------------------------------------------------*/
@@ -75,6 +97,7 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
        const struct hc_driver *driver = &ehci_atmel_hc_driver;
        struct resource *res;
        struct ehci_hcd *ehci;
+        struct atmel_ehci_priv *atmel_ehci;
        int irq;
        int retval;
@@ -105,6 +128,7 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
                retval = -ENOMEM;
                goto fail_create_hcd;
        }
+        atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        hcd->regs = devm_ioremap_resource(&pdev->dev, res);
@@ -116,23 +140,23 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
        hcd->rsrc_start = res->start;
        hcd->rsrc_len = resource_size(res);
-        iclk = devm_clk_get(&pdev->dev, "ehci_clk");
+        atmel_ehci->iclk = devm_clk_get(&pdev->dev, "ehci_clk");
-        if (IS_ERR(iclk)) {
+        if (IS_ERR(atmel_ehci->iclk)) {
                dev_err(&pdev->dev, "Error getting interface clock\n");
                retval = -ENOENT;
                goto fail_request_resource;
        }
-        fclk = devm_clk_get(&pdev->dev, "uhpck");
+        atmel_ehci->fclk = devm_clk_get(&pdev->dev, "uhpck");
-        if (IS_ERR(fclk)) {
+        if (IS_ERR(atmel_ehci->fclk)) {
                dev_err(&pdev->dev, "Error getting function clock\n");
                retval = -ENOENT;
                goto fail_request_resource;
        }
        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                uclk = devm_clk_get(&pdev->dev, "usb_clk");
+                atmel_ehci->uclk = devm_clk_get(&pdev->dev, "usb_clk");
-                if (IS_ERR(uclk)) {
+                if (IS_ERR(atmel_ehci->uclk)) {
                        dev_err(&pdev->dev, "failed to get uclk\n");
-                        retval = PTR_ERR(uclk);
+                        retval = PTR_ERR(atmel_ehci->uclk);
                        goto fail_request_resource;
                }
        }
@@ -169,11 +193,35 @@ static int ehci_atmel_drv_remove(struct platform_device *pdev)
        usb_put_hcd(hcd);
        atmel_stop_ehci(pdev);
-        fclk = iclk = NULL;
        return 0;
 }
+#ifdef CONFIG_PM
+static int ehci_atmel_drv_suspend(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
+        int ret;
+        ret = ehci_suspend(hcd, false);
+        if (ret)
+                return ret;
+        atmel_stop_clock(atmel_ehci);
+        return 0;
+}
+static int ehci_atmel_drv_resume(struct device *dev)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct atmel_ehci_priv *atmel_ehci = hcd_to_atmel_ehci_priv(hcd);
+        atmel_start_clock(atmel_ehci);
+        return ehci_resume(hcd, false);
+}
+#endif
 #ifdef CONFIG_OF
 static const struct of_device_id atmel_ehci_dt_ids[] = {
        { .compatible = "atmel,at91sam9g45-ehci" },
@@ -183,12 +231,16 @@ static const struct of_device_id atmel_ehci_dt_ids[] = {
 MODULE_DEVICE_TABLE(of, atmel_ehci_dt_ids);
 #endif
+static SIMPLE_DEV_PM_OPS(ehci_atmel_pm_ops, ehci_atmel_drv_suspend,
+                                        ehci_atmel_drv_resume);
 static struct platform_driver ehci_atmel_driver = {
        .probe          = ehci_atmel_drv_probe,
        .remove         = ehci_atmel_drv_remove,
        .shutdown       = usb_hcd_platform_shutdown,
        .driver         = {
                .name   = "atmel-ehci",
+                .pm     = &ehci_atmel_pm_ops,
                .of_match_table = of_match_ptr(atmel_ehci_dt_ids),
        },
 };
@@ -199,7 +251,7 @@ static int __init ehci_atmel_init(void)
                return -ENODEV;
        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
-        ehci_init_driver(&ehci_atmel_hc_driver, NULL);
+        ehci_init_driver(&ehci_atmel_hc_driver, &ehci_atmel_drv_overrides);
        return platform_driver_register(&ehci_atmel_driver);
 }
 module_init(ehci_atmel_init);
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index fb7bd0c7dc15..ab4eee3df97a 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -709,7 +709,6 @@ static struct platform_driver ehci_fsl_driver = {
        .shutdown = usb_hcd_platform_shutdown,
        .driver = {
                .name = "fsl-ehci",
-                .owner  = THIS_MODULE,
                .pm = EHCI_FSL_PM_OPS,
        },
 };
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
index 495b6fbcbcd9..21650044b09e 100644
--- a/drivers/usb/host/ehci-grlib.c
+++ b/drivers/usb/host/ehci-grlib.c
@@ -187,7 +187,6 @@ static struct platform_driver ehci_grlib_driver = {
        .shutdown       = usb_hcd_platform_shutdown,
        .driver = {
                .name = "grlib-ehci",
-                .owner = THIS_MODULE,
                .of_match_table = ehci_hcd_grlib_of_match,
        },
 };
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 38bfeedae1d0..85e56d1abd23 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -1110,7 +1110,7 @@ int ehci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 EXPORT_SYMBOL_GPL(ehci_suspend);
 /* Returns 0 if power was preserved, 1 if power was lost */
-int ehci_resume(struct usb_hcd *hcd, bool hibernated)
+int ehci_resume(struct usb_hcd *hcd, bool force_reset)
 {
        struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
@@ -1124,12 +1124,12 @@ int ehci_resume(struct usb_hcd *hcd, bool hibernated)
                return 0;               /* Controller is dead */
        /*
-         * If CF is still set and we aren't resuming from hibernation
+         * If CF is still set and reset isn't forced
         * then we maintained suspend power.
         * Just undo the effect of ehci_suspend().
         */
        if (ehci_readl(ehci, &ehci->regs->configured_flag) == FLAG_CF &&
-                        !hibernated) {
+                        !force_reset) {
                int     mask = INTR_MASK;
                ehci_prepare_ports_for_controller_resume(ehci);
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 118edb7bdca2..87cf86f38b36 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -700,15 +700,15 @@ ehci_hub_descriptor (
        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
-        temp = 0x0008;                  /* per-port overcurrent reporting */
+        temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */
        if (HCS_PPC (ehci->hcs_params))
-                temp |= 0x0001;         /* per-port power control */
+                temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */
        else
-                temp |= 0x0002;         /* no power switching */
+                temp |= HUB_CHAR_NO_LPSM; /* no power switching */
 #if 0
 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
        if (HCS_INDICATOR (ehci->hcs_params))
-                temp |= 0x0080;         /* per-port indicators (LEDs) */
+                temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */
 #endif
        desc->wHubCharacteristics = cpu_to_le16(temp);
 }
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 851006a0d97b..965202138161 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -42,6 +42,20 @@ static inline bool is_intel_quark_x1000(struct pci_dev *pdev)
                pdev->device == PCI_DEVICE_ID_INTEL_QUARK_X1000_SOC;
 }
+static const struct pci_device_id ci_hdrc_pci_id_table[] = {
+        { PCI_DEVICE(0x153F, 0x1004), },
+        { PCI_DEVICE(0x153F, 0x1006), },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0811), },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0829), },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0xe006), },
+        {}
+};
+static inline bool is_ci_hdrc_pci(struct pci_dev *pdev)
+{
+        return !!pci_match_id(ci_hdrc_pci_id_table, pdev);
+}
 /*
 * 0x84 is the offset of in/out threshold register,
 * and it is the same offset as the register of 'hostpc'.
@@ -352,6 +366,13 @@ static const struct ehci_driver_overrides pci_overrides __initconst = {
 /*-------------------------------------------------------------------------*/
+static int ehci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+        if (is_ci_hdrc_pci(pdev))
+                return -ENODEV;
+        return usb_hcd_pci_probe(pdev, id);
+}
 /* PCI driver selection metadata; PCI hotplugging uses this */
 static const struct pci_device_id pci_ids [] = { {
        /* handle any USB 2.0 EHCI controller */
@@ -370,7 +391,7 @@ static struct pci_driver ehci_pci_driver = {
        .name =         (char *) hcd_name,
        .id_table =     pci_ids,
-        .probe =        usb_hcd_pci_probe,
+        .probe =        ehci_pci_probe,
        .remove =       usb_hcd_pci_remove,
        .shutdown =     usb_hcd_pci_shutdown,
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index 8557803e6154..d8a75a51d6d4 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -43,7 +43,8 @@
 struct ehci_platform_priv {
        struct clk *clks[EHCI_MAX_CLKS];
        struct reset_control *rst;
-        struct phy *phy;
+        struct phy **phys;
+        int num_phys;
 };
 static const char hcd_name[] = "ehci-platform";
@@ -78,7 +79,7 @@ static int ehci_platform_power_on(struct platform_device *dev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(dev);
        struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
-        int clk, ret;
+        int clk, ret, phy_num;
        for (clk = 0; clk < EHCI_MAX_CLKS && priv->clks[clk]; clk++) {
                ret = clk_prepare_enable(priv->clks[clk]);
@@ -86,20 +87,28 @@ static int ehci_platform_power_on(struct platform_device *dev)
                        goto err_disable_clks;
        }
-        if (priv->phy) {
+        for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
-                ret = phy_init(priv->phy);
+                if (priv->phys[phy_num]) {
-                if (ret)
+                        ret = phy_init(priv->phys[phy_num]);
-                        goto err_disable_clks;
+                        if (ret)
+                                goto err_exit_phy;
-                ret = phy_power_on(priv->phy);
+                        ret = phy_power_on(priv->phys[phy_num]);
-                if (ret)
+                        if (ret) {
-                        goto err_exit_phy;
+                                phy_exit(priv->phys[phy_num]);
+                                goto err_exit_phy;
+                        }
+                }
        }
        return 0;
 err_exit_phy:
-        phy_exit(priv->phy);
+        while (--phy_num >= 0) {
+                if (priv->phys[phy_num]) {
+                        phy_power_off(priv->phys[phy_num]);
+                        phy_exit(priv->phys[phy_num]);
+                }
+        }
 err_disable_clks:
        while (--clk >= 0)
                clk_disable_unprepare(priv->clks[clk]);
@@ -111,11 +120,13 @@ static void ehci_platform_power_off(struct platform_device *dev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(dev);
        struct ehci_platform_priv *priv = hcd_to_ehci_priv(hcd);
-        int clk;
+        int clk, phy_num;
-        if (priv->phy) {
+        for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
-                phy_power_off(priv->phy);
+                if (priv->phys[phy_num]) {
-                phy_exit(priv->phy);
+                        phy_power_off(priv->phys[phy_num]);
+                        phy_exit(priv->phys[phy_num]);
+                }
        }
        for (clk = EHCI_MAX_CLKS - 1; clk >= 0; clk--)
@@ -143,7 +154,8 @@ static int ehci_platform_probe(struct platform_device *dev)
        struct usb_ehci_pdata *pdata = dev_get_platdata(&dev->dev);
        struct ehci_platform_priv *priv;
        struct ehci_hcd *ehci;
-        int err, irq, clk = 0;
+        const char *phy_name;
+        int err, irq, phy_num, clk = 0;
        if (usb_disabled())
                return -ENODEV;
@@ -155,7 +167,8 @@ static int ehci_platform_probe(struct platform_device *dev)
        if (!pdata)
                pdata = &ehci_platform_defaults;
-        err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
+        err = dma_coerce_mask_and_coherent(&dev->dev,
+                pdata->dma_mask_64 ? DMA_BIT_MASK(64) : DMA_BIT_MASK(32));
        if (err)
                return err;
@@ -185,12 +198,42 @@ static int ehci_platform_probe(struct platform_device *dev)
                if (of_property_read_bool(dev->dev.of_node, "big-endian"))
                        ehci->big_endian_mmio = ehci->big_endian_desc = 1;
-                priv->phy = devm_phy_get(&dev->dev, "usb");
+                if (of_property_read_bool(dev->dev.of_node,
-                if (IS_ERR(priv->phy)) {
+                                          "needs-reset-on-resume"))
-                        err = PTR_ERR(priv->phy);
+                        pdata->reset_on_resume = 1;
-                        if (err == -EPROBE_DEFER)
-                                goto err_put_hcd;
+                priv->num_phys = of_count_phandle_with_args(dev->dev.of_node,
-                        priv->phy = NULL;
+                                "phys", "#phy-cells");
+                priv->num_phys = priv->num_phys > 0 ? priv->num_phys : 1;
+                priv->phys = devm_kcalloc(&dev->dev, priv->num_phys,
+                                sizeof(struct phy *), GFP_KERNEL);
+                if (!priv->phys)
+                        return -ENOMEM;
+                for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
+                                err = of_property_read_string_index(
+                                                dev->dev.of_node,
+                                                "phy-names", phy_num,
+                                                &phy_name);
+                                if (err < 0) {
+                                        if (priv->num_phys > 1) {
+                                                dev_err(&dev->dev, "phy-names not provided");
+                                                goto err_put_hcd;
+                                        } else
+                                                phy_name = "usb";
+                                }
+                                priv->phys[phy_num] = devm_phy_get(&dev->dev,
+                                                phy_name);
+                                if (IS_ERR(priv->phys[phy_num])) {
+                                        err = PTR_ERR(priv->phys[phy_num]);
+                                        if ((priv->num_phys > 1) ||
+                                            (err == -EPROBE_DEFER))
+                                                goto err_put_hcd;
+                                        priv->phys[phy_num] = NULL;
+                                }
                }
                for (clk = 0; clk < EHCI_MAX_CLKS; clk++) {
@@ -340,7 +383,7 @@ static int ehci_platform_resume(struct device *dev)
                        return err;
        }
-        ehci_resume(hcd, false);
+        ehci_resume(hcd, pdata->reset_on_resume);
        return 0;
 }
 #endif /* CONFIG_PM_SLEEP */
@@ -349,6 +392,7 @@ static const struct of_device_id vt8500_ehci_ids[] = {
        { .compatible = "via,vt8500-ehci", },
        { .compatible = "wm,prizm-ehci", },
        { .compatible = "generic-ehci", },
+        { .compatible = "cavium,octeon-6335-ehci", },
        {}
 };
 MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
diff --git a/drivers/usb/host/ehci-pmcmsp.c b/drivers/usb/host/ehci-pmcmsp.c
index 7d75465d97c7..342816a7f8b1 100644
--- a/drivers/usb/host/ehci-pmcmsp.c
+++ b/drivers/usb/host/ehci-pmcmsp.c
@@ -325,6 +325,5 @@ static struct platform_driver ehci_hcd_msp_driver = {
        .remove         = ehci_hcd_msp_drv_remove,
        .driver         = {
                .name   = "pmcmsp-ehci",
-                .owner  = THIS_MODULE,
        },
 };
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 547924796d29..1a10c8d542ca 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -234,7 +234,6 @@ static struct platform_driver ehci_hcd_ppc_of_driver = {
        .shutdown       = usb_hcd_platform_shutdown,
        .driver = {
                .name = "ppc-of-ehci",
-                .owner = THIS_MODULE,
                .of_match_table = ehci_hcd_ppc_of_match,
        },
 };
diff --git a/drivers/usb/host/ehci-sead3.c b/drivers/usb/host/ehci-sead3.c
index 9b6e8d0eac43..3d86cc2ffe68 100644
--- a/drivers/usb/host/ehci-sead3.c
+++ b/drivers/usb/host/ehci-sead3.c
@@ -178,7 +178,6 @@ static struct platform_driver ehci_hcd_sead3_driver = {
        .shutdown       = usb_hcd_platform_shutdown,
        .driver = {
                .name   = "sead3-ehci",
-                .owner  = THIS_MODULE,
                .pm     = SEAD3_EHCI_PMOPS,
        }
 };
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index 0e0ce684aff3..5caf88d679e4 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -189,7 +189,6 @@ static struct platform_driver ehci_hcd_sh_driver = {
        .shutdown       = ehci_hcd_sh_shutdown,
        .driver         = {
                .name   = "sh_ehci",
-                .owner  = THIS_MODULE,
        },
 };
diff --git a/drivers/usb/host/ehci-tilegx.c b/drivers/usb/host/ehci-tilegx.c
index 0d247673c3ca..bdb93b6a356f 100644
--- a/drivers/usb/host/ehci-tilegx.c
+++ b/drivers/usb/host/ehci-tilegx.c
@@ -210,7 +210,6 @@ static struct platform_driver ehci_hcd_tilegx_driver = {
        .shutdown       = ehci_hcd_tilegx_drv_shutdown,
        .driver = {
                .name   = "tilegx-ehci",
-                .owner  = THIS_MODULE,
        }
 };
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index a2328361dc80..f54480850bb8 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -236,7 +236,6 @@ static struct platform_driver ehci_hcd_xilinx_of_driver = {
        .shutdown       = usb_hcd_platform_shutdown,
        .driver = {
                .name = "xilinx-of-ehci",
-                .owner = THIS_MODULE,
                .of_match_table = ehci_hcd_xilinx_of_match,
        },
 };
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index 6f0577b0a5ae..52ef0844a180 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -871,7 +871,7 @@ extern int	ehci_handshake(struct ehci_hcd *ehci, void __iomem *ptr,
 #ifdef CONFIG_PM
 extern int      ehci_suspend(struct usb_hcd *hcd, bool do_wakeup);
-extern int      ehci_resume(struct usb_hcd *hcd, bool hibernated);
+extern int      ehci_resume(struct usb_hcd *hcd, bool force_reset);
 #endif  /* CONFIG_PM */
 extern int      ehci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
diff --git a/drivers/usb/host/fhci-hub.c b/drivers/usb/host/fhci-hub.c
index 6af2512f8378..70116a65262c 100644
--- a/drivers/usb/host/fhci-hub.c
+++ b/drivers/usb/host/fhci-hub.c
@@ -32,8 +32,8 @@ static u8 root_hub_des[] = {
        0x09, /* blength */
        0x29, /* bDescriptorType;hub-descriptor */
        0x01, /* bNbrPorts */
-        0x00, /* wHubCharacteristics */
+        HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM, /* wHubCharacteristics */
-        0x00,
+        0x00, /* per-port power, no overcurrent */
        0x01, /* bPwrOn2pwrGood;2ms */
        0x00, /* bHubContrCurrent;0mA */
        0x00, /* DeviceRemoveable */
@@ -208,7 +208,6 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 {
        struct fhci_hcd *fhci = hcd_to_fhci(hcd);
        int retval = 0;
-        int len = 0;
        struct usb_hub_status *hub_status;
        struct usb_port_status *port_status;
        unsigned long flags;
@@ -272,8 +271,6 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                break;
        case GetHubDescriptor:
                memcpy(buf, root_hub_des, sizeof(root_hub_des));
-                buf[3] = 0x11; /* per-port power, no ovrcrnt */
-                len = (buf[0] < wLength) ? buf[0] : wLength;
                break;
        case GetHubStatus:
                hub_status = (struct usb_hub_status *)buf;
@@ -281,7 +278,6 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                    cpu_to_le16(fhci->vroot_hub->hub.wHubStatus);
                hub_status->wHubChange =
                    cpu_to_le16(fhci->vroot_hub->hub.wHubChange);
-                len = 4;
                break;
        case GetPortStatus:
                port_status = (struct usb_port_status *)buf;
@@ -289,7 +285,6 @@ int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                    cpu_to_le16(fhci->vroot_hub->port.wPortStatus);
                port_status->wPortChange =
                    cpu_to_le16(fhci->vroot_hub->port.wPortChange);
-                len = 4;
                break;
        case SetHubFeature:
                switch (wValue) {
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index ecf02b2623e8..475b21fd373b 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -1521,8 +1521,8 @@ fotg210_hub_descriptor(
        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
-        temp = 0x0008;          /* per-port overcurrent reporting */
+        temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */
-        temp |= 0x0002;         /* no power switching */
+        temp |= HUB_CHAR_NO_LPSM;       /* no power switching */
        desc->wHubCharacteristics = cpu_to_le16(temp);
 }
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index 664d2aa1239c..a83eefefffda 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -1479,8 +1479,8 @@ fusbh200_hub_descriptor (
        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
-        temp = 0x0008;          /* per-port overcurrent reporting */
+        temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */
-        temp |= 0x0002;         /* no power switching */
+        temp |= HUB_CHAR_NO_LPSM;       /* no power switching */
        desc->wHubCharacteristics = cpu_to_le16(temp);
 }
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index eb4efba9f1ad..6a2ad550b120 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -1482,9 +1482,8 @@ static int get_hub_descriptor(struct usb_hcd *hcd,
        desc->bDescLength = 9;
        desc->bPwrOn2PwrGood = 0;
        desc->wHubCharacteristics = (__force __u16) cpu_to_le16(
-                0x0002 |        /* No power switching */
+                HUB_CHAR_NO_LPSM |      /* No power switching */
-                0x0010 |        /* No over current protection */
+                HUB_CHAR_NO_OCPM);      /* No over current protection */
-                0);
        desc->u.hs.DeviceRemovable[0] = 1 << 1;
        desc->u.hs.DeviceRemovable[1] = ~0;
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 31c9c4d0fa0b..113d0cc6cc43 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -948,7 +948,10 @@ static void isp116x_hub_descriptor(struct isp116x *isp116x,
        desc->bHubContrCurrent = 0;
        desc->bNbrPorts = (u8) (reg & 0x3);
        /* Power switching, device type, overcurrent. */
-        desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) & 0x1f));
+        desc->wHubCharacteristics = cpu_to_le16((u16) ((reg >> 8) &
+                                                       (HUB_CHAR_LPSM |
+                                                        HUB_CHAR_COMPOUND |
+                                                        HUB_CHAR_OCPM)));
        desc->bPwrOn2PwrGood = (u8) ((reg >> 24) & 0xff);
        /* ports removable, and legacy PortPwrCtrlMask */
        desc->u.hs.DeviceRemovable[0] = 0;
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 75e5876f9d7c..b32ab60cad1e 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -1543,8 +1543,12 @@ static void isp1362_hub_descriptor(struct isp1362_hcd *isp1362_hcd,
        desc->bHubContrCurrent = 0;
        desc->bNbrPorts = reg & 0x3;
        /* Power switching, device type, overcurrent. */
-        desc->wHubCharacteristics = cpu_to_le16((reg >> 8) & 0x1f);
+        desc->wHubCharacteristics = cpu_to_le16((reg >> 8) &
-        DBG(0, "%s: hubcharacteristics = %02x\n", __func__, cpu_to_le16((reg >> 8) & 0x1f));
+                                                (HUB_CHAR_LPSM |
+                                                 HUB_CHAR_COMPOUND |
+                                                 HUB_CHAR_OCPM));
+        DBG(0, "%s: hubcharacteristics = %02x\n", __func__,
+                        desc->wHubCharacteristics);
        desc->bPwrOn2PwrGood = (reg >> 24) & 0xff;
        /* ports removable, and legacy PortPwrCtrlMask */
        desc->u.hs.DeviceRemovable[0] = desc->bNbrPorts == 1 ? 1 << 1 : 3 << 1;
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 395649f357aa..cecf39a220e7 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -1359,9 +1359,7 @@ static int isp1760_run(struct usb_hcd *hcd)
        if (retval)
                return retval;
-        init_timer(&errata2_timer);
+        setup_timer(&errata2_timer, errata2_function, (unsigned long)hcd);
-        errata2_timer.function = errata2_function;
-        errata2_timer.data = (unsigned long) hcd;
        errata2_timer.expires = jiffies + SLOT_CHECK_PERIOD * HZ / 1000;
        add_timer(&errata2_timer);
@@ -1798,13 +1796,13 @@ static void isp1760_hub_descriptor(struct isp1760_hcd *priv,
        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
        /* per-port overcurrent reporting */
-        temp = 0x0008;
+        temp = HUB_CHAR_INDV_PORT_OCPM;
        if (HCS_PPC(priv->hcs_params))
                /* per-port power control */
-                temp |= 0x0001;
+                temp |= HUB_CHAR_INDV_PORT_LPSM;
        else
                /* no power switching */
-                temp |= 0x0002;
+                temp |= HUB_CHAR_NO_LPSM;
        desc->wHubCharacteristics = cpu_to_le16(temp);
 }
@@ -2247,6 +2245,9 @@ struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
        hcd->rsrc_start = res_start;
        hcd->rsrc_len = res_len;
+        /* This driver doesn't support wakeup requests */
+        hcd->cant_recv_wakeups = 1;
        ret = usb_add_hcd(hcd, irq, irqflags);
        if (ret)
                goto err_unmap;
diff --git a/drivers/usb/host/max3421-hcd.c b/drivers/usb/host/max3421-hcd.c
index 6234c75da33f..a98833cbfcf3 100644
--- a/drivers/usb/host/max3421-hcd.c
+++ b/drivers/usb/host/max3421-hcd.c
@@ -55,6 +55,7 @@
 * single thread (max3421_spi_thread).
 */
+#include <linux/jiffies.h>
 #include <linux/module.h>
 #include <linux/spi/spi.h>
 #include <linux/usb.h>
@@ -1291,7 +1292,7 @@ max3421_handle_irqs(struct usb_hcd *hcd)
                char sbuf[16 * 16], *dp, *end;
                int i;
-                if (jiffies - last_time > 5*HZ) {
+                if (time_after(jiffies, last_time + 5*HZ)) {
                        dp = sbuf;
                        end = sbuf + sizeof(sbuf);
                        *dp = '\0';
@@ -1660,7 +1661,8 @@ hub_descriptor(struct usb_hub_descriptor *desc)
         */
        desc->bDescriptorType = 0x29;   /* hub descriptor */
        desc->bDescLength = 9;
-        desc->wHubCharacteristics = cpu_to_le16(0x0001);
+        desc->wHubCharacteristics = cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM |
+                                                HUB_CHAR_COMMON_OCPM);
        desc->bNbrPorts = 1;
 }
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index dc9e4e61f1c8..7cce85a1f7dc 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -33,7 +33,17 @@
                for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
 /* interface, function and usb clocks; sometimes also an AHB clock */
-static struct clk *iclk, *fclk, *uclk, *hclk;
+#define hcd_to_ohci_at91_priv(h) \
+        ((struct ohci_at91_priv *)hcd_to_ohci(h)->priv)
+struct ohci_at91_priv {
+        struct clk *iclk;
+        struct clk *fclk;
+        struct clk *uclk;
+        struct clk *hclk;
+        bool clocked;
+        bool wakeup;            /* Saved wake-up state for resume */
+};
 /* interface and function clocks; sometimes also an AHB clock */
 #define DRIVER_DESC "OHCI Atmel driver"
@@ -41,45 +51,53 @@ static struct clk *iclk, *fclk, *uclk, *hclk;
 static const char hcd_name[] = "ohci-atmel";
 static struct hc_driver __read_mostly ohci_at91_hc_driver;
-static int clocked;
+static const struct ohci_driver_overrides ohci_at91_drv_overrides __initconst = {
+        .extra_priv_size = sizeof(struct ohci_at91_priv),
+};
 extern int usb_disabled(void);
 /*-------------------------------------------------------------------------*/
-static void at91_start_clock(void)
+static void at91_start_clock(struct ohci_at91_priv *ohci_at91)
 {
+        if (ohci_at91->clocked)
+                return;
        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                clk_set_rate(uclk, 48000000);
+                clk_set_rate(ohci_at91->uclk, 48000000);
-                clk_prepare_enable(uclk);
+                clk_prepare_enable(ohci_at91->uclk);
        }
-        clk_prepare_enable(hclk);
+        clk_prepare_enable(ohci_at91->hclk);
-        clk_prepare_enable(iclk);
+        clk_prepare_enable(ohci_at91->iclk);
-        clk_prepare_enable(fclk);
+        clk_prepare_enable(ohci_at91->fclk);
-        clocked = 1;
+        ohci_at91->clocked = true;
 }
-static void at91_stop_clock(void)
+static void at91_stop_clock(struct ohci_at91_priv *ohci_at91)
 {
-        clk_disable_unprepare(fclk);
+        if (!ohci_at91->clocked)
-        clk_disable_unprepare(iclk);
+                return;
-        clk_disable_unprepare(hclk);
+        clk_disable_unprepare(ohci_at91->fclk);
+        clk_disable_unprepare(ohci_at91->iclk);
+        clk_disable_unprepare(ohci_at91->hclk);
        if (IS_ENABLED(CONFIG_COMMON_CLK))
-                clk_disable_unprepare(uclk);
+                clk_disable_unprepare(ohci_at91->uclk);
-        clocked = 0;
+        ohci_at91->clocked = false;
 }
 static void at91_start_hc(struct platform_device *pdev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(pdev);
        struct ohci_regs __iomem *regs = hcd->regs;
+        struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
        dev_dbg(&pdev->dev, "start\n");
        /*
         * Start the USB clocks.
         */
-        at91_start_clock();
+        at91_start_clock(ohci_at91);
        /*
         * The USB host controller must remain in reset.
@@ -91,6 +109,7 @@ static void at91_stop_hc(struct platform_device *pdev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(pdev);
        struct ohci_regs __iomem *regs = hcd->regs;
+        struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
        dev_dbg(&pdev->dev, "stop\n");
@@ -102,7 +121,7 @@ static void at91_stop_hc(struct platform_device *pdev)
        /*
         * Stop the USB clocks.
         */
-        at91_stop_clock();
+        at91_stop_clock(ohci_at91);
 }
@@ -128,7 +147,8 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
        struct at91_usbh_data *board;
        struct ohci_hcd *ohci;
        int retval;
-        struct usb_hcd *hcd = NULL;
+        struct usb_hcd *hcd;
+        struct ohci_at91_priv *ohci_at91;
        struct device *dev = &pdev->dev;
        struct resource *res;
        int irq;
@@ -142,6 +162,7 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
        hcd = usb_create_hcd(driver, dev, "at91");
        if (!hcd)
                return -ENOMEM;
+        ohci_at91 = hcd_to_ohci_at91_priv(hcd);
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        hcd->regs = devm_ioremap_resource(dev, res);
@@ -152,29 +173,29 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
        hcd->rsrc_start = res->start;
        hcd->rsrc_len = resource_size(res);
-        iclk = devm_clk_get(dev, "ohci_clk");
+        ohci_at91->iclk = devm_clk_get(dev, "ohci_clk");
-        if (IS_ERR(iclk)) {
+        if (IS_ERR(ohci_at91->iclk)) {
                dev_err(dev, "failed to get ohci_clk\n");
-                retval = PTR_ERR(iclk);
+                retval = PTR_ERR(ohci_at91->iclk);
                goto err;
        }
-        fclk = devm_clk_get(dev, "uhpck");
+        ohci_at91->fclk = devm_clk_get(dev, "uhpck");
-        if (IS_ERR(fclk)) {
+        if (IS_ERR(ohci_at91->fclk)) {
                dev_err(dev, "failed to get uhpck\n");
-                retval = PTR_ERR(fclk);
+                retval = PTR_ERR(ohci_at91->fclk);
                goto err;
        }
-        hclk = devm_clk_get(dev, "hclk");
+        ohci_at91->hclk = devm_clk_get(dev, "hclk");
-        if (IS_ERR(hclk)) {
+        if (IS_ERR(ohci_at91->hclk)) {
                dev_err(dev, "failed to get hclk\n");
-                retval = PTR_ERR(hclk);
+                retval = PTR_ERR(ohci_at91->hclk);
                goto err;
        }
        if (IS_ENABLED(CONFIG_COMMON_CLK)) {
-                uclk = devm_clk_get(dev, "usb_clk");
+                ohci_at91->uclk = devm_clk_get(dev, "usb_clk");
-                if (IS_ERR(uclk)) {
+                if (IS_ERR(ohci_at91->uclk)) {
                        dev_err(dev, "failed to get uclk\n");
-                        retval = PTR_ERR(uclk);
+                        retval = PTR_ERR(ohci_at91->uclk);
                        goto err;
                }
        }
@@ -347,11 +368,13 @@ static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 */
                desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
-                desc->wHubCharacteristics |= cpu_to_le16(0x0001);
+                desc->wHubCharacteristics |=
+                        cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM);
                if (pdata->overcurrent_supported) {
                        desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
-                        desc->wHubCharacteristics |=  cpu_to_le16(0x0008|0x0001);
+                        desc->wHubCharacteristics |=
+                                cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM);
                }
                dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
@@ -593,19 +616,27 @@ static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int
-ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
+ohci_hcd_at91_drv_suspend(struct device *dev)
 {
-        struct usb_hcd  *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd  *hcd = dev_get_drvdata(dev);
        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
-        bool            do_wakeup = device_may_wakeup(&pdev->dev);
+        struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
        int             ret;
-        if (do_wakeup)
+        /*
+         * Disable wakeup if we are going to sleep with slow clock mode
+         * enabled.
+         */
+        ohci_at91->wakeup = device_may_wakeup(dev)
+                        && !at91_suspend_entering_slow_clock();
+        if (ohci_at91->wakeup)
                enable_irq_wake(hcd->irq);
-        ret = ohci_suspend(hcd, do_wakeup);
+        ret = ohci_suspend(hcd, ohci_at91->wakeup);
        if (ret) {
-                disable_irq_wake(hcd->irq);
+                if (ohci_at91->wakeup)
+                        disable_irq_wake(hcd->irq);
                return ret;
        }
        /*
@@ -615,7 +646,7 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
         *
         * REVISIT: some boards will be able to turn VBUS off...
         */
-        if (at91_suspend_entering_slow_clock()) {
+        if (!ohci_at91->wakeup) {
                ohci->hc_control = ohci_readl(ohci, &ohci->regs->control);
                ohci->hc_control &= OHCI_CTRL_RWC;
                ohci_writel(ohci, ohci->hc_control, &ohci->regs->control);
@@ -623,38 +654,37 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
                /* flush the writes */
                (void) ohci_readl (ohci, &ohci->regs->control);
-                at91_stop_clock();
+                at91_stop_clock(ohci_at91);
        }
        return ret;
 }
-static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
+static int ohci_hcd_at91_drv_resume(struct device *dev)
 {
-        struct usb_hcd  *hcd = platform_get_drvdata(pdev);
+        struct usb_hcd  *hcd = dev_get_drvdata(dev);
+        struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd);
-        if (device_may_wakeup(&pdev->dev))
+        if (ohci_at91->wakeup)
                disable_irq_wake(hcd->irq);
-        if (!clocked)
+        at91_start_clock(ohci_at91);
-                at91_start_clock();
        ohci_resume(hcd, false);
        return 0;
 }
-#else
-#define ohci_hcd_at91_drv_suspend NULL
-#define ohci_hcd_at91_drv_resume  NULL
 #endif
+static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops, ohci_hcd_at91_drv_suspend,
+                                        ohci_hcd_at91_drv_resume);
 static struct platform_driver ohci_hcd_at91_driver = {
        .probe          = ohci_hcd_at91_drv_probe,
        .remove         = ohci_hcd_at91_drv_remove,
        .shutdown       = usb_hcd_platform_shutdown,
-        .suspend        = ohci_hcd_at91_drv_suspend,
-        .resume         = ohci_hcd_at91_drv_resume,
        .driver         = {
                .name   = "at91_ohci",
+                .pm     = &ohci_hcd_at91_pm_ops,
                .of_match_table = of_match_ptr(at91_ohci_dt_ids),
        },
 };
@@ -665,7 +695,7 @@ static int __init ohci_at91_init(void)
                return -ENODEV;
        pr_info("%s: " DRIVER_DESC "\n", hcd_name);
-        ohci_init_driver(&ohci_at91_hc_driver, NULL);
+        ohci_init_driver(&ohci_at91_hc_driver, &ohci_at91_drv_overrides);
        /*
         * The Atmel HW has some unusual quirks, which require Atmel-specific
diff --git a/drivers/usb/host/ohci-da8xx.c b/drivers/usb/host/ohci-da8xx.c
index 1c76999b2184..e5c33bc98ea4 100644
--- a/drivers/usb/host/ohci-da8xx.c
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -431,7 +431,6 @@ static struct platform_driver ohci_hcd_da8xx_driver = {
        .resume         = ohci_da8xx_resume,
 #endif
        .driver         = {
-                .owner  = THIS_MODULE,
                .name   = "ohci",
        },
 };
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 0aa17c937115..fe2aedd8a54d 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -544,15 +544,15 @@ ohci_hub_descriptor (
        temp = 1 + (ohci->num_ports / 8);
        desc->bDescLength = 7 + 2 * temp;
-        temp = 0;
+        temp = HUB_CHAR_COMMON_LPSM | HUB_CHAR_COMMON_OCPM;
        if (rh & RH_A_NPS)              /* no power switching? */
-            temp |= 0x0002;
+                temp |= HUB_CHAR_NO_LPSM;
        if (rh & RH_A_PSM)              /* per-port power switching? */
-            temp |= 0x0001;
+                temp |= HUB_CHAR_INDV_PORT_LPSM;
        if (rh & RH_A_NOCP)             /* no overcurrent reporting? */
-            temp |= 0x0010;
+                temp |= HUB_CHAR_NO_OCPM;
        else if (rh & RH_A_OCPM)        /* per-port overcurrent reporting? */
-            temp |= 0x0008;
+                temp |= HUB_CHAR_INDV_PORT_OCPM;
        desc->wHubCharacteristics = cpu_to_le16(temp);
        /* ports removable, and usb 1.0 legacy PortPwrCtrlMask */
diff --git a/drivers/usb/host/ohci-jz4740.c b/drivers/usb/host/ohci-jz4740.c
index 8ddd8f5470cb..4db78f169256 100644
--- a/drivers/usb/host/ohci-jz4740.c
+++ b/drivers/usb/host/ohci-jz4740.c
@@ -239,7 +239,6 @@ static struct platform_driver ohci_hcd_jz4740_driver = {
        .remove = jz4740_ohci_remove,
        .driver = {
                .name = "jz4740-ohci",
-                .owner = THIS_MODULE,
        },
 };
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index b81d202b15a2..185ceee52d47 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -38,7 +38,8 @@
 struct ohci_platform_priv {
        struct clk *clks[OHCI_MAX_CLKS];
        struct reset_control *rst;
-        struct phy *phy;
+        struct phy **phys;
+        int num_phys;
 };
 static const char hcd_name[] = "ohci-platform";
@@ -47,7 +48,7 @@ static int ohci_platform_power_on(struct platform_device *dev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(dev);
        struct ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
-        int clk, ret;
+        int clk, ret, phy_num;
        for (clk = 0; clk < OHCI_MAX_CLKS && priv->clks[clk]; clk++) {
                ret = clk_prepare_enable(priv->clks[clk]);
@@ -55,20 +56,28 @@ static int ohci_platform_power_on(struct platform_device *dev)
                        goto err_disable_clks;
        }
-        if (priv->phy) {
+        for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
-                ret = phy_init(priv->phy);
+                if (priv->phys[phy_num]) {
-                if (ret)
+                        ret = phy_init(priv->phys[phy_num]);
-                        goto err_disable_clks;
+                        if (ret)
+                                goto err_exit_phy;
-                ret = phy_power_on(priv->phy);
+                        ret = phy_power_on(priv->phys[phy_num]);
-                if (ret)
+                        if (ret) {
-                        goto err_exit_phy;
+                                phy_exit(priv->phys[phy_num]);
+                                goto err_exit_phy;
+                        }
+                }
        }
        return 0;
 err_exit_phy:
-        phy_exit(priv->phy);
+        while (--phy_num >= 0) {
+                if (priv->phys[phy_num]) {
+                        phy_power_off(priv->phys[phy_num]);
+                        phy_exit(priv->phys[phy_num]);
+                }
+        }
 err_disable_clks:
        while (--clk >= 0)
                clk_disable_unprepare(priv->clks[clk]);
@@ -80,11 +89,13 @@ static void ohci_platform_power_off(struct platform_device *dev)
 {
        struct usb_hcd *hcd = platform_get_drvdata(dev);
        struct ohci_platform_priv *priv = hcd_to_ohci_priv(hcd);
-        int clk;
+        int clk, phy_num;
-        if (priv->phy) {
+        for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
-                phy_power_off(priv->phy);
+                if (priv->phys[phy_num]) {
-                phy_exit(priv->phy);
+                        phy_power_off(priv->phys[phy_num]);
+                        phy_exit(priv->phys[phy_num]);
+                }
        }
        for (clk = OHCI_MAX_CLKS - 1; clk >= 0; clk--)
@@ -112,7 +123,8 @@ static int ohci_platform_probe(struct platform_device *dev)
        struct usb_ohci_pdata *pdata = dev_get_platdata(&dev->dev);
        struct ohci_platform_priv *priv;
        struct ohci_hcd *ohci;
-        int err, irq, clk = 0;
+        const char *phy_name;
+        int err, irq, phy_num, clk = 0;
        if (usb_disabled())
                return -ENODEV;
@@ -160,12 +172,38 @@ static int ohci_platform_probe(struct platform_device *dev)
                of_property_read_u32(dev->dev.of_node, "num-ports",
                                     &ohci->num_ports);
-                priv->phy = devm_phy_get(&dev->dev, "usb");
+                priv->num_phys = of_count_phandle_with_args(dev->dev.of_node,
-                if (IS_ERR(priv->phy)) {
+                                "phys", "#phy-cells");
-                        err = PTR_ERR(priv->phy);
+                priv->num_phys = priv->num_phys > 0 ? priv->num_phys : 1;
-                        if (err == -EPROBE_DEFER)
-                                goto err_put_hcd;
+                priv->phys = devm_kcalloc(&dev->dev, priv->num_phys,
-                        priv->phy = NULL;
+                                sizeof(struct phy *), GFP_KERNEL);
+                if (!priv->phys)
+                        return -ENOMEM;
+                for (phy_num = 0; phy_num < priv->num_phys; phy_num++) {
+                                err = of_property_read_string_index(
+                                                dev->dev.of_node,
+                                                "phy-names", phy_num,
+                                                &phy_name);
+                                if (err < 0) {
+                                        if (priv->num_phys > 1) {
+                                                dev_err(&dev->dev, "phy-names not provided");
+                                                goto err_put_hcd;
+                                        } else
+                                                phy_name = "usb";
+                                }
+                                priv->phys[phy_num] = devm_phy_get(&dev->dev,
+                                                phy_name);
+                                if (IS_ERR(priv->phys[phy_num])) {
+                                        err = PTR_ERR(priv->phys[phy_num]);
+                                        if ((priv->num_phys > 1) ||
+                                            (err == -EPROBE_DEFER))
+                                                goto err_put_hcd;
+                                        priv->phys[phy_num] = NULL;
+                                }
                }
                for (clk = 0; clk < OHCI_MAX_CLKS; clk++) {
@@ -328,6 +366,7 @@ static int ohci_platform_resume(struct device *dev)
 static const struct of_device_id ohci_platform_ids[] = {
        { .compatible = "generic-ohci", },
+        { .compatible = "cavium,octeon-6335-ohci", },
        { }
 };
 MODULE_DEVICE_TABLE(of, ohci_platform_ids);
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 965e3e9e688a..4f87a5c61b08 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -229,7 +229,6 @@ static struct platform_driver ohci_hcd_ppc_of_driver = {
        .shutdown       = usb_hcd_platform_shutdown,
        .driver = {
                .name = "ppc-of-ohci",
-                .owner = THIS_MODULE,
                .of_match_table = ohci_hcd_ppc_of_match,
        },
 };
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index 095113ea1fcb..7a1919ca543a 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -249,14 +249,14 @@ static int ohci_s3c2410_hub_control(
                 */
                desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
-                desc->wHubCharacteristics |= cpu_to_le16(0x0001);
+                desc->wHubCharacteristics |= cpu_to_le16(
+                        HUB_CHAR_INDV_PORT_LPSM);
                if (info->enable_oc) {
                        desc->wHubCharacteristics &= ~cpu_to_le16(
                                HUB_CHAR_OCPM);
                        desc->wHubCharacteristics |=  cpu_to_le16(
-                                0x0008 |
+                                HUB_CHAR_INDV_PORT_OCPM);
-                                0x0001);
                }
                dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 4e81c804c73e..a8b8d8b8d9f3 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -265,7 +265,6 @@ static struct platform_driver ohci_hcd_sm501_driver = {
        .suspend        = ohci_sm501_suspend,
        .resume         = ohci_sm501_resume,
        .driver         = {
-                .owner  = THIS_MODULE,
                .name   = "sm501-usb",
        },
 };
diff --git a/drivers/usb/host/ohci-tilegx.c b/drivers/usb/host/ohci-tilegx.c
index bef6dfb0405a..e1b208da460a 100644
--- a/drivers/usb/host/ohci-tilegx.c
+++ b/drivers/usb/host/ohci-tilegx.c
@@ -199,7 +199,6 @@ static struct platform_driver ohci_hcd_tilegx_driver = {
        .shutdown       = ohci_hcd_tilegx_drv_shutdown,
        .driver = {
                .name   = "tilegx-ohci",
-                .owner  = THIS_MODULE,
        }
 };
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index bb409588d39c..e9a6eec39142 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -368,6 +368,5 @@ static struct platform_driver ohci_hcd_tmio_driver = {
        .resume         = ohci_hcd_tmio_drv_resume,
        .driver         = {
                .name   = "tmio-ohci",
-                .owner  = THIS_MODULE,
        },
 };
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 036924e640f5..ef7efb278b15 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -457,11 +457,11 @@ static void ehci_hub_descriptor(struct oxu_hcd *oxu,
        memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
        memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
-        temp = 0x0008;                  /* per-port overcurrent reporting */
+        temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */
        if (HCS_PPC(oxu->hcs_params))
-                temp |= 0x0001;         /* per-port power control */
+                temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */
        else
-                temp |= 0x0002;         /* no power switching */
+                temp |= HUB_CHAR_NO_LPSM; /* no power switching */
        desc->wHubCharacteristics = (__force __u16)cpu_to_le16(temp);
 }
@@ -2598,9 +2598,7 @@ static int oxu_hcd_init(struct usb_hcd *hcd)
        spin_lock_init(&oxu->lock);
-        init_timer(&oxu->watchdog);
+        setup_timer(&oxu->watchdog, oxu_watchdog, (unsigned long)oxu);
-        oxu->watchdog.function = oxu_watchdog;
-        oxu->watchdog.data = (unsigned long) oxu;
        /*
         * hw default: 1K periodic list heads, one per frame.
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index ce636466edb7..f9400564cb72 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -603,9 +603,9 @@ static void quirk_usb_handoff_ohci(struct pci_dev *pdev)
                        msleep(10);
                }
                if (wait_time <= 0)
-                        dev_warn(&pdev->dev, "OHCI: BIOS handoff failed"
+                        dev_warn(&pdev->dev,
-                                        " (BIOS bug?) %08x\n",
+                                 "OHCI: BIOS handoff failed (BIOS bug?) %08x\n",
-                                        readl(base + OHCI_CONTROL));
+                                 readl(base + OHCI_CONTROL));
        }
 #endif
@@ -733,8 +733,9 @@ static void ehci_bios_handoff(struct pci_dev *pdev,
                 * and hope nothing goes too wrong
                 */
                if (try_handoff)
-                        dev_warn(&pdev->dev, "EHCI: BIOS handoff failed"
+                        dev_warn(&pdev->dev,
-                                 " (BIOS bug?) %08x\n", cap);
+                                 "EHCI: BIOS handoff failed (BIOS bug?) %08x\n",
+                                 cap);
                pci_write_config_byte(pdev, offset + 2, 0);
        }
@@ -781,8 +782,9 @@ static void quirk_usb_disable_ehci(struct pci_dev *pdev)
                case 0: /* Illegal reserved cap, set cap=0 so we exit */
                        cap = 0; /* then fallthrough... */
                default:
-                        dev_warn(&pdev->dev, "EHCI: unrecognized capability "
+                        dev_warn(&pdev->dev,
-                                 "%02x\n", cap & 0xff);
+                                 "EHCI: unrecognized capability %02x\n",
+                                 cap & 0xff);
                }
                offset = (cap >> 8) & 0xff;
        }
@@ -893,8 +895,7 @@ void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
         */
        if (!IS_ENABLED(CONFIG_USB_XHCI_HCD)) {
                dev_warn(&xhci_pdev->dev,
-                                "CONFIG_USB_XHCI_HCD is turned off, "
+                         "CONFIG_USB_XHCI_HCD is turned off, defaulting to EHCI.\n");
-                                "defaulting to EHCI.\n");
                dev_warn(&xhci_pdev->dev,
                                "USB 3.0 devices will work at USB 2.0 speeds.\n");
                usb_disable_xhci_ports(xhci_pdev);
@@ -919,8 +920,9 @@ void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
        pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
                        &ports_available);
-        dev_dbg(&xhci_pdev->dev, "USB 3.0 ports that are now enabled "
+        dev_dbg(&xhci_pdev->dev,
-                        "under xHCI: 0x%x\n", ports_available);
+                "USB 3.0 ports that are now enabled under xHCI: 0x%x\n",
+                ports_available);
        /* Read XUSB2PRM, xHCI USB 2.0 Port Routing Mask Register
         * Indicate the USB 2.0 ports to be controlled by the xHCI host.
@@ -941,8 +943,9 @@ void usb_enable_intel_xhci_ports(struct pci_dev *xhci_pdev)
        pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
                        &ports_available);
-        dev_dbg(&xhci_pdev->dev, "USB 2.0 ports that are now switched over "
+        dev_dbg(&xhci_pdev->dev,
-                        "to xHCI: 0x%x\n", ports_available);
+                "USB 2.0 ports that are now switched over to xHCI: 0x%x\n",
+                ports_available);
 }
 EXPORT_SYMBOL_GPL(usb_enable_intel_xhci_ports);
@@ -1010,8 +1013,9 @@ static void quirk_usb_handoff_xhci(struct pci_dev *pdev)
                /* Assume a buggy BIOS and take HC ownership anyway */
                if (timeout) {
-                        dev_warn(&pdev->dev, "xHCI BIOS handoff failed"
+                        dev_warn(&pdev->dev,
-                                        " (BIOS bug ?) %08x\n", val);
+                                 "xHCI BIOS handoff failed (BIOS bug ?) %08x\n",
+                                 val);
                        writel(val & ~XHCI_HC_BIOS_OWNED, base + ext_cap_offset);
                }
        }
@@ -1039,8 +1043,8 @@ hc_init:
        if (timeout) {
                val = readl(op_reg_base + XHCI_STS_OFFSET);
                dev_warn(&pdev->dev,
-                                "xHCI HW not ready after 5 sec (HC bug?) "
+                         "xHCI HW not ready after 5 sec (HC bug?) status = 0x%x\n",
-                                "status = 0x%x\n", val);
+                         val);
        }
        /* Send the halt and disable interrupts command */
@@ -1054,8 +1058,8 @@ hc_init:
        if (timeout) {
                val = readl(op_reg_base + XHCI_STS_OFFSET);
                dev_warn(&pdev->dev,
-                                "xHCI HW did not halt within %d usec "
+                         "xHCI HW did not halt within %d usec status = 0x%x\n",
-                                "status = 0x%x\n", XHCI_MAX_HALT_USEC, val);
+                         XHCI_MAX_HALT_USEC, val);
        }
        iounmap(base);
@@ -1075,8 +1079,8 @@ static void quirk_usb_early_handoff(struct pci_dev *pdev)
                return;
        if (pci_enable_device(pdev) < 0) {
-                dev_warn(&pdev->dev, "Can't enable PCI device, "
+                dev_warn(&pdev->dev,
-                                "BIOS handoff failed.\n");
+                         "Can't enable PCI device, BIOS handoff failed.\n");
                return;
        }
        if (pdev->class == PCI_CLASS_SERIAL_USB_UHCI)
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index c4bcfaedeec9..bdc82fea0a1f 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2141,7 +2141,8 @@ static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
        desc->bNbrPorts = r8a66597->max_root_hub;
        desc->bDescLength = 9;
        desc->bPwrOn2PwrGood = 0;
-        desc->wHubCharacteristics = cpu_to_le16(0x0011);
+        desc->wHubCharacteristics =
+                cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM);
        desc->u.hs.DeviceRemovable[0] =
                ((1 << r8a66597->max_root_hub) - 1) << 1;
        desc->u.hs.DeviceRemovable[1] = ~0;
@@ -2483,9 +2484,8 @@ static int r8a66597_probe(struct platform_device *pdev)
                r8a66597->max_root_hub = 2;
        spin_lock_init(&r8a66597->lock);
-        init_timer(&r8a66597->rh_timer);
+        setup_timer(&r8a66597->rh_timer, r8a66597_timer,
-        r8a66597->rh_timer.function = r8a66597_timer;
+                    (unsigned long)r8a66597);
-        r8a66597->rh_timer.data = (unsigned long)r8a66597;
        r8a66597->reg = reg;
        /* make sure no interrupts are pending */
@@ -2496,9 +2496,8 @@ static int r8a66597_probe(struct platform_device *pdev)
        for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
                INIT_LIST_HEAD(&r8a66597->pipe_queue[i]);
-                init_timer(&r8a66597->td_timer[i]);
+                setup_timer(&r8a66597->td_timer[i], r8a66597_td_timer,
-                r8a66597->td_timer[i].function = r8a66597_td_timer;
+                            (unsigned long)r8a66597);
-                r8a66597->td_timer[i].data = (unsigned long)r8a66597;
                setup_timer(&r8a66597->interval_timer[i],
                                r8a66597_interval_timer,
                                (unsigned long)r8a66597);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 25fb1da8d3d7..4f4ba1ea9e9b 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1103,12 +1103,12 @@ sl811h_hub_descriptor (
                desc->bPwrOn2PwrGood = sl811->board->potpg;
                if (!desc->bPwrOn2PwrGood)
                        desc->bPwrOn2PwrGood = 10;
-                temp = 0x0001;
+                temp = HUB_CHAR_INDV_PORT_LPSM;
        } else
-                temp = 0x0002;
+                temp = HUB_CHAR_NO_LPSM;
        /* no overcurrent errors detection/handling */
-        temp |= 0x0010;
+        temp |= HUB_CHAR_NO_OCPM;
        desc->wHubCharacteristics = cpu_to_le16(temp);
@@ -1691,9 +1691,7 @@ sl811h_probe(struct platform_device *dev)
        spin_lock_init(&sl811->lock);
        INIT_LIST_HEAD(&sl811->async);
        sl811->board = dev_get_platdata(&dev->dev);
-        init_timer(&sl811->timer);
+        setup_timer(&sl811->timer, sl811h_timer, (unsigned long)sl811);
-        sl811->timer.function = sl811h_timer;
-        sl811->timer.data = (unsigned long) sl811;
        sl811->addr_reg = addr_reg;
        sl811->data_reg = data_reg;
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index 2894e54e5b9c..ad97e8a1ad1c 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -2590,15 +2590,15 @@ static int u132_roothub_descriptor(struct u132 *u132,
        desc->bNbrPorts = u132->num_ports;
        temp = 1 + (u132->num_ports / 8);
        desc->bDescLength = 7 + 2 * temp;
-        temp = 0;
+        temp = HUB_CHAR_COMMON_LPSM | HUB_CHAR_COMMON_OCPM;
        if (rh_a & RH_A_NPS)
-                temp |= 0x0002;
+                temp |= HUB_CHAR_NO_LPSM;
        if (rh_a & RH_A_PSM)
-                temp |= 0x0001;
+                temp |= HUB_CHAR_INDV_PORT_LPSM;
        if (rh_a & RH_A_NOCP)
-                temp |= 0x0010;
+                temp |= HUB_CHAR_NO_OCPM;
        else if (rh_a & RH_A_OCPM)
-                temp |= 0x0008;
+                temp |= HUB_CHAR_INDV_PORT_OCPM;
        desc->wHubCharacteristics = cpu_to_le16(temp);
        retval = u132_read_pcimem(u132, roothub.b, &rh_b);
        if (retval)
diff --git a/drivers/usb/host/uhci-grlib.c b/drivers/usb/host/uhci-grlib.c
index 05f57ffdf9ab..0342991c9507 100644
--- a/drivers/usb/host/uhci-grlib.c
+++ b/drivers/usb/host/uhci-grlib.c
@@ -188,7 +188,6 @@ static struct platform_driver uhci_grlib_driver = {
        .shutdown       = uhci_hcd_grlib_shutdown,
        .driver = {
                .name = "grlib-uhci",
-                .owner = THIS_MODULE,
                .of_match_table = uhci_hcd_grlib_of_match,
        },
 };
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
index cf8f46003f62..3a3e3eeba291 100644
--- a/drivers/usb/host/uhci-platform.c
+++ b/drivers/usb/host/uhci-platform.c
@@ -147,7 +147,6 @@ static struct platform_driver uhci_platform_driver = {
        .shutdown       = uhci_hcd_platform_shutdown,
        .driver = {
                .name = "platform-uhci",
-                .owner = THIS_MODULE,
                .of_match_table = platform_uhci_ids,
        },
 };
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index bb89175ca6e5..745717ec9c89 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -552,7 +552,7 @@ void xhci_dbg_ctx(struct xhci_hcd *xhci,
        if (ctx->type == XHCI_CTX_TYPE_INPUT) {
                struct xhci_input_control_ctx *ctrl_ctx =
-                        xhci_get_input_control_ctx(xhci, ctx);
+                        xhci_get_input_control_ctx(ctx);
                if (!ctrl_ctx) {
                        xhci_warn(xhci, "Could not get input context, bad type.\n");
                        return;
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 5cb3d7a10017..f8336408ef07 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -535,7 +535,7 @@ static void xhci_free_container_ctx(struct xhci_hcd *xhci,
        kfree(ctx);
 }
-struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci,
+struct xhci_input_control_ctx *xhci_get_input_control_ctx(
                                              struct xhci_container_ctx *ctx)
 {
        if (ctx->type != XHCI_CTX_TYPE_INPUT)
@@ -784,8 +784,7 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
 * Reinstalls the "normal" endpoint ring (at its previous dequeue mark,
 * not at the beginning of the ring).
 */
-void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
+void xhci_setup_no_streams_ep_input_ctx(struct xhci_ep_ctx *ep_ctx,
-                struct xhci_ep_ctx *ep_ctx,
                struct xhci_virt_ep *ep)
 {
        dma_addr_t addr;
@@ -833,9 +832,8 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
 static void xhci_init_endpoint_timer(struct xhci_hcd *xhci,
                struct xhci_virt_ep *ep)
 {
-        init_timer(&ep->stop_cmd_timer);
+        setup_timer(&ep->stop_cmd_timer, xhci_stop_endpoint_command_watchdog,
-        ep->stop_cmd_timer.data = (unsigned long) ep;
+                    (unsigned long)ep);
-        ep->stop_cmd_timer.function = xhci_stop_endpoint_command_watchdog;
        ep->xhci = xhci;
 }
@@ -1342,8 +1340,7 @@ static u32 xhci_get_endpoint_mult(struct usb_device *udev,
        return ep->ss_ep_comp.bmAttributes;
 }
-static u32 xhci_get_endpoint_type(struct usb_device *udev,
+static u32 xhci_get_endpoint_type(struct usb_host_endpoint *ep)
-                struct usb_host_endpoint *ep)
 {
        int in;
        u32 type;
@@ -1376,8 +1373,7 @@ static u32 xhci_get_endpoint_type(struct usb_device *udev,
 * Basically, this is the maxpacket size, multiplied by the burst size
 * and mult size.
 */
-static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci,
+static u32 xhci_get_max_esit_payload(struct usb_device *udev,
-                struct usb_device *udev,
                struct usb_host_endpoint *ep)
 {
        int max_burst;
@@ -1418,7 +1414,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
        ep_index = xhci_get_endpoint_index(&ep->desc);
        ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
-        endpoint_type = xhci_get_endpoint_type(udev, ep);
+        endpoint_type = xhci_get_endpoint_type(ep);
        if (!endpoint_type)
                return -EINVAL;
        ep_ctx->ep_info2 = cpu_to_le32(endpoint_type);
@@ -1484,7 +1480,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
        }
        ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet) |
                        MAX_BURST(max_burst));
-        max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep);
+        max_esit_payload = xhci_get_max_esit_payload(udev, ep);
        ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload));
        /*
@@ -1773,7 +1769,7 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
        return command;
 }
-void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv)
+void xhci_urb_free_priv(struct urb_priv *urb_priv)
 {
        if (urb_priv) {
                kfree(urb_priv->td[0]);
@@ -1926,7 +1922,7 @@ static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
 }
 /* TRB math checks for xhci_trb_in_td(), using the command and event rings. */
-static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags)
+static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci)
 {
        struct {
                dma_addr_t              input_dma;
@@ -2452,7 +2448,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                                                flags);
        if (!xhci->event_ring)
                goto fail;
-        if (xhci_check_trb_in_td_math(xhci, flags) < 0)
+        if (xhci_check_trb_in_td_math(xhci) < 0)
                goto fail;
        xhci->erst.entries = dma_alloc_coherent(dev,
@@ -2509,9 +2505,8 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
        xhci_print_ir_set(xhci, 0);
        /* init command timeout timer */
-        init_timer(&xhci->cmd_timer);
+        setup_timer(&xhci->cmd_timer, xhci_handle_command_timeout,
-        xhci->cmd_timer.data = (unsigned long) xhci;
+                    (unsigned long)xhci);
-        xhci->cmd_timer.function = xhci_handle_command_timeout;
        /*
         * XXX: Might need to set the Interrupter Moderation Register to
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index e692e769c50c..88da8d629820 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -299,7 +299,7 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
         * seconds), then it should assume that the there are
         * larger problems with the xHC and assert HCRST.
         */
-        ret = xhci_handshake(xhci, &xhci->op_regs->cmd_ring,
+        ret = xhci_handshake(&xhci->op_regs->cmd_ring,
                        CMD_RING_RUNNING, 0, 5 * 1000 * 1000);
        if (ret < 0) {
                xhci_err(xhci, "Stopped the command ring failed, "
@@ -609,7 +609,7 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
                spin_unlock(&xhci->lock);
                usb_hcd_giveback_urb(hcd, urb, status);
-                xhci_urb_free_priv(xhci, urb_priv);
+                xhci_urb_free_priv(urb_priv);
                spin_lock(&xhci->lock);
        }
 }
@@ -1110,7 +1110,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
         * 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);
+        ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "Could not get input context, bad type.\n");
                return;
@@ -2354,8 +2354,8 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                        status = 0;
                        break;
                }
-                xhci_warn(xhci, "ERROR Unknown event condition, HC probably "
+                xhci_warn(xhci, "ERROR Unknown event condition %u, HC probably busted\n",
-                                "busted\n");
+                          trb_comp_code);
                goto cleanup;
        }
@@ -2497,7 +2497,7 @@ cleanup:
                        urb = td->urb;
                        urb_priv = urb->hcpriv;
-                        xhci_urb_free_priv(xhci, urb_priv);
+                        xhci_urb_free_priv(urb_priv);
                        usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
                        if ((urb->actual_length != urb->transfer_buffer_length &&
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index c50d8d202618..ec8ac1674854 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -60,8 +60,7 @@ MODULE_PARM_DESC(quirks, "Bit flags for quirks to be enabled as default");
 * handshake done).  There are two failure modes:  "usec" have passed (major
 * hardware flakeout), or the register reads as all-ones (hardware removed).
 */
-int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
+int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, int usec)
-                      u32 mask, u32 done, int usec)
 {
        u32     result;
@@ -111,7 +110,7 @@ int xhci_halt(struct xhci_hcd *xhci)
        xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Halt the HC");
        xhci_quiesce(xhci);
-        ret = xhci_handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(&xhci->op_regs->status,
                        STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
        if (!ret) {
                xhci->xhc_state |= XHCI_STATE_HALTED;
@@ -140,7 +139,7 @@ static int xhci_start(struct xhci_hcd *xhci)
         * Wait for the HCHalted Status bit to be 0 to indicate the host is
         * running.
         */
-        ret = xhci_handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(&xhci->op_regs->status,
                        STS_HALT, 0, XHCI_MAX_HALT_USEC);
        if (ret == -ETIMEDOUT)
                xhci_err(xhci, "Host took too long to start, "
@@ -175,7 +174,7 @@ int xhci_reset(struct xhci_hcd *xhci)
        command |= CMD_RESET;
        writel(command, &xhci->op_regs->command);
-        ret = xhci_handshake(xhci, &xhci->op_regs->command,
+        ret = xhci_handshake(&xhci->op_regs->command,
                        CMD_RESET, 0, 10 * 1000 * 1000);
        if (ret)
                return ret;
@@ -186,7 +185,7 @@ int xhci_reset(struct xhci_hcd *xhci)
         * xHCI cannot write to any doorbells or operational registers other
         * than status until the "Controller Not Ready" flag is cleared.
         */
-        ret = xhci_handshake(xhci, &xhci->op_regs->status,
+        ret = xhci_handshake(&xhci->op_regs->status,
                        STS_CNR, 0, 10 * 1000 * 1000);
        for (i = 0; i < 2; ++i) {
@@ -473,10 +472,8 @@ static void compliance_mode_recovery(unsigned long arg)
 static void compliance_mode_recovery_timer_init(struct xhci_hcd *xhci)
 {
        xhci->port_status_u0 = 0;
-        init_timer(&xhci->comp_mode_recovery_timer);
+        setup_timer(&xhci->comp_mode_recovery_timer,
+                    compliance_mode_recovery, (unsigned long)xhci);
-        xhci->comp_mode_recovery_timer.data = (unsigned long) xhci;
-        xhci->comp_mode_recovery_timer.function = compliance_mode_recovery;
        xhci->comp_mode_recovery_timer.expires = jiffies +
                        msecs_to_jiffies(COMP_MODE_RCVRY_MSECS);
@@ -929,7 +926,7 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup)
        /* Some chips from Fresco Logic need an extraordinary delay */
        delay *= (xhci->quirks & XHCI_SLOW_SUSPEND) ? 10 : 1;
-        if (xhci_handshake(xhci, &xhci->op_regs->status,
+        if (xhci_handshake(&xhci->op_regs->status,
                      STS_HALT, STS_HALT, delay)) {
                xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n");
                spin_unlock_irq(&xhci->lock);
@@ -944,7 +941,7 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup)
        command = readl(&xhci->op_regs->command);
        command |= CMD_CSS;
        writel(command, &xhci->op_regs->command);
-        if (xhci_handshake(xhci, &xhci->op_regs->status,
+        if (xhci_handshake(&xhci->op_regs->status,
                                STS_SAVE, 0, 10 * 1000)) {
                xhci_warn(xhci, "WARN: xHC save state timeout\n");
                spin_unlock_irq(&xhci->lock);
@@ -1011,7 +1008,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                command = readl(&xhci->op_regs->command);
                command |= CMD_CRS;
                writel(command, &xhci->op_regs->command);
-                if (xhci_handshake(xhci, &xhci->op_regs->status,
+                if (xhci_handshake(&xhci->op_regs->status,
                              STS_RESTORE, 0, 10 * 1000)) {
                        xhci_warn(xhci, "WARN: xHC restore state timeout\n");
                        spin_unlock_irq(&xhci->lock);
@@ -1082,7 +1079,7 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
        command = readl(&xhci->op_regs->command);
        command |= CMD_RUN;
        writel(command, &xhci->op_regs->command);
-        xhci_handshake(xhci, &xhci->op_regs->status, STS_HALT,
+        xhci_handshake(&xhci->op_regs->status, STS_HALT,
                  0, 250 * 1000);
        /* step 5: walk topology and initialize portsc,
@@ -1276,7 +1273,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
                        return -ENOMEM;
                command->in_ctx = xhci->devs[slot_id]->in_ctx;
-                ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
+                ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
                if (!ctrl_ctx) {
                        xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                        __func__);
@@ -1374,7 +1371,7 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
                        ret = xhci_check_maxpacket(xhci, slot_id,
                                        ep_index, urb);
                        if (ret < 0) {
-                                xhci_urb_free_priv(xhci, urb_priv);
+                                xhci_urb_free_priv(urb_priv);
                                urb->hcpriv = NULL;
                                return ret;
                        }
@@ -1440,7 +1437,7 @@ dying:
                        urb->ep->desc.bEndpointAddress, urb);
        ret = -ESHUTDOWN;
 free_priv:
-        xhci_urb_free_priv(xhci, urb_priv);
+        xhci_urb_free_priv(urb_priv);
        urb->hcpriv = NULL;
        spin_unlock_irqrestore(&xhci->lock, flags);
        return ret;
@@ -1553,7 +1550,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
                usb_hcd_unlink_urb_from_ep(hcd, urb);
                spin_unlock_irqrestore(&xhci->lock, flags);
                usb_hcd_giveback_urb(hcd, urb, -ESHUTDOWN);
-                xhci_urb_free_priv(xhci, urb_priv);
+                xhci_urb_free_priv(urb_priv);
                return ret;
        }
        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
@@ -1660,7 +1657,7 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
        in_ctx = xhci->devs[udev->slot_id]->in_ctx;
        out_ctx = xhci->devs[udev->slot_id]->out_ctx;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -1676,8 +1673,10 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
             cpu_to_le32(EP_STATE_DISABLED)) ||
            le32_to_cpu(ctrl_ctx->drop_flags) &
            xhci_get_endpoint_flag(&ep->desc)) {
-                xhci_warn(xhci, "xHCI %s called with disabled ep %p\n",
+                /* Do not warn when called after a usb_device_reset */
-                                __func__, ep);
+                if (xhci->devs[udev->slot_id]->eps[ep_index].ring != NULL)
+                        xhci_warn(xhci, "xHCI %s called with disabled ep %p\n",
+                                  __func__, ep);
                return 0;
        }
@@ -1714,7 +1713,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
                struct usb_host_endpoint *ep)
 {
        struct xhci_hcd *xhci;
-        struct xhci_container_ctx *in_ctx, *out_ctx;
+        struct xhci_container_ctx *in_ctx;
        unsigned int ep_index;
        struct xhci_input_control_ctx *ctrl_ctx;
        u32 added_ctxs;
@@ -1745,8 +1744,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
        virt_dev = xhci->devs[udev->slot_id];
        in_ctx = virt_dev->in_ctx;
-        out_ctx = virt_dev->out_ctx;
+        ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -1758,8 +1756,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         * to add it again without dropping it, reject the addition.
         */
        if (virt_dev->eps[ep_index].ring &&
-                        !(le32_to_cpu(ctrl_ctx->drop_flags) &
+                        !(le32_to_cpu(ctrl_ctx->drop_flags) & added_ctxs)) {
-                                xhci_get_endpoint_flag(&ep->desc))) {
                xhci_warn(xhci, "Trying to add endpoint 0x%x "
                                "without dropping it.\n",
                                (unsigned int) ep->desc.bEndpointAddress);
@@ -1769,8 +1766,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
        /* If the HCD has already noted the endpoint is enabled,
         * ignore this request.
         */
-        if (le32_to_cpu(ctrl_ctx->add_flags) &
+        if (le32_to_cpu(ctrl_ctx->add_flags) & added_ctxs) {
-            xhci_get_endpoint_flag(&ep->desc)) {
                xhci_warn(xhci, "xHCI %s called with enabled ep %p\n",
                                __func__, ep);
                return 0;
@@ -1816,7 +1812,7 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
        struct xhci_slot_ctx *slot_ctx;
        int i;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -2542,7 +2538,7 @@ static int xhci_reserve_bandwidth(struct xhci_hcd *xhci,
        if (virt_dev->tt_info)
                old_active_eps = virt_dev->tt_info->active_eps;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -2639,7 +2635,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
        spin_lock_irqsave(&xhci->lock, flags);
        virt_dev = xhci->devs[udev->slot_id];
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
        if (!ctrl_ctx) {
                spin_unlock_irqrestore(&xhci->lock, flags);
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@@ -2758,7 +2754,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
        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, command->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -2883,7 +2879,7 @@ static void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
        dma_addr_t addr;
        in_ctx = xhci->devs[slot_id]->in_ctx;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -3173,7 +3169,7 @@ int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
                xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
                return -ENOMEM;
        }
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(config_cmd->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -3328,7 +3324,7 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
         */
        ep_index = xhci_get_endpoint_index(&eps[0]->desc);
        command = vdev->eps[ep_index].stream_info->free_streams_command;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
        if (!ctrl_ctx) {
                spin_unlock_irqrestore(&xhci->lock, flags);
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@@ -3346,7 +3342,7 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
                xhci_endpoint_copy(xhci, command->in_ctx,
                                vdev->out_ctx, ep_index);
-                xhci_setup_no_streams_ep_input_ctx(xhci, ep_ctx,
+                xhci_setup_no_streams_ep_input_ctx(ep_ctx,
                                &vdev->eps[ep_index]);
        }
        xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx,
@@ -3820,7 +3816,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
        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);
+        ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -4003,7 +3999,7 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
        /* Attempt to issue an Evaluate Context command to change the MEL. */
        command = xhci->lpm_command;
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
        if (!ctrl_ctx) {
                spin_unlock_irqrestore(&xhci->lock, flags);
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@@ -4741,7 +4737,7 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
                xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
                return -ENOMEM;
        }
-        ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx);
+        ctrl_ctx = xhci_get_input_control_ctx(config_cmd->in_ctx);
        if (!ctrl_ctx) {
                xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
                                __func__);
@@ -4910,6 +4906,10 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
        if (retval)
                goto error;
        xhci_dbg(xhci, "Called HCD init\n");
+        xhci_info(xhci, "hcc params 0x%08x hci version 0x%x quirks 0x%08x\n",
+                  xhci->hcc_params, xhci->hci_version, xhci->quirks);
        return 0;
 error:
        kfree(xhci);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index cc7c5bb7cbcf..974514762a14 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1605,6 +1605,8 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
        dev_warn(xhci_to_hcd(xhci)->self.controller , fmt , ## args)
 #define xhci_warn_ratelimited(xhci, fmt, args...) \
        dev_warn_ratelimited(xhci_to_hcd(xhci)->self.controller , fmt , ## args)
+#define xhci_info(xhci, fmt, args...) \
+        dev_info(xhci_to_hcd(xhci)->self.controller , fmt , ## args)
 /*
 * Registers should always be accessed with double word or quad word accesses.
@@ -1712,8 +1714,7 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
 void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
                struct xhci_ep_ctx *ep_ctx,
                struct xhci_stream_info *stream_info);
-void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
+void xhci_setup_no_streams_ep_input_ctx(struct xhci_ep_ctx *ep_ctx,
-                struct xhci_ep_ctx *ep_ctx,
                struct xhci_virt_ep *ep);
 void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
        struct xhci_virt_device *virt_dev, bool drop_control_ep);
@@ -1727,14 +1728,13 @@ struct xhci_ring *xhci_stream_id_to_ring(
 struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
                bool allocate_in_ctx, bool allocate_completion,
                gfp_t mem_flags);
-void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv);
+void xhci_urb_free_priv(struct urb_priv *urb_priv);
 void xhci_free_command(struct xhci_hcd *xhci,
                struct xhci_command *command);
 /* xHCI host controller glue */
 typedef void (*xhci_get_quirks_t)(struct device *, struct xhci_hcd *);
-int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
+int xhci_handshake(void __iomem *ptr, u32 mask, u32 done, int usec);
-                u32 mask, u32 done, int usec);
 void xhci_quiesce(struct xhci_hcd *xhci);
 int xhci_halt(struct xhci_hcd *xhci);
 int xhci_reset(struct xhci_hcd *xhci);
@@ -1864,7 +1864,7 @@ int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
 void xhci_ring_device(struct xhci_hcd *xhci, int slot_id);
 /* xHCI contexts */
-struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
+struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_container_ctx *ctx);
 struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
 struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int ep_index);
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index 37b44b04a701..6431d08c8d9d 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -299,9 +299,7 @@ static inline void mts_show_command(struct scsi_cmnd *srb)
        MTS_DEBUG( "Command %s (%d bytes)\n", what, srb->cmd_len);
 out:
-        MTS_DEBUG( "  %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+        MTS_DEBUG( "  %10ph\n", srb->cmnd);
-               srb->cmnd[0], srb->cmnd[1], srb->cmnd[2], srb->cmnd[3], srb->cmnd[4], srb->cmnd[5],
-               srb->cmnd[6], srb->cmnd[7], srb->cmnd[8], srb->cmnd[9]);
 }
 #else
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 40ef40affe83..588d62a73e1a 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -124,12 +124,8 @@ static void async_complete(struct urb *urb)
        } else if (rq->dr->bRequest == 3) {
                memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 #if 0
-                dev_dbg(&priv->usbdev->dev,
+                dev_dbg(&priv->usbdev->dev, "async_complete regs %7ph\n",
-                        "async_complete regs %02x %02x %02x %02x %02x %02x %02x\n",
+                        priv->reg);
-                        (unsigned int)priv->reg[0], (unsigned int)priv->reg[1],
-                        (unsigned int)priv->reg[2], (unsigned int)priv->reg[3],
-                        (unsigned int)priv->reg[4], (unsigned int)priv->reg[5],
-                        (unsigned int)priv->reg[6]);
 #endif
                /* if nAck interrupts are enabled and we have an interrupt, call the interrupt procedure */
                if (rq->reg[2] & rq->reg[1] & 0x10 && pp)
@@ -742,9 +738,7 @@ static int uss720_probe(struct usb_interface *intf,
        set_1284_register(pp, 2, 0x0c, GFP_KERNEL);
        /* debugging */
        get_1284_register(pp, 0, &reg, GFP_KERNEL);
-        dev_dbg(&intf->dev, "reg: %02x %02x %02x %02x %02x %02x %02x\n",
+        dev_dbg(&intf->dev, "reg: %7ph\n", priv->reg);
-                priv->reg[0], priv->reg[1], priv->reg[2], priv->reg[3],
-                priv->reg[4], priv->reg[5], priv->reg[6]);
        endpoint = &interface->endpoint[2];
        dev_dbg(&intf->dev, "epaddr %d interval %d\n",
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index b072420e44f5..b79e5be7aa97 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -349,9 +349,10 @@ int musb_hub_control(
                desc->bDescriptorType = 0x29;
                desc->bNbrPorts = 1;
                desc->wHubCharacteristics = cpu_to_le16(
-                                  0x0001        /* per-port power switching */
+                          HUB_CHAR_INDV_PORT_LPSM /* per-port power switching */
-                                | 0x0010        /* no overcurrent reporting */
-                                );
+                        | HUB_CHAR_NO_OCPM      /* no overcurrent reporting */
+                        );
                desc->bPwrOn2PwrGood = 5;       /* msec/2 */
                desc->bHubContrCurrent = 0;
diff --git a/drivers/usb/renesas_usbhs/mod_host.c b/drivers/usb/renesas_usbhs/mod_host.c
index f0d323125871..96eead619282 100644
--- a/drivers/usb/renesas_usbhs/mod_host.c
+++ b/drivers/usb/renesas_usbhs/mod_host.c
@@ -1234,7 +1234,8 @@ static int __usbhsh_hub_get_status(struct usbhsh_hpriv *hpriv,
                desc->bNbrPorts                 = roothub_id;
                desc->bDescLength               = 9;
                desc->bPwrOn2PwrGood            = 0;
-                desc->wHubCharacteristics       = cpu_to_le16(0x0011);
+                desc->wHubCharacteristics       =
+                        cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM);
                desc->u.hs.DeviceRemovable[0]   = (roothub_id << 1);
                desc->u.hs.DeviceRemovable[1]   = ~0;
                dev_dbg(dev, "%s :: GetHubDescriptor\n", __func__);
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index f4c56fc1a9f6..f40c856ff758 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -56,6 +56,7 @@ static const struct usb_device_id id_table[] = {
        { USB_DEVICE(0x0846, 0x1100) }, /* NetGear Managed Switch M4100 series, M5300 series, M7100 series */
        { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
        { USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
+        { USB_DEVICE(0x0908, 0x01FF) }, /* Siemens RUGGEDCOM USB Serial Console */
        { USB_DEVICE(0x0BED, 0x1100) }, /* MEI (TM) Cashflow-SC Bill/Voucher Acceptor */
        { USB_DEVICE(0x0BED, 0x1101) }, /* MEI series 2000 Combo Acceptor */
        { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 220b4be89641..e4473a9109cf 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -1309,35 +1309,6 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
        const unsigned char *current_position = data;
        unsigned char *data1;
-#ifdef NOTMOS7840
-        Data = 0x00;
-        status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
-        mos7840_port->shadowLCR = Data;
-        dev_dbg(&port->dev, "%s: LINE_CONTROL_REGISTER is %x\n", __func__, Data);
-        dev_dbg(&port->dev, "%s: mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
-        /* Data = 0x03; */
-        /* status = mos7840_set_uart_reg(port,LINE_CONTROL_REGISTER,Data); */
-        /* mos7840_port->shadowLCR=Data;//Need to add later */
-        Data |= SERIAL_LCR_DLAB;        /* data latch enable in LCR 0x80 */
-        status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
-        /* Data = 0x0c; */
-        /* status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); */
-        Data = 0x00;
-        status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data);
-        dev_dbg(&port->dev, "%s: DLL value is %x\n", __func__, Data);
-        Data = 0x0;
-        status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data);
-        dev_dbg(&port->dev, "%s: DLM value is %x\n", __func__, Data);
-        Data = Data & ~SERIAL_LCR_DLAB;
-        dev_dbg(&port->dev, "%s: mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
-        status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
-#endif
        if (mos7840_port_paranoia_check(port, __func__))
                return -1;
@@ -1614,37 +1585,6 @@ static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
                *clk_sel_val = 0x70;
        }
        return 0;
-#ifdef NOTMCS7840
-        for (i = 0; i < ARRAY_SIZE(mos7840_divisor_table); i++) {
-                if (mos7840_divisor_table[i].BaudRate == baudrate) {
-                        *divisor = mos7840_divisor_table[i].Divisor;
-                        return 0;
-                }
-        }
-        /* After trying for all the standard baud rates    *
-         * Try calculating the divisor for this baud rate  */
-        if (baudrate > 75 && baudrate < 230400) {
-                /* get the divisor */
-                custom = (__u16) (230400L / baudrate);
-                /* Check for round off */
-                round1 = (__u16) (2304000L / baudrate);
-                round = (__u16) (round1 - (custom * 10));
-                if (round > 4)
-                        custom++;
-                *divisor = custom;
-                dev_dbg(&port->dev, " Baud %d = %d\n", baudrate, custom);
-                return 0;
-        }
-        dev_dbg(&port->dev, "%s", " Baud calculation Failed...\n");
-        return -1;
-#endif
 }
 /*****************************************************************************
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index efdcee15b520..f0c0c53359ad 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -507,18 +507,10 @@ static void option_instat_callback(struct urb *urb);
 #define VIATELECOM_VENDOR_ID                    0x15eb
 #define VIATELECOM_PRODUCT_CDS7                 0x0001
-/* some devices interfaces need special handling due to a number of reasons */
-enum option_blacklist_reason {
-                OPTION_BLACKLIST_NONE = 0,
-                OPTION_BLACKLIST_SENDSETUP = 1,
-                OPTION_BLACKLIST_RESERVED_IF = 2
-};
-#define MAX_BL_NUM  11
 struct option_blacklist_info {
-        /* bitfield of interface numbers for OPTION_BLACKLIST_SENDSETUP */
+        /* bitmask of interface numbers blacklisted for send_setup */
        const unsigned long sendsetup;
-        /* bitfield of interface numbers for OPTION_BLACKLIST_RESERVED_IF */
+        /* bitmask of interface numbers that are reserved */
        const unsigned long reserved;
 };
@@ -1822,36 +1814,13 @@ struct option_private {
 module_usb_serial_driver(serial_drivers, option_ids);
-static bool is_blacklisted(const u8 ifnum, enum option_blacklist_reason reason,
-                           const struct option_blacklist_info *blacklist)
-{
-        unsigned long num;
-        const unsigned long *intf_list;
-        if (blacklist) {
-                if (reason == OPTION_BLACKLIST_SENDSETUP)
-                        intf_list = &blacklist->sendsetup;
-                else if (reason == OPTION_BLACKLIST_RESERVED_IF)
-                        intf_list = &blacklist->reserved;
-                else {
-                        BUG_ON(reason);
-                        return false;
-                }
-                for_each_set_bit(num, intf_list, MAX_BL_NUM + 1) {
-                        if (num == ifnum)
-                                return true;
-                }
-        }
-        return false;
-}
 static int option_probe(struct usb_serial *serial,
                        const struct usb_device_id *id)
 {
        struct usb_interface_descriptor *iface_desc =
                                &serial->interface->cur_altsetting->desc;
        struct usb_device_descriptor *dev_desc = &serial->dev->descriptor;
+        const struct option_blacklist_info *blacklist;
        /* Never bind to the CD-Rom emulation interface */
        if (iface_desc->bInterfaceClass == 0x08)
@@ -1862,10 +1831,9 @@ static int option_probe(struct usb_serial *serial,
         * the same class/subclass/protocol as the serial interfaces.  Look at
         * the Windows driver .INF files for reserved interface numbers.
         */
-        if (is_blacklisted(
+        blacklist = (void *)id->driver_info;
-                iface_desc->bInterfaceNumber,
+        if (blacklist && test_bit(iface_desc->bInterfaceNumber,
-                OPTION_BLACKLIST_RESERVED_IF,
+                                                &blacklist->reserved))
-                (const struct option_blacklist_info *) id->driver_info))
                return -ENODEV;
        /*
         * Don't bind network interface on Samsung GT-B3730, it is handled by
@@ -1876,8 +1844,8 @@ static int option_probe(struct usb_serial *serial,
            iface_desc->bInterfaceClass != USB_CLASS_CDC_DATA)
                return -ENODEV;
-        /* Store device id so we can use it during attach. */
+        /* Store the blacklist info so we can use it during attach. */
-        usb_set_serial_data(serial, (void *)id);
+        usb_set_serial_data(serial, (void *)blacklist);
        return 0;
 }
@@ -1885,7 +1853,7 @@ static int option_probe(struct usb_serial *serial,
 static int option_attach(struct usb_serial *serial)
 {
        struct usb_interface_descriptor *iface_desc;
-        const struct usb_device_id *id;
+        const struct option_blacklist_info *blacklist;
        struct usb_wwan_intf_private *data;
        struct option_private *priv;
@@ -1899,16 +1867,16 @@ static int option_attach(struct usb_serial *serial)
                return -ENOMEM;
        }
-        /* Retrieve device id stored at probe. */
+        /* Retrieve blacklist info stored at probe. */
-        id = usb_get_serial_data(serial);
+        blacklist = usb_get_serial_data(serial);
        iface_desc = &serial->interface->cur_altsetting->desc;
        priv->bInterfaceNumber = iface_desc->bInterfaceNumber;
        data->private = priv;
-        if (!is_blacklisted(iface_desc->bInterfaceNumber,
+        if (!blacklist || !test_bit(iface_desc->bInterfaceNumber,
-                        OPTION_BLACKLIST_SENDSETUP,
+                                                &blacklist->sendsetup)) {
-                        (struct option_blacklist_info *)id->driver_info)) {
                data->send_setup = option_send_setup;
        }
        spin_lock_init(&data->susp_lock);
diff --git a/drivers/usb/usbip/vhci_hcd.c b/drivers/usb/usbip/vhci_hcd.c
index 1ae9d40f96bf..11f6f61c2381 100644
--- a/drivers/usb/usbip/vhci_hcd.c
+++ b/drivers/usb/usbip/vhci_hcd.c
@@ -218,7 +218,8 @@ static inline void hub_descriptor(struct usb_hub_descriptor *desc)
        memset(desc, 0, sizeof(*desc));
        desc->bDescriptorType = 0x29;
        desc->bDescLength = 9;
-        desc->wHubCharacteristics = (__constant_cpu_to_le16(0x0001));
+        desc->wHubCharacteristics = __constant_cpu_to_le16(
+                HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM);
        desc->bNbrPorts = VHCI_NPORTS;
        desc->u.hs.DeviceRemovable[0] = 0xff;
        desc->u.hs.DeviceRemovable[1] = 0xff;
diff --git a/drivers/usb/wusbcore/rh.c b/drivers/usb/wusbcore/rh.c
index fe8bc777ab88..aa5af817f31c 100644
--- a/drivers/usb/wusbcore/rh.c
+++ b/drivers/usb/wusbcore/rh.c
@@ -185,9 +185,9 @@ static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
        descr->bDescriptorType = 0x29;  /* HUB type */
        descr->bNbrPorts = wusbhc->ports_max;
        descr->wHubCharacteristics = cpu_to_le16(
-                0x00                    /* All ports power at once */
+                HUB_CHAR_COMMON_LPSM    /* All ports power at once */
                | 0x00                  /* not part of compound device */
-                | 0x10                  /* No overcurrent protection */
+                | HUB_CHAR_NO_OCPM      /* No overcurrent protection */
                | 0x00                  /* 8 FS think time FIXME ?? */
                | 0x00);                /* No port indicators */
        descr->bPwrOn2PwrGood = 0;
diff --git a/drivers/uwb/lc-dev.c b/drivers/uwb/lc-dev.c
index 8c7cfab5cee3..72033589db19 100644
--- a/drivers/uwb/lc-dev.c
+++ b/drivers/uwb/lc-dev.c
@@ -43,13 +43,6 @@ static inline void uwb_mac_addr_init(struct uwb_mac_addr *addr)
        memset(&addr->data, 0xff, sizeof(addr->data));
 }
-/* @returns !0 if a device @addr is a broadcast address */
-static inline int uwb_dev_addr_bcast(const struct uwb_dev_addr *addr)
-{
-        static const struct uwb_dev_addr bcast = { .data = { 0xff, 0xff } };
-        return !uwb_dev_addr_cmp(addr, &bcast);
-}
 /*
 * Add callback @new to be called when an event occurs in @rc.
 */
diff --git a/include/linux/mfd/syscon/exynos4-pmu.h b/include/linux/mfd/syscon/exynos4-pmu.h
new file mode 100644
index 000000000000..278b1b1549e9
--- /dev/null
+++ b/include/linux/mfd/syscon/exynos4-pmu.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2015 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_EXYNOS4_H_
+#define _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_
+/* Exynos4 PMU register definitions */
+/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
+#define EXYNOS4_MIPI_PHY_CONTROL(n)     (0x710 + (n) * 4)
+#define EXYNOS4_MIPI_PHY_ENABLE         (1 << 0)
+#define EXYNOS4_MIPI_PHY_SRESETN        (1 << 1)
+#define EXYNOS4_MIPI_PHY_MRESETN        (1 << 2)
+#define EXYNOS4_MIPI_PHY_RESET_MASK     (3 << 1)
+#endif /* _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_ */
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 745def862580..470a240f66a1 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -53,9 +53,9 @@ struct ieee1394_device_id {
 /**
 * struct usb_device_id - identifies USB devices for probing and hotplugging
- * @match_flags: Bit mask controlling of the other fields are used to match
+ * @match_flags: Bit mask controlling which of the other fields are used to
- *      against new devices.  Any field except for driver_info may be used,
+ *      match against new devices. Any field except for driver_info may be
- *      although some only make sense in conjunction with other fields.
+ *      used, although some only make sense in conjunction with other fields.
 *      This is usually set by a USB_DEVICE_*() macro, which sets all
 *      other fields in this structure except for driver_info.
 * @idVendor: USB vendor ID for a device; numbers are assigned
diff --git a/include/linux/usb.h b/include/linux/usb.h
index f89c24a03bd9..7ee1b5c3b4cb 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -82,7 +82,7 @@ struct usb_host_interface {
        int extralen;
        unsigned char *extra;   /* Extra descriptors */
-        /* array of desc.bNumEndpoint endpoints associated with this
+        /* array of desc.bNumEndpoints endpoints associated with this
         * interface setting.  these will be in no particular order.
         */
        struct usb_host_endpoint *endpoint;
@@ -127,10 +127,6 @@ enum usb_interface_condition {
 *      to the sysfs representation for that device.
 * @pm_usage_cnt: PM usage counter for this interface
 * @reset_ws: Used for scheduling resets from atomic context.
- * @reset_running: set to 1 if the interface is currently running a
- *      queued reset so that usb_cancel_queued_reset() doesn't try to
- *      remove from the workqueue when running inside the worker
- *      thread. See __usb_queue_reset_device().
 * @resetting_device: USB core reset the device, so use alt setting 0 as
 *      current; needs bandwidth alloc after reset.
 *
@@ -181,7 +177,6 @@ struct usb_interface {
        unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
        unsigned needs_altsetting0:1;   /* switch to altsetting 0 is pending */
        unsigned needs_binding:1;       /* needs delayed unbind/rebind */
-        unsigned reset_running:1;
        unsigned resetting_device:1;    /* true: bandwidth alloc after reset */
        struct device dev;              /* interface specific device info */
diff --git a/include/linux/usb/ehci_pdriver.h b/include/linux/usb/ehci_pdriver.h
index 7eb4dcd0d386..db0431b39a63 100644
--- a/include/linux/usb/ehci_pdriver.h
+++ b/include/linux/usb/ehci_pdriver.h
@@ -34,6 +34,8 @@ struct usb_hcd;
 *                      after initialization.
 * @no_io_watchdog:     set to 1 if the controller does not need the I/O
 *                      watchdog to run.
+ * @reset_on_resume:    set to 1 if the controller needs to be reset after
+ *                      a suspend / resume cycle (but can't detect that itself).
 *
 * These are general configuration options for the EHCI controller. All of
 * these options are activating more or less workarounds for some hardware.
@@ -45,6 +47,8 @@ struct usb_ehci_pdata {
        unsigned        big_endian_desc:1;
        unsigned        big_endian_mmio:1;
        unsigned        no_io_watchdog:1;
+        unsigned        reset_on_resume:1;
+        unsigned        dma_mask_64:1;
        /* Turn on all power and clocks */
        int (*power_on)(struct platform_device *pdev);
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 086bf13307e6..68b1e836dff1 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -146,6 +146,8 @@ struct usb_hcd {
        unsigned                amd_resume_bug:1; /* AMD remote wakeup quirk */
        unsigned                can_do_streams:1; /* HC supports streams */
        unsigned                tpl_support:1; /* OTG & EH TPL support */
+        unsigned                cant_recv_wakeups:1;
+                        /* wakeup requests from downstream aren't received */
        unsigned int            irq;            /* irq allocated */
        void __iomem            *regs;          /* device memory/io */
@@ -453,6 +455,7 @@ extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
 #endif /* CONFIG_PCI */
 /* pci-ish (pdev null is ok) buffer alloc/mapping support */
+void usb_init_pool_max(void);
 int hcd_buffer_create(struct usb_hcd *hcd);
 void hcd_buffer_destroy(struct usb_hcd *hcd);
diff --git a/include/uapi/linux/usbdevice_fs.h b/include/uapi/linux/usbdevice_fs.h
index abe5f4bd4d82..019ba1e0799a 100644
--- a/include/uapi/linux/usbdevice_fs.h
+++ b/include/uapi/linux/usbdevice_fs.h
@@ -128,11 +128,12 @@ struct usbdevfs_hub_portinfo {
        char port [127];        /* e.g. port 3 connects to device 27 */
 };
-/* Device capability flags */
+/* System and bus capability flags */
 #define USBDEVFS_CAP_ZERO_PACKET                0x01
 #define USBDEVFS_CAP_BULK_CONTINUATION          0x02
 #define USBDEVFS_CAP_NO_PACKET_SIZE_LIM         0x04
 #define USBDEVFS_CAP_BULK_SCATTER_GATHER        0x08
+#define USBDEVFS_CAP_REAP_AFTER_DISCONNECT      0x10
 /* USBDEVFS_DISCONNECT_CLAIM flags & struct */